kubernator 1.0.11__py3-none-any.whl → 1.0.13__py3-none-any.whl

kubernator/api.py

@@ -28,7 +28,6 @@ import urllib.parse
 from collections.abc import Callable
 from collections.abc import Iterable, MutableSet, Reversible
 from enum import Enum
-from functools import cache
 from hashlib import sha256
 from io import StringIO as io_StringIO
 from pathlib import Path
@@ -40,14 +39,19 @@ from typing import Optional, Union, MutableSequence
 import requests
 import yaml
 from appdirs import user_config_dir
+from diff_match_patch import diff_match_patch
 from jinja2 import (Environment,
                     ChainableUndefined,
                     make_logging_undefined,
                     Template as JinjaTemplate,
                     pass_context)
-from jsonpath_ng.ext import parse as jp_parse
 from jsonschema import validators
 
+from kubernator._json_path import jp  # noqa: F401
+from kubernator._k8s_client_patches import (URLLIB_HEADERS_PATCH,
+                                            CUSTOM_OBJECT_PATCH_23,
+                                            CUSTOM_OBJECT_PATCH_25)
+
 _CACHE_HEADER_TRANSLATION = {"etag": "if-none-match",
                              "last-modified": "if-modified-since"}
 _CACHE_HEADERS = ("etag", "last-modified")
@@ -68,45 +72,6 @@ def to_patterns(*patterns):
     return [re.compile(fnmatch.translate(p)) for p in patterns]
 
 
-class JPath:
-    def __init__(self, pattern):
-        self.pattern = jp_parse(pattern)
-
-    def find(self, val):
-        return self.pattern.find(val)
-
-    def all(self, val):
-        return list(map(lambda x: x.value, self.find(val)))
-
-    def first(self, val):
-        """Returns the first element or None if it doesn't exist"""
-        try:
-            return next(map(lambda x: x.value, self.find(val)))
-        except StopIteration:
-            return None
-
-    def only(self, val):
-        """Returns the first and only element.
-        Raises ValueError if more than one value found
-        Raises KeyError if no value found
-        """
-        m = map(lambda x: x.value, self.find(val))
-        try:
-            v = next(m)
-        except StopIteration:
-            raise KeyError("no value found")
-        try:
-            next(m)
-            raise ValueError("more than one value returned")
-        except StopIteration:
-            return v
-
-
-@cache
-def jp(pattern) -> JPath:
-    return JPath(pattern)
-
-
 def scan_dir(logger, path: Path, path_filter: Callable[[os.DirEntry], bool], excludes, includes):
     logger.debug("Scanning %s, excluding %s, including %s", path, excludes, includes)
     with os.scandir(path) as it:  # type: Iterable[os.DirEntry]
@@ -228,20 +193,6 @@ def validator_with_defaults(validator_class):
     return validators.extend(validator_class, {"properties": set_defaults})
 
 
-def install_python_k8s_client(run, package_major, logger_stdout, logger_stderr):
-    cache_dir = get_cache_dir("python")
-    package_major_dir = cache_dir / str(package_major)
-
-    if not package_major_dir.exists():
-        package_major_dir.mkdir(parents=True, exist_ok=True)
-
-        run([sys.executable, "-m", "pip", "install", "--no-deps", "--no-cache-dir", "--no-input", "--pre",
-             "--root-user-action=ignore", "--break-system-packages", "--disable-pip-version-check",
-             "--target", str(package_major_dir), f"kubernetes~={package_major}.0"], logger_stdout, logger_stderr).wait()
-
-    return package_major_dir
-
-
 class _PropertyList(MutableSequence):
 
     def __init__(self, seq, read_parent, name):
@@ -740,7 +691,7 @@ class Repository:
                              self.local_dir)
             run(["git", "config", "remote.origin.fetch", f"+refs/heads/{ref}:refs/remotes/origin/{ref}"],
                 stdout_logger, stderr_logger, cwd=git_cache).wait()
-            run(["git", "fetch", "-pPt"], stdout_logger, stderr_logger, cwd=git_cache).wait()
+            run(["git", "fetch", "-pPt", "--force"], stdout_logger, stderr_logger, cwd=git_cache).wait()
             run(["git", "checkout", ref], stdout_logger, stderr_logger, cwd=git_cache).wait()
             run(["git", "clean", "-f"], stdout_logger, stderr_logger, cwd=git_cache).wait()
             run(["git", "reset", "--hard", ref, "--"], stdout_logger, stderr_logger, cwd=git_cache).wait()
