ajslater
diff --git a/‎NEWS.md‎
Lines changed: 6 additions & 0 deletions b/‎NEWS.md‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎README.md‎
Lines changed: 1 addition & 1 deletion b/‎README.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎codex/librarian/daemon.py‎
Lines changed: 4 additions & 4 deletions b/‎codex/librarian/daemon.py‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎codex/librarian/librariand.py‎
Lines changed: 158 additions & 148 deletions b/‎codex/librarian/librariand.py‎
Lines changed: 158 additions & 148 deletions
@@ -1,5 +1,11 @@
 # Codex News
 
+## v0.6.3
+
+- Add LOGLEVEL environment variable. Set to DEBUG to see everything.
+- Removed DEV environment variable.
+- Possible fix for newly imported covers not displaying.
+
 ## v0.6.2
 
 - Librarian startup crash is intermittent and only in docker.
 
@@ -207,7 +207,7 @@ Codex is a Django Python webserver with a VueJS front end. This is my first ever
 
 `/codex/dev-server-ttabs.sh` will run the three or four different servers reccomended for development in terminal tabs.
 
-`/codex/run.sh` runs the main Django server. Set the `DEV` environment variables to activate both development and debug mode: `DEV=1 ./run.sh`. This also lets you run the server without collecting static files for production and with a hot reloading frontend.
+`/codex/run.sh` runs the main Django server. Set the `DEBUG` environment variable to activate debug mode: `DEBUG=1 ./run.sh`. This also lets you run the server without collecting static files for production and with a hot reloading frontend.
 
 ### Links
 
 
@@ -3,17 +3,17 @@
 
 def start_daemons():
     """Start the daemons. But don't import them until django is set up."""
-    from codex.librarian.librariand import start_librarian
+    from codex.librarian.librariand import LibrarianDaemon
     from codex.websocket_server import start_flood_control_worker
 
+    LibrarianDaemon.start()
     start_flood_control_worker()
-    start_librarian()
 
 
 def stop_daemons():
     """Stop the daemons. But don't import them until django is set up."""
-    from codex.librarian.librariand import stop_librarian
+    from codex.librarian.librariand import LibrarianDaemon
     from codex.websocket_server import stop_flood_control_worker
 
+    LibrarianDaemon.stop()
     stop_flood_control_worker()
-    stop_librarian()
@@ -1,12 +1,12 @@
 """Library process worker for background tasks."""
+import faulthandler
 import logging
 import os
 import platform
 import time
 
 from multiprocessing import Pool
 from multiprocessing import Process
-from multiprocessing import Value
 from time import sleep
 
 import simplejson as json
@@ -41,6 +41,7 @@
 from codex.models import Folder
 from codex.serializers.webpack import WEBSOCKET_MESSAGES as WS_MSGS
 from codex.settings.django_setup import django_setup
+from codex.settings.settings import PORT
 from codex.websocket_server import BROADCAST_SECRET
 from codex.websocket_server import IPC_SUFFIX
 from codex.websocket_server import WS_API_PATH
@@ -50,11 +51,9 @@
 django_setup()
 
 LOG = logging.getLogger(__name__)
-PORT = Value("i", 9810)  # Shared memory overwritten in run.py
 BROADCAST_URL_TMPL = "ws://localhost:{port}/" + WS_API_PATH + IPC_SUFFIX
 MAX_WS_ATTEMPTS = 4
 SHUTDOWN_TASK = "shutdown"
-librarian_proc = None
 if platform.system() == "Darwin":
     # XXX Fixes QUEUE sharing with default spawn start method. The spawn
     # method is also very very slow. Use fork and the
@@ -65,152 +64,163 @@
     set_start_method("fork", force=True)
 
 
