kubernator 1.0.5__tar.gz → 1.0.6__tar.gz

{kubernator-1.0.5 → kubernator-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kubernator
-Version: 1.0.5
+Version: 1.0.6
 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.5 → kubernator-1.0.6}/kubernator/__init__.py

@@ -16,12 +16,12 @@
 #   limitations under the License.
 #
 
-__version__ = "1.0.5"
+__version__ = "1.0.6"
 
 
 def _main():
     from kubernator import app
-    return app.main()
+    return app.main() or 0
 
 
 def main():

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/api.py

@@ -152,8 +152,12 @@ def _download_remote_file(url, file_name, cache: dict):
             return dict(r.headers)
 
 
+def get_app_cache_dir():
+    return Path(user_config_dir("kubernator"))
+
+
 def get_cache_dir(category: str, sub_category: str = None):
-    config_dir = Path(user_config_dir("kubernator")) / category
+    config_dir = get_app_cache_dir() / category
     if sub_category:
         config_dir = config_dir / sub_category
     if not config_dir.exists():
@@ -224,6 +228,19 @@ 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(["pip", "install", "--no-deps", "--no-cache-dir", "--no-input", "--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):

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/app.py

@@ -26,11 +26,13 @@ import urllib.parse
 from collections import deque
 from collections.abc import MutableMapping, Callable
 from pathlib import Path
+from shutil import rmtree
 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)
+                            download_remote_file, load_remote_file, Repository, StripNL, jp, get_app_cache_dir,
+                            install_python_k8s_client)
 from kubernator.proc import run, run_capturing_out
 
 TRACE = 5
@@ -55,10 +57,16 @@ logger = logging.getLogger("kubernator")
 
 
 def define_arg_parse():
-    parser = argparse.ArgumentParser(description="Kubernetes Provisioning Tool",
+    parser = argparse.ArgumentParser(prog="kubernator",
+                                     description="Kubernetes Provisioning Tool",
                                      formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument("--version", action="version", version=kubernator.__version__,
-                        help="print version and exit")
+    g = parser.add_mutually_exclusive_group()
+    g.add_argument("--version", action="version", version=kubernator.__version__,
+                   help="print version and exit")
+    g.add_argument("--clear-cache", action="store_true",
+                   help="clear 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")
     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,
@@ -158,47 +166,50 @@ class App(KubernatorPlugin):
 
         self.register_plugin(self)
 
-        while True:
-            cwd = self.next()
-            if not cwd:
-                logger.debug("No paths left to traverse")
-                break
+        try:
+            while True:
+                cwd = self.next()
+                if not cwd:
+                    logger.debug("No paths left to traverse")
+                    break
 
-            context = self.context
-
-            logger.debug("Inspecting directory %s", self._display_path(cwd))
-            self._run_handlers(KubernatorPlugin.handle_before_dir, False, context, None, cwd)
+                context = self.context
 
-            if (ktor_py := (cwd / ".kubernator.py")).exists():
-                self._run_handlers(KubernatorPlugin.handle_before_script, False, context, None, cwd)
+                logger.debug("Inspecting directory %s", self._display_path(cwd))
+                self._run_handlers(KubernatorPlugin.handle_before_dir, False, context, None, cwd)
 
-                for h in self.context._plugins:
-                    h.set_context(context)
+                if (ktor_py := (cwd / ".kubernator.py")).exists():
+                    self._run_handlers(KubernatorPlugin.handle_before_script, False, context, None, cwd)
 
-                self._exec_ktor(ktor_py)
+                    for h in self.context._plugins:
+                        h.set_context(context)
 
-                for h in self.context._plugins:
-                    h.set_context(None)
+                    self._exec_ktor(ktor_py)
 
-                self._run_handlers(KubernatorPlugin.handle_after_script, True, context, None, cwd)
+                    for h in self.context._plugins:
+                        h.set_context(None)
 
-            self._run_handlers(KubernatorPlugin.handle_after_dir, True, context, None, cwd)
+                    self._run_handlers(KubernatorPlugin.handle_after_script, True, context, None, cwd)
 
-        self.context = self._top_dir_context
-        context = self.context
+                self._run_handlers(KubernatorPlugin.handle_after_dir, True, context, None, cwd)
 
-        self._run_handlers(KubernatorPlugin.handle_apply, True, context, None)
+            self.context = self._top_dir_context
+            context = self.context
 
-        self._run_handlers(KubernatorPlugin.handle_verify, True, context, None)
+            self._run_handlers(KubernatorPlugin.handle_apply, True, context, None)
 
-        self._run_handlers(KubernatorPlugin.handle_shutdown, True, context, None)
+            self._run_handlers(KubernatorPlugin.handle_verify, True, context, None)
+        finally:
+            self.context = self._top_dir_context
+            context = self.context
+            self._run_handlers(KubernatorPlugin.handle_shutdown, True, context, None)
 
     def discover_plugins(self):
         importlib.invalidate_caches()
         search_path = Path(kubernator.__path__[0], "plugins")
         [importlib.import_module(name)
          for finder, name, is_pkg in
-         pkgutil.iter_modules([search_path], "kubernator.plugins.")]
+         pkgutil.iter_modules([str(search_path)], "kubernator.plugins.")]
 
         for plugin in KubernatorPlugin.__subclasses__():
             if plugin._name in self._plugin_types:
@@ -440,11 +451,36 @@ class App(KubernatorPlugin):
         return "Kubernator"
 
 
+def clear_cache():
+    cache_dir = get_app_cache_dir()
+    logger.info("Clearing application cache at %s", cache_dir)
+    if cache_dir.exists():
+        rmtree(cache_dir)
+
+
+def pre_cache_k8s_clients(*versions):
+    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)
+
+
 def main():
     args = define_arg_parse().parse_args()
     init_logging(args.verbose, args.log_format, args.log_file)
 
     try:
+        if args.clear_cache:
+            clear_cache()
+            return
+
+        if args.pre_cache_k8s_client:
+            pre_cache_k8s_clients(*args.pre_cache_k8s_client)
+            return
+
         with App(args) as app:
             app.run()
     except SystemExit as e:

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/plugins/awscli.py

@@ -54,7 +54,7 @@ class AwsCliPlugin(KubernatorPlugin):
     def set_context(self, context):
         self.context = context
 
-    def cmd(self, *args, output="json", region=None):
+    def stanza(self, *args, output="json", region=None):
         context = self.context
         stanza = [context.awscli.aws_file, "--output", output]
         if region:
@@ -112,7 +112,7 @@ class AwsCliPlugin(KubernatorPlugin):
 
         context.globals.awscli = dict(version=version,
                                       aws_file=self.aws_file,
-                                      cmd=self.cmd
+                                      stanza=self.stanza
                                       )
 
     def __repr__(self):

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/plugins/eks.py

@@ -64,7 +64,7 @@ class EksPlugin(KubernatorPlugin):
     def handle_init(self):
         context = self.context
 
-        self.context.app.run(context.awscli.cmd(
+        self.context.app.run(context.awscli.stanza(
             "eks", "update-kubeconfig", "--name", self.name, "--kubeconfig", context.eks.kubeconfig,
             region=self.region),
             stdout_logger,

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/plugins/helm.py

@@ -106,7 +106,7 @@ class HelmPlugin(KubernatorPlugin):
     def set_context(self, context):
         self.context = context
 
-    def helm_stanza(self):
+    def stanza(self):
         context = self.context
         stanza = [context.helm.helm_file, f"--kubeconfig={context.kubeconfig.kubeconfig}"]
         if logger.getEffectiveLevel() < logging.INFO:
@@ -145,13 +145,13 @@ class HelmPlugin(KubernatorPlugin):
                                     default_excludes=Globs([".*"], True),
                                     namespace_transformer=True,
                                     helm_file=helm_file,
-                                    helm_stanza=self.helm_stanza,
+                                    stanza=self.stanza,
                                     add_helm_template=self.add_helm_template,
                                     add_helm=self.add_helm,
                                     )
 
     def handle_init(self):
-        version = self.context.app.run_capturing_out(self.helm_stanza() + ["version", "--template", "{{.Version}}"],
+        version = self.context.app.run_capturing_out(self.stanza() + ["version", "--template", "{{.Version}}"],
                                                      logger.error)
         logger.info("Found Helm version %s", version)
 
@@ -204,10 +204,10 @@ class HelmPlugin(KubernatorPlugin):
         logger.debug("Repository %s mapping to %s", repository, repository_hash)
         if repository_hash not in self.repositories:
             logger.info("Adding and updating repository %s mapping to %s", repository, repository_hash)
-            self.context.app.run(self.helm_stanza() + ["repo", "add", repository_hash, repository],
+            self.context.app.run(self.stanza() + ["repo", "add", repository_hash, repository],
                                  stdout_logger,
                                  stderr_logger).wait()
-            self.context.app.run(self.helm_stanza() + ["repo", "update"],
+            self.context.app.run(self.stanza() + ["repo", "update"],
                                  stdout_logger,
                                  stderr_logger).wait()
             self.repositories.add(repository_hash)
@@ -233,7 +233,7 @@ class HelmPlugin(KubernatorPlugin):
 
             stdin = write_stdin
 
-        resources = self.context.app.run_capturing_out(self.helm_stanza() +
+        resources = self.context.app.run_capturing_out(self.stanza() +
                                                        ["template",
                                                         name,
                                                         f"{repository_hash}/{chart}",

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/plugins/istio.py

@@ -90,19 +90,19 @@ class IstioPlugin(KubernatorPlugin, K8SResourcePluginMixin):
             default_includes=Globs(["*.istio.yaml", "*.istio.yml"], True),
             default_excludes=Globs([".*"], True),
             istioctl_file=istioctl_file,
-            istioctl_stanza=self.istioctl_stanza,
+            stanza=self.stanza,
             test=self.test_istioctl
         )
 
     def test_istioctl(self):
         context = self.context
-        version_out: str = context.app.run_capturing_out(context.istio.istioctl_stanza() + ["version", "-o", "json"],
+        version_out: str = context.app.run_capturing_out(context.istio.stanza() + ["version", "-o", "json"],
                                                          stderr_logger)
 
         version_out_js = json.loads(version_out)
         version = version_out_js["clientVersion"]["version"]
         logger.info("Using istioctl %r version %r with stanza %r",
-                    self.context.istio.istioctl_file, version, context.istio.istioctl_stanza())
+                    self.context.istio.istioctl_file, version, context.istio.stanza())
 
         logger.info("Found Istio client version %s", version)
 
@@ -111,7 +111,7 @@ class IstioPlugin(KubernatorPlugin, K8SResourcePluginMixin):
     def set_context(self, context):
         self.context = context
 
-    def istioctl_stanza(self):
+    def stanza(self):
         context = self.context.istio
         return [context.istioctl_file, f"--kubeconfig={self.context.kubeconfig.kubeconfig}"]
 
@@ -145,7 +145,8 @@ class IstioPlugin(KubernatorPlugin, K8SResourcePluginMixin):
         # This plugin only deals with Istio Operator, so only load that stuff
         self.resource_definitions_schema = load_remote_file(logger,
                                                             f"https://raw.githubusercontent.com/kubernetes/kubernetes/"
-                                                            f"{self.context.k8s.server_version}/api/openapi-spec/swagger.json",
+                                                            f"{self.context.k8s.server_git_version}"
+                                                            f"/api/openapi-spec/swagger.json",
                                                             FileType.JSON)
         self._populate_resource_definitions()
         self.add_remote_crds(f"{url_prefix}/crd-operator.yaml", FileType.YAML)
@@ -188,9 +189,9 @@ class IstioPlugin(KubernatorPlugin, K8SResourcePluginMixin):
 
             if context.app.args.command == "apply":
                 logger.info("Running Istio precheck")
-                context.app.run(context.istio.istioctl_stanza() + ["x", "precheck"],
+                context.app.run(context.istio.stanza() + ["x", "precheck"],
                                 stdout_logger, stderr_logger).wait()
-                context.app.run(context.istio.istioctl_stanza() + ["validate", "-f", operators_file.name],
+                context.app.run(context.istio.stanza() + ["validate", "-f", operators_file.name],
                                 stdout_logger, stderr_logger).wait()
 
                 self._operator_init(operators_file, True)
@@ -229,7 +230,7 @@ class IstioPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                 raise
 
         logger.info("Running Istio operator init%s", status_details)
-        istio_operator_init = context.istio.istioctl_stanza() + ["operator", "init", "-f", operators_file.name]
+        istio_operator_init = context.istio.stanza() + ["operator", "init", "-f", operators_file.name]
         context.app.run(istio_operator_init + (["--dry-run"] if dry_run else []),
                         stdout_logger,
                         stderr_logger).wait()

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/plugins/k8s.py

@@ -24,19 +24,30 @@ import sys
 import types
 from collections.abc import Mapping
 from functools import partial
+from importlib.metadata import version as pkg_version
 from pathlib import Path
 from typing import Iterable, Callable, Sequence
 
 import jsonpatch
 import yaml
 
-from kubernator.api import (KubernatorPlugin, Globs, scan_dir, load_file, FileType, load_remote_file)
+from kubernator.api import (KubernatorPlugin,
+                            Globs,
+                            scan_dir,
+                            load_file,
+                            FileType,
+                            load_remote_file,
+                            StripNL,
+                            install_python_k8s_client)
 from kubernator.plugins.k8s_api import (K8SResourcePluginMixin,
                                         K8SResource,
                                         K8SResourcePatchType,
                                         K8SPropagationPolicy)
 
 logger = logging.getLogger("kubernator.k8s")
+proc_logger = logger.getChild("proc")
+stdout_logger = StripNL(proc_logger.info)
+stderr_logger = StripNL(proc_logger.warning)
 
 
 def final_resource_validator(resources: Sequence[K8SResource],
@@ -62,6 +73,8 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
         super().__init__()
         self.context = None
 
+        self.embedded_pkg_version = self._get_kubernetes_client_version()
+
         self._transformers = []
         self._validators = []
 
@@ -109,30 +122,64 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
     def _kubeconfig_changed(self):
         self.setup_client()
 
+    def _get_kubernetes_client_version(self):
+        return pkg_version("kubernetes").split(".")
+
     def setup_client(self):
+        k8s = self.context.k8s
+        if "server_version" not in k8s:
+            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.debug("Reading Kubernetes OpenAPI spec for %s", k8s.server_git_version)
+
+        k8s_def = load_remote_file(logger, f"https://raw.githubusercontent.com/kubernetes/kubernetes/"
+                                           f"{k8s.server_git_version}/api/openapi-spec/swagger.json",
+                                   FileType.JSON)
+        self.resource_definitions_schema = k8s_def
+
+        self._populate_resource_definitions()
+
+    def _setup_client(self):
         from kubernetes import client
 
         context = self.context
+        k8s = context.k8s
 
-        context.k8s.client = self._setup_k8s_client()
-        version = client.VersionApi(context.k8s.client).get_code()
+        k8s.client = self._setup_k8s_client()
+        version = client.VersionApi(k8s.client).get_code()
         if "-eks-" in version.git_version:
             git_version = version.git_version.split("-")[0]
         else:
             git_version = version.git_version
 
-        context.k8s.server_version = git_version
-
-        logger.info("Found Kubernetes %s on %s", version.git_version, context.k8s.client.configuration.host)
+        k8s.server_version = git_version[1:].split(".")
+        k8s.server_git_version = git_version
 
-        logger.debug("Reading Kubernetes OpenAPI spec for version %s", git_version)
-
-        k8s_def = load_remote_file(logger, f"https://raw.githubusercontent.com/kubernetes/kubernetes/"
-                                           f"{git_version}/api/openapi-spec/swagger.json",
-                                   FileType.JSON)
-        self.resource_definitions_schema = k8s_def
-
-        self._populate_resource_definitions()
+        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(".")))
 
     def handle_before_dir(self, cwd: Path):
         context = self.context

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/plugins/k8s_api.py

@@ -337,6 +337,8 @@ class K8SResourceKey(namedtuple("K8SResourceKey", ["group", "kind", "name", "nam
 
 
 class K8SResource:
+    _k8s_client_version = None
+
     def __init__(self, manifest: dict, rdef: K8SResourceDef, source: Union[str, Path] = None):
         self.key = self.get_manifest_key(manifest)
 
@@ -413,7 +415,7 @@ class K8SResource:
         rdef = self.rdef
         kwargs = {"name": self.name,
                   "body": json_patch
-                  if patch_type != K8SResourcePatchType.SERVER_SIDE_PATCH
+                  if patch_type != K8SResourcePatchType.SERVER_SIDE_PATCH or self._k8s_client_version[0] > 24
                   else json.dumps(json_patch),
                   "_preload_content": False,
                   "field_manager": "kubernator",

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/plugins/kubectl.py

@@ -49,7 +49,7 @@ class KubectlPlugin(KubernatorPlugin):
     def set_context(self, context):
         self.context = context
 
-    def kubectl_stanza(self):
+    def stanza(self):
         context = self.context.kubectl
         return [context.kubectl_file, f"--kubeconfig={context.kubeconfig}"]
 
@@ -85,14 +85,14 @@ class KubectlPlugin(KubernatorPlugin):
         context.globals.kubectl = dict(version=version,
                                        kubeconfig=kubeconfig,
                                        kubectl_file=kubectl_file,
-                                       kubectl_stanza=self.kubectl_stanza,
+                                       stanza=self.stanza,
                                        test=self.test_kubectl
                                        )
 
         context.globals.kubectl.version = context.kubectl.test()
 
     def test_kubectl(self):
-        version_out: str = self.context.app.run_capturing_out(self.kubectl_stanza() +
+        version_out: str = self.context.app.run_capturing_out(self.stanza() +
                                                               ["version", "--client=true", "-o", "json"],
                                                               stderr_logger)
 
@@ -100,7 +100,7 @@ class KubectlPlugin(KubernatorPlugin):
         kubectl_version = version_out_js["clientVersion"]["gitVersion"][1:]
 
         logger.info("Using kubectl %r version %r with stanza %r",
-                    self.context.kubectl.kubectl_file, kubectl_version, self.kubectl_stanza())
+                    self.context.kubectl.kubectl_file, kubectl_version, self.stanza())
 
         return kubectl_version
 

kubernator-1.0.6/kubernator/plugins/minikube.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+#
+#   Copyright 2020 Express Systems USA, Inc
+#   Copyright 2023 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 kubernator.api import (KubernatorPlugin,
+                            StripNL,
+                            get_golang_os,
+                            get_golang_machine,
+                            prepend_os_path,
+                            get_cache_dir,
+                            CalledProcessError
+                            )
+
+logger = logging.getLogger("kubernator.minikube")
+proc_logger = logger.getChild("proc")
+stdout_logger = StripNL(proc_logger.info)
+stderr_logger = StripNL(proc_logger.warning)
+
+
+class MinikubePlugin(KubernatorPlugin):
+    logger = logger
+
+    _name = "minikube"
+
+    def __init__(self):
+        self.context = None
+        self.minikube_dir = None
+        self.minikube_home_dir = None
+        self.kubeconfig_dir = None
+
+        super().__init__()
+
+    def set_context(self, context):
+        self.context = context
+
+    def get_latest_minikube_version(self):
+        context = self.context
+        versions = context.app.run_capturing_out(["git", "ls-remote", "-t", "--refs",
+                                                  "https://github.com/kubernetes/minikube", "v*"],
+                                                 stderr_logger)
+
+        # 06e3b0cf7999f74fc52af362b42fb21076ade64a        refs/tags/v1.9.1
+        # "refs/tags/v1.9.1"
+        # "1.9.1"
+        # ("1","9","1")
+        # (1, 9, 1)
+        # sort and get latest, which is the last/highest
+        # "v1.9.1"
+        return (".".join(map(str, sorted(list(map(lambda v: tuple(map(int, v)),
+                                                  filter(lambda v: len(v) == 3,
+                                                         map(lambda line: line.split()[1][11:].split("."),
+                                                             versions.splitlines(False))))))[-1])))
+
+    def cmd(self, *extra_args):
+        stanza, env = self._stanza(list(extra_args))
+        return self.context.app.run(stanza, stdout_logger, stderr_logger, env=env).wait()
+
+    def cmd_out(self, *extra_args):
+        stanza, env = self._stanza(list(extra_args))
+        return self.context.app.run_capturing_out(stanza, stderr_logger, env=env)
+
+    def _stanza(self, extra_args):
+        context = self.context
+        minikube = context.minikube
+        stanza = [context.minikube.minikube_file, "-p", f"minikube-{minikube.profile}"] + extra_args
+        env = dict(os.environ)
+        env["MINIKUBE_HOME"] = str(self.minikube_home_dir)
+        env["KUBECONFIG"] = str(minikube.kubeconfig)
+        return stanza, env
+
+    def register(self, minikube_version=None, profile="default", k8s_version=None,
+                 keep_running=False, start_fresh=False,
+                 nodes=1, driver="docker", cpus="no-limit", extra_args=None):
+        context = self.context
+
+        context.app.register_plugin("kubeconfig")
+
+        if not k8s_version:
+            msg = "No Kubernetes version is specified for Minikube"
+            logger.critical(msg)
+            raise RuntimeError(msg)
+
+        if not minikube_version:
+            minikube_version = self.get_latest_minikube_version()
+            logger.info("No minikube version is specified, latest is %s", minikube_version)
+
+        minikube_dl_file, _ = context.app.download_remote_file(logger,
+                                                               f"https://github.com/kubernetes/minikube/releases"
+                                                               f"/download/v{minikube_version}/"
+                                                               f"minikube-{get_golang_os()}-{get_golang_machine()}",
+                                                               "bin")
+
+        os.chmod(minikube_dl_file, 0o500)
+        self.minikube_dir = tempfile.TemporaryDirectory()
+        minikube_file = Path(self.minikube_dir.name) / "minikube"
+        minikube_file.symlink_to(minikube_dl_file)
+        prepend_os_path(self.minikube_dir.name)
+        version_out: str = self.context.app.run_capturing_out([minikube_file, "version", "--short"],
+                                                              stderr_logger).strip()
+        version = version_out[1:]
+        logger.info("Found minikube %s in %s", version, minikube_file)
+
+        profile_dir = get_cache_dir("minikube", profile)
+        self.minikube_home_dir = profile_dir / "home"
+        self.minikube_home_dir.mkdir(parents=True, exist_ok=True)
+        self.kubeconfig_dir = profile_dir / ".kube"
+        self.kubeconfig_dir.mkdir(parents=True, exist_ok=True)
+
+        context.globals.minikube = dict(version=version,
+                                        minikube_file=str(minikube_file),
+                                        profile=profile,
+                                        k8s_version=k8s_version,
+                                        start_fresh=start_fresh,
+                                        keep_running=keep_running,
+                                        nodes=nodes,
+                                        driver=driver,
+                                        cpus=cpus,
+                                        extra_args=extra_args or [],
+                                        kubeconfig=str(self.kubeconfig_dir / "config"),
+                                        cmd=self.cmd,
+                                        cmd_out=self.cmd_out
+                                        )
+        context.kubeconfig.kubeconfig = context.minikube.kubeconfig
+
+        logger.info("Minikube Home is %s", self.minikube_home_dir)
+        logger.info("Minikube Kubeconfig is %s", context.minikube.kubeconfig)
+
+    def minikube_is_running(self):
+        try:
+            out = self.cmd_out("status", "-o", "json")
+            logger.info("Minikube profile %r is running: %s", self.context.minikube.profile,
+                        out.strip())
+            return True
+        except CalledProcessError as e:
+            logger.info("Minikube profile %r is not running: %s", self.context.minikube.profile,
+                        e.output.strip())
+            return False
+
+    def minikube_start(self):
+        minikube = self.context.minikube
+        if not self.minikube_is_running():
+            logger.info("Starting minikube profile %r...", minikube.profile)
+            self.cmd("start",
+                     "--driver", str(minikube.driver),
+                     "--nodes", str(minikube.nodes),
+                     "--cpus", str(minikube.cpus),
+                     "--kubernetes-version", str(minikube.k8s_version),
+                     "--wait", "apiserver")
+        else:
+            logger.warning("Minikube profile %r is already running!", minikube.profile)
+
+        logger.info("Updating minikube profile %r context", minikube.profile)
+        self.cmd("update-context")
+
+    def minikube_stop(self):
+        minikube = self.context.minikube
+        if self.minikube_is_running():
+            logger.info("Shutting down minikube profile %r...", minikube.profile)
+            self.cmd("stop", "-o", "json")
+
+    def minikube_delete(self):
+        minikube = self.context.minikube
+        self.minikube_stop()
+        logger.warning("Deleting minikube profile %r!", minikube.profile)
+        self.cmd("delete")
+
+    def handle_start(self):
+        minikube = self.context.minikube
+        if minikube.start_fresh:
+            self.minikube_delete()
+
+        self.minikube_start()
+
+    def handle_shutdown(self):
+        minikube = self.context.minikube
+        if not minikube.keep_running:
+            self.minikube_stop()
+        else:
+            logger.warning("Will keep minikube profile %s running!", minikube.profile)
+
+    def __repr__(self):
+        return "Minikube Plugin"

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/plugins/terraform.py

@@ -51,7 +51,7 @@ class TerraformPlugin(KubernatorPlugin):
     def set_context(self, context):
         self.context = context
 
-    def tf_stanza(self):
+    def stanza(self):
         return [self.tf_file]
 
     def register(self, version=None):
@@ -95,7 +95,7 @@ class TerraformPlugin(KubernatorPlugin):
 
         context.globals.terraform = dict(version=version,
                                          tf_file=self.tf_file,
-                                         tf_stanza=self.tf_stanza,
+                                         stanza=self.stanza,
                                          )
 
         logger.info("Found Terraform version %s at %s", version, self.tf_file)
@@ -127,10 +127,10 @@ class TerraformPlugin(KubernatorPlugin):
         if not tf_detected:
             return
 
-        context.app.run(self.tf_stanza() + ["init", "-reconfigure", "-input=false", "-upgrade=false"],
+        context.app.run(self.stanza() + ["init", "-reconfigure", "-input=false", "-upgrade=false"],
                         stdout_logger, stderr_logger, cwd=cwd).wait()
 
-        output = json.loads(context.app.run_capturing_out(self.tf_stanza() + ["output", "-json"],
+        output = json.loads(context.app.run_capturing_out(self.stanza() + ["output", "-json"],
                                                           stderr_logger, cwd=cwd))
         if not output:
             raise RuntimeError("Terraform output produced no values. Please check if Terraform is functioning.")

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/plugins/terragrunt.py

@@ -49,7 +49,7 @@ class TerragruntPlugin(KubernatorPlugin):
     def set_context(self, context):
         self.context = context
 
-    def tg_stanza(self):
+    def stanza(self):
         return [self.tg_file]
 
     def register(self, version=None):
@@ -81,7 +81,7 @@ class TerragruntPlugin(KubernatorPlugin):
         version = version_out.split(" ")[-1][1:].strip()
         context.globals.terragrunt = dict(version=version,
                                           tg_file=self.tg_file,
-                                          tg_stanza=self.tg_stanza,
+                                          stanza=self.stanza,
                                           )
 
         logger.info("Found Terragrunt version %s at %s", version, self.tg_file)
@@ -113,10 +113,10 @@ class TerragruntPlugin(KubernatorPlugin):
         if not tg_detected:
             return
 
-        context.app.run(self.tg_stanza() + ["run-all", "init", "-reconfigure", "-input=false", "-upgrade=false"],
+        context.app.run(self.stanza() + ["run-all", "init", "-reconfigure", "-input=false", "-upgrade=false"],
                         stdout_logger, stderr_logger, cwd=cwd).wait()
 
-        output_json = context.app.run_capturing_out(self.tg_stanza() + ["run-all", "output", "-json"],
+        output_json = context.app.run_capturing_out(self.stanza() + ["run-all", "output", "-json"],
                                                     stderr_logger, cwd=cwd)
 
         json_decoder = json.JSONDecoder()

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator/proc.py

@@ -70,13 +70,16 @@ class ProcessRunner:
                  safe_args=None, universal_newlines=True, **kwargs):
         self._safe_args = safe_args or args
         logger.trace("Starting %r", self._safe_args)
+
+        if "env" not in kwargs:
+            kwargs["env"] = os.environ
+
         self._proc = Popen(args,
                            stdout=PIPE if isinstance(stdout, Callable) else (stdout if stdout is not None else DEVNULL),
                            stderr=PIPE if isinstance(stderr, Callable) else (stderr if stderr is not None else DEVNULL),
                            stdin=PIPE if isinstance(stdin, (Callable, bytes, str)) else
                            (stdin if stdin is not None else DEVNULL),
                            universal_newlines=universal_newlines,
-                           env=os.environ if "env" not in kwargs else kwargs["env"],
                            **kwargs)
 
         self._stdin_writer = (spawn(partial(stream_writer_text if universal_newlines else stream_writer_buf,

{kubernator-1.0.5 → kubernator-1.0.6}/kubernator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kubernator
-Version: 1.0.5
+Version: 1.0.6
 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.5 → kubernator-1.0.6}/setup.py

@@ -21,7 +21,7 @@ class install(_install):
 if __name__ == '__main__':
     setup(
         name = 'kubernator',
-        version = '1.0.5',
+        version = '1.0.6',
         description = 'Kubernator is the a pluggable framework for K8S provisioning',
         long_description = '# Kubernator\n\nKubernator™ (Ktor™) is an integrated solution for the Kubernetes state management. It operates on directories,\nprocessing their content via a collection of plugins, generating Kubernetes resources in the process, validating them,\ntransforming them and then applying against the Kubernetes cluster.\n\n[![Gitter](https://img.shields.io/gitter/room/karellen/lobby?logo=gitter)](https://gitter.im/karellen/Lobby)\n[![Build Status](https://img.shields.io/github/actions/workflow/status/karellen/kubernator/kubernator.yml?branch=master)](https://github.com/karellen/kubernator/actions/workflows/kubernator.yml)\n[![Coverage Status](https://img.shields.io/coveralls/github/karellen/kubernator/master?logo=coveralls)](https://coveralls.io/r/karellen/kubernator?branch=master)\n\n[![Kubernator Version](https://img.shields.io/pypi/v/kubernator?logo=pypi)](https://pypi.org/project/kubernator/)\n[![Kubernator Python Versions](https://img.shields.io/pypi/pyversions/kubernator?logo=pypi)](https://pypi.org/project/kubernator/)\n[![Kubernator Downloads Per Day](https://img.shields.io/pypi/dd/kubernator?logo=pypi)](https://pypi.org/project/kubernator/)\n[![Kubernator Downloads Per Week](https://img.shields.io/pypi/dw/kubernator?logo=pypi)](https://pypi.org/project/kubernator/)\n[![Kubernator Downloads Per Month](https://img.shields.io/pypi/dm/kubernator?logo=pypi)](https://pypi.org/project/kubernator/)\n\n## Notices\n\n### Beta Software\n\nWhile fully functional in the current state and used in production, this software is in **BETA**. A lot of things\nare expected to change rapidly, including main APIs, initialization procedures and some core features. Documentation at\nthis stage is basically non-existent.\n\n### License\n\nThe product is licensed under the Apache License, Version 2.0. Please see LICENSE for further details.\n\n### Warranties and Liability\n\nKubernator and its plugins are provided on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\nexpress or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT,\nMERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of\nusing or redistributing Kubernator and assume any risks associated with doing so.\n\n### Trademarks\n\n"Kubernator" and "Ktor" are trademarks or registered trademarks of Express Systems USA, Inc and Karellen, Inc. All other\ntrademarks are property of their respective owners.\n\n## Problem Statement\n\n## Solution\n\n## Using Kubernator with Docker\n\nA simple example is as follows:\n```\n$ docker run --mount type=bind,source="$(pwd)",target=/root,readonly -t ghcr.io/karellen/kubernator:latest\n```\n\nPlease note, that some plugins (e.g. `awscli`, `eks`) may require additional volume mounts or environmental\nvariables to be passed for credentials and other external configuration.\n\n## Mode of Operation\n\nKubernator is a command line utility. Upon startup and processing of the command line arguments and initializing\nlogging, Kubernator initializes plugins. Current plugins include:\n\n0. Kubernator App\n1. Terraform\n2. kOps\n3. Kubernetes\n4. Helm\n5. Template\n\nThe order of initialization matters as it\'s the order the plugin handlers are executed!\n\nThe entire application operates in the following stages by invoking each plugin\'s stage handler in sequence:\n\n1. Plugin Init Stage\n2. Pre-start script (if specified)\n3. Plugin Start Stage\n4. For each directory in the pipeline:\n    1. Plugin Before Directory Stage\n    2. If `.kubernator.py` is present in the directory:\n        1. Plugin Before Script Stage\n        2. `.kubernator.py` script\n        3. Plugin After Script Stage\n    3. Plugin After Directory Stage\n5. Plugin End Stage\n\nEach plugin individually plays a specific role and performs a specific function which will be described in a later\nsection.\n\n## State/Context\n\nThere is a global state that is carried through as the application is running. It is a hierarchy of objects (`context`)\nthat follows the parent-child relationship as the application traverses the directory structure. For example, given the\ndirectory structure `/a/b`, `/a/c`, and `/a/c/d` any value of the context set or modified in context scoped to\ndirectory `/a` is visible in directories `/a/b`, `/a/c` and `/a/c/d`, while the same modified or set in `/a/b` is only\nvisible there, while one in `/a/c` is visible in `/a/c` and in `/a/c/d` but not `/a` or `/a/b`.\n\nAdditionally, there is a `context.globals` which is the top-most context that is available in all stages that are not\nassociated with the directory structure.\n\nNote, that in cases where the directory structure traversal moves to remote directories (that are actualized by local\ntemporary directories), such remote directory structure enters the context hierarchy as a child of the directory in\nwhich remote was registered.\n\nAlso note, that context carries not just data by references to essential functions.\n\nIn pre-start and `.kubernator.py` scripts the context is fully available as a global variable `ktor`.\n\n### Plugins\n\n#### Kubernator App Plugin\n\nThe role of the Kubernator App Plugin is to traverse the directory structure, expose essential functions through context\nand to run Kubernator scripts.\n\nIn the *After Directory Stage* Kubernator app scans the directories immediately available in the current, sorts them in\nthe alphabetic order, excludes those matching any of the patterns in `context.app.excludes` and then queues up the\nremaining directories in the order the match the patterns in `context.app.includes`.\n\nThus, for a directory content `/a/foo`, `/a/bal`, `/a/bar`, `/a/baz`, excludes `f*`, and includes `baz` and `*`, the\nresulting queue of directories to traverse will be `/a/baz`, `/a/bal`, `/a/bar`.\n\nNotice, that user can further interfere with processing order of the directory queue by asking Kubernator to walk\narbitrary paths, both local and remote.\n\n##### Context\n\n* `ktor.app.args`\n  > Namespace containing command line argument values\n* `ktor.app.walk_local(*paths: Union[Path, str, bytes])`\n  > Immediately schedules the paths to be traversed after the current directory by adding them to the queue\n  > Relative path is relative to the current directory\n* `ktor.app.walk_remote(repo, *path_prefixes: Union[Path, str, bytes])`\n  > Immediately schedules the path prefixes under the remote repo URL to be traversed after the current directory by\n  > adding them to the queue. Only Git URLs are currently supported.\n  > All absolute path prefixes are relativized based on the repository.\n* `ktor.app.repository_credentials_provider(func: Callable)`\n  > Sets a repository credentials provider function `func` that sets/overwrites credentials for URLs being specified by\n  > `walk_remote`. The callable `func` accepts a single argument containing a parsed URL in a form of tuple. The `func`\n  > is expected to return a tuple of three elements representing URL schema, username and password. If the value should\n  > not be changed it should be None. To convert from `git://repo.com/hello` to HTTPS authentication one should write\n  > a function returning `("https", "username", "password")`. The best utility is achieved by logic that allows running\n  > the plan both in CI and local environments using different authentication mechanics in different environments.\n\n#### Terraform\n\nThis is exclusively designed to pull the configuration options out of Terraform and to allow scripts and plugins to\nutilize that data.\n\n##### Context\n\n* `ktor.tf`\n  > A dictionary containing the values from Terraform output\n\n#### Kops\n\n##### Context\n\n#### Kubernetes\n\n##### Context\n\n#### Helm\n\n##### Context\n\n#### Templates\n\n##### Context\n\n## Examples\n\n### Adding Remote Directory\n\n```python\nktor.app.repository_credentials_provider(lambda r: ("ssh", "git", None))\nktor.app.walk_remote("git://repo.example.com/org/project?ref=dev", "/project")\n```\n\n### Adding Local Directory\n\n```python\nktor.app.walk_local("/home/username/local-dir")\n```\n\n### Using Transformers\n\n```python\ndef remove_replicas(resources, r: "K8SResource"):\n    if (r.group == "apps" and r.kind in ("StatefulSet", "Deployment")\n            and "replicas" in r.manifest["spec"]):\n        logger.warning("Resource %s in %s contains `replica` specification that will be removed. Use HPA!!!",\n                       r, r.source)\n        del r.manifest["spec"]["replicas"]\n\n\nktor.k8s.add_transformer(remove_replicas)\n```\n',
         long_description_content_type = 'text/markdown',

kubernator-1.0.5/kubernator/plugins/minikube.py

@@ -1,101 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#   Copyright 2020 Express Systems USA, Inc
-#   Copyright 2023 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
-
-from kubernator.api import (KubernatorPlugin,
-                            StripNL,
-                            get_golang_os,
-                            get_golang_machine
-                            )
-
-logger = logging.getLogger("kubernator.minikube")
-proc_logger = logger.getChild("proc")
-stdout_logger = StripNL(proc_logger.info)
-stderr_logger = StripNL(proc_logger.warning)
-
-
-class MinikubePlugin(KubernatorPlugin):
-    logger = logger
-
-    _name = "minikube"
-
-    def __init__(self):
-        self.context = None
-        self.minikube_home_dir = None
-        self.kubeconfig_dir = None
-
-        super().__init__()
-
-    def set_context(self, context):
-        self.context = context
-
-    def get_latest_minikube_version(self):
-        context = self.context
-        versions = context.app.run_capturing_out(["git", "ls-remote", "-t", "--refs",
-                                                  "https://github.com/kubernetes/minikube", "v*"],
-                                                 stderr_logger)
-
-        # 06e3b0cf7999f74fc52af362b42fb21076ade64a        refs/tags/v1.9.1
-        # "refs/tags/v1.9.1"
-        # "1.9.1"
-        # ("1","9","1")
-        # (1, 9, 1)
-        # sort and get latest, which is the last/highest
-        # "v1.9.1"
-        return (".".join(map(str, sorted(list(map(lambda v: tuple(map(int, v)),
-                                                  filter(lambda v: len(v) == 3,
-                                                         map(lambda line: line.split()[1][11:].split("."),
-                                                             versions.splitlines(False))))))[-1])))
-
-    def cmd(self, ):
-        pass
-
-    def register(self, minikube_version=None, k8s_version=None):
-        context = self.context
-
-        context.app.register_plugin("kubectl")
-
-        if not minikube_version:
-            minikube_version = self.get_latest_minikube_version()
-            logger.info("No minikube version is specified, latest is %s", minikube_version)
-
-        minikube_file = context.app.download_remote_file(logger,
-                                                         f"https://github.com/kubernetes/minikube/releases/download/"
-                                                         f"v{minikube_version}/"
-                                                         f"minikube-{get_golang_os()}-{get_golang_machine()}", "bin")
-        os.chmod(minikube_file, 0o500)
-        version_out: str = self.context.app.run_capturing_out([minikube_file, "version", "--short"],
-                                                              stderr_logger)
-        version = version_out[1:]
-        logger.info("Found minikube %s in %r", version, minikube_file)
-
-        context.globals.minikube = dict(version=version,
-                                        minikube_file=minikube_file,
-                                        cmd=self.cmd
-                                        )
-
-    def handle_init(self):
-        pass
-
-    def handle_shutdown(self):
-        pass
-
-    def __repr__(self):
-        return "AWS CLI Plugin"