django-restit 4.2.42__tar.gz → 4.2.44__tar.gz

{django_restit-4.2.42 → django_restit-4.2.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-restit
-Version: 4.2.42
+Version: 4.2.44
 Summary: A Rest Framework for DJANGO
 License: MIT
 Author: Ian Starnes

{django_restit-4.2.42 → django_restit-4.2.44}/account/rpc/group.py

@@ -83,7 +83,7 @@ def rest_on_membership(request, pk=None):
 @rd.login_required
 def rest_on_users_membership(request, group_id=None):
     ms = request.member.getMembershipFor(group_id, include_parents=True)
-    if ms is None:
+    if ms is None or not ms.is_enabled:
         return rv.restStatus(request, False, error="not found", error_code=404)
     return ms.restGet(request)
 

{django_restit-4.2.42 → django_restit-4.2.44}/location/providers/iplookup/restit.py

@@ -26,7 +26,7 @@ def getLocation(ip):
     if GEOIP_RESTIT_HOST is None:
         return None
     params = {"ip": ip}
-    url = f"https://{GEOIP_RESTIT_HOST}/rpc/location/ip/lookup"
+    url = f"https://{GEOIP_RESTIT_HOST}/api/location/ip/lookup"
     res = requests.get(url, params=params)
     if res.status_code != 200:
         return None

{django_restit-4.2.42 → django_restit-4.2.44}/pyproject.toml

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

{django_restit-4.2.42 → django_restit-4.2.44}/rest/__init__.py

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

{django_restit-4.2.42 → django_restit-4.2.44}/taskqueue/models.py

@@ -31,6 +31,10 @@ TASK_STATES = [
     (TASK_STATE_CANCELED, 'canceled')
 ]
 
+TQ_RETRY_BACKOFF_FACTOR = settings.get("TQ_RETRY_BACKOFF_FACTOR", 2)
+TQ_RETRY_ATTEMPTS = settings.get("TQ_RETRY_ATTEMPTS", 5)
+TQ_RETRY_DELAY = settings.get("TQ_RETRY_DELAY", 60)
+
 def getAppHandler(app_name, fname):
     try:
         # module = __import__(app_name + '.tq', globals(), locals(), ['*'], 0)
@@ -143,6 +147,12 @@ class Task(models.Model, RestModel):
             return self.runtime
         return (datetime.now() - self.started_at).total_seconds()
 
+    @property
+    def max_attempts(self):
+        if self.data:
+            return self.data.get("retry_max_attempts", TQ_RETRY_ATTEMPTS)
+        return TQ_RETRY_ATTEMPTS
+
     def set_action(self, value):
         if value == "retry_now":
             self.retry_now()
@@ -158,6 +168,20 @@ class Task(models.Model, RestModel):
 
     def log(self, text, kind="info"):
         TaskLog.Log(self, text, kind=kind)
+        if self.data and ((self.data.log_component and self.data.log_pk) or self.data.log_tid):
+            PLOG = self.getModel("auditlog", "PersistentLog")
+            level = 0
+            if kind == "exception":
+                level = 21
+            elif kind == "error":
+                level = 17
+            PLOG.log(message=text, action=f"taskqueue_{kind}", 
+                     level=level,
+                     method=self.fname, path=self.model,
+                     tid=self.data.log_tid,
+                     component=self.data.log_component,
+                     pkey=self.data.log_pk,
+                     group=self.data.group_id)
 
     def log_exception(self, text, kind="exception"):
         self.log(str(text), kind=kind)
@@ -173,7 +197,17 @@ class Task(models.Model, RestModel):
     def retry_later(self, reason=None, from_now_secs=None):
         if reason:
             self.reason = reason
-        if from_now_secs:
+        if from_now_secs == -1:
+            # allow backoff retry
+            if self.data:
+                bof = self.data.get("retry_bof", TQ_RETRY_BACKOFF_FACTOR)
+                delay = self.data.get("retry_delay", TQ_RETRY_DELAY)
+            else:
+                bof = TQ_RETRY_BACKOFF_FACTOR
+                delay = TQ_RETRY_DELAY
+            attempts = self.attempts - 1
+            from_now_secs = delay * (bof ** attempts)
+        if from_now_secs is not None:
             # this will not run the task again until after this time has been hit
             self.scheduled_for = datetime.now() + timedelta(seconds=from_now_secs)
         self.state = TASK_STATE_RETRY
@@ -200,24 +234,30 @@ class Task(models.Model, RestModel):
         self.notifyError()
         self.save()
 
-    def notifyError(self, kind="Failure"):
-        subject = "TaskQueue - {}".format(kind)
-        handler = "unknown bg_handler"
-        if self.data:
-            handler = self.data.get("bg_handler")
-        msg = "{}:{}<br>\n{}".format(self.model, handler, self.reason)
-        # sms_msg = "{}\n{}".format(subject, msg)
-        # Member.notifyWithPermission("taskqueue_alerts", subject, msg, sms_msg=sms_msg)
+    def notifyError(self):
+        handler = f"{self.model}{self.fname}"
+        subject = f"TaskQueue - {handler}"
+
+        msg = f"{handler}<br>\n{self.reason}"
         metadata = {
             "server": settings.get("HOSTNAME", "unknown"),
             "task": self.pk,
             "reason": self.reason,
-            "kind": kind,
             "app": self.model,
             "fname": self.fname,
             "channel": self.channel,
+            "attempts": self.attempts,
             "handler": handler
         }
+
+        if self.data:
+            if self.data.url:
+                metadata["url"] = self.data.url
+                msg = f"{msg}<br>\n{self.data.url}"
+            if self.data.log_component:
+                metadata["component"] = self.data.log_component
+            if self.data.log_pk:
+                metadata["component_id"] = self.data.log_pk
         try:
             import incident
             incident.event_now(
@@ -254,10 +294,16 @@ class Task(models.Model, RestModel):
         return getattr(model, self.fname, None)
 
     @classmethod
-    def WebRequest(cls, url, data, fname="POST", stale_after_seconds=0):
+    def WebRequest(cls, url, data, fname="POST", stale_after_seconds=0,
+                   log_component=None, log_pk=None, log_tid=None):
         tdata = nobjict()
         tdata.url = url
         tdata.data = data
+        if log_component is not None:
+            tdata.log_component = log_component
+            tdata.log_pk = log_pk
+        if log_tid is not None:
+            tdata.log_tid = log_tid
         task = cls(channel="tq_hook", model="tq_web_request", fname=fname, data=tdata)
         if stale_after_seconds:
             task.stale_after = datetime.now() + timedelta(seconds=stale_after_seconds)
@@ -266,29 +312,41 @@ class Task(models.Model, RestModel):
         return task
 
     @classmethod
-    def EmailRequest(cls, address, data, filename=None, subject=None):
+    def EmailRequest(cls, address, data, filename=None, subject=None,
+                     log_component=None, log_pk=None, log_tid=None):
         tdata = nobjict()
         tdata.address = address
         tdata.filename = filename
         tdata.subject = subject
         tdata.data = data
+        if log_component is not None:
+            tdata.log_component = log_component
+            tdata.log_pk = log_pk
+        if log_tid is not None:
+            tdata.log_tid = log_tid
         task = cls(channel="tq_hook", model="tq_email_request", data=tdata)
         task.save()
         task.publish()
         return task
 
     @classmethod
-    def SMSRequest(cls, phone, data):
+    def SMSRequest(cls, phone, data, log_component=None, log_pk=None, log_tid=None):
         tdata = nobjict()
         tdata.phone = phone
         tdata.data = data
+        if log_component is not None:
+            tdata.log_component = log_component
+            tdata.log_pk = log_pk
+        if log_tid is not None:
+            tdata.log_tid = log_tid
         task = cls(channel="tq_hook", model="tq_sms_request", data=tdata)
         task.save()
         task.publish()
         return task
 
     @classmethod
-    def SFTPRequest(cls, host, data, filename, username, password):
+    def SFTPRequest(cls, host, data, filename, username, password,
+                    log_component=None, log_pk=None, log_tid=None):
         tdata = nobjict()
         tdata.host = host
         tdata.filename = filename
@@ -297,13 +355,19 @@ class Task(models.Model, RestModel):
         tdata.username = username
         tdata.password = password
         tdata.data = data
+        if log_component is not None:
+            tdata.log_component = log_component
+            tdata.log_pk = log_pk
+        if log_tid is not None:
+            tdata.log_tid = log_tid
         task = cls(channel="tq_hook", model="tq_sftp_request", data=tdata)
         task.save()
         task.publish()
         return task
     
     @classmethod
-    def S3Request(cls, bucket, data, folder, aws, secret, filename, when):
+    def S3Request(cls, bucket, data, folder, aws, secret, filename, when,
+                  log_component=None, log_pk=None, log_tid=None):
         tdata = nobjict()
         tdata.bucket = bucket
         tdata.filename = filename
@@ -312,6 +376,11 @@ class Task(models.Model, RestModel):
         tdata.aws = aws
         tdata.secret = secret
         tdata.when = str(when)
+        if log_component is not None:
+            tdata.log_component = log_component
+            tdata.log_pk = log_pk
+        if log_tid is not None:
+            tdata.log_tid = log_tid
         task = cls(channel="tq_hook", model="tq_s3_request", data=tdata)
         task.save()
         task.publish()

{django_restit-4.2.42 → django_restit-4.2.44}/taskqueue/transports/http.py

@@ -14,7 +14,7 @@ def REQUEST(task):
         resp = net.REQUEST(method, url, params=params,
                            data=task.data.data, raw_response=True,
                            verify=False, timeout=REQ_TIMEOUT)
-        task.log(resp.text)
+        task.log(resp.text, kind="response")
         return resp.status_code == 200
     except requests.Timeout:
         task.log("request timed out", kind="error")

{django_restit-4.2.42 → django_restit-4.2.44}/taskqueue/worker.py

@@ -178,7 +178,7 @@ class WorkManager(object):
             pass
 
     def processBacklog(self):
-        tasks = Task.objects.filter(state__in=[0,1,2])
+        tasks = Task.objects.filter(state__in=[0, 1, 2])
         for task in tasks:
             if task.channel in self.subscribe_to:
                 if task.cancel_requested:
@@ -196,8 +196,9 @@ class WorkManager(object):
     def _on_webrequest(self, task):
         if http.REQUEST(task):
             task.completed()
-        elif task.attempts < 5:
-            task.retry_later(from_now_secs=task.attempts * task.attempts * 60)
+        elif task.attempts < task.max_attempts:
+            # -1 will auto calculate retry with back off
+            task.retry_later(from_now_secs=-1)
         else:
             task.failed("max attempts")
 
@@ -212,8 +213,8 @@ class WorkManager(object):
             resp = s3.UPLOAD(task)
         if resp:
             task.completed()
-        elif task.state == 1:
-            task.retry_later(from_now_secs=task.attempts * 60)
+        elif task.attempts < task.max_attempts:
+            task.retry_later(from_now_secs=-1)
         else:
             task.failed()