dfsync 0.4.9__tar.gz → 0.4.10__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: dfsync
-Version: 0.4.9
+Version: 0.4.10
 Summary: 
 Author: Mihai Balint
 Author-email: balint.mihai@gmail.com
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: black (==24.3.0)
 Requires-Dist: click (>=8,<9)
 Requires-Dist: click-default-group (>=1.2.2,<2.0.0)

dfsync-0.4.10/dfsync/lib.py

@@ -0,0 +1,101 @@
+from enum import Enum
+import platform
+import subprocess
+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)
+
+
+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

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

@@ -13,6 +13,7 @@ from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
 
 import dfsync.filters as filters
+import dfsync.lib as lib
 from dfsync.backends import rsync_backend, kube_backend
 from dfsync.distribution import (
     get_installed_version,
@@ -25,7 +26,6 @@ from dfsync.distribution import (
 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
 
 logging.basicConfig(level=logging.WARN)
 
@@ -44,7 +44,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,7 +262,7 @@ def main():
     pass
 
 
-@main.command()
+@main.command(add_help_option=False)
 def version():
     """
     Print the currently installed version
@@ -279,17 +283,16 @@ 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
@@ -395,6 +398,11 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync, ver
         elif len(missing) > 0:
             click.echo(f"Using source file/dirs {', '.join(paths)}")
 
+        installed_rsync = lib.check_rsync()
+        click.echo(f"Installed: {installed_rsync.executable}")
+        if installed_rsync != lib.RsyncFlavour.SAMBA_RSYNC:
+            raise UnsupportedRsyncError()
+
         backend_options = dict(
             destination_dir=destination_dir,
             supervisor=supervisor,
@@ -423,6 +431,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(
@@ -455,7 +471,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 +497,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

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

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

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)