Vland/visualisation/visualisation.py

#! /usr/bin/python

#  Copyright 2015 Linaro Limited
#
#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
#  MA 02110-1301, USA.
#
#  Visualisation module for VLANd. Fork a trivial webserver
#  implementation on an extra, and generate a simple set of pages and
#  graphics on demand.
#

import os, sys, logging, time, datetime, re, signal
from multiprocessing import Process
from BaseHTTPServer import BaseHTTPRequestHandler
from BaseHTTPServer import HTTPServer
import urlparse
import cStringIO

from Vland.errors import InputError
from Vland.db.db import VlanDB
from Vland.config.config import VlanConfig
from Vland.visualisation.graphics import Graphics,Switch
from Vland.util import VlanUtil
class VlandHTTPServer(HTTPServer):
    """ Trivial wrapper for HTTPServer so we can include our own state. """
    def __init__(self, server_address, handler, state):
        HTTPServer.__init__(self, server_address, handler)
        self.state = state

class GraphicsCache(object):
    """ Cache for graphics state, to avoid having to recalculate every
        query too many times. """
    last_update = None
    graphics = {}

    def __init__(self):
        # Pick an epoch older than any sensible use
        self.last_update = datetime.datetime(2000, 01, 01)

class Visualisation(object):
    """ Code and config for the visualisation graphics module. """

    state = None
    p = None

    # Fork a new process for the visualisation webserver
    def __init__(self, state):
        self.state = state
        self.p = Process(target=self.visloop, args=())
        self.p.start()

    def _receive_signal(self, signum, stack):
        if signum == signal.SIGUSR1:
            self.state.db_ok = True

    # The main loop for the visualisation webserver
    def visloop(self):
        self.state.db_ok = False
        self.state.cache = GraphicsCache()

        loglevel = VlanUtil().set_logging_level(self.state.config.logging.level)

        # Should we log to stderr?
        if self.state.config.logging.filename is None:
            logging.basicConfig(level = loglevel,
                                format = '%(asctime)s %(levelname)-8s %(message)s')
        else:
            logging.basicConfig(level = loglevel,
                                format = '%(asctime)s %(levelname)-8s VIS  %(message)s',
                                datefmt = '%Y-%m-%d %H:%M:%S %Z',
                                filename = self.state.config.logging.filename,
                                filemode = 'a')
            logging.info('%s visualisation starting up', self.state.banner)

        # Wait for main process to signal to us that it's finished with any
        # database upgrades and we can open it without any problems.
        signal.signal(signal.SIGUSR1, self._receive_signal)
        while not self.state.db_ok:
            logging.info('%s visualisation waiting for db_ok signal', self.state.banner)
            time.sleep(1)
        logging.info('%s visualisation received db_ok signal', self.state.banner)

        self.state.db = VlanDB(db_name=self.state.config.database.dbname,
                               username=self.state.config.database.username,
                               readonly=True)

        server = VlandHTTPServer(('', self.state.config.visualisation.port),
                                 GetHandler, self.state)
        server.serve_forever()

    # Kill the webserver
    def shutdown(self):
        self.p.terminate()

    # Kill the webserver
    def signal_db_ok(self):
        os.kill(self.p.pid, signal.SIGUSR1)

