kubernator 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

kubernator/__init__.py

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

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):
@@ -620,6 +637,7 @@ def clone_url_str(url):
 
 
 def prepend_os_path(path):
+    path = str(path)
     paths = os.environ["PATH"].split(os.pathsep)
     if path not in paths:
         paths.insert(0, path)

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/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:
@@ -101,7 +101,7 @@ class AwsCliPlugin(KubernatorPlugin):
                 aws_file.chmod(0o500)
 
             self.aws_dir = awscli_cache_dir
-            prepend_os_path(str(self.aws_dir))
+            prepend_os_path(self.aws_dir)
 
         self.aws_file = str(aws_file)
 
@@ -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/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/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:
@@ -132,7 +132,7 @@ class HelmPlugin(KubernatorPlugin):
             copy(Path(self.helm_dir.name)/f"{get_golang_os()}-{get_golang_machine()}"/"helm", helm_file)
 
             os.chmod(helm_file, 0o500)
-            prepend_os_path(str(self.helm_dir))
+            prepend_os_path(self.helm_dir.name)
         else:
             # Use current version
             helm_file = which("helm")
@@ -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/plugins/istio.py

@@ -77,7 +77,7 @@ class IstioPlugin(KubernatorPlugin, K8SResourcePluginMixin):
             istio_tar.extractall(self.istioctl_dir.name)
 
             os.chmod(istioctl_file, 0o500)
-            prepend_os_path(str(self.istioctl_dir))
+            prepend_os_path(self.istioctl_dir.name)
         else:
             # Use current version
             istioctl_file = which("istioctl")
@@ -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/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/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/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}"]
 
@@ -73,7 +73,7 @@ class KubectlPlugin(KubernatorPlugin):
             kubectl_file = str(Path(self.kubectl_dir.name) / "kubectl")
             copy(kubectl_file_dl, kubectl_file)
             os.chmod(kubectl_file, 0o500)
-            prepend_os_path(str(self.kubectl_dir))
+            prepend_os_path(self.kubectl_dir.name)
         else:
             # Use current version
             kubectl_file = which("kubectl")
@@ -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/plugins/minikube.py

@@ -18,11 +18,16 @@
 
 import logging
 import os
+import tempfile
+from pathlib import Path
 
 from kubernator.api import (KubernatorPlugin,
                             StripNL,
                             get_golang_os,
-                            get_golang_machine
+                            get_golang_machine,
+                            prepend_os_path,
+                            get_cache_dir,
+                            CalledProcessError
                             )
 
 logger = logging.getLogger("kubernator.minikube")
@@ -38,6 +43,7 @@ class MinikubePlugin(KubernatorPlugin):
 
     def __init__(self):
         self.context = None
+        self.minikube_dir = None
         self.minikube_home_dir = None
         self.kubeconfig_dir = None
 
@@ -64,38 +70,132 @@ class MinikubePlugin(KubernatorPlugin):
                                                          map(lambda line: line.split()[1][11:].split("."),
                                                              versions.splitlines(False))))))[-1])))
 
-    def cmd(self, ):
-        pass
+    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 register(self, minikube_version=None, k8s_version=None):
+    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("kubectl")
+        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_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)
+        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)
+                                                              stderr_logger).strip()
         version = version_out[1:]
-        logger.info("Found minikube %s in %r", version, minikube_file)
+        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=minikube_file,
-                                        cmd=self.cmd
+                                        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
                                         )
-
-    def handle_init(self):
-        pass
+        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):
-        pass
+        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 "AWS CLI Plugin"
+        return "Minikube Plugin"

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):
@@ -71,7 +71,7 @@ class TerraformPlugin(KubernatorPlugin):
             tf_zip.extractall(self.tf_dir.name)
 
             os.chmod(tf_file, 0o500)
-            prepend_os_path(str(self.tf_dir))
+            prepend_os_path(self.tf_dir.name)
         else:
             # Use current version
             tf_file = which("terraform")