-def get_websocket():
-    """Connect to the websocket broadcast url."""
-    # Its easier to inject these into the ws server event loop
-    # by sending them instead of using shared memory.
-    ws = None
-    attempts = 0
-    while ws is None or not ws.connected and attempts <= MAX_WS_ATTEMPTS:
-        time.sleep(0.5)
-        try:
-            broadcast_url = BROADCAST_URL_TMPL.format(port=PORT.value)
-            ws = create_connection(broadcast_url)
-        except ConnectionRefusedError:
-            attempts += 1
-    if ws and ws.connected:
-        LOG.info("Librarian connected to websockets.")
-    else:
-        LOG.error("Librarian cannot connect to websockets.")
-    return ws
-
-
-def send_json(ws, typ, message):
-    """Send a JSON message."""
-    obj = {"type": typ}
-    if typ in MessageType.SECRET_TYPES:
-        obj["secret"] = BROADCAST_SECRET.value
-    obj["message"] = message
-    msg = json.dumps(obj)
-    if ws is None or not ws.connected:
-        ws = get_websocket()
-    ws.send(msg)
-    return ws
-
-
-def process_task(task, ws, pool, watcher, main_pid):
-    """Process an individual task popped off the queue."""
-    run = True
-    try:
-        if isinstance(task, ScanRootTask):
-            msg = WS_MSGS["SCAN_LIBRARY"]
-            ws = send_json(ws, MessageType.ADMIN_BROADCAST, msg)
-            scan_root(task.library_id, task.force)
-        elif isinstance(task, ScanDoneTask):
-            if task.failed_imports:
-                msg = WS_MSGS["FAILED_IMPORTS"]
-            else:
-                msg = WS_MSGS["SCAN_DONE"]
-            ws = send_json(ws, MessageType.ADMIN_BROADCAST, msg)
-        elif isinstance(task, ComicModifiedTask):
-            import_comic(task.library_id, task.src_path)
-        elif isinstance(task, ComicCoverCreateTask):
-            # Cover creation is cpu bound, farm it out.
-            args = (task.src_path, task.db_cover_path, task.force)
-            pool.apply_async(create_comic_cover, args=args)
-        elif isinstance(task, FolderMovedTask):
-            obj_moved(task.src_path, task.dest_path, Folder)
-        elif isinstance(task, ComicMovedTask):
-            obj_moved(task.src_path, task.dest_path, Comic)
-        elif isinstance(task, ComicDeletedTask):
-            obj_deleted(task.src_path, Comic)
-        elif isinstance(task, FolderDeletedTask):
-            obj_deleted(task.src_path, Folder)
-        elif isinstance(task, LibraryChangedTask):
-            msg = WS_MSGS["LIBRARY_CHANGED"]
-            ws = send_json(ws, MessageType.BROADCAST, msg)
-        elif isinstance(task, WatcherCronTask):
-            sleep(task.sleep)
-            watcher.set_all_library_watches()
-        elif isinstance(task, ScannerCronTask):
-            sleep(task.sleep)
-            scan_cron()
-        elif isinstance(task, UpdateCronTask):
-            sleep(task.sleep)
-            update_codex(main_pid, task.force)
-        elif isinstance(task, RestartTask):
-            sleep(task.sleep)
-            restart_codex(main_pid)
-        elif task == SHUTDOWN_TASK:
-            LOG.info("Shutting down Librarian...")
-            run = False
+# XXX Should this inherit from Process?
+class LibrarianDaemon:
+    """Librarian Process."""
+
+    proc = None
+
+    def __init__(self, main_pid):
+        """Create threads and process pool."""
+        LOG.debug("Librarian initializing...")
+        self.main_pid = main_pid
+        self.watcher = Uatu()
+        self.crond = Crond()
+        self.pool = Pool()
+        self.ws = None
+        LOG.debug("Librarian initialized.")
+
+    def ensure_websocket(self):
+        """Connect to the websocket broadcast url."""
+        # Its easier to inject these into the ws server event loop
+        # by sending them instead of using shared memory.
+        if self.ws is not None and self.ws.connected:
+            return
+        attempts = 0
+        while self.ws is None or not self.ws.connected and attempts <= MAX_WS_ATTEMPTS:
+            time.sleep(0.5)
+            try:
+                broadcast_url = BROADCAST_URL_TMPL.format(port=PORT)
+                self.ws = create_connection(broadcast_url)
+            except ConnectionRefusedError:
+                attempts += 1
+        if self.ws and self.ws.connected:
+            LOG.info("Librarian connected to websockets.")
         else:
-            LOG.warning(f"Unhandled task popped: {task}")
-    except (Comic.DoesNotExist, Folder.DoesNotExist) as exc:
-        LOG.warning(exc)
-    except Exception as exc:
-        LOG.exception(exc)
-    return run
-
-
-def librarian(main_pid):
-    """
-    Process tasks from the queue.
-
-    This proces also runs the crond thread and the Watchdog Observer
-    threads.
-    """
-    try:
-        LOG.info("Started Librarian.")
-        ws = None
-        LOG.debug("ws declared.")
+            LOG.error("Librarian cannot connect to websockets.")
+
+    def send_json(self, typ, message):
+        """Send a JSON message."""
+        obj = {"type": typ}
+        if typ in MessageType.SECRET_TYPES:
+            obj["secret"] = BROADCAST_SECRET.value
+        obj["message"] = message
+        msg = json.dumps(obj)
+        self.ensure_websocket()
+        self.ws.send(msg)
+
+    def process_task(self, task):
+        """Process an individual task popped off the queue."""
         run = True
