ansible-core 2.18.4rc1__py3-none-any.whl → 2.19.0b1__py3-none-any.whl

ansible/executor/task_queue_manager.py

@@ -27,18 +27,22 @@ import multiprocessing.queues
 
 from ansible import constants as C
 from ansible import context
-from ansible.errors import AnsibleError
+from ansible.errors import AnsibleError, ExitCode, AnsibleCallbackError
+from ansible._internal._errors._handler import ErrorHandler
 from ansible.executor.play_iterator import PlayIterator
 from ansible.executor.stats import AggregateStats
 from ansible.executor.task_result import TaskResult
+from ansible.inventory.data import InventoryData
 from ansible.module_utils.six import string_types
-from ansible.module_utils.common.text.converters import to_text, to_native
+from ansible.module_utils.common.text.converters import to_native
+from ansible.parsing.dataloader import DataLoader
 from ansible.playbook.play_context import PlayContext
 from ansible.playbook.task import Task
 from ansible.plugins.loader import callback_loader, strategy_loader, module_loader
 from ansible.plugins.callback import CallbackBase
-from ansible.template import Templar
+from ansible._internal._templating._engine import TemplateEngine
 from ansible.vars.hostvars import HostVars
+from ansible.vars.manager import VariableManager
 from ansible.utils.display import Display
 from ansible.utils.lock import lock_decorator
 from ansible.utils.multiprocessing import context as multiprocessing_context
@@ -47,6 +51,10 @@ from dataclasses import dataclass
 
 __all__ = ['TaskQueueManager']
 
+STDIN_FILENO = 0
+STDOUT_FILENO = 1
+STDERR_FILENO = 2
+
 display = Display()
 
 
@@ -111,7 +119,7 @@ class AnsibleEndPlay(Exception):
 
 class TaskQueueManager:
 
-    '''
+    """
     This class handles the multiprocessing requirements of Ansible by
     creating a pool of worker forks, a result handler fork, and a
     manager object with shared datastructures/queues for coordinating
@@ -119,29 +127,40 @@ class TaskQueueManager:
 
     The queue manager is responsible for loading the play strategy plugin,
     which dispatches the Play's tasks to hosts.
-    '''
-
-    RUN_OK = 0
-    RUN_ERROR = 1
-    RUN_FAILED_HOSTS = 2
-    RUN_UNREACHABLE_HOSTS = 4
-    RUN_FAILED_BREAK_PLAY = 8
-    RUN_UNKNOWN_ERROR = 255
-
-    def __init__(self, inventory, variable_manager, loader, passwords, stdout_callback=None, run_additional_callbacks=True, run_tree=False, forks=None):
-
+    """
+
+    RUN_OK = ExitCode.SUCCESS
+    RUN_ERROR = ExitCode.GENERIC_ERROR
+    RUN_FAILED_HOSTS = ExitCode.HOST_FAILED
+    RUN_UNREACHABLE_HOSTS = ExitCode.HOST_UNREACHABLE
+    RUN_FAILED_BREAK_PLAY = 8  # never leaves PlaybookExecutor.run
+    RUN_UNKNOWN_ERROR = 255  # never leaves PlaybookExecutor.run, intentionally includes the bit value for 8
+
+    _callback_dispatch_error_handler = ErrorHandler.from_config('_CALLBACK_DISPATCH_ERROR_BEHAVIOR')
+
+    def __init__(
+        self,
+        inventory: InventoryData,
+        variable_manager: VariableManager,
+        loader: DataLoader,
+        passwords: dict[str, str | None],
+        stdout_callback: str | None = None,
+        run_additional_callbacks: bool = True,
+        run_tree: bool = False,
+        forks: int | None = None,
+    ) -> None:
         self._inventory = inventory
         self._variable_manager = variable_manager
         self._loader = loader
         self._stats = AggregateStats()
         self.passwords = passwords
-        self._stdout_callback = stdout_callback
+        self._stdout_callback: str | None | CallbackBase = stdout_callback
         self._run_additional_callbacks = run_additional_callbacks
         self._run_tree = run_tree
         self._forks = forks or 5
 
         self._callbacks_loaded = False
-        self._callback_plugins = []
+        self._callback_plugins: list[CallbackBase] = []
         self._start_at_done = False
 
         # make sure any module paths (if specified) are added to the module_loader
@@ -154,14 +173,21 @@ class TaskQueueManager:
         self._terminated = False
 
         # dictionaries to keep track of failed/unreachable hosts
-        self._failed_hosts = dict()
-        self._unreachable_hosts = dict()
+        self._failed_hosts: dict[str, t.Literal[True]] = dict()
+        self._unreachable_hosts: dict[str, t.Literal[True]] = dict()
 
         try:
             self._final_q = FinalQueue()
         except OSError as e:
             raise AnsibleError("Unable to use multiprocessing, this is normally caused by lack of access to /dev/shm: %s" % to_native(e))
 
+        try:
+            # Done in tqm, and not display, because this is only needed for commands that execute tasks
+            for fd in (STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO):
+                os.set_inheritable(fd, False)
+        except Exception as ex:
+            self.warning(f"failed to set stdio as non inheritable: {ex}")
+
         self._callback_lock = threading.Lock()
 
         # A temporary file (opened pre-fork) used by connection
@@ -175,11 +201,11 @@ class TaskQueueManager:
             self._workers.append(None)
 
     def load_callbacks(self):
-        '''
+        """
         Loads all available callbacks, with the exception of those which
         utilize the CALLBACK_TYPE option. When CALLBACK_TYPE is set to 'stdout',
         only one such callback plugin will be loaded.
