django-restit 4.2.172__tar.gz → 4.2.173__tar.gz

{django_restit-4.2.172 → django_restit-4.2.173}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-restit
-Version: 4.2.172
+Version: 4.2.173
 Summary: A Rest Framework for DJANGO
 License: MIT
 Author: Ian Starnes

{django_restit-4.2.172 → django_restit-4.2.173}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-restit"
-version = "4.2.172"
+version = "4.2.173"
 description = "A Rest Framework for DJANGO"
 authors = ["Ian Starnes <ians@311labs.com>"]
 license = "MIT"

{django_restit-4.2.172 → django_restit-4.2.173}/rest/__init__.py

@@ -1,4 +1,4 @@
 from .uberdict import UberDict  # noqa: F401
 from .settings_helper import settings  # noqa: F401
 
-__version__ = "4.2.172"
+__version__ = "4.2.173"

{django_restit-4.2.172 → django_restit-4.2.173}/taskqueue/models.py

@@ -166,8 +166,8 @@ class Task(models.Model, RestModel):
             self.retry_now()
         elif value == "cancel":
             request = self.getActiveRequest()
-            self.reason = "cancel request by {}".format(request.member.username)
-            self.cancel(request.DATA.get("reason", "canceled by {}".format(request.member.username)))
+            self.reason = f"cancel request by {request.member.username}"
+            self.cancel(request.DATA.get("reason", f"canceled by {request.member.username}"))
 
     # def auditlog(self, action, message, request=None, path=None, component="taskqueue.Task"):
     #     # message, level=0, request=None, component=None, pkey=None, action=None, group=None, path=None, method=None
@@ -183,7 +183,7 @@ class Task(models.Model, RestModel):
                 level = 21
             elif kind == "error":
                 level = 17
-            PLOG.log(message=text, action=f"taskqueue_{kind}", 
+            PLOG.log(message=text, action=f"taskqueue_{kind}",
                      level=level,
                      method=self.fname, path=self.model,
                      tid=self.data.log_tid,
@@ -290,7 +290,7 @@ class Task(models.Model, RestModel):
         try:
             import incident
             incident.event_now(
-                category, description=subject, details=msg, 
+                category, description=subject, details=msg,
                 level=3, **metadata)
         except Exception as err:
             self.log(str(err), kind="error")
@@ -395,7 +395,7 @@ class Task(models.Model, RestModel):
         task.save()
         task.publish()
         return task
-    
+
     @classmethod
     def S3Request(cls, bucket, data, folder, aws, secret, filename, when,
                   log_component=None, log_pk=None, log_tid=None):
@@ -458,7 +458,6 @@ class TaskWorkerClient:
         uid = crypto.randomString(16)
         self.recv_channel = f"tq:{uid}:{settings.HOSTNAME}"
         self.send_channel = f"tq:host:{hostname}"
-            
         self.client = None
         self.pubsub = None
 
@@ -480,7 +479,7 @@ class TaskWorkerClient:
         data["hostname"] = settings.HOSTNAME
         data["response_channel"] = self.recv_channel
         redis.publish(
-            self.send_channel, 
+            self.send_channel,
             data, self.client)
 
     def recv(self, timeout=5.0):
@@ -492,7 +491,7 @@ class TaskWorkerClient:
         if msg.data:
             msg.data = nobjict.fromJSON(msg.data)
         return msg.data
-            
+
     def ping(self):
         start = time.perf_counter()
         self.send(dict(action="ping"))
@@ -644,6 +643,3 @@ class TaskHook(models.Model, RestModel, MetaDataModel):
 
 class TaskHookMetaData(MetaDataBase):
     parent = models.ForeignKey(TaskHook, related_name="properties", on_delete=models.CASCADE)
-
-
-

{django_restit-4.2.172 → django_restit-4.2.173}/taskqueue/worker.py

@@ -84,10 +84,10 @@ class WorkManager(object):
         if event.channel == "tq_restart":
             self.restart()
             return
-        
+
         if event.data:
             event.data = nobjict.fromJSON(event.data)
-        
+
         if event.channel == self.host_channel:
             self.on_host_event(event)
             return
@@ -198,6 +198,7 @@ class WorkManager(object):
             task.failed("max attempts")
 
     def _on_hookrequest(self, task):
+        resp = None
         if task.model == "tq_email_request":
             resp = email.SEND(task)
         elif task.model == "tq_sms_request":
@@ -223,7 +224,7 @@ class WorkManager(object):
             redis.publish(
                 event.data.response_channel,
                 dict(action="restarting", hostname=settings.HOSTNAME))
-            self.restart() 
+            self.restart()
         elif action == "get_stats":
             data = nobjict(action="stats", hostname=settings.HOSTNAME)
             data.uptime = time.time() - self.started_at
@@ -240,83 +241,107 @@ class WorkManager(object):
             task.worker_running = True
             self._running_count += 1
             self._pending_count -= 1
+            # remove the task from scheduled
+            del self._scheduled_tasks[task.id]
             self.updateCounts()
 
     def on_task_ended(self, task):
         with self.lock:
             task.worker_running = False
-            del self._scheduled_tasks[task.id]
             self._running_count -= 1
             self.updateCounts()
 
     def on_run_task(self, task):
+        """ Handles execution of a task with structured error handling and refactored logic. """
+
         self.logger.info("running task({})".format(task.id))
 
-        # check if its canceled
+        # Start task and handle cancel/stale conditions early
+        if not self._initialize_task(task):
+            return
+
+        # Get the appropriate handler for the task
+        handler = self._get_task_handler(task)
+        if handler is None:
+            task.failed("failed to find handler")
+            return self._end_task(task)
+
+        # Execute task
+        self._execute_task(task, handler)
+
+    def _initialize_task(self, task):
+        """ Initializes task and checks if it should run. Returns False if the task should stop. """
         try:
             self.on_task_started(task)
             task.refresh_from_db()
             task._thread_id = threading.current_thread().ident
             self.logger.debug("running on thread:{}".format(task._thread_id))
+
             if task.state not in [0, 1, 2, 10] or task.cancel_requested:
                 self.logger.info("task({}) was canceled?".format(task.id))
-                self.on_task_ended(task)
-                return
+                return self._end_task(task)
 
             if task.is_stale:
                 self.logger.warning("task({}) is now stale".format(task.id))
                 task.failed("stale")
-                self.on_task_ended(task)
-                return
+                return self._end_task(task)
+
+            return True
         except Exception as err:
             self.logger.exception(err)
-            return
+            return False
 
-        handler = None
-        if task.model == "tq_web_request":
-            handler = self._on_webrequest
-        elif task.model in ["tq_sftp_request", "tq_email_request", "tq_sms_request", "tq_s3_request"]:
-            handler = self._on_hookrequest
-        else:
-            try:
-                handler = task.getHandler()
-            except Exception as err:
-                self.logger.exception(err)
-                task.log_exception(err)
-                task.failed(str(err))
-                self.on_task_ended(task)
-                return
+    def _get_task_handler(self, task):
+        """ Determines the appropriate handler for the task. """
+        task_handlers = {
+            "tq_web_request": self._on_webrequest,
+            "tq_sftp_request": self._on_hookrequest,
+            "tq_email_request": self._on_hookrequest,
+            "tq_sms_request": self._on_hookrequest,
+            "tq_s3_request": self._on_hookrequest,
+        }
 
-        if handler is None:
-            self.logger.error("failed to find handler: task({})".format(task.id))
-            task.failed("failed to find handler")
-            self.on_task_ended(task)
-            return
+        handler = task_handlers.get(task.model)
+        if handler:
+            return handler
+
+        try:
+            return task.getHandler()
+        except Exception as err:
+            self.logger.exception(err)
+            task.log_exception(err)
+            task.failed(str(err))
+            self._end_task(task)
+            return None
 
-        # self.logger.debug("task.started()")
+    def _execute_task(self, task, handler):
+        """ Runs the task handler and manages exceptions. """
         task.started()
         try:
-            # self.logger.debug("task({}) calling handler".format(task.id))
             handler(task)
             if task.state == TASK_STATE_STARTED:
                 task.completed()
-            # self.logger.debug("task({}) handler finished".format(task.id))
         except Exception as err:
-            self.logger.exception(err, "task({}) had exception".format(task.id))
-            task.log_exception(err)
-            if "connection already closed" in str(err).lower():
-                # this is a nasty little bug in django when forking django db connections
-                # we will schedule the task to retry later
-                task.retry_later()
-                # let us try and close db connections?
-                hack_closeDjangoDB()
-                # or should we restart the task queue?
-            else:
-                task.failed(str(err))
+            self._handle_task_exception(task, err)
         except SystemExit:
             self.logger.error("task({}) was killed".format(task.id))
         finally:
-            self.on_task_ended(task)
+            self._end_task(task)
+
+    def _handle_task_exception(self, task, err):
+        """ Handles exceptions during task execution. """
+        self.logger.exception("task({}) had exception: {}".format(task.id, err))
+        task.log_exception(err)
+
+        if "connection already closed" in str(err).lower():
+            task.retry_later()
+            hack_closeDjangoDB()
+        else:
+            task.failed(str(err))
+
+    def _end_task(self, task):
+        """ Ensures proper cleanup and logging at the end of the task. """
+        self.on_task_ended(task)
         self.logger.info("task({}) finished with state {}".format(task.id, task.state))
 
     def run_forever(self):
@@ -420,5 +445,3 @@ def hack_closeDjangoDB():
     from django.db import connections
     for conn in connections.all():
         conn.close_if_unusable_or_obsolete()
-
-