safekeep 0.3.0__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: safekeep
-Version: 0.3.0
+Version: 0.3.1
 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.0 → safekeep-0.3.1}/safekeep/__init__.py

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

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

@@ -14,11 +14,14 @@ from safekeep.copier import TMP_INFIX
 from safekeep.daemon import Daemon, setup_logging
 from safekeep.platform import (
     INOTIFY_MIN_WATCHES,
+    LOG_PATH,
     fswatch_monitor,
     inotify_limit,
     install_hint,
     is_darwin,
     is_linux,
+    linger_enabled,
+    recent_permission_errors,
 )
 from safekeep.volumes import dest_state
 
@@ -54,7 +57,8 @@ def build_parser():
                    help='config, progetti e stato delle dest — sola lettura')
     sub.add_parser('doctor', parents=[common],
                    help='diagnostica: config, fswatch + monitor di piattaforma, python, '
-                        'TCC/plist (macOS), inotify/systemd (Linux) — exit ≠ 0 se un check '
+                        'errori di permesso recenti nel log, TCC/plist (macOS), '
+                        'inotify/systemd/linger (Linux) — exit ≠ 0 se un check '
                         'fatale fallisce')
     return parser
 
@@ -226,6 +230,20 @@ def cmd_doctor(args):
     out(sys.version_info >= (3, 9),
         f'python {sys.version.split()[0]} (≥ 3.9)', is_fatal=True)
 
+    # Errori di permesso recenti nel log corrente (SPEC.md §14.4): sintomo
+    # delle ultime 24h, non stato del sistema → sempre NON fatale
+    log = os.path.expanduser(LOG_PATH)
+    recent = recent_permission_errors()
+    if recent is None:
+        out(True, f'errori di permesso recenti: log assente — check saltato ({log})')
+    elif recent[0] > 0:
+        out(False, f'errori di permesso recenti: {recent[0]} nelle ultime 24h '
+                   f'(ultimo: {recent[1]}) — log: {log} — warning non fatale: '
+                   'vedi i pending con `safekeep sync-once --dry-run`, poi '
+                   'riconcedere i permessi al volume (FDA/Full Disk Access)')
+    else:
+        out(True, f'errori di permesso recenti: nessuno nelle ultime 24h — log: {log}')
+
     # Linux: il limite di watch di inotify è il rischio #1 sugli alberi grandi
     # (SPEC.md §14.4) — informativo, NON fatale
     if is_linux():
@@ -296,6 +314,17 @@ def cmd_doctor(args):
                                'del template — rilancia install.sh', is_fatal=True)
                 else:
                     out(True, f'unit systemd: {unit}')
+            # linger: solo dove la unit è installata (SPEC.md §14.4) — non fatale
+            enabled = linger_enabled()
+            if enabled is None:
+                out(True, 'linger: non verificabile (/var/lib/systemd/linger '
+                          'assente) — check saltato')
+            elif enabled:
+                out(True, 'linger: abilitato (agent al boot anche senza login)')
+            else:
+                out(False, "linger: NON abilitato — l'agent non partirà al boot "
+                           'senza login → loginctl enable-linger $USER — '
+                           'warning non fatale')
 
     return 1 if fatal else 0
 

{safekeep-0.3.0 → safekeep-0.3.1}/safekeep/daemon.py

@@ -27,7 +27,7 @@ from .config import (
 )
 from .copier import MOUNT_ERRNOS, copy_one, needs_copy, prune_project, reconcile_project
 from .matcher import BUILTIN_RULES, Matcher, _glob, parse_rule
-from .platform import fswatch_monitor, init_system
+from .platform import LOG_PATH, fswatch_monitor, init_system
 from .volumes import backoff_schedule, dest_state, partition_dests
 
 log = logging.getLogger('safekeep')
@@ -271,7 +271,7 @@ def setup_logging(level='info', logfile=None):
     logger._safekeep_handlers = True
     fmt = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
     if logfile is None:
-        logfile = os.path.expanduser('~/.local/state/safekeep/safekeep.log')
+        logfile = os.path.expanduser(LOG_PATH)
     try:
         os.makedirs(os.path.dirname(logfile), exist_ok=True)
         handler = logging.handlers.RotatingFileHandler(

safekeep-0.3.1/safekeep/platform.py

@@ -0,0 +1,119 @@
+"""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.
+
+I nomi dei monitor sono quelli stampati da `fswatch -M`: `fsevents_monitor`
+(FSEvents, macOS) e `inotify_monitor` (inotify, Linux) — attenzione, su Linux
+il nome NON è `inotify` (SPEC.md §14.2).
+"""
+import getpass
+import os
+import re
+import shutil
+import sys
+from datetime import datetime
+
+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'
+# 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')
+
+
+def is_darwin():
+    return sys.platform == 'darwin'
+
+
+def is_linux():
+    return sys.platform == 'linux'
+
+
+def fswatch_monitor():
+    """Monitor fswatch per la piattaforma (SPEC.md §14.2), usato da
+    `daemon.fswatch_argv()` e dal check monitor di `doctor`."""
+    return 'fsevents_monitor' if is_darwin() else 'inotify_monitor'
+
+
+def init_system():
+    """`launchd` (Darwin) o `systemd` (Linux) — SPEC.md §14.3."""
+    return 'launchd' if is_darwin() else 'systemd'
+
+
+def install_hint():
+    """Come installare `fswatch` su questa macchina (SPEC.md §14.4)."""
+    if is_darwin():
+        return 'brew install fswatch'
+    for pm, cmd in (('pacman', 'pacman -S fswatch'),
+                    ('apt-get', 'sudo apt-get install fswatch'),
+                    ('dnf', 'sudo dnf install fswatch')):
+        if shutil.which(pm):
+            return cmd
+    return 'installa fswatch col package manager della tua distro'
+
+
+def inotify_limit(path=INOTIFY_LIMIT_PATH):
+    """`fs.inotify.max_user_watches`, o None se il file non c'è o è illeggibile
+    (SPEC.md §14.4: su Linux è il rischio #1 sugli alberi grandi)."""
+    try:
+        with open(path) as fh:
+            return int(fh.read().strip())
+    except (OSError, ValueError):
+        return None
+
+
+def recent_permission_errors(path=None, now=None, window=86400):
+    """`(conteggio, ultimo timestamp)` degli errori di permesso nelle ultime
+    `window` secondi del log corrente, o None se il log non c'è/non è leggibile
+    (SPEC.md §14.4: check non fatale, finestra 24h — segue l'incidente EPERM).
+
+    Il timestamp è il prefisso `%(asctime)s` della riga (`YYYY-MM-DD HH:MM:SS`,
+    prime 19 posizioni). **Limite dichiarato**: una riga senza timestamp
+    parsificabile o fuori dalla finestra (clock skew incluso) non viene contata —
+    non essendo sicuri che sia recente, non la contiamo: il conteggio è un minimo."""
+    if path is None:
+        path = os.path.expanduser(LOG_PATH)
+    if now is None:
+        now = datetime.now()
+    count, last = 0, None
+    try:
+        with open(path, encoding='utf-8', errors='replace') as fh:
+            for line in fh:
+                if not PERM_ERR_RE.search(line):
+                    continue
+                try:
+                    ts = datetime.strptime(line[:19], '%Y-%m-%d %H:%M:%S')
+                except ValueError:
+                    continue        # timestamp illeggibile → non sicuri, salta
+                age = (now - ts).total_seconds()
+                if not 0 <= age <= window:
+                    continue        # troppo vecchio (o nel futuro: clock skew)
+                count += 1
+                if last is None or ts > last:
+                    last = ts
+    except OSError:
+        return None
+    return count, last
+
+
+def linger_enabled(user=None, linger_dir=None):
+    """`True`/`False` se l'utente è in `/var/lib/systemd/linger/`, None se la
+    directory non c'è (niente systemd → non determinabile, SPEC.md §14.4).
+    Legge la directory direttamente: stessa informazione di
+    `loginctl show-user $USER -p Linger`, senza root."""
+    if linger_dir is None:
+        linger_dir = LINGER_DIR
+    try:
+        entries = os.listdir(linger_dir)
+    except OSError:
+        return None
+    if user is None:
+        try:
+            user = getpass.getuser()
+        except OSError:
+            return None
+    return user in entries

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: safekeep
-Version: 0.3.0
+Version: 0.3.1
 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.0 → safekeep-0.3.1}/tests/test_cli.py

