django-restit 4.2.103__py3-none-any.whl → 4.2.105__py3-none-any.whl

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):

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.dist-info → django_restit-4.2.105.dist-info}/METADATA

@@ -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.dist-info → django_restit-4.2.105.dist-info}/RECORD

@@ -26,11 +26,11 @@ account/migrations/0021_alter_cloudcredentials_group.py,sha256=zoFYmE-hd3uRGX6DR
 account/migrations/0022_alter_memberdevice_modified.py,sha256=9eeKcdr9p6qFJ8ZxSnKSj1KxZjW8NZfM0YCMck6i0QQ,424
 account/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 account/models/__init__.py,sha256=cV_lMnT2vL_mjiYtT4hlcIHo52ocFbGSNVkOIHHLXZY,385
-account/models/device.py,sha256=qW9tKMFhlSepaNku4OOHGb9VoSU6hhOXyg4hzDwlbKk,5886
+account/models/device.py,sha256=0AFeLMGk4im4KZVd3eGSyRbK4eQEXiFM2cdY8GUzihs,5934
 account/models/feeds.py,sha256=vI7fG4ASY1M0Zjke24RdnfDcuWeATl_yR_25jPmT64g,2011
 account/models/group.py,sha256=mjWwePt3ogQUo9m0EhURMz0aBrVVx_0Drr0lNDESQio,22281
 account/models/legacy.py,sha256=zYdtv4LC0ooxPVqWM-uToPwV-lYWQLorSE6p6yn1xDw,2720
-account/models/member.py,sha256=XYb3LUd9HhhY6fX4m963-ts0VTmYLLjiqpPzlMoF7Xo,53129
+account/models/member.py,sha256=JziyYNC13SFWX07Thtoe2V_YlrKNn2RHJZcRk15Zh-s,54205
 account/models/membership.py,sha256=90EpAhOsGaqphDAkONP6j_qQ0OWSRaQsI8H7E7fgMkE,9249
 account/models/notify.py,sha256=TOkuVBLAsbzT58FOxII_G3Cj_IDQx16vyehyEsNrDcY,15306
 account/models/passkeys.py,sha256=TJxITUi4DT4_1tW2K7ZlOcRjJuMVl2NtKz7pKQU8-Tw,1516
@@ -352,10 +352,10 @@ metrics/migrations/0004_eodmetrics.py,sha256=Ky6ZVMZqa0F_SUp_QFWY7ZKBgVhy9CS4wZc
 metrics/migrations/0005_alter_metrics_v1_alter_metrics_v10_alter_metrics_v11_and_more.py,sha256=pmwJfpPJ1RUX_CqM66l6vvV-nrAUPo_GIan0Pc9mQHs,2358
 metrics/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 metrics/models.py,sha256=lD9nVzfwdav70ENulqJ8rE8Ui8EWlzdVp05rg8bAlMA,13444
-metrics/periodic.py,sha256=VmL0YG05D6k5fcNsF4QqPEU-BBPbZXjbOrp3b8EHZ-U,651
+metrics/periodic.py,sha256=28V8Ml4y1WpZeuC-6Ggf8l4kudskYpBedIKLAe5Br2c,978
 metrics/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-metrics/providers/aws.py,sha256=RDM5RLeFADHexm4cHaJdAm3K6iz1NwMSNcV9GYuGtjY,7432
-metrics/rpc.py,sha256=nY7TQPOXJ-CcFbv5uvrCicGbsvEdrIooD0rFKS8Ma1E,21300
+metrics/providers/aws.py,sha256=vhz0w6xE_V_V050g3V2uKEUPRIaI_o48MFkfsHjLzQU,8307
+metrics/rpc.py,sha256=yIv1ZVnlY_RYI693pX5iptH3gnVAC1DQ2nJQ5vLZQyw,21657
 metrics/settings.py,sha256=wwHA9Z7BAHNeu3tFVn8Fh5j46KR-eGx0E8r5dzCFlAU,132
 metrics/tq.py,sha256=WHBRYSinmTuxF9l-_-lx0yfzEYkb0ffVMt_uvCj9bYo,825
 metrics/utils.py,sha256=PSydxeI983udULUTcbeWG-_ulPSOac6Q_t_8k_Vjn1I,12606
