Port changes from main to refactored branch (#472)

Port changes from main to refactored branch

Depends-on: ansible/ansible-zuul-jobs#1563
SUMMARY

This PR contains several commits that complete the rebase of the 2.x-refactor branch onto main. Most of the changes here had to be manually backported after rebasing as the original changes were to code that will be deprecated. In addition, rather than trying to manually sort out conflicts and changes to the sanity ignores, I rewrote the refresh_ignore_files script to fully automate the management of ignore files. Previously, these files were both manually edited and auto-generated. This should no longer be the case, and these files should never be manually edited going forward.
For the purposes of reviewing and history, I kept all changes in separate commits tied to the original commit being backported.

ISSUE TYPE

COMPONENT NAME

ADDITIONAL INFORMATION

Reviewed-by: Jill R <None>

plugins/module_utils/k8s/client.py

@@ -12,7 +12,9 @@ from ansible_collections.kubernetes.core.plugins.module_utils.args_common import
     AUTH_ARG_SPEC,
     AUTH_PROXY_HEADERS_SPEC,
 )
-from ansible_collections.kubernetes.core.plugins.module_utils.k8s.core import requires
+from ansible_collections.kubernetes.core.plugins.module_utils.k8s.core import (
+    requires as _requires,
+)
 
 try:
     from ansible_collections.kubernetes.core.plugins.module_utils import (
@@ -49,6 +51,25 @@ except ImportError:
 _pool = {}
 
 
+class unique_string(str):
+    _low = None
+
+    def __hash__(self):
+        return id(self)
+
+    def __eq__(self, other):
+        return self is other
+
+    def lower(self):
+        if self._low is None:
+            lower = str.lower(self)
+            if str.__eq__(lower, self):
+                self._low = self
+            else:
+                self._low = unique_string(lower)
+        return self._low
+
+
 def _create_auth_spec(module=None, **kwargs) -> Dict:
     auth: Dict = {}
     # If authorization variables aren't defined, look for them in environment variables
@@ -148,7 +169,30 @@ def _create_configuration(auth: Dict):
     return configuration
 
 
-def _configuration_digest(configuration) -> str:
+def _create_headers(module=None, **kwargs):
+    header_map = {
+        "impersonate_user": "Impersonate-User",
+        "impersonate_groups": "Impersonate-Group",
+    }
+
+    headers = {}
+    for arg_name, header_name in header_map.items():
+        value = None
+        if module and module.params.get(arg_name) is not None:
+            value = module.params.get(arg_name)
+        elif arg_name in kwargs and kwargs.get(arg_name) is not None:
+            value = kwargs.get(arg_name)
+        else:
+            value = os.getenv("K8S_AUTH_{0}".format(arg_name.upper()), None)
+            if value is not None:
+                if AUTH_ARG_SPEC[arg_name].get("type") == "list":
+                    value = [x for x in value.split(",") if x != ""]
+        if value:
+            headers[header_name] = value
+    return headers
+
+
+def _configuration_digest(configuration, **kwargs) -> str:
     m = hashlib.sha256()
     for k in AUTH_ARG_MAP:
         if not hasattr(configuration, k):
@@ -161,19 +205,36 @@ def _configuration_digest(configuration) -> str:
                 m.update(content.encode())
         else:
             m.update(str(v).encode())
+    for k, v in kwargs.items():
+        content = "{0}: {1}".format(k, v)
+        m.update(content.encode())
     digest = m.hexdigest()
 
     return digest
 
 
+def _set_header(client, header, value):
+    if isinstance(value, list):
+        for v in value:
+            client.set_default_header(header_name=unique_string(header), header_value=v)
+    else:
+        client.set_default_header(header_name=header, header_value=value)
+
+
 def cache(func):
-    def wrapper(*args):
+    def wrapper(*args, **kwargs):
         client = None
-        digest = _configuration_digest(*args)
+        hashable_kwargs = {}
+        for k, v in kwargs.items():
+            if isinstance(v, list):
+                hashable_kwargs[k] = ",".join(sorted(v))
+            else:
+                hashable_kwargs[k] = v
+        digest = _configuration_digest(*args, **hashable_kwargs)
         if digest in _pool:
             client = _pool[digest]
         else:
-            client = func(*args)
+            client = func(*args, **kwargs)
             _pool[digest] = client
 
         return client
@@ -182,10 +243,11 @@ def cache(func):
 
 
 @cache
-def create_api_client(configuration):
-    return k8sdynamicclient.K8SDynamicClient(
-        kubernetes.client.ApiClient(configuration), discoverer=LazyDiscoverer
-    )
+def create_api_client(configuration, **headers):
+    client = kubernetes.client.ApiClient(configuration)
+    for header, value in headers.items():
+        _set_header(client, header, value)
+    return k8sdynamicclient.K8SDynamicClient(client, discoverer=LazyDiscoverer)
 
 
 class K8SClient:
@@ -204,20 +266,32 @@ class K8SClient:
     def resources(self) -> List[Any]:
         return self.client.resources
 
+    def _find_resource_with_prefix(
+        self, prefix: str, kind: str, api_version: str
+    ) -> Resource:
+        for attribute in ["kind", "name", "singular_name"]:
+            try:
+                return self.client.resources.get(
+                    **{"prefix": prefix, "api_version": api_version, attribute: kind}
+                )
+            except (ResourceNotFoundError, ResourceNotUniqueError):
+                pass
+        return self.client.resources.get(
+            prefix=prefix, api_version=api_version, short_names=[kind]
+        )
+
     def resource(self, kind: str, api_version: str) -> Resource:
         """Fetch a kubernetes client resource.
 
         This will attempt to find a kubernetes resource trying, in order, kind,
         name, singular_name and short_names.
         """
-        for attribute in ["kind", "name", "singular_name"]:
-            try:
-                return self.client.resources.get(
-                    **{"api_version": api_version, attribute: kind}
-                )
-            except (ResourceNotFoundError, ResourceNotUniqueError):
-                pass
-        return self.client.resources.get(api_version=api_version, short_names=[kind])
+        try:
+            if api_version == "v1":
+                return self._find_resource_with_prefix("api", kind, api_version)
+        except ResourceNotFoundError:
+            pass
+        return self._find_resource_with_prefix(None, kind, api_version)
 
     def _ensure_dry_run(self, params: Dict) -> Dict:
         if self.dry_run:
@@ -252,13 +326,18 @@ class K8SClient:
 
 def get_api_client(module=None, **kwargs: Optional[Any]) -> K8SClient:
     auth_spec = _create_auth_spec(module, **kwargs)
+    if module:
+        requires = module.requires
+    else:
+        requires = _requires
     if isinstance(auth_spec.get("kubeconfig"), dict):
-        if module:
-            module.requires("kubernetes", "17.17.0", "to use in-memory config")
-        else:
-            requires("kubernetes", "17.17.0", "to use in-memory config")
+        requires("kubernetes", "17.17.0", "to use in-memory config")
+    if auth_spec.get("no_proxy"):
+        requires("kubernetes", "19.15.0", "to use the no_proxy feature")
+
     configuration = _create_configuration(auth_spec)
-    client = create_api_client(configuration)
+    headers = _create_headers(module, **kwargs)
+    client = create_api_client(configuration, **headers)
 
     k8s_client = K8SClient(
         configuration=configuration,