@@ -4,6 +4,7 @@ Ogni run è un subprocess con HOME finto: niente scritture nella home reale.
 """
 import argparse
 import contextlib
+import getpass
 import io
 import os
 import shutil
@@ -11,9 +12,10 @@ import subprocess
 import sys
 import tempfile
 import unittest
+from datetime import datetime, timedelta
 from unittest import mock
 
-from safekeep import cli
+from safekeep import cli, platform as plat
 from safekeep.platform import fswatch_monitor
 
 REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@@ -271,5 +273,95 @@ class PruneCliTest(CliTestCase):
             self.assertTrue(os.path.exists(os.path.join(self.dest, keep)), keep)
 
 
+class DoctorPermessiRecentiTest(CliTestCase):
+    """SPEC.md §14.4: errori di permesso nel log corrente — finestra 24h,
+    warning non fatale, log assente ⇒ check saltato."""
+
+    def log_path(self):
+        return os.path.join(self.home, '.local/state/safekeep/safekeep.log')
+
+    @staticmethod
+    def stamp(delta):
+        return (datetime.now() - delta).strftime('%Y-%m-%d %H:%M:%S,000')
+
+    def riga(self, delta, msg='[Errno 1] Operation not permitted: /x.tmp.1'):
+        return f'{self.stamp(delta)} ERROR copia fallita a → b: {msg}\n'
+
+    def riga_doctor(self, stdout):
+        self.assertIn('errori di permesso', stdout, stdout)
+        return next(l for l in stdout.splitlines() if 'errori di permesso' in l)
+
+    def test_errore_recente_warning_non_fatale(self):
+        write(self.log_path(), self.riga(timedelta(hours=3)))
+        r = self.cli('doctor', '--config', self.cfg)
+        line = self.riga_doctor(r.stdout)
+        self.assertTrue(line.startswith('✗'), line)
+        for needle in ('nelle ultime 24h', 'warning non fatale',
+                       'sync-once --dry-run', 'Full Disk Access',
+                       self.log_path()):
+            self.assertIn(needle, line, needle)
+        self.assertEqual(r.returncode, 0, r.stdout)      # NON fatale
+
+    def test_errore_vecchio_verde(self):
+        write(self.log_path(),
+              self.riga(timedelta(days=3), '[Errno 13] Permission denied'))
+        r = self.cli('doctor', '--config', self.cfg)
+        line = self.riga_doctor(r.stdout)
+        self.assertTrue(line.startswith('✔'), line)
+        self.assertIn('nessuno nelle ultime 24h', line)
+
+    def test_log_assente_check_saltato(self):
+        r = self.cli('doctor', '--config', self.cfg)     # nessun log nel HOME finto
+        line = self.riga_doctor(r.stdout)
+        self.assertTrue(line.startswith('✔'), line)
+        self.assertIn('check saltato', line)
+
+
+@unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+class DoctorLingerTest(CliTestCase):
+    """SPEC.md §14.4: linger solo dove c'è la unit systemd, warning non fatale."""
+
+    def doctor_linux(self, unit=True, linger=()):
+        if unit:
+            write(os.path.join(self.home, '.config/systemd/user/safekeep.service'),
+                  '[Unit]\nDescription=safekeep\n')
+        linger_dir = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, linger_dir, ignore_errors=True)
+        for name in linger:
+            open(os.path.join(linger_dir, name), 'w').close()
+        args = argparse.Namespace(config=self.cfg, v=False)
+        buf = io.StringIO()
+        with mock.patch.dict(os.environ, {'HOME': self.home}), \
+                mock.patch.object(cli, 'is_linux', return_value=True), \
+                mock.patch.object(cli, 'is_darwin', return_value=False), \
+                mock.patch.object(plat, 'LINGER_DIR', linger_dir), \
+                contextlib.redirect_stdout(buf):
+            code = cli.cmd_doctor(args)
+        return code, buf.getvalue()
+
+    @staticmethod
+    def riga_linger(out):
+        return next(l for l in out.splitlines() if 'linger' in l)
+
+    def test_unit_assenta_niente_linger(self):
+        code, out = self.doctor_linux(unit=False)
+        self.assertNotIn('linger', out, 'il check esiste solo con la unit installata')
+        self.assertEqual(code, 0, out)
+
+    def test_linger_disabilitato_warning_non_fatale(self):
+        code, out = self.doctor_linux(unit=True)
+        line = self.riga_linger(out)
+        self.assertTrue(line.startswith('✗'), line)
+        self.assertIn('loginctl enable-linger', line)
+        self.assertIn('warning non fatale', line)
+        self.assertEqual(code, 0, out)                   # NON fatale
+
+    def test_linger_abilitato_verde(self):
+        code, out = self.doctor_linux(unit=True, linger=(getpass.getuser(),))
+        line = self.riga_linger(out)
+        self.assertTrue(line.startswith('✔'), line)
+        self.assertEqual(code, 0, out)
+
+
 if __name__ == '__main__':
     unittest.main()

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

