cleepcli 1.44.0__tar.gz → 1.44.3__tar.gz

{cleepcli-1.44.0/cleepcli.egg-info → cleepcli-1.44.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cleepcli
-Version: 1.44.0
+Version: 1.44.3
 Summary: Cleep-cli helps developers to build great Cleep applications from command line.
 Home-page: https://github.com/CleepDevice/cleep-cli
 Author: Tanguy Bonneau

{cleepcli-1.44.0 → cleepcli-1.44.3}/bin/ccli

@@ -291,11 +291,22 @@ def modssync(run_scripts):
     f = File()
 
     for module in config.MODULES_REPO_URL.keys():
-        res = f.module_sync(module)
-        if not res:
-            sys.exit(1)
         if run_scripts:
-            res = f.module_run_install_scripts(module)
+            # Same order as package install: scripts + preinst, then files, then postinst
+            res = f.module_sync(module, backend=False, frontend=False, scripts=True)
+            if not res:
+                sys.exit(1)
+            res = f.module_run_install_script(module, "preinst.sh")
+            if not res:
+                sys.exit(1)
+            res = f.module_sync(module, backend=True, frontend=True, scripts=True)
+            if not res:
+                sys.exit(1)
+            res = f.module_run_install_script(module, "postinst.sh")
+            if not res:
+                sys.exit(1)
+        else:
+            res = f.module_sync(module)
             if not res:
                 sys.exit(1)
 

{cleepcli-1.44.0 → cleepcli-1.44.3}/bin/cleep-cli

@@ -291,11 +291,22 @@ def modssync(run_scripts):
     f = File()
 
     for module in config.MODULES_REPO_URL.keys():
-        res = f.module_sync(module)
-        if not res:
-            sys.exit(1)
         if run_scripts:
-            res = f.module_run_install_scripts(module)
+            # Same order as package install: scripts + preinst, then files, then postinst
+            res = f.module_sync(module, backend=False, frontend=False, scripts=True)
+            if not res:
+                sys.exit(1)
+            res = f.module_run_install_script(module, "preinst.sh")
+            if not res:
+                sys.exit(1)
+            res = f.module_sync(module, backend=True, frontend=True, scripts=True)
+            if not res:
+                sys.exit(1)
+            res = f.module_run_install_script(module, "postinst.sh")
+            if not res:
+                sys.exit(1)
+        else:
+            res = f.module_sync(module)
             if not res:
                 sys.exit(1)
 

{cleepcli-1.44.0 → cleepcli-1.44.3}/cleepcli/cleepapi.py

@@ -243,6 +243,39 @@ class CleepApi():
             return False
         return True
 
+    def notify_sync_started(self):
+        """
+        Tell the developer UI a watch sync is starting.
+        """
+        data = {'to': 'developer', 'command': 'notify_sync_started'}
+        result = self.__post(self.command_url, data)
+        if not result or result[0] != 200:
+            self.logger.debug('Unable to notify sync started')
+            return False
+        return True
+
+    def notify_sync_done(self):
+        """
+        Tell the developer UI a watch sync finished without restart.
+        """
+        data = {'to': 'developer', 'command': 'notify_sync_done'}
+        result = self.__post(self.command_url, data)
+        if not result or result[0] != 200:
+            self.logger.debug('Unable to notify sync done')
+            return False
+        return True
+
+    def notify_sync_failed(self):
+        """
+        Tell the developer UI a watch sync failed.
+        """
+        data = {'to': 'developer', 'command': 'notify_sync_failed'}
+        result = self.__post(self.command_url, data)
+        if not result or result[0] != 200:
+            self.logger.debug('Unable to notify sync failed')
+            return False
+        return True
+
     def get_documentation(self, module_name):
         """
         Call endpoint to get documentation for specified application

{cleepcli-1.44.0 → cleepcli-1.44.3}/cleepcli/file.py

@@ -31,12 +31,19 @@ class File():
             'MEDIA_DST': config.MEDIA_DST,
             'CONFIG_DIR': config.CONFIG_DIR,
         }
+        variables['MODULES_DST'] = config.MODULES_DST
         cmd = """
 set -e
 mkdir -p "%(HTML_DST)s/"
-mkdir -p "%(CORE_DST)s/modules"
+mkdir -p "%(CORE_DST)s"
+mkdir -p "%(MODULES_DST)s"
 mkdir -p "%(MEDIA_DST)s/modules"
 mkdir -p "%(CONFIG_DIR)s"
+# Python imports cleep.modules from CORE_DST/modules; it must point at the live apps tree
+if [ -e "%(CORE_DST)s/modules" ] && [ ! -L "%(CORE_DST)s/modules" ]; then
+    rm -rf "%(CORE_DST)s/modules"
+fi
+ln -sfn "%(MODULES_DST)s" "%(CORE_DST)s/modules"
 rsync -av "%(REPO_DIR)s/cleep/" "%(CORE_DST)s/" --exclude "/tests/" --exclude "modules" --exclude "*__pycache__*" --delete --exclude "*.pyc" --keep-dirlinks
 rsync -av "%(REPO_DIR)s/html/" "%(HTML_DST)s/" --delete --exclude "js/modules/" --exclude "*node_modules*"
 rsync -av "%(REPO_DIR)s/bin/cleep" "%(BIN_DST)s/cleep"
@@ -53,16 +60,19 @@ rsync -av "%(REPO_DIR)s/medias/sounds" "%(MEDIA_DST)s/sounds/" --delete
 
         return True
 
-    def module_sync(self, module_name):
-        """ 
+    def module_sync(self, module_name, backend=True, frontend=True, scripts=True):
+        """
         Copy specified module content to valid execution location
+
+        Args:
+            module_name (str): module folder name under MODULES_SRC
+            backend (bool): sync backend/ when True
+            frontend (bool): sync frontend/ when True
+            scripts (bool): sync scripts/ when True
         """
         if not os.path.exists(os.path.join(config.MODULES_SRC, module_name)):
             self.logger.error('Module "%s" doesn\'t exist [%s]' % (module_name, os.path.join(config.MODULES_SRC, module_name)))
             return False
-    
-        if not os.path.exists(os.path.join(config.MODULES_DST, module_name)):
-            os.makedirs(os.path.join(config.MODULES_DST, module_name))
 
         mod_backend_src = os.path.join(config.MODULES_SRC, module_name, 'backend/')
         mod_backend_dst = os.path.join(config.MODULES_DST, module_name)
@@ -71,26 +81,34 @@ rsync -av "%(REPO_DIR)s/medias/sounds" "%(MEDIA_DST)s/sounds/" --delete
         mod_scripts_src = os.path.join(config.MODULES_SRC, module_name, 'scripts/')
         mod_scripts_dst = os.path.join(config.MODULES_SCRIPTS_DST, module_name)
 
-        c = Console()
-        cmd = """
-set -e
+        parts = []
+        if backend:
+            parts.append("""
 if [ -d "%(BACKEND_SRC)s" ]; then
     /bin/mkdir -p "%(BACKEND_DST)s"
     rsync -av "%(BACKEND_SRC)s" "%(BACKEND_DST)s" --delete --exclude "*.pyc" --exclude "*__pycache__*"
 fi
+""" % {'BACKEND_SRC': mod_backend_src, 'BACKEND_DST': mod_backend_dst})
+        if frontend:
+            parts.append("""
 if [ -d "%(FRONTEND_SRC)s" ]; then
     /bin/mkdir -p "%(FRONTEND_DST)s"
     rsync -av "%(FRONTEND_SRC)s" "%(FRONTEND_DST)s" --delete --exclude "*node_modules*"
 fi
+""" % {'FRONTEND_SRC': mod_frontend_src, 'FRONTEND_DST': mod_frontend_dst})
+        if scripts:
+            parts.append("""
 if [ -d "%(SCRIPTS_SRC)s" ]; then
     /bin/mkdir -p "%(SCRIPTS_DST)s"
     rsync -av "%(SCRIPTS_SRC)s" "%(SCRIPTS_DST)s" --delete --exclude "*__pycache__*"
 fi
-    """ % { 
-            'BACKEND_SRC': mod_backend_src, 'BACKEND_DST': mod_backend_dst,
-            'FRONTEND_SRC': mod_frontend_src, 'FRONTEND_DST': mod_frontend_dst,
-            'SCRIPTS_SRC': mod_scripts_src, 'SCRIPTS_DST': mod_scripts_dst
-        }
+""" % {'SCRIPTS_SRC': mod_scripts_src, 'SCRIPTS_DST': mod_scripts_dst})
+
+        if not parts:
+            return True
+
+        c = Console()
+        cmd = "set -e\n" + "\n".join(parts)
         self.logger.debug('Modsync cmd: %s' % cmd)
         resp = c.command(cmd, 120)
 
@@ -103,30 +121,39 @@ fi
 
         return True
 
-    def module_run_install_scripts(self, module_name):
+    def module_run_install_script(self, module_name, script_name):
         """
-        Run module installation scripts
+        Run one module installation script from the synced scripts directory
+
+        Args:
+            module_name (str): module name
+            script_name (str): script filename (preinst.sh, postinst.sh, ...)
         """
         if not os.path.exists(os.path.join(config.MODULES_SRC, module_name)):
             self.logger.error('Module "%s" doesn\'t exist [%s]' % (module_name, os.path.join(config.MODULES_SRC, module_name)))
             return False
 
-        preinst_script = os.path.join(config.MODULES_SCRIPTS_DST, module_name, "preinst.sh")
-        postinst_script = os.path.join(config.MODULES_SCRIPTS_DST, module_name, "postinst.sh")
-        console = Console()
-
-        if os.path.exists(preinst_script):
-            self.logger.info('Running %s scripts', preinst_script)
-            resp = console.command(preinst_script, timeout=300)
-            if resp["killed"] or resp["returncode"] != 0:
-                self.logger.error('Error running %s [%s]: %s', preinst_script, resp["returncode"], ''.join(resp["stderr"]))
-                return False
-
-        if os.path.exists(postinst_script):
-            self.logger.info('Running %s scripts', postinst_script)
-            resp = console.command(postinst_script, timeout=300)
-            if resp["killed"] or resp["returncode"] != 0:
-                self.logger.error('Error running %s [%s]: %s', postinst_script, resp["returncode"], ''.join(resp["stderr"]))
-                return False
-
+        script_path = os.path.join(config.MODULES_SCRIPTS_DST, module_name, script_name)
+        if not os.path.exists(script_path):
+            return True
+
+        self.logger.info('Running %s', script_path)
+        resp = Console().command(script_path, timeout=300)
+        if resp["killed"] or resp["returncode"] != 0:
+            self.logger.error(
+                'Error running %s [%s]: %s',
+                script_path,
+                resp["returncode"],
+                ''.join(resp["stderr"]),
+            )
+            return False
         return True
+
+    def module_run_install_scripts(self, module_name):
+        """
+        Run module installation scripts (preinst then postinst)
+        """
+        return (
+            self.module_run_install_script(module_name, "preinst.sh")
+            and self.module_run_install_script(module_name, "postinst.sh")
+        )

{cleepcli-1.44.0 → cleepcli-1.44.3}/cleepcli/version.py

@@ -1,4 +1,4 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-VERSION = "1.44.0"
+VERSION = "1.44.3"

{cleepcli-1.44.0 → cleepcli-1.44.3}/cleepcli/watch.py

@@ -11,6 +11,7 @@ from watchdog.observers import Observer
 from watchdog.events import (
     FileSystemEventHandler,
     EVENT_TYPE_CREATED,
+    EVENT_TYPE_DELETED,
     EVENT_TYPE_MODIFIED,
     EVENT_TYPE_MOVED,
 )
@@ -18,7 +19,12 @@ import watchdog.events as events
 from .cleepapi import CleepApi
 from .file import File
 
-_WATCHED_EVENT_TYPES = (EVENT_TYPE_CREATED, EVENT_TYPE_MODIFIED, EVENT_TYPE_MOVED)
+_WATCHED_EVENT_TYPES = (
+    EVENT_TYPE_CREATED,
+    EVENT_TYPE_DELETED,
+    EVENT_TYPE_MODIFIED,
+    EVENT_TYPE_MOVED,
+)
 
 
 def _is_under(path, root):
@@ -27,20 +33,42 @@ def _is_under(path, root):
     return path == root or path.startswith(root + os.sep)
 
 
-def iter_watch_directories(root):
+# One observer.schedule() = one inotify instance. Keep that count low
+# (kernel default is often 128) by using recursive watches on a few roots.
+MODULE_CONTENT_DIRS = ("backend", "frontend", "scripts")
+
+
+def iter_watch_roots():
     """
-    Yield directories to watch under root.
+    Yield (path, recursive) pairs to schedule on the observer.
 
-    Rejected directory names are not yielded and are not descended into, so
-    inotify never watches them.
+    Core/html/bin are watched recursively. Modules watch only backend,
+    frontend and scripts so .git under each app is never registered.
     """
-    if not os.path.isdir(root):
+    for root in (config.CORE_SRC, config.HTML_SRC, config.BIN_SRC):
+        if os.path.isdir(root):
+            yield root, True
+
+    if not os.path.isdir(config.MODULES_SRC):
         return
-    for dirpath, dirnames, _filenames in os.walk(root):
-        dirnames[:] = [
-            name for name in dirnames if name not in CleepHandler.REJECTED_DIRS
-        ]
-        yield dirpath
+
+    yield config.MODULES_SRC, False
+    try:
+        names = sorted(os.listdir(config.MODULES_SRC))
+    except OSError:
+        return
+    for name in names:
+        if name in CleepHandler.REJECTED_DIRS:
+            continue
+        module_path = os.path.join(config.MODULES_SRC, name)
+        if not os.path.isdir(module_path):
+            continue
+        # Non-recursive: see backend/frontend/scripts appear without watching .git
+        yield module_path, False
+        for sub in MODULE_CONTENT_DIRS:
+            content = os.path.join(module_path, sub)
+            if os.path.isdir(content):
+                yield content, True
 
 
 class _Batch:
@@ -96,40 +124,60 @@ class ActionsExecutor(Thread):
         """
         self.running = False
 
-    def note_change(self, module=None, core=False, frontend=False):
+    def note_change(self, module=None, core=False, frontend=False, backend=False):
         """
         Remember a source change. The sync runs once writes stay quiet.
+
+        Scripts-only edits set neither frontend nor backend: files are synced
+        and Cleep is left running (install scripts are not re-run on watch).
+
+        The first change of a batch notifies the UI immediately so the wait
+        for the quiet period is visible.
         """
+        notify_started = False
         with self._lock:
+            notify_started = not self._batch.pending()
             if module:
                 self._batch.modules.add(module)
             if core:
                 self._batch.core = True
             if frontend:
                 self._batch.frontend = True
-            else:
+            if backend:
                 self._batch.backend = True
             self._batch.last = time.monotonic()
+        if notify_started:
+            self.cleep.notify_sync_started()
 
     def _run_batch(self, batch):
         failed = False
-        if batch.core:
-            self.logger.info("Syncing core")
-            if not self.file.core_sync():
-                failed = True
-        for module in sorted(batch.modules):
-            self.logger.info('Syncing module "%s"', module)
-            if not self.file.module_sync(module):
-                failed = True
-        if failed:
-            self.logger.error("Sync failed, Cleep was not restarted")
-            return
-        if batch.backend:
-            # Backend restart drops the UI connection. The page reloads on its own
-            # once Cleep answers again, with the frontend files already synced.
-            self.cleep.restart_backend()
-        elif batch.frontend:
-            self.cleep.restart_frontend()
+        try:
+            if batch.core:
+                self.logger.info("Syncing core")
+                if not self.file.core_sync():
+                    failed = True
+            for module in sorted(batch.modules):
+                self.logger.info('Syncing module "%s"', module)
+                if not self.file.module_sync(module):
+                    failed = True
+            if failed:
+                self.logger.error("Sync failed, Cleep was not restarted")
+                self.cleep.notify_sync_failed()
+                return
+            if batch.backend:
+                # Backend restart drops the UI connection. The page reloads on its own
+                # once Cleep answers again, with the frontend files already synced.
+                if not self.cleep.restart_backend():
+                    self.cleep.notify_sync_failed()
+            elif batch.frontend:
+                if not self.cleep.restart_frontend():
+                    self.cleep.notify_sync_failed()
+            else:
+                # Scripts-only: files synced, Cleep keeps running
+                self.cleep.notify_sync_done()
+        except Exception:
+            self.cleep.notify_sync_failed()
+            raise
 
     def run(self):
         """
@@ -200,24 +248,54 @@ class CleepHandler(FileSystemEventHandler):
             return getattr(event, "dest_path", None) or event.src_path
         return None
 
-    def schedule_tree(self, root):
+    def schedule_all(self):
         """
-        Watch root and every directory under it, except rejected names.
+        Install the few recursive watches needed for core and module sources.
         """
-        for directory in iter_watch_directories(root):
-            self._watch_directory(directory)
+        for path, recursive in iter_watch_roots():
+            self._schedule(path, recursive=recursive)
 
-    def _watch_directory(self, path):
+    def _schedule(self, path, recursive=True):
         """
-        Watch one directory. Rejected names and directories already watched are skipped.
+        Watch path once. Rejected names and duplicates are skipped.
         """
         if self.observer is None or not path or self._rejected_path(path):
-            return
+            return False
         real = os.path.abspath(path)
         if real in self._watched or not os.path.isdir(real):
-            return
-        self.observer.schedule(self, real, recursive=False)
+            return False
+        self.observer.schedule(self, real, recursive=recursive)
         self._watched.add(real)
+        return True
+
+    def _schedule_module(self, module_path):
+        """
+        Watch a module root (non-recursive) and its content dirs. Never watches .git.
+        """
+        if not module_path or not os.path.isdir(module_path):
+            return
+        if os.path.basename(module_path) in self.REJECTED_DIRS:
+            return
+        self._schedule(module_path, recursive=False)
+        for sub in MODULE_CONTENT_DIRS:
+            self._schedule(os.path.join(module_path, sub), recursive=True)
+
+    def _maybe_schedule_new_path(self, path):
+        """
+        Add watches when a new module or module content dir appears.
+
+        Core/html/bin are already recursive, so new dirs there need no schedule.
+        """
+        if not path or self._rejected_path(path):
+            return
+        parent = os.path.dirname(path)
+        name = os.path.basename(path)
+        modules_root = os.path.abspath(config.MODULES_SRC)
+        if os.path.abspath(parent) == modules_root:
+            self._schedule_module(path)
+            return
+        if name in MODULE_CONTENT_DIRS and os.path.abspath(os.path.dirname(parent)) == modules_root:
+            self._schedule(path, recursive=True)
 
     def _module_name_from_path(self, path):
         prefix = config.MODULES_SRC.rstrip(os.sep) + os.sep
@@ -313,7 +391,7 @@ class CleepHandler(FileSystemEventHandler):
         Returns:
             module name (string) or None if nothing found
         """
-        pattern = r"^%s/(.*?)/(?:frontend|backend|scripts)/.*$" % (
+        pattern = r"^%s/(.*?)/(?:frontend|backend|scripts)(?:/.*)?$" % (
             re.escape(config.MODULES_SRC)
         )
         # self.logger.debug('Module pattern: %s' % pattern)
@@ -364,7 +442,7 @@ class CleepHandler(FileSystemEventHandler):
         Returns:
             True if change on frontend, False otherwise
         """
-        pattern = r"^(%s/|%s/(?:.*?)/frontend/).*$" % (
+        pattern = r"^(%s/|%s/(?:.*?)/frontend(?:/)?).*$" % (
             re.escape(config.HTML_SRC),
             re.escape(config.MODULES_SRC),
         )
@@ -376,16 +454,31 @@ class CleepHandler(FileSystemEventHandler):
 
         return False
 
+    def __change_on_scripts(self, event):
+        """
+        Detect change on module install scripts
+        """
+        pattern = r"^%s/(?:.*?)/scripts(?:/.*)?$" % (re.escape(config.MODULES_SRC))
+        path = self._event_path(event)
+        return bool(path and re.search(pattern, path))
+
     def _queue_change(self, event):
         frontend = self.__change_on_frontend(event)
+        scripts = self.__change_on_scripts(event)
         module = self.__change_on_module(event)
         core = module is None and self.__change_on_core(event)
+        # Scripts are synced for the next install; they do not reload Cleep.
+        backend = not frontend and not scripts
         if module:
             self.logger.debug('  Change on module "%s"' % module)
-            self.actions_executor.note_change(module=module, frontend=frontend)
+            self.actions_executor.note_change(
+                module=module, frontend=frontend, backend=backend
+            )
         elif core:
             self.logger.debug("  Change on core")
-            self.actions_executor.note_change(core=True, frontend=frontend)
+            self.actions_executor.note_change(
+                core=True, frontend=frontend, backend=backend
+            )
         else:
             self.logger.debug("  Dropped due to useless change")
 
@@ -394,22 +487,25 @@ class CleepHandler(FileSystemEventHandler):
             self.logger.debug("Event: %s" % event)
             created = self._created_directory(event)
             if created:
-                self.schedule_tree(created)
                 if self._rejected_path(created):
                     self.logger.debug(" Filtered: directory")
                     return
-                module = self._module_name_from_path(created)
-                if module:
-                    frontend = self.__change_on_frontend(event)
-                    self.logger.debug('  Change on module "%s"' % module)
-                    self.actions_executor.note_change(module=module, frontend=frontend)
+                self._maybe_schedule_new_path(created)
+                # New module root: only schedule watches; wait for content files
+                modules_root = os.path.abspath(config.MODULES_SRC)
+                if os.path.abspath(os.path.dirname(created)) == modules_root:
                     return
-                if _is_under(created, config.CORE_SRC) or _is_under(
+                if self.__change_on_module(event):
+                    self._queue_change(event)
+                elif _is_under(created, config.CORE_SRC) or _is_under(
                     created, config.HTML_SRC
                 ) or _is_under(created, config.BIN_SRC):
                     frontend = self.__change_on_frontend(event)
-                    self.logger.debug("  Change on core")
-                    self.actions_executor.note_change(core=True, frontend=frontend)
+                    self.actions_executor.note_change(
+                        core=True,
+                        frontend=frontend,
+                        backend=not frontend,
+                    )
                 return
 
             if self.__is_event_dropped(event):
@@ -451,25 +547,38 @@ class CleepWatchdog:
         event_handler = CleepHandler(self.actions_executor)
         observer = Observer()
         event_handler.observer = observer
-        scheduled = 0
-        for root in (
-            config.CORE_SRC,
-            config.HTML_SRC,
-            config.BIN_SRC,
-            config.MODULES_SRC,
-        ):
-            before = len(event_handler._watched)
-            event_handler.schedule_tree(root)
-            scheduled += len(event_handler._watched) - before
-
-        if not scheduled:
+        try:
+            event_handler.schedule_all()
+        except OSError as error:
+            self.logger.error(
+                "Unable to start filesystem watches (%s). "
+                "Check fs.inotify.max_user_instances / max_user_watches",
+                error,
+            )
+            self.actions_executor.stop()
+            return False
+
+        if not event_handler._watched:
             self.logger.error(
                 'Please get Cleep sources using "cleep-cli getcore" command'
             )
+            self.actions_executor.stop()
             return False
 
-        self.logger.info('Cleep watchdog is running on "%s" (CTRL-C to stop)' % path)
-        observer.start()
+        self.logger.info(
+            'Cleep watchdog is running on "%s" (%d watches, CTRL-C to stop)'
+            % (path, len(event_handler._watched))
+        )
+        try:
+            observer.start()
+        except OSError as error:
+            self.logger.error(
+                "Unable to start filesystem watches (%s). "
+                "Check fs.inotify.max_user_instances / max_user_watches",
+                error,
+            )
+            self.actions_executor.stop()
+            return False
         try:
             while True:
                 time.sleep(0.25)

{cleepcli-1.44.0 → cleepcli-1.44.3/cleepcli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cleepcli
-Version: 1.44.0
+Version: 1.44.3
 Summary: Cleep-cli helps developers to build great Cleep applications from command line.
 Home-page: https://github.com/CleepDevice/cleep-cli
 Author: Tanguy Bonneau

cleepcli-1.44.3/tests/test_watch.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+import shutil
+import tempfile
+import time
+import unittest
+from unittest.mock import Mock, patch
+
+from watchdog.events import (
+    DirCreatedEvent,
+    FileDeletedEvent,
+    FileModifiedEvent,
+    FileMovedEvent,
+)
+from watchdog.observers import Observer
+
+from cleepcli import config
+from cleepcli.watch import ActionsExecutor, CleepHandler, iter_watch_roots
+
+
+class IterWatchRootsTests(unittest.TestCase):
+    def test_skips_module_git_and_watches_content_dirs(self):
+        repo = tempfile.mkdtemp()
+        try:
+            core = os.path.join(repo, "cleep")
+            html = os.path.join(repo, "html")
+            bin_dir = os.path.join(repo, "bin")
+            modules = os.path.join(repo, "modules")
+            os.makedirs(os.path.join(core, "libs"))
+            os.makedirs(html)
+            os.makedirs(bin_dir)
+            os.makedirs(os.path.join(modules, "audio", ".git", "objects", "ab"))
+            os.makedirs(os.path.join(modules, "audio", "backend"))
+            os.makedirs(os.path.join(modules, "audio", "frontend"))
+            os.makedirs(os.path.join(modules, "audio", "tests"))
+
+            with patch.object(config, "CORE_SRC", core), patch.object(
+                config, "HTML_SRC", html
+            ), patch.object(config, "BIN_SRC", bin_dir), patch.object(
+                config, "MODULES_SRC", modules
+            ):
+                roots = list(iter_watch_roots())
+        finally:
+            shutil.rmtree(repo)
+
+        paths = {path for path, _recursive in roots}
+        recursive = {path: recursive for path, recursive in roots}
+        self.assertIn(core, paths)
+        self.assertTrue(recursive[core])
+        self.assertIn(html, paths)
+        self.assertIn(bin_dir, paths)
+        self.assertIn(modules, paths)
+        self.assertFalse(recursive[modules])
+        self.assertIn(os.path.join(modules, "audio"), paths)
+        self.assertFalse(recursive[os.path.join(modules, "audio")])
+        self.assertIn(os.path.join(modules, "audio", "backend"), paths)
+        self.assertIn(os.path.join(modules, "audio", "frontend"), paths)
+        self.assertTrue(recursive[os.path.join(modules, "audio", "backend")])
+        self.assertFalse(any(".git" in path.split(os.sep) for path in paths))
+        self.assertFalse(any(path.endswith(os.path.join("audio", "tests")) for path in paths))
+        # 3 core trees + modules root + module root + 2 content dirs
+        self.assertEqual(len(roots), 7)
+
+
+class HandlerTests(unittest.TestCase):
+    def setUp(self):
+        self.executor = Mock()
+        self.handler = CleepHandler(self.executor)
+
+    def test_git_file_is_ignored(self):
+        path = os.path.join(
+            config.MODULES_SRC, "cleepbus.tangb", ".git", "objects", "ab", "deadbeef"
+        )
+        self.handler.on_any_event(FileModifiedEvent(path))
+        self.executor.note_change.assert_not_called()
+
+    def test_tests_file_is_ignored(self):
+        path = os.path.join(config.CORE_SRC, "libs", "tests", "test_rpcserver.py")
+        self.handler.on_any_event(FileModifiedEvent(path))
+        self.executor.note_change.assert_not_called()
+
+    def test_core_file_is_queued(self):
+        path = os.path.join(config.CORE_SRC, "rpcserver.py")
+        self.handler.on_any_event(FileModifiedEvent(path))
+        self.executor.note_change.assert_called_once_with(
+            core=True, frontend=False, backend=True
+        )
+
+    def test_atomic_save_move_is_queued(self):
+        src = os.path.join(config.CORE_SRC, ".rpcserver.py.tmp")
+        dest = os.path.join(config.CORE_SRC, "rpcserver.py")
+        self.handler.on_any_event(FileMovedEvent(src, dest))
+        self.executor.note_change.assert_called_once_with(
+            core=True, frontend=False, backend=True
+        )
+
+    def test_module_file_delete_is_queued(self):
+        path = os.path.join(config.MODULES_SRC, "audio", "backend", "audio.py")
+        self.handler.on_any_event(FileDeletedEvent(path))
+        self.executor.note_change.assert_called_once_with(
+            module="audio", frontend=False, backend=True
+        )
+
+    def test_module_scripts_do_not_restart_backend(self):
+        path = os.path.join(config.MODULES_SRC, "audio", "scripts", "postinst.sh")
+        self.handler.on_any_event(FileModifiedEvent(path))
+        self.executor.note_change.assert_called_once_with(
+            module="audio", frontend=False, backend=False
+        )
+
+    def test_module_frontend_is_queued(self):
+        path = os.path.join(config.MODULES_SRC, "audio", "frontend", "desc.json")
+        self.handler.on_any_event(FileModifiedEvent(path))
+        self.executor.note_change.assert_called_once_with(
+            module="audio", frontend=True, backend=False
+        )
+
+    def test_created_git_directory_is_not_watched(self):
+        self.handler.observer = Mock()
+        path = os.path.join(config.MODULES_SRC, "cleepbus.tangb", ".git")
+        self.handler.on_any_event(DirCreatedEvent(path))
+        self.handler.observer.schedule.assert_not_called()
+        self.executor.note_change.assert_not_called()
+
+    def test_schedule_all_is_idempotent(self):
+        repo = tempfile.mkdtemp()
+        try:
+            core = os.path.join(repo, "cleep")
+            html = os.path.join(repo, "html")
+            bin_dir = os.path.join(repo, "bin")
+            modules = os.path.join(repo, "modules")
+            os.makedirs(core)
+            os.makedirs(html)
+            os.makedirs(bin_dir)
+            os.makedirs(os.path.join(modules, "audio", "backend"))
+            self.handler.observer = Mock()
+            with patch.object(config, "CORE_SRC", core), patch.object(
+                config, "HTML_SRC", html
+            ), patch.object(config, "BIN_SRC", bin_dir), patch.object(
+                config, "MODULES_SRC", modules
+            ):
+                self.handler.schedule_all()
+                first = self.handler.observer.schedule.call_count
+                self.handler.schedule_all()
+                self.assertEqual(self.handler.observer.schedule.call_count, first)
+                self.assertLess(first, 20)
+        finally:
+            shutil.rmtree(repo)
+
+    def test_created_module_backend_is_scheduled(self):
+        self.handler.observer = Mock()
+        path = os.path.join(config.MODULES_SRC, "audio", "backend")
+        with patch("os.path.isdir", return_value=True):
+            self.handler.on_any_event(DirCreatedEvent(path))
+        self.handler.observer.schedule.assert_called_once()
+        args, kwargs = self.handler.observer.schedule.call_args
+        self.assertEqual(os.path.abspath(args[1]), os.path.abspath(path))
+        self.assertTrue(kwargs.get("recursive", args[2] if len(args) > 2 else False))
+        self.executor.note_change.assert_called_once_with(
+            module="audio", frontend=False, backend=True
+        )
+
+    def test_created_core_directory_is_queued(self):
+        self.handler.observer = Mock()
+        path = os.path.join(config.CORE_SRC, "libs", "newpkg")
+        self.handler.on_any_event(DirCreatedEvent(path))
+        self.handler.observer.schedule.assert_not_called()
+        self.executor.note_change.assert_called_once_with(
+            core=True, frontend=False, backend=True
+        )
+
+
+class QuietPeriodTests(unittest.TestCase):
+    def _executor(self):
+        executor = ActionsExecutor("https://127.0.0.1:443")
+        executor.file = Mock()
+        executor.file.core_sync.return_value = True
+        executor.file.module_sync.return_value = True
+        executor.cleep = Mock()
+        executor.quiet_period = 0.2
+        executor.poll_interval = 0.05
+        return executor
+
+    def _wait_until(self, predicate, timeout=2.0):
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if predicate():
+                return True
+            time.sleep(0.05)
+        return False
+
+    def test_burst_runs_one_sync_and_one_restart(self):
+        executor = self._executor()
+        executor.start()
+        try:
+            for _ in range(5):
+                executor.note_change(core=True, backend=True)
+                time.sleep(0.02)
+            self.assertTrue(self._wait_until(lambda: executor.file.core_sync.call_count >= 1))
+            time.sleep(0.4)
+            self.assertEqual(executor.file.core_sync.call_count, 1)
+            executor.cleep.notify_sync_started.assert_called_once()
+            executor.cleep.restart_backend.assert_called_once()
+            executor.cleep.restart_frontend.assert_not_called()
+            executor.cleep.notify_sync_done.assert_not_called()
+        finally:
+            executor.stop()
+            executor.join(timeout=2)
+
+    def test_failed_sync_does_not_restart(self):
+        executor = self._executor()
+        executor.file.core_sync.return_value = False
+        executor.start()
+        try:
+            executor.note_change(core=True, backend=True)
+            self.assertTrue(self._wait_until(lambda: executor.file.core_sync.call_count >= 1))
+            time.sleep(0.4)
+            executor.cleep.restart_backend.assert_not_called()
+            executor.cleep.restart_frontend.assert_not_called()
+            executor.cleep.notify_sync_failed.assert_called_once()
+        finally:
+            executor.stop()
+            executor.join(timeout=2)
+
+    def test_frontend_only_refreshes_the_ui(self):
+        executor = self._executor()
+        executor.start()
+        try:
+            executor.note_change(module="audio", frontend=True)
+            self.assertTrue(self._wait_until(lambda: executor.file.module_sync.call_count >= 1))
+            time.sleep(0.4)
+            executor.cleep.notify_sync_started.assert_called_once()
+            executor.cleep.restart_backend.assert_not_called()
+            executor.cleep.restart_frontend.assert_called_once()
+        finally:
+            executor.stop()
+            executor.join(timeout=2)
+
+    def test_scripts_only_does_not_restart(self):
+        executor = self._executor()
+        executor.start()
+        try:
+            executor.note_change(module="audio")
+            self.assertTrue(self._wait_until(lambda: executor.file.module_sync.call_count >= 1))
+            time.sleep(0.4)
+            executor.cleep.restart_backend.assert_not_called()
+            executor.cleep.restart_frontend.assert_not_called()
+            executor.cleep.notify_sync_done.assert_called_once()
+        finally:
+            executor.stop()
+            executor.join(timeout=2)
+
+    def test_core_and_modules_restart_once(self):
+        executor = self._executor()
+        executor.start()
+        try:
+            executor.note_change(core=True, backend=True)
+            executor.note_change(module="network", backend=True)
+            executor.note_change(module="audio", frontend=True)
+            self.assertTrue(self._wait_until(lambda: executor.file.core_sync.call_count >= 1))
+            time.sleep(0.4)
+            self.assertEqual(executor.file.core_sync.call_count, 1)
+            self.assertEqual(executor.file.module_sync.call_count, 2)
+            executor.cleep.restart_backend.assert_called_once()
+            executor.cleep.restart_frontend.assert_not_called()
+        finally:
+            executor.stop()
+            executor.join(timeout=2)
+
+
+class InotifyTests(unittest.TestCase):
+    def test_module_git_objects_are_not_watched(self):
+        repo = tempfile.mkdtemp()
+        observer = Observer()
+        try:
+            modules = os.path.join(repo, "modules")
+            git_dir = os.path.join(modules, "audio", ".git", "objects", "ab")
+            backend = os.path.join(modules, "audio", "backend")
+            os.makedirs(git_dir)
+            os.makedirs(backend)
+            os.makedirs(os.path.join(repo, "cleep"))
+            os.makedirs(os.path.join(repo, "html"))
+            os.makedirs(os.path.join(repo, "bin"))
+
+            executor = Mock()
+            handler = CleepHandler(executor)
+            handler.observer = observer
+            seen = []
+
+            def record(event):
+                seen.append(getattr(event, "src_path", "") or "")
+
+            handler.on_any_event = record
+            with patch.object(config, "CORE_SRC", os.path.join(repo, "cleep")), patch.object(
+                config, "HTML_SRC", os.path.join(repo, "html")
+            ), patch.object(config, "BIN_SRC", os.path.join(repo, "bin")), patch.object(
+                config, "MODULES_SRC", modules
+            ):
+                handler.schedule_all()
+            observer.start()
+            time.sleep(0.2)
+            with open(os.path.join(git_dir, "deadbeef"), "w", encoding="utf-8") as handle:
+                handle.write("x")
+            with open(os.path.join(backend, "audio.py"), "w", encoding="utf-8") as handle:
+                handle.write("x")
+            time.sleep(0.5)
+        finally:
+            observer.stop()
+            observer.join(timeout=2)
+            shutil.rmtree(repo)
+
+        self.assertTrue(any(path.endswith("audio.py") for path in seen))
+        self.assertFalse(any(".git" in path.split(os.sep) for path in seen))
+
+
+if __name__ == "__main__":
+    unittest.main()

cleepcli-1.44.0/tests/test_watch.py

@@ -1,208 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import os
-import shutil
-import tempfile
-import time
-import unittest
-from unittest.mock import Mock
-
-from watchdog.events import DirCreatedEvent, FileModifiedEvent, FileMovedEvent
-from watchdog.observers import Observer
-
-from cleepcli import config
-from cleepcli.watch import ActionsExecutor, CleepHandler, iter_watch_directories
-
-
-class IterWatchDirectoriesTests(unittest.TestCase):
-    def test_skips_rejected_directories(self):
-        root = tempfile.mkdtemp()
-        try:
-            os.makedirs(os.path.join(root, ".git", "objects", "ab"))
-            os.makedirs(os.path.join(root, "pkg", "__pycache__"))
-            os.makedirs(os.path.join(root, "pkg", "tests"))
-            os.makedirs(os.path.join(root, "pkg", "node_modules", "lib"))
-            os.makedirs(os.path.join(root, "pkg", "backend"))
-            watched = set(iter_watch_directories(root))
-        finally:
-            shutil.rmtree(root)
-
-        self.assertIn(root, watched)
-        self.assertIn(os.path.join(root, "pkg"), watched)
-        self.assertIn(os.path.join(root, "pkg", "backend"), watched)
-        self.assertFalse(any(".git" in path.split(os.sep) for path in watched))
-        self.assertFalse(any("__pycache__" in path.split(os.sep) for path in watched))
-        self.assertFalse(any("tests" in path.split(os.sep) for path in watched))
-        self.assertFalse(any("node_modules" in path.split(os.sep) for path in watched))
-
-
-class HandlerTests(unittest.TestCase):
-    def setUp(self):
-        self.executor = Mock()
-        self.handler = CleepHandler(self.executor)
-
-    def test_git_file_is_ignored(self):
-        path = os.path.join(
-            config.MODULES_SRC, "cleepbus.tangb", ".git", "objects", "ab", "deadbeef"
-        )
-        self.handler.on_any_event(FileModifiedEvent(path))
-        self.executor.note_change.assert_not_called()
-
-    def test_tests_file_is_ignored(self):
-        path = os.path.join(config.CORE_SRC, "libs", "tests", "test_rpcserver.py")
-        self.handler.on_any_event(FileModifiedEvent(path))
-        self.executor.note_change.assert_not_called()
-
-    def test_core_file_is_queued(self):
-        path = os.path.join(config.CORE_SRC, "rpcserver.py")
-        self.handler.on_any_event(FileModifiedEvent(path))
-        self.executor.note_change.assert_called_once_with(core=True, frontend=False)
-
-    def test_atomic_save_move_is_queued(self):
-        src = os.path.join(config.CORE_SRC, ".rpcserver.py.tmp")
-        dest = os.path.join(config.CORE_SRC, "rpcserver.py")
-        self.handler.on_any_event(FileMovedEvent(src, dest))
-        self.executor.note_change.assert_called_once_with(core=True, frontend=False)
-
-    def test_created_git_directory_is_not_watched(self):
-        self.handler.observer = Mock()
-        path = os.path.join(config.MODULES_SRC, "cleepbus.tangb", ".git")
-        self.handler.on_any_event(DirCreatedEvent(path))
-        self.handler.observer.schedule.assert_not_called()
-        self.executor.note_change.assert_not_called()
-
-    def test_directory_is_scheduled_once(self):
-        root = tempfile.mkdtemp()
-        try:
-            os.makedirs(os.path.join(root, "pkg"))
-            self.handler.observer = Mock()
-            self.handler.schedule_tree(root)
-            self.handler.schedule_tree(root)
-            self.assertEqual(self.handler.observer.schedule.call_count, 2)
-        finally:
-            shutil.rmtree(root)
-
-    def test_created_core_directory_is_queued(self):
-        self.handler.observer = Mock()
-        path = os.path.join(config.CORE_SRC, "libs", "newpkg")
-        self.handler.on_any_event(DirCreatedEvent(path))
-        self.executor.note_change.assert_called_once_with(core=True, frontend=False)
-
-
-class QuietPeriodTests(unittest.TestCase):
-    def _executor(self):
-        executor = ActionsExecutor("https://127.0.0.1:443")
-        executor.file = Mock()
-        executor.file.core_sync.return_value = True
-        executor.file.module_sync.return_value = True
-        executor.cleep = Mock()
-        executor.quiet_period = 0.2
-        executor.poll_interval = 0.05
-        return executor
-
-    def _wait_until(self, predicate, timeout=2.0):
-        deadline = time.time() + timeout
-        while time.time() < deadline:
-            if predicate():
-                return True
-            time.sleep(0.05)
-        return False
-
-    def test_burst_runs_one_sync_and_one_restart(self):
-        executor = self._executor()
-        executor.start()
-        try:
-            for _ in range(5):
-                executor.note_change(core=True, frontend=False)
-                time.sleep(0.02)
-            self.assertTrue(self._wait_until(lambda: executor.file.core_sync.call_count >= 1))
-            time.sleep(0.4)
-            self.assertEqual(executor.file.core_sync.call_count, 1)
-            executor.cleep.restart_backend.assert_called_once()
-            executor.cleep.restart_frontend.assert_not_called()
-        finally:
-            executor.stop()
-            executor.join(timeout=2)
-
-    def test_failed_sync_does_not_restart(self):
-        executor = self._executor()
-        executor.file.core_sync.return_value = False
-        executor.start()
-        try:
-            executor.note_change(core=True, frontend=False)
-            self.assertTrue(self._wait_until(lambda: executor.file.core_sync.call_count >= 1))
-            time.sleep(0.4)
-            executor.cleep.restart_backend.assert_not_called()
-            executor.cleep.restart_frontend.assert_not_called()
-        finally:
-            executor.stop()
-            executor.join(timeout=2)
-
-    def test_frontend_only_refreshes_the_ui(self):
-        executor = self._executor()
-        executor.start()
-        try:
-            executor.note_change(module="audio", frontend=True)
-            self.assertTrue(self._wait_until(lambda: executor.file.module_sync.call_count >= 1))
-            time.sleep(0.4)
-            executor.cleep.restart_backend.assert_not_called()
-            executor.cleep.restart_frontend.assert_called_once()
-        finally:
-            executor.stop()
-            executor.join(timeout=2)
-
-    def test_core_and_modules_restart_once(self):
-        executor = self._executor()
-        executor.start()
-        try:
-            executor.note_change(core=True, frontend=False)
-            executor.note_change(module="network", frontend=False)
-            executor.note_change(module="audio", frontend=True)
-            self.assertTrue(self._wait_until(lambda: executor.file.core_sync.call_count >= 1))
-            time.sleep(0.4)
-            self.assertEqual(executor.file.core_sync.call_count, 1)
-            self.assertEqual(executor.file.module_sync.call_count, 2)
-            executor.cleep.restart_backend.assert_called_once()
-            executor.cleep.restart_frontend.assert_not_called()
-        finally:
-            executor.stop()
-            executor.join(timeout=2)
-
-
-class InotifyTests(unittest.TestCase):
-    def test_git_objects_are_not_watched(self):
-        root = tempfile.mkdtemp()
-        observer = Observer()
-        try:
-            git_dir = os.path.join(root, ".git", "objects", "ab")
-            os.makedirs(git_dir)
-            os.makedirs(os.path.join(root, "pkg"))
-            executor = Mock()
-            handler = CleepHandler(executor)
-            seen = []
-
-            def record(event):
-                seen.append(event.src_path)
-
-            handler.on_any_event = record
-            for directory in iter_watch_directories(root):
-                observer.schedule(handler, directory, recursive=False)
-            observer.start()
-            time.sleep(0.2)
-            with open(os.path.join(git_dir, "deadbeef"), "w", encoding="utf-8") as handle:
-                handle.write("x")
-            with open(os.path.join(root, "pkg", "a.py"), "w", encoding="utf-8") as handle:
-                handle.write("x")
-            time.sleep(0.5)
-        finally:
-            observer.stop()
-            observer.join(timeout=2)
-            shutil.rmtree(root)
-
-        self.assertTrue(any(path.endswith("a.py") for path in seen))
-        self.assertFalse(any(".git" in path.split(os.sep) for path in seen))
-
-
-if __name__ == "__main__":
-    unittest.main()