Dashboard updates

management/commands/extractors/builtin_runningsoftwareprobe.py

@@ -76,33 +76,38 @@ def insert(connection_str, user_id, reading):
                                                            'timestamp, ' + \
                                                            'utc_logged, ' + \
                                                            'running_task_count) VALUES (%s, %s, %s, %s, %s) RETURNING id;'
+    running_count = -1
+
+    if 'RUNNING_TASK_COUNT' in reading:
+        running_count = reading['RUNNING_TASK_COUNT']
 
     cursor.execute(reading_cmd, (user_id, \
                                  reading['GUID'], \
                                  reading['TIMESTAMP'], \
                                  datetime.datetime.fromtimestamp(reading['TIMESTAMP'], tz=pytz.utc), \
-                                 reading['RUNNING_TASK_COUNT']))
+                                 running_count))
 
-    for row in cursor.fetchall():
-        reading_id = row[0]
+    if 'RUNNING_TASKS' in reading:
+        for row in cursor.fetchall():
+            reading_id = row[0]
 
-        task_cursor = conn.cursor()
+            task_cursor = conn.cursor()
 
-        for task in reading['RUNNING_TASKS']:
-            task_cmd = 'INSERT INTO builtin_runningsoftwareprobe_runningtask(user_id, ' + \
-                                                                            'reading_id, ' + \
-                                                                            'utc_logged, ' + \
-                                                                            'package_name, ' + \
-                                                                            'package_category, ' + \
-                                                                            'task_stack_index) VALUES (%s, %s, %s, %s, %s, %s);'
+            for task in reading['RUNNING_TASKS']:
+                task_cmd = 'INSERT INTO builtin_runningsoftwareprobe_runningtask(user_id, ' + \
+                                                                                'reading_id, ' + \
+                                                                                'utc_logged, ' + \
+                                                                                'package_name, ' + \
+                                                                                'package_category, ' + \
+                                                                                'task_stack_index) VALUES (%s, %s, %s, %s, %s, %s);'
 
-            task_cursor.execute(task_cmd, (user_id, \
-                                           reading_id, 
-                                           datetime.datetime.fromtimestamp(reading['TIMESTAMP'], tz=pytz.utc), 
-                                           task['PACKAGE_NAME'], 
-                                           task['PACKAGE_CATEGORY'], 
-                                           task['TASK_STACK_INDEX']))
-        task_cursor.close()
+                task_cursor.execute(task_cmd, (user_id, \
+                                               reading_id, 
+                                               datetime.datetime.fromtimestamp(reading['TIMESTAMP'], tz=pytz.utc), 
+                                               task['PACKAGE_NAME'], 
+                                               task['PACKAGE_CATEGORY'], 
+                                               task['TASK_STACK_INDEX']))
+            task_cursor.close()
 
     conn.commit()
 

management/commands/pr_status_check_consistent_hardware.py

@@ -0,0 +1,33 @@
+import datetime
+import json
+
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+
+from purple_robot_app.models import PurpleRobotDevice, PurpleRobotReading, my_slugify
+from purple_robot_app.management.commands.pr_check_status import log_alert, cancel_alert
+
+HARDWARE_PROBE = 'edu.northwestern.cbits.purple_robot_manager.probes.builtin.HardwareInformationProbe'
+
+TAG = 'device_hardware_changed'
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        for device in PurpleRobotDevice.objects.filter(mute_alerts=False):
+            start = timezone.now() - datetime.timedelta(days=3)
+
+            mac = None
+            same_mac = True
+
+            for reading in PurpleRobotReading.objects.filter(user_id=device.hash_key, probe=HARDWARE_PROBE, logged__gte=start):
+                payload = json.loads(reading.payload)
+
+                if mac == None:
+                    mac = payload['WIFI_MAC']
+                elif mac != payload['WIFI_MAC']:
+                    same_mac = False
+
+            if same_mac:
+                cancel_alert(tags=TAG, user_id=device.hash_key)
+            else:
+                log_alert(message='Device hardware changed.', severity=2, tags=TAG, user_id=device.hash_key)