-        '''
+        """
 
         if self._callbacks_loaded:
             return
@@ -268,19 +294,19 @@ class TaskQueueManager:
         self._callbacks_loaded = True
 
     def run(self, play):
-        '''
+        """
         Iterates over the roles/tasks in a play, using the given (or default)
         strategy for queueing tasks. The default is the linear strategy, which
         operates like classic Ansible by keeping all hosts in lock-step with
         a given task (meaning no hosts move on to the next task until all hosts
         are done with the current task).
-        '''
+        """
 
         if not self._callbacks_loaded:
             self.load_callbacks()
 
         all_vars = self._variable_manager.get_vars(play=play)
-        templar = Templar(loader=self._loader, variables=all_vars)
+        templar = TemplateEngine(loader=self._loader, variables=all_vars)
 
         new_play = play.copy()
         new_play.post_validate(templar)
@@ -383,25 +409,25 @@ class TaskQueueManager:
                     except AttributeError:
                         pass
 
-    def clear_failed_hosts(self):
+    def clear_failed_hosts(self) -> None:
         self._failed_hosts = dict()
 
-    def get_inventory(self):
+    def get_inventory(self) -> InventoryData:
         return self._inventory
 
-    def get_variable_manager(self):
+    def get_variable_manager(self) -> VariableManager:
         return self._variable_manager
 
-    def get_loader(self):
+    def get_loader(self) -> DataLoader:
         return self._loader
 
     def get_workers(self):
         return self._workers[:]
 
-    def terminate(self):
+    def terminate(self) -> None:
         self._terminated = True
 
-    def has_dead_workers(self):
+    def has_dead_workers(self) -> bool:
 
         # [<WorkerProcess(WorkerProcess-2, stopped[SIGKILL])>,
         # <WorkerProcess(WorkerProcess-2, stopped[SIGTERM])>
@@ -414,6 +440,7 @@ class TaskQueueManager:
 
     @lock_decorator(attr='_callback_lock')
     def send_callback(self, method_name, *args, **kwargs):
+        # We always send events to stdout callback first, rest should follow config order
         for callback_plugin in [self._stdout_callback] + self._callback_plugins:
             # a plugin that set self.disabled to True will not be called
             # see osx_say.py example for such a plugin
@@ -457,11 +484,8 @@ class TaskQueueManager:
                 continue
 
             for method in methods:
-                try:
-                    method(*new_args, **kwargs)
-                except Exception as e:
-                    # TODO: add config toggle to make this fatal or not?
-                    display.warning(u"Failure using method (%s) in callback plugin (%s): %s" % (to_text(method_name), to_text(callback_plugin), to_text(e)))
-                    from traceback import format_tb
-                    from sys import exc_info
-                    display.vvv('Callback Exception: \n' + ' '.join(format_tb(exc_info()[2])))
+                with self._callback_dispatch_error_handler.handle(AnsibleCallbackError):
+                    try:
+                        method(*new_args, **kwargs)
+                    except Exception as ex:
+                        raise AnsibleCallbackError(f"Callback dispatch {method_name!r} failed for plugin {callback_plugin._load_name!r}.") from ex

ansible/executor/task_result.py

@@ -4,12 +4,14 @@
 
 from __future__ import annotations
 
