dfsync 0.4.6__tar.gz → 0.4.7__tar.gz

{dfsync-0.4.6 → dfsync-0.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dfsync
-Version: 0.4.6
+Version: 0.4.7
 Summary: 
 Author: Mihai Balint
 Author-email: balint.mihai@gmail.com

{dfsync-0.4.6 → dfsync-0.4.7}/dfsync/backends/kube.py

@@ -12,6 +12,7 @@ from kubernetes.client.exceptions import ApiException
 from tenacity import retry, retry_if_exception_type, wait_exponential, stop_after_attempt
 
 from dfsync.filters import GIT_FILTER
+from dfsync.kube_credentials import KubeContextConfig
 from .rsync import rsync_backend
 
 DEFAULT_COMMAND = []
@@ -178,84 +179,72 @@ def please_wait(msg="Please wait"):
     print("⌛  {}...".format(msg))
 
 
-def _get_kube_api_client(context_name):
-    configuration = client.Configuration()
-    config.load_kube_config(
-        context=context_name,
-        client_configuration=configuration,
-    )
-    configuration.verify_ssl = True
-    configuration.assert_hostname = False
-    return client.ApiClient(configuration)
-
+def get_selected_kubernetes(kube_host=None) -> KubeContextConfig:
+    try:
+        config.load_kube_config()
+    except Exception as e:
+        error_message = str(e)
+        print(f"Failed to load default kube config: {error_message}")
 
-def get_selected_kubernetes(kube_host=None):
     contexts, active_context = config.list_kube_config_contexts()
     if not contexts:
         raise ValueError("Cannot find any kubernetes contexts in kube-config file")
 
-    context_apis = []
-    selected_context = None
-    selected_context_api = None
-    active_context_api = None
+    k8sctx_configs = []
+    active_k8ctx = None
+    selected_k8ctx = None
     multiple_matches = False
+
     for c in contexts:
-        ctx_client = client.CoreV1Api(api_client=_get_kube_api_client(c["name"]))
-        context_apis.append([c, ctx_client])
+        k8sctx = KubeContextConfig(c["name"])
+        k8sctx_configs.append(k8sctx)
 
-        ctx_api_host = ctx_client.api_client.configuration.host
-        if c["name"] == active_context["name"]:
-            active_context_api = ctx_client
+        if k8sctx.context_name == active_context["name"]:
+            active_k8ctx = k8sctx
+            k8sctx.is_active = True
 
-        if kube_host is not None and kube_host.lower() == ctx_api_host.lower():
-            if selected_context is None:
-                selected_context = c
-                selected_context_api = ctx_client
+        if kube_host is not None and kube_host.lower() == k8sctx.host.lower():
+            if selected_k8ctx is None:
+                selected_k8ctx = k8sctx
+                k8sctx.is_selected = True
             else:
                 multiple_matches = True
 
-    if len(contexts) > 1 or multiple_matches or (kube_host is not None and selected_context is None):
-        print(f"Multiple kubernetes contexts in kube-config:")
+    if kube_host is None and selected_k8ctx is None and active_k8ctx is not None:
+        # Select the active context if no specific arg is given
+        selected_k8ctx = active_k8ctx
+        selected_k8ctx.is_selected = True
 
-        for c, ctx_client in context_apis:
-            ctx_api_host = ctx_client.api_client.configuration.host
-            tags = []
-            if c == selected_context:
-                tags.append("ACTIVE-SELECTED")
-            elif c["name"] == active_context["name"]:
-                tags.append("ACTIVE")
+    if len(contexts) > 1 or multiple_matches or (kube_host is not None and selected_k8ctx is None):
+        print("Multiple kubernetes contexts in kube-config:")
+
+        for k8sctx in k8sctx_configs:
+            print(f"  {k8sctx.active_glyph} {k8sctx.prettified_str}")
 
-            if len(tags) > 0:
-                tags_str = ",".join(tags)
-                print(f"  * {c['name']} on {ctx_api_host} [{tags_str}]")
-            else:
-                print(f"  * {c['name']} on {ctx_api_host}")
         if kube_host is None:
-            ctx_api_host = active_context_api.api_client.configuration.host
             print(
-                f"Add --kube-host={ctx_api_host} to use a specific kubernetes API host\n"
+                f"Add --kube-host={active_k8ctx.host} to use a specific kubernetes API host\n"
                 f"Alternatively, use 'kubectl config set current-context <name>' to set the current context"
             )
 
-    if kube_host is not None and selected_context is None:
+    if kube_host is not None and selected_k8ctx is None:
         raise ValueError(f"None of the kubernetes contexts match '{kube_host}'")
 
-    if selected_context is None:
-        selected_context = active_context
-        selected_context_api = active_context_api
-    return selected_context, selected_context_api
+    if selected_k8ctx is None:
+        raise ValueError("Failed to select a kubernetes context config")
+
+    return selected_k8ctx
 
 
 class KubeReDeployer:
     def __init__(self, kube_host=None, pod_timeout=30, container_command=None, full_sync=True, **kwargs):
-        config.load_kube_config()
-        selected_context, selected_context_api = get_selected_kubernetes(kube_host)
+        k8sctx = get_selected_kubernetes(kube_host)
 
-        self.context_name = selected_context["name"]
-        self.api = selected_context_api
-        self.apps_api = client.AppsV1Api(api_client=_get_kube_api_client(self.context_name))
+        self.context_name = k8sctx.context_name
+        self.api = k8sctx.core_v1_api()
+        self.apps_api = k8sctx.apps_v1_api()
 
-        print(f"Using cluster: {self.context_name} on {self.api.api_client.configuration.host}")
+        print(f"Using cluster: {k8sctx.prettified_str}")
         self.rsync_backend_instance = rsync_backend()
         self._image_distro = None
         self.pod_timeout = pod_timeout

{dfsync-0.4.6 → dfsync-0.4.7}/dfsync/char_ui.py

@@ -60,7 +60,16 @@ class KeyHandlerException(Exception):
     pass
 
 
-KeyHandler = namedtuple("KeyHandler", "keys description action")
+class KeyHandler:
+    def __init__(self, keys, description, action, strict_case):
+        self.keys = keys
+        self.description = description
+        self.action = action
+
+        self.event_keys = set(keys)
+        if not strict_case:
+            self.event_keys.update([k.lower() for k in self.keys])
+            self.event_keys.update([k.upper() for k in self.keys])
 
 
 class KeyController(ControlledThreadedOperation):
@@ -97,12 +106,12 @@ class KeyController(ControlledThreadedOperation):
             except (Exception, KeyboardInterrupt) as e:
                 self._exception = e
 
-    def on_key(self, *keys, description: str = None, action=None):
+    def on_key(self, *keys, description: str = None, action=None, strict_case=False):
         if action is None:
             raise ValueError("'action' cannot be None")
-        handler = KeyHandler(keys=keys, description=description, action=action)
+        handler = KeyHandler(keys=keys, description=description, action=action, strict_case=strict_case)
         self.handlers.append(handler)
-        for k in keys:
+        for k in handler.event_keys:
             self.key_handlers[k] = handler
 
     def raise_exceptions(self):

{dfsync-0.4.6 → dfsync-0.4.7}/dfsync/kube_credentials.py

@@ -2,6 +2,7 @@ import os
 import os.path
 import yaml
 from urllib.parse import urlparse
+from kubernetes import client, config
 
 LOCAL_CREDENTIALS_FILE = os.path.expanduser("~/.kube/config")
 EMPTY_CREDENTIALS = """apiVersion: v1
@@ -18,7 +19,7 @@ def update_local_kube_config(new_kube_credentials):
     try:
         with open(LOCAL_CREDENTIALS_FILE, "r") as f:
             credentials = yaml.safe_load(f)
-    except FileNotFoundError as e:
+    except FileNotFoundError:
         credentials = yaml.safe_load(EMPTY_CREDENTIALS)
         kube_dir, _ = os.path.split(LOCAL_CREDENTIALS_FILE)
         os.makedirs(kube_dir, exist_ok=True)
@@ -132,3 +133,89 @@ def contextualize_kube_credentials(kube_host, credentials_file):
         print(exc)
 
     return {}
+
+
+def normalized_k8s_url(k8s_url: str) -> str:
+    parsed = None
+    result = k8s_url
+    if k8s_url is None:
+        return None
+    elif not k8s_url:
+        raise ValueError(f"Invalid k8s URL: `{k8s_url}`")
+    elif "://" not in k8s_url.lower():
+        result = f"https://{k8s_url}"
+        parsed = urlparse(result)
+    else:
+        parsed = urlparse(k8s_url)
+
+    if all([parsed.scheme, parsed.netloc]):
+        return result
+    else:
+        raise ValueError(f"Invalid k8s URL: `{k8s_url}`")
+
+
+RED = "\033[38;2;255;0;0m"
+GREEN = "\033[38;2;128;255;128m"
+GRAY = "\033[38;2;128;128;128m"
+NEUTRAL = "\033[0m"
+
+
+class KubeContextConfig:
+    def __init__(self, context_name: str) -> None:
+        self._api_client = None
+        self._load_failure = None
+        self._configuration = client.Configuration()
+        self.context_name = context_name
+        self._adjust_ssl()
+        self.is_active = False
+        self.is_selected = False
+
+    def _adjust_ssl(self):
+        self._configuration.verify_ssl = True
+        self._configuration.assert_hostname = False
+
+    def _load(self):
+        if self._api_client is not None:
+            return
+        try:
+            config.load_kube_config(
+                context=self.context_name,
+                client_configuration=self._configuration,
+            )
+            self._adjust_ssl()
+            self._api_client = client.ApiClient(self._configuration)
+            self._load_failure = None
+        except Exception as e:
+            self._load_failure = str(e)
+
+    @property
+    def host(self):
+        self._load()
+        return self._configuration.host
+
+    @property
+    def api_client(self):
+        self._load()
+        return self._api_client
+
+    def apps_v1_api(self):
+        return client.AppsV1Api(api_client=self.api_client)
+
+    def core_v1_api(self):
+        return client.CoreV1Api(api_client=self.api_client)
+
+    @property
+    def active_glyph(self):
+        glyph = "@" if self.is_active else "*"
+        COLOR = GREEN if self.is_selected else GRAY
+        return f"{COLOR}{glyph}{NEUTRAL}"
+
+    @property
+    def prettified_str(self, include_failure=True):
+        fail_text = ""
+        if self._load_failure and include_failure:
+            fail_text = f"{RED}{self._load_failure[:80]}{NEUTRAL}"
+
+        txt = f"{self.context_name} on {self.host}"
+        COLOR = GREEN if self.is_selected else GRAY
+        return f"{COLOR}{txt}{NEUTRAL} {fail_text}"

{dfsync-0.4.6 → dfsync-0.4.7}/dfsync/lib.py

@@ -1,4 +1,5 @@
-import time, threading
+import time
+import threading
 
 
 class ThreadedOperationsManager:
@@ -35,13 +36,13 @@ class ControlledThreadedOperation:
 
     @property
     def is_completed(self):
-        return self._running == False
+        return self._running is False
 
     def run(self):
         while self._running:
             try:
                 self._run_once()
-            except:
+            except Exception:
                 time.sleep(0.001)
 
     def _run_once(self):

{dfsync-0.4.6 → dfsync-0.4.7}/dfsync/monitor.py

@@ -17,7 +17,7 @@ from dfsync.distribution import get_installed_version, get_latest_version, is_ol
 from dfsync.filters import add_user_ignored_patterns_filter, ALL_FILTERS
 from dfsync.config import read_config
 from dfsync.char_ui import KeyController
-from dfsync.kube_credentials import contextualize_kube_credentials, update_local_kube_config
+from dfsync.kube_credentials import contextualize_kube_credentials, update_local_kube_config, normalized_k8s_url
 from dfsync.lib import ControlledThreadedOperation, thread_manager
 
 logging.basicConfig(level=logging.WARN)
@@ -271,7 +271,7 @@ def import_kube_host(kube_host=None, credentials=None):
 
     ssh user@kube-host -C "sudo cat /root/.kube/config" | dfsync import-kube-host --kube-host=https://kube-host:6443
     """
-    patch = contextualize_kube_credentials(kube_host, credentials)
+    patch = contextualize_kube_credentials(normalized_k8s_url(kube_host), credentials)
     update_local_kube_config(patch)
 
 
@@ -342,7 +342,7 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync):
         backend_options = dict(
             destination_dir=destination_dir,
             supervisor=supervisor,
-            kube_host=kube_host,
+            kube_host=normalized_k8s_url(kube_host),
             pod_timeout=pod_timeout,
             container_command=config.container_command,
             full_sync=full_sync,

{dfsync-0.4.6 → dfsync-0.4.7}/dfsync/test_kube_credentials.py

@@ -1,7 +1,8 @@
-import pytest, yaml, tempfile
+import pytest
+import yaml
+import tempfile
 
-import dfsync.kube_credentials
-from dfsync.kube_credentials import update_local_kube_config
+from dfsync.kube_credentials import update_local_kube_config, normalized_k8s_url
 
 
 @pytest.fixture
@@ -91,3 +92,16 @@ def test_update_existing_kube_config(mock_kube_credentials):
         assert credentials["users"][1]["name"] == "new_user"
         assert credentials["users"][1]["user"]["username"] == "new_username"
         assert credentials["users"][1]["user"]["password"] == "new_password"
+
+
+def test_normalized_k8s_url():
+    assert normalized_k8s_url("http://example.com") == "http://example.com"
+    assert normalized_k8s_url("https://example.com") == "https://example.com"
+    assert normalized_k8s_url("example.com") == "https://example.com"
+    assert normalized_k8s_url("http://example.com") == "http://example.com"
+    assert normalized_k8s_url("https://192.168.0.123:443") == "https://192.168.0.123:443"
+    assert normalized_k8s_url("192.168.0.123:6443") == "https://192.168.0.123:6443"
+    with pytest.raises(ValueError):
+        normalized_k8s_url("")
+    with pytest.raises(ValueError):
+        normalized_k8s_url(None)

{dfsync-0.4.6 → dfsync-0.4.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dfsync"
-version = "0.4.6"
+version = "0.4.7"
 description = ""
 authors = ["Mihai Balint <balint.mihai@gmail.com>"]