new file mode 100644

@@ -0,0 +1,27 @@

+---

+breaking_changes:

+- >-

+  Replaced the in-tree dependency resolver with an external implementation

+  that pip >= 20.3 uses now by default — ``resolvelib``.

+  (https://github.com/ansible/ansible/issues/71784)

+- >-

+  Made SCM collections be reinstalled regardless of ``--force`` being

+  present.

+major_changes:

+- |

+  Declared ``resolvelib >= 0.5.3, < 0.6.0`` a direct dependency of

+  ansible-core. Refs:

+  - https://github.com/sarugaku/resolvelib

+  - https://pypi.org/p/resolvelib

+  - https://pradyunsg.me/blog/2020/03/27/pip-resolver-testing

+- >-

+  It became possible to install Ansible Collections from local folders and

+  namespaces folder similar to SCM structure with multiple collections.

+minor_changes:

+- >-

+  Refactored ``ansible-galaxy collection [download|install|list|verify]``

+  CLI subcommands with the public interface kept intact.

+- >-

+  The new dependency resolver prefers ``MANIFEST.json`` over ``galaxy.yml``

+  if it exists in the target directory.

+...

@@ -1,5 +1,5 @@

 # Copyright: (c) 2013, James Cammarata <jcammarata@ansible.com>

-# Copyright: (c) 2018, Ansible Project

+# Copyright: (c) 2018-2021, Ansible Project

 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

 from __future__ import (absolute_import, division, print_function)

@@ -24,7 +24,6 @@ from ansible.galaxy import Galaxy, get_collections_galaxy_meta_info

 from ansible.galaxy.api import GalaxyAPI

 from ansible.galaxy.collection import (

     build_collection,

-    CollectionRequirement,

     download_collections,

     find_existing_collections,

     install_collections,

@@ -33,6 +32,10 @@ from ansible.galaxy.collection import (

     validate_collection_path,

     verify_collections

 )

+from ansible.galaxy.collection.concrete_artifact_manager import (

+    ConcreteArtifactsManager,

+)

+from ansible.galaxy.dependency_resolution.dataclasses import Requirement

 from ansible.galaxy.role import GalaxyRole

 from ansible.galaxy.token import BasicAuthToken, GalaxyToken, KeycloakToken, NoTokenSentinel

@@ -52,6 +55,26 @@ display = Display()

 urlparse = six.moves.urllib.parse.urlparse

+def with_collection_artifacts_manager(wrapped_method):

+    """Inject an artifacts manager if not passed explicitly.

+

+    This decorator constructs a ConcreteArtifactsManager and maintains

+    the related temporary directory auto-cleanup around the target

+    method invocation.

+    """

+    def method_wrapper(*args, **kwargs):

+        if 'artifacts_manager' in kwargs:

+            return wrapped_method(*args, **kwargs)

+

+        with ConcreteArtifactsManager.under_tmpdir(

+                C.DEFAULT_LOCAL_TMP,

+                validate_certs=not context.CLIARGS['ignore_certs'],

+        ) as concrete_artifact_cm:

+            kwargs['artifacts_manager'] = concrete_artifact_cm

+            return wrapped_method(*args, **kwargs)

+    return method_wrapper

+

+

 def _display_header(path, h1, h2, w1=10, w2=7):

     display.display('\n# {0}\n{1:{cwidth}} {2:{vwidth}}\n{3} {4}\n'.format(

         path,

@@ -76,20 +99,19 @@ def _display_role(gr):

 def _display_collection(collection, cwidth=10, vwidth=7, min_cwidth=10, min_vwidth=7):

     display.display('{fqcn:{cwidth}} {version:{vwidth}}'.format(

-        fqcn=to_text(collection),

-        version=collection.latest_version,

+        fqcn=to_text(collection.fqcn),

+        version=collection.ver,

         cwidth=max(cwidth, min_cwidth),  # Make sure the width isn't smaller than the header

         vwidth=max(vwidth, min_vwidth)

     ))

 def _get_collection_widths(collections):

-    if is_iterable(collections):

-        fqcn_set = set(to_text(c) for c in collections)

-        version_set = set(to_text(c.latest_version) for c in collections)

-    else:

-        fqcn_set = set([to_text(collections)])

-        version_set = set([collections.latest_version])

+    if not is_iterable(collections):

+        collections = (collections, )

+

+    fqcn_set = {to_text(c.fqcn) for c in collections}

+    version_set = {to_text(c.ver) for c in collections}

     fqcn_length = len(max(fqcn_set, key=len))

     version_length = len(max(version_set, key=len))

@@ -447,7 +469,7 @@ class GalaxyCLI(CLI):

         # Need to filter out empty strings or non truthy values as an empty server list env var is equal to [''].

         server_list = [s for s in C.GALAXY_SERVER_LIST or [] if s]

-        for server_key in server_list:

+        for server_priority, server_key in enumerate(server_list, start=1):

             # Config definitions are looked up dynamically based on the C.GALAXY_SERVER_LIST entry. We look up the

             # section [galaxy_server.<server>] for the values url, username, password, and token.

             config_dict = dict((k, server_config_def(server_key, k, req)) for k, req in server_def)

@@ -486,7 +508,11 @@ class GalaxyCLI(CLI):

                         server_options['token'] = GalaxyToken(token=token_val)

             server_options.update(galaxy_options)

-            config_servers.append(GalaxyAPI(self.galaxy, server_key, **server_options))

+            config_servers.append(GalaxyAPI(

+                self.galaxy, server_key,

+                priority=server_priority,

+                **server_options

+            ))

         cmd_server = context.CLIARGS['api_server']

         cmd_token = GalaxyToken(token=context.CLIARGS['api_key'])

@@ -497,15 +523,21 @@ class GalaxyCLI(CLI):

             if config_server:

                 self.api_servers.append(config_server)

             else:

-                self.api_servers.append(GalaxyAPI(self.galaxy, 'cmd_arg', cmd_server, token=cmd_token,

-                                                  **galaxy_options))

+                self.api_servers.append(GalaxyAPI(

+                    self.galaxy, 'cmd_arg', cmd_server, token=cmd_token,

+                    priority=len(config_servers) + 1,

+                    **galaxy_options

+                ))

         else:

             self.api_servers = config_servers

         # Default to C.GALAXY_SERVER if no servers were defined

         if len(self.api_servers) == 0:

-            self.api_servers.append(GalaxyAPI(self.galaxy, 'default', C.GALAXY_SERVER, token=cmd_token,

-                                              **galaxy_options))

+            self.api_servers.append(GalaxyAPI(

+                self.galaxy, 'default', C.GALAXY_SERVER, token=cmd_token,

+                priority=0,

+                **galaxy_options

+            ))

         context.CLIARGS['func']()

@@ -530,7 +562,7 @@ class GalaxyCLI(CLI):

     def _get_default_collection_path(self):

         return C.COLLECTIONS_PATHS[0]

-    def _parse_requirements_file(self, requirements_file, allow_old_format=True):

+    def _parse_requirements_file(self, requirements_file, allow_old_format=True, artifacts_manager=None):

         """

         Parses an Ansible requirement.yml file and returns all the roles and/or collections defined in it. There are 2

         requirements file format:

@@ -556,6 +588,7 @@ class GalaxyCLI(CLI):

         :param requirements_file: The path to the requirements file.

         :param allow_old_format: Will fail if a v1 requirements file is found and this is set to False.

+        :param artifacts_manager: Artifacts manager.

         :return: a dict containing roles and collections to found in the requirements file.

         """

         requirements = {

@@ -619,33 +652,48 @@ class GalaxyCLI(CLI):

             for role_req in file_requirements.get('roles') or []:

                 requirements['roles'] += parse_role_req(role_req)

-            for collection_req in file_requirements.get('collections') or []:

-                if isinstance(collection_req, dict):

-                    req_name = collection_req.get('name', None)

-                    if req_name is None:

-                        raise AnsibleError("Collections requirement entry should contain the key name.")

-

-                    req_type = collection_req.get('type')

-                    if req_type not in ('file', 'galaxy', 'git', 'url', None):

-                        raise AnsibleError("The collection requirement entry key 'type' must be one of file, galaxy, git, or url.")

-

-                    req_version = collection_req.get('version', '*')

-                    req_source = collection_req.get('source', None)

-                    if req_source:

-                        # Try and match up the requirement source with our list of Galaxy API servers defined in the

-                        # config, otherwise create a server with that URL without any auth.

-                        req_source = next(iter([a for a in self.api_servers if req_source in [a.name, a.api_server]]),

-                                          GalaxyAPI(self.galaxy,

-                                                    "explicit_requirement_%s" % req_name,

-                                                    req_source,

-                                                    validate_certs=not context.CLIARGS['ignore_certs']))

-

-                    requirements['collections'].append((req_name, req_version, req_source, req_type))

-                else:

-                    requirements['collections'].append((collection_req, '*', None, None))

+            requirements['collections'] = [

+                Requirement.from_requirement_dict(

+                    self._init_coll_req_dict(collection_req),

+                    artifacts_manager,

+                )

+                for collection_req in file_requirements.get('collections') or []

+            ]

         return requirements

+    def _init_coll_req_dict(self, coll_req):

+        if not isinstance(coll_req, dict):

+            # Assume it's a string:

+            return {'name': coll_req}

+

+        if (

+                'name' not in coll_req or

+                not coll_req.get('source') or

+                coll_req.get('type', 'galaxy') != 'galaxy'

+        ):

+            return coll_req

+

+        # Try and match up the requirement source with our list of Galaxy API

+        # servers defined in the config, otherwise create a server with that

+        # URL without any auth.

+        coll_req['source'] = next(

+            iter(

+                srvr for srvr in self.api_servers

+                if coll_req['source'] in {srvr.name, srvr.api_server}

+            ),

+            GalaxyAPI(

+                self.galaxy,

+                'explicit_requirement_{name!s}'.format(

+                    name=coll_req['name'],

+                ),

+                coll_req['source'],

+                validate_certs=not context.CLIARGS['ignore_certs'],

+            ),

+        )

+

+        return coll_req

+

     @staticmethod

     def exit_without_ignore(rc=1):

         """

@@ -733,26 +781,29 @@ class GalaxyCLI(CLI):

         return meta_value

-    def _require_one_of_collections_requirements(self, collections, requirements_file):

+    def _require_one_of_collections_requirements(

+            self, collections, requirements_file,

+            artifacts_manager=None,

+    ):

         if collections and requirements_file:

             raise AnsibleError("The positional collection_name arg and --requirements-file are mutually exclusive.")

         elif not collections and not requirements_file:

             raise AnsibleError("You must specify a collection name or a requirements file.")

         elif requirements_file:

             requirements_file = GalaxyCLI._resolve_path(requirements_file)

-            requirements = self._parse_requirements_file(requirements_file, allow_old_format=False)

+            requirements = self._parse_requirements_file(

+                requirements_file,

+                allow_old_format=False,

+                artifacts_manager=artifacts_manager,

+            )

         else:

-            requirements = {'collections': [], 'roles': []}

-            for collection_input in collections:

-                requirement = None

-                if os.path.isfile(to_bytes(collection_input, errors='surrogate_or_strict')) or \

-                        urlparse(collection_input).scheme.lower() in ['http', 'https'] or \

-                        collection_input.startswith(('git+', 'git@')):

-                    # Arg is a file path or URL to a collection

-                    name = collection_input

-                else:

-                    name, dummy, requirement = collection_input.partition(':')

-                requirements['collections'].append((name, requirement or '*', None, None))

+            requirements = {

+                'collections': [

+                    Requirement.from_string(coll_input, artifacts_manager)

+                    for coll_input in collections

+                ],

+                'roles': [],

+            }

         return requirements

     ############################

@@ -792,27 +843,37 @@ class GalaxyCLI(CLI):

         for collection_path in context.CLIARGS['args']:

             collection_path = GalaxyCLI._resolve_path(collection_path)

-            build_collection(collection_path, output_path, force)

+            build_collection(

+                to_text(collection_path, errors='surrogate_or_strict'),

+                to_text(output_path, errors='surrogate_or_strict'),

+                force,

+            )

-    def execute_download(self):

+    @with_collection_artifacts_manager

+    def execute_download(self, artifacts_manager=None):

         collections = context.CLIARGS['args']

         no_deps = context.CLIARGS['no_deps']

         download_path = context.CLIARGS['download_path']

-        ignore_certs = context.CLIARGS['ignore_certs']

         requirements_file = context.CLIARGS['requirements']

         if requirements_file:

             requirements_file = GalaxyCLI._resolve_path(requirements_file)

-        requirements = self._require_one_of_collections_requirements(collections, requirements_file)['collections']

+        requirements = self._require_one_of_collections_requirements(

+            collections, requirements_file,

+            artifacts_manager=artifacts_manager,

+        )['collections']

         download_path = GalaxyCLI._resolve_path(download_path)

         b_download_path = to_bytes(download_path, errors='surrogate_or_strict')

         if not os.path.exists(b_download_path):

             os.makedirs(b_download_path)

-        download_collections(requirements, download_path, self.api_servers, (not ignore_certs), no_deps,

-                             context.CLIARGS['allow_pre_release'])

+        download_collections(

+            requirements, download_path, self.api_servers, no_deps,

+            context.CLIARGS['allow_pre_release'],

+            artifacts_manager=artifacts_manager,

+        )

         return 0

@@ -1002,29 +1063,38 @@ class GalaxyCLI(CLI):

         self.pager(data)

-    def execute_verify(self):

+    @with_collection_artifacts_manager

+    def execute_verify(self, artifacts_manager=None):

         collections = context.CLIARGS['args']

         search_paths = context.CLIARGS['collections_path']

-        ignore_certs = context.CLIARGS['ignore_certs']

         ignore_errors = context.CLIARGS['ignore_errors']

         requirements_file = context.CLIARGS['requirements']

-        requirements = self._require_one_of_collections_requirements(collections, requirements_file)['collections']

+        requirements = self._require_one_of_collections_requirements(

+            collections, requirements_file,

+            artifacts_manager=artifacts_manager,

+        )['collections']

         resolved_paths = [validate_collection_path(GalaxyCLI._resolve_path(path)) for path in search_paths]

-        verify_collections(requirements, resolved_paths, self.api_servers, (not ignore_certs), ignore_errors,

-                           allow_pre_release=True)

+        verify_collections(

+            requirements, resolved_paths,

+            self.api_servers, ignore_errors,

+            artifacts_manager=artifacts_manager,

+        )

         return 0

-    def execute_install(self):

+    @with_collection_artifacts_manager

+    def execute_install(self, artifacts_manager=None):

         """

         Install one or more roles(``ansible-galaxy role install``), or one or more collections(``ansible-galaxy collection install``).

         You can pass in a list (roles or collections) or use the file

         option listed below (these are mutually exclusive). If you pass in a list, it

         can be a name (which will be downloaded via the galaxy API and github), or it can be a local tar archive file.

+

+        :param artifacts_manager: Artifacts manager.

         """

         install_items = context.CLIARGS['args']

         requirements_file = context.CLIARGS['requirements']

@@ -1042,7 +1112,10 @@ class GalaxyCLI(CLI):

         role_requirements = []

         if context.CLIARGS['type'] == 'collection':

             collection_path = GalaxyCLI._resolve_path(context.CLIARGS['collections_path'])

-            requirements = self._require_one_of_collections_requirements(install_items, requirements_file)

+            requirements = self._require_one_of_collections_requirements(

+                install_items, requirements_file,

+                artifacts_manager=artifacts_manager,

+            )

             collection_requirements = requirements['collections']

             if requirements['roles']:

@@ -1055,7 +1128,10 @@ class GalaxyCLI(CLI):

                 if not (requirements_file.endswith('.yaml') or requirements_file.endswith('.yml')):

                     raise AnsibleError("Invalid role requirements file, it must end with a .yml or .yaml extension")

-                requirements = self._parse_requirements_file(requirements_file)

+                requirements = self._parse_requirements_file(

+                    requirements_file,

+                    artifacts_manager=artifacts_manager,

+                )

                 role_requirements = requirements['roles']

                 # We can only install collections and roles at the same time if the type wasn't specified and the -p

@@ -1090,11 +1166,15 @@ class GalaxyCLI(CLI):

             display.display("Starting galaxy collection install process")

             # Collections can technically be installed even when ansible-galaxy is in role mode so we need to pass in

             # the install path as context.CLIARGS['collections_path'] won't be set (default is calculated above).

-            self._execute_install_collection(collection_requirements, collection_path)

+            self._execute_install_collection(

+                collection_requirements, collection_path,

+                artifacts_manager=artifacts_manager,

+            )

-    def _execute_install_collection(self, requirements, path):

+    def _execute_install_collection(

+            self, requirements, path, artifacts_manager,

+    ):

         force = context.CLIARGS['force']

-        ignore_certs = context.CLIARGS['ignore_certs']

         ignore_errors = context.CLIARGS['ignore_errors']

         no_deps = context.CLIARGS['no_deps']

         force_with_deps = context.CLIARGS['force_with_deps']

@@ -1111,8 +1191,12 @@ class GalaxyCLI(CLI):

         if not os.path.exists(b_output_path):

             os.makedirs(b_output_path)

-        install_collections(requirements, output_path, self.api_servers, (not ignore_certs), ignore_errors,

-                            no_deps, force, force_with_deps, allow_pre_release=allow_pre_release)

+        install_collections(

+            requirements, output_path, self.api_servers, ignore_errors,

+            no_deps, force, force_with_deps,

+            allow_pre_release=allow_pre_release,

+            artifacts_manager=artifacts_manager,

+        )

         return 0

@@ -1283,9 +1367,12 @@ class GalaxyCLI(CLI):

         return 0

-    def execute_list_collection(self):

+    @with_collection_artifacts_manager

+    def execute_list_collection(self, artifacts_manager=None):

         """

         List all collections installed on the local system

+

+        :param artifacts_manager: Artifacts manager.

         """

         collections_search_paths = set(context.CLIARGS['collections_path'])

@@ -1328,8 +1415,16 @@ class GalaxyCLI(CLI):

                     continue

                 collection_found = True

-                collection = CollectionRequirement.from_path(b_collection_path, False, fallback_metadata=True)

-                fqcn_width, version_width = _get_collection_widths(collection)

+

+                try:

+                    collection = Requirement.from_dir_path_as_unknown(

+                        b_collection_path,

+                        artifacts_manager,

+                    )

+                except ValueError as val_err:

+                    six.raise_from(AnsibleError(val_err), val_err)

+

+                fqcn_width, version_width = _get_collection_widths([collection])

                 _display_header(collection_path, 'Collection', 'Version', fqcn_width, version_width)

                 _display_collection(collection, fqcn_width, version_width)

@@ -1339,7 +1434,9 @@ class GalaxyCLI(CLI):

                 collection_path = validate_collection_path(path)

                 if os.path.isdir(collection_path):

                     display.vvv("Searching {0} for collections".format(collection_path))

-                    collections = find_existing_collections(collection_path, fallback_metadata=True)

+                    collections = list(find_existing_collections(

+                        collection_path, artifacts_manager,

+                    ))

                 else:

                     # There was no 'ansible_collections/' directory in the path, so there

                     # or no collections here.

@@ -1355,8 +1452,7 @@ class GalaxyCLI(CLI):

                 _display_header(collection_path, 'Collection', 'Version', fqcn_width, version_width)

                 # Sort collections by the namespace and name

-                collections.sort(key=to_text)

-                for collection in collections:

+                for collection in sorted(collections, key=to_text):

                     _display_collection(collection, fqcn_width, version_width)

         # Do not warn if the specific collection was found in any of the search paths

@@ -7,6 +7,7 @@ __metaclass__ = type

 import collections

 import datetime

+import functools

 import hashlib

 import json

 import os

@@ -233,11 +234,17 @@ class CollectionVersionMetadata:

         self.dependencies = dependencies

+@functools.total_ordering

 class GalaxyAPI:

     """ This class is meant to be used as a API client for an Ansible Galaxy server """

-    def __init__(self, galaxy, name, url, username=None, password=None, token=None, validate_certs=True,

-                 available_api_versions=None, clear_response_cache=False, no_cache=True):

+    def __init__(

+            self, galaxy, name, url,

+            username=None, password=None, token=None, validate_certs=True,

+            available_api_versions=None,

+            clear_response_cache=False, no_cache=True,

+            priority=float('inf'),

+    ):

         self.galaxy = galaxy

         self.name = name

         self.username = username

@@ -246,6 +253,7 @@ class GalaxyAPI:

         self.api_server = url

         self.validate_certs = validate_certs

         self._available_api_versions = available_api_versions or {}

+        self._priority = priority

         b_cache_dir = to_bytes(C.config.get_config_value('GALAXY_CACHE_DIR'), errors='surrogate_or_strict')

         makedirs_safe(b_cache_dir, mode=0o700)

@@ -263,6 +271,38 @@ class GalaxyAPI:

         display.debug('Validate TLS certificates for %s: %s' % (self.api_server, self.validate_certs))

+    def __str__(self):

+        # type: (GalaxyAPI) -> str

+        """Render GalaxyAPI as a native string representation."""

+        return to_native(self.name)

+

+    def __unicode__(self):

+        # type: (GalaxyAPI) -> unicode

+        """Render GalaxyAPI as a unicode/text string representation."""

+        return to_text(self.name)

+

+    def __repr__(self):

+        # type: (GalaxyAPI) -> str

+        """Render GalaxyAPI as an inspectable string representation."""

+        return (

+            '<{instance!s} "{name!s}" @ {url!s} with priority {priority!s}>'.

+            format(

+                instance=self, name=self.name,

+                priority=self._priority, url=self.api_server,

+            )

+        )

+

+    def __lt__(self, other_galaxy_api):

+        # type: (GalaxyAPI, GalaxyAPI) -> Union[bool, 'NotImplemented']

+        """Return whether the instance priority is higher than other."""

+        if not isinstance(other_galaxy_api, self.__class__):

+            return NotImplemented

+

+        return (

+            self._priority > other_galaxy_api._priority or

+            self.name < self.name

+        )

+

     @property

     @g_connect(['v1', 'v2', 'v3'])

     def available_api_versions(self):

@@ -1,5 +1,5 @@

 # -*- coding: utf-8 -*-

-# Copyright: (c) 2019, Ansible Project

+# Copyright: (c) 2019-2021, Ansible Project

 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

 """Installed collections management package."""

@@ -9,7 +9,6 @@ __metaclass__ = type

 import errno

 import fnmatch

 import json

-import operator

 import os

 import shutil

 import stat

@@ -25,30 +24,102 @@ from contextlib import contextmanager

 from distutils.version import LooseVersion

 from hashlib import sha256

 from io import BytesIO

+from itertools import chain

+from resolvelib.resolvers import InconsistentCandidate

 from yaml.error import YAMLError

+# NOTE: Adding type ignores is a hack for mypy to shut up wrt bug #1153

 try:

-    import queue

+    import queue  # type: ignore[import]

+except ImportError:  # Python 2

+    import Queue as queue  # type: ignore[import,no-redef]

+

+try:

+    # NOTE: It's in Python 3 stdlib and can be installed on Python 2

+    # NOTE: via `pip install typing`. Unnecessary in runtime.

+    # NOTE: `TYPE_CHECKING` is True during mypy-typecheck-time.

+    from typing import TYPE_CHECKING

 except ImportError:

-    import Queue as queue  # Python 2

+    TYPE_CHECKING = False

+

+if TYPE_CHECKING:

+    from typing import Dict, Iterable, List, Optional, Text, Union

+    if sys.version_info[:2] >= (3, 8):

+        from typing import Literal

+    else:  # Python 2 + Python 3.4-3.7

+        from typing_extensions import Literal

+

+    from ansible.galaxy.api import GalaxyAPI

+    from ansible.galaxy.collection.concrete_artifact_manager import (

+        ConcreteArtifactsManager,

+    )

+

+    ManifestKeysType = Literal[

+        'collection_info', 'file_manifest_file', 'format',

+    ]

+    FileMetaKeysType = Literal[

+        'name',

+        'ftype',

+        'chksum_type',

+        'chksum_sha256',

+        'format',

+    ]

+    CollectionInfoKeysType = Literal[

+        # collection meta:

+        'namespace', 'name', 'version',

+        'authors', 'readme',

+        'tags', 'description',

+        'license', 'license_file',

+        'dependencies',

+        'repository', 'documentation',

+        'homepage', 'issues',

+

+        # files meta:

+        FileMetaKeysType,

+    ]

+    ManifestValueType = Dict[

+        CollectionInfoKeysType,

+        Optional[

+            Union[

+                int, str,  # scalars, like name/ns, schema version

+                List[str],  # lists of scalars, like tags

+                Dict[str, str],  # deps map

+            ],

+        ],

+    ]

+    CollectionManifestType = Dict[ManifestKeysType, ManifestValueType]

+    FileManifestEntryType = Dict[FileMetaKeysType, Optional[Union[str, int]]]

+    FilesManifestType = Dict[

+        Literal['files', 'format'],

+        Union[List[FileManifestEntryType], int],

+    ]

 import ansible.constants as C

 from ansible.errors import AnsibleError

 from ansible.galaxy import get_collections_galaxy_meta_info

-from ansible.galaxy.api import CollectionVersionMetadata, GalaxyError

-from ansible.galaxy.user_agent import user_agent

-from ansible.module_utils import six

+from ansible.galaxy.collection.concrete_artifact_manager import (

+    _consume_file,

+    _download_file,

+    _get_meta_from_src_dir,

+    _tarfile_extract,

+)

+from ansible.galaxy.collection.galaxy_api_proxy import MultiGalaxyAPIProxy

+from ansible.galaxy.dependency_resolution import (

+    build_collection_dependency_resolver,

+)

+from ansible.galaxy.dependency_resolution.dataclasses import (

+    Candidate, Requirement,

+)

+from ansible.galaxy.dependency_resolution.errors import (

+    CollectionDependencyResolutionImpossible,

+)

+from ansible.galaxy.dependency_resolution.versioning import meets_requirements

+from ansible.module_utils.six import raise_from

 from ansible.module_utils._text import to_bytes, to_native, to_text

 from ansible.utils.collection_loader import AnsibleCollectionRef

 from ansible.utils.display import Display

-from ansible.utils.galaxy import scm_archive_collection

 from ansible.utils.hashing import secure_hash, secure_hash_s

 from ansible.utils.version import SemanticVersion

-from ansible.module_utils.urls import open_url

-

-urlparse = six.moves.urllib.parse.urlparse

-urldefrag = six.moves.urllib.parse.urldefrag

-urllib_error = six.moves.urllib.error

 display = Display()

@@ -58,532 +129,145 @@ MANIFEST_FORMAT = 1

 ModifiedContent = namedtuple('ModifiedContent', ['filename', 'expected', 'installed'])

-class CollectionRequirement:

-

-    _FILE_MAPPING = [(b'MANIFEST.json', 'manifest_file'), (b'FILES.json', 'files_file')]

-

-    def __init__(self, namespace, name, b_path, api, versions, requirement, force, parent=None, metadata=None,

-                 files=None, skip=False, allow_pre_releases=False):

-        """Represents a collection requirement, the versions that are available to be installed as well as any

-        dependencies the collection has.

-

-        :param namespace: The collection namespace.

-        :param name: The collection name.

-        :param b_path: Byte str of the path to the collection tarball if it has already been downloaded.

-        :param api: The GalaxyAPI to use if the collection is from Galaxy.

-        :param versions: A list of versions of the collection that are available.

-        :param requirement: The version requirement string used to verify the list of versions fit the requirements.

-        :param force: Whether the force flag applied to the collection.

-        :param parent: The name of the parent the collection is a dependency of.

-        :param metadata: The galaxy.api.CollectionVersionMetadata that has already been retrieved from the Galaxy

-            server.

-        :param files: The files that exist inside the collection. This is based on the FILES.json file inside the

-            collection artifact.

-        :param skip: Whether to skip installing the collection. Should be set if the collection is already installed

-            and force is not set.

-        :param allow_pre_releases: Whether to skip pre-release versions of collections.

-        """

-        self.namespace = namespace

-        self.name = name

-        self.b_path = b_path

-        self.api = api

-        self._versions = set(versions)

-        self.force = force

-        self.skip = skip

-        self.required_by = []

-        self.allow_pre_releases = allow_pre_releases

-

-        self._metadata = metadata

-        self._files = files

-

-        self.add_requirement(parent, requirement)

-

-    def __str__(self):

-        return to_native("%s.%s" % (self.namespace, self.name))

-

-    def __unicode__(self):

-        return u"%s.%s" % (self.namespace, self.name)

-

-    @property

-    def metadata(self):

-        self._get_metadata()

-        return self._metadata

-

-    @property

-    def versions(self):

-        if self.allow_pre_releases:

-            return self._versions

-        return set(v for v in self._versions if v == '*' or not SemanticVersion(v).is_prerelease)

-

-    @versions.setter

-    def versions(self, value):

-        self._versions = set(value)

-

-    @property

-    def pre_releases(self):

-        return set(v for v in self._versions if SemanticVersion(v).is_prerelease)

-

-    @property

-    def latest_version(self):

-        try:

-            return max([v for v in self.versions if v != '*'], key=SemanticVersion)

-        except ValueError:  # ValueError: max() arg is an empty sequence

-            return '*'

-

-    @property

-    def dependencies(self):

-        if not self._metadata:

-            if len(self.versions) > 1:

-                return {}

-            self._get_metadata()

-

-        dependencies = self._metadata.dependencies

-

-        if dependencies is None:

-            return {}

-

-        return dependencies

-

-    @staticmethod

-    def artifact_info(b_path):

-        """Load the manifest data from the MANIFEST.json and FILES.json. If the files exist, return a dict containing the keys 'files_file' and 'manifest_file'.

-        :param b_path: The directory of a collection.

-        """

-        info = {}

-        for b_file_name, property_name in CollectionRequirement._FILE_MAPPING:

-            b_file_path = os.path.join(b_path, b_file_name)

-            if not os.path.exists(b_file_path):

-                continue

-            with open(b_file_path, 'rb') as file_obj:

-                try:

-                    info[property_name] = json.loads(to_text(file_obj.read(), errors='surrogate_or_strict'))

-                except ValueError:

-                    raise AnsibleError("Collection file at '%s' does not contain a valid json string." % to_native(b_file_path))

-        return info

-

-    @staticmethod

-    def galaxy_metadata(b_path):

-        """Generate the manifest data from the galaxy.yml file.

-        If the galaxy.yml exists, return a dictionary containing the keys 'files_file' and 'manifest_file'.

-

-        :param b_path: The directory of a collection.

-        """

-        b_galaxy_path = get_galaxy_metadata_path(b_path)

-        info = {}

-        if os.path.exists(b_galaxy_path):

-            collection_meta = _get_galaxy_yml(b_galaxy_path)

-            info['files_file'] = _build_files_manifest(b_path, collection_meta['namespace'], collection_meta['name'], collection_meta['build_ignore'])

-            info['manifest_file'] = _build_manifest(**collection_meta)

-        return info

-

-    @staticmethod

-    def collection_info(b_path, fallback_metadata=False):

-        info = CollectionRequirement.artifact_info(b_path)

-        if info or not fallback_metadata:

-            return info

-        return CollectionRequirement.galaxy_metadata(b_path)

-

-    def add_requirement(self, parent, requirement):

-        self.required_by.append((parent, requirement))

-        new_versions = set(v for v in self.versions if self._meets_requirements(v, requirement, parent))

-        if len(new_versions) == 0:

-            if self.skip:

-                force_flag = '--force-with-deps' if parent else '--force'

-                version = self.latest_version if self.latest_version != '*' else 'unknown'

-                msg = "Cannot meet requirement %s:%s as it is already installed at version '%s'. Use %s to overwrite" \

-                      % (to_text(self), requirement, version, force_flag)

-                raise AnsibleError(msg)

-            elif parent is None:

-                msg = "Cannot meet requirement %s for dependency %s" % (requirement, to_text(self))

-            else:

-                msg = "Cannot meet dependency requirement '%s:%s' for collection %s" \

-                      % (to_text(self), requirement, parent)

+def verify_local_collection(

+        local_collection, remote_collection,

+        artifacts_manager,

+):  # type: (Candidate, Candidate, ConcreteArtifactsManager) -> None

+    """Verify integrity of the locally installed collection.

-            collection_source = to_text(self.b_path, nonstring='passthru') or self.api.api_server

-            req_by = "\n".join(

-                "\t%s - '%s:%s'" % (to_text(p) if p else 'base', to_text(self), r)

-                for p, r in self.required_by

-            )

+    :param local_collection: Collection being checked.

+    :param remote_collection: Correct collection.

+    :param artifacts_manager: Artifacts manager.

+    """

+    b_temp_tar_path = (  # NOTE: AnsibleError is raised on URLError

+        artifacts_manager.get_artifact_path

+        if remote_collection.is_concrete_artifact

+        else artifacts_manager.get_galaxy_artifact_path

+    )(remote_collection)

+

+    b_collection_path = to_bytes(

+        local_collection.src, errors='surrogate_or_strict',

+    )

-            versions = ", ".join(sorted(self.versions, key=SemanticVersion))

-            if not self.versions and self.pre_releases:

-                pre_release_msg = (

-                    '\nThis collection only contains pre-releases. Utilize `--pre` to install pre-releases, or '

-                    'explicitly provide the pre-release version.'

-                )