ansible-core 2.19.0b5__py3-none-any.whl → 2.19.0b6__py3-none-any.whl

ansible/module_utils/_internal/_deprecator.py

@@ -5,7 +5,7 @@ import pathlib
 import sys
 import typing as t
 
-from ansible.module_utils._internal import _stack, _messages, _validation
+from ansible.module_utils._internal import _stack, _messages, _validation, _plugin_info
 
 
 def deprecator_from_collection_name(collection_name: str | None) -> _messages.PluginInfo | None:
@@ -19,7 +19,7 @@ def deprecator_from_collection_name(collection_name: str | None) -> _messages.Pl
 
     return _messages.PluginInfo(
         resolved_name=collection_name,
-        type=_COLLECTION_ONLY_TYPE,
+        type=None,
     )
 
 
@@ -54,7 +54,7 @@ def _path_as_core_plugininfo(path: str) -> _messages.PluginInfo | None:
 
     if match := re.match(r'plugins/(?P<plugin_type>\w+)/(?P<plugin_name>\w+)', relpath):
         plugin_name = match.group("plugin_name")
-        plugin_type = match.group("plugin_type")
+        plugin_type = _plugin_info.normalize_plugin_type(match.group("plugin_type"))
 
         if plugin_type not in _DEPRECATOR_PLUGIN_TYPES:
             # The plugin type isn't a known deprecator type, so we have to assume the caller is intermediate code.
@@ -65,13 +65,13 @@ def _path_as_core_plugininfo(path: str) -> _messages.PluginInfo | None:
     elif match := re.match(r'modules/(?P<module_name>\w+)', relpath):
         # AnsiballZ Python package for core modules
         plugin_name = match.group("module_name")
-        plugin_type = "module"
+        plugin_type = _messages.PluginType.MODULE
     elif match := re.match(r'legacy/(?P<module_name>\w+)', relpath):
         # AnsiballZ Python package for non-core library/role modules
         namespace = 'ansible.legacy'
 
         plugin_name = match.group("module_name")
-        plugin_type = "module"
+        plugin_type = _messages.PluginType.MODULE
     else:
         return ANSIBLE_CORE_DEPRECATOR  # non-plugin core path, safe to use ansible-core for the same reason as the non-deprecator plugin type case above
 
@@ -85,7 +85,7 @@ def _path_as_collection_plugininfo(path: str) -> _messages.PluginInfo | None:
     if not (match := re.search(r'/ansible_collections/(?P<ns>\w+)/(?P<coll>\w+)/plugins/(?P<plugin_type>\w+)/(?P<plugin_name>\w+)', path)):
         return None
 
-    plugin_type = match.group('plugin_type')
+    plugin_type = _plugin_info.normalize_plugin_type(match.group('plugin_type'))
 
     if plugin_type in _AMBIGUOUS_DEPRECATOR_PLUGIN_TYPES:
         # We're able to detect the namespace, collection and plugin type -- but we have no way to identify the plugin name currently.
@@ -93,9 +93,6 @@ def _path_as_collection_plugininfo(path: str) -> _messages.PluginInfo | None:
         # In the future we could improve the detection and/or make it easier for a caller to identify the plugin name.
         return deprecator_from_collection_name('.'.join((match.group('ns'), match.group('coll'))))
 
-    if plugin_type == 'modules':
-        plugin_type = 'module'
-
     if plugin_type not in _DEPRECATOR_PLUGIN_TYPES:
         # The plugin type isn't a known deprecator type, so we have to assume the caller is intermediate code.
         # We have no way of knowing if the intermediate code is deprecating its own feature, or acting on behalf of another plugin.
@@ -107,46 +104,43 @@ def _path_as_collection_plugininfo(path: str) -> _messages.PluginInfo | None:
     return _messages.PluginInfo(resolved_name=name, type=plugin_type)
 
 
