django-restit 4.2.103__tar.gz → 4.2.105__tar.gz

{django_restit-4.2.103 → django_restit-4.2.105}/PKG-INFO

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

{django_restit-4.2.103 → django_restit-4.2.105}/account/models/device.py

@@ -41,13 +41,15 @@ class MemberDevice(models.Model, rm.RestModel, rm.MetaDataModel):
     def sendData(self, message, **kwargs):
         messenger = getCloudMessenger(self.cm_provider)
         if messenger:
-            return messenger.sendToDevice(self, message)
+            resp = messenger.sendToDevice(self, message)
+            return resp
         return objict(status_code=404, reason=self.cm_provider)
 
     def sendNotification(self, title, body):
         messenger = getCloudMessenger(self.cm_provider)
         if messenger:
-            return messenger.sendNotification(self.cm_token, title, body)
+            resp = messenger.sendNotification(self.cm_token, title, body)
+            return resp
         return objict(status_code=404, reason=self.cm_provider)
 
     def notify(self, title, body):

{django_restit-4.2.103 → django_restit-4.2.105}/account/models/member.py

@@ -627,7 +627,22 @@ class Member(User, RestModel, MetaDataModel):
         #     for slog in qset:
         #         slog.logout()
 
-    def notifyMobile(self, data=None, title=None, body=None):
+    def notifyMobile(self, data=None, title=None, body=None, delay=None):
+        if delay:
+            Task = RestModel.getModel("taskqueue", "Task")
+            if delay < 60:
+                Task.Publish(
+                    "account.Member", "on_task_cm",
+                    data=dict(pk=self.pk, delay=delay, data=data, title=title, body=body),
+                    stale_after_seconds=300,
+                    channel="tq_app_handler")
+            else:
+                Task.Publish(
+                    "account.Member", "on_task_cm",
+                    data=dict(pk=self.pk, data=data, title=title, body=body),
+                    scheduled_for=datetime.now() + timedelta(seconds=delay),
+                    channel="tq_app_handler")
+            return
         stale = datetime.now() - timedelta(days=60)
         for device in self.devices.filter(state=1, modified__gt=stale).exclude(cm_provider="ws", cm_token__isnull=True):
             if data is not None:
@@ -1226,6 +1241,16 @@ class Member(User, RestModel, MetaDataModel):
             return None
         return cls.objects.filter(pk=uid).last()
 
+    @classmethod
+    def on_task_cm(cls, task):
+        member = cls.objects.filter(pk=task.data.pk).last()
+        if not member:
+            task.failed("could not find member")
+            return False
+        if task.data.delay:
+            time.sleep(task.data.delay)  # delay
+        member.notifyMobile(data=task.data.data, title=task.data.title, body=task.data.body)
+
 
 class MemberMetaData(MetaDataBase):
     parent = models.ForeignKey(Member, related_name="properties", on_delete=models.CASCADE)

{django_restit-4.2.103 → django_restit-4.2.105}/metrics/periodic.py

@@ -3,6 +3,9 @@ from taskqueue.models import Task
 from .models import Metrics
 from rest import log
 from rest import decorators as rd
+from rest import settings
+
+PUSH_METRICS_TO_CLOUDWATCH = settings.get("PUSH_METRICS_TO_CLOUDWATCH", False)
 
 
 @rd.periodic(minute=15, hour=10)
@@ -16,3 +19,10 @@ def run_cleanup(force=False, verbose=False, now=None):
 @rd.periodic(minute=15, hour=11, weekday=1)
 def run_checks(force=False, verbose=False, now=None):
     Task.Publish("metrics", "run_monitoring", channel="tq_app_handler")
+
+
+@rd.periodic(minute=rd.PERIODIC_EVERY_5_MINUTES)
+def run_aws_metrics(force=False, verbose=False, now=None):
+    if PUSH_METRICS_TO_CLOUDWATCH:
+        from metrics.providers import aws
+        aws.publishLocalMetrics()

{django_restit-4.2.103 → django_restit-4.2.105}/metrics/providers/aws.py

@@ -2,7 +2,7 @@ import boto3
 from datetime import datetime, timedelta
 from rest import settings
 from objict import objict
