[ui] Add some primitive database diagnostics to UI.

 - The most imporant part of this is a diagnostic which finds any cycles which
   are present in the database. Although this isn't supposed to happen,
   currently it is possible to end up with database in this situation when
   discovered dependencies induce a cycle.

Author: ddunbar

products/ui/llbuildui/graphalgorithms.py

@@ -0,0 +1,37 @@
+import orderedset
+
+def find_cycle(nodes, successors):
+    path = orderedset.orderedset()
+    visited = set()
+    
+    def visit(node):
+        # If the node is already in the current path, we have found a cycle.
+        if not path.add(node):
+            return (path, node)
+
+        # If we have otherwise already visited this node, we don't need to visit
+        # it again.
+        if node in visited:
+            item = path.pop()
+            assert item == node
+            return
+        visited.add(node)
+        
+        # Otherwise, visit all the successors.
+        for succ in successors(node):
+            cycle = visit(succ)
+            if cycle is not None:
+                return cycle
+
+        item = path.pop()
+        assert item == node
+        return None
+            
+    for node in nodes:
+        cycle = visit(node)
+        if cycle is not None:
+            return cycle
+        else:
+            assert not path.items
+
+    return None

products/ui/llbuildui/orderedset.py

@@ -0,0 +1,16 @@
+class orderedset(object):
+    def __init__(self):
+        self.items = []
+        self.set = set()
+
+    def add(self, item):
+        if item in self.set:
+            return False
+        self.items.append(item)
+        self.set.add(item)
+        return True
+
+    def pop(self):
+        item = self.items.pop()
+        self.set.remove(item)
+        return item

products/ui/llbuildui/templates/diagnostics.html

@@ -0,0 +1,23 @@
+{% extends "layout.html" %}
+{% block title %}Database Diagnostics{% endblock %}
+{% block body %}
+
+<p>
+  Key Names: {{ "{:,d}".format(session.query(model.KeyName).count()) }}<br/>
+  Key Names Size: {{ "{:,d}".format(session.query(sql.functions.sum(sql.functions.char_length(model.KeyName.name))).first()[0]) }}<br/>
+  Rule Results: {{ "{:,d}".format(session.query(model.RuleResult).count()) }}<br/>
+  Rule Dependencies: {{ "{:,d}".format(session.query(model.RuleDependency).count()) }}<br/>
+</p>
+
+{% if cycle %}
+<p>
+  <font color="red">WARNING: Database contains a cycle!</font><br>
+  <ul>
+    {% for node in cycle %}
+    <li>{{node}}</li>
+    {% endfor %}
+  </ul>
+</p>
+{% endif %}
+
+{% endblock %}

products/ui/llbuildui/views.py

@@ -1,7 +1,9 @@
 import flask
+import sqlalchemy.sql
 
 from flask import Flask, current_app, g, redirect, request, session, url_for
 
+import graphalgorithms
 import model
 
 main = flask.Blueprint('main', __name__)
@@ -33,6 +35,40 @@ def config():
         return redirect(url_for('main.index'))
     return flask.render_template("config.html", db_path=session.get("db"))
 
+@main.route('/diagnostics', methods=['GET', 'POST'])
+def diagnostics():
+    s = current_app.database_session
+
+    # Find all the rules.
+    rules = {}
+    key_names = {}
+    for result in s.query(model.KeyName):
+        key_names[result.id] = result.name
+    for result in s.query(model.RuleResult):
+        rules[result.key_id] = result
+
+    # Find information on any cycles in the database.
+    def successors(id):
+        # Get the rule.
+        rule = rules[id]
+
+        # Get the dependencies.
+        succs = []
+        for dependency in rule.dependencies:
+            succs.append(dependency.key_id)
+        return succs
+    keys = sorted(rules.keys())
+    cycle = graphalgorithms.find_cycle(keys, successors)
+    if cycle is not None:
+        cycle = cycle[0].items + [cycle[1]]
+        cycle = [key_names[id] for id in cycle]
+    
+    return flask.render_template("diagnostics.html",
+                                 db_path=session.get("db"),
+                                 session=s, model=model, sql=sqlalchemy.sql,
+                                 cycle=cycle)
+
+
 # MARK: Model Object Views
 
 @main.route('/rule_result/<path:name>')