class GetHandler(BaseHTTPRequestHandler):
    """ Methods to generate and serve the pages """

    parsed_path = None

    # Trivial top-level page. Link to images for each of the VLANs we
    # know about.
    def send_index(self):
        self.send_response(200)
        self.wfile.write('Content-type: text/html\r\n')
        self.end_headers()
        config = self.server.state.config.visualisation
        cache = self.server.state.cache
        db = self.server.state.db
        switches = db.all_switches()
        vlans = db.all_vlans()
        vlan_tags = {}

        for vlan in vlans:
            vlan_tags[vlan['vlan_id']] = vlan['tag']

        if cache.last_update < self.server.state.db.get_last_modified_time():
            logging.debug('Cache is out of date')
            # Fill the cache with all the information we need:
            # * the graphics themselves
            # * the data to match each graphic, so we can generate imagemap/tooltips
            cache.graphics = {}
            if len(switches) > 0:
                for vlan in vlans:
                    cache.graphics[vlan['vlan_id']] = self.generate_graphic(vlan['vlan_id'])
            cache.last_update = datetime.datetime.utcnow()

        page = []
        page.append('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">')
        page.append('<html>')
        page.append('<head>')
        page.append('<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">')
        page.append('<TITLE>VLANd visualisation</TITLE>')
        page.append('<link rel="stylesheet" type="text/css" href="style.css">')
        if config.refresh and config.refresh > 0:
            page.append('<meta http-equiv="refresh" content="%d">' % config.refresh)
        page.append('</HEAD>')
        page.append('<body>')

        # Generate left-hand menu with links to each VLAN diagram
        page.append('<div class="menu">')
        if len(switches) > 0:
            page.append('<h2>Menu</h2>')
            page.append('<p>VLANs: %d</p>' % len(vlans))
            page.append('<ul>')
            for vlan in vlans:
                page.append('<li><a href="./#vlan%d">VLAN ID %d, Tag %d<br>(%s)</a>' % (vlan['vlan_id'], vlan['vlan_id'], vlan['tag'], vlan['name']))
            page.append('</ul>')
        page.append('<div class="date"><p>Current time: %s</p>' % datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC"))
        page.append('<p>version %s</p>' % self.server.state.version)
        page.append('</div>')
        page.append('</div>')

        # Now the main content area with the graphics
        page.append('<div class="content">')
        page.append('<h1>VLANd visualisation</h1>')

        # Bail early if we have nothing to show!
        if len(switches) == 0:
            page.append('<p>No switches found in the database, nothing to show...</p>')
            page.append('</div>')
            page.append('</body>')
            self.wfile.write('\r\n'.join(page))
            return

        # Trivial javascript helpers for tooltip control
        page.append('<SCRIPT LANGUAGE="javascript">')
        page.append('function popup(v,p) {')
        page.append('a=v.toString();')
        page.append('b=p.toString();')
        page.append('id="port".concat("",a).concat(".",b);')
        page.append('document.getElementById(id).style.visibility="visible";')
        page.append('}')
        page.append('function popdown(v,p) {')
        page.append('a=v.toString();')
        page.append('b=p.toString();')
        page.append('id="port".concat("",a).concat(".",b);')
        page.append('document.getElementById(id).style.visibility="hidden";')
        page.append('}')
        page.append('</SCRIPT>')

        # For each VLAN, add a graphic
        for vlan in vlans:
            this_image = cache.graphics[vlan['vlan_id']]
            page.append('<a name="vlan%d"></a>' % vlan['vlan_id'])
            page.append('<h3>VLAN ID %d, Tag %d, name %s</h3>' % (vlan['vlan_id'], vlan['tag'], vlan['name']))

            # Link to an image we generate from our data
            page.append('<p><img src="images/vlan/%d.png" ' % vlan['vlan_id'])
            page.append('width="%d" height="%d" ' % ( this_image['image']['width'], this_image['image']['height']))
            page.append('alt="VLAN %d diagram" usemap="#MAPVLAN%d">' % (vlan['vlan_id'],vlan['vlan_id']))

            # Generate an imagemap describing all the ports, with
            # javascript hooks to pop up/down a tooltip box based on
            # later data.
            page.append('<map name="MAPVLAN%d">' % vlan['vlan_id'])
            for switch in this_image['ports'].keys():
                for portnum in this_image['ports'][switch].keys():
                    this_port = this_image['ports'][switch][portnum]
                    port = this_port['db']
                    ((ulx,uly),(lrx,lry),upper) = this_port['location']
                    page.append('<area shape="rect" ')
                    page.append('coords="%d,%d,%d,%d" ' % (ulx,uly,lrx,lry))
                    page.append('onMouseOver="popup(%d,%d)" onMouseOut="popdown(%d,%d)">' % (vlan['vlan_id'], port['port_id'], vlan['vlan_id'], port['port_id']))
            page.append('</map></p>')
            page.append('<hr>')
        page.append('</div>') # End of normal content, all the VLAN graphics shown

        # Now generate the tooltip boxes for the ports. Each is
        # fully-formed but invisible, ready for our javascript helper
        # to pop visible on demand.
        for vlan in vlans:
            this_image = cache.graphics[vlan['vlan_id']]
            for switch in this_image['ports'].keys():
                for portnum in this_image['ports'][switch].keys():
                    this_port = this_image['ports'][switch][portnum]
                    port = this_port['db']
                    page.append('<div class="port" id="port%d.%d">' % (vlan['vlan_id'], port['port_id']))
                    page.append('Port ID: %d<br>' % port['port_id'])
                    page.append('Port Number: %d<br>' % port['number'])
                    page.append('Port Name: %s<br>' % port['name'])
                    if port['is_locked']:
                        page.append('Locked - ')
                        if (port['lock_reason'] is not None
                                and len(port['lock_reason']) > 1):
                            page.append(port['lock_reason'])
                        else:
                            page.append('unknown reason')
                        page.append('<br>')
                    if port['is_trunk']:
                        page.append('Trunk')
                        if port['trunk_id'] != -1:
                            page.append(' (Trunk ID %d)' % port['trunk_id'])
                        page.append('<br>')
                    else:
                        page.append('Current VLAN ID: %d (Tag %d)<br>' % (port['current_vlan_id'], vlan_tags[port['current_vlan_id']]))
                        page.append('Base VLAN ID: %d (Tag %d)<br>' % (port['base_vlan_id'], vlan_tags[port['base_vlan_id']]))
                    page.append('</div>')

        page.append('</body>')
        self.wfile.write('\r\n'.join(page))

    # Simple-ish style sheet
    def send_style(self):
        self.send_response(200)
        self.wfile.write('Content-type: text/css\r\n')
        self.end_headers()
        cache = self.server.state.cache
        page = []
        page.append('body {')
        page.append('    background: white;')
        page.append('    color: black;')
        page.append('    font-size: 12pt;')
        page.append('}')
        page.append('')
        page.append('.menu {')
        page.append('	 position:fixed;')
        page.append('	 float:left;')
        page.append('    font-family: arial, Helvetica, sans-serif;')
        page.append('	 width:20%;')
        page.append('	 height:100%;')
        page.append('    font-size: 10pt;')
        page.append('    padding-top: 10px;')
        page.append('}')
        page.append('')
        page.append('.content {')
        page.append('	 position:relative;')
        page.append('    padding-top: 10px;')
        page.append('	 width: 80%;')
        page.append('	 max-width:80%;')
        page.append('	 margin-left: 21%;')
        page.append('    margin-top: 50px;')
        page.append('	 height:100%;')
        page.append('}')
        page.append('')
        page.append('h1,h2,h3 {')
        page.append('    font-family: arial, Helvetica, sans-serif;')
        page.append('    padding-right:3pt;')
        page.append('    padding-top:2pt;')
        page.append('    padding-bottom:2pt;')
        page.append('    margin-top:8pt;')
        page.append('    margin-bottom:8pt;')
        page.append('    border-style:none;')
        page.append('    border-width:thin;')
        page.append('}')
        page.append('A:link { text-decoration: none; }')
        page.append('A:visited { text-decoration: none}')
        page.append('h1 { font-size: 18pt; }')
        page.append('h2 { font-size: 14pt; }')
        page.append('h3 { font-size: 12pt; }')
        page.append('dl,ul { margin-top: 1pt; text-indent: 0 }')
        page.append('ol { margin-top: 1pt; text-indent: 0 }')
        page.append('div.date { font-size: 8pt; }')
        page.append('div.sig { font-size: 8pt; }')
        page.append('div.port {')
        page.append('    display: block;')
        page.append('    position: fixed;')
        page.append('    left: 0px;')
        page.append('    bottom: 0px;')
        page.append('    z-index: 99;')
        page.append('    background: #FFFF00;')
        page.append('    border-style: solid;')
        page.append('    border-width: 3pt;')
        page.append('    border-color: #3B3B3B;')
        page.append('    margin: 1;')
        page.append('    padding: 5px;')
        page.append('    font-size: 10pt;')
        page.append('    font-family: Courier,monotype;')
        page.append('    visibility: hidden;')
        page.append('}')
        self.wfile.write('\r\n'.join(page))

    # Generate a PNG showing the layout of switches/port/trunks for a
    # specific VLAN
    def send_graphic(self):
        vlan_id = 0
        vlan_re = re.compile(r'^/images/vlan/(\d+).png$')
        match = vlan_re.match(self.parsed_path.path)
        if match:
            vlan_id = int(match.group(1))
        cache = self.server.state.cache

        # Do we have a graphic for this VLAN ID?
        if not vlan_id in cache.graphics.keys():
            logging.debug('asked for vlan_id %s', vlan_id)
            logging.debug(cache.graphics.keys())
            self.send_response(404)
            self.wfile.write('Content-type: text/plain\r\n')
            self.end_headers()
            self.wfile.write('404 Not Found\r\n')
            self.wfile.write('%s' % self.parsed_path.path)
            logging.error('VLAN graphic not found - asked for %s', self.parsed_path.path)
            return

        # Yes - just send it from the cache
        self.send_response(200)
        self.wfile.write('Content-type: image/png\r\n')
        self.end_headers()
        self.wfile.write(cache.graphics[vlan_id]['image']['png'].getvalue())
        return

    # Generate a PNG showing the layout of switches/port/trunks for a
    # specific VLAN, and return that PNG along with geometry details
    def generate_graphic(self, vlan_id):
        db = self.server.state.db
        vlan = db.get_vlan_by_id(vlan_id)
        # We've been asked for a VLAN that doesn't exist
        if vlan is None:
            return None

        data = {}
        data['image'] = {}
        data['ports'] = {}

        gim = Graphics()

        # Pick fonts. TODO: Make these configurable?
        gim.set_font(['/usr/share/fonts/truetype/inconsolata/Inconsolata.otf',
                      '/usr/share/fonts/truetype/freefont/FreeMono.ttf'])
        try:
            gim.font
        # If we can't get the font we need, fail
        except NameError:
            self.send_response(500)
            self.wfile.write('Content-type: text/plain\r\n')
            self.end_headers()
            self.wfile.write('500 Internal Server Error\r\n')
            logging.error('Unable to generate graphic, no fonts found - asked for %s',
                          self.parsed_path.path)
            return

        switch = {}
        size_x = {}
        size_y = {}

        switches = db.all_switches()

        # Need to set gaps big enough for the number of trunks, at least.
        trunks = db.all_trunks()
        y_gap = max(20, 15 * len(trunks))
        x_gap = max(20, 15 * len(trunks))

        x = 0
        y = y_gap

        # Work out how much space we need for the switches
        for i in range(0, len(switches)):
            ports = db.get_ports_by_switch(switches[i]['switch_id'])
            switch[i] = Switch(gim, len(ports), switches[i]['name'])
            (size_x[i], size_y[i]) = switch[i].get_dimensions()
            x = max(x, size_x[i])
            y += size_y[i] + y_gap

        # Add space for the legend and the label
        label = "VLAN %d - %s" % (vlan['tag'], vlan['name'])
        (legend_width, legend_height) = gim.get_legend_dimensions()
        (label_width, label_height) = gim.get_label_size(label, gim.label_font_size)
        x = max(x, legend_width + 2*x_gap + label_width)
        x = x_gap + x + x_gap
        y = y + max(legend_height + y_gap, label_height)

        # Create a canvas of the right size
        gim.create_canvas(x, y)

        # Draw the switches and ports in it
        curr_y = y_gap
        for i in range(0, len(switches)):
            switch[i].draw_switch(gim, x_gap, curr_y)
            ports = db.get_ports_by_switch(switches[i]['switch_id'])
            data['ports'][i] = {}
            for port_id in ports:
                port = db.get_port_by_id(port_id)
                port_location = switch[i].get_port_location(port['number'])
                data['ports'][i][port['number']] = {}
                data['ports'][i][port['number']]['db'] = port
                data['ports'][i][port['number']]['location'] = port_location
                if port['is_locked']:
                    switch[i].draw_port(gim, port['number'], 'locked')
                elif port['is_trunk']:
                    switch[i].draw_port(gim, port['number'], 'trunk')
                elif port['current_vlan_id'] == int(vlan_id):
                    switch[i].draw_port(gim, port['number'], 'VLAN')
                else:
                    switch[i].draw_port(gim, port['number'], 'normal')
            curr_y += size_y[i] + y_gap

        # Now add the trunks
        for i in range(0, len(trunks)):
            ports = db.get_ports_by_trunk(trunks[i]['trunk_id'])
            port1 = db.get_port_by_id(ports[0])
            port2 = db.get_port_by_id(ports[1])
            for s in range(0, len(switches)):
                if switches[s]['switch_id'] == port1['switch_id']:
                    switch1 = s
                if switches[s]['switch_id'] == port2['switch_id']:
                    switch2 = s
            gim.draw_trunk(i,
                           switch[switch1].get_port_location(port1['number']),
                           switch[switch2].get_port_location(port2['number']),
                           gim.port_pallette['trunk']['trace'])

        # And the legend and label
        gim.draw_legend(x_gap, curr_y)
        gim.draw_label(x - label_width - 2*x_gap, curr_y, label, int(x_gap / 2))

        # All done - push the image file into the cache for this vlan
        data['image']['png'] = cStringIO.StringIO()
        gim.im.writePng(data['image']['png'])
        data['image']['width'] = x
        data['image']['height'] = y
        return data

    # Implement an HTTP GET handler for the HTTPServer instance
    def do_GET(self):
        # Compare the URL path to any of the names we recognise and
        # call the right generator function if we get a match
        self.parsed_path = urlparse.urlparse(self.path)
        for url in self.functionMap:
            match = re.match(url['re'], self.parsed_path.path)
            if match:
                return url['fn'](self)

        # Fall-through for any files we don't recognise
        self.send_response(404)
        self.wfile.write('Content-type: text/plain\r\n')
        self.end_headers()
        self.wfile.write('404 Not Found')
        self.wfile.write('%s' % self.parsed_path.path)
        logging.error('File not supported - asked for %s', self.parsed_path.path)
        return

    # Override the BaseHTTPRequestHandler log_message() method so we
    # can log requests properly
    def log_message(self, fmt, *args):
        """Log an arbitrary message. """
        logging.info('%s %s', self.client_address[0], fmt%args)

    functionMap = (
        {'re': r'^/$', 'fn': send_index},
        {'re': r'^/style.css$', 'fn': send_style},
        {'re': r'^/images/vlan/(\d+).png$', 'fn': send_graphic}
    )