-import socket
+from rest.extra import hostinfo
 
 
 METRIC_MAP = {
@@ -19,10 +19,20 @@ METRIC_MAP = {
     "cache_cons": "CurrConnections",
     "max": "Maximum",
     "min": "Minimum",
-    "avg": "Average"
+    "avg": "Average",
+    "ec2_cons": "EstablishedConnections"
 }
 
 
+def publishLocalMetrics():
+    # this will publish any local metrics to cloudwatch
+    instance = getLocalEC2()
+    pushMetric(
+        METRIC_MAP["ec2_cons"],
+        hostinfo.getTcpEstablishedCount(),
+        "Count", instance)
+
+
 def getLocalEC2():
     """
     {
@@ -43,9 +53,7 @@ def getLocalEC2():
         "zone": "us-west-2d"
     }
     """
-    hostname = socket.gethostname()
-    priv_ip = socket.gethostbyname(hostname)
-    return getEC2ByIP(priv_ip)
+    return getEC2ByIP(hostinfo.getHostIP())
 
 
 def getClient(region=settings.AWS_REGION, service="cloudwatch"):
@@ -54,6 +62,29 @@ def getClient(region=settings.AWS_REGION, service="cloudwatch"):
     return boto3.client(service, aws_access_key_id=key, aws_secret_access_key=secret, region_name=region)
 
 
+def pushMetric(name, value, unit="Count", instance=None):
+    """Push the custom metric to CloudWatch."""
+    cloudwatch = getClient(service="cloudwatch")
+    if instance is None:
+        instance = getLocalEC2()
+    return cloudwatch.put_metric_data(
+        Namespace = 'CustomMetrics',
+        MetricData = [
+            {
+                'MetricName': name,
+                'Dimensions': [
+                    {
+                        'Name': 'InstanceId',
+                        'Value': instance.id
+                    },
+                ],
+                'Value': value,
+                'Unit': unit
+            },
+        ]
+    )
+
+
 def buildQuery(id, instance, period=300, metric="cpu", namespace="rds", stat="max"):
     dname = "DBInstanceIdentifier"
     if namespace == "ec2":
@@ -135,7 +166,7 @@ def getAllEC2(just_ids=False, region=settings.AWS_REGION):
 
 def getEC2ByIP(ip):
     # retreives the local ec2 instance details by private ip
-    client = getClient("ec2")
+    client = getClient(service="ec2")
     filters = [dict(Name="private-ip-address", Values=[ip])]
     resp = client.describe_instances(Filters=filters)["Reservations"]
     try:

{django_restit-4.2.103 → django_restit-4.2.105}/metrics/rpc.py

@@ -287,7 +287,7 @@ def getPeriods(period, duration):
 
 @rd.urlGET('restit/domains')
 @rd.login_required
-def rest_on_ec2_domains(request, pk=None):
+def rest_on_ec2_domains(request):
     if not settings.DOMAIN_WATCH:
         return rv.restPermissionDenied(request)
 
@@ -300,7 +300,7 @@ def rest_on_ec2_domains(request, pk=None):
 
 @rd.urlGET('restit/servers')
 @rd.login_required
-def rest_on_ec2_restit_stats(request, pk=None):
+def rest_on_ec2_restit_stats(request):
     hostname = settings.SERVER_ROOT
     if hostname is None:
         hostname = settings.SERVER_NAME
@@ -332,19 +332,19 @@ def rest_on_ec2_restit_stats(request, pk=None):
 
 @rd.urlGET('aws/ec2/list/details')
 @rd.login_required
-def rest_on_ec2_list(request, pk=None):
+def rest_on_ec2_list(request):
     return rv.restReturn(request, dict(data=aws.getAllEC2()))
 
 
 @rd.urlGET('aws/ec2/list/ids')
 @rd.login_required
-def rest_on_ec2_list_ids(request, pk=None):
+def rest_on_ec2_list_ids(request):
     return rv.restReturn(request, dict(data=aws.getAllEC2(True)))
 
 
 @rd.urlGET('aws/ec2/cpu')
 @rd.requires_params(["ids"])
-def rest_on_ec2_metrics_cpu(request, pk=None):
+def rest_on_ec2_metrics_cpu(request):
     ids = request.DATA.getlist("ids")
     period = request.DATA.get("period", 300, field_type=int)
     duration = request.DATA.get("duration", period*8, field_type=int)
@@ -383,9 +383,22 @@ def rest_on_ec2_metrics_cpu(request, pk=None):
     return rv.restReturn(request, dict(data=data))
 
 
+@rd.urlGET('aws/ec2/network/established')
+@rd.requires_params(["ids"])
+def rest_on_ec2_metrics_net_established(request):
+    data = aws.getMetrics(
+        request.DATA.getlist("ids"),
+        period=request.DATA.get("period", 300, field_type=int),
+        duration_seconds=request.DATA.get("duration", 900, field_type=int),
+        metric="EstablishedConnections",
+        namespace="CustomMetrics",
+        stat="max")
+    return rv.restReturn(request, dict(data=data))
+
+
 @rd.urlGET('aws/ec2/network/in')
 @rd.requires_params(["ids"])
-def rest_on_ec2_metrics_netin(request, pk=None):
+def rest_on_ec2_metrics_netin(request):
     data = aws.getMetrics(
         request.DATA.getlist("ids"),
         period=request.DATA.get("period", 300, field_type=int),
@@ -398,7 +411,7 @@ def rest_on_ec2_metrics_netin(request, pk=None):
 
 @rd.urlGET('aws/ec2/network/out')
 @rd.requires_params(["ids"])
-def rest_on_ec2_metrics_netout(request, pk=None):
+def rest_on_ec2_metrics_netout(request):
     ids = request.DATA.getlist("ids")
     period = request.DATA.get("period", 300, field_type=int)
     duration = request.DATA.get("duration", period*8, field_type=int)
@@ -426,7 +439,7 @@ def rest_on_ec2_metrics_netout(request, pk=None):
 
 @rd.urlGET('aws/rds/cpu')
 @rd.requires_params(["ids"])
-def rest_on_ec2_metrics_cpu(request, pk=None):
+def rest_on_ec2_metrics_cpu(request):
     ids = request.DATA.getlist("ids")
     period = request.DATA.get("period", 300, field_type=int)
     duration = request.DATA.get("duration", period*8, field_type=int)
@@ -446,7 +459,7 @@ def rest_on_ec2_metrics_cpu(request, pk=None):
 
 @rd.urlGET('aws/rds/memory')
 @rd.requires_params(["ids"])
-def rest_on_rds_metrics_memory(request, pk=None):
+def rest_on_rds_metrics_memory(request):
     ids = request.DATA.getlist("ids")
     period = request.DATA.get("period", 300, field_type=int)
     duration = request.DATA.get("duration", period*8, field_type=int)
@@ -466,7 +479,7 @@ def rest_on_rds_metrics_memory(request, pk=None):
 
 @rd.urlGET('aws/rds/cons')
 @rd.requires_params(["ids"])
-def rest_on_rds_metrics_cons(request, pk=None):
+def rest_on_rds_metrics_cons(request):
     ids = request.DATA.getlist("ids")
     period = request.DATA.get("period", 300, field_type=int)
     duration = request.DATA.get("duration", period*8, field_type=int)
@@ -486,19 +499,19 @@ def rest_on_rds_metrics_cons(request, pk=None):
 
 @rd.urlGET('aws/redis/cpu')
 @rd.requires_params(["ids"])
-def rest_on_redis_metrics_cpu(request, pk=None):
+def rest_on_redis_metrics_cpu(request):
     return get_redis_metrics(request, "cpu")
 
 
 @rd.urlGET('aws/redis/cons')
 @rd.requires_params(["ids"])
-def rest_on_redis_metrics_cons(request, pk=None):
+def rest_on_redis_metrics_cons(request):
     return get_redis_metrics(request, "cache_cons")
 
 
 @rd.urlGET('aws/redis/memory')
 @rd.requires_params(["ids"])
-def rest_on_redis_metrics_mem(request, pk=None):
+def rest_on_redis_metrics_mem(request):
     return get_redis_metrics(request, "cache_usage")
 
 

{django_restit-4.2.103 → django_restit-4.2.105}/pyproject.toml

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

django_restit-4.2.103/rest/rpc.py → django_restit-4.2.105/rest/extra/hostinfo.py

@@ -1,59 +1,24 @@
-from . import views
-
-import version
-import time
 from datetime import datetime
-import platform
-import subprocess
-from . import joke
-from . import helpers
-
-import django
+import time
+from rest import helpers
 from django.conf import settings
+import django
+import version
+import platform
+import socket
 
 
-from .decorators import url
-
 try:
     import psutil
 except Exception:
     print("no psutil")
 
-
-URL_PREFIX = ""
-
 SOFTWARE_VERSIONS = getattr(settings, 'SOFTWARE_VERSIONS', None)
-ALLOW_PUBLIC_SYS_INFO = getattr(settings, 'ALLOW_PUBLIC_SYS_INFO', False)
-# SOFTWARE_VERSIONS_ACTUAL = {}
-
-
-@url(r'^version$')
-def on_get_version(request):
-    return views.restStatus(request, True, {"data": version.VERSION, "ip": request.ip})
-
 
-@url(r'^versions$')
-def on_get_version(request):
-    from rest import __version__ as restit_version
-    versions = dict(
-        project=version.VERSION,
-        restit=restit_version)
-    if request.DATA.get("detailed") and SOFTWARE_VERSIONS:
-        getVersions(versions)
-    return views.restStatus(request, True, {"data": versions})
 
-
-@url('test/session')
-def on_get_my_session(request):
-    echo = request.DATA.get("echo", None)
-    if echo:
-        request.session["echo"] = echo
-    return views.restReturn(request, dict(echo=request.session.get("echo", "not set")))
-
-
-@url(r'^joke$')
-def on_get_joke(request):
-    return views.restGet(request, {"joke": joke.getRandomJoke()})
+def getHostIP():
+    hostname = socket.gethostname()
+    return socket.gethostbyname(hostname)
 
 
 def getTcpEstablishedCount():
@@ -69,10 +34,18 @@ def getTcpEstablished():
     return established
 
 
-@url(r'^system/info$')
-def on_get_system_info(request):
-    if not ALLOW_PUBLIC_SYS_INFO and not request.user.is_authenticated:
-        return views.restPermissionDenied(request, "system info is not public", 565)
+def getVersions(out=None):
+    if out is None:
+        out = {}
+    for key in SOFTWARE_VERSIONS:
+        if key == "django":
+            out[key] = django.__version__
+        else:
+            out[key] = safe_cmd(SOFTWARE_VERSIONS[key])
+    return out
+
+
+def getHostInfo(include_versions=False, include_blocked=False):
     mem = psutil.virtual_memory()
     disk = psutil.disk_usage('/')
     net = psutil.net_io_counters()
@@ -130,11 +103,11 @@ def on_get_system_info(request):
     except Exception:
         pass
 
-    if request.DATA.get("versions") and SOFTWARE_VERSIONS:
+    if include_versions and SOFTWARE_VERSIONS:
         out["versions"] = getVersions()
-    if request.DATA.get("blocked"):
+    if include_blocked:
         out["blocked"] = helpers.getBlockedHosts()
-    return views.restGet(request, out)
+    return out
 
 
 def safe_cmd(cmd, *args):
@@ -147,14 +120,3 @@ def safe_cmd(cmd, *args):
         return str(err)
         # print( str(err))
     return None
-
-
-def getVersions(out=None):
-    if out is None:
-        out = {}
-    for key in SOFTWARE_VERSIONS:
-        if key == "django":
-            out[key] = django.__version__
-        else:
-            out[key] = safe_cmd(SOFTWARE_VERSIONS[key])
-    return out

django_restit-4.2.105/rest/rpc.py

@@ -0,0 +1,62 @@
+from . import views
+
+import version
+from . import joke
+from . import helpers
+
+import django
+from django.conf import settings
+
+
+from .decorators import url
+from rest.extra import hostinfo
+
+
+URL_PREFIX = ""
+
+SOFTWARE_VERSIONS = getattr(settings, 'SOFTWARE_VERSIONS', None)
+ALLOW_PUBLIC_SYS_INFO = getattr(settings, 'ALLOW_PUBLIC_SYS_INFO', False)
+SYS_INFO_KEY = getattr(settings, 'SYS_INFO_KEY', None)
+# SOFTWARE_VERSIONS_ACTUAL = {}
+
+
+@url('version')
+def on_get_version(request):
+    return views.restStatus(request, True, {"data": version.VERSION, "ip": request.ip})
+
+
+@url('versions')
+def on_get_version(request):
+    from rest import __version__ as restit_version
+    versions = dict(
+        project=version.VERSION,
+        restit=restit_version)
+    if request.DATA.get("detailed") and SOFTWARE_VERSIONS:
+        hostinfo.getVersions(versions)
+    return views.restStatus(request, True, {"data": versions})
+
+
+@url('test/session')
+def on_get_my_session(request):
+    echo = request.DATA.get("echo", None)
+    if echo:
+        request.session["echo"] = echo
+    return views.restReturn(request, dict(echo=request.session.get("echo", "not set")))
+
+
+@url('joke')
+def on_get_joke(request):
+    return views.restGet(request, {"joke": joke.getRandomJoke()})
+
+
+@url('system/info')
+def on_get_system_info(request):
+    key = request.DATA.get("key")
+    if SYS_INFO_KEY is None or key != SYS_INFO_KEY:
+        if not ALLOW_PUBLIC_SYS_INFO and not request.user.is_authenticated:
+            return views.restPermissionDenied(request, "system info is not public", 565)
+    out = hostinfo.getHostInfo(
+        include_versions=request.DATA.get("versions") and SOFTWARE_VERSIONS,
+        include_blocked=request.DATA.get("blocked"))
+    return views.restGet(request, out)
+

{django_restit-4.2.103 → django_restit-4.2.105}/taskqueue/models.py

@@ -392,7 +392,7 @@ class Task(models.Model, RestModel):
         return task
 
     @classmethod
-    def PublishModelTask(cls, model_name, fname, data, stale_after_seconds=0, channel="tq_model_handler", scheduled_for=scheduled_for):
+    def PublishModelTask(cls, model_name, fname, data, stale_after_seconds=0, channel="tq_model_handler", scheduled_for=None):
         return cls.Publish(cls, model_name, fname, data, stale_after_seconds, channel, scheduled_for)
 
     @classmethod