def publish(repository_version_pk):
"""
Create a Publication based on a RepositoryVersion.
Args:
repository_version_pk (str): Create a publication from this repository version.
"""
repository_version = RepositoryVersion.objects.get(
pk=repository_version_pk)
log.info(
_("Publishing: repository=%(repository)s, version=%(version)d"),
{
"repository": repository_version.repository.name,
"version": repository_version.number
},
)
with WorkingDirectory():
with CookbookPublication.create(repository_version) as publication:
check_repo_version_constraint(publication)
universe = Universe("__universe__")
universe.write(populate(publication))
metadata = PublishedMetadata(
relative_path=os.path.basename(universe.relative_path),
publication=publication,
file=File(open(universe.relative_path, "rb")),
)
metadata.save()
log.info(_("Publication: %(publication)s created"),
{"publication": publication.pk})
def publish(repository_version_pk):
"""
Create a Publication based on a RepositoryVersion.
Args:
repository_version_pk (str): Create a publication from this repository version.
"""
repository_version = RepositoryVersion.objects.get(
pk=repository_version_pk)
log.info(
_("Publishing: repository=%(repository)s, version=%(version)d"),
{
"repository": repository_version.repository.name,
"version": repository_version.number
},
)
with WorkingDirectory():
with ProgressReport(message="Publishing Content",
code="publishing.content") as progress_report:
with CookbookPublication.create(repository_version) as publication:
universe = Universe("__universe__")
universe.write(
populate(publication, progress_report=progress_report))
PublishedMetadata.create_from_file(
relative_path=os.path.basename(universe.relative_path),
publication=publication,
file=File(open(universe.relative_path, "rb")),
)
log.info(_("Publication: %(publication)s created"),
{"publication": publication.pk})
def publish_verbatim(publisher_pk, repository_version_pk):
"""
Use provided publisher to create a verbatim Publication based on a RepositoryVersion.
Args:
publisher_pk (str): Use the publish settings provided by this publisher.
repository_version_pk (str): Create a publication from this repository version.
"""
publisher = DebVerbatimPublisher.objects.get(pk=publisher_pk)
repository_version = RepositoryVersion.objects.get(
pk=repository_version_pk)
log.info(
_('Publishing (verbatim): repository={repo}, version={ver}, publisher={pub}'
).format(
repo=repository_version.repository.name,
ver=repository_version.number,
pub=publisher.name,
))
with WorkingDirectory():
with Publication.create(repository_version,
publisher,
pass_through=True) as publication:
pass
log.info(
_('Publication (verbatim): {publication} created').format(
publication=publication.pk))
def sync(importer_pk, repository_pk):
"""
Validate the importer, create and finalize RepositoryVersion.
Args:
importer_pk (str): The importer PK.
repository_pk (str): The repository to sync into.
Raises:
ValueError: When feed_url is empty.
"""
importer = GemImporter.objects.get(pk=importer_pk)
repository = Repository.objects.get(pk=repository_pk)
if not importer.feed_url:
raise ValueError(
_("An importer must have a 'feed_url' attribute to sync."))
base_version = RepositoryVersion.latest(repository)
with RepositoryVersion.create(repository) as new_version:
synchronizer = Synchronizer(importer, new_version, base_version)
with WorkingDirectory():
log.info(
_('Starting sync: repository=%(repository)s importer=%(importer)s'
), {
'repository': repository.name,
'importer': importer.name
})
synchronizer.run()
def publish(manifest, repository_version_pk):
"""
Create a Publication based on a RepositoryVersion.
Args:
manifest (str): Filename to use for manifest file.
repository_version_pk (str): Create a publication from this repository version.
"""
repo_version = RepositoryVersion.objects.get(pk=repository_version_pk)
log.info(
_("Publishing: repository={repo}, version={ver}, manifest={manifest}").
format(repo=repo_version.repository.name,
ver=repo_version.number,
manifest=manifest))
with WorkingDirectory():
with FilePublication.create(repo_version,
pass_through=True) as publication:
manifest = Manifest(manifest)
manifest.write(populate(publication))
PublishedMetadata.create_from_file(file=File(
open(manifest.relative_path, "rb")),
publication=publication)
log.info(
_("Publication: {publication} created").format(
publication=publication.pk))
def publish(publisher_pk, repository_version_pk):
"""
Use provided publisher to create a Publication based on a RepositoryVersion.
Args:
publisher_pk (str): Use the publish settings provided by this publisher.
repository_version_pk (str): Create a publication from this repository version.
"""
publisher = FilePublisher.objects.get(pk=publisher_pk)
repository_version = RepositoryVersion.objects.get(pk=repository_version_pk)
log.info(_('Publishing: repository={repo}, version={ver}, publisher={pub}').format(
repo=repository_version.repository.name,
ver=repository_version.number,
pub=publisher.name,
))
with WorkingDirectory():
with Publication.create(repository_version, publisher, pass_through=True) as publication:
manifest = Manifest(publisher.manifest)
manifest.write(populate(publication))
metadata = PublishedMetadata(
relative_path=os.path.basename(manifest.relative_path),
publication=publication,
file=File(open(manifest.relative_path, 'rb')))
metadata.save()
log.info(_('Publication: {publication} created').format(publication=publication.pk))
def publish(publisher_pk, repository_version_pk):
"""
Create a Publication based on a RepositoryVersion.
Args:
publisher_pk (str): Use the publish settings provided by this publisher.
repository_version_pk (str): Create a Publication from this RepositoryVersion.
"""
publisher = python_models.PythonPublisher.objects.get(pk=publisher_pk)
repository_version = models.RepositoryVersion.objects.get(
pk=repository_version_pk)
log.info(
_('Publishing: repository={repo}, version={version}, publisher={pub}').
format(repo=repository_version.repository.name,
version=repository_version.number,
pub=publisher.name))
with WorkingDirectory():
with models.Publication.create(repository_version,
publisher) as publication:
write_simple_api(publication)
log.info(_('Publication: {pk} created').format(pk=publication.pk))
def publish(publisher_pk, repository_version_pk):
"""
Use provided publisher to create a Publication based on a RepositoryVersion.
Args:
publisher_pk (str): Use the publish settings provided by this publisher.
repository_version_pk (str): Create a publication from this repository version.
"""
publisher = AnsiblePublisher.objects.get(pk=publisher_pk)
repository_version = RepositoryVersion.objects.get(pk=repository_version_pk)
log.info(
_('Publishing: repository=%(repository)s, version=%(version)d, publisher=%(publisher)s'),
{
'repository': repository_version.repository.name,
'version': repository_version.number,
'publisher': publisher.name,
})
with WorkingDirectory():
with Publication.create(repository_version, publisher) as publication:
populate(publication)
log.info(
_('Publication: %(publication)s created'),
{
'publication': publication.pk
})
def synchronize(remote_pk, repository_pk):
"""
Create a new version of the repository that is synchronized with the remote
as specified by the remote.
Args:
remote_pk (str): The remote PK.
repository_pk (str): The repository PK.
Raises:
ValueError: When url is empty.
"""
remote = PuppetRemote.objects.get(pk=remote_pk)
repository = Repository.objects.get(pk=repository_pk)
base_version = RepositoryVersion.latest(repository)
if not remote.url:
raise ValueError(
_('An remote must have a url specified to synchronize.'))
with WorkingDirectory():
with RepositoryVersion.create(repository) as new_version:
log.info(_('Synchronizing: repository=%(r)s remote=%(p)s'), {
'r': repository.name,
'p': remote.name
})
def publish(publisher_pk, repository_version_pk):
"""
Use provided publisher to create a Publication based on a RepositoryVersion.
Args:
publisher_pk (str): Use the publish settings provided by this publisher.
repository_version_pk (str): Create a publication from this repository version.
"""
publisher = FilePublisher.objects.get(pk=publisher_pk)
repository_version = RepositoryVersion.objects.get(pk=repository_version_pk)
log.info(
_('Publishing: repository=%(repository)s, version=%(version)d, publisher=%(publisher)s'),
{
'repository': repository_version.repository.name,
'version': repository_version.number,
'publisher': publisher.name,
})
with WorkingDirectory():
with Publication.create(repository_version, publisher) as publication:
manifest = Manifest('PULP_MANIFEST')
manifest.write(populate(publication))
metadata = PublishedMetadata(
relative_path=os.path.basename(manifest.relative_path),
publication=publication,
file=File(open(manifest.relative_path, 'rb')))
metadata.save()
log.info(
_('Publication: %(publication)s created'),
{
'publication': publication.pk
})
def publish(repository_version_pk):
"""
Create a Publication based on a RepositoryVersion.
Args:
repository_version_pk (str): Create a publication from this repository version.
"""
repository_version = RepositoryVersion.objects.get(pk=repository_version_pk)
log.info(_('Publishing: repository={repo}, version={version}').format(
repo=repository_version.repository.name,
version=repository_version.number,
))
with WorkingDirectory():
with RpmPublication.create(repository_version) as publication:
publication_data = PublicationData(publication)
publication_data.populate()
content = publication.repository_version.content
# Main repo
create_repomd_xml(content, publication, publication_data.repomdrecords)
for sub_repo in publication_data.sub_repos:
name = sub_repo[0]
content = getattr(publication_data, f"{name}_content")
extra_repomdrecords = getattr(publication_data, f"{name}_repomdrecords")
create_repomd_xml(content, publication, extra_repomdrecords, name)
def publish(repository_version_pk,
metadata_signing_service=None,
checksum_types=None):
"""
Create a Publication based on a RepositoryVersion.
Args:
repository_version_pk (str): Create a publication from this repository version.
metadata_signing_service (pulpcore.app.models.AsciiArmoredDetachedSigningService):
A reference to an associated signing service.
checksum_types (dict): Checksum types for metadata and packages.
"""
repository_version = RepositoryVersion.objects.get(
pk=repository_version_pk)
repository = repository_version.repository.cast()
checksum_types = checksum_types or {}
checksum_types["original"] = repository.original_checksum_types
original_metadata_checksum_type = repository.original_checksum_types.get(
"primary", CHECKSUM_TYPES.SHA256)
log.info(
_('Publishing: repository={repo}, version={version}').format(
repo=repository.name,
version=repository_version.number,
))
with WorkingDirectory():
with RpmPublication.create(repository_version) as publication:
publication.package_checksum_type = checksum_types.get(
"package", CHECKSUM_TYPES.SHA256)
publication.metadata_checksum_type = checksum_types.get(
"metadata", original_metadata_checksum_type)
publication_data = PublicationData(publication)
publication_data.populate()
content = publication.repository_version.content
# Main repo
create_repomd_xml(
content,
publication,
checksum_types,
publication_data.repomdrecords,
metadata_signing_service=metadata_signing_service)
for sub_repo in publication_data.sub_repos:
name = sub_repo[0]
checksum_types["original"] = getattr(publication_data,
f"{name}_checksums")
content = getattr(publication_data, f"{name}_content")
extra_repomdrecords = getattr(publication_data,
f"{name}_repomdrecords")
create_repomd_xml(
content,
publication,
checksum_types,
extra_repomdrecords,
name,
metadata_signing_service=metadata_signing_service)
async def create(self):
"""
Perform the work specified by pipeline.
"""
with WorkingDirectory(
): # TODO: Working Directory is probably not needed
stages = self.pipeline_stages()
stages.append(EndStage())
pipeline = create_pipeline(stages)
await pipeline
def build_image_from_containerfile(containerfile_pk=None,
artifacts={},
repository_pk=None,
tag=None):
"""
Builds an OCI container image from a Containerfile.
The artifacts are made available inside the build container at the paths specified by their
values. The Containerfile can make use of these files during build process.
Args:
containerfile_pk (str): The pk of an Artifact that contains the Containerfile
artifacts (dict): A dictionary where each key is an artifact PK and the value is it's
relative path (name) inside the /pulp_working_directory of the build
container executing the Containerfile.
repository_pk (str): The pk of a Repository to add the OCI container image
tag (str): Tag name for the new image in the repository
Returns:
A class:`pulpcore.plugin.models.RepositoryVersion` that contains the new OCI container
image and tag.
"""
containerfile = Artifact.objects.get(pk=containerfile_pk)
repository = ContainerRepository.objects.get(pk=repository_pk)
name = str(uuid4())
with WorkingDirectory() as working_directory:
path = "{}/".format(working_directory.path)
for key, val in artifacts.items():
artifact = Artifact.objects.get(pk=key)
dirs = os.path.split(val)[0]
if dirs:
os.makedirs(dirs)
shutil.copy(artifact.file.path, "{}{}".format(path, val))
bud_cp = subprocess.run(
["buildah", "bud", "-f", containerfile.file.path, "-t", name],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
if bud_cp.returncode != 0:
raise Exception(bud_cp.stderr)
image_dir = "{}image/".format(path)
os.makedirs(image_dir)
push_cp = subprocess.run(
["buildah", "push", "-f", "oci", name, "dir:{}".format(image_dir)],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
if push_cp.returncode != 0:
raise Exception(push_cp.stderr)
repository_version = add_image_from_directory_to_repository(
image_dir, repository, tag)
return repository_version
def publish(publisher_pk, repository_version_pk):
"""
Use provided publisher to create a Publication based on a RepositoryVersion.
Args:
publisher_pk (str): Use the publish settings provided by this publisher.
repository_version_pk (str): Create a publication from this repository version.
"""
publisher = GemPublisher.objects.get(pk=publisher_pk)
repository_version = RepositoryVersion.objects.get(
pk=repository_version_pk)
log.info(
_('Publishing: repository=%(repository)s, version=%(version)d, publisher=%(publisher)s'
), {
'repository': repository_version.repository.name,
'version': repository_version.number,
'publisher': publisher.name,
})
with WorkingDirectory():
with Publication.create(repository_version, publisher) as publication:
specs = []
latest_versions = {}
prerelease_specs = []
for content in GemContent.objects.filter(
pk__in=publication.repository_version.content).order_by(
'-created'):
for content_artifact in content.contentartifact_set.all():
published_artifact = PublishedArtifact(
relative_path=content_artifact.relative_path,
publication=publication,
content_artifact=content_artifact)
published_artifact.save()
if re.fullmatch(r"[0-9.]*", content.version):
specs.append(Key(content.name, content.version))
old_ver = latest_versions.get(content.name)
if old_ver is None or version.parse(
old_ver) < version.parse(content.version):
latest_versions[content.name] = content.version
else:
prerelease_specs.append(Key(content.name, content.version))
latest_specs = [
Key(name, version)
for name, version in latest_versions.items()
]
_publish_specs(specs, 'specs.4.8', publication)
_publish_specs(latest_specs, 'latest_specs.4.8', publication)
_publish_specs(prerelease_specs, 'prerelease_specs.4.8',
publication)
log.info(_('Publication: %(publication)s created'),
{'publication': publication.pk})
def publish(repository_version_pk):
"""
Create a Publication based on a RepositoryVersion.
Args:
repository_version_pk (str): Create a publication from this repository version.
"""
repository_version = RepositoryVersion.objects.get(
pk=repository_version_pk)
log.info(
_("Publishing: repository={repo}, version={ver}").format(
repo=repository_version.repository.name,
ver=repository_version.number))
with WorkingDirectory():
with GemPublication.create(repository_version) as publication:
specs = []
latest_versions = {}
prerelease_specs = []
for content in GemContent.objects.filter(
pk__in=publication.repository_version.content).order_by(
"-pulp_created"):
for content_artifact in content.contentartifact_set.all():
published_artifact = PublishedArtifact(
relative_path=content_artifact.relative_path,
publication=publication,
content_artifact=content_artifact,
)
published_artifact.save()
if re.fullmatch(r"[0-9.]*", content.version):
specs.append(Key(content.name, content.version))
old_ver = latest_versions.get(content.name)
if old_ver is None or version.parse(
old_ver) < version.parse(content.version):
latest_versions[content.name] = content.version
else:
prerelease_specs.append(Key(content.name, content.version))
latest_specs = [
Key(name, version)
for name, version in latest_versions.items()
]
_publish_specs(specs, "specs.4.8", publication)
_publish_specs(latest_specs, "latest_specs.4.8", publication)
_publish_specs(prerelease_specs, "prerelease_specs.4.8",
publication)
log.info(
_("Publication: {publication} created").format(
publication=publication.pk))
def create(self):
"""
Perform the work. This is the long-blocking call where all syncing occurs.
"""
with WorkingDirectory():
with RepositoryVersion.create(self.repository) as new_version:
loop = asyncio.get_event_loop()
stages = self.pipeline_stages(new_version)
stages.append(ContentUnitAssociation(new_version))
if self.mirror:
stages.append(ContentUnitUnassociation(new_version))
stages.append(EndStage())
pipeline = create_pipeline(stages)
loop.run_until_complete(pipeline)
def sync(remote_pk, repository_pk):
"""
Sync content from the remote repository.
Create a new version of the repository that is synchronized with the remote.
Args:
remote_pk (str): The remote PK.
repository_pk (str): The repository PK.
Raises:
serializers: ValidationError
"""
remote = python_models.PythonRemote.objects.get(pk=remote_pk)
repository = models.Repository.objects.get(pk=repository_pk)
if not remote.url:
raise serializers.ValidationError(
detail=_("A remote must have a url attribute to sync."))
base_version = models.RepositoryVersion.latest(repository)
with models.RepositoryVersion.create(repository) as new_version:
with WorkingDirectory():
log.info(
_('Creating RepositoryVersion: repository={repository} remote={remote}'
).format(repository=repository.name, remote=remote.name))
project_specifiers = python_models.ProjectSpecifier.objects.filter(
remote=remote).all()
inventory_keys = _fetch_inventory(base_version)
remote_metadata = _fetch_specified_metadata(
remote, project_specifiers)
remote_keys = set(
[content['filename'] for content in remote_metadata])
delta = _find_delta(inventory=inventory_keys, remote=remote_keys)
additions = _build_additions(delta, remote_metadata)
removals = _build_removals(delta, base_version)
changeset = ChangeSet(remote,
new_version,
additions=additions,
removals=removals)
changeset.apply_and_drain()
def synchronize(remote_pk, repository_pk):
"""
Sync content from the remote repository.
Create a new version of the repository that is synchronized with the remote.
Args:
remote_pk (str): The remote PK.
repository_pk (str): The repository PK.
Raises:
ValueError: When remote has no url specified.
"""
remote = AnsibleRemote.objects.get(pk=remote_pk)
repository = Repository.objects.get(pk=repository_pk)
base_version = RepositoryVersion.latest(repository)
if not remote.url:
raise ValueError(
_('A remote must have a url specified to synchronize.'))
with WorkingDirectory():
with RepositoryVersion.create(repository) as new_version:
log.info(_('Synchronizing: repository=%(r)s remote=%(p)s'), {
'r': repository.name,
'p': remote.name
})
roles = fetch_roles(remote)
content = fetch_content(base_version)
delta = find_delta(roles, content)
additions = build_additions(remote, roles, delta)
removals = build_removals(base_version, delta)
changeset = ChangeSet(remote=remote,
repository_version=new_version,
additions=additions,
removals=removals)
for report in changeset.apply():
if not log.isEnabledFor(logging.DEBUG):
continue
log.debug(
_('Applied: repository=%(r)s remote=%(p)s change:%(c)s'), {
'r': repository.name,
'p': remote.name,
'c': report,
})
def synchronize(importer_pk, repository_pk):
"""
Create a new version of the repository that is synchronized with the remote
as specified by the importer.
Args:
importer_pk (str): The importer PK.
repository_pk (str): The repository PK.
Raises:
ValueError: When feed_url is empty.
"""
importer = FileImporter.objects.get(pk=importer_pk)
repository = Repository.objects.get(pk=repository_pk)
base_version = RepositoryVersion.latest(repository)
if not importer.feed_url:
raise ValueError(
_('An importer must have a feed_url specified to synchronize.'))
with WorkingDirectory():
with RepositoryVersion.create(repository) as new_version:
log.info(_('Synchronizing: repository=%(r)s importer=%(p)s'), {
'r': repository.name,
'p': importer.name
})
manifest = fetch_manifest(importer)
content = fetch_content(base_version)
delta = find_delta(manifest, content)
additions = build_additions(importer, manifest, delta)
removals = build_removals(base_version, delta)
changeset = ChangeSet(importer=importer,
repository_version=new_version,
additions=additions,
removals=removals)
for report in changeset.apply():
if not log.isEnabledFor(logging.DEBUG):
continue
log.debug(
_('Applied: repository=%(r)s importer=%(p)s change:%(c)s'),
{
'r': repository.name,
'p': importer.name,
'c': report,
})
def is_optimized_sync(repository, remote, url):
"""
Check whether it is possible to optimize the synchronization or not.
Caution: we are not storing when the remote was last updated, so the order of this
logic must remain in this order where we first check the version number as other
changes than sync could have taken place such that the date or repo version will be
different from last sync.
Args:
repository(RpmRepository): An RpmRepository to check optimization for.
remote(RpmRemote): An RPMRemote to check optimization for.
url(str): A remote repository URL.
Returns:
bool: True, if sync is optimized; False, otherwise.
"""
with WorkingDirectory():
result = get_repomd_file(remote, url)
if not result:
return False
repomd_path = result.path
repomd = cr.Repomd(repomd_path)
repomd_checksum = get_sha256(repomd_path)
is_optimized = (
repository.last_sync_remote
and remote.pk == repository.last_sync_remote.pk and
repository.last_sync_repo_version == repository.latest_version().number
and
remote.pulp_last_updated <= repository.latest_version().pulp_created
and is_previous_version(repomd.revision,
repository.last_sync_revision_number)
and repository.last_sync_repomd_checksum == repomd_checksum)
if is_optimized:
optimize_data = dict(message="Optimizing Sync", code="optimizing.sync")
with ProgressReport(**optimize_data) as optimize_pb:
optimize_pb.done = 1
optimize_pb.save()
return is_optimized
def synchronize(remote_pk, repository_pk):
"""
Sync content from the remote repository.
Create a new version of the repository that is synchronized with the remote.
Args:
remote_pk (str): The remote PK.
repository_pk (str): The repository PK.
Raises:
ValueError: If the remote does not specify a url to sync.
"""
remote = RpmRemote.objects.get(pk=remote_pk)
repository = Repository.objects.get(pk=repository_pk)
dupe_criteria = {'model': Package,
'field_names': ['name', 'epoch', 'version', 'release', 'arch']}
if not remote.url:
raise ValueError(_('A remote must have a url specified to synchronize.'))
log.info(_('Synchronizing: repository={r} remote={p}').format(
r=repository.name, p=remote.name))
download_artifacts = (remote.policy == Remote.IMMEDIATE)
first_stage = RpmFirstStage(remote)
with WorkingDirectory():
with RepositoryVersion.create(repository) as new_version:
loop = asyncio.get_event_loop()
remove_duplicates_stage = RemoveDuplicates(new_version, **dupe_criteria)
stages = [first_stage]
if download_artifacts:
stages.extend([QueryExistingArtifacts(), ArtifactDownloader(), ArtifactSaver()])
stages.extend([
QueryExistingContents(), ErratumContentSaver(), remove_duplicates_stage,
ContentAssociation(new_version), EndStage()
])
pipeline = create_pipeline(stages)
loop.run_until_complete(pipeline)
def publish_verbatim(repository_version_pk):
"""
Create a VerbatimPublication based on a RepositoryVersion.
Args:
repository_version_pk (str): Create a publication from this repository version.
"""
repo_version = RepositoryVersion.objects.get(pk=repository_version_pk)
log.info(_('Publishing (verbatim): repository={repo}, version={ver}').format(
repo=repo_version.repository.name,
ver=repo_version.number,
))
with WorkingDirectory():
with VerbatimPublication.create(repo_version, pass_through=True) as publication:
pass
log.info(_('Publication (verbatim): {publication} created').format(publication=publication.pk))
def publish(publisher_pk, repository_version_pk):
"""
Use provided publisher to create a Publication based on a RepositoryVersion.
Args:
publisher_pk (str): Use the publish settings provided by this publisher.
repository_version_pk (str): Create a publication from this repository version.
"""
publisher = PuppetPublisher.objects.get(pk=publisher_pk)
repository_version = RepositoryVersion.objects.get(
pk=repository_version_pk)
log.info(
_('Publishing: repository=%(repository)s, version=%(version)d, publisher=%(publisher)s'
), {
'repository': repository_version.repository.name,
'version': repository_version.number,
'publisher': publisher.name,
})
with WorkingDirectory():
with Publication.create(repository_version, publisher) as publication:
# Write any Artifacts (files) to the file system and the database.
# each.
# artifact = YourArtifactWriter.write(relative_path)
# published_artifact = PublishedArtifact(
# relative_path=artifact.relative_path,
# publication=publication,
# content_artifact=artifact)
# published_artifact.save()
# Write any metadata files to the file system, and the database.
# metadata = YourMetadataWriter.write(relative_path)
# metadata = PublishedMetadata(
# relative_path=os.path.basename(manifest.relative_path),
# publication=publication,
# file=File(open(manifest.relative_path, 'rb')))
# metadata.save()
pass
log.info(_('Publication: %(publication)s created'),
{'publication': publication.pk})
def publish(repository_version_pk):
"""
Create a Publication based on a RepositoryVersion.
Args:
repository_version_pk (str): Create a Publication from this RepositoryVersion.
"""
repository_version = models.RepositoryVersion.objects.get(pk=repository_version_pk)
log.info(_('Publishing: repository={repo}, version={version}').format(
repo=repository_version.repository.name,
version=repository_version.number,
))
with WorkingDirectory():
with python_models.PythonPublication.create(repository_version) as publication:
write_simple_api(publication)
log.info(_('Publication: {pk} created').format(pk=publication.pk))
def synchronize(remote_pk, repository_pk):
"""
Sync content from the remote repository.
Create a new version of the repository that is synchronized with the remote.
Args:
remote_pk (str): The remote PK.
repository_pk (str): The repository PK.
Raises:
ValueError: If the remote does not specify a url to sync.
"""
remote = RpmRemote.objects.get(pk=remote_pk)
repository = Repository.objects.get(pk=repository_pk)
if not remote.url:
raise ValueError(
_('A remote must have a url specified to synchronize.'))
log.info(
_('Synchronizing: repository={r} remote={p}').format(r=repository.name,
p=remote.name))
first_stage = RpmFirstStage(remote)
with WorkingDirectory():
with RepositoryVersion.create(repository) as new_version:
loop = asyncio.get_event_loop()
stages = [
first_stage,
QueryExistingArtifacts(),
ArtifactDownloader(),
ArtifactSaver(),
QueryExistingContentUnits(),
ErratumContentUnitSaver(),
ContentUnitAssociation(new_version),
EndStage()
]
pipeline = create_pipeline(stages)
loop.run_until_complete(pipeline)
def publish(publisher_pk, repository_version_pk):
"""
Use provided publisher to create a Publication based on a RepositoryVersion.
Args:
publisher_pk (str): Use the publish settings provided by this publisher.
repository_version_pk (str): Create a publication from this repository version.
"""
publisher = PluginTemplatePublisher.objects.get(pk=publisher_pk)
repository_version = RepositoryVersion.objects.get(
pk=repository_version_pk)
log.info(
_('Publishing: repository={repo}, version={ver}, publisher={pub}').
format(repo=repository_version.repository.name,
ver=repository_version.number,
pub=publisher.name))
with WorkingDirectory():
with Publication.create(repository_version, publisher) as publication:
# Write any Artifacts (files) to the file system, and the database.
#
# artifact = YourArtifactWriter.write(relative_path)
# published_artifact = PublishedArtifact(
# relative_path=artifact.relative_path,
# publication=publication,
# content_artifact=artifact)
# published_artifact.save()
# Write any metadata files to the file system, and the database.
#
# metadata = YourMetadataWriter.write(relative_path)
# metadata = PublishedMetadata(
# relative_path=os.path.basename(manifest.relative_path),
# publication=publication,
# file=File(open(manifest.relative_path, 'rb')))
# metadata.save()
pass
log.info(
_('Publication: {publication} created').format(
publication=publication.pk))
def create(self):
"""
Perform the work. This is the long-blocking call where all syncing occurs.
"""
with WorkingDirectory():
with RepositoryVersion.create(self.repository) as new_version:
loop = asyncio.get_event_loop()
stages = [
self.first_stage,
QueryExistingContentUnits(),
ExistingContentNeedsNoArtifacts(),
ArtifactDownloader(),
ArtifactSaver(),
ContentUnitSaver(),
ContentUnitAssociation(new_version)
]
if self.mirror:
stages.append(ContentUnitUnassociation(new_version))
stages.append(EndStage())
pipeline = create_pipeline(stages)
loop.run_until_complete(pipeline)
def publish(repository_version_pk):
"""
Create a Publication based on a RepositoryVersion.
Args:
repository_version_pk (str): Create a publication from this repository version.
"""
repository_version = RepositoryVersion.objects.get(
pk=repository_version_pk)
log.info(
_("Publishing: repository={repo}, version={ver}").format(
repo=repository_version.repository.name,
ver=repository_version.number,
))
with WorkingDirectory():
with ChartPublication.create(repository_version) as publication:
publish_chart_content(publication)
log.info(
_("Publication: {publication} created").format(
publication=publication.pk))
def publish(repository_version_pk, metadata_signing_service=None):
"""
Create a Publication based on a RepositoryVersion.
Args:
repository_version_pk (str): Create a publication from this repository version.
metadata_signing_service (pulpcore.app.models.AsciiArmoredDetachedSigningService):
A reference to an associated signing service.
"""
repository_version = RepositoryVersion.objects.get(pk=repository_version_pk)
log.info(_('Publishing: repository={repo}, version={version}').format(
repo=repository_version.repository.name,
version=repository_version.number,
))
with WorkingDirectory():
with RpmPublication.create(repository_version) as publication:
publication_data = PublicationData(publication)
publication_data.populate()
content = publication.repository_version.content
# Main repo
create_repomd_xml(
content, publication, publication_data.repomdrecords,
metadata_signing_service=metadata_signing_service
)
for sub_repo in publication_data.sub_repos:
name = sub_repo[0]
content = getattr(publication_data, f"{name}_content")
extra_repomdrecords = getattr(publication_data, f"{name}_repomdrecords")
create_repomd_xml(
content, publication, extra_repomdrecords, name,
metadata_signing_service=metadata_signing_service
)