kubernator 1.0.22__py3-none-any.whl → 1.0.23__py3-none-any.whl

kubernator/__init__.py

@@ -16,7 +16,7 @@
 #   limitations under the License.
 #
 
-__version__ = "1.0.22"
+__version__ = "1.0.23"
 
 
 def _main():

kubernator/plugins/gke.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+#
+#   Copyright 2020 Express Systems USA, Inc
+#   Copyright 2025 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.
+#
+
+import logging
+import os
+import tempfile
+from pathlib import Path
+from shutil import which
+
+from kubernator.api import (KubernatorPlugin,
+                            StripNL
+                            )
+
+logger = logging.getLogger("kubernator.gke")
+proc_logger = logger.getChild("proc")
+stdout_logger = StripNL(proc_logger.info)
+stderr_logger = StripNL(proc_logger.warning)
+
+
+class GkePlugin(KubernatorPlugin):
+    logger = logger
+
+    _name = "gke"
+
+    def __init__(self):
+        self.context = None
+        self.kubeconfig_dir = tempfile.TemporaryDirectory()
+        self.name = None
+        self.region = None
+        self.project = None
+        self.gcloud_file = None
+
+        super().__init__()
+
+    def set_context(self, context):
+        self.context = context
+
+    def register(self, *, name=None, region=None, project=None):
+        context = self.context
+
+        if not name:
+            raise ValueError("`name` is required")
+        if not region:
+            raise ValueError("`region` is required")
+        if not project:
+            raise ValueError("`project` is required")
+
+        self.name = name
+        self.region = region
+        self.project = project
+
+        # Use current version
+        gcloud_file = which("gcloud")
+        if not gcloud_file:
+            raise RuntimeError("`gcloud` cannot be found")
+        logger.debug("Found gcloud in %r", gcloud_file)
+        self.gcloud_file = gcloud_file
+
+        context.app.register_plugin("kubeconfig")
+
+        context.globals.gke = dict(kubeconfig=str(Path(self.kubeconfig_dir.name) / "config"),
+                                   name=name,
+                                   region=region,
+                                   project=project,
+                                   gcloud_file=gcloud_file
+                                   )
+
+    def handle_init(self):
+        context = self.context
+
+        env = dict(os.environ)
+        env["KUBECONFIG"] = str(context.gke.kubeconfig)
+        self.context.app.run([context.gke.gcloud_file, "components", "install", "gke-gcloud-auth-plugin"],
+                             stdout_logger,
+                             stderr_logger).wait()
+        self.context.app.run([context.gke.gcloud_file, "container", "clusters", "get-credentials",
+                              context.gke.name,
+                              "--region", context.gke.region,
+                              "--project", context.gke.project],
+                             stdout_logger,
+                             stderr_logger,
+                             env=env).wait()
+
+        context.kubeconfig.set(context.gke.kubeconfig)
+
+    def handle_shutdown(self):
+        self.kubeconfig_dir.cleanup()
+
+    def __repr__(self):
+        return "GKE Plugin"

kubernator/plugins/istio.py

@@ -25,6 +25,7 @@ from pathlib import Path
 from shutil import which
 
 import yaml
