dfsync 0.4.9__tar.gz → 0.4.11__tar.gz

{dfsync-0.4.9 → dfsync-0.4.11}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: dfsync
-Version: 0.4.9
+Version: 0.4.11
 Summary: 
 Author: Mihai Balint
 Author-email: balint.mihai@gmail.com
@@ -11,12 +11,14 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: black (==24.3.0)
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: click (>=8,<9)
 Requires-Dist: click-default-group (>=1.2.2,<2.0.0)
 Requires-Dist: gitpython (>=3.1.14,<4.0.0)
 Requires-Dist: kubernetes (>=28.1.0,<29.0.0)
 Requires-Dist: paramiko[invoke] (>=3.2.0,<4.0.0)
+Requires-Dist: sentry-sdk (>=2.26.0,<3.0.0)
 Requires-Dist: tenacity (>=8.0.1,<9.0.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Requires-Dist: watchdog (>=2.0.2,<3.0.0)

{dfsync-0.4.9 → dfsync-0.4.11}/dfsync/backends/kube.py

@@ -569,7 +569,7 @@ class KubeReDeployer:
         try:
             resp = self._exec(pod, spec, status, Generic.check_can_exec())
             return
-        except:
+        except Exception:
             self._uncrash(pod, spec, status)
 
     def _sniff_image_distro(self, pod, spec, status):
@@ -596,7 +596,7 @@ class KubeReDeployer:
                     return False
 
             return len(resp) > 0
-        except:
+        except Exception:
             return False
 
     def stabilize_deployments(self, image_base):

{dfsync-0.4.9 → dfsync-0.4.11}/dfsync/backends/rsync.py

@@ -10,6 +10,8 @@ EVENT_TYPE_MAP = {
     "full-sync": "Full Sync",
 }
 
+RSYNC_CONFIG = {"RSYNC_EXECUTABLE": "rsync"}
+
 
 class StopStreamReader(Exception):
     pass
@@ -174,7 +176,7 @@ class FileRsync:
             rsync_cmd = self._get_rsync_cmd_on_full_sync(src_paths, destination_dir, blocking_io, rsh)
         else:
             rsync_cmd = [
-                "rsync",
+                get_rsync_executable(),
                 "-Rvx",
                 "--temp-dir=/tmp",
                 "--delay-updates",
@@ -227,7 +229,7 @@ class FileRsync:
                 if return_code != 23:
                     raise subprocess.CalledProcessError(returncode=return_code, cmd=rsync_cmd)
 
-        except:
+        except Exception:
             echo("Sync failed")
             env_str = "N/A"
             if rsh_env:
@@ -260,7 +262,7 @@ class FileRsync:
             src_dir = "{}/".format(src_dir)
 
         cmd = [
-            "rsync",
+            get_rsync_executable(),
             "-rvx",
             "--delete",
             "--filter=-,s *",
@@ -276,7 +278,7 @@ class FileRsync:
     def _get_rsync_cmd_on_full_sync(self, src_file_paths: list, destination_dir: str, blocking_io: list, rsh: list):
         filters = ["--filter=- {}".format(f) for f in list_files_to_ignore()]
         return [
-            "rsync",
+            get_rsync_executable(),
             "-rvx",
             "--temp-dir=/tmp",
             "--delay-updates",
@@ -312,3 +314,11 @@ def sanitize_relative_path(path):
 
 
 rsync_backend = FileRsync
+
+
+def get_rsync_executable() -> str:
+    return RSYNC_CONFIG["RSYNC_EXECUTABLE"]
+
+
+def set_rsync_executable(executable_path: str) -> str:
+    return RSYNC_CONFIG["RSYNC_EXECUTABLE"]

{dfsync-0.4.9 → dfsync-0.4.11}/dfsync/filters.py

@@ -1,4 +1,3 @@
-import black
 import fnmatch
 import os.path
 import git.exc
@@ -75,7 +74,9 @@ class EmacsBufferFilter(UserConfigFilter):
         self._ignore_message = "Emacs buffer backup"
 
 
-class PythonBlackFilter(LoggingFilter):
+class PythonSyntaxFilter(LoggingFilter):
+    """Reject .py files that do not parse, so a half-saved file never reaches the pod."""
+
     def __init__(self):
         super().__init__()
 
@@ -87,17 +88,17 @@ class PythonBlackFilter(LoggingFilter):
         parent_path, file_name = os.path.split(os.path.expanduser(src_file_path))
         for pattern in PYTHON_PATTERNS:
             if fnmatch.fnmatch(file_name, pattern):
-                return self._black_check(src_file_path)
+                return self._syntax_check(src_file_path)
         return False
 
-    def _black_check(self, src_file_path):
+    def _syntax_check(self, src_file_path):
         try:
-            with open(src_file_path, "r") as f:
+            with open(src_file_path, "rb") as f:
                 contents = f.read()
-                black.format_file_contents(contents, fast=False, mode=black.FileMode())
+            compile(contents, src_file_path, "exec", dont_inherit=True)
             return False
 
-        except (FileNotFoundError, PermissionError, black.report.NothingChanged) as e:
+        except (FileNotFoundError, PermissionError):
             return False
 
         except Exception as e:
@@ -106,6 +107,10 @@ class PythonBlackFilter(LoggingFilter):
             return True
 
 
+# Kept for code that imported the old name
+PythonBlackFilter = PythonSyntaxFilter
+
+
 class UntrackedGitFilesFilter(LoggingFilter):
     def __init__(self):
         super().__init__()
@@ -192,7 +197,7 @@ class UntrackedGitFilesFilter(LoggingFilter):
         )
 
 
-USER_FILTERS = [EmacsBufferFilter(), PythonBlackFilter()]
+USER_FILTERS = [EmacsBufferFilter(), PythonSyntaxFilter()]
 GIT_FILTER = UntrackedGitFilesFilter()
 ALL_FILTERS = [
     exclude_watchdog_directory_events,

dfsync-0.4.11/dfsync/lib.py

@@ -0,0 +1,120 @@
+import base64
+from enum import Enum
+import platform
+import subprocess
+import time
+import threading
+import zlib
+
+
+class ThreadedOperationsManager:
+    def __init__(self):
+        self.threads = []
+
+    def stop(self, *args, **kwargs):
+        for thread in self.threads:
+            thread.stop(*args, **kwargs)
+
+    def register_threaded_operation(self, op):
+        self.threads.append(op)
+
+
+thread_manager = ThreadedOperationsManager()
+
+
+class ControlledThreadedOperation:
+    def __init__(self):
+        self._running = False
+        self._thread = threading.Thread(target=self.run)
+        thread_manager.register_threaded_operation(self)
+
+    def start(self):
+        self._running = True
+        self._thread.start()
+
+    def stop(self, *args, **kwargs):
+        self._running = False
+
+    @property
+    def is_running(self):
+        return self._running
+
+    @property
+    def is_completed(self):
+        return self._running is False
+
+    def run(self):
+        while self._running:
+            try:
+                self._run_once()
+            except Exception:
+                time.sleep(0.001)
+
+    def _run_once(self):
+        time.sleep(0.001)
+
+
+class RsyncFlavour(Enum):
+    SAMBA_RSYNC = "SAMBA_RSYNC"
+    OPEN_RSYNC = "OPENRSYNC"
+
+    @property
+    def executable(self):
+        if platform.system() == "Darwin":  # Check if running on macOS
+            if self == RsyncFlavour.SAMBA_RSYNC:
+                return "/opt/homebrew/bin/rsync"
+            elif self == RsyncFlavour.OPEN_RSYNC:
+                return "/usr/bin/rsync"
+
+        # Default fallback for other platforms or if paths don't exist
+        return "rsync"
+
+    @property
+    def exists_installed(self):
+        try:
+            # Check if the executable exists and is executable
+            result = subprocess.run(
+                ["which", self.executable], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False
+            )
+            if result.returncode != 0:
+                return False
+
+            # Additionally verify it can be executed
+            result = subprocess.run(
+                [self.executable, "--version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+
+def check_rsync() -> RsyncFlavour:
+    try:
+        result = subprocess.run(["rsync", "--version"], capture_output=True, text=True)
+        version_text = result.stdout
+
+        if "rsync.samba.org/" in version_text:
+            return RsyncFlavour.SAMBA_RSYNC
+        else:
+            # Default to OpenRsync if we can't positively identify Samba rsync
+            return RsyncFlavour.OPEN_RSYNC
+    except (subprocess.SubprocessError, FileNotFoundError):
+        # If rsync isn't available or fails, default to Samba rsync
+        return RsyncFlavour.SAMBA_RSYNC
+
+
+NONCE = "Rah4liteaR1geughuC8eushaOhtiW0xu"
+
+
+def dsn_pack(unpacked_dsn: str) -> str:
+    # XOR with NONCE, compress and base64 encode
+    xored = "".join(chr(ord(a) ^ ord(b)) for a, b in zip(unpacked_dsn, NONCE * (len(unpacked_dsn) // len(NONCE) + 1)))
+    compressed = zlib.compress(xored.encode())
+    return base64.b64encode(compressed).decode()
+
+
+def dsn_unpack(packed_dsn: str) -> str:
+    # Reverse the packing process
+    decoded = base64.b64decode(packed_dsn)
+    decompressed = zlib.decompress(decoded).decode()
+    return "".join(chr(ord(a) ^ ord(b)) for a, b in zip(decompressed, NONCE * (len(decompressed) // len(NONCE) + 1)))

{dfsync-0.4.9 → dfsync-0.4.11}/dfsync/monitor.py

@@ -1,31 +1,37 @@
-import click
+import logging
 import os
 import os.path
+import queue
 import sys
 import time
-import logging
-import queue
-
-from click_default_group import DefaultGroup
 from contextlib import contextmanager
 from functools import partial
-from watchdog.observers import Observer
+
+import click
+import sentry_sdk
+from click_default_group import DefaultGroup
 from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
 
 import dfsync.filters as filters
-from dfsync.backends import rsync_backend, kube_backend
+import dfsync.lib as lib
+from dfsync.backends import kube_backend, rsync_backend
+from dfsync.backends.rsync import set_rsync_executable
+from dfsync.char_ui import KeyController
+from dfsync.config import read_config
 from dfsync.distribution import (
+    AsyncVersionChecker,
     get_installed_version,
     get_latest_version,
-    is_older_version,
-    AsyncVersionChecker,
     is_installed_in_editable_mode,
+    is_older_version,
     update_package,
 )
-from dfsync.config import read_config
-from dfsync.char_ui import KeyController
-from dfsync.kube_credentials import contextualize_kube_credentials, update_local_kube_config, normalized_k8s_url
-from dfsync.lib import ControlledThreadedOperation, thread_manager
+from dfsync.kube_credentials import (
+    contextualize_kube_credentials,
+    normalized_k8s_url,
+    update_local_kube_config,
+)
 
 logging.basicConfig(level=logging.WARN)
 
@@ -34,6 +40,7 @@ BACKENDS = {
     "file-rsync": rsync_backend,
     "kube-rsync": kube_backend,
 }
+SENTRY_DSN = "eJyzEpVxkQ+O9gpKYAoIdwyKFinjYnZ04gnSjXXhTg/xFEwOiA+Li/ENULSP4+Rh5JCS0Y33lpThZlDmZ2MwlhOUqg0CAPv5DeE="
 
 
 class IgnoreEvent(Exception):
@@ -44,7 +51,11 @@ class RelatedLocationsError(ValueError):
     pass
 
 
-class FileChangedEventHandler(ControlledThreadedOperation, FileSystemEventHandler):
+class UnsupportedRsyncError(ValueError):
+    pass
+
+
+class FileChangedEventHandler(lib.ControlledThreadedOperation, FileSystemEventHandler):
     def __init__(
         self,
         backend: str = "log",
@@ -258,11 +269,12 @@ def main():
     pass
 
 
-@main.command()
+@main.command(add_help_option=False)
 def version():
     """
     Print the currently installed version
     """
+    sentry_sdk.set_tag("command", "version")
     _version()
 
 
@@ -279,21 +291,21 @@ def _version():
         click.echo(f"Latest version is {latest_version}, please update using `dfsync self-update`")
 
 
-@main.command(name="help", context_settings=dict(ignore_unknown_options=True))
-@click.option("--help", is_flag=True, default=False, hidden=True)
-def help(help):
+@main.command(name="help", add_help_option=False)
+def help():
     """
     Print the usage/help for dfsync
     """
-    with click.Context(sync, info_name="dfsync") as ctx:
+    with click.Context(sync, info_name="dfsync", max_content_width=999) as ctx:
         click.echo(sync.get_help(ctx))
 
 
-@main.command()
+@main.command(add_help_option=False)
 def self_update():
     """
     Update dfsync to the latest version published on pypi
     """
+    sentry_sdk.set_tag("command", "self_update")
     latest_version = get_latest_version()
     installed_version = get_installed_version()
     if not is_older_version(installed_version, latest_version):
@@ -316,6 +328,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
     """
+    sentry_sdk.set_tag("command", "import_kube_host")
     patch = contextualize_kube_credentials(normalized_k8s_url(kube_host), credentials)
     update_local_kube_config(patch)
 
@@ -363,6 +376,7 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync, ver
     * editor-aware: changes to temporary files created by source code editors will be ignored
     * transparent: every action is diligently logged in the console
     """
+    sentry_sdk.set_tag("command", "sync")
     logging.basicConfig(
         level=logging.WARN,
         format="%(asctime)s - %(message)s",
@@ -389,12 +403,22 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync, ver
         click.echo(f"Source file/dirs not found: {', '.join(missing)}")
 
     backend, destination_dir = split_destination(destination_dir)
+    sentry_sdk.set_tag("sync-backend", backend)
     try:
         if len(paths) == 0:
             raise ValueError("No source file/dirs found")
         elif len(missing) > 0:
             click.echo(f"Using source file/dirs {', '.join(paths)}")
 
+        if backend == "kube-rsync":
+            installed_rsync = lib.check_rsync()
+            if installed_rsync != lib.RsyncFlavour.SAMBA_RSYNC and lib.RsyncFlavour.SAMBA_RSYNC.exists_installed:
+                set_rsync_executable(lib.RsyncFlavour.SAMBA_RSYNC.executable)
+            elif installed_rsync != lib.RsyncFlavour.SAMBA_RSYNC:
+                click.echo(f"Found rsync: {installed_rsync.executable}")
+                raise UnsupportedRsyncError()
+
+        sentry_sdk.set_tag("sync-backend", backend)
         backend_options = dict(
             destination_dir=destination_dir,
             supervisor=supervisor,
@@ -423,6 +447,14 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync, ver
         click.echo(str(e))
         return -1
 
+    except UnsupportedRsyncError:
+        click.echo(
+            "\nStarting from Mac OSX Sequoia 15.4, Apple are shipping openrsync instead of the GPL-licensed rsync from Samba"
+            "\nThe Apple version of rsync has less features and is currently not supported by dfsync"
+            "\nPlease use homebrew to install the GPL-licensed rsync from Samba with this command `brew install rsync`."
+        )
+        return -1
+
     except ValueError as e:
         click.echo(
             "Trying {} from source: {} to destination: '{}'\n".format(
@@ -432,6 +464,7 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync, ver
             )
         )
         click.echo(str(e))
+        sentry_sdk.capture_exception(e)
         return -1
 
     checker = AsyncVersionChecker()
@@ -455,7 +488,7 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync, ver
     controller.on_key(
         "x",
         description="to exit",
-        action=partial(thread_manager.stop, "Exiting."),
+        action=partial(lib.thread_manager.stop, "Exiting."),
     )
 
     try:
@@ -481,16 +514,16 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync, ver
             controller.raise_exceptions()
 
     except KeyboardInterrupt:
-        thread_manager.stop()
+        lib.thread_manager.stop()
         click.echo("Received [Ctrl-C], exiting.")
 
     except:
-        thread_manager.stop()
+        lib.thread_manager.stop()
         raise
 
     finally:
         observer.stop()
-        thread_manager.stop()
+        lib.thread_manager.stop()
         backend_engine.on_monitor_exit(**backend_options)
         if observer.ident is not None:
             # only join the observer if it was previously started
@@ -498,4 +531,8 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync, ver
 
 
 if __name__ == "__main__":
+    sentry_sdk.init(
+        lib.dsn_unpack(SENTRY_DSN),
+        release=f"dfsync@{get_installed_version()}",
+    )
     sys.exit(main() or 0)

dfsync-0.4.11/dfsync/sentry.py

@@ -0,0 +1,9 @@
+import sentry_sdk
+
+sentry_sdk.init(
+    dsn="http://7717d7a6e4bf47fd850192acb50accd4@10.6.1.11//1",
+)
+try:
+    1 / 0
+except Exception as e:
+    sentry_sdk.capture_exception(e)

dfsync-0.4.11/dfsync/test_filters.py

@@ -0,0 +1,28 @@
+from dfsync.filters import USER_FILTERS, PythonBlackFilter, PythonSyntaxFilter
+
+
+def test_rejects_python_that_does_not_parse(tmp_path):
+    src = tmp_path / "broken.py"
+    src.write_text("def f(:\n")
+    assert PythonSyntaxFilter().is_filtered(src_file_path=str(src))
+
+
+def test_syncs_valid_python_even_if_not_formatted(tmp_path):
+    src = tmp_path / "ugly.py"
+    src.write_text("x  =  [1,\n2]\n")
+    assert not PythonSyntaxFilter().is_filtered(src_file_path=str(src))
+
+
+def test_ignores_files_that_are_not_python(tmp_path):
+    src = tmp_path / "notes.txt"
+    src.write_text("def f(:\n")
+    assert not PythonSyntaxFilter().is_filtered(src_file_path=str(src))
+
+
+def test_syncs_a_deleted_file(tmp_path):
+    assert not PythonSyntaxFilter().is_filtered(src_file_path=str(tmp_path / "gone.py"))
+
+
+def test_old_name_still_works():
+    assert PythonBlackFilter is PythonSyntaxFilter
+    assert any(isinstance(f, PythonSyntaxFilter) for f in USER_FILTERS)

{dfsync-0.4.9 → dfsync-0.4.11}/dfsync/test_lib.py

@@ -1,5 +1,4 @@
-import pytest
-from dfsync.lib import ControlledThreadedOperation, ThreadedOperationsManager
+from dfsync.lib import ControlledThreadedOperation, ThreadedOperationsManager, dsn_pack, dsn_unpack
 
 
 def test_threaded_operations_manager():
@@ -26,3 +25,24 @@ def test_controlled_threaded_operation():
     operation.stop()
     assert not operation.is_running
     assert operation.is_completed
+
+
+def test_dsn_pack_unpack():
+    # Test basic packing and unpacking
+    original_dsn = "test_dsn_string"
+    packed = dsn_pack(original_dsn)
+    unpacked = dsn_unpack(packed)
+    assert unpacked == original_dsn
+
+    # Test with empty string
+    assert dsn_unpack(dsn_pack("")) == ""
+
+    # Test with longer string
+    long_dsn = "https://very.long.dsn.string.with.special/characters?key=value&other=123"
+    assert dsn_unpack(dsn_pack(long_dsn)) == long_dsn
+
+    # Test that packed value is different from original
+    assert dsn_pack("test") != "test"
+
+    # Test that consecutive packs produce same result
+    assert dsn_pack("test") == dsn_pack("test")

{dfsync-0.4.9 → dfsync-0.4.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dfsync"
-version = "0.4.9"
+version = "0.4.11"
 description = ""
 authors = ["Mihai Balint <balint.mihai@gmail.com>"]
 
@@ -14,9 +14,9 @@ toml = "^0.10.2"
 tenacity = "^8.0.1"
 click-default-group = "^1.2.2"
 paramiko = {version = "^3.2.0", extras = ["invoke"]}
-black = "24.3.0"
+sentry-sdk = "^2.26.0"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
 pytest = "^7.4"
 pytest_mock = "^3.12"
 ipython = "^8"

dfsync-0.4.9/dfsync/lib.py

@@ -1,49 +0,0 @@
-import time
-import threading
-
-
-class ThreadedOperationsManager:
-    def __init__(self):
-        self.threads = []
-
-    def stop(self, *args, **kwargs):
-        for thread in self.threads:
-            thread.stop(*args, **kwargs)
-
-    def register_threaded_operation(self, op):
-        self.threads.append(op)
-
-
-thread_manager = ThreadedOperationsManager()
-
-
-class ControlledThreadedOperation:
-    def __init__(self):
-        self._running = False
-        self._thread = threading.Thread(target=self.run)
-        thread_manager.register_threaded_operation(self)
-
-    def start(self):
-        self._running = True
-        self._thread.start()
-
-    def stop(self, *args, **kwargs):
-        self._running = False
-
-    @property
-    def is_running(self):
-        return self._running
-
-    @property
-    def is_completed(self):
-        return self._running is False
-
-    def run(self):
-        while self._running:
-            try:
-                self._run_once()
-            except Exception:
-                time.sleep(0.001)
-
-    def _run_once(self):
-        time.sleep(0.001)