[ui] Add a primitive trace UI.

 - This is just an initial sketch of loading a trace file and showing all of the
   tasks which ran (in the order that they were readied).

Author: ddunbar

products/ui/llbuildui/app.py

@@ -3,6 +3,7 @@
 import flask
 
 import database
+import trace
 import views
 
 class LLBuildApp(flask.Flask):
@@ -20,6 +21,14 @@ def _teardown(exception):
 
         self.register_blueprint(views.main)
 
+    @property
+    def trace(self):
+        d = flask.g.get('_trace', None)
+        if d is None:
+            result = trace.Trace.frompath(flask.session["trace"])
+            d = flask.g._trace = result
+        return d
+
     @property
     def database_session(self):
         s = flask.g.get('_database_session', None)

products/ui/llbuildui/templates/db_config.html

@@ -5,7 +5,7 @@
 
 Select the database:
 <form action="" method="post">
-  <p><input type=text name=db_path>
+  <p><input type=text name=db_path value="{{db_path}}">
   <p><input type=submit value="Set Path">
 </form>
 

products/ui/llbuildui/templates/index.html

@@ -2,6 +2,7 @@
 {% block title %}llbuild Debugging UI{% endblock %}
 {% block body %}
 
+<p><a href="{{ url_for('main.trace_root') }}">Tracer Viewer</a></p>
 <p><a href="{{ url_for('main.db_root') }}">Database Browser</a></p>
 
 {% endblock %}

products/ui/llbuildui/templates/layout.html

@@ -26,6 +26,9 @@
             {% if db_path %}
             <li><a href="{{ url_for('main.db_config') }}"><i>Database:</i> {{ db_path }}</a></li>
             {% endif %}
+            {% if trace_path %}
+            <li><a href="{{ url_for('main.trace_config') }}"><i>Trace:</i> {{ trace_path }}</a></li>
+            {% endif %}
           </ul>
         </div><!--/.nav-collapse -->
       </div>

products/ui/llbuildui/templates/trace_config.html

@@ -0,0 +1,12 @@
+{% extends "layout.html" %}
+{% block title %}Configuration{% endblock %}
+{% block body %}
+
+        
+Select the trace path:
+<form action="" method="post">
+  <p><input type=text name=trace_path value="{{trace_path}}">
+  <p><input type=submit value="Set Path">
+</form>
+
+{% endblock %}

products/ui/llbuildui/templates/trace_root.html

@@ -0,0 +1,14 @@
+{% extends "layout.html" %}
+{% block title %}Build Trace{% endblock %}
+{% block body %}
+
+<p>
+  Events:<br>
+  {% for event in trace.events%}
+  {% if event.isReadiedTask %}
+  {{event.task.rule.key}}<br><br>
+  {% endif %}
+  {% endfor %}
+</p>
+
+{% endblock %}

products/ui/llbuildui/trace.py