+
 from kubernator.api import (KubernatorPlugin, scan_dir,
                             TemplateEngine,
                             load_remote_file,
@@ -34,6 +35,7 @@ from kubernator.api import (KubernatorPlugin, scan_dir,
                             get_golang_os,
                             get_golang_machine,
                             prepend_os_path, jp, load_file)
+from kubernator.plugins.k8s import api_exc_normalize_body, api_exc_format_body
 from kubernator.plugins.k8s_api import K8SResourcePluginMixin
 
 logger = logging.getLogger("kubernator.istio")
@@ -277,11 +279,17 @@ class IstioPlugin(KubernatorPlugin, K8SResourcePluginMixin):
         try:
             res.delete(dry_run=dry_run)
         except ApiException as e:
-            skip = False
-            if e.status == 404 and missing_ok:
-                skip = True
-            if not skip:
+            api_exc_normalize_body(e)
+            try:
+                skip = False
+                if e.status == 404 and missing_ok:
+                    skip = True
+                if not skip:
+                    raise
+            except ApiException as e:
+                api_exc_format_body(e)
                 raise
+
         return res
 
     def _create_resource_internal(self, manifest, dry_run=True, exists_ok=False):
@@ -297,12 +305,18 @@ class IstioPlugin(KubernatorPlugin, K8SResourcePluginMixin):
             res.create(dry_run=dry_run)
         except ApiException as e:
             skip = False
-            if e.status == 409:
-                status = json.loads(e.body)
-                if status["reason"] == "AlreadyExists" and exists_ok:
-                    skip = True
-            if not skip:
+            api_exc_normalize_body(e)
+            try:
+                if e.status == 409:
+                    status = e.body
+                    if status["reason"] == "AlreadyExists" and exists_ok:
+                        skip = True
+                if not skip:
+                    raise
+            except ApiException as e:
+                api_exc_format_body(e)
                 raise
+
         return res
 
     def _install(self, operators_file, dry_run):

kubernator/plugins/k8s.py

@@ -30,6 +30,7 @@ from typing import Iterable, Callable, Sequence
 
 import jsonpatch
 import yaml
+from kubernetes.client import ApiException
 
 from kubernator.api import (KubernatorPlugin,
                             Globs,
@@ -39,7 +40,8 @@ from kubernator.api import (KubernatorPlugin,
                             load_remote_file,
                             StripNL,
                             install_python_k8s_client,
-                            TemplateEngine)
+                            TemplateEngine,
+                            sleep)
 from kubernator.merge import extract_merge_instructions, apply_merge_instructions
 from kubernator.plugins.k8s_api import (K8SResourcePluginMixin,
                                         K8SResource,
@@ -82,6 +84,21 @@ def normalize_pkg_version(v: str):
     return tuple(map(int, v_split))
 
 
+def api_exc_normalize_body(e: "ApiException"):
+    if e.headers and "content-type" in e.headers:
+        content_type = e.headers["content-type"]
+        if content_type == "application/json" or content_type.endswith("+json"):
+            e.body = json.loads(e.body)
+        elif (content_type in ("application/yaml", "application/x-yaml", "text/yaml",
+                               "text/x-yaml") or content_type.endswith("+yaml")):
+            e.body = yaml.safe_load(e.body)
+
+
+def api_exc_format_body(e: ApiException):
+    if not isinstance(e.body, (str, bytes)):
+        e.body = json.dumps(e.body, indent=4)
+
+
 class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
     logger = logger
 
@@ -120,6 +137,8 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                                                       ("apps", "StatefulSet"): K8SPropagationPolicy.ORPHAN,
                                                       ("apps", "Deployment"): K8SPropagationPolicy.ORPHAN,
                                                       ("storage.k8s.io", "StorageClass"): K8SPropagationPolicy.ORPHAN,
+                                                      (None, "Pod"): K8SPropagationPolicy.BACKGROUND,
+                                                      ("batch", "Job"): K8SPropagationPolicy.ORPHAN,
                                                       },
                                    default_includes=Globs(["*.yaml", "*.yml"], True),
                                    default_excludes=Globs([".*"], True),
@@ -137,6 +156,7 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                                    field_validation=field_validation,
                                    field_validation_warn_fatal=field_validation_warn_fatal,
                                    field_validation_warnings=0,
+                                   conflict_retry_delay=0.3,
                                    _k8s=self,
                                    )
         context.k8s = dict(default_includes=Globs(context.globals.k8s.default_includes),
@@ -199,7 +219,7 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
 
         k8s.client = self._setup_k8s_client()
         version = client.VersionApi(k8s.client).get_code()
-        if "-eks-" in version.git_version:
+        if "-eks-" or "-gke" in version.git_version:
             git_version = version.git_version.split("-")[0]
         else:
             git_version = version.git_version
@@ -409,8 +429,8 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
 
         def handle_400_strict_validation_error(e: ApiException):
             if e.status == 400:
-                status = json.loads(e.body)
-
+                # Assumes the body has been parsed
+                status = e.body
                 if status["status"] == "Failure":
                     if FIELD_VALIDATION_STRICT_MARKER in status["message"]:
                         message = status["message"]
@@ -425,18 +445,31 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                                      resource, resource.source, status["message"])
                         raise e from None
 
