Add top offenders curses command

Author: satterly

alertaclient/api.py

@@ -41,67 +41,67 @@ def __init__(self, endpoint=None, key=None, token=None, timeout=5.0, ssl_verify=
             HTTPConnection.debuglevel = 1
 
         key = key or os.environ.get('ALERTA_API_KEY', '')
-        self.client = HTTPClient(self.endpoint, key, token, timeout, ssl_verify, debug)
+        self.http = HTTPClient(self.endpoint, key, token, timeout, ssl_verify, debug)
 
     # Alerts
     def send_alert(self, **kwargs):
-        r = self.client.post('/alert', kwargs)
+        r = self.http.post('/alert', kwargs)
         return Alert.parse(r['alert'])
 
     def get_alert(self, id):
-        return Alert.parse(self.client.get('/alert/%s' % id)['alert'])
+        return Alert.parse(self.http.get('/alert/%s' % id)['alert'])
 
     def set_status(self, id, status, text):
         data = {
             'status': status,
             'text': text
         }
-        return self.client.put('/alert/%s/status' % id, data)
+        return self.http.put('/alert/%s/status' % id, data)
 
     def tag_alert(self, id, tags):
-        return self.client.put('/alert/%s/tag' % id, {"tags": tags})
+        return self.http.put('/alert/%s/tag' % id, {"tags": tags})
 
     def untag_alert(self, id, tags):
-        return self.client.put('/alert/%s/untag' % id, {"tags": tags})
+        return self.http.put('/alert/%s/untag' % id, {"tags": tags})
 
     def update_attributes(self, id, attributes):
         data = {
             'attributes': attributes
         }
-        return self.client.put('/alert/%s/attributes' % id, data)
+        return self.http.put('/alert/%s/attributes' % id, data)
 
     def delete_alert(self, id):
-        return self.client.delete('/alert/%s' % id)
+        return self.http.delete('/alert/%s' % id)
 
     def search(self, query=None):
         return self.get_alerts(query)
 
     def get_alerts(self, query=None):
-        r = self.client.get('/alerts', query)
+        r = self.http.get('/alerts', query)
         return [Alert.parse(a) for a in r['alerts']]
 
     def get_history(self, query=None):
-        r = self.client.get('/alerts/history', query)
+        r = self.http.get('/alerts/history', query)
         return [RichHistory.parse(a) for a in r['history']]
 
     def get_count(self, query=None):
-        counts = self.client.get('/alerts/count', query)
+        counts = self.http.get('/alerts/count', query)
         return counts['total'], counts['severityCounts'], counts['statusCounts']
 
     def get_top10_count(self, query=None):
-        counts = self.client.get('/alerts/top10/count', query)
+        counts = self.http.get('/alerts/top10/count', query)
         return counts['top10']
 
     def get_top10_flapping(self, query=None):
-        counts = self.client.get('/alerts/top10/flapping', query)
+        counts = self.http.get('/alerts/top10/flapping', query)
         return counts['top10']
 
     def get_environments(self, query=None):
-        counts = self.client.get('/environments', query)
+        counts = self.http.get('/environments', query)
         return counts['environments']
 
     def get_services(self, query=None):
-        counts = self.client.get('/services', query)
+        counts = self.http.get('/services', query)
         return counts['services']
 
     # Blackouts
@@ -116,46 +116,46 @@ def create_blackout(self, environment, service=None, resource=None, event=None,
             'startTime': start,
             'duration': duration
         }
-        r = self.client.post('/blackout', data)
+        r = self.http.post('/blackout', data)
         return Blackout.parse(r['blackout'])
 
     def get_blackouts(self, query=None):
-        r = self.client.get('/blackouts', query)
+        r = self.http.get('/blackouts', query)
         return [Blackout.parse(b) for b in r['blackouts']]
 
     def delete_blackout(self, id):
-        return self.client.delete('/blackout/%s' % id)
+        return self.http.delete('/blackout/%s' % id)
 
     # Customers
     def create_customer(self, customer, match):
         data = {
             'customer': customer,
             'match': match
         }
-        r = self.client.post('/customer', data)
+        r = self.http.post('/customer', data)
         return Customer.parse(r['customer'])
 
     def get_customers(self, query=None):
-        r = self.client.get('/customers', query)
+        r = self.http.get('/customers', query)
         return [Customer.parse(c) for c in r['customers']]
 
     def delete_customer(self, id):
-        return self.client.delete('/customer/%s' % id)
+        return self.http.delete('/customer/%s' % id)
 
     # Heartbeats
     def heartbeat(self, **kwargs):
-        r = self.client.post('/heartbeat', kwargs)
+        r = self.http.post('/heartbeat', kwargs)
         return Heartbeat.parse(r['heartbeat'])
 
     def get_heartbeat(self, id):
-        return Heartbeat.parse(self.client.get('/heartbeat/%s' % id)['heartbeat'])
+        return Heartbeat.parse(self.http.get('/heartbeat/%s' % id)['heartbeat'])
 
     def get_heartbeats(self, query=None):
-        r = self.client.get('/heartbeats', query)
+        r = self.http.get('/heartbeats', query)
         return [Heartbeat.parse(hb) for hb in r['heartbeats']]
 
     def delete_heartbeat(self, id):
-        return self.client.delete('/heartbeat/%s' % id)
+        return self.http.delete('/heartbeat/%s' % id)
 
     # API Keys
     def create_key(self, username, scopes=None, expires=None, text=''):
@@ -166,46 +166,46 @@ def create_key(self, username, scopes=None, expires=None, text=''):
         }
         if expires:
             data['expireTime'] = DateTime.iso8601(expires)