@@ -0,0 +1,223 @@
+import json
+
+class Trace(object):
+    """
+    An llbuild build system trace
+    """
+
+    # Get a cached trace.
+    @classmethod
+    def frompath(cls, path):
+        db = cls._traces.get(path)
+        if db is None:
+            cls._traces[path] = db = Trace(path)
+        return db
+    _traces = {}
+    
+    def __init__(self, path):
+        self.events = []
+        self.tasks = {}
+        self.rules = {}
+
+        # FIXME: Move this format to just JSON for ease of loading.
+        with open(path) as f:
+            lines = list(f)
+            print((lines[0], lines[-1]))
+            assert(lines.pop(0) == '[\n')
+            assert(lines.pop(-1) == ']\n')
+            for line in lines:
+                assert(line.startswith('{ '))
+                assert(line.endswith('},\n'))
+                line = line[2:-3]
+                event_data = [eval(s) for s in line.split(', ')]
+                handler = _event_handlers.get(event_data[0])
+                if handler is None:
+                    raise NotImplementedError(
+                        "unknown event: {}".format(event_data[0]))
+                event = handler(self, event_data[1:])
+                if event:
+                    self.events.append(event)
+
+# MARK: Event Parsing
+
+class Rule(object):
+    def __init__(self, data):
+        (name, key) = data
+        self.name = name
+        self.key = key
+
+class Task(object):
+    def __init__(self, data):
+        (name,) = data
+        self.name = name
+        self.rule = None
+
+###
+
+class Event(object):
+    @property
+    def isReadiedTask(self):
+        return isinstance(self, ReadiedTask)
+
+class BuildStarted(Event):
+    def __init__(self, trace, data):
+        pass
+
+class BuildEnded(Event):
+    def __init__(self, trace, data):
+        pass
+
+class HandlingBuildInputRequest(Event):
+    def __init__(self, trace, data):
+        (rule,) = data
+        self.rule = trace.rules[rule]
+
+class CheckingRuleNeedsToRun(Event):
+    def __init__(self, trace, data):
+        (rule,) = data
+        self.rule = trace.rules[rule]
+
+class RuleNeedsToRun(Event):
+    class NeverBuilt(Event):
+        pass
+    class InvalidValue(Event):
+        pass
+    class InputRebuilt(Event):
+        def __init__(self, inputRule):
+            self.inputRule = inputRule
+    def __init__(self, trace, data):
+        self.rule = trace.rules[data[0]]
+        if data[1] == 'invalid-value':
+            (_, _) = data
+            self.reason = RuleNeedsToRun.InvalidValue()
+        elif data[1] == 'never-built':
+            (_, _) = data
+            self.reason = RuleNeedsToRun.NeverBuilt()
+        elif data[1] == 'input-rebuilt':
+            (_, _, inputRule) = data
+            self.reason = RuleNeedsToRun.InputRebuilt(
+                trace.rules[inputRule])
+        else:
+            raise NotImplementedError("unknown reason: {}".format(data))
+
+class RuleDoesNotNeedToRun(Event):
+    def __init__(self, trace, data):
+        (rule,) = data
+        self.rule = trace.rules[rule]
+
+class CreatedTaskForRule(Event):
+    def __init__(self, trace, data):
+        (task, rule) = data
+        self.task = trace.tasks[task]
+        self.rule = trace.rules[rule]
+        self.task.rule = self.rule
+
+class HandlingTaskInputRequest(Event):
+    def __init__(self, trace, data):
+        (task, rule) = data
+        self.task = trace.tasks[task]
+        self.rule = trace.rules[rule]
+
+class AddedRulePendingTask(Event):
+    def __init__(self, trace, data):
+        (rule, task) = data
+        self.rule = trace.rules[rule]
+        self.task = trace.tasks[task]
+
+class RuleScheduledForScanning(Event):
+    def __init__(self, trace, data):
+        (rule,) = data
+        self.rule = trace.rules[rule]
+
+class PausedInputRequestForRuleScan(Event):
+    def __init__(self, trace, data):
+        (rule,) = data
+        self.rule = trace.rules[rule]
+
+class ReadyingTaskInputRequest(Event):
+    def __init__(self, trace, data):
+        (task, rule) = data
+        self.task = trace.tasks[task]
+        self.rule = trace.rules[rule]
+
+class CompletedTaskInputRequest(Event):
+    def __init__(self, trace, data):
+        (task, rule) = data
+        self.task = trace.tasks[task]
+        self.rule = trace.rules[rule]
+
+class UpdatedTaskWaitCount(Event):
+    def __init__(self, trace, data):
+        (task, count) = data
+        self.task = trace.tasks[task]
+        self.count = count
+
+class RuleScanningDeferredOnInput(Event):
+    def __init__(self, trace, data):
+        (rule, inputRule) = data
+        self.rule = trace.rules[rule]
+        self.inputRule = trace.rules[inputRule]
+
+class RuleScanningDeferredOnTask(Event):
+    def __init__(self, trace, data):
+        (rule, inputTask) = data
+        self.rule = trace.rules[rule]
+        self.inputTask = trace.tasks[inputTask]
+
+class RuleScanningNextInput(Event):
+    def __init__(self, trace, data):
+        (rule, inputRule) = data
+        self.rule = trace.rules[rule]
+        self.inputRule = trace.rules[inputRule]
+
+class UnblockedTask(Event):
+    def __init__(self, trace, data):
+        (task,) = data
+        self.task = trace.tasks[task]
+
+class ReadiedTask(Event):
+    def __init__(self, trace, data):
+        (task, rule) = data
+        self.task = trace.tasks[task]
+        assert(self.task.rule is trace.rules[rule])
+
+class FinishedTask(Event):
+    def __init__(self, trace, data):
+        (task, rule, effect) = data
+        self.task = trace.tasks[task]
+        assert(self.task.rule is trace.rules[rule])
+        self.effect = effect
+
+def _create_rule(trace, data):
+    rule = Rule(data)
+    trace.rules[rule.name] = rule
+
+def _create_task(trace, data):
+    task = Task(data)
+    trace.tasks[task.name] = task
+             
+_event_handlers = {
+    "new-rule": _create_rule,
+    "new-task": _create_task,
+
+    "build-started": BuildStarted,
+    "build-ended": BuildEnded,
+    "handling-build-input-request": HandlingBuildInputRequest,
+    "checking-rule-needs-to-run": CheckingRuleNeedsToRun,
+    "rule-needs-to-run": RuleNeedsToRun,
+    "rule-does-not-need-to-run": RuleDoesNotNeedToRun,
+    "created-task-for-rule": CreatedTaskForRule,
+    "handling-task-input-request": HandlingTaskInputRequest,
+    "added-rule-pending-task": AddedRulePendingTask,
+    "rule-scheduled-for-scanning": RuleScheduledForScanning,
+    "paused-input-request-for-rule-scan": RuleScheduledForScanning,
+    "readying-task-input-request": ReadyingTaskInputRequest,
+    "completed-task-input-request": CompletedTaskInputRequest,
+    "updated-task-wait-count": UpdatedTaskWaitCount,
+    "rule-scanning-deferred-on-input": RuleScanningDeferredOnInput,
+    "rule-scanning-deferred-on-task": RuleScanningDeferredOnTask,
+    "rule-scanning-next-input": RuleScanningNextInput,
+    "unblocked-task": UnblockedTask,
+    "readied-task": ReadiedTask,
+    "finished-task": FinishedTask,
+}

products/ui/llbuildui/views.py

@@ -12,6 +12,29 @@
 def index():
     return flask.render_template("index.html")
 
+# MARK: Trace Viewer
+
+@main.route('/trace')
+def trace_root():
+    # If no database has been selected, prompt for one.
+    trace_path = session.get("trace")
+    if trace_path is None:
+        return redirect(url_for('main.trace_config'))
+    
+    return flask.render_template(
+        "trace_root.html", trace=current_app.trace,
+        trace_path=session.get("trace"))
+
+@main.route('/trace/config', methods=['GET', 'POST'])
+def trace_config():
+    if request.method == 'POST':
+        session['trace'] = request.form['trace_path']
+        return redirect(url_for('main.trace_root'))
+    return flask.render_template("trace_config.html",
+                                 trace_path=session.get("trace"))
+
+# MARK: Database Browser
+
 @main.route('/db')
 def db_root():
     # If no database has been selected, prompt for one.