@@ -795,3 +746,63 @@ class KubernatorPlugin:
 
     def handle_shutdown(self):
         pass
+
+
+def install_python_k8s_client(run, package_major, logger, logger_stdout, logger_stderr, disable_patching):
+    cache_dir = get_cache_dir("python")
+    package_major_dir = cache_dir / str(package_major)
+    package_major_dir_str = str(package_major_dir)
+    patch_indicator = package_major_dir / ".patched"
+
+    if disable_patching and package_major_dir.exists() and patch_indicator.exists():
+        logger.info("Patching is disabled, existing Kubernetes Client %s (%s) was patched - "
+                    "deleting current client",
+                    str(package_major), package_major_dir)
+        rmtree(package_major_dir)
+
+    if not package_major_dir.exists():
+        package_major_dir.mkdir(parents=True, exist_ok=True)
+        run([sys.executable, "-m", "pip", "install", "--no-deps", "--no-input", "--pre",
+             "--root-user-action=ignore", "--break-system-packages", "--disable-pip-version-check",
+             "--target", package_major_dir_str, f"kubernetes~={package_major}.0"], logger_stdout, logger_stderr).wait()
+
+    if not patch_indicator.exists() and not disable_patching:
+        for patch_text, target_file, skip_if_found, min_version, max_version, name in (
+                URLLIB_HEADERS_PATCH, CUSTOM_OBJECT_PATCH_23, CUSTOM_OBJECT_PATCH_25):
+            patch_target = package_major_dir / target_file
+            logger.info("Applying patch %s to %s...", name, patch_target)
+            if min_version and int(package_major) < min_version:
+                logger.info("Skipping patch %s on %s due to package major version %s below minimum %d!",
+                            name, patch_target, package_major, min_version)
+                continue
+            if max_version and int(package_major) > max_version:
+                logger.info("Skipping patch %s on %s due to package major version %s above maximum %d!",
+                            name, patch_target, package_major, max_version)
+                continue
+
+            with open(patch_target, "rt") as f:
+                target_file_original = f.read()
+            if skip_if_found in target_file_original:
+                logger.info("Skipping patch %s on %s, as it already appears to be patched!", name,
+                            patch_target)
+                continue
+
+            dmp = diff_match_patch()
+            patches = dmp.patch_fromText(patch_text)
+            target_file_patched, results = dmp.patch_apply(patches, target_file_original)
+            failed_patch = False
+            for idx, result in enumerate(results):
+                if not result:
+                    failed_patch = True
+                    msg = ("Failed to apply a patch to Kubernetes Client API %s, hunk #%d, patch: \n%s" % (
+                        patch_target, idx, patches[idx]))
+                    logger.fatal(msg)
+            if failed_patch:
+                raise RuntimeError(f"Failed to apply some Kubernetes Client API {patch_target} patches")
+
+            with open(patch_target, "wt") as f:
+                f.write(target_file_patched)
+
+        patch_indicator.touch(exist_ok=False)
+
+    return package_major_dir

kubernator/app.py

@@ -32,7 +32,7 @@ from typing import Optional, Union
 import kubernator
 from kubernator.api import (KubernatorPlugin, Globs, scan_dir, PropertyDict, config_as_dict, config_parent,
                             download_remote_file, load_remote_file, Repository, StripNL, jp, get_app_cache_dir,
-                            install_python_k8s_client)
+                            get_cache_dir, install_python_k8s_client)
 from kubernator.proc import run, run_capturing_out
 
 TRACE = 5
@@ -65,8 +65,12 @@ def define_arg_parse():
                    help="print version and exit")
     g.add_argument("--clear-cache", action="store_true",
                    help="clear cache and exit")
