dfsync 0.4.10__tar.gz → 0.4.11__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: dfsync
-Version: 0.4.10
+Version: 0.4.11
 Summary: 
 Author: Mihai Balint
 Author-email: balint.mihai@gmail.com
@@ -12,12 +12,13 @@ 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)
+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.10 → 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.10 → 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.10 → 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.10 → dfsync-0.4.11}/dfsync/lib.py

@@ -1,8 +1,10 @@
+import base64
 from enum import Enum
 import platform
 import subprocess
 import time
 import threading
+import zlib
 
 
 class ThreadedOperationsManager:
@@ -99,3 +101,20 @@ def check_rsync() -> RsyncFlavour:
     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.10 → 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
 import dfsync.lib as lib
-from dfsync.backends import rsync_backend, kube_backend
+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.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):
@@ -267,6 +274,7 @@ def version():
     """
     Print the currently installed version
     """
+    sentry_sdk.set_tag("command", "version")
     _version()
 
 
@@ -297,6 +305,7 @@ 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):
@@ -319,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)
 
@@ -366,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",
@@ -392,17 +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)}")
 
-        installed_rsync = lib.check_rsync()
-        click.echo(f"Installed: {installed_rsync.executable}")
-        if installed_rsync != lib.RsyncFlavour.SAMBA_RSYNC:
-            raise UnsupportedRsyncError()
+        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,
@@ -448,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()
@@ -514,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.10 → 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.10 → dfsync-0.4.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dfsync"
-version = "0.4.10"
+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"