<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: reposync.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'># reposync.py
# DNF plugin adding a command to download all packages from given remote repo.
#
# Copyright (C) 2014 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
# Public License for more details.  You should have received a copy of the
# GNU General Public License along with this program; if not, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.
#

from __future__ import absolute_import
from __future__ import unicode_literals

import hawkey
import os
import shutil
import types

from dnfpluginscore import _, logger
from dnf.cli.option_parser import OptionParser
import dnf
import dnf.cli


def _pkgdir(intermediate, target):
    cwd = dnf.i18n.ucd(os.getcwd())
    return os.path.realpath(os.path.join(cwd, intermediate, target))


class RPMPayloadLocation(dnf.repo.RPMPayload):
    def __init__(self, pkg, progress, pkg_location):
        super(RPMPayloadLocation, self).__init__(pkg, progress)
        self.package_dir = os.path.dirname(pkg_location)

    def _target_params(self):
        tp = super(RPMPayloadLocation, self)._target_params()
        dnf.util.ensure_dir(self.package_dir)
        tp[&#039;dest&#039;] = self.package_dir
        return tp


@dnf.plugin.register_command
class RepoSyncCommand(dnf.cli.Command):
    aliases = (&#039;reposync&#039;,)
    summary = _(&#039;download all packages from remote repo&#039;)

    def __init__(self, cli):
        super(RepoSyncCommand, self).__init__(cli)

    @staticmethod
    def set_argparser(parser):
        parser.add_argument(&#039;-a&#039;, &#039;--arch&#039;, dest=&#039;arches&#039;, default=[],
                            action=OptionParser._SplitCallback, metavar=&#039;[arch]&#039;,
                            help=_(&#039;download only packages for this ARCH&#039;))
        parser.add_argument(&#039;--delete&#039;, default=False, action=&#039;store_true&#039;,
                            help=_(&#039;delete local packages no longer present in repository&#039;))
        parser.add_argument(&#039;--download-metadata&#039;, default=False, action=&#039;store_true&#039;,
                            help=_(&#039;download all the metadata.&#039;))
        parser.add_argument(&#039;-g&#039;, &#039;--gpgcheck&#039;, default=False, action=&#039;store_true&#039;,
                            help=_(&#039;Remove packages that fail GPG signature checking &#039;
                                   &#039;after downloading&#039;))
        parser.add_argument(&#039;-m&#039;, &#039;--downloadcomps&#039;, default=False, action=&#039;store_true&#039;,
                            help=_(&#039;also download and uncompress comps.xml&#039;))
        parser.add_argument(&#039;--metadata-path&#039;,
                            help=_(&#039;where to store downloaded repository metadata. &#039;
                                   &#039;Defaults to the value of --download-path.&#039;))
        parser.add_argument(&#039;-n&#039;, &#039;--newest-only&#039;, default=False, action=&#039;store_true&#039;,
                            help=_(&#039;download only newest packages per-repo&#039;))
        parser.add_argument(&#039;--norepopath&#039;, default=False, action=&#039;store_true&#039;,
                            help=_(&quot;Don&#039;t add the reponame to the download path.&quot;))
        parser.add_argument(&#039;-p&#039;, &#039;--download-path&#039;, default=&#039;./&#039;,
                            help=_(&#039;where to store downloaded repositories&#039;))
        parser.add_argument(&#039;--remote-time&#039;, default=False, action=&#039;store_true&#039;,
                            help=_(&#039;try to set local timestamps of local files by &#039;
                                   &#039;the one on the server&#039;))
        parser.add_argument(&#039;--source&#039;, default=False, action=&#039;store_true&#039;,
                            help=_(&#039;download only source packages&#039;))
        parser.add_argument(&#039;-u&#039;, &#039;--urls&#039;, default=False, action=&#039;store_true&#039;,
                            help=_(&quot;Just list urls of what would be downloaded, &quot;
                                   &quot;don&#039;t download&quot;))

    def configure(self):
        demands = self.cli.demands
        demands.available_repos = True
        demands.sack_activation = True

        repos = self.base.repos

        if self.opts.repo:
            repos.all().disable()
            for repoid in self.opts.repo:
                try:
                    repo = repos[repoid]
                except KeyError:
                    raise dnf.cli.CliError(&quot;Unknown repo: &#039;%s&#039;.&quot; % repoid)
                repo.enable()

        if self.opts.source:
            repos.enable_source_repos()

        if len(list(repos.iter_enabled())) &gt; 1 and self.opts.norepopath:
            raise dnf.cli.CliError(
                _(&quot;Can&#039;t use --norepopath with multiple repositories&quot;))

        for repo in repos.iter_enabled():
            repo._repo.expire()
            repo.deltarpm = False

    def run(self):
        self.base.conf.keepcache = True
        gpgcheck_ok = True
        for repo in self.base.repos.iter_enabled():
            if self.opts.remote_time:
                repo._repo.setPreserveRemoteTime(True)
            if self.opts.download_metadata:
                if self.opts.urls:
                    for md_type, md_location in repo._repo.getMetadataLocations():
                        url = repo.remote_location(md_location)
                        if url:
                            print(url)
                        else:
                            msg = _(&quot;Failed to get mirror for metadata: %s&quot;) % md_type
                            logger.warning(msg)
                else:
                    self.download_metadata(repo)
            if self.opts.downloadcomps:
                if self.opts.urls:
                    mdl = dict(repo._repo.getMetadataLocations())
                    group_locations = [mdl[md_type]
                                       for md_type in (&#039;group&#039;, &#039;group_gz&#039;, &#039;group_gz_zck&#039;)
                                       if md_type in mdl]
                    if group_locations:
                        for group_location in group_locations:
                            url = repo.remote_location(group_location)
                            if url:
                                print(url)
                                break
                        else:
                            msg = _(&quot;Failed to get mirror for the group file.&quot;)
                            logger.warning(msg)
                else:
                    self.getcomps(repo)
            pkglist = self.get_pkglist(repo)
            if self.opts.urls:
                self.print_urls(pkglist)
            else:
                self.download_packages(pkglist)
                if self.opts.gpgcheck:
                    for pkg in pkglist:
                        local_path = self.pkg_download_path(pkg)
                        # base.package_signature_check uses pkg.localPkg() to determine
                        # the location of the package rpm file on the disk.
                        # Set it to the correct download path.
                        pkg.localPkg  = types.MethodType(
                            lambda s, local_path=local_path: local_path, pkg)
                        result, error = self.base.package_signature_check(pkg)
                        if result != 0:
                            logger.warning(_(&quot;Removing {}: {}&quot;).format(
                                os.path.basename(local_path), error))
                            os.unlink(local_path)
                            gpgcheck_ok = False
            if self.opts.delete:
                self.delete_old_local_packages(repo, pkglist)
        if not gpgcheck_ok:
            raise dnf.exceptions.Error(_(&quot;GPG signature check failed.&quot;))

    def repo_target(self, repo):
        return _pkgdir(self.opts.destdir or self.opts.download_path,
                       repo.id if not self.opts.norepopath else &#039;&#039;)

    def metadata_target(self, repo):
        if self.opts.metadata_path:
            return _pkgdir(self.opts.metadata_path, repo.id if not self.opts.norepopath else &#039;&#039;)
        else:
            return self.repo_target(repo)

    def pkg_download_path(self, pkg):
        repo_target = self.repo_target(pkg.repo)
        pkg_download_path = os.path.realpath(
            os.path.join(repo_target, pkg.location))
        # join() ensures repo_target ends with a path separator (otherwise the
        # check would pass if pkg_download_path was a &quot;sibling&quot; path component
        # of repo_target that has the same prefix).
        if not pkg_download_path.startswith(os.path.join(repo_target, &#039;&#039;)):
            raise dnf.exceptions.Error(
                _(&quot;Download target &#039;{}&#039; is outside of download path &#039;{}&#039;.&quot;).format(
                    pkg_download_path, repo_target))
        return pkg_download_path

    def delete_old_local_packages(self, repo, pkglist):
        # delete any *.rpm file under target path, that was not downloaded from repository
        downloaded_files = set(self.pkg_download_path(pkg) for pkg in pkglist)
        for dirpath, dirnames, filenames in os.walk(self.repo_target(repo)):
            for filename in filenames:
                path = os.path.join(dirpath, filename)
                if filename.endswith(&#039;.rpm&#039;) and os.path.isfile(path):
                    if path not in downloaded_files:
                        # Delete disappeared or relocated file
                        try:
                            os.unlink(path)
                            logger.info(_(&quot;[DELETED] %s&quot;), path)
                        except OSError:
                            logger.error(_(&quot;failed to delete file %s&quot;), path)

    def getcomps(self, repo):
        comps_fn = repo._repo.getCompsFn()
        if comps_fn:
            dest_path = self.metadata_target(repo)
            dnf.util.ensure_dir(dest_path)
            dest = os.path.join(dest_path, &#039;comps.xml&#039;)
            dnf.yum.misc.decompress(comps_fn, dest=dest)
            logger.info(_(&quot;comps.xml for repository %s saved&quot;), repo.id)

    def download_metadata(self, repo):
        repo_target = self.metadata_target(repo)
        repo._repo.downloadMetadata(repo_target)
        return True

    def _get_latest(self, query):
        &quot;&quot;&quot;
        return union of these queries:
        - the latest NEVRAs from non-modular packages
        - all packages from stream version with the latest package NEVRA
          (this should not be needed but the latest package NEVRAs might be
          part of an older module version)
        - all packages from the latest stream version
        &quot;&quot;&quot;
        if not dnf.base.WITH_MODULES:
            return query.latest()

        query.apply()
        module_packages = self.base._moduleContainer.getModulePackages()
        all_artifacts = set()
        module_dict = {}  # {NameStream: {Version: [modules]}}
        artifact_version = {} # {artifact: {NameStream: [Version]}}
        for module_package in module_packages:
            artifacts = module_package.getArtifacts()
            all_artifacts.update(artifacts)
            module_dict.setdefault(module_package.getNameStream(), {}).setdefault(
                module_package.getVersionNum(), []).append(module_package)
            for artifact in artifacts:
                artifact_version.setdefault(artifact, {}).setdefault(
                    module_package.getNameStream(), []).append(module_package.getVersionNum())

        # the latest NEVRAs from non-modular packages
        latest_query = query.filter(
            pkg__neq=query.filter(nevra_strict=all_artifacts)).latest()

        # artifacts from the newest version and those versions that contain an artifact
        # with the highest NEVRA
        latest_stream_artifacts = set()
        for namestream, version_dict in module_dict.items():
            # versions that will be synchronized
            versions = set()
            # add the newest stream version
            versions.add(sorted(version_dict.keys(), reverse=True)[0])
            # collect all artifacts in all stream versions
            stream_artifacts = set()
            for modules in version_dict.values():
                for module in modules:
                    stream_artifacts.update(module.getArtifacts())
            # find versions to which the packages with the highest NEVRAs belong
            for latest_pkg in query.filter(nevra_strict=stream_artifacts).latest():
                # here we depend on modules.yaml allways containing full NEVRA (including epoch)
                nevra = &quot;{0.name}-{0.epoch}:{0.version}-{0.release}.{0.arch}&quot;.format(latest_pkg)
                # download only highest version containing the latest artifact
                versions.add(max(artifact_version[nevra][namestream]))
            # add all artifacts from selected versions for synchronization
            for version in versions:
                for module in version_dict[version]:
                    latest_stream_artifacts.update(module.getArtifacts())
        latest_query = latest_query.union(query.filter(nevra_strict=latest_stream_artifacts))

        return latest_query

    def get_pkglist(self, repo):
        query = self.base.sack.query(flags=hawkey.IGNORE_MODULAR_EXCLUDES).available().filterm(
            reponame=repo.id)
        if self.opts.newest_only:
            query = self._get_latest(query)
        if self.opts.source:
            query.filterm(arch=&#039;src&#039;)
        elif self.opts.arches:
            query.filterm(arch=self.opts.arches)
        # skip packages that would have been downloaded to the same location
        pkglist = []
        seen_paths = set()
        for pkg in query:
            download_path = self.pkg_download_path(pkg)
            if download_path not in seen_paths:
                pkglist.append(pkg)
                seen_paths.add(download_path)
        return pkglist

    def download_packages(self, pkglist):
        base = self.base
        progress = base.output.progress
        if progress is None:
            progress = dnf.callback.NullDownloadProgress()
        drpm = dnf.drpm.DeltaInfo(base.sack.query(flags=hawkey.IGNORE_MODULAR_EXCLUDES).installed(),
                                  progress, 0)
        payloads = [RPMPayloadLocation(pkg, progress, self.pkg_download_path(pkg))
                    for pkg in pkglist]
        base._download_remote_payloads(payloads, drpm, progress, None, False)

    def print_urls(self, pkglist):
        for pkg in pkglist:
            url = pkg.remote_location()
            if url:
                print(url)
            else:
                msg = _(&quot;Failed to get mirror for package: %s&quot;) % pkg.name
                logger.warning(msg)
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib/python3.9/site-packages/dnf-plugins/reposync.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib%2Fpython3.9%2Fsite-packages%2Fdnf-plugins' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>