+    g.add_argument("--clear-k8s-cache", action="store_true",
+                   help="clear Kubernetes Client cache and exit")
     g.add_argument("--pre-cache-k8s-client", action="extend", nargs="+", type=int,
-                   help="download specified K8S client library minor(!) version(s) and exit")
+                   help="download specified K8S client library major(!) version(s) and exit")
+    parser.add_argument("--pre-cache-k8s-client-no-patch", action="store_true", default=None,
+                        help="do not patch the k8s client being pre-cached")
     parser.add_argument("--log-format", choices=["human", "json"], default="human",
                         help="whether to log for human or machine consumption")
     parser.add_argument("--log-file", type=argparse.FileType("w"), default=None,
@@ -453,23 +457,37 @@ class App(KubernatorPlugin):
 
 def clear_cache():
     cache_dir = get_app_cache_dir()
-    logger.info("Clearing application cache at %s", cache_dir)
+    _clear_cache("Clearing application cache at %s", cache_dir)
+
+
+def clear_k8s_cache():
+    cache_dir = get_cache_dir("python")
+    _clear_cache("Clearing Kubernetes Client cache at %s", cache_dir)
+
+
+def _clear_cache(msg, cache_dir):
+    logger.info(msg, cache_dir)
     if cache_dir.exists():
         rmtree(cache_dir)
 
 
-def pre_cache_k8s_clients(*versions):
+def pre_cache_k8s_clients(*versions, disable_patching=False):
     proc_logger = logger.getChild("proc")
     stdout_logger = StripNL(proc_logger.info)
     stderr_logger = StripNL(proc_logger.warning)
 
     for v in versions:
-        logger.info("Caching K8S client library ~=v%s.0...", v)
-        install_python_k8s_client(run, v, stdout_logger, stderr_logger)
+        logger.info("Caching K8S client library ~=v%s.0%s...", v,
+                    " (no patches)" if disable_patching else "")
+        install_python_k8s_client(run, v, logger, stdout_logger, stderr_logger, disable_patching)
 
 
 def main():
-    args = define_arg_parse().parse_args()
+    argparser = define_arg_parse()
+    args = argparser.parse_args()
+    if not args.pre_cache_k8s_client and args.pre_cache_k8s_client_no_patch is not None:
+        argparser.error("--pre-cache-k8s-client-no-patch can only be used with --pre-cache-k8s-client")
+
     init_logging(args.verbose, args.log_format, args.log_file)
 
     try:
@@ -477,8 +495,13 @@ def main():
             clear_cache()
             return
 
+        if args.clear_k8s_cache:
+            clear_k8s_cache()
+            return
+
         if args.pre_cache_k8s_client:
-            pre_cache_k8s_clients(*args.pre_cache_k8s_client)
+            pre_cache_k8s_clients(*args.pre_cache_k8s_client,
+                                  disable_patching=args.pre_cache_k8s_client_no_patch)
             return
 
         with App(args) as app:

kubernator/merge.py

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+#
+#   Copyright 2020 Express Systems USA, Inc
+#   Copyright 2024 Karellen, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+from copy import deepcopy
+from kubernator.api import jp
+from jsonpath_ng.jsonpath import Index, Child
+
+
+# https://github.com/kubernetes/community/blob/master/contributors/devel/sig-api-machinery/strategic-merge-patch.md
+
+def extract_merge_instructions(manifest, resource):
+    normalized_manifest = deepcopy(manifest)
+    change_instrs = jp('$..`match(/\\\\$patch|\\\\$deleteFromPrimitiveList\\/.*/)`').find(manifest)
+
+    instructions = []
+    for change_instr in change_instrs:
+        field = change_instr.path.fields[0]
+        context = change_instr.context.value
+
+        list_of_maps = False
+        search_key = None
+        change_path = change_instr.full_path.left
+        if isinstance(change_path, Child) and isinstance(change_path.right, Index):
+            list_of_maps = True
+            index = change_path.right.index
+            change_path = change_path.left
+            clean_manifest_result: list = change_path.find(normalized_manifest)[0].value
+            search_key = context.copy()
+            del search_key[field]
+            del clean_manifest_result[index]
+        else:
+            clean_manifest_result = change_path.find(normalized_manifest)[0]
+            clean_manifest_result_context = clean_manifest_result.value
+            del clean_manifest_result_context[field]
+
+        instruction_value = context[field]
+        if field == "$patch":
+            if instruction_value in ("replace", "delete"):
+                instructions.append(("patch", instruction_value,
+                                     change_path, list_of_maps, search_key))
+            else:
+                raise ValueError("Invalid $patch instruction %r in resource %s at %s" %
+                                 (instruction_value,
+                                  resource,
+                                  change_path))
+        elif field.startswith("$deleteFromPrimitiveList/"):
+            instructions.append(("delete-from-list", instruction_value, field[25:],
+                                 change_path))
+
+    return instructions, normalized_manifest
+
+
+def apply_merge_instructions(merge_instrs, source_manifest, target_manifest, logger, resource):
+    for merge_instr in merge_instrs:
+        if merge_instr[0] == "patch":
+            op, op_type, change_path, list_of_maps, search_key = merge_instr
+        else:
+            op, delete_list, field_name, change_path = merge_instr
+
+        if op == "patch":
+            source_obj = change_path.find(source_manifest)[0].value
+            merged_obj = change_path.find(target_manifest)[0].value
+            if op_type == "delete":
+                if list_of_maps:
+                    logger.trace("Deleting locally in resource %s: %s from %s at %s",
+                                 resource,
+                                 search_key,
+                                 merged_obj,
+                                 change_path)
+                    del_idxs = []
+                    for idx, obj in enumerate(merged_obj):
+                        for k, v in search_key.items():
+                            if k in obj:
+                                if v is not None and obj[k] == v:
+                                    del_idxs.append(idx)
+
+                    for idx in del_idxs:
+                        del merged_obj[idx]
+                else:
+                    logger.trace("Deleting locally in resource %s: %s at %s",
+                                 resource,
+                                 merged_obj,
+                                 change_path)
+                    merged_datum = change_path.find(target_manifest)[0]
+                    merged_datum.context.value[merged_datum.path.fields[0]] = None
+            elif op_type == "replace":
+                logger.trace("Replacing locally in resource %s: %s with %s at %s",
+                             resource,
+                             merged_obj, source_obj,
+                             change_path)
+                merged_obj.clear()
+                if list_of_maps:
+                    merged_obj.extend(source_obj)
+                else:
+                    merged_obj.update(source_obj)
+            else:
+                raise ValueError("Invalid $patch instruction %s found at %s in resource %s",
+                                 op_type, change_path, resource)
+
+        elif op == "delete-from-list":
+            merged_list: list = change_path.find(target_manifest)[0].value[field_name]
+            if not isinstance(merged_list, list):
+                raise ValueError("Not a list in resource %s: %s in %r at %s" %
+                                 (resource, merged_list, field_name, change_path))
+            logger.trace("Deleting from list locally in resource %s: %s from %s in %r at %s",
+                         resource, delete_list, merged_list, field_name, change_path)
+            for v in delete_list:
+                try:
+                    merged_list.remove(v)
+                except ValueError:
+                    logger.warning("No value %s to delete from list %s in %r at %s in resource %s",
+                                   v, merged_list, field_name, change_path, resource)
+        else:
+            raise RuntimeError("should never reach here")

kubernator/plugins/k8s.py

@@ -39,6 +39,7 @@ from kubernator.api import (KubernatorPlugin,
                             load_remote_file,
                             StripNL,
                             install_python_k8s_client)
+from kubernator.merge import extract_merge_instructions, apply_merge_instructions
 from kubernator.plugins.k8s_api import (K8SResourcePluginMixin,
                                         K8SResource,
                                         K8SResourcePatchType,
@@ -84,7 +85,10 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
     def set_context(self, context):
         self.context = context
 
-    def register(self, field_validation="Strict", field_validation_warn_fatal=True):
+    def register(self,
+                 field_validation="Warn",
+                 field_validation_warn_fatal=True,
+                 disable_client_patches=False):
         self.context.app.register_plugin("kubeconfig")
 
         if field_validation not in VALID_FIELD_VALIDATION:
@@ -113,6 +117,7 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                                    add_validator=self.api_remove_validator,
                                    get_api_versions=self.get_api_versions,
                                    create_resource=self.create_resource,
+                                   disable_client_patches=disable_client_patches,
                                    field_validation=field_validation,
                                    field_validation_warn_fatal=field_validation_warn_fatal,
                                    field_validation_warnings=0,
@@ -142,27 +147,24 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
             self._setup_client()
 
         server_minor = k8s.server_version[1]
-        pkg_major = self.embedded_pkg_version[0]
-        if server_minor != pkg_major:
-            logger.info("Bundled Kubernetes client version %s doesn't match server version %s",
-                        ".".join(self.embedded_pkg_version), ".".join(k8s.server_version))
-            pkg_dir = install_python_k8s_client(self.context.app.run, server_minor, stdout_logger, stderr_logger)
-
-            modules_to_delete = []
-            for k, v in sys.modules.items():
-                if k == "kubernetes" or k.startswith("kubernetes."):
-                    modules_to_delete.append(k)
-            for k in modules_to_delete:
-                del sys.modules[k]
-
-            logger.info("Adding sys.path reference to %s", pkg_dir)
-            sys.path.insert(0, str(pkg_dir))
-            self.embedded_pkg_version = self._get_kubernetes_client_version()
-            logger.info("Switching to Kubernetes client version %s", ".".join(self.embedded_pkg_version))
-            self._setup_client()
-        else:
-            logger.info("Bundled Kubernetes client version %s matches server version %s",
-                        ".".join(self.embedded_pkg_version), ".".join(k8s.server_version))
+
+        logger.info("Using Kubernetes client version =~%s.0 for server version %s",
+                    server_minor, ".".join(k8s.server_version))
+        pkg_dir = install_python_k8s_client(self.context.app.run, server_minor, logger,
+                                            stdout_logger, stderr_logger, k8s.disable_client_patches)
+
+        modules_to_delete = []
+        for k, v in sys.modules.items():
+            if k == "kubernetes" or k.startswith("kubernetes."):
+                modules_to_delete.append(k)
+        for k in modules_to_delete:
+            del sys.modules[k]
+
+        logger.info("Adding sys.path reference to %s", pkg_dir)
+        sys.path.insert(0, str(pkg_dir))
+        self.embedded_pkg_version = self._get_kubernetes_client_version()
+        logger.info("Switching to Kubernetes client version %s", ".".join(self.embedded_pkg_version))
+        self._setup_client()
 
         logger.debug("Reading Kubernetes OpenAPI spec for %s", k8s.server_git_version)
 
@@ -192,6 +194,7 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
         logger.info("Found Kubernetes %s on %s", k8s.server_git_version, k8s.client.configuration.host)
         K8SResource._k8s_client_version = tuple(map(int, pkg_version("kubernetes").split(".")))
         K8SResource._k8s_field_validation = k8s.field_validation
+        K8SResource._k8s_field_validation_patched = not k8s.disable_client_patches
         K8SResource._logger = self.logger
         K8SResource._api_warnings = self._api_warnings
 
@@ -404,6 +407,13 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                             return
                 raise
 
+        merge_instrs, normalized_manifest = extract_merge_instructions(resource.manifest, resource)
+        if merge_instrs:
+            logger.trace("Normalized manifest (no merge instructions) for resource %s: %s", resource,
+                         normalized_manifest)
+        else:
+            normalized_manifest = resource.manifest
+
         logger.debug("Applying resource %s%s", resource, status_msg)
         try:
             remote_resource = resource.get()
@@ -419,9 +429,9 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
             else:
                 raise
         else:
-            logger.trace("Attempting to retrieve a normalized patch for resource %s: %s", resource, resource.manifest)
+            logger.trace("Attempting to retrieve a normalized patch for resource %s: %s", resource, normalized_manifest)
             try:
-                merged_resource = resource.patch(resource.manifest,
+                merged_resource = resource.patch(normalized_manifest,
                                                  patch_type=K8SResourcePatchType.SERVER_SIDE_PATCH,
                                                  dry_run=True,
                                                  force=True)
@@ -456,6 +466,9 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                         raise
             else:
                 logger.trace("Merged resource %s: %s", resource, merged_resource)
+                if merge_instrs:
+                    apply_merge_instructions(merge_instrs, normalized_manifest, merged_resource, logger, resource)
+
                 patch = jsonpatch.make_patch(remote_resource, merged_resource)
                 logger.trace("Resource %s initial patches are: %s", resource, patch)
                 patch = self._filter_resource_patch(patch, patch_field_excludes)

kubernator/plugins/k8s_api.py

@@ -340,6 +340,7 @@ class K8SResourceKey(namedtuple("K8SResourceKey", ["group", "kind", "name", "nam
 class K8SResource:
     _k8s_client_version = None
     _k8s_field_validation = None
+    _k8s_field_validation_patched = None
     _logger = None
     _api_warnings = None
 
@@ -411,7 +412,7 @@ class K8SResource:
                   }
 
         # `and not self.rdef.custom` to be removed after solving https://github.com/kubernetes-client/gen/issues/259
-        if self._k8s_client_version[0] > 22 and not self.rdef.custom:
+        if self._k8s_client_version[0] > 22 and (self._k8s_field_validation_patched or not self.rdef.custom):
             kwargs["field_validation"] = self._k8s_field_validation
         if rdef.namespaced:
             kwargs["namespace"] = self.namespace
@@ -432,7 +433,7 @@ class K8SResource:
                   }
 
         # `and not self.rdef.custom` to be removed after solving https://github.com/kubernetes-client/gen/issues/259
-        if self._k8s_client_version[0] > 22 and not self.rdef.custom:
+        if self._k8s_client_version[0] > 22 and (self._k8s_field_validation_patched or not self.rdef.custom):
             kwargs["field_validation"] = self._k8s_field_validation
         if patch_type == K8SResourcePatchType.SERVER_SIDE_PATCH:
             kwargs["force"] = force

kubernator/plugins/minikube.py

@@ -124,7 +124,7 @@ class MinikubePlugin(KubernatorPlugin):
         profile_dir = get_cache_dir("minikube")
         self.minikube_home_dir = profile_dir
         self.minikube_home_dir.mkdir(parents=True, exist_ok=True)
-        self.kubeconfig_dir = profile_dir / ".kube"
+        self.kubeconfig_dir = profile_dir / ".kube" / profile
         self.kubeconfig_dir.mkdir(parents=True, exist_ok=True)
 
         if not driver:

kubernator/plugins/template.py

@@ -159,12 +159,12 @@ class TemplatePlugin(KubernatorPlugin):
             raise ValueError(f"Template with a name {name} does not exist")
 
         template = self.templates[name]
-        logger.debug("Rendering template %s from %s in %s", name, template.source, source)
+        templ_source = _get_source(name, template.source, source)
+        logger.debug("Rendering %s", templ_source)
         rendered_template = template.render(self.context, values)
 
         if self.template_engine.failures():
-            raise ValueError(f"Unable to render template {name} from {template.source} in {source} "
-                             "due to undefined required variables")
+            raise ValueError(f"Unable to render template {templ_source} due to undefined required variables")
 
         return rendered_template
 
@@ -174,8 +174,9 @@ class TemplatePlugin(KubernatorPlugin):
 
         rendered_template = self.render_template(name, source, values)
         template = self.templates[name]
-        logger.info("Applying template %s from %s", name, template.source)
-        self.context.k8s.add_resources(rendered_template, source=template.source)
+        templ_source = _get_source(name, template.source, source)
+        logger.info("Applying %s", templ_source)
+        self.context.k8s.add_resources(rendered_template, source=templ_source)
 
     def _process_template_doc(self, template_doc, source):
         logger.info("Processing Kubernator template from %s", source)
@@ -209,3 +210,9 @@ class TemplatePlugin(KubernatorPlugin):
 
     def __repr__(self):
         return "Template Plugin"
+
+
+def _get_source(name, template_def_source, template_appl_source):
+    return "template %r from %s%s" % (name, template_def_source,
+                                      "" if template_def_source == template_appl_source else
+                                      " in %s" % template_appl_source)

{kubernator-1.0.11.dist-info → kubernator-1.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kubernator
-Version: 1.0.11
+Version: 1.0.13
 Summary: Kubernator is the a pluggable framework for K8S provisioning
 Home-page: https://github.com/karellen/kubernator
 Author: Express Systems USA, Inc.
@@ -33,13 +33,14 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: appdirs (~=1.4)
 Requires-Dist: coloredlogs (~=15.0)
+Requires-Dist: diff-match-patch (>2023.0)
 Requires-Dist: gevent (>=21.1.2)
 Requires-Dist: jinja2 (~=3.1)
 Requires-Dist: json-log-formatter (~=0.3)
 Requires-Dist: jsonpatch (~=1.32)
-Requires-Dist: jsonpath-ng (~=1.5)
+Requires-Dist: jsonpath-ng (~=1.6.1)
 Requires-Dist: jsonschema (<4.0)
-Requires-Dist: kubernetes (~=28.0)
+Requires-Dist: kubernetes (~=29.0)
 Requires-Dist: openapi-schema-validator (~=0.1)
 Requires-Dist: openapi-spec-validator (~=0.3)
 Requires-Dist: requests (~=2.25)

kubernator-1.0.13.dist-info/RECORD

@@ -0,0 +1,30 @@
+kubernator/LICENSE,sha256=wKKdOCMTCPQRV5gDkVLAsXX8qSnRJ5owk7yWPO1KZNo,11387
+kubernator/__init__.py,sha256=3INpPMTdUp9RrfskvnKR_Z6m6l_5i1Ma0SgEE9mgD4E,915
+kubernator/__main__.py,sha256=f0S60wgpLu--1UlOhzfWail-xt8zyIuODodX98_yPN0,707
+kubernator/_json_path.py,sha256=pjQKXxgbpQWETYBIrIuJZHgugF92IbEAM19AC7JUmAQ,3162
+kubernator/_k8s_client_patches.py,sha256=PEeWPInnW38NDyK7G24_Dmw-x7xHpN3vJWZeckdqgK0,76892
+kubernator/api.py,sha256=O1wJ2K_u8CoFDMzSood5_VkP4L1Hmo4VWQQxn9D1T4A,26648
+kubernator/app.py,sha256=FQVWQydYPendvI6n5yJjacrD6DN85ex_4-d0Enb1xLg,20496
+kubernator/merge.py,sha256=eW5fajnDdI2n8aUqRfTmdG6GWDvDtcVKPKsp3fiB5Nk,5882
+kubernator/proc.py,sha256=8YlgbppyHic_51fVTPD7OP8x5yuRuL8j1kThR8MJjNI,5119
+kubernator/plugins/__init__.py,sha256=h9TLYK8UFEi53ipZSZsTBjp0ljKhisWsgPpt_PkWrO8,670
+kubernator/plugins/awscli.py,sha256=S6X7-qFiaZ7NDVDl2Jg0t-ih9KAJ45cUjjzd5Qe93ZM,4252
+kubernator/plugins/eks.py,sha256=xe7vyPHNwuP8gEYDSzPyBkm-RkAtP64wCOqs9U5I7xI,2273
+kubernator/plugins/helm.py,sha256=3BYZBPoiMUtNgmhdcbYCVRTPtaQMYzhfnMqXWyZRJZc,10525
+kubernator/plugins/istio.py,sha256=rjqFyWWKVhcv8tB5sY9cAQV8XnmUYc5vn8t1R6GRjOQ,10432
+kubernator/plugins/k8s.py,sha256=w_Uw8tvbeGgJ35jZs6BahWkVIlX6gxcX5-bOskudIfw,23387
+kubernator/plugins/k8s_api.py,sha256=w2aB7CU0rPqRgzhI5mLMJUUSpWlJGCsX_bHl4SjfzM8,27594
+kubernator/plugins/kops.py,sha256=QsrQJUF6wGJo2QRVqP92pG5vmOTYQIc25PD_DWCzrAA,9635
+kubernator/plugins/kubeconfig.py,sha256=uwtHmF2I6LiTPrC3M88G5SfYxDWtuh0MqcMfrHHoNRA,2178
+kubernator/plugins/kubectl.py,sha256=IgNghW1Q6s8V2o08eNY2NWfkkdV9Z6X2A3YFQinFr4g,4028
+kubernator/plugins/minikube.py,sha256=kWPDIS4X1JnEoXw_rIOvgvFtjJMch39uL0mD7gQwtjE,10162
+kubernator/plugins/template.py,sha256=KEiPfI7TbYXmF4a8ATWuFhxxWbcASHttFM_ekYEZ8Ps,8371
+kubernator/plugins/terraform.py,sha256=a1MPl9G8Rznjd28uMRdYWrjpFDLlFAVmLFH4hFEsMsQ,5285
+kubernator/plugins/terragrunt.py,sha256=-qN8tTqPUXJ9O7CEiJVUB0GSUQU3DUTkv-aWdIIsm7Q,5051
+kubernator-1.0.13.dist-info/METADATA,sha256=wlY-Q2tjUEEc8UNdv2iUbAbqbKnW6z9G25co5z-4lag,10522
+kubernator-1.0.13.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+kubernator-1.0.13.dist-info/entry_points.txt,sha256=IWDtHzyTleRqDSuVRXEr5GImrI7z_kh21t5DWZ8ldcQ,47
+kubernator-1.0.13.dist-info/namespace_packages.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+kubernator-1.0.13.dist-info/top_level.txt,sha256=_z1CxWeKMI55ckf2vC8HqjbCn_E2Y_P5RdrhE_QWcIs,11
+kubernator-1.0.13.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+kubernator-1.0.13.dist-info/RECORD,,

kubernator-1.0.11.dist-info/RECORD

@@ -1,27 +0,0 @@
-kubernator/LICENSE,sha256=wKKdOCMTCPQRV5gDkVLAsXX8qSnRJ5owk7yWPO1KZNo,11387
-kubernator/__init__.py,sha256=Fq_DcRKw3SzT9L-UcFqcw0DT6EC40NZSpyD6Y4T-mz4,915
-kubernator/__main__.py,sha256=f0S60wgpLu--1UlOhzfWail-xt8zyIuODodX98_yPN0,707
-kubernator/api.py,sha256=3hxYHOJt_ps9VFqqOuIHOHPLThLb98RO-gZZ_E-xd9I,24951
-kubernator/app.py,sha256=kGS8jVcf-nCY1mP6MdqMR27XNcEMb5Uxek9FEW4GWLg,19472
-kubernator/proc.py,sha256=8YlgbppyHic_51fVTPD7OP8x5yuRuL8j1kThR8MJjNI,5119
-kubernator/plugins/__init__.py,sha256=h9TLYK8UFEi53ipZSZsTBjp0ljKhisWsgPpt_PkWrO8,670
-kubernator/plugins/awscli.py,sha256=S6X7-qFiaZ7NDVDl2Jg0t-ih9KAJ45cUjjzd5Qe93ZM,4252
-kubernator/plugins/eks.py,sha256=xe7vyPHNwuP8gEYDSzPyBkm-RkAtP64wCOqs9U5I7xI,2273
-kubernator/plugins/helm.py,sha256=3BYZBPoiMUtNgmhdcbYCVRTPtaQMYzhfnMqXWyZRJZc,10525
-kubernator/plugins/istio.py,sha256=rjqFyWWKVhcv8tB5sY9cAQV8XnmUYc5vn8t1R6GRjOQ,10432
-kubernator/plugins/k8s.py,sha256=hUchwibVpvuHiC2HHCcbKgtSdlbg98P3NRweJn_4Hs4,22856
-kubernator/plugins/k8s_api.py,sha256=RlpbcdTheox2Tq5iz1_ghjJ6846wsSrJzjOEKpee4h8,27473
-kubernator/plugins/kops.py,sha256=QsrQJUF6wGJo2QRVqP92pG5vmOTYQIc25PD_DWCzrAA,9635
-kubernator/plugins/kubeconfig.py,sha256=uwtHmF2I6LiTPrC3M88G5SfYxDWtuh0MqcMfrHHoNRA,2178
-kubernator/plugins/kubectl.py,sha256=IgNghW1Q6s8V2o08eNY2NWfkkdV9Z6X2A3YFQinFr4g,4028
-kubernator/plugins/minikube.py,sha256=Gm1aI5QlYFd8eyWm7g85z2aZmPcscYD63ww3sPcvxVQ,10152
-kubernator/plugins/template.py,sha256=o6UqLw1wK91gCfN7q-Wwc3P5iycAeELUryXh-egA2vQ,8070
-kubernator/plugins/terraform.py,sha256=a1MPl9G8Rznjd28uMRdYWrjpFDLlFAVmLFH4hFEsMsQ,5285
-kubernator/plugins/terragrunt.py,sha256=-qN8tTqPUXJ9O7CEiJVUB0GSUQU3DUTkv-aWdIIsm7Q,5051
-kubernator-1.0.11.dist-info/METADATA,sha256=mCyyX7mv3-pOIT_eofB9PG5ksf6VifM6B-W7M4TkNRI,10478
-kubernator-1.0.11.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-kubernator-1.0.11.dist-info/entry_points.txt,sha256=IWDtHzyTleRqDSuVRXEr5GImrI7z_kh21t5DWZ8ldcQ,47
-kubernator-1.0.11.dist-info/namespace_packages.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-kubernator-1.0.11.dist-info/top_level.txt,sha256=_z1CxWeKMI55ckf2vC8HqjbCn_E2Y_P5RdrhE_QWcIs,11
-kubernator-1.0.11.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-kubernator-1.0.11.dist-info/RECORD,,