@@ -386,6 +386,7 @@ rest/decorators.py,sha256=ig0LATc3-2mhEJPAWHRbIRM-ZOFyjm6e_F9RhpRWidE,15082
 rest/encryption.py,sha256=x6Kiez0tVqfxK26MSsRL3k8OS05ni1gEX2aj3I0S9V0,788
 rest/errors.py,sha256=uKwG9OkLme36etabqK54DMjMQc1fgEoUIAUxXa7WFQw,612
 rest/extra/__init__.py,sha256=YzmNsch5H5FFLkUK9mIAKyoRK_rJCA9HGb0kubp4h30,54
+rest/extra/hostinfo.py,sha256=bAj-6XjY9sJPLHqLxZZLHjmlzSFDJK1L18w81Zb_1ec,3081
 rest/extra/json_metadata.py,sha256=p_ffzmANmOFix_oC3voR6_NNTjcn7-T7aXcH-I4_Npg,1078
 rest/fields.py,sha256=_v1TJVc6vyWlqmwFRJ6mtuR5Fo-lS0KcUhPWIrzKZUo,9719
 rest/forms.py,sha256=66Wm5cdy8tKib_mGicjq_yd-gNVMFWRECnrDksnNnwU,6316
@@ -412,7 +413,7 @@ rest/models/metadata.py,sha256=1nQ7CYo9bJHoaXE_hVNaj1-Y7yqhHlf2ZlaD1IfTzic,12904
 rest/net.py,sha256=LcB2QV6VNRtsSdmiQvYZgwQUDwOPMn_VBdRiZ6OpI-I,2974
 rest/regexes.yaml,sha256=VoGb4E-P_K9f82Yzcpltgzekpt9usRtwu9PYlo46nUw,149463
 rest/requestex.py,sha256=N56056vV3zWkAP-QrYsCu7SdpPzE5kLuPoxGIuZAKt0,16127
-rest/rpc.py,sha256=Z-0Q62VeMViZiS_9vBHKJmbERgemsfg8pnKFjV-DH-w,4200
+rest/rpc.py,sha256=lHJkZXOxLJJoD4LVPDMXZGk5jV6Yltu7Lu4pMxMpq38,1764
 rest/search.py,sha256=QVjk2b5tZLgf1zM2MHvJTyRjwUbY5ZD7HXSTmSPXtvU,8362
 rest/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rest/serializers/collection.py,sha256=V9O4qxw26VX9dSYdbsN0-RNnXEi347Ln8eFLZ003LhA,4646
@@ -455,7 +456,7 @@ taskqueue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 taskqueue/admin.py,sha256=E6zXoToS_ea3MdoGjZzF1JiepWFtDSoZUQdan8H-pXI,208
 taskqueue/migrations/0001_initial.py,sha256=JwYib8CK5ftSXlfxKZUcKEEVsXktNB5q3h-2tu9inGk,4738
 taskqueue/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-taskqueue/models.py,sha256=N3_9jWHPGzs6UxlAzpjst6qPhvIs1RELTy1cMXMeXsA,22407
+taskqueue/models.py,sha256=i8v0vQqlz4X3rVFVJsUSldA-26NEPWnsMZF2Kly_1Qo,22398
 taskqueue/periodic.py,sha256=2i0271khrCow3hDmlNEcoAZnesBVl40jd7MIim2Cxs4,3543
 taskqueue/rpc.py,sha256=Lf5VUoqCRkfWUAIvx_s508mjAtDPwpiWyxg0ryqWbQA,5793
 taskqueue/tq.py,sha256=PzSoDrawYcqZylruEgsK95gcJ4J_VhdM6rxg9V6_X8E,942
