django-restit 4.2.112__tar.gz → 4.2.113__tar.gz

{django_restit-4.2.112 → django_restit-4.2.113}/PKG-INFO

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

{django_restit-4.2.112 → django_restit-4.2.113}/incident/tq.py

@@ -118,16 +118,16 @@ def on_incoming_email(task):
 def run_cleanup(task):
     stale = datetime.now() - timedelta(days=90)
     # delete all ossec alerts older then 90 days
-    count = ia.ServerOssecAlert.objects.filter(created__lte=stale).delete()
+    count = ia.ServerOssecAlert.objects.filter(created__lte=stale).delete()[0]
     if count:
         task.log(f"deleted {count} old ServerOssecAlert")
     # delete all events older then 90 days
     count = ia.Event.objects.filter(created__lte=stale).filter(
-        Q(incident__state=ia.INCIDENT_STATE_IGNORE) | Q(incident__isnull=True)).delete()
+        Q(incident__state=ia.INCIDENT_STATE_IGNORE) | Q(incident__isnull=True)).delete()[0]
     if count:
         task.log(f"deleted {count} old Events")
     
-    count = ia.Incident.objects.filter(created__lte=stale).filter(state=ia.INCIDENT_STATE_IGNORE).delete()
+    count = ia.Incident.objects.filter(created__lte=stale).filter(state=ia.INCIDENT_STATE_IGNORE).delete()[0]
     if count:
         task.log(f"deleted {count} old Incidents")
 

{django_restit-4.2.112 → django_restit-4.2.113}/metrics/client.py

@@ -329,8 +329,12 @@ class R(object):
             for s in slug:
                 self.metric(s, num, category, expire, date)
             return
+        
         # Add the slug to the set of metric slugs
-        self.r.sadd(self._metric_slugs_key, slug)
+        try:
+            self.r.sadd(self._metric_slugs_key, slug)
+        except Exception:
+            return
 
         if category:
             self._categorize(slug, category)

{django_restit-4.2.112 → django_restit-4.2.113}/metrics/periodic.py

@@ -1,13 +1,13 @@
 from datetime import datetime, timedelta
 from taskqueue.models import Task
-from .models import Metrics
+from metrics.models import Metrics
 from rest import log
 from rest import decorators as rd
 
 
 @rd.periodic(minute=15, hour=10)
 def run_cleanup(force=False, verbose=False, now=None):
-    count = Metrics.objects.filter(expires__lte=datetime.now()).delete()
+    count = Metrics.objects.filter(expires__lte=datetime.now()).delete()[0]
     if count > 0:
         logger = log.getLogger("auditlog", filename="auditlog.log")
         logger.info(f"METRICS.CLEANUP {count} expired records deleted")

{django_restit-4.2.112 → django_restit-4.2.113}/metrics/rpc.py

@@ -301,32 +301,44 @@ def rest_on_ec2_domains(request):
 @rd.urlGET('restit/servers')
 @rd.login_required
 def rest_on_ec2_restit_stats(request):
-    hostname = settings.SERVER_ROOT
-    if hostname is None:
-        hostname = settings.SERVER_NAME
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+    hostname = settings.SERVER_ROOT or settings.SERVER_NAME
     if hostname.count(".") == 2:
-        hostname = hostname[hostname.find(".")]
+        hostname = hostname.split(".")[1]  # Corrected to get the second part
+
     instances = aws.getAllEC2()
     hosts = [inst.name for inst in instances]
-    data = []
-    for name in hosts:
+    path = "versions"
+    params = {"detailed": 1}
+    if request.DATA.get("sysinfo"):
+        path = "system/info"
+        params["key"] = settings.SYS_INFO_KEY
+
+    def fetch_host_data(name):
         if settings.SERVER_NAME_MAP and name in settings.SERVER_NAME_MAP:
             host = settings.SERVER_NAME_MAP[name]
             if "." not in host:
                 host = f"{name}.{hostname}"
         else:
             host = f"{name}.{hostname}"