-        r = self.client.post('/key', data)
+        r = self.http.post('/key', data)
         return ApiKey.parse(r['data'])
 
     def get_keys(self, query=None):
-        r = self.client.get('/keys', query)
+        r = self.http.get('/keys', query)
         return [ApiKey.parse(k) for k in r['keys']]
 
     def delete_key(self, id):
-        return self.client.delete('/key/%s' % id)
+        return self.http.delete('/key/%s' % id)
 
     # Permissions
     def create_perm(self, role, scopes):
         data = {
             'match': role,
             'scopes': scopes
         }
-        r = self.client.post('/perm', data)
+        r = self.http.post('/perm', data)
         return Permission.parse(r['permission'])
 
     def get_perms(self, query=None):
-        r = self.client.get('/perms', query)
+        r = self.http.get('/perms', query)
         return [Permission.parse(p) for p in r['permissions']]
 
     def delete_perm(self, id):
-        return self.client.delete('/perm/%s' % id)
+        return self.http.delete('/perm/%s' % id)
 
     # Users
     def login(self, username, password):
         data = {
             'username': username,
             'password': password
         }
-        r = self.client.post('/auth/login', data)
+        r = self.http.post('/auth/login', data)
         if 'token' in r:
             return r['token']
         else:
             raise AuthError
 
     def get_users(self, query=None):
-        r = self.client.get('/users', query)
+        r = self.http.get('/users', query)
         return [User.parse(u) for u in r['users']]
 
     def update_user(self, id, **kwargs):
@@ -218,20 +218,20 @@ def update_user(self, id, **kwargs):
             'text': kwargs.get('text'),
             'email_verified': kwargs.get('email_verified')
         }
-        return self.client.put('/user/{}'.format(id), data)
+        return self.http.put('/user/{}'.format(id), data)
 
     def update_user_attributes(self, id, attributes):
         pass
 
     def delete_user(self, id):
-        return self.client.delete('/user/%s' % id)
+        return self.http.delete('/user/%s' % id)
 
     def userinfo(self):
-        return self.client.get('/userinfo')
+        return self.http.get('/userinfo')
 
     # Management
     def mgmt_status(self):
-        return self.client.get('/management/status')
+        return self.http.get('/management/status')
 
 
 class ApiAuth(AuthBase):

alertaclient/commands/cmd_top.py

@@ -0,0 +1,14 @@
+
+import click
+
+from alertaclient.top import Screen
+
+
+@click.command('top', short_help='Show top offenders and stats')
+@click.pass_obj
+def cli(obj):
+    """Display alerts like unix "top" command."""
+    client = obj['client']
+
+    screen = Screen(client)
+    screen.run()

alertaclient/top.py