-        def create(exists_ok=False):
+        def create(exists_ok=False, wait_for_delete=False):
             logger.info("Creating resource %s%s%s", resource, status_msg,
                         " (ignoring existing)" if exists_ok else "")
-            try:
-                create_func()
-            except ApiException as e:
-                if exists_ok:
-                    if e.status == 409:
-                        status = json.loads(e.body)
-                        if status["reason"] == "AlreadyExists":
-                            return
-                raise
+            while True:
+                try:
+                    create_func()
+                    return
+                except ApiException as __e:
+                    api_exc_normalize_body(__e)
+                    try:
+                        if exists_ok or wait_for_delete:
+                            if __e.status == 409:
+                                status = __e.body
+                                if status["reason"] == "AlreadyExists":
+                                    if wait_for_delete:
+                                        sleep(self.context.k8s.conflict_retry_delay)
+                                        logger.info("Retry creating resource %s%s%s", resource, status_msg,
+                                                    " (ignoring existing)" if exists_ok else "")
+                                        continue
+                                    else:
+                                        return
+                        raise
+                    except ApiException as ___e:
+                        api_exc_format_body(___e)
+                        raise
 
         merge_instrs, normalized_manifest = extract_merge_instructions(resource.manifest, resource)
         if merge_instrs:
@@ -450,15 +483,20 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
             remote_resource = resource.get()
             logger.trace("Current resource %s: %s", resource, remote_resource)
         except ApiException as e:
-            if e.status == 404:
-                try:
-                    create()
-                    return 1, 0, 0
-                except ApiException as e:
-                    if not handle_400_strict_validation_error(e):
-                        raise
-
-            else:
+            api_exc_normalize_body(e)
+            try:
+                if e.status == 404:
+                    try:
+                        create()
+                        return 1, 0, 0
+                    except ApiException as e:
+                        api_exc_normalize_body(e)
+                        if not handle_400_strict_validation_error(e):
+                            raise
+                else:
+                    raise
+            except ApiException as _e:
+                api_exc_format_body(_e)
                 raise
         else:
             logger.trace("Attempting to retrieve a normalized patch for resource %s: %s", resource, normalized_manifest)
@@ -468,34 +506,44 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                                                  dry_run=True,
                                                  force=True)
             except ApiException as e:
-                if e.status == 422:
-                    status = json.loads(e.body)
-                    details = status["details"]
-                    immutable_key = details["group"], details["kind"]
-
-                    try:
-                        propagation_policy = self.context.k8s.immutable_changes[immutable_key]
-                    except KeyError:
-                        raise e from None
+                try:
+                    api_exc_normalize_body(e)
+
+                    if e.status == 422:
+                        status = e.body
+                        # Assumes the body has been unmarshalled
+                        details = status["details"]
+                        immutable_key = details.get("group"), details["kind"]
+
+                        try:
+                            propagation_policy = self.context.k8s.immutable_changes[immutable_key]
+                        except KeyError:
+                            raise e from None
+                        else:
+                            for cause in details["causes"]:
+                                if (
+                                        cause["reason"] == "FieldValueInvalid" and
+                                        "field is immutable" in cause["message"]
+                                        or
+                                        cause["reason"] == "FieldValueForbidden" and
+                                        ("Forbidden: updates to" in cause["message"]
+                                         or
+                                         "Forbidden: pod updates" in cause["message"])
+                                ):
+                                    logger.info("Deleting resource %s (cascade %s)%s", resource,
+                                                propagation_policy.policy,
+                                                status_msg)
+                                    delete_func(propagation_policy=propagation_policy)
+                                    create(exists_ok=dry_run, wait_for_delete=not dry_run)
+                                    return 1, 0, 1
+                            raise
                     else:
-                        for cause in details["causes"]:
-                            if (
-                                    cause["reason"] == "FieldValueInvalid" and
-                                    "field is immutable" in cause["message"]
-                                    or
-                                    cause["reason"] == "FieldValueForbidden" and
-                                    "Forbidden: updates to" in cause["message"]
-                            ):
-                                logger.info("Deleting resource %s (cascade %s)%s", resource,
-                                            propagation_policy.policy,
-                                            status_msg)
-                                delete_func(propagation_policy=propagation_policy)
-                                create(exists_ok=dry_run)
-                                return 1, 0, 1
-                        raise
-                else:
-                    if not handle_400_strict_validation_error(e):
-                        raise
+                        if not handle_400_strict_validation_error(e):
+                            raise
+                except ApiException as _e:
+                    api_exc_format_body(_e)
+                    raise
+
             else:
                 logger.trace("Merged resource %s: %s", resource, merged_resource)
                 if merge_instrs:

kubernator/plugins/k8s_api.py

@@ -116,22 +116,22 @@ k8s_format_checker = FormatChecker()
 
 @k8s_format_checker.checks("int32")
 def check_int32(value):
-    return -2147483648 < value < 2147483647
+    return value is not None and (-2147483648 < value < 2147483647)
 
 
 @k8s_format_checker.checks("int64")
 def check_int64(value):
-    return -9223372036854775808 < value < 9223372036854775807
+    return value is not None and (-9223372036854775808 < value < 9223372036854775807)
 
 
 @k8s_format_checker.checks("float")
 def check_float(value):
-    return -3.4E+38 < value < +3.4E+38
+    return value is not None and (-3.4E+38 < value < +3.4E+38)
 
 
 @k8s_format_checker.checks("double")
 def check_double(value):
-    return -1.7E+308 < value < +1.7E+308
+    return value is not None and (-1.7E+308 < value < +1.7E+308)
 
 
 @k8s_format_checker.checks("byte", ValueError)
@@ -619,9 +619,9 @@ class K8SResourcePluginMixin:
         errors = list(self._validate_resource(manifest, source))
         if errors:
             for error in errors:
-                if source:
-                    self.logger.error("Error detected in K8S manifest %s from %s",
-                                      resource_description, source, exc_info=error)
+                self.logger.error("Error detected in K8S manifest %s from %s: \n%s",
+                                  resource_description, source or "<unknown>", yaml.safe_dump(manifest, None),
+                                  exc_info=error)
             raise errors[0]
 
         rdef = self._get_manifest_rdef(manifest)

kubernator/plugins/kubectl.py

@@ -16,6 +16,7 @@
 #   limitations under the License.
 #
 
+import io
 import json
 import logging
 import os
@@ -23,6 +24,8 @@ import tempfile
 from pathlib import Path
 from shutil import which, copy
 
+import yaml
+
 from kubernator.api import (KubernatorPlugin,
                             prepend_os_path,
                             StripNL,
@@ -89,15 +92,44 @@ class KubectlPlugin(KubernatorPlugin):
         context.globals.kubectl = dict(version=version,
                                        kubectl_file=kubectl_file,
                                        stanza=self.stanza,
-                                       test=self.test_kubectl
+                                       test=self.test_kubectl,
+                                       run=self.run,
+                                       run_capturing=self.run_capturing,
+                                       get=self.get,
                                        )
 
         context.globals.kubectl.version = context.kubectl.test()
 
+    def run_capturing(self, *args, **kwargs):
+        return self.context.app.run_capturing_out(self.stanza() +
+                                                  list(args),
+                                                  stderr_logger,
+                                                  **kwargs
+                                                  )
+
+    def run(self, *args, **kwargs):
+        self.context.app.run(self.stanza() +
+                             list(args),
+                             stdout_logger,
+                             stderr_logger,
+                             **kwargs
+                             ).wait()
+
+    def get(self, resource_type, resource_name, namespace=None):
+        args = ["get", resource_type, resource_name]
+        if namespace:
+            args += ["-n", namespace]
+        args += ["-o", "yaml"]
+
+        res = list(yaml.safe_load_all(io.StringIO(self.context.kubectl.run_capturing(*args))))
+        if len(res):
+            if len(res) > 1:
+                return res
+            return res[0]
+        return None
+
     def test_kubectl(self):
-        version_out: str = self.context.app.run_capturing_out(self.stanza() +
-                                                              ["version", "--client=true", "-o", "json"],
-                                                              stderr_logger)
+        version_out: str = self.run_capturing("version", "--client=true", "-o", "json")
 
         version_out_js = json.loads(version_out)
         kubectl_version = version_out_js["clientVersion"]["gitVersion"][1:]

kubernator/plugins/minikube.py

@@ -15,7 +15,7 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 #
-
+import json
 import logging
 import os
 import tempfile
@@ -91,7 +91,7 @@ class MinikubePlugin(KubernatorPlugin):
 
     def register(self, minikube_version=None, profile="default", k8s_version=None,
                  keep_running=False, start_fresh=False,
-                 nodes=1, driver=None, cpus="no-limit", extra_args=None):
+                 nodes=1, driver=None, cpus="no-limit", extra_args=None, extra_addons=None):
         context = self.context
 
         context.app.register_plugin("kubeconfig")