@@ -508,7 +509,7 @@ ws4redis/servers/uwsgi.py,sha256=VyhoCI1DnVFqBiJYHoxqn5Idlf6uJPHvfBKgkjs34mo,172
 ws4redis/settings.py,sha256=K0yBiLUuY81iDM4Yr-k8hbvjn5VVHu5zQhmMK8Dtz0s,1536
 ws4redis/utf8validator.py,sha256=S0OlfjeGRP75aO6CzZsF4oTjRQAgR17OWE9rgZdMBZA,5122
 ws4redis/websocket.py,sha256=R0TUyPsoVRD7Y_oU7w2I6NL4fPwiz5Vl94-fUkZgLHA,14848
-django_restit-4.2.103.dist-info/LICENSE.md,sha256=VHN4hhEeVOoFjtG-5fVv4jesA4SWi0Z-KgOzzN6a1ps,1068
-django_restit-4.2.103.dist-info/METADATA,sha256=nrU8OENjEKfiHoufi6H03kYhsf4mkpD01W8WvOWJkeM,7663
-django_restit-4.2.103.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-django_restit-4.2.103.dist-info/RECORD,,
+django_restit-4.2.105.dist-info/LICENSE.md,sha256=VHN4hhEeVOoFjtG-5fVv4jesA4SWi0Z-KgOzzN6a1ps,1068
+django_restit-4.2.105.dist-info/METADATA,sha256=coKathiRmyLShZnTuanyUxbHmC_0C2nPkuTfHR4aszs,7663
+django_restit-4.2.105.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+django_restit-4.2.105.dist-info/RECORD,,

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()

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:

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")
 
 

rest/extra/hostinfo.py

@@ -0,0 +1,122 @@
+from datetime import datetime
+import time
+from rest import helpers
+from django.conf import settings
+import django
+import version
+import platform
+import socket
+
+
+try:
+    import psutil
+except Exception:
+    print("no psutil")
+
+SOFTWARE_VERSIONS = getattr(settings, 'SOFTWARE_VERSIONS', None)
+
+
+def getHostIP():
+    hostname = socket.gethostname()
+    return socket.gethostbyname(hostname)
+
+
+def getTcpEstablishedCount():
+    return len(getTcpEstablished())
+
+
+def getTcpEstablished():
+    cons = psutil.net_connections(kind="tcp")
+    established = []
+    for c in cons:
+        if c.status == "ESTABLISHED":
+            established.append(c)
+    return established
+
+
+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()
+
+    out = {
+        "time": time.time(),
+        "datetime": str(datetime.now()),
+        "version": version.VERSION,
+        "os": {
+            "system": platform.system(),
+            "version": platform.version(),
+            "hostname": platform.node(),
+            "release": platform.release(),
+            "processor": platform.processor(),
+            "machine": platform.machine()
+        },
+        "boot_time": psutil.boot_time(),
+        "cpu_load": psutil.cpu_percent(),
+        "cpus_load": psutil.cpu_percent(percpu=True),
+        "memory": {
+            "total": mem.total,
+            "used": mem.used,
+            "available": mem.available,
+            "percent": mem.percent
+        },
+        "disk": {
+            "total": disk.total,
+            "used": disk.used,
+            "free": disk.free,
+            "percent": disk.percent
+        }, 
+        "users": psutil.users()
+    }
+
+    try:
+        out["cpu"] = {
+            "count": psutil.cpu_count(),
+            "freq": psutil.cpu_freq(),
+        }
+    except Exception:
+        pass
+
+    try:
+        out["network"] = {
+            "tcp_cons": getTcpEstablishedCount(),
+            "bytes_sent": net.bytes_sent,
+            "bytes_recv": net.bytes_recv,
+            "packets_sent": net.packets_sent,
+            "packets_recv": net.packets_recv,
+            "errin": net.errin,
+            "errout": net.errout,
+            "dropin": net.dropin,
+            "dropout": net.dropout
+        }
+    except Exception:
+        pass
+
+    if include_versions and SOFTWARE_VERSIONS:
+        out["versions"] = getVersions()
+    if include_blocked:
+        out["blocked"] = helpers.getBlockedHosts()
+    return out
+
+
+def safe_cmd(cmd, *args):
+    try:
+        cmd_args = [cmd]
+        if len(args):
+            cmd_args.extend(list(args))
+        return helpers.toString(subprocess.check_output(cmd_args, shell=True).strip())
+    except Exception as err:
+        return str(err)
+        # print( str(err))
+    return None