-        resp = net.REQUEST(
-            "GET", host, 
-            f"/{REST_PREFIX}versions", 
-            params=dict(detailed=1),
-            timeout=5.0)
-        if resp.status:
-            resp.data.id = host
-            resp.data.hostname = host
-            data.append(resp.data)
-        else:
-            data.append(dict(id=host, hostname=host))
+
+        try:
+            resp = net.REQUEST("GET", host, f"/{REST_PREFIX}{path}", params=params, timeout=5.0)
+            if resp.status:
+                resp.data.id = host
+                resp.data.hostname = host
+                return resp.data
+            else:
+                return dict(id=host, hostname=host)
+        except requests.RequestException:
+            return dict(id=host, hostname=host)
+
+    data = []
+    with ThreadPoolExecutor(max_workers=10) as executor:  # Adjust max_workers as needed
+        futures = {executor.submit(fetch_host_data, name): name for name in hosts}
+        for future in as_completed(futures):
+            data.append(future.result())
+
     return rv.restReturn(request, dict(data=data))
 
 

{django_restit-4.2.112 → django_restit-4.2.113}/pyproject.toml

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

{django_restit-4.2.112 → django_restit-4.2.113}/rest/__init__.py

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

{django_restit-4.2.112 → django_restit-4.2.113}/rest/models/base.py

@@ -1197,7 +1197,7 @@ class RestModel(object):
             can_delete = getattr(cls.RestMeta, "CAN_DELETE", False)
             if not can_delete:
                 raise re.PermissionDeniedException(f"deletion not allowed for {cls.get_class_name()}", 438)
-            count = qset.delete()
+            count = qset.delete()[0]
             return GRAPH_HELPERS.restStatus(request, True, error="delete {} items".format(count))
         elif action == "update":
             update_fields = request.DATA.get(["batch_data", "batch_update"])

{django_restit-4.2.112 → django_restit-4.2.113}/rest/rpc.py

@@ -10,6 +10,8 @@ from django.conf import settings
 
 from .decorators import url
 from rest.extra import hostinfo
+from ws4redis import client as redis
+from django.db import connections
 
 
 URL_PREFIX = ""
@@ -49,6 +51,27 @@ def on_get_joke(request):
     return views.restGet(request, {"joke": joke.getRandomJoke()})
 
 
+@url('status')
+def on_get_status(request):
+    flag = True
+    try:
+        flag = redis.ping()
+    except Exception:
+        flag = False
+    status = dict(redis=flag, database={})
+    for alias in settings.DATABASES.keys():
+        db_conn = connections[alias]
+        try:
+            # Ensure connection with a timeout
+            db_conn.ensure_connection()
+            status["database"][alias] = True
+        except Exception:
+            flag = False
+            status["database"][alias] = False
+    if flag:
+        return views.restGet(request, status)
+    return views.restResult(request, status, 417)
+
 @url('system/info')
 def on_get_system_info(request):
     key = request.DATA.get("key")

{django_restit-4.2.112 → django_restit-4.2.113}/taskqueue/periodic.py

@@ -95,11 +95,11 @@ def run_cleanup(force=False, verbose=False, now=None):
     if not settings.TQ_MASTER:
         return
     stale = datetime.now() - timedelta(days=TQ_DELETE_AFTER)
-    count = Task.objects.filter(created__lte=stale).delete()
+    count = Task.objects.filter(created__lte=stale).delete()[0]
     if count:
         logger.info("deleted {} old tasks".format(count))
     stale = datetime.now() - timedelta(days=TQ_DELETE_COMPLETED_AFTER)
-    count = Task.objects.filter(created__lte=stale, state=TASK_STATE_COMPLETED).delete()
+    count = Task.objects.filter(created__lte=stale, state=TASK_STATE_COMPLETED).delete()[0]
     if count:
         logger.info("deleted {} old completed tasks".format(count))
 

{django_restit-4.2.112 → django_restit-4.2.113}/ws4redis/client.py

@@ -21,6 +21,10 @@ def buildEventMessage(name=None, message=None, priority=0, model=None, model_pk=
     return msg.toJSON(as_string=True)
 
 
+def ping():
+    return getRedisClient().ping()
+
+
 def exists(key, default=None):
     c = getRedisClient()
     return c.exists(key)