@@ -166,12 +166,14 @@ class MinikubePlugin(KubernatorPlugin):
                                         minikube_file=str(minikube_file),
                                         profile=profile,
                                         k8s_version=k8s_version,
+                                        k8s_version_tuple=k8s_version_tuple,
                                         start_fresh=start_fresh,
                                         keep_running=keep_running,
                                         nodes=nodes,
                                         driver=driver,
                                         cpus=cpus,
                                         extra_args=extra_args or [],
+                                        extra_addons=extra_addons or [],
                                         kubeconfig=str(self.kubeconfig_dir / "config"),
                                         cmd=self.cmd,
                                         cmd_out=self.cmd_out
@@ -202,6 +204,16 @@ class MinikubePlugin(KubernatorPlugin):
                     "--wait", "apiserver",
                     "--nodes", str(minikube.nodes)]
 
+            addons = []
+            if minikube.k8s_version_tuple >= (1, 28):
+                addons += ["volumesnapshots", "csi-hostpath-driver"]
+
+            if minikube.extra_addons:
+                addons += minikube.extra_addons
+
+            if addons:
+                args += ["--addons", ",".join(addons)]
+
             if minikube.driver == "docker":
                 args.extend(["--cpus", str(minikube.cpus)])
 
@@ -212,6 +224,24 @@ class MinikubePlugin(KubernatorPlugin):
         logger.info("Updating minikube profile %r context", minikube.profile)
         self.cmd("update-context")
 
+        if minikube.k8s_version_tuple >= (1, 28):
+            logger.info("Disabling old storage addons")
+            self.cmd("addons", "disable", "storage-provisioner")
+            self.cmd("addons", "disable", "default-storageclass")
+
+        logger.info("Running initialization scripts for profile %r", minikube.profile)
+        self.context.app.register_plugin("kubectl", version=minikube.k8s_version)
+        if minikube.k8s_version_tuple >= (1, 28):
+            storage_class = self.context.kubectl.get("storageclass", "csi-hostpath-sc")
+            self.context.kubectl.run("delete", "storageclass", "csi-hostpath-sc")
+            storage_class["metadata"]["annotations"]["storageclass.kubernetes.io/is-default-class"] = "true"
+            storage_class["volumeBindingMode"] = "WaitForFirstConsumer"
+
+            def write_stdin():
+                return json.dumps(storage_class)
+
+            self.context.kubectl.run("create", "-f", "-", stdin=write_stdin)
+
     def minikube_stop(self):
         minikube = self.context.minikube
         if self.minikube_is_running():

