Optimize gTS + Refactor

Author: TristanDamron

build-resources/geocml-task-scheduler/geocml-task-scheduler/schedule.py

@@ -1,20 +1,23 @@
 from task import Task
+from task_scheduler import TaskScheduler
 from backup_geocml_db import backup_geocml_db
 from restore_geocml_db_from_backups import restore_geocml_db_from_backups
 from healthcheck_services import healthcheck_services
 from register_with_drgon import register_with_drgon
 
-backup_geocml_db_task = Task(backup_geocml_db, (), 3600) # task runs every hour
-backup_geocml_db_task.start()
+scheduler = TaskScheduler()
 
-restore_geocml_db_task = Task(restore_geocml_db_from_backups, (), 1) # task runs every second until stopped
-restore_geocml_db_task.start()
+# DEFINE TASKS HERE
+backup_geocml_db_task = Task(backup_geocml_db, ())
+restore_geocml_db_task = Task(restore_geocml_db_from_backups, ())
+healthcheck_services_task = Task(healthcheck_services, ())
+register_with_drgon_task = Task(register_with_drgon, ())
 
-healthcheck_services_task = Task(healthcheck_services, (), 60)
-healthcheck_services_task.start()
+# ADD TASKS TO SCHEDULER HERE
+scheduler.add(backup_geocml_db_task, 3600)  # task runs every hour
+scheduler.add(restore_geocml_db_task, 1)  # task runs every second until stopped
+scheduler.add(healthcheck_services_task, 60)
+scheduler.add(register_with_drgon_task, 60)
 
-register_with_drgon_task = Task(register_with_drgon, (), 60)
-register_with_drgon_task.start()
 
-while True:
-    pass # keep schedule.py process running in container
+scheduler.tick()

build-resources/geocml-task-scheduler/geocml-task-scheduler/task.py

@@ -1,36 +1,32 @@
 from threading import Thread
-from time import sleep, time
+from time import time
 from task_logger import log
 
-class Task(Thread):
-    def __init__(self, target, args, timeout):
+class Task(object):
+    def __init__(self, target, args):
         """
         target: function
         args: tuple
-        timeout: int
         """
         Thread.__init__(self)
         self.target = target
-        self.args = args # TODO: do args work?
-        self.timeout = timeout
+        self.args = args
 
-    def run(self):
-        """
-        Calls the target function every n seconds
-        """
-        while True:
-            sleep(self.timeout)
-            start = time()
-            log('Running \'{}\' at {}'.format(self.target.__name__, start), self.target)
+    def __str__(self):
+        return self.target.__name__
+
+    def start(self):
+        start = time()
+        log("Running \'{}\' at {}".format(str(self), str(self), start), self.target)
+        ret_code = 1
+
+        try:
+            ret_code = self.target(*self.args)
+            log("Ran \'{}\' in {}".format(str(self), str(self), time() - start), self.target)
+            if ret_code == 0: # ret_code 0: task stopped successfully, 1: task failed, will try again
+                log("Stopping task \'{}\' at {} with exit code 0".format(str(self), str(self), time()),
+                    self.target)
+        except Exception as e:
+            log("FATAL: {} at {}".format(str(self), e, time()))
 
-            try:
-                ret_code = self.target()
-                log('Ran \'{}\' in {}'.format(self.target.__name__, time() - start), self.target)
-                if ret_code == 0: # ret_code 0: task stopped successfully
-                    log('Stopping task \'{}\' at {} with exit code 0'.format(self.target.__name__, time()),
-                       self.target)
-                    return
-            # TODO: ret_code 1: task stopped due to expected error
-            # TODO: other ret_codes: log warning (ret_code {} is not valid)
-            except Exception as e:
-                log('FATAL: {} at {}'.format(e, time())) # TODO: should the task be stopped after this?
+        return ret_code

build-resources/geocml-task-scheduler/geocml-task-scheduler/task_logger.py

@@ -1,13 +1,13 @@
+import inspect
+
 task_log_path = 'task_log'
 
 def log(message, task=None):
     """
     task: function
     message: str
     """
-    f = open(task_log_path, 'a')
-    if task == None:
-        f.write('{}\n'.format(message))
-    else:
-        f.write('{}:{}\n'.format(task.__name__, message))
+    current_frame = inspect.currentframe()
+    f = open(task_log_path, "a")
+    f.write("[{}]: {}\n".format(inspect.getouterframes(current_frame, 2)[1][3], message))
     f.close()

build-resources/geocml-task-scheduler/geocml-task-scheduler/task_scheduler.py

@@ -0,0 +1,36 @@
+from task_logger import log
+from time import sleep
+
+class TaskScheduler(object):
+    def __init__(self):
+        self.schedule = {}
+
+    def add(self, task, timeout):
+        """
+        task: Task
+        timeout: int
+        """
+        try:
+            self.schedule[str(task)] = {
+                "task": task,
+                "timeout": timeout,
+                "last_ran": 0,
+                "ret_code": -1
+            }
+        except KeyError:
+            log('FATAL: {} is already scheduled'.format(str(task)))
+
+    def tick(self):
+        while True:
+            sleep(0.25)
+            updated_schedule = self.schedule.copy()
+            for key, value in self.schedule.items():
+                if value["last_ran"] >= value["timeout"]:
+                    if value["ret_code"] == 0:
+                        del updated_schedule[key]
+                        continue
+
+                    value["last_ran"] = 0
+                    value["ret_code"] = value["task"].start()
+                value["last_ran"] += 0.25
+            self.schedule = updated_schedule