-        LOG.debug("about to start daemons")
-        watcher = Uatu()
-        LOG.debug("created Uatu")
-        crond = Crond()
-        LOG.debug("created Cron")
-        watcher.start()
+        try:
+            if isinstance(task, ScanRootTask):
+                msg = WS_MSGS["SCAN_LIBRARY"]
+                self.send_json(MessageType.ADMIN_BROADCAST, msg)
+                scan_root(task.library_id, task.force)
+            elif isinstance(task, ScanDoneTask):
+                if task.failed_imports:
+                    msg = WS_MSGS["FAILED_IMPORTS"]
+                else:
+                    msg = WS_MSGS["SCAN_DONE"]
+                self.send_json(MessageType.ADMIN_BROADCAST, msg)
+            elif isinstance(task, ComicModifiedTask):
+                import_comic(task.library_id, task.src_path)
+            elif isinstance(task, ComicCoverCreateTask):
+                # Cover creation is cpu bound, farm it out.
+                args = (task.src_path, task.db_cover_path, task.force)
+                self.pool.apply_async(create_comic_cover, args=args)
+            elif isinstance(task, FolderMovedTask):
+                obj_moved(task.src_path, task.dest_path, Folder)
+            elif isinstance(task, ComicMovedTask):
+                obj_moved(task.src_path, task.dest_path, Comic)
+            elif isinstance(task, ComicDeletedTask):
+                obj_deleted(task.src_path, Comic)
+            elif isinstance(task, FolderDeletedTask):
+                obj_deleted(task.src_path, Folder)
+            elif isinstance(task, LibraryChangedTask):
+                msg = WS_MSGS["LIBRARY_CHANGED"]
+                self.send_json(MessageType.BROADCAST, msg)
+            elif isinstance(task, WatcherCronTask):
+                sleep(task.sleep)
+                self.watcher.set_all_library_watches()
+            elif isinstance(task, ScannerCronTask):
+                sleep(task.sleep)
+                scan_cron()
+            elif isinstance(task, UpdateCronTask):
+                sleep(task.sleep)
+                update_codex(self.main_pid, task.force)
+            elif isinstance(task, RestartTask):
+                sleep(task.sleep)
+                restart_codex(self.main_pid)
+            elif task == SHUTDOWN_TASK:
+                LOG.info("Shutting down Librarian...")
+                run = False
+            else:
+                LOG.warning(f"Unhandled task popped: {task}")
+        except (Comic.DoesNotExist, Folder.DoesNotExist) as exc:
+            LOG.warning(exc)
+        except Exception as exc:
+            LOG.exception(exc)
+        return run
+
+    def start_threads(self):
+        """Start all librarian's threads."""
+        LOG.info("Starting Librarian Threads...")
+        self.watcher.start()
         LOG.debug("started Uatu")
-        crond.start()
+        self.crond.start()
         LOG.debug("started Cron")
-        pool = Pool()
-        LOG.debug("created process pool")
-        LOG.info("Librarian started threads and waiting for tasks.")
-        while run:
-            task = QUEUE.get()
-            run = process_task(task, ws, pool, watcher, main_pid)
-
-        if ws:
-            ws.close()
-        pool.close()
-        crond.stop()
-        watcher.stop()
-        crond.join()
-        watcher.join()
-        pool.join()
-    except Exception as exc:
-        LOG.error("Librarian crashed.")
-        LOG.exception(exc)
-    LOG.info("Stopped Librarian.")
-
-
-def start_librarian():
-    """Start the worker process."""
-    global librarian_proc
-
-    args = (os.getpid(),)
-    librarian_proc = Process(
-        target=librarian, name="librarian", args=args, daemon=False
-    )
-    librarian_proc.start()
-    # this signal is thrown by runserver which i don't use anymore
-    # file_changed.connect(stop_librarian)
-
-
-def stop_librarian(*args, **kwargs):
-    """Stop the librarian process."""
-    global librarian_proc
-    QUEUE.put(SHUTDOWN_TASK)
-    if librarian_proc:
-        librarian_proc.join()
+
+    def stop_threads(self):
+        """Stop all librarian's threads."""
+        LOG.debug("Stopping threads...")
+        if self.ws:
+            self.ws.close()
+        self.pool.close()
+        self.crond.stop()
+        self.watcher.stop()
+        self.crond.join()
+        self.watcher.join()
+        self.pool.join()
+
+    def loop(self):
+        """
+        Process tasks from the queue.
+
+        This proces also runs the crond thread and the Watchdog Observer
+        threads.
+        """
+        try:
+            faulthandler.enable()
+            LOG.info("Started Librarian.")
+            self.start_threads()
+            run = True
+            LOG.info("Librarian started threads and waiting for tasks.")
+            while run:
+                task = QUEUE.get()
+                run = self.process_task(task)
+            self.stop_threads()
+        except Exception as exc:
+            LOG.error("Librarian crashed.")
+            LOG.exception(exc)
+        LOG.info("Stopped Librarian.")
+
+    @staticmethod
+    def worker(main_pid):
+        """Create a new librarian daemon and run it."""
+        daemon = LibrarianDaemon(main_pid)
+        daemon.loop()
+
+    @classmethod
+    def start(cls):
+        """Start the worker process."""
+        args = (os.getpid(),)
+        cls.proc = Process(target=cls.worker, name="librarian", args=args, daemon=False)
+        cls.proc.start()
+
+    @classmethod
+    def stop(cls):
+        """Stop the librarian process."""
+        QUEUE.put(SHUTDOWN_TASK)
+        if cls.proc:
+            cls.proc.join()