@@ -8,6 +8,7 @@ import shutil
 import subprocess
 import tempfile
 import unittest
+from datetime import datetime, timedelta
 from unittest import mock
 
 from safekeep import platform as plat
@@ -146,5 +147,85 @@ class AgentTemplateTest(unittest.TestCase):
             self.assertIn(needle, text, needle)
 
 
+class RecentPermissionErrorsTest(unittest.TestCase):
+    """SPEC.md §14.4: errori di permesso recenti nel log, finestra 24h,
+    non fatale; righe senza timestamp sicuro non vengono contate."""
+
+    NOW = datetime(2026, 10, 4, 20, 0, 0)
+
+    def _log(self, text):
+        fd, path = tempfile.mkstemp(suffix='.log')
+        self.addCleanup(os.unlink, path)
+        with os.fdopen(fd, 'w') as fh:
+            fh.write(text)
+        return path
+
+    @staticmethod
+    def _stamp(dt):
+        return dt.strftime('%Y-%m-%d %H:%M:%S,000')   # formato %(asctime)s
+
+    def test_ricente_vecchio_e_normale_nello_stesso_log(self):
+        text = (
+            f'{self._stamp(self.NOW - timedelta(hours=2))} ERROR copia fallita '
+            "a → b: [Errno 1] Operation not permitted: '/x.tmp.1'\n"
+            f'{self._stamp(self.NOW - timedelta(days=3))} ERROR copia fallita '
+            "a → b: [Errno 13] Permission denied: '/y'\n"
+            f'{self._stamp(self.NOW - timedelta(minutes=5))} INFO reconcile: 0 copie\n'
+        )
+        count, last = plat.recent_permission_errors(self._log(text), now=self.NOW)
+        self.assertEqual(count, 1, 'solo la riga nelle ultime 24h')
+        self.assertEqual(last, self.NOW - timedelta(hours=2))
+
+    def test_log_assente(self):
+        self.assertIsNone(
+            plat.recent_permission_errors('/non/esiste/safekeep.log'),
+            'nessun log ⇒ check saltato, non warning')
+
+    def test_timestamp_illeggibile_non_e_contato(self):
+        text = ("senza-data ERROR [Errno 1] Operation not permitted: '/x'\n"
+                + f'{self._stamp(self.NOW - timedelta(hours=1))} ERROR '
+                  "[Errno 1] Operation not permitted: '/y'\n"
+                + f'{self._stamp(self.NOW + timedelta(hours=1))} ERROR '
+                  "[Errno 1] Operation not permitted: '/z'\n")
+        count, _ = plat.recent_permission_errors(self._log(text), now=self.NOW)
+        self.assertEqual(count, 1, 'non sicuri (o clock skew) ⇒ non contiamo')
+
+    def test_copre_eperm_e_eacces(self):
+        for riga in ('[Errno 1] Operation not permitted',
+                     'qualcosa Operation not permitted',
+                     '[Errno 13] Permission denied',
+                     'qualcosa Permission denied'):
+            with self.subTest(riga=riga):
+                self.assertIsNotNone(plat.PERM_ERR_RE.search(riga))
+        self.assertIsNone(plat.PERM_ERR_RE.search('INFO reconcile: 0 copie'))
+
+
+class LingerTest(unittest.TestCase):
+    """SPEC.md §14.4: linger systemd, directory finta al posto di
+    /var/lib/systemd/linger."""
+
+    def _dir(self, *entries):
+        path = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, path, ignore_errors=True)
+        for name in entries:
+            open(os.path.join(path, name), 'w').close()
+        return path
+
+    def test_abilitato_disabilitato_e_dir_assente(self):
+        d = self._dir('utente')
+        self.assertTrue(plat.linger_enabled(user='utente', linger_dir=d))
+        self.assertFalse(plat.linger_enabled(user='altro', linger_dir=d))
+        self.assertIsNone(
+            plat.linger_enabled(user='utente',
+                                linger_dir=os.path.join(os.sep, 'niente', 'qui')),
+            'niente systemd ⇒ non determinabile, check saltato')
+
+    def test_user_default_e_costante(self):
+        self.assertEqual(plat.LINGER_DIR, '/var/lib/systemd/linger')
+        with mock.patch('getpass.getuser', return_value='chi'):
+            self.assertTrue(plat.linger_enabled(linger_dir=self._dir('chi')))
+            self.assertFalse(plat.linger_enabled(linger_dir=self._dir()))
+
+
 if __name__ == '__main__':
     unittest.main()

