| import flask |
| import sqlalchemy.sql |
| import sqlalchemy.sql.expression |
| |
| from flask import Flask, current_app, g, redirect, request, session, url_for |
| |
| import graphalgorithms |
| import model |
| |
| main = flask.Blueprint('main', __name__) |
| |
| @main.route('/') |
| 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. |
| db_path = session.get("db") |
| if db_path is None: |
| return redirect(url_for('main.db_config')) |
| |
| s = current_app.database_session |
| |
| # Compute the roots of the results. |
| # |
| # We compute this by simply looking for nodes which have no dependencies. |
| dependees = set() |
| for result in s.query(model.RuleResult): |
| for item in result.dependencies: |
| dependees.add(item) |
| roots = [result |
| for result in s.query(model.RuleResult) |
| if result.key_id not in dependees] |
| |
| return flask.render_template("db_root.html", db_path=db_path, roots=roots) |
| |
| @main.route('/db/config', methods=['GET', 'POST']) |
| def db_config(): |
| if request.method == 'POST': |
| session['db'] = request.form['db_path'] |
| return redirect(url_for('main.db_root')) |
| return flask.render_template("db_config.html", db_path=session.get("db")) |
| |
| @main.route('/db/diagnostics', methods=['GET', 'POST']) |
| def db_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) |
| 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("db_diagnostics.html", |
| db_path=session.get("db"), |
| session=s, model=model, sql=sqlalchemy.sql, |
| cycle=cycle) |
| |
| |
| # MARK: Model Object Views |
| |
| @main.route('/db/rule_result/<path:name>') |
| def db_rule_result(name): |
| # Get the result. |
| s = current_app.database_session |
| rule_result = s.query(model.RuleResult).join(model.KeyName).filter( |
| model.KeyName.name == name).one() |
| dependency_results = [ |
| s.query(model.RuleResult).filter_by( |
| key_id=dependency).one() |
| for dependency in rule_result.dependencies] |
| # FIXME: We need to get back the dependents view, it was super useful. |
| dependency_results = sorted(dependency_results, key=lambda d: d.key.name) |
| |
| return flask.render_template( |
| "db_rule_result.html", |
| db_path=session.get("db"), rule_result=rule_result, |
| dependency_results=dependency_results) |