safekeep 0.3.1__tar.gz → 0.4.0__tar.gz

{safekeep-0.3.1/safekeep.egg-info → safekeep-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: safekeep
-Version: 0.3.1
+Version: 0.4.0
 Summary: Selective always-on backups for macOS and Linux: fswatch-driven copy of allow-listed files, never deletes
 License-Expression: MIT
 Project-URL: Repository, https://github.com/foxhound87/safekeep

{safekeep-0.3.1 → safekeep-0.4.0}/safekeep/__init__.py

@@ -3,4 +3,4 @@ import logging
 
 logging.getLogger('safekeep').addHandler(logging.NullHandler())
 
-__version__ = '0.3.1'
+__version__ = '0.4.0'

{safekeep-0.3.1 → safekeep-0.4.0}/safekeep/cli.py

@@ -20,8 +20,11 @@ from safekeep.platform import (
     install_hint,
     is_darwin,
     is_linux,
+    is_wsl,
     linger_enabled,
     recent_permission_errors,
+    systemd_user_available,
+    wsl_distro,
 )
 from safekeep.volumes import dest_state
 
@@ -244,6 +247,23 @@ def cmd_doctor(args):
     else:
         out(True, f'errori di permesso recenti: nessuno nelle ultime 24h — log: {log}')
 
+    # WSL (SPEC.md §17.2): tre righe informative — nessuna è mai fatale
+    if is_wsl():
+        out(True, f'WSL rilevato: {wsl_distro() or "sconosciuta"} '
+                  '(supporto best-effort, SPEC §17)')
+        if not systemd_user_available():
+            out(False, 'systemd user non disponibile (WSL1 o systemd spento) — '
+                       'abilita systemd in /etc/wsl.conf: [boot] systemd=true '
+                       '(poi wsl --shutdown da Windows) oppure esegui '
+                       '`safekeep run` a mano — warning non fatale')
+        if daemon is not None:
+            sotto_mnt = [p for p in list(daemon.cfg.sources)
+                         + list(daemon.cfg.dests) if p.startswith('/mnt/')]
+            if sotto_mnt:
+                out(True, f'drvfs: {len(sotto_mnt)} path sotto /mnt/ — I/O lento '
+                          'e case-insensitive di default: valuta una dest su ext4 '
+                          'nativa della distro (SPEC §17.2)')
+
     # Linux: il limite di watch di inotify è il rischio #1 sugli alberi grandi
     # (SPEC.md §14.4) — informativo, NON fatale
     if is_linux():

{safekeep-0.3.1 → safekeep-0.4.0}/safekeep/platform.py

@@ -1,9 +1,10 @@
 """Rilevamento piattaforma (SPEC.md §14.1): l'unico posto che legge `sys.platform`.
 
 Funzioni/constanti minime: monitor fswatch atteso, hint di installazione,
-init system, limite di watch di inotify, log corrente, linger systemd.
-Tutto letto **a chiamata** (mai a import), così i test patchano `sys.platform`
-ed esercitano entrambi i rami anche girando su una sola piattaforma.
+init system, limite di watch di inotify, log corrente, linger systemd,
+rilevamento WSL. Tutto letto **a chiamata** (mai a import), così i test
+patchano `sys.platform` ed esercitano entrambi i rami anche girando su una
+sola piattaforma.
 
 I nomi dei monitor sono quelli stampati da `fswatch -M`: `fsevents_monitor`
 (FSEvents, macOS) e `inotify_monitor` (inotify, Linux) — attenzione, su Linux
@@ -11,6 +12,7 @@ il nome NON è `inotify` (SPEC.md §14.2).
 """
 import getpass
 import os
+import platform as _platform
 import re
 import shutil
 import sys
@@ -20,6 +22,7 @@ INOTIFY_LIMIT_PATH = '/proc/sys/fs/inotify/max_user_watches'
 INOTIFY_MIN_WATCHES = 16384        # sotto questa soglia un home medio lo supera
 LOG_PATH = '~/.local/state/safekeep/safekeep.log'   # log corrente (SPEC.md §3)
 LINGER_DIR = '/var/lib/systemd/linger'
+SYSTEMD_RUN_PATH = '/run/systemd/system'            # assente su WSL1/systemd off
 # EPERM (Errno 1) / EACCES (Errno 13) come li scrive il logger: codice errno
 # + testo del kernel (SPEC.md §14.4)
 PERM_ERR_RE = re.compile(r'\[Errno (?:1|13)\]|Operation not permitted|Permission denied')
@@ -117,3 +120,28 @@ def linger_enabled(user=None, linger_dir=None):
         except OSError:
             return None
     return user in entries
+
+
+def is_wsl():
+    """True dentro WSL (Windows Subsystem for Linux) — SPEC.md §17.1.
+
+    `sys.platform` resta `linux` su WSL: il rilevamento passa dall'env
+    `WSL_DISTRO_NAME` (ogni distro WSL lo settà) oppure dal kernel
+    (`platform.release()` contiene `microsoft` su WSL1 e WSL2)."""
+    if os.environ.get('WSL_DISTRO_NAME'):
+        return True
+    return 'microsoft' in _platform.release().lower()
+
+
+def wsl_distro():
+    """Nome della distro WSL (env `WSL_DISTRO_NAME`), vuoto se assente —
+    SPEC.md §17.1."""
+    return os.environ.get('WSL_DISTRO_NAME', '')
+
+
+def systemd_user_available(path=None):
+    """True se c'è un init systemd vivo (`/run/systemd/system`): assente su
+    WSL1 o con systemd spento in WSL2 — SPEC.md §17.2."""
+    if path is None:
+        path = SYSTEMD_RUN_PATH
+    return os.path.exists(path)

{safekeep-0.3.1 → safekeep-0.4.0/safekeep.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: safekeep
-Version: 0.3.1
+Version: 0.4.0
 Summary: Selective always-on backups for macOS and Linux: fswatch-driven copy of allow-listed files, never deletes
 License-Expression: MIT
 Project-URL: Repository, https://github.com/foxhound87/safekeep

{safekeep-0.3.1 → safekeep-0.4.0}/tests/test_cli.py

@@ -363,5 +363,68 @@ class DoctorLingerTest(CliTestCase):
         self.assertEqual(code, 0, out)
 
 
+class DoctorWslTest(CliTestCase):
+    """SPEC.md §17.2: le tre righe WSL di `doctor` sono informative e non fatali."""
+
+    def doctor_wsl(self, distro='Ubuntu', systemd=False, dest='/mnt/c/backup'):
+        cfg = write(os.path.join(self.tmp, 'wsl.cfg'), f'dest: {dest}\n')
+        args = argparse.Namespace(config=cfg, v=False)
+        buf = io.StringIO()
+        with mock.patch.dict(os.environ, {'HOME': self.home}), \
+                mock.patch.object(cli, 'is_wsl', return_value=True), \
+                mock.patch.object(cli, 'wsl_distro', return_value=distro), \
+                mock.patch.object(cli, 'systemd_user_available',
+                                  return_value=systemd), \
+                contextlib.redirect_stdout(buf):
+            code = cli.cmd_doctor(args)
+        return code, buf.getvalue()
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_wsle_righe_con_hint_systemd_e_drvfs(self):
+        code, out = self.doctor_wsl()
+        self.assertIn('✔ WSL rilevato: Ubuntu', out)
+        hint = next(l for l in out.splitlines()
+                    if 'systemd user non disponibile' in l)
+        self.assertTrue(hint.startswith('✗'), hint)
+        for needle in ('/etc/wsl.conf', 'systemd=true', 'safekeep run',
+                       'warning non fatale'):
+            self.assertIn(needle, hint, needle)
+        drvfs = next(l for l in out.splitlines() if 'drvfs' in l)
+        self.assertIn('/mnt/', drvfs)
+        self.assertEqual(code, 0, out)                     # mai fatale
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_systemd_attivo_nessun_hint(self):
+        code, out = self.doctor_wsl(systemd=True)
+        self.assertNotIn('systemd user non disponibile', out)
+        self.assertIn('WSL rilevato', out)
+        self.assertEqual(code, 0, out)
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_nessun_path_sotto_mnt_niente_drvfs(self):
+        code, out = self.doctor_wsl(dest=os.path.join(self.tmp, 'dst'))
+        self.assertNotIn('drvfs', out)
+        self.assertEqual(code, 0, out)
+
+    def test_detection_reale_via_env_fino_a_doctor(self):
+        """Detection reale (env) fino all'output di doctor: niente patch."""
+        env = dict(os.environ, HOME=self.home, WSL_DISTRO_NAME='Debian')
+        r = subprocess.run([sys.executable, CLI, 'doctor', '--config', self.cfg],
+                           capture_output=True, text=True, env=env, cwd=REPO,
+                           timeout=60)
+        self.assertIn('WSL rilevato: Debian', r.stdout)
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_senza_wsl_nulla_cambia(self):
+        """Su Linux/macOS non-WSL nessuna riga WSL compare (SPEC §17)."""
+        env = {k: v for k, v in os.environ.items() if k != 'WSL_DISTRO_NAME'}
+        env['HOME'] = self.home
+        r = subprocess.run([sys.executable, CLI, 'doctor', '--config', self.cfg],
+                           capture_output=True, text=True, env=env, cwd=REPO,
+                           timeout=60)
+        self.assertNotIn('WSL', r.stdout)
+        self.assertNotIn('drvfs', r.stdout)
+
+
 if __name__ == '__main__':
     unittest.main()

{safekeep-0.3.1 → safekeep-0.4.0}/tests/test_platform.py

@@ -227,5 +227,70 @@ class LingerTest(unittest.TestCase):
             self.assertFalse(plat.linger_enabled(linger_dir=self._dir()))
 
 
+class WslTest(unittest.TestCase):
+    """SPEC.md §17.1: rilevamento WSL via env o kernel, letto a chiamata."""
+
+    def test_env_wsl_distro_name(self):
+        with mock.patch.dict(os.environ, {'WSL_DISTRO_NAME': 'Ubuntu'}):
+            self.assertTrue(plat.is_wsl())
+            self.assertEqual(plat.wsl_distro(), 'Ubuntu')
+
+    def test_kernel_microsoft_senza_env(self):
+        for release in ('5.15.167.4-microsoft-standard-WSL2',   # WSL2
+                        '4.4.0-19041-Microsoft'):              # WSL1 (maiuscolo)
+            with self.subTest(release=release), \
+                    mock.patch.dict(os.environ, {'WSL_DISTRO_NAME': ''}), \
+                    mock.patch.object(plat, '_platform') as p:
+                p.release.return_value = release
+                self.assertTrue(plat.is_wsl())
+                self.assertEqual(plat.wsl_distro(), '')
+
+    def test_non_wsl(self):
+        with mock.patch.dict(os.environ, {'WSL_DISTRO_NAME': ''}), \
+                mock.patch.object(plat, '_platform') as p:
+            p.release.return_value = '24.6.0'             # macOS, niente microsoft
+            self.assertFalse(plat.is_wsl())
+            self.assertEqual(plat.wsl_distro(), '')
+
+    def test_systemd_user_available(self):
+        with tempfile.TemporaryDirectory() as d:
+            self.assertTrue(plat.systemd_user_available(path=d))
+        self.assertFalse(
+            plat.systemd_user_available(path='/non/esiste/qui'),
+            '/run/systemd/system assente = WSL1 o systemd spento (SPEC §17.2)')
+
+
+@unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+class InstallShSenzaSystemdTest(unittest.TestCase):
+    """SPEC.md §17.3: `install.sh` su Linux senza systemd → unit NON installata,
+    istruzioni di avvio manuale ed exit 0 (nessun errore duro)."""
+
+    def test_ramo_linux_senza_systemd_esce_0(self):
+        if os.path.isdir('/run/systemd/system'):
+            self.skipTest('questa macchina ha systemd: ramo diverso')
+        tmp = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, tmp, ignore_errors=True)
+        home, fake_bin = os.path.join(tmp, 'home'), os.path.join(tmp, 'bin')
+        os.makedirs(home)
+        os.makedirs(fake_bin)
+        uname = os.path.join(fake_bin, 'uname')            # uname finto → Linux
+        with open(uname, 'w') as fh:
+            fh.write('#!/bin/bash\necho Linux\n')
+        os.chmod(uname, 0o755)
+        env = dict(os.environ, HOME=home,
+                   PATH=fake_bin + os.pathsep + os.environ['PATH'])
+        r = subprocess.run(['bash', os.path.join(REPO, 'install.sh')],
+                           capture_output=True, text=True, env=env, timeout=60)
+        self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+        self.assertIn('systemd non disponibile', r.stdout)
+        self.assertIn('safekeep.py run', r.stdout)         # avvio manuale
+        self.assertIn('systemd=true', r.stdout)            # hint /etc/wsl.conf
+        self.assertTrue(os.path.exists(os.path.join(home, '.safekeep')),
+                        'la config viene creata comunque')
+        self.assertFalse(os.path.exists(
+            os.path.join(home, '.config/systemd/user/safekeep.service')),
+            'niente unit senza systemd')
+
+
 if __name__ == '__main__':
     unittest.main()