+import typing as t
+
 from ansible import constants as C
 from ansible.parsing.dataloader import DataLoader
 from ansible.vars.clean import module_response_deepcopy, strip_internal_keys
 
 _IGNORE = ('failed', 'skipped')
-_PRESERVE = ('attempts', 'changed', 'retries')
+_PRESERVE = ('attempts', 'changed', 'retries', '_ansible_no_log')
 _SUB_PRESERVE = {'_ansible_delegated_vars': ('ansible_host', 'ansible_port', 'ansible_user', 'ansible_connection')}
 
 # stuff callbacks need
@@ -22,11 +24,11 @@ CLEAN_EXCEPTIONS = (
 
 
 class TaskResult:
-    '''
+    """
     This class is responsible for interpreting the resulting data
     from an executed task, and provides helper methods for determining
     the result of a given task.
-    '''
+    """
 
     def __init__(self, host, task, return_data, task_fields=None):
         self._host = host
@@ -93,7 +95,7 @@ class TaskResult:
         return ret
 
     def _check_key(self, key):
-        '''get a specific key from the result or its items'''
+        """get a specific key from the result or its items"""
 
         if isinstance(self._result, dict) and key in self._result:
             return self._result.get(key, False)
@@ -106,7 +108,7 @@ class TaskResult:
 
     def clean_copy(self):
 
-        ''' returns 'clean' taskresult object '''
+        """ returns 'clean' taskresult object """
 
         # FIXME: clean task_fields, _task and _host copies
         result = TaskResult(self._host, self._task, {}, self._task_fields)
@@ -127,15 +129,15 @@ class TaskResult:
                     if key in self._result[sub]:
                         subset[sub][key] = self._result[sub][key]
 
-        if isinstance(self._task.no_log, bool) and self._task.no_log or self._result.get('_ansible_no_log', False):
-            x = {"censored": "the output has been hidden due to the fact that 'no_log: true' was specified for this result"}
+        # DTFIX-FUTURE: is checking no_log here redundant now that we use _ansible_no_log everywhere?
+        if isinstance(self._task.no_log, bool) and self._task.no_log or self._result.get('_ansible_no_log'):
+            censored_result = censor_result(self._result)
 
-            # preserve full
-            for preserve in _PRESERVE:
-                if preserve in self._result:
-                    x[preserve] = self._result[preserve]
+            if results := self._result.get('results'):
+                # maintain shape for loop results so callback behavior recognizes a loop was performed
+                censored_result.update(results=[censor_result(item) if item.get('_ansible_no_log') else item for item in results])
 
-            result._result = x
+            result._result = censored_result
         elif self._result:
             result._result = module_response_deepcopy(self._result)
 
@@ -151,3 +153,10 @@ class TaskResult:
         result._result.update(subset)
 
         return result
+
+
+def censor_result(result: dict[str, t.Any]) -> dict[str, t.Any]:
+    censored_result = {key: value for key in _PRESERVE if (value := result.get(key, ...)) is not ...}
+    censored_result.update(censored="the output has been hidden due to the fact that 'no_log: true' was specified for this result")
+
+    return censored_result

ansible/galaxy/__init__.py

@@ -18,7 +18,7 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 #
 ########################################################################
-''' This manages remote shared Ansible objects, mainly roles'''
+""" This manages remote shared Ansible objects, mainly roles"""
 
 from __future__ import annotations
 
@@ -40,7 +40,7 @@ def get_collections_galaxy_meta_info():
 
 
 class Galaxy(object):
-    ''' Keeps global galaxy info '''
+    """ Keeps global galaxy info """
 
     def __init__(self):
         # TODO: eventually remove this as it contains a mismash of properties that aren't really global

ansible/galaxy/api.py

@@ -57,13 +57,13 @@ def should_retry_error(exception):
     if isinstance(exception, GalaxyError) and exception.http_code in RETRY_HTTP_ERROR_CODES:
         return True
 
-    if isinstance(exception, AnsibleError) and (orig_exc := getattr(exception, 'orig_exc', None)):
+    if isinstance(exception, AnsibleError) and (cause := exception.__cause__):
         # URLError is often a proxy for an underlying error, handle wrapped exceptions
-        if isinstance(orig_exc, URLError):
-            orig_exc = orig_exc.reason
+        if isinstance(cause, URLError):
+            cause = cause.reason
 
         # Handle common URL related errors
-        if isinstance(orig_exc, (TimeoutError, BadStatusLine, IncompleteRead)):
+        if isinstance(cause, (TimeoutError, BadStatusLine, IncompleteRead)):
             return True
 
     return False
@@ -408,11 +408,8 @@ class GalaxyAPI:
                             method=method, timeout=self._server_timeout, http_agent=user_agent(), follow_redirects='safe')
         except HTTPError as e:
             raise GalaxyError(e, error_context_msg)
-        except Exception as e:
-            raise AnsibleError(
-                "Unknown error when attempting to call Galaxy at '%s': %s" % (url, to_native(e)),
-                orig_exc=e
-            )
+        except Exception as ex:
+            raise AnsibleError(f"Unknown error when attempting to call Galaxy at {url!r}.") from ex
 
         resp_data = to_text(resp.read(), errors='surrogate_or_strict')
         try:
@@ -471,8 +468,8 @@ class GalaxyAPI:
             resp = open_url(url, data=args, validate_certs=self.validate_certs, method="POST", http_agent=user_agent(), timeout=self._server_timeout)
         except HTTPError as e:
             raise GalaxyError(e, 'Attempting to authenticate to galaxy')
-        except Exception as e:
-            raise AnsibleError('Unable to authenticate to galaxy: %s' % to_native(e), orig_exc=e)
+        except Exception as ex:
+            raise AnsibleError('Unable to authenticate to galaxy.') from ex
 
         data = json.loads(to_text(resp.read(), errors='surrogate_or_strict'))
         return data
@@ -817,8 +814,17 @@ class GalaxyAPI:
 
         signatures = data.get('signatures') or []
 
+        download_url_info = urlparse(data['download_url'])
+        if not download_url_info.scheme and not download_url_info.path.startswith('/'):
+            # galaxy does a lot of redirects, with much more complex pathing than we use
+            # within this codebase, without updating _call_galaxy to be able to return
+            # the final URL, we can't reliably build a relative URL.
+            raise AnsibleError(f'Invalid non absolute download_url: {data["download_url"]}')
+
+        download_url = urljoin(self.api_server, data['download_url'])
+
         return CollectionVersionMetadata(data['namespace']['name'], data['collection']['name'], data['version'],
-                                         data['download_url'], data['artifact']['sha256'],
+                                         download_url, data['artifact']['sha256'],
                                          data['metadata']['dependencies'], data['href'], signatures)
 
     @g_connect(['v2', 'v3'])
@@ -896,12 +902,10 @@ class GalaxyAPI:
             if not next_link:
                 break
             elif relative_link:
-                # TODO: This assumes the pagination result is relative to the root server. Will need to be verified
-                # with someone who knows the AH API.
-
-                # Remove the query string from the versions_url to use the next_link's query
-                versions_url = urljoin(versions_url, urlparse(versions_url).path)
-                next_link = versions_url.replace(versions_url_info.path, next_link)
+                next_link_info = urlparse(next_link)
+                if not next_link_info.scheme and not next_link_info.path.startswith('/'):
+                    raise AnsibleError(f'Invalid non absolute pagination link: {next_link}')
+                next_link = urljoin(self.api_server, next_link)
 
             data = self._call_galaxy(to_native(next_link, errors='surrogate_or_strict'),
                                      error_context_msg=error_context_msg, cache=True, cache_key=cache_key)

ansible/galaxy/collection/__init__.py

@@ -126,13 +126,13 @@ from ansible.galaxy.dependency_resolution.dataclasses import (
 from ansible.galaxy.dependency_resolution.versioning import meets_requirements
 from ansible.plugins.loader import get_all_plugin_loaders
 from ansible.module_utils.common.file import S_IRWU_RG_RO, S_IRWXU_RXG_RXO, S_IXANY
+from ansible.module_utils.common.sentinel import Sentinel
 from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
 from ansible.module_utils.common.collections import is_sequence
 from ansible.module_utils.common.yaml import yaml_dump
 from ansible.utils.collection_loader import AnsibleCollectionRef
 from ansible.utils.display import Display
 from ansible.utils.hashing import secure_hash, secure_hash_s
-from ansible.utils.sentinel import Sentinel
 
 
 display = Display()

ansible/galaxy/collection/concrete_artifact_manager.py

@@ -35,10 +35,10 @@ from ansible.module_utils.common.text.converters import to_bytes, to_native, to_
 from ansible.module_utils.api import retry_with_delays_and_condition
 from ansible.module_utils.api import generate_jittered_backoff
 from ansible.module_utils.common.process import get_bin_path
+from ansible.module_utils.common.sentinel import Sentinel
 from ansible.module_utils.common.yaml import yaml_load
 from ansible.module_utils.urls import open_url
 from ansible.utils.display import Display
-from ansible.utils.sentinel import Sentinel
 
 import ansible.constants as C
 
@@ -485,16 +485,13 @@ def _download_file(url, b_path, expected_hash, validate_certs, token=None, timeo
     display.display("Downloading %s to %s" % (url, to_text(b_tarball_dir)))
     # NOTE: Galaxy redirects downloads to S3 which rejects the request
     # NOTE: if an Authorization header is attached so don't redirect it
-    try:
-        resp = open_url(
-            to_native(url, errors='surrogate_or_strict'),
-            validate_certs=validate_certs,
-            headers=None if token is None else token.headers(),
-            unredirected_headers=['Authorization'], http_agent=user_agent(),
-            timeout=timeout
-        )
-    except Exception as err:
-        raise AnsibleError(to_native(err), orig_exc=err)
+    resp = open_url(
+        to_native(url, errors='surrogate_or_strict'),
+        validate_certs=validate_certs,
+        headers=None if token is None else token.headers(),
+        unredirected_headers=['Authorization'], http_agent=user_agent(),
+        timeout=timeout
+    )
 
     with open(b_file_path, 'wb') as download_file:  # type: t.BinaryIO
         actual_hash = _consume_file(resp, write_to=download_file)

ansible/galaxy/dependency_resolution/dataclasses.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import os
+import pathlib
 import typing as t
 
 from collections import namedtuple
@@ -25,6 +26,8 @@ if t.TYPE_CHECKING:
         '_ComputedReqKindsMixin',
     )
 
+import ansible
+import ansible.release
 
 from ansible.errors import AnsibleError, AnsibleAssertionError
 from ansible.galaxy.api import GalaxyAPI
@@ -39,6 +42,7 @@ _ALLOW_CONCRETE_POINTER_IN_SOURCE = False  # NOTE: This is a feature flag
 _GALAXY_YAML = b'galaxy.yml'
 _MANIFEST_JSON = b'MANIFEST.json'
 _SOURCE_METADATA_FILE = b'GALAXY.yml'
+_ANSIBLE_PACKAGE_PATH = pathlib.Path(ansible.__file__).parent
 
 display = Display()
 
@@ -224,6 +228,13 @@ class _ComputedReqKindsMixin:
         if dir_path.endswith(to_bytes(os.path.sep)):
             dir_path = dir_path.rstrip(to_bytes(os.path.sep))
         if not _is_collection_dir(dir_path):
+            dir_pathlib = pathlib.Path(to_text(dir_path))
+
+            # special handling for bundled collections without manifests, e.g., ansible._protomatter
+            if dir_pathlib.is_relative_to(_ANSIBLE_PACKAGE_PATH):
+                req_name = f'{dir_pathlib.parent.name}.{dir_pathlib.name}'
+                return cls(req_name, ansible.release.__version__, dir_path, 'dir', None)
+
             display.warning(
                 u"Collection at '{path!s}' does not have a {manifest_json!s} "
                 u'file, nor has it {galaxy_yml!s}: cannot detect version.'.
@@ -578,10 +589,9 @@ class _ComputedReqKindsMixin:
 
         See https://github.com/ansible/ansible/pull/81606 for extra context.
         """
-        version_string = self.ver[0]
-        return version_string.isdigit() or not (
-            version_string == '*' or
-            version_string.startswith(('<', '>', '!='))
+        version_spec_start_char = self.ver[0]
+        return version_spec_start_char.isdigit() or not (
+            version_spec_start_char.startswith(('<', '>', '!', '*'))
         )
 
     @property

ansible/galaxy/dependency_resolution/providers.py

@@ -39,7 +39,7 @@ except ImportError:
 
 # TODO: add python requirements to ansible-test's ansible-core distribution info and remove the hardcoded lowerbound/upperbound fallback
 RESOLVELIB_LOWERBOUND = SemanticVersion("0.5.3")
-RESOLVELIB_UPPERBOUND = SemanticVersion("1.1.0")
+RESOLVELIB_UPPERBOUND = SemanticVersion("2.0.0")
 RESOLVELIB_VERSION = SemanticVersion.from_loose_version(LooseVersion(resolvelib_version))
 
 

ansible/galaxy/dependency_resolution/reporters.py

@@ -5,12 +5,46 @@
 
 from __future__ import annotations
 
+from collections import defaultdict
+
 try:
     from resolvelib import BaseReporter
 except ImportError:
     class BaseReporter:  # type: ignore[no-redef]
         pass
 
+try:
+    from resolvelib.resolvers import Criterion
+except ImportError:
+    class Criterion:  # type: ignore[no-redef]
+        pass
+
+from ansible.utils.display import Display
+from .dataclasses import Candidate, Requirement
+
+
+display = Display()
+
+
+_CLI_APP_NAME = 'ansible-galaxy'
+_MESSAGES_AT_REJECT_COUNT = {
+    1: (
+        f'{_CLI_APP_NAME} is looking at multiple versions of {{fqcn}} to '
+        'determine which version is compatible with other '
+        'requirements. This could take a while.'
+    ),
+    8: (
+        f'{_CLI_APP_NAME} is looking at multiple versions of {{fqcn}} to '
+        'determine which version is compatible with other '
+        'requirements. This could take a while.'
+    ),
+    13: (
+        'This is taking longer than usual. You might need to provide '
+        'the dependency resolver with stricter constraints to reduce '
+        'runtime. If you want to abort this run, press Ctrl + C.'
+    ),
+}
+
 
 class CollectionDependencyReporter(BaseReporter):
     """A dependency reporter for Ansible Collections.
@@ -18,3 +52,50 @@ class CollectionDependencyReporter(BaseReporter):
     This is a proxy class allowing us to abstract away importing resolvelib
     outside of the `ansible.galaxy.dependency_resolution` Python package.
     """
+
+    def __init__(self) -> None:
+        """Initialize the collection rejection counter."""
+        super().__init__()
+
+        self.reject_count_by_fqcn: defaultdict[str, int] = defaultdict(int)
+
+    def _maybe_log_rejection_message(self, candidate: Candidate) -> bool:
+        """Print out rejection messages on pre-defined limit hits."""
+        # Inspired by https://github.com/pypa/pip/commit/9731131
+        self.reject_count_by_fqcn[candidate.fqcn] += 1
+
+        collection_rejections_count = self.reject_count_by_fqcn[candidate.fqcn]
+
+        if collection_rejections_count not in _MESSAGES_AT_REJECT_COUNT:
+            return False
+
+        collection_rejection_message = _MESSAGES_AT_REJECT_COUNT[
+            collection_rejections_count
+        ]
+        display.display(collection_rejection_message.format(fqcn=candidate.fqcn))
+
+        return True
+
+    def rejecting_candidate(  # resolvelib >= 0.9.0
+            self,
+            criterion: Criterion[Candidate, Requirement],
+            candidate: Candidate,
+    ) -> None:
+        """Augment rejection messages with conflict details."""
+        if not self._maybe_log_rejection_message(candidate):
+            return
+
+        msg = 'Will try a different candidate, due to conflict:'
+        for req_info in criterion.information:
+            req, parent = req_info.requirement, req_info.parent
+            msg += '\n    '
+            if parent:
+                msg += f'{parent !s} depends on '
+            else:
+                msg += 'The user requested '
+            msg += str(req)
+        display.v(msg)
+
+    def backtracking(self, candidate: Candidate) -> None:  # resolvelib < 0.9.0
+        """Print out rejection messages on pre-defined limit hits."""
+        self._maybe_log_rejection_message(candidate)

ansible/galaxy/role.py

@@ -185,13 +185,11 @@ class GalaxyRole(object):
             info_path = os.path.join(self.path, self.META_INSTALL)
             if os.path.isfile(info_path):
                 try:
-                    f = open(info_path, 'r')
-                    self._install_info = yaml_load(f)
+                    with open(info_path, 'r') as f:
+                        self._install_info = yaml_load(f)
                 except Exception:
                     display.vvvvv("Unable to load Galaxy install info for %s" % self.name)
                     return False
-                finally:
-                    f.close()
         return self._install_info
 
     @property
@@ -470,12 +468,10 @@ class GalaxyRole(object):
                 meta_path = os.path.join(self.path, meta_requirements)
                 if os.path.isfile(meta_path):
                     try:
-                        f = open(meta_path, 'r')
-                        self._requirements = yaml_load(f)
+                        with open(meta_path, 'r') as f:
+                            self._requirements = yaml_load(f)
                     except Exception:
                         display.vvvvv("Unable to load requirements for %s" % self.name)
-                    finally:
-                        f.close()
 
                     break