@@ -0,0 +1,131 @@
+
+import curses
+import sys
+import time
+from curses import wrapper
+from datetime import datetime
+
+from alertaclient.models.alert import Alert
+from alertaclient.utils import DateTime
+
+
+class Screen(object):
+
+    ALIGN_RIGHT = 'R'
+    ALIGN_CENTRE = 'C'
+
+    def __init__(self, client):
+        self.client = client
+
+        self.lines = None
+        self.cols = None
+
+    def run(self):
+        wrapper(self.main)
+
+    def main(self, stdscr):
+        self.screen = stdscr
+
+        curses.use_default_colors()
+
+        curses.init_pair(1, curses.COLOR_RED, -1)
+        curses.init_pair(2, curses.COLOR_MAGENTA, -1)
+        curses.init_pair(3, curses.COLOR_YELLOW, -1)
+        curses.init_pair(4, curses.COLOR_BLUE, -1)
+        curses.init_pair(5, curses.COLOR_CYAN, -1)
+        curses.init_pair(6, curses.COLOR_GREEN, -1)
+        curses.init_pair(7, curses.COLOR_WHITE, curses.COLOR_BLACK)
+
+        COLOR_RED = curses.color_pair(1)
+        COLOR_MAGENTA = curses.color_pair(2)
+        COLOR_YELLOW = curses.color_pair(3)
+        COLOR_BLUE = curses.color_pair(4)
+        COLOR_CYAN = curses.color_pair(5)
+        COLOR_GREEN = curses.color_pair(6)
+        COLOR_BLACK = curses.color_pair(7)
+
+        self.SEVERITY_MAP = {
+            'critical': ["Crit", COLOR_RED],
+            'major': ["Majr", COLOR_MAGENTA],
+            'minor': ["Minr", COLOR_YELLOW],
+            'warning': ["Warn", COLOR_BLUE],
+            'indeterminate': ["Ind ", COLOR_CYAN],
+            'cleared': ["Clr", COLOR_GREEN],
+            'normal': ["Norm", COLOR_GREEN],
+            'inform': ["Info", COLOR_GREEN],
+            'ok': ["Ok", COLOR_GREEN],
+            'debug': ["Dbug", COLOR_BLACK],
+            'auth': ["Sec", COLOR_BLACK],
+            'unknown': ["Unkn", COLOR_BLACK]
+        }
+
+        self.screen.keypad(1)
+        self.screen.nodelay(1)
+
+        while True:
+            self.update()
+            event = self.screen.getch()
+            if 0 < event < 256:
+                self._key_press(chr(event))
+            else:
+                if event == curses.KEY_RESIZE:
+                    self.update()
+            time.sleep(2)
+
+    def update(self):
+        self.lines, self.cols = self.screen.getmaxyx()
+        self.screen.clear()
+
+        now = datetime.utcnow()
+        status = self.client.mgmt_status()
+        version = status['version']
+
+        # draw header
+        self._addstr(0, 0, self.client.endpoint, curses.A_BOLD)
+        self._addstr(0, 'C', 'alerta {}'.format(version), curses.A_BOLD)
+        self._addstr(0, 'R', '{}'.format(now.strftime('%H:%M:%S %d/%m/%y')), curses.A_BOLD)
+
+        # draw bars
+
+        # draw alerts
+        self._addstr(2, 1, 'Sev. Time     Dupl. Env.         Service      Resource     Event        Value ', curses.A_UNDERLINE)
+
+        def short_sev(severity):
+            return self.SEVERITY_MAP[severity][0]
+
+        def color(severity):
+            return self.SEVERITY_MAP[severity][1]
+
+        r = self.client.http.get('/alerts')
+        alerts = [Alert.parse(a) for a in r['alerts']]
+        last_time = DateTime.parse(r['lastTime'])
+        for i, alert in enumerate(alerts):
+            self._addstr(i+3, 1, '{0:<4} {1} {2:5d} {3:<12} {4:<12} {5:<12.12} {6:<12.12} {7:<6.6}'.format(
+                short_sev(alert.severity),
+                alert.last_receive_time.strftime('%H:%M:%S'),
+                alert.duplicate_count,
+                alert.environment,
+                ','.join(alert.service),
+                alert.resource,
+                alert.event,
+                alert.value
+            ), color(alert.severity))
+
+        # draw footer
+        self._addstr(self.lines - 1, 0, 'Last Update: {}'.format(last_time.strftime('%H:%M:%S')), curses.A_BOLD)
+        self._addstr(self.lines - 1, 'C', '{} - {}'.format(r['status'], r.get('message', 'no errors')), curses.A_BOLD)
+        self._addstr(self.lines - 1, 'R', 'Count: {}'.format(r['total']), curses.A_BOLD)
+
+        self.screen.refresh()
+
+    def _addstr(self, y, x, str, attr=0):
+        if x == self.ALIGN_RIGHT:
+            x = self.cols - len(str) - 1
+        if x == self.ALIGN_CENTRE:
+            x = int((self.cols / 2) - len(str) / 2)
+
+        self.screen.addstr(y, x, str, attr)
+
+    def _key_press(self, key):
+        if key in 'qQ':
+            sys.exit(0)