Refactor code

Author: quietsy

root/app/swag-ondemand.py

@@ -1,54 +1,62 @@
 from datetime import datetime
 import docker
+import logging
 import os
 import threading
 import time
 
+ACCESS_LOG_FILE = "/config/log/nginx/access.log"
+LOG_FILE = "/config/log/ondemand/ondemand.log"
+STOP_THRESHOLD = int(os.environ.get("SWAG_ONDEMAND_STOP_THRESHOLD", "1800"))
+
 last_accessed_urls = set()
 last_accessed_urls_lock = threading.Lock()
 ondemand_containers = {}
 ondemand_containers_lock = threading.Lock()
-stop_threshold = int(os.environ.get("SWAG_ONDEMAND_STOP_THRESHOLD", "1800"))
 
 class ContainerThread(threading.Thread):
-    def process_containers(self, docker_client):
+    def __init__(self):
+        super().__init__()
+        self.docker_client = docker.from_env()
+        self.daemon = True
+
+    def process_containers(self):
         global ondemand_containers
-        containers = docker_client.containers.list(all=True, filters={ "label": ["swag_ondemand=enable"] })
+        containers = self.docker_client.containers.list(all=True, filters={ "label": ["swag_ondemand=enable"] })
         container_names = {container.name for container in containers}
 
         for container_name in list(ondemand_containers.keys()):
             if container_name in container_names:
                 continue
             ondemand_containers.pop(container_name)
-            print(f"{datetime.now()} - Stopped monitoring {container_name}")
+            logging.info(f"Stopped monitoring {container_name}")
 
         for container in containers:
             container_urls = container.labels.get("swag_ondemand_urls", f"https://{container.name}.,http://{container.name}.")
             if container.name not in ondemand_containers.keys():
                 last_accessed = datetime.now()
-                print(f"{datetime.now()} - Started monitoring {container.name}")
+                logging.info(f"Started monitoring {container.name}")
             else:
                 last_accessed = ondemand_containers[container.name]["last_accessed"]
             ondemand_containers[container.name] = { "status": container.status, "urls": container_urls, "last_accessed": last_accessed }
 
-    def stop_containers(self, docker_client):
+    def stop_containers(self):
         global ondemand_containers
 
         for container_name in ondemand_containers.keys():
             if ondemand_containers[container_name]["status"] != "running":
                 continue
             inactive_seconds = (datetime.now() - ondemand_containers[container_name]["last_accessed"]).total_seconds()
-            if inactive_seconds < stop_threshold:
+            if inactive_seconds < STOP_THRESHOLD:
                 continue
-            docker_client.containers.get(container_name).stop()
-            print(f"{datetime.now()} - Stopped {container_name} after {stop_threshold}s of inactivity")
+            self.docker_client.containers.get(container_name).stop()
+            logging.info(f"Stopped {container_name} after {STOP_THRESHOLD}s of inactivity")
 
-    def start_containers(self, docker_client):
+    def start_containers(self):
         global ondemand_containers
-        last_accessed_urls_lock.acquire()
-        last_accessed_urls_combined = ",".join(last_accessed_urls)
-        last_accessed_urls.clear()
-        last_accessed_urls_lock.release()
+        with last_accessed_urls_lock:
+            last_accessed_urls_combined = ",".join(last_accessed_urls)
+            last_accessed_urls.clear()
 
         for container_name in ondemand_containers.keys():
             accessed = False
@@ -59,21 +67,25 @@ def start_containers(self, docker_client):
                 accessed = True
             if not accessed or ondemand_containers[container_name]["status"] == "running":
                 continue
-            docker_client.containers.get(container_name).start()
-            print(f"{datetime.now()} - Started {container_name}")
+            self.docker_client.containers.get(container_name).start()
+            logging.info(f"Started {container_name}")
             ondemand_containers[container_name]["status"] = "running"
 
     def run(self):
         while True:
-            docker_client = docker.from_env()
-            with ondemand_containers_lock:
-                self.process_containers(docker_client)
-                self.start_containers(docker_client)
-                self.stop_containers(docker_client)
-            time.sleep(5)
+            try:
+                with ondemand_containers_lock:
+                    self.process_containers()
+                    self.start_containers()
+                    self.stop_containers()
+                time.sleep(2)
+            except Exception as e:
+                logging.exception(e)
 
 class LogReaderThread(threading.Thread):
-    logname = "/config/log/nginx/access.log"
+    def __init__(self):
+        super().__init__()
+        self.daemon = True
 
     def tail(self, f):
         f.seek(0,2)
@@ -82,24 +94,44 @@ def tail(self, f):
         while True:
             line = f.readline()
             if not line:
-                time.sleep(1)
-                if os.stat(self.logname).st_ino != inode:
+                time.sleep(0.1)
+                if os.stat(ACCESS_LOG_FILE).st_ino != inode:
                     f.close()
-                    f = open(self.logname, 'r')
+                    f = open(ACCESS_LOG_FILE, 'r')
                     inode = os.fstat(f.fileno()).st_ino
                 continue
             yield line
 
     def run(self):
-        logfile = open(self.logname, "r")
-        for line in self.tail(logfile):
-            for part in line.split():
-                if not part.startswith("http"):
+        while True:
+            try:
+                if not os.path.exists(ACCESS_LOG_FILE):
+                    time.sleep(1)
                     continue
-                with last_accessed_urls_lock:
-                    last_accessed_urls.add(part)
-                    print(f"{datetime.now()} - Accessed {part}")
-                break
 
-ContainerThread().start()
-LogReaderThread().start()
+                logfile = open(ACCESS_LOG_FILE, "r")
+                for line in self.tail(logfile):
+                    for part in line.split():
+                        if not part.startswith("http"):
+                            continue
+                        with last_accessed_urls_lock:
+                            last_accessed_urls.add(part)
+                        break
+            except Exception as e:
+                logging.exception(e)
+                time.sleep(1)
+
+if __name__ == "__main__":
+    os.makedirs(os.path.dirname(LOG_FILE), exist_ok=True)
+    logging.basicConfig(filename=LOG_FILE,
+                    filemode='a',
+                    format='%(asctime)s - %(threadName)s - %(levelname)s - %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S',
+                    level=logging.INFO)
+    logging.info("Starting swag-ondemand...")
+
+    ContainerThread().start()
+    LogReaderThread().start()
+    
+    while True:
+        time.sleep(1)