rest/rpc.py

@@ -1,10 +1,6 @@
 from . import views
 
 import version
-import time
-from datetime import datetime
-import platform
-import subprocess
 from . import joke
 from . import helpers
 
@@ -13,33 +9,30 @@ from django.conf import settings
 
 
 from .decorators import url
-
-try:
-    import psutil
-except Exception:
-    print("no psutil")
+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(r'^version$')
+@url('version')
 def on_get_version(request):
     return views.restStatus(request, True, {"data": version.VERSION, "ip": request.ip})
 
 
-@url(r'^versions$')
+@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:
-        getVersions(versions)
+        hostinfo.getVersions(versions)
     return views.restStatus(request, True, {"data": versions})
 
 
@@ -51,110 +44,19 @@ def on_get_my_session(request):
     return views.restReturn(request, dict(echo=request.session.get("echo", "not set")))
 
 
-@url(r'^joke$')
+@url('joke')
 def on_get_joke(request):
     return views.restGet(request, {"joke": joke.getRandomJoke()})
 
 
-def getTcpEstablishedCount():
-    return len(getTcpEstablished())
-
-
-def getTcpEstablished():
-    cons = psutil.net_connections(kind="tcp")
-    established = []
-    for c in cons:
-        if c.status == "ESTABLISHED":
-            established.append(c)
-    return established
-
-
-@url(r'^system/info$')
+@url('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)
-    mem = psutil.virtual_memory()
-    disk = psutil.disk_usage('/')
-    net = psutil.net_io_counters()
-
-    out = {
-        "time": time.time(),
-        "datetime": str(datetime.now()),
-        "version": version.VERSION,
-        "os": {
-            "system": platform.system(),
-            "version": platform.version(),
-            "hostname": platform.node(),
-            "release": platform.release(),
-            "processor": platform.processor(),
-            "machine": platform.machine()
-        },
-        "boot_time": psutil.boot_time(),
-        "cpu_load": psutil.cpu_percent(),
-        "cpus_load": psutil.cpu_percent(percpu=True),
-        "memory": {
-            "total": mem.total,
-            "used": mem.used,
-            "available": mem.available,
-            "percent": mem.percent
-        },
-        "disk": {
-            "total": disk.total,
-            "used": disk.used,
-            "free": disk.free,
-            "percent": disk.percent
-        }, 
-        "users": psutil.users()
-    }
-
-    try:
-        out["cpu"] = {
-            "count": psutil.cpu_count(),
-            "freq": psutil.cpu_freq(),
-        }
-    except Exception:
-        pass
-
-    try:
-        out["network"] = {
-            "tcp_cons": getTcpEstablishedCount(),
-            "bytes_sent": net.bytes_sent,
-            "bytes_recv": net.bytes_recv,
-            "packets_sent": net.packets_sent,
-            "packets_recv": net.packets_recv,
-            "errin": net.errin,
-            "errout": net.errout,
-            "dropin": net.dropin,
-            "dropout": net.dropout
-        }
-    except Exception:
-        pass
-
-    if request.DATA.get("versions") and SOFTWARE_VERSIONS:
-        out["versions"] = getVersions()
-    if request.DATA.get("blocked"):
-        out["blocked"] = helpers.getBlockedHosts()
+    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)
 
-
-def safe_cmd(cmd, *args):
-    try:
-        cmd_args = [cmd]
-        if len(args):
-            cmd_args.extend(list(args))
-        return helpers.toString(subprocess.check_output(cmd_args, shell=True).strip())
-    except Exception as err:
-        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

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