safekeep-0.3.0/safekeep/platform.py

@@ -1,57 +0,0 @@
-"""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. 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
-il nome NON è `inotify` (SPEC.md §14.2).
-"""
-import shutil
-import sys
-
-INOTIFY_LIMIT_PATH = '/proc/sys/fs/inotify/max_user_watches'
-INOTIFY_MIN_WATCHES = 16384        # sotto questa soglia un home medio lo supera
-
-
-def is_darwin():
-    return sys.platform == 'darwin'
-
-
-def is_linux():
-    return sys.platform == 'linux'
-
-
-def fswatch_monitor():
-    """Monitor fswatch per la piattaforma (SPEC.md §14.2), usato da
-    `daemon.fswatch_argv()` e dal check monitor di `doctor`."""
-    return 'fsevents_monitor' if is_darwin() else 'inotify_monitor'
-
-
-def init_system():
-    """`launchd` (Darwin) o `systemd` (Linux) — SPEC.md §14.3."""
-    return 'launchd' if is_darwin() else 'systemd'
-
-
-def install_hint():
-    """Come installare `fswatch` su questa macchina (SPEC.md §14.4)."""
-    if is_darwin():
-        return 'brew install fswatch'
-    for pm, cmd in (('pacman', 'pacman -S fswatch'),
-                    ('apt-get', 'sudo apt-get install fswatch'),
-                    ('dnf', 'sudo dnf install fswatch')):
-        if shutil.which(pm):
-            return cmd
-    return 'installa fswatch col package manager della tua distro'
-
-
-def inotify_limit(path=INOTIFY_LIMIT_PATH):
-    """`fs.inotify.max_user_watches`, o None se il file non c'è o è illeggibile
-    (SPEC.md §14.4: su Linux è il rischio #1 sugli alberi grandi)."""
-    try:
-        with open(path) as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        return None