{kubernator-1.0.22.dist-info → kubernator-1.0.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kubernator
-Version: 1.0.22
+Version: 1.0.23
 Summary: Kubernator is the a pluggable framework for K8S provisioning
 Home-page: https://github.com/karellen/kubernator
 Author: Express Systems USA, Inc.

{kubernator-1.0.22.dist-info → kubernator-1.0.23.dist-info}/RECORD

@@ -1,5 +1,5 @@
 kubernator/LICENSE,sha256=wKKdOCMTCPQRV5gDkVLAsXX8qSnRJ5owk7yWPO1KZNo,11387
-kubernator/__init__.py,sha256=2Ip--l-XtVX9778fc9qar47xy5S1vx8WGZt0Qtar-jQ,915
+kubernator/__init__.py,sha256=jOpQxAOrrl0lyLUkXRk6PqxxzgdZ65LU8QCBcYQthFc,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
@@ -10,21 +10,22 @@ kubernator/proc.py,sha256=43jrpTe1FCdhDIK0b6hnB6XqU_m7iYu3wbzJyzO3pl0,5979
 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/gke.py,sha256=HZc-Bu2W8MvF50EgoAcZ8W-CAVEWJ4y8f4yG_3s8C1w,3429
 kubernator/plugins/helm.py,sha256=2563hLr0uJucw0xo9JLfbCtpGPRZ5e5gYTnapQrqy3w,12036
-kubernator/plugins/istio.py,sha256=1dHjD9r6Kk2-tw6OFMOfBpksnqGMguTyyF1FwwWEtI8,14977
-kubernator/plugins/k8s.py,sha256=XIHqFpdbRL57dnbgOonRD3Mxs9LVSUxQT-GPnpEyZyM,24762
-kubernator/plugins/k8s_api.py,sha256=PDa7MB9q3WMm_9tr8T6LY_ojrHpyGYiNTlvBZinbgFY,27379
+kubernator/plugins/istio.py,sha256=UFSBJo-I2x4F-ZO5WCSMpConOr_oYNZZb66DNOI_nME,15399
+kubernator/plugins/k8s.py,sha256=A2qSOjkPasgBEc1Le2UXuSKTItd0Qz63E6Vv8WVQ0hQ,27307
+kubernator/plugins/k8s_api.py,sha256=IkiegYwHJUasH5BlBxLo2_064cuzOGr3OJ1ToGy1p-s,27527
 kubernator/plugins/kops.py,sha256=-yhpEjydz9E7Ep24WtEs93rLTXtw4yakdgVqXlIj1ww,9688
 kubernator/plugins/kubeconfig.py,sha256=uwtHmF2I6LiTPrC3M88G5SfYxDWtuh0MqcMfrHHoNRA,2178
-kubernator/plugins/kubectl.py,sha256=IgNghW1Q6s8V2o08eNY2NWfkkdV9Z6X2A3YFQinFr4g,4028
-kubernator/plugins/minikube.py,sha256=V7nf6YRi-NRIGMTuf4JvrIUFCQXyjBs3kTBjAk5NDDw,10922
+kubernator/plugins/kubectl.py,sha256=hV6rnTj0XmQe5QJp3p6fNK3EQrWdNlam0qxsK3IkD5g,5125
+kubernator/plugins/minikube.py,sha256=zbboER1VsCvIsh-yUE3_XpzPNcT4c6vh1LigDonEm3U,12384
 kubernator/plugins/template.py,sha256=542nyS4ZNgdwJHEoIA5aLP1d4C312ydd7sPM9ZFbHuI,8357
 kubernator/plugins/terraform.py,sha256=a1MPl9G8Rznjd28uMRdYWrjpFDLlFAVmLFH4hFEsMsQ,5285
 kubernator/plugins/terragrunt.py,sha256=-qN8tTqPUXJ9O7CEiJVUB0GSUQU3DUTkv-aWdIIsm7Q,5051
-kubernator-1.0.22.dist-info/METADATA,sha256=CnePh_LaJAjBca5EBd87AUv6Tkyj7SiqTKy2US_rNrA,10822
-kubernator-1.0.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kubernator-1.0.22.dist-info/entry_points.txt,sha256=IWDtHzyTleRqDSuVRXEr5GImrI7z_kh21t5DWZ8ldcQ,47
-kubernator-1.0.22.dist-info/namespace_packages.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-kubernator-1.0.22.dist-info/top_level.txt,sha256=_z1CxWeKMI55ckf2vC8HqjbCn_E2Y_P5RdrhE_QWcIs,11
-kubernator-1.0.22.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-kubernator-1.0.22.dist-info/RECORD,,
+kubernator-1.0.23.dist-info/METADATA,sha256=YW6ZY4aeqPYs-2EzsWTazp0PnC4LC6rj8ykZ7KB8sjc,10822
+kubernator-1.0.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kubernator-1.0.23.dist-info/entry_points.txt,sha256=IWDtHzyTleRqDSuVRXEr5GImrI7z_kh21t5DWZ8ldcQ,47
+kubernator-1.0.23.dist-info/namespace_packages.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+kubernator-1.0.23.dist-info/top_level.txt,sha256=_z1CxWeKMI55ckf2vC8HqjbCn_E2Y_P5RdrhE_QWcIs,11
+kubernator-1.0.23.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+kubernator-1.0.23.dist-info/RECORD,,