management/commands/pr_status_check_latest_version.py

@@ -0,0 +1,57 @@
+import datetime
+import json
+import requests
+
+from BeautifulSoup import BeautifulSoup
+
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+
+from purple_robot_app.models import PurpleRobotDevice, PurpleRobotReading, my_slugify
+from purple_robot_app.management.commands.pr_check_status import log_alert, cancel_alert
+
+TAG = 'running_latest_version'
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        play_url = 'https://play.google.com/store/apps/details?id=edu.northwestern.cbits.purple_robot_manager'
+
+        r = requests.get(play_url)
+
+        soup = BeautifulSoup(r.text)
+
+        if soup != None:
+            changelog = ''
+
+            changes = soup.findAll('div', { 'class': 'recent-change' })
+
+            for change in changes:
+                if len(changelog) > 0:
+                    changelog += '\n'
+
+                changelog += change.contents[0].strip()
+
+            version_html = soup.find('div', { 'class': 'content', 'itemprop': 'softwareVersion' })
+
+            version = version_html.contents[0].strip()
+
+            version_code = None
+            version_code_html = soup.findAll('button', { 'class': 'dropdown-child' })
+
+            for div in version_code_html:
+                if div.contents[0].strip() == 'Latest Version':
+                    version_code = float(div['data-dropdown-value'])
+
+            for device in PurpleRobotDevice.objects.filter(mute_alerts=False):
+                device_version = device.config_last_user_agent
+
+                if device_version == None:
+                    log_alert(message='Unable to determine installed version.', severity=1, tags=TAG, user_id=device.hash_key)
+                elif device_version.endswith(str(version)):
+                    cancel_alert(tags=TAG, user_id=device.hash_key)
+                else:
+                    log_alert(message='Running an older version on Purple Robot: ' + device_version + '.', severity=1, tags=TAG, user_id=device.hash_key)
+        else:
+            print('Unable to fetch Play Store metadata.')
+
+

models.py

@@ -7,6 +7,7 @@
 import pytz
 import string
 import time
+import traceback
 
 from django.core.cache import cache
 from django.core.urlresolvers import reverse
@@ -115,7 +116,7 @@ def set_most_recent_reading(self, new_reading):
 
         if ('latest_readings' in perf_data) == False:
             perf_data['latest_readings'] = {}
-        else:
+        elif (new_reading.probe in perf_data['latest_readings']):
             old_reading = PurpleRobotReading.objects.filter(pk=perf_data['latest_readings'][new_reading.probe]).first()
 
         if ('reading_counts' in perf_data) == False:
@@ -726,10 +727,13 @@ def ingest_readings(self):
 
                 if device != None:
                     device.set_most_recent_reading(reading)
-            except KeyError:
+            except KeyError as e:
+                print('Missing Key: ' + json.dumps(item, indent=2))
+                print(traceback.format_exc())
+
                 if tags is None or len(tags) == 0:
                     tags = 'ingest_error'
-                else:
+                elif tags.find('ingest_error') == -1:
                     tags += ' ingest_error'
 
         if tags is None or tags.find(tag) == -1:

templatetags/purple_robot.py

@@ -288,7 +288,12 @@ def __init__(self, data_size):
         self.data_size = template.Variable(data_size)
 
     def render(self, context):
-        data_size = float(self.data_size.resolve(context))
+        size = self.data_size.resolve(context)
+
+        if size == None:
+            size = 0
+
+        data_size = float(size)
 
         if data_size < 0:
             return 'Unknown / None'
@@ -315,7 +320,12 @@ def render(self, context):
         data_size = 0
 
         for device in PurpleRobotDevice.objects.all():
-            data_size += device.total_readings_size()
+            size = device.total_readings_size()
+
+            if size == None:
+                size = 0
+
+            data_size += size
 
         data_size *= 2