-_COLLECTION_ONLY_TYPE: t.Final = 'collection'
-"""Ersatz placeholder plugin type for use by a `PluginInfo` instance that references only a collection."""
-
 _ANSIBLE_MODULE_BASE_PATH: t.Final = pathlib.Path(sys.modules['ansible'].__file__).parent
 """Runtime-detected base path of the `ansible` Python package to distinguish between Ansible-owned and external code."""
 
 ANSIBLE_CORE_DEPRECATOR: t.Final = deprecator_from_collection_name('ansible.builtin')
 """Singleton `PluginInfo` instance for ansible-core callers where the plugin can/should not be identified in messages."""
 
-INDETERMINATE_DEPRECATOR: t.Final = _messages.PluginInfo(resolved_name='indeterminate', type='indeterminate')
+INDETERMINATE_DEPRECATOR: t.Final = _messages.PluginInfo(resolved_name=None, type=None)
 """Singleton `PluginInfo` instance for indeterminate deprecator."""
 
 _DEPRECATOR_PLUGIN_TYPES: t.Final = frozenset(
     {
-        'action',
-        'become',
-        'cache',
-        'callback',
-        'cliconf',
-        'connection',
-        # doc_fragments - no code execution
-        # filter - basename inadequate to identify plugin
-        'httpapi',
-        'inventory',
-        'lookup',
-        'module',  # only for collections
-        'netconf',
-        'shell',
-        'strategy',
-        'terminal',
-        # test - basename inadequate to identify plugin
-        'vars',
+        _messages.PluginType.ACTION,
+        _messages.PluginType.BECOME,
+        _messages.PluginType.CACHE,
+        _messages.PluginType.CALLBACK,
+        _messages.PluginType.CLICONF,
+        _messages.PluginType.CONNECTION,
+        # DOC_FRAGMENTS - no code execution
+        # FILTER - basename inadequate to identify plugin
+        _messages.PluginType.HTTPAPI,
+        _messages.PluginType.INVENTORY,
+        _messages.PluginType.LOOKUP,
+        _messages.PluginType.MODULE,  # only for collections
+        _messages.PluginType.NETCONF,
+        _messages.PluginType.SHELL,
+        _messages.PluginType.STRATEGY,
+        _messages.PluginType.TERMINAL,
+        # TEST - basename inadequate to identify plugin
+        _messages.PluginType.VARS,
     }
 )
 """Plugin types which are valid for identifying a deprecator for deprecation purposes."""
 
 _AMBIGUOUS_DEPRECATOR_PLUGIN_TYPES: t.Final = frozenset(
     {
-        'filter',
-        'test',
+        _messages.PluginType.FILTER,
+        _messages.PluginType.TEST,
     }
 )
 """Plugin types for which basename cannot be used to identify the plugin name."""

ansible/module_utils/_internal/_json/_profiles/__init__.py

@@ -87,6 +87,7 @@ For controller-to-module, type behavior is profile dependent.
 _common_module_response_types: frozenset[type[AnsibleSerializable]] = frozenset(
     {
         _messages.PluginInfo,
+        _messages.PluginType,
         _messages.Event,
         _messages.EventChain,
         _messages.ErrorSummary,

ansible/module_utils/_internal/_messages.py

@@ -8,6 +8,7 @@ A future release will remove the provisional status.
 from __future__ import annotations as _annotations
 
 import dataclasses as _dataclasses
+import enum as _enum
 import sys as _sys
 import typing as _t
 
@@ -21,14 +22,37 @@ else:
     _dataclass_kwargs = dict(frozen=True)
 
 
+class PluginType(_datatag.AnsibleSerializableEnum):
+    """Enum of Ansible plugin types."""
+
+    ACTION = _enum.auto()
+    BECOME = _enum.auto()
+    CACHE = _enum.auto()
+    CALLBACK = _enum.auto()
+    CLICONF = _enum.auto()
+    CONNECTION = _enum.auto()
+    DOC_FRAGMENTS = _enum.auto()
+    FILTER = _enum.auto()
+    HTTPAPI = _enum.auto()
+    INVENTORY = _enum.auto()
+    LOOKUP = _enum.auto()
+    MODULE = _enum.auto()
+    NETCONF = _enum.auto()
+    SHELL = _enum.auto()
+    STRATEGY = _enum.auto()
+    TERMINAL = _enum.auto()
+    TEST = _enum.auto()
+    VARS = _enum.auto()
+
+
 @_dataclasses.dataclass(**_dataclass_kwargs)
 class PluginInfo(_datatag.AnsibleSerializableDataclass):
     """Information about a loaded plugin."""
 
-    resolved_name: str
+    resolved_name: _t.Optional[str]
     """The resolved canonical plugin name; always fully-qualified for collection plugins."""
 
-    type: str
+    type: _t.Optional[PluginType]
     """The plugin type."""
 
 

ansible/module_utils/_internal/_plugin_info.py

@@ -21,5 +21,18 @@ def get_plugin_info(value: HasPluginInfo) -> _messages.PluginInfo:
     """Utility method that returns a `PluginInfo` from an object implementing the `HasPluginInfo` protocol."""
     return _messages.PluginInfo(
         resolved_name=value.ansible_name,
-        type=value.plugin_type,
+        type=normalize_plugin_type(value.plugin_type),
     )
+
+
+def normalize_plugin_type(value: str) -> _messages.PluginType | None:
+    """Normalize value and return it as a PluginType, or None if the value does match any known plugin type."""
+    value = value.lower()
+
+    if value == 'modules':
+        value = 'module'
+
+    try:
+        return _messages.PluginType(value)
+    except ValueError:
+        return None

ansible/module_utils/ansible_release.py

@@ -17,6 +17,6 @@
 
 from __future__ import annotations
 
-__version__ = '2.19.0b5'
+__version__ = '2.19.0b6'
 __author__ = 'Ansible, Inc.'
 __codename__ = "What Is and What Should Never Be"

ansible/module_utils/basic.py

@@ -480,9 +480,11 @@ class AnsibleModule(object):
             if basedir is not None and not os.path.exists(basedir):
                 try:
                     os.makedirs(basedir, mode=0o700)
-                except (OSError, IOError) as e:
-                    self.warn("Unable to use %s as temporary directory, "
-                              "failing back to system: %s" % (basedir, to_native(e)))
+                except OSError as ex:
+                    self.error_as_warning(
+                        msg=f"Unable to use {basedir!r} as temporary directory, falling back to system default.",
+                        exception=ex,
+                    )
                     basedir = None
                 else:
                     self.warn("Module remote_tmp %s did not exist and was "
@@ -494,11 +496,11 @@ class AnsibleModule(object):
             basefile = "ansible-moduletmp-%s-" % time.time()
             try:
                 tmpdir = tempfile.mkdtemp(prefix=basefile, dir=basedir)
-            except (OSError, IOError) as e:
-                self.fail_json(
-                    msg="Failed to create remote module tmp path at dir %s "
-                        "with prefix %s: %s" % (basedir, basefile, to_native(e))
-                )
+            except OSError as ex:
+                raise Exception(
+                    f"Failed to create remote module tmp path at dir {basedir!r} "
+                    f"with prefix {basefile!r}.",
+                ) from ex
             if not self._keep_remote_files:
                 atexit.register(shutil.rmtree, tmpdir)
             self._tmpdir = tmpdir
@@ -658,11 +660,8 @@ class AnsibleModule(object):
             return context
         try:
             ret = selinux.lgetfilecon_raw(to_native(path, errors='surrogate_or_strict'))
-        except OSError as e:
-            if e.errno == errno.ENOENT:
-                self.fail_json(path=path, msg='path %s does not exist' % path)
-            else:
-                self.fail_json(path=path, msg='failed to retrieve selinux context')
+        except OSError as ex:
+            self.fail_json(path=path, msg='Failed to retrieve selinux context.', exception=ex)
         if ret[0] == -1:
             return context
         # Limit split to 4 because the selevel, the last in the list,
@@ -802,9 +801,9 @@ class AnsibleModule(object):
                 return True
             try:
                 os.lchown(b_path, uid, -1)
-            except (IOError, OSError) as e:
+            except OSError as ex:
                 path = to_text(b_path)
-                self.fail_json(path=path, msg='chown failed: %s' % (to_text(e)))
+                self.fail_json(path=path, msg='chown failed', exception=ex)
             changed = True
         return changed
 
@@ -1330,7 +1329,7 @@ class AnsibleModule(object):
                     else:
                         journal.send(MESSAGE=u"%s %s" % (module, journal_msg),
                                      **dict(journal_args))
-                except IOError:
+                except OSError:
                     # fall back to syslog since logging to journal failed
                     self._log_to_syslog(journal_msg)
             else:
@@ -1660,8 +1659,8 @@ class AnsibleModule(object):
 
             try:
                 self.preserved_copy(fn, backupdest)
-            except (shutil.Error, IOError) as e:
-                self.fail_json(msg='Could not make backup of %s to %s: %s' % (fn, backupdest, to_native(e)))
+            except (shutil.Error, OSError) as ex:
+                raise Exception(f'Could not make backup of {fn!r} to {backupdest!r}.') from ex
 
         return backupdest
 
@@ -1735,28 +1734,25 @@ class AnsibleModule(object):
         try:
             # Optimistically try a rename, solves some corner cases and can avoid useless work, throws exception if not atomic.
             os.rename(b_src, b_dest)
-        except (IOError, OSError) as e:
-            if e.errno not in [errno.EPERM, errno.EXDEV, errno.EACCES, errno.ETXTBSY, errno.EBUSY]:
+        except OSError as ex:
+            if ex.errno in (errno.EPERM, errno.EXDEV, errno.EACCES, errno.ETXTBSY, errno.EBUSY):
                 # only try workarounds for errno 18 (cross device), 1 (not permitted),  13 (permission denied)
                 # and 26 (text file busy) which happens on vagrant synced folders and other 'exotic' non posix file systems
-                self.fail_json(msg='Could not replace file: %s to %s: %s' % (src, dest, to_native(e)))
-            else:
                 # Use bytes here.  In the shippable CI, this fails with
                 # a UnicodeError with surrogateescape'd strings for an unknown
                 # reason (doesn't happen in a local Ubuntu16.04 VM)
                 b_dest_dir = os.path.dirname(b_dest)
                 b_suffix = os.path.basename(b_dest)
-                error_msg = None
                 tmp_dest_name = None
                 try:
                     tmp_dest_fd, tmp_dest_name = tempfile.mkstemp(prefix=b'.ansible_tmp', dir=b_dest_dir, suffix=b_suffix)
-                except (OSError, IOError) as e:
-                    error_msg = 'The destination directory (%s) is not writable by the current user. Error was: %s' % (os.path.dirname(dest), to_native(e))
-
+                except OSError as ex:
                     if unsafe_writes:
                         self._unsafe_writes(b_src, b_dest)
                     else:
-                        self.fail_json(msg=error_msg)
+                        raise Exception(
+                            f'The destination directory {os.path.dirname(dest)!r} is not writable by the current user.'
+                        ) from ex
 
                 if tmp_dest_name:
                     b_tmp_dest_name = to_bytes(tmp_dest_name, errors='surrogate_or_strict')
@@ -1785,24 +1781,27 @@ class AnsibleModule(object):
                                     if dest_stat and (tmp_stat.st_uid != dest_stat.st_uid or tmp_stat.st_gid != dest_stat.st_gid):
                                         os.chown(b_tmp_dest_name, dest_stat.st_uid, dest_stat.st_gid)
                                     os.utime(b_tmp_dest_name, times=(time.time(), time.time()))
-                            except OSError as e:
-                                if e.errno != errno.EPERM:
+                            except OSError as ex:
+                                if ex.errno != errno.EPERM:
                                     raise
                             try:
                                 os.rename(b_tmp_dest_name, b_dest)
-                            except (shutil.Error, OSError, IOError) as e:
-                                if unsafe_writes and e.errno == errno.EBUSY:
+                            except (shutil.Error, OSError) as ex:
+                                if unsafe_writes and ex.errno == errno.EBUSY:
                                     self._unsafe_writes(b_tmp_dest_name, b_dest)
                                 else:
-                                    self.fail_json(msg='Unable to make %s into to %s, failed final rename from %s: %s' %
-                                                       (src, dest, b_tmp_dest_name, to_native(e)))
-                        except (shutil.Error, OSError, IOError) as e:
+                                    raise Exception(
+                                        f'Unable to make {src!r} into to {dest!r}, failed final rename from {to_text(b_tmp_dest_name)!r}.'
+                                    ) from ex
+                        except (shutil.Error, OSError) as ex:
                             if unsafe_writes:
                                 self._unsafe_writes(b_src, b_dest)
                             else:
-                                self.fail_json(msg='Failed to replace file: %s to %s: %s' % (src, dest, to_native(e)))
+                                raise Exception(f'Failed to replace {dest!r} with {src!r}.') from ex
                     finally:
                         self.cleanup(b_tmp_dest_name)
+            else:
+                raise Exception(f'Could not replace {dest!r} with {src!r}.') from ex
 
         if creating:
             # make sure the file has the correct permissions
@@ -1829,18 +1828,11 @@ class AnsibleModule(object):
         # sadly there are some situations where we cannot ensure atomicity, but only if
         # the user insists and we get the appropriate error we update the file unsafely
         try:
-            out_dest = in_src = None
-            try:
-                out_dest = open(dest, 'wb')
-                in_src = open(src, 'rb')
-                shutil.copyfileobj(in_src, out_dest)
-            finally:  # assuring closed files in 2.4 compatible way
-                if out_dest:
-                    out_dest.close()
-                if in_src:
-                    in_src.close()
-        except (shutil.Error, OSError, IOError) as e:
-            self.fail_json(msg='Could not write data to file (%s) from (%s): %s' % (dest, src, to_native(e)))
+            with open(dest, 'wb') as out_dest:
+                with open(src, 'rb') as in_src:
+                    shutil.copyfileobj(in_src, out_dest)
+        except (shutil.Error, OSError) as ex:
+            raise Exception(f'Could not write data to file {dest!r} from {src!r}.') from ex
 
     def _clean_args(self, args):
 
@@ -2126,18 +2118,16 @@ class AnsibleModule(object):
             selector.close()
 
             rc = cmd.returncode
-        except (OSError, IOError) as e:
-            self.log("Error Executing CMD:%s Exception:%s" % (self._clean_args(args), to_native(e)))
+        except OSError as ex:
             if handle_exceptions:
-                self.fail_json(rc=e.errno, stdout=b'', stderr=b'', msg=to_native(e), cmd=self._clean_args(args))
+                self.fail_json(rc=ex.errno, stdout='', stderr='', msg="Error executing command.", cmd=self._clean_args(args), exception=ex)
             else:
-                raise e
-        except Exception as e:
-            self.log("Error Executing CMD:%s Exception:%s" % (self._clean_args(args), to_native(traceback.format_exc())))
+                raise
+        except Exception as ex:
             if handle_exceptions:
-                self.fail_json(rc=257, stdout=b'', stderr=b'', msg=to_native(e), cmd=self._clean_args(args))
+                self.fail_json(rc=257, stdout='', stderr='', msg="Error executing command.", cmd=self._clean_args(args), exception=ex)
             else:
-                raise e
+                raise
 
         if rc != 0 and check_rc:
             msg = heuristic_log_sanitize(stderr.rstrip(), self.no_log_values)
@@ -2208,7 +2198,7 @@ def __getattr__(importable_name):
         importable = repeat
     elif importable_name in {
         'PY2', 'PY3', 'b', 'binary_type', 'integer_types',
-        'iteritems', 'string_types', 'test_type'
+        'iteritems', 'string_types', 'text_type',
     }:
         import importlib
         importable = getattr(

ansible/module_utils/common/respawn.py

@@ -10,6 +10,7 @@ import sys
 import typing as t
 
 from ansible.module_utils.common.text.converters import to_bytes
+from ansible.module_utils._internal._ansiballz import _respawn
 
 _ANSIBLE_PARENT_PATH = pathlib.Path(__file__).parents[3]
 
@@ -39,7 +40,7 @@ def respawn_module(interpreter_path) -> t.NoReturn:
         raise Exception('module has already been respawned')
 
     # FUTURE: we need a safe way to log that a respawn has occurred for forensic/debug purposes
-    payload = _create_payload()
+    payload = _respawn.create_payload()
     stdin_read, stdin_write = os.pipe()
     os.write(stdin_write, to_bytes(payload))
     os.close(stdin_write)
@@ -59,10 +60,12 @@ def probe_interpreters_for_module(interpreter_paths, module_name):
     :arg module_name: fully-qualified Python module name to probe for (for example, ``selinux``)
     """
     PYTHONPATH = os.getenv('PYTHONPATH', '')
+
     env = os.environ.copy()
     env.update({
         'PYTHONPATH': f'{_ANSIBLE_PARENT_PATH}:{PYTHONPATH}'.rstrip(': ')
     })
+
     for interpreter_path in interpreter_paths:
         if not os.path.exists(interpreter_path):
             continue
@@ -81,43 +84,3 @@ def probe_interpreters_for_module(interpreter_paths, module_name):
             continue
 
     return None
-
-
-def _create_payload():
-    # FIXME: move this into _ansiballz and skip the template
-    from ansible.module_utils import basic
-
-    module_fqn = sys.modules['__main__']._module_fqn
-    modlib_path = sys.modules['__main__']._modlib_path
-
-    respawn_code_template = """
-if __name__ == '__main__':
-    import runpy
-    import sys
-
-    json_params = {json_params!r}
-    profile = {profile!r}
-    module_fqn = {module_fqn!r}
-    modlib_path = {modlib_path!r}
-
-    sys.path.insert(0, modlib_path)
-
-    from ansible.module_utils._internal import _ansiballz
-
-    _ansiballz.run_module(
-        json_params=json_params,
-        profile=profile,
-        module_fqn=module_fqn,
-        modlib_path=modlib_path,
-        init_globals=dict(_respawned=True),
-    )
-"""
-
-    respawn_code = respawn_code_template.format(
-        json_params=basic._ANSIBLE_ARGS,
-        profile=basic._ANSIBLE_PROFILE,
-        module_fqn=module_fqn,
-        modlib_path=modlib_path,
-    )
-
-    return respawn_code

ansible/module_utils/connection.py

@@ -33,7 +33,6 @@ import json
 import pickle
 import socket
 import struct
-import traceback
 import uuid
 
 from functools import partial
@@ -136,12 +135,11 @@ class Connection(object):
 
         try:
             out = self.send(data)
-        except socket.error as e:
+        except OSError as ex:
             raise ConnectionError(
-                'unable to connect to socket %s. See Troubleshooting socket path issues '
-                'in the Network Debug and Troubleshooting Guide' % self.socket_path,
-                err=to_text(e, errors='surrogate_then_replace'), exception=traceback.format_exc()
-            )
+                f'Unable to connect to socket {self.socket_path!r}. See Troubleshooting socket path issues '
+                'in the Network Debug and Troubleshooting Guide.'
+            ) from ex
 
         try:
             response = json.loads(out)
@@ -192,13 +190,12 @@ class Connection(object):
             send_data(sf, to_bytes(data))
             response = recv_data(sf)
 
-        except socket.error as e:
+        except OSError as ex:
             sf.close()
             raise ConnectionError(
-                'unable to connect to socket %s. See the socket path issue category in '
-                'Network Debug and Troubleshooting Guide' % self.socket_path,
-                err=to_text(e, errors='surrogate_then_replace'), exception=traceback.format_exc()
-            )
+                f'Unable to connect to socket {self.socket_path!r}. See the socket path issue category in '
+                'Network Debug and Troubleshooting Guide.',
+            ) from ex
 
         sf.close()
 

ansible/module_utils/facts/hardware/linux.py

@@ -182,7 +182,7 @@ class LinuxHardware(Hardware):
                         xen = True
                     # Only interested in the first line
                     break
-        except IOError:
+        except OSError:
             pass
 
         if not os.access("/proc/cpuinfo", os.R_OK):

ansible/module_utils/facts/sysctl.py

@@ -17,8 +17,6 @@ from __future__ import annotations
 
 import re
 
-from ansible.module_utils.common.text.converters import to_text
-
 
 def get_sysctl(module, prefixes):
 
@@ -31,8 +29,8 @@ def get_sysctl(module, prefixes):
 
         try:
             rc, out, err = module.run_command(cmd)
-        except (IOError, OSError) as e:
-            module.warn('Unable to read sysctl: %s' % to_text(e))
+        except OSError as ex:
+            module.error_as_warning('Unable to read sysctl.', exception=ex)
             rc = 1
 
         if rc == 0:
@@ -54,8 +52,8 @@ def get_sysctl(module, prefixes):
 
                 try:
                     (key, value) = re.split(r'\s?=\s?|: ', line, maxsplit=1)
-                except Exception as e:
-                    module.warn('Unable to split sysctl line (%s): %s' % (to_text(line), to_text(e)))
+                except Exception as ex:
+                    module.error_as_warning(f'Unable to split sysctl line {line!r}.', exception=ex)
 
             if key:
                 sysctl[key] = value.strip()

ansible/module_utils/facts/system/caps.py

@@ -38,8 +38,8 @@ class SystemCapabilitiesFactCollector(BaseFactCollector):
                 # NOTE: -> get_caps_data()/parse_caps_data() for easier mocking -akl
                 try:
                     rc, out, err = module.run_command([capsh_path, "--print"], errors='surrogate_then_replace', handle_exceptions=False)
-                except (IOError, OSError) as e:
-                    module.warn('Could not query system capabilities: %s' % str(e))
+                except OSError as ex:
+                    module.error_as_warning('Could not query system capabilities.', exception=ex)
 
             if rc == 0:
                 enforced_caps = []

ansible/module_utils/facts/system/local.py

@@ -50,7 +50,7 @@ class LocalFactCollector(BaseFactCollector):
                     rc, out, err = module.run_command(fn)
                     if rc != 0:
                         failed = 'Failure executing fact script (%s), rc: %s, err: %s' % (fn, rc, err)
-                except (IOError, OSError) as e:
+                except OSError as e:
                     failed = 'Could not execute fact script (%s): %s' % (fn, to_text(e))
 
                 if failed is not None:

ansible/module_utils/facts/virtual/linux.py

@@ -129,7 +129,7 @@ class LinuxVirtual(Virtual):
                 for line in get_file_lines('/proc/xen/capabilities'):
                     if "control_d" in line:
                         is_xen_host = True
-            except IOError:
+            except OSError:
                 pass
 
             if is_xen_host:

ansible/module_utils/service.py

@@ -286,7 +286,7 @@ def is_systemd_managed(module):
             with open('/proc/1/comm', 'r') as init_proc:
                 init = init_proc.readline().strip()
                 return init == 'systemd'
-        except IOError:
+        except OSError:
             # If comm doesn't exist, old kernel, no systemd
             return False
 

ansible/module_utils/urls.py

@@ -580,7 +580,7 @@ def get_ca_certs(cafile=None, capath=None):
                             cadata[b_der] = None
                     except Exception:
                         continue
-                except (OSError, IOError):
+                except OSError:
                     pass
 
     # paths_checked isn't used any more, but is kept just for ease of debugging
@@ -694,7 +694,7 @@ def _configure_auth(url, url_username, url_password, use_gssapi, force_basic_aut
         try:
             rc = netrc.netrc(os.environ.get('NETRC'))
             login = rc.authenticators(parsed.hostname)
-        except IOError:
+        except OSError:
             login = None
 
         if login:
@@ -1303,8 +1303,8 @@ def fetch_url(module, url, data=None, headers=None, method=None,
     except urllib.error.URLError as e:
         code = int(getattr(e, 'code', -1))
         info.update(dict(msg="Request failed: %s" % to_native(e), status=code))
-    except socket.error as e:
-        info.update(dict(msg="Connection failure: %s" % to_native(e), status=-1))
+    except OSError as ex:
+        info.update(dict(msg=f"Connection failure: {ex}", status=-1))
     except http.client.BadStatusLine as e:
         info.update(dict(msg="Connection failure: connection was closed before a valid response was received: %s" % to_native(e.line), status=-1))
     except Exception as ex: