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)
