def create( pulp_ctx: PulpContext, distribution_ctx: PulpContainerDistributionContext, name: str, base_path: str, repository: Optional[str], version: Optional[int], repository_type: Optional[str], ) -> None: repository_ctx: PulpRepositoryContext body = {"name": name, "base_path": base_path} if repository: if repository_type == "container": repository_ctx = PulpContainerRepositoryContext(pulp_ctx) elif repository_type == "push": repository_ctx = PulpContainerPushRepositoryContext(pulp_ctx) else: raise NotImplementedError() repository_href = repository_ctx.find(name=repository)["pulp_href"] if version is not None: body["repository_version"] = f"{repository_href}versions/{version}/" else: body["repository"] = repository_href result = distribution_ctx.create(body=body) distribution = distribution_ctx.show(result["created_resources"][0]) pulp_ctx.output_result(distribution)
def create( pulp_ctx: PulpContext, remote_ctx: PulpEntityContext, name: str, url: str, requirements_file: Any, requirements: Optional[str], auth_url: Optional[str], token: Optional[str], **remote_options: Dict[str, Any], ) -> None: """ Creates a Collection or Role remote based on -t parameter e.g. pulp ansible remote -t role create ... """ body: EntityDefinition = {"name": name, "url": url} body.update( check_collection_options( remote_ctx=remote_ctx, requirements_file=requirements_file, requirements=requirements, auth_url=auth_url, token=token, )) if remote_options: removed_nulls = { k: v for k, v in remote_options.items() if v is not None } body.update(removed_nulls) result = remote_ctx.create(body=body) pulp_ctx.output_result(result)
def repair( pulp_ctx: PulpContext, repository_version_ctx: PulpRepositoryVersionContext, ) -> None: href = repository_version_ctx.pulp_href result = repository_version_ctx.repair(href) pulp_ctx.output_result(result)
def list(pulp_ctx: PulpContext, export_ctx: PulpExportContext, exporter: str, limit: int, offset: int, **kwargs: Any) -> None: params = {k: v for k, v in kwargs.items() if v is not None} exporter_ctx = PulpExporterContext(pulp_ctx) export_ctx.exporter = exporter_ctx.find(name=exporter) result = export_ctx.list(limit=limit, offset=offset, parameters=params) pulp_ctx.output_result(result)
def run( pulp_ctx: PulpContext, export_ctx: PulpExportContext, exporter: str, full: bool, chunk_size: str, versions: List[RepositoryVersionDefinition], start_versions: List[RepositoryVersionDefinition], ) -> None: exporter_ctx = PulpExporterContext(pulp_ctx) export_ctx.exporter = exporter_ctx.find(name=exporter) body: Dict[str, Any] = dict(full=full) if chunk_size: body["chunk_size"] = chunk_size vers_list = [] for v in versions: vers_list.append(export_ctx.find_repository_version(v)["pulp_href"]) if vers_list: body["versions"] = vers_list start_vers_list = [] for v in start_versions: start_vers_list.append( export_ctx.find_repository_version(v)["pulp_href"]) if start_vers_list: body["start_versions"] = start_vers_list result = export_ctx.create(body=body) pulp_ctx.output_result(result)
def status(pulp_ctx: PulpContext, retries: int, retry_delay: int) -> None: """ Retrieve pulp status. And refresh outdated local api caches if server versions changed. """ if retries < 0: raise click.ClickException(_("Cannot specify a negative retry count.")) retries_left = retries while True: try: result = pulp_ctx.call("status_read") except click.ClickException: if retries_left: retries_left = retries_left - 1 click.echo(".", nl=False, err=True) time.sleep(retry_delay) else: if retries: click.echo(" Failed.", err=True) raise else: if retries: click.echo(" Ready.", err=True) break component_versions = { item["component"]: item["version"] for item in result.get("versions", []) } if component_versions != pulp_ctx.component_versions: click.echo("Notice: Cached api is outdated. Refreshing...", err=True) pulp_ctx.api.load_api(refresh_cache=True) result = pulp_ctx.call("status_read") pulp_ctx.output_result(result)
def call( pulp_ctx: PulpContext, operation_id: str, parameters: Iterable[str], body: Any, uploads: Iterable[IO[bytes]], ) -> None: """ Make a REST call by operation-id. WARNING: Danger ahead! """ try: params: Dict[str, str] = dict( parameter.partition("=")[::2] for parameter in parameters) except ValueError: raise click.ClickException( "Parameters must be in the form <key>=<value>.") uploads_dict: Dict[str, bytes] = {file.name: file.read() for file in uploads} result = pulp_ctx.call(operation_id, parameters=params, body=body, uploads=uploads_dict) pulp_ctx.output_result(result)
def list_entities(pulp_ctx: PulpContext, entity_ctx: PulpEntityContext, limit: int, offset: int, **kwargs: Any) -> None: """ Show a list of entries """ parameters = {k: v for k, v in kwargs.items() if v is not None} result = entity_ctx.list(limit=limit, offset=offset, parameters=parameters) pulp_ctx.output_result(result)
def has_plugin(pulp_ctx: PulpContext, name: str, min_version: str, max_version: str) -> None: """ Check whether a specific plugin is installed on the server. """ available = pulp_ctx.has_plugin(name, min_version, max_version) pulp_ctx.output_result(available) sys.exit(0 if available else 1)
def show(pulp_ctx: PulpContext, task_ctx: PulpTaskContext, href: str, wait: bool) -> None: """Shows details of a task.""" entity = task_ctx.show(href) if wait and entity["state"] in ["waiting", "running"]: click.echo(f"Waiting for task {href} to finish.", err=True) entity = pulp_ctx.wait_for_task(entity) pulp_ctx.output_result(entity)
def repository(ctx: click.Context, pulp_ctx: PulpContext) -> None: """ Perform actions on all repositories. Please look for the plugin specific repository commands for more detailed actions. i.e. 'pulp file repository <...>' """ pulp_ctx.needs_plugin("pulpcore", min_version="3.10.dev") ctx.obj = PulpRepositoryContext(pulp_ctx)
def show(pulp_ctx: PulpContext, task_ctx: PulpTaskContext, wait: bool) -> None: """Shows details of a task.""" entity = task_ctx.entity if wait and entity["state"] in ["waiting", "running", "canceling"]: click.echo(_("Waiting for task {href} to finish.").format( href=task_ctx.pulp_href), err=True) entity = pulp_ctx.wait_for_task(entity) pulp_ctx.output_result(entity)
def assign( pulp_ctx: PulpContext, guard_ctx: PulpRbacContentGuardContext, users: Optional[List[str]], groups: Optional[List[str]], ) -> None: href = guard_ctx.entity["pulp_href"] result = guard_ctx.assign(href=href, users=users, groups=groups) pulp_ctx.output_result(result)
def content(ctx: click.Context, pulp_ctx: PulpContext) -> None: """ Perform actions on all content units. Please look for the plugin specific content commands for more detailed actions. i.e. 'pulp file content <...>' """ pulp_ctx.needs_plugin("core", min_version="3.10") ctx.obj = PulpContentContext(pulp_ctx)
def callback( pulp_ctx: PulpContext, entity_ctx: PulpEntityContext, limit: int, offset: int, **kwargs: Any ) -> None: """ Show the list of optionally filtered {entities}. """ parameters = {k: v for k, v in kwargs.items() if v is not None} result = entity_ctx.list(limit=limit, offset=offset, parameters=parameters) pulp_ctx.output_result(result)
def role_remove( pulp_ctx: PulpContext, entity_ctx: PulpEntityContext, role: str, users: List[str], groups: List[str], ) -> None: result = entity_ctx.remove_role(role, users, groups) pulp_ctx.output_result(result)
def upload( pulp_ctx: PulpContext, artifact_ctx: PulpArtifactContext, file: IO[bytes], chunk_size: int, ) -> None: artifact_href = artifact_ctx.upload(file, chunk_size) result = artifact_ctx.show(artifact_href) pulp_ctx.output_result(result)
def create( pulp_ctx: PulpContext, remote_ctx: PulpContainerRemoteContext, name: str, upstream_name: str, url: str, ) -> None: remote = {"name": name, "upstream_name": upstream_name, "url": url} result = remote_ctx.create(body=remote) pulp_ctx.output_result(result)
def purge( pulp_ctx: PulpContext, task_ctx: PulpTaskContext, finished: Optional[datetime], state: Optional[Tuple[str]], ) -> None: pulp_ctx.needs_plugin(PluginRequirement("core", "3.17.0.dev")) state_list = list(state) if state else None finished_str = finished.strftime(DATETIME_FORMATS[1]) if finished else None task_ctx.purge(finished_str, state_list)
def callback(pulp_ctx: PulpContext, entity_ctx: PulpEntityContext, **kwargs: Any) -> None: """ Create a {entity}. """ body: EntityDefinition = entity_ctx.preprocess_body(kwargs) result = entity_ctx.create(body=body) if "created_resources" in result: entity_ctx.pulp_href = result["created_resources"][0] result = entity_ctx.entity pulp_ctx.output_result(result)
def repair_version( pulp_ctx: PulpContext, repository_ctx: PulpRepositoryContext, repository_version_ctx: PulpRepositoryVersionContext, version: int, ) -> None: repo_href = repository_ctx.pulp_href href = f"{repo_href}versions/{version}/" result = repository_version_ctx.repair(href) pulp_ctx.output_result(result)
def cleanup(pulp_ctx: PulpContext, **kwargs: Any) -> None: """ Cleanup orphaned content. """ body = {k: v for k, v in kwargs.items() if v is not None} if pulp_ctx.has_plugin(PluginRequirement("core", "3.14")): result = pulp_ctx.call("orphans_cleanup_cleanup", body=body) else: result = pulp_ctx.call("orphans_delete") pulp_ctx.output_result(result)
def update( pulp_ctx: PulpContext, distribution_ctx: PulpAnsibleDistributionContext, name: str, base_path: Optional[str], repository: Optional[str], version: Optional[int], ) -> None: """ To remove repository or repository_version fields set --repository to "" """ dist_body: EntityDefinition = distribution_ctx.find(name=name) href: str = dist_body["pulp_href"] body: EntityDefinition = dict() if base_path: body["base_path"] = base_path if repository is not None: if repository == "": # unset repository or repository version if dist_body["repository"]: body["repository"] = "" elif dist_body["repository_version"]: body["repository_version"] = "" else: repo = PulpAnsibleRepositoryContext(pulp_ctx).find(name=repository) if version is not None: if dist_body["repository"]: distribution_ctx.update(href, body={"repository": ""}) body[ "repository_version"] = f'{repo["versions_href"]}{version}/' else: if dist_body["repository_version"]: distribution_ctx.update(href, body={"repository_version": ""}) body["repository"] = repo["pulp_href"] elif version is not None: # keep current repository, change version if dist_body["repository"]: distribution_ctx.update(href, body={"repository": ""}) body[ "repository_version"] = f'{dist_body["repository"]}versions/{version}/' elif dist_body["repository_version"]: repository_href, _, _ = dist_body["repository_version"].partition( "versions") body[ "repository_version"] = f"{repository_href}versions/{version}/" else: raise click.ClickException( f"Distribution {name} doesn't have a repository set, " f"please specify the repository to use with --repository") distribution_ctx.update(href, body=body) dist_body = distribution_ctx.show(href) pulp_ctx.output_result(dist_body)
def upload( pulp_ctx: PulpContext, entity_ctx: PulpPythonContentContext, relative_path: str, file: IO[bytes], chunk_size: int, ) -> None: """Create a Python package content unit through uploading a file""" artifact_href = PulpArtifactContext(pulp_ctx).upload(file, chunk_size) content = {"relative_path": relative_path, "artifact": artifact_href} result = entity_ctx.create(body=content) pulp_ctx.output_result(result)
def create( pulp_ctx: PulpContext, distribution_ctx: PulpFileDistributionContext, name: str, base_path: str, publication: Optional[str], ) -> None: body = {"name": name, "base_path": base_path} if publication: body["publication"] = publication result = distribution_ctx.create(body=body) distribution = distribution_ctx.show(result["created_resources"][0]) pulp_ctx.output_result(distribution)
def create( pulp_ctx: PulpContext, importer_ctx: PulpImporterContext, name: str, repo_map: List[RepositoryMap], ) -> None: params: Dict[str, Union[str, Dict[str, str]]] = {"name": name} if repo_map: params["repo_mapping"] = {source: dest for source, dest in repo_map} result = importer_ctx.create(body=params) pulp_ctx.output_result(result)
def upload( pulp_ctx: PulpContext, entity_ctx: PulpFileContentContext, relative_path: str, file: IO[bytes], chunk_size: int, ) -> None: """Create a file content unit by uploading a file""" artifact_href = PulpArtifactContext(pulp_ctx).upload(file, chunk_size) content = {"relative_path": relative_path, "artifact": artifact_href} task = entity_ctx.create(body=content) result = entity_ctx.show(task["created_resources"][0]) pulp_ctx.output_result(result)
def status(pulp_ctx: PulpContext) -> None: """ Retrieve pulp status. And refresh outdated local api caches if server versions changed. """ result = pulp_ctx.call("status_read") component_versions = { item["component"]: item["version"] for item in result.get("versions", []) } if component_versions != pulp_ctx.component_versions: click.echo("Notice: Cached api is outdated. Refreshing...", err=True) pulp_ctx.api.load_api(refresh_cache=True) result = pulp_ctx.call("status_read") pulp_ctx.output_result(result)
def comps_upload( pulp_ctx: PulpContext, file: IO[bytes], repository: Optional[EntityFieldDefinition], replace: Optional[bool], ) -> None: """Create comps.xml content-units by uploading a comps.xml-formatted file""" pulp_ctx.needs_plugin(PluginRequirement("rpm", min="3.17.0dev")) entity_ctx = PulpRpmCompsXmlContext(pulp_ctx) href = None if isinstance(repository, PulpEntityContext): href = repository.pulp_href result = entity_ctx.upload_comps(file, href, replace) pulp_ctx.output_result(result)
def content_list( pulp_ctx: PulpContext, version: PulpRepositoryVersionContext, offset: Optional[int], limit: Optional[int], type: Optional[str], **params: Any, ) -> None: parameters = {k: v for k, v in params.items() if v is not None} parameters.update({"repository_version": version.pulp_href}) result = content_contexts[type](pulp_ctx).list(limit=limit, offset=offset, parameters=parameters) pulp_ctx.output_result(result)