@@ -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/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):
@@ -66,7 +66,7 @@ class TerragruntPlugin(KubernatorPlugin):
             tg_file = Path(self.tg_dir.name) / "terragrunt"
             copy(tg_file_cache, tg_file)
             os.chmod(tg_file, 0o500)
-            prepend_os_path(str(self.tg_dir))
+            prepend_os_path(self.tg_dir.name)
         else:
             # Use current version
             tg_file = which("terragrunt")
@@ -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/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.4.dist-info → kubernator-1.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kubernator
-Version: 1.0.4
+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.6.dist-info/RECORD

@@ -0,0 +1,27 @@
+kubernator/LICENSE,sha256=wKKdOCMTCPQRV5gDkVLAsXX8qSnRJ5owk7yWPO1KZNo,11387
+kubernator/__init__.py,sha256=PTgWFGl8toikIoJ1DhGqzDU4n_T6ysuFFY_78v2Ho3w,914
+kubernator/__main__.py,sha256=f0S60wgpLu--1UlOhzfWail-xt8zyIuODodX98_yPN0,707
+kubernator/api.py,sha256=nu6dHXAayk1M4Mc5lni4GiQ6kKsrjWmaUM4BwmotR5E,24168
+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=CHuK97TTLf6j6lTL1FSB51xyQ_Jqf-lAVZId_NHhQfQ,10469
+kubernator/plugins/istio.py,sha256=ixY-6H_hH55rBBcWJqq6SCkyHrVIu4iJdKm18okxdfk,9777
+kubernator/plugins/k8s.py,sha256=klbAU-DIDNzY-aXfbhxQKHwGhStTmJ-k7ydr1ckUqr8,20248
+kubernator/plugins/k8s_api.py,sha256=xsDQii32khCUOc4hMlNc0zHLQK73VTb4kdnug8ukmy4,26000
+kubernator/plugins/kops.py,sha256=QsrQJUF6wGJo2QRVqP92pG5vmOTYQIc25PD_DWCzrAA,9635
+kubernator/plugins/kubeconfig.py,sha256=uwtHmF2I6LiTPrC3M88G5SfYxDWtuh0MqcMfrHHoNRA,2178
+kubernator/plugins/kubectl.py,sha256=4Z01zDCni0B60F4L2ImuA3Ob8HMD1YK-DD9FXfZ1Z6Y,3861
+kubernator/plugins/minikube.py,sha256=cJYnjGcQdNNrTAisDzF5kJXuAeYbRHUBc-XCuxBwEY8,8386
+kubernator/plugins/template.py,sha256=o6UqLw1wK91gCfN7q-Wwc3P5iycAeELUryXh-egA2vQ,8070
+kubernator/plugins/terraform.py,sha256=bw-0KUBYB1bKEeBTfSYD5A1PGHtuGwOVLV86z6zznkc,5231
+kubernator/plugins/terragrunt.py,sha256=UbV_Hm2wO8lPpkRvE9PGCbtpcWVjDJedAv-SHw7KngE,4996
+kubernator-1.0.6.dist-info/METADATA,sha256=SBKFOc51gi4deyJyGzk2l6Sg4oMOPYCWsHYRMXZKiHs,10300
+kubernator-1.0.6.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+kubernator-1.0.6.dist-info/entry_points.txt,sha256=IWDtHzyTleRqDSuVRXEr5GImrI7z_kh21t5DWZ8ldcQ,47
+kubernator-1.0.6.dist-info/namespace_packages.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+kubernator-1.0.6.dist-info/top_level.txt,sha256=_z1CxWeKMI55ckf2vC8HqjbCn_E2Y_P5RdrhE_QWcIs,11
+kubernator-1.0.6.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+kubernator-1.0.6.dist-info/RECORD,,

kubernator-1.0.4.dist-info/RECORD

@@ -1,27 +0,0 @@
-kubernator/LICENSE,sha256=wKKdOCMTCPQRV5gDkVLAsXX8qSnRJ5owk7yWPO1KZNo,11387
-kubernator/__init__.py,sha256=vrdZZ51ljtDBriYt-0tQJ9VzAEoxoaNtXoB6kHOzeis,909
-kubernator/__main__.py,sha256=f0S60wgpLu--1UlOhzfWail-xt8zyIuODodX98_yPN0,707
-kubernator/api.py,sha256=ugpHtUMJypwMJ9E3aZvmiPhQu0DNosCGJPsak2NtLnU,23582
-kubernator/app.py,sha256=Un6BvgD_L8DUhB4rZiRDoWGVE1TKDcMcBR0UKSYWwgI,18087
-kubernator/proc.py,sha256=MNJwcpSwY_j-WfxEtI3CIhC59rID47GQwUMOFiIQEMk,5131
-kubernator/plugins/__init__.py,sha256=h9TLYK8UFEi53ipZSZsTBjp0ljKhisWsgPpt_PkWrO8,670
-kubernator/plugins/awscli.py,sha256=TvxKHTtu_oxS0O4jTpOBqxfnn9a9J--mqTYS9MNLOMg,4248
-kubernator/plugins/eks.py,sha256=PbbnopFxy7sF66GLAq_BazjUKSPQvKsS_Z4vqUDJ7pA,2270
-kubernator/plugins/helm.py,sha256=9WkeYCjrLWzUN5e_MZdH_L_sQXiXtyLZ10sW47CpRLU,10504
-kubernator/plugins/istio.py,sha256=WnfRuClbl4Z5tYRMJjVwPIHn66BXHxV7QVBAt6RMMig,9781
-kubernator/plugins/k8s.py,sha256=EBb92zf7pV1EgOmjVvhnrwBRHihUBxxZVF4MH-Mjwjk,18129
-kubernator/plugins/k8s_api.py,sha256=SDxU86Uthy1fcTotAdRWSv13BMoyO0znfcP_7aQ0yIM,25932
-kubernator/plugins/kops.py,sha256=QsrQJUF6wGJo2QRVqP92pG5vmOTYQIc25PD_DWCzrAA,9635
-kubernator/plugins/kubeconfig.py,sha256=uwtHmF2I6LiTPrC3M88G5SfYxDWtuh0MqcMfrHHoNRA,2178
-kubernator/plugins/kubectl.py,sha256=l3H3hjZsf_QTU-UnM5WqaNQkzz6NzTErQy6wlzSWsQU,3901
-kubernator/plugins/minikube.py,sha256=crXSXVf7O4JLS1d5-2tjKOFEBurYFgzM18x9dEmbpc8,3760
-kubernator/plugins/template.py,sha256=o6UqLw1wK91gCfN7q-Wwc3P5iycAeELUryXh-egA2vQ,8070
-kubernator/plugins/terraform.py,sha256=2fP776nTWH06sfBcyOlJTaAMZGEnHPy8eZsDs0JPYMo,5246
-kubernator/plugins/terragrunt.py,sha256=FEAqohdvOB2rAXHOR-SyS3A_GuHhvrLuE3P02qlVDSI,5011
-kubernator-1.0.4.dist-info/METADATA,sha256=-jhH3tNI3oqHTZGYQ7xdlJQVY2dYCjb15uUD6vqiHNM,10300
-kubernator-1.0.4.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-kubernator-1.0.4.dist-info/entry_points.txt,sha256=IWDtHzyTleRqDSuVRXEr5GImrI7z_kh21t5DWZ8ldcQ,47
-kubernator-1.0.4.dist-info/namespace_packages.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-kubernator-1.0.4.dist-info/top_level.txt,sha256=_z1CxWeKMI55ckf2vC8HqjbCn_E2Y_P5RdrhE_QWcIs,11
-kubernator-1.0.4.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-kubernator-1.0.4.dist-info/RECORD,,