diff --git a/clblob/console.html b/clblob/console.html
index 9afa0d5..a60eae5 100644
--- a/clblob/console.html
+++ b/clblob/console.html
@@ -154,684 +154,942 @@
 }
 
         </style>
-        <script src="_jquery.js"></script>
+        <!-- TODO: IMPORTANT For production use, mithril.js should be a local file like jQuery was -->
+        <script src="//unpkg.com/mithril/mithril.js"></script>
         <script>
-
-$(document).ready(get_config);
+/* global m, window, document, location, setTimeout */
+/* jshint sub: true */
+/* jshint -W097 */
+/* jshint asi: true */
+"use strict"
 
 function get_config() {
-    $.getJSON('/_config', update_config);
+    m.request({url: "/_config"}).then(update_config)
+}
+
+var config
+var refresh_replicas = []
+var refresh_timer
+var refresh_auto_ms = 60000
+var keypress_max_ms = 1000
+var last_keypress = 0
+var running_status = 0
+var queued_status = []
+var replica_usage = {}
+var replica_timeout = 2000
+
+var clusters = []
+var allReplicasByName = {}
+var allReplicasByIP = {}
+var summaryAvailable = false;
+
+// stateForReplica stores the last known state for a replica
+// its contents are: 
+// replica_ID: {
+//    requestResult: "success" | "error" | null, 
+//    status: Object, 
+//    hidden: boolean, 
+//    maximumWarningSeverity: "ok" | "warning" | "critical", 
+//    updating: boolean,
+//    relativeUsagePercent: number
+//}
+var stateForReplica = {}
+
+function getStateForReplica(replica) {
+    var state = stateForReplica[replica]
+    if (!state) {
+        state = {
+            requestResult: null, 
+            status: {}, 
+            hidden: true,
+            maximumWarningSeverity: "ok",
+            updating: false,
+            relativeUsagePercent: null
+        }
+        stateForReplica[replica] = state
+    }
+    return state
+}
+
+// Will only change keys supplied in newState and leave others as they were
+function updateStateForReplica(replica, newState) {
+    var state = getStateForReplica(replica)
+    for (var key in newState) {
+        state[key] = newState[key]
+    }
+}
+
+function updateStateForAllReplicas(newState) {
+    for (var replica in stateForReplica) {
+        var state = getStateForReplica(replica)
+        for (var key in newState) {
+            state[key] = newState[key]
+        }
+    }
+}
+
+function updateStateForBucketReplicas(bucket, newState) {
+    bucket.replicas.map(function (replica) {
+        var state = getStateForReplica(replica)
+        for (var key in newState) {
+            state[key] = newState[key]
+        }
+    })
+}
+
+function getStateForBucketReplicas(bucket) {
+    var result = []
+    bucket.replicas.map(function (replica) {
+        var state = getStateForReplica(replica)
+        result.push(state)
+    })
+    return result
+}
+
+function getReplicaLabelCSSClasses(replica) {
+    var state = getStateForReplica(replica)
+    var severity = "." + state.maximumWarningSeverity
+    var updating = state.updating ? ".updating" : ""
+    return severity + updating
 }
 
-var config;
-var refresh_replicas = [];
-var refresh_timer;
-var refresh_auto_ms = 60000;
-var keypress_max_ms = 1000;
-var last_keypress = 0;
-var running_status = 0;
-var queued_status = [];
-var replica_usage = {};
-var replica_timeout = 2000;
+// type is name or metric
+// Label generated may include relative usage percent if available.
+// Label will also include warning classes if needed.
+function getReplicaLabel(replica, type) {
+    var relativeUsagePercent = getStateForReplica(replica).relativeUsagePercent
+    var relativeUsagePercentText = relativeUsagePercent === null ? "" : " " + relativeUsagePercent + "%"
+    var possibleColonForRelativeUsagePercent = relativeUsagePercent === null ? "" : ":"
+    return m("." + type + ".replica_name_" + replica + getReplicaLabelCSSClasses(replica), 
+        m("b", replica, possibleColonForRelativeUsagePercent),
+        relativeUsagePercentText
+    )
+}
 
 function update_config(data) {
-    config = data;
-    var grid = '';
-    var main = '';
-    var by_ip = {};
-    var clusters = config.clblob.client.clusters;
-
-    grid += '<div class="group">';
-    for (var cluster = 0; cluster < clusters.length; cluster++) {
-        grid += '<div class="grid_cluster">' +
-            '<div class="group">' +
-            '<div class="name"><b>cluster ' + cluster + '</b></div>' +
-            '</div>' +
-            '<div class="group">';
-
-        main += '<div id="cluster_' + cluster + '" class="cluster">' +
-            '<div class="group">' +
-            '<div class="name"><b>cluster ' + cluster + '</b></div>' +
-            '</div>';
-
-        var buckets = clusters[cluster];
-        for (var bucket = 0; bucket < buckets.length; bucket++) {
-            grid += '<div class="grid_bucket">' +
-                '<div class="grid_bucket_number">' + bucket + '</div>';
-
-            main += '<div id="bucket_' + cluster + '_' + bucket +
-                '" class="bucket">' +
-                '<div class="group clickable" onclick="' +
-                '$(this).siblings(\'div.replica\').toggleClass(\'hide\');">' +
-                '<div class="name"><b>bucket ' + bucket + '</b></div>' +
-                metric('write weight', buckets[bucket].write_weight, 0, 0,
-                    null, 0);
-
-            var replicas = buckets[bucket].replicas;
-            var replica_main = '';
-            for (var replica = 0; replica < replicas.length; replica++) {
-                grid += hover_help(
-                    '<a href="#bucket_' + cluster + '_' + bucket + '" ' +
-                    'onclick="$(\'#replica_' + replicas[replica] + '\')' +
-                    '.parent().children(\'div.replica\')' +
-                    '.removeClass(\'hide\');">' +
-                    '<div id="grid_replica_' + replicas[replica] +
-                    '" class="grid_replica"></div></a>',
-                    replicas[replica]);
-
-                main += '<div class="metric replica_name_' + replicas[replica] +
-                    '"><b>' + replicas[replica] + '</b></div>';
-
-                replica_main += '<div id="replica_' + replicas[replica] +
-                    '" class="replica">' +
-                    '<div class="group">' +
-                    '<div class="name replica_name_' + replicas[replica] +
-                    '"><b>' + replicas[replica] + '</b></div>' +
-                    '</div></div>';
-
-                var ip = config.clblob.client.replicas[replicas[replica]].ip;
-                var port = config.clblob.client.replicas[replicas[replica]].port;
-                if (!by_ip[ip])
-                    by_ip[ip] = {};
-                by_ip[ip][port] = replicas[replica];
-
-                refresh_replicas.push(replicas[replica]);
+    config = data
+    clusters = config.clblob.client.clusters
+    allReplicasByName = config.clblob.client.replicas
+    
+    for (var clusterIndex = 0; clusterIndex < clusters.length; clusterIndex++) {
+        var buckets = clusters[clusterIndex]
+        for (var bucketIndex = 0; bucketIndex < buckets.length; bucketIndex++) {
+            var replicasInBucket = buckets[bucketIndex].replicas
+            for (var replicaIndex = 0; replicaIndex < replicasInBucket.length; replicaIndex++) {
+                var replica = replicasInBucket[replicaIndex]
+                var ip = allReplicasByName[replica].ip
+                var port = allReplicasByName[replica].port
+                if (!allReplicasByIP[ip]) allReplicasByIP[ip] = {}
+                allReplicasByIP[ip][port] = replica
+                refresh_replicas.push(replica)
             }
-            grid += '</div>';
-            main += '</div>' + replica_main + '</div>';
         }
-        grid += '</div></div>';
-        main += '</div>';
     }
-    grid += '</div>';
 
-    $('#grid').html(grid);
-    $('#by_ip').html(iterate_sorted_object(by_ip, combine_ips));
-    $('#main').html(main);
-    $('div.replica').addClass('hide');
-    $(document).keypress(handle_keypress);
-    refresh();
+    refresh()
+}
+
+function grid() {
+    return m(".group",
+        clusters.map(function (cluster, clusterIndex) {
+            return m(".grid_cluster", 
+                m(".group", 
+                    m(".name", m("b", "cluster ", clusterIndex))
+                ),
+                m(".group", 
+                    cluster.map(function (bucket, bucketIndex) {
+                        return m(".grid_bucket", 
+                            m(".grid_bucket_number", bucketIndex),
+                            bucket.replicas.map(function (replica, replicaIndex) {
+                                return hover_help(
+                                    m("a", 
+                                        {
+                                            href: "#bucket_" + clusterIndex + "_" + bucketIndex,
+                                            onclick: function() {
+                                                updateStateForBucketReplicas(bucket, {hidden: false})
+                                            }
+                                        }, 
+                                        m(".grid_replica#grid_replica_" + replica + getReplicaLabelCSSClasses(replica))
+                                    ),
+                                    replica
+                                )
+                        }))
+                    })
+                )
+            )
+        })
+    )
+}
+
+function main() {
+    return clusters.map(function (cluster, clusterIndex) {
+        return m(".cluster#cluster_" + clusterIndex,
+            m(".group",
+                m(".name",
+                    m("b", "cluster " + clusterIndex)
+                )
+            ),
+            cluster.map(function (bucket, bucketIndex) {
+                return m(".bucket#bucket_" + clusterIndex + "_" + bucketIndex,
+                    m(".group.clickable", 
+                        {
+                            onclick: function(event) {
+                                updateStateForBucketReplicas(bucket, {hidden: !getStateForBucketReplicas(bucket)[0].hidden})
+                            }
+                        }, 
+                        m(".name",
+                            m("b", "bucket " + bucketIndex)
+                        ),
+                        metric("write weight", bucket.write_weight, 0, 0, null, 0),
+                        bucket.replicas.map(function (replica, replicaIndex) {
+                            return getReplicaLabel(replica, "metric")
+                        })
+                    ),
+                    replica_main(bucket.replicas)
+                )
+            })
+        )
+    })
+}
+
+function replica_main(replicas) {
+    return replicas.map(function (replica, replicaIndex) {
+        var requestResult = getStateForReplica(replica).requestResult
+        var innerDiv
+        if (requestResult === "success") {
+            innerDiv = generate_replica_status_success_div(replica)
+        } else if (requestResult === "error") {
+            innerDiv = generate_replica_status_fail_div(replica)
+        } else {
+            innerDiv = m(".group", 
+                getReplicaLabel(replica, "name")
+            )
+        }
+
+        var state = getStateForReplica(replica)
+        var hideClass = state.hidden ? ".hide" : ""
+        var warningClass = state.requestResult === "error" ? ".warning" : ""
+        return m(".replica#replica_" + replica + hideClass + warningClass,
+            innerDiv
+        )
+    })
 }
 
 function combine_ips(ip, ports) {
-    return '<div class="ip"><div class="group">' + '<div class="name"><b>ip ' +
-        ip + '</b></div>' + iterate_sorted_object(ports, combine_ports) +
-        '</div></div>';
+    return m(".ip",
+        m(".group",
+            m(".name", m("b", "ip " + ip)),
+            iterate_sorted_object(ports, combine_ports)
+        )
+    )
 }
 
 function combine_ports(port, replica) {
-    return '<div class="metric replica_name_' + replica + '"><b>' + replica +
-        '</b></div>';
+    return getReplicaLabel(replica, "metric")
 }
 
 function foreach_replica(callback, filter) {
     for (var index = 0; index < refresh_replicas.length; index++) {
-        replica = refresh_replicas[index];
+        var replica = refresh_replicas[index]
         if (filter === true) {
-            if ($('#replica_' + replica).hasClass('hide'))
-                continue;
+            if (getStateForReplica(replica).hidden)
+                continue
         }
-        else if (filter && filter != replica)
-            continue;
-        callback(replica);
+        else if (filter && filter !== replica)
+            continue
+        callback(replica)
     }
 }
 
 function handle_keypress(event) {
+
+    // This redraw is needed because this event handler is setup outside of Mithril
+    // There are a some key presses that don"t require an redraw, 
+    // but it is clearer to just always do a redraw for now unless there is a performance issue
+    setTimeout(m.redraw, 0)
+
     if (event.ctrlKey)
-        return;
-    if (event.which == 104) {
-        $('div.replica').addClass('hide');
-        return;
+        return
+    if (event.which === 104) {
+        updateStateForAllReplicas({hidden: true})
+        return
     }
-    if (event.which == 72) {
-        $('div.replica').removeClass('hide');
-        return;
+    if (event.which === 72) {
+        updateStateForAllReplicas({hidden: false})
+        return
     }
-    if (event.which == 73 || event.which == 105) {
-        $('#by_ip').toggleClass('hide');
-        return;
+    if (event.which === 73 || event.which === 105) {
+        isByIPHidden = !isByIPHidden
+        return
     }
-    var url;
-    var upper_key = event.which & 95;
-    var filter = event.which == 32 || event.which >= 97;
-    if (upper_key == 82 || event.which == 32)
-        url = null;
-    if (upper_key == 66)
-        url = '/_buffer/';
-    if (upper_key == 80)
-        url = '/_purge/';
-    if (upper_key == 83)
-        url = '/_sync/';
+    var url
+    var upper_key = event.which & 95
+    var filter = event.which === 32 || event.which >= 97
+    if (upper_key === 82 || event.which === 32)
+        url = null
+    if (upper_key === 66)
+        url = "/_buffer/"
+    if (upper_key === 80)
+        url = "/_purge/"
+    if (upper_key === 83)
+        url = "/_sync/"
     if (url === undefined)
-        return;
+        return
 
-    event.preventDefault();
+    event.preventDefault()
 
-    var current = Math.round(new Date().getTime() / keypress_max_ms);
-    if (current == last_keypress)
-        return;
-    last_keypress = current;
+    var current = Math.round(new Date().getTime() / keypress_max_ms)
+    if (current === last_keypress)
+        return
+    last_keypress = current
 
-    if (url != null) {
+    if (url !== null) {
         foreach_replica(function (replica) {
-            $.ajax({url: url + replica, type: "GET", timeout: replica_timeout});
-        }, filter);
+            m.request({
+                url: url + replica, 
+                method: "GET",
+                config: configXHRTimeout,
+                // Don't try to convert the result to JSON
+                deserialize: function(value) { return value }
+            })
+        }, filter)
     }
     else
-        refresh(filter);
+        refresh(filter)
+}
+
+function configXHRTimeout(xhr) {
+    xhr.timeout = replica_timeout
 }
 
 function flush_status() {
     while (running_status < 8) {
-        replica = queued_status.shift();
+        var replica = queued_status.shift()
         if (!replica)
-            break;
-        running_status++;
-        $('#grid_replica_' + replica).addClass('updating');
-        $('div.replica_name_' + replica).addClass('updating');
-        $.ajax({
-            url: '/_status/' + replica,
-            type: "GET",
-            dataType: "json",
-            timeout: replica_timeout,
-            success: update_status(replica),
-            error: update_status_fail(replica)});
+            break
+        running_status++
+        updateStateForReplica(replica, {updating: true})
+        m.request({
+            url: "/_status/" + replica,
+            method: "GET",
+            config: configXHRTimeout,
+            extract: function(xhr) {
+                // If there is an error, return xhr with its statusText instead of the parsed JSON result
+                if ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304) {
+                    return JSON.parse(xhr.responseText);
+                }
+                return xhr;
+            }
+        })
+        .then(update_status(replica))
+        .catch(update_status_fail(replica))
     }
 }
 
 function refresh(filter) {
     if (!filter && refresh_timer)
-        window.clearTimeout(refresh_timer);
+        window.clearTimeout(refresh_timer)
     foreach_replica(function (replica) {
         if (filter)
-            queued_status.unshift(replica);
+            queued_status.unshift(replica)
         else
-            queued_status.push(replica);
+            queued_status.push(replica)
         },
-        filter);
-    flush_status();
+        filter)
+    flush_status()
     if (!filter) {
-        refresh_timer = window.setTimeout(function () { refresh(); },
-            refresh_auto_ms);
+        refresh_timer = window.setTimeout(
+            function () {
+                refresh()
+                // timeouts need to call m.redraw if they could affect drawable state
+                m.redraw()
+            },
+            refresh_auto_ms
+        )
     }
 }
 
 var summary = {
-    'cluster events': {
-        'critical': 10000,
-        'factor': 1000,
-        'type': 'metric',
-        'values': {},
-        'warning': 1000,
-        'help_text': 'The total number of events queued to a cluster across ' +
-            'all replicas.'},
-    'disk inodes': {
-        'factor': 1000,
-        'type': 'usage',
-        'values': {},
-        'help_text': 'The &lt;used&gt;/&lt;total&gt; number of disk inodes ' +
-            'across all replicas.'},
-    'disk space': {
-        'factor': 1024,
-        'type': 'usage',
-        'values': {},
-        'help_text': 'The &lt;used&gt;/&lt;total&gt; amount of disk space ' +
-            'across all replicas.'},
-    'replica events': {
-        'critical': 10000,
-        'factor': 1000,
-        'type': 'metric',
-        'values': {},
-        'warning': 1000,
-        'help_text': 'The total number of events queued to a replica across ' +
-            'all replicas.'}};
+    "cluster events": {
+        critical: 10000,
+        factor: 1000,
+        type: "metric",
+        values: {},
+        warning: 1000,
+        help_text: "The total number of events queued to a cluster across all replicas."
+    },
+    "disk inodes": {
+        factor: 1000,
+        type: "usage",
+        values: {},
+        help_text: "The &lt;used&gt;/&lt;total&gt; number of disk inodes across all replicas."
+    },
+    "disk space": {
+        factor: 1024,
+        type: "usage",
+        values: {},
+        help_text: "The &lt;used&gt;/&lt;total&gt; amount of disk space across all replicas."
+    },
+    "replica events": {
+        critical: 10000,
+        factor: 1000,
+        type: "metric",
+        values: {},
+        warning: 1000,
+        help_text: "The total number of events queued to a replica across all replicas."
+    }
+}
 
 function update_summary() {
-    var html = '';
-    html += '<div class="group">';
-    html += '<div class="name"><b>summary</b></div>';
-    html += iterate_sorted_object(summary, summary_metrics);
-    html += '</div>';
-    $('#summary').html(html);
+    summaryAvailable = true;
+    iterate_sorted_object(summary, update_summary_metrics)
 }
 
-function summary_metrics(name, details) {
-    var usage = 0;
-    var total = 0;
-    var count = 0;
-    for (replica in details['values']) {
-        count++;
-        if (details['type'] == 'usage') {
-            usage += details['values'][replica][0];
-            total += details['values'][replica][1];
+function generate_summary_div() {
+    if (!summaryAvailable) return [];
+    return m(".group",
+        m(".name", m("b", "summary")),
+        iterate_sorted_object(summary, summary_metrics)
+    )
+}
+
+function update_summary_metrics(name, details) {
+    var usage = 0
+    var total = 0
+    var count = 0
+    for (var replica in details["values"]) {
+        count++
+        if (details["type"] === "usage") {
+            usage += details["values"][replica][0]
+            total += details["values"][replica][1]
         }
         else
-            total += details['values'][replica];
+            total += details["values"][replica]
     }
-    if (count == 0)
-        return '';
-    if (details['type'] == 'usage')
+    // Add storage object into summary data structure for later use when generating summary metrics divs
+    details._replicaStats = {
+        usage: usage,
+        total: total,
+        count: count
+    }
+}
+
+function summary_metrics(name, details) {
+    if (!details._replicaStats || details._replicaStats.count === 0)
+        return ""
+    if (details["type"] === "usage")
         return hover_help(
-            usage_metric(name, total, usage, 60, 80, details['factor']),
-            details['help_text']);
+            usage_metric(name, details._replicaStats.total, details._replicaStats.usage, 60, 80, details["factor"]),
+            details["help_text"]
+        )
     return hover_help(
-        metric(name, total, details['warning'], details['critical'],
-            details['factor']),
-        details['help_text']);
+        metric(name, details._replicaStats.total, details["warning"], details["critical"], details["factor"]),
+        details["help_text"]
+    )
 }
 
 function update_replica_usage(cluster, bucket) {
-    var replicas = config.clblob.client.clusters[cluster][bucket].replicas;
-    var max_usage = 0;
-    for (var replica = 0; replica < replicas.length; replica++) {
-        if (max_usage < replica_usage[replicas[replica]])
-            max_usage = replica_usage[replicas[replica]];
+    var replicaIndex
+    var replicas = clusters[cluster][bucket].replicas
+    var max_usage = 0
+    for (replicaIndex = 0; replicaIndex < replicas.length; replicaIndex++) {
+        if (max_usage < replica_usage[replicas[replicaIndex]])
+            max_usage = replica_usage[replicas[replicaIndex]]
     }
-    if (max_usage == 0)
-        return;
-    for (var replica = 0; replica < replicas.length; replica++) {
-        var replica_name = replicas[replica];
-        if (replica_usage[replica_name] == undefined)
-            continue;
-        var relative = (replica_usage[replica_name] / max_usage) * 100;
-        var replica_object = $('.replica_name_' + replica_name);
-        replica_object.html('<b>' + replica_name +
-            ':</b> ' + Math.round(relative) + '%');
-        if (relative < 98 && !replica_object.hasClass('critical')) {
-            $('#grid_replica_' + replica_name).addClass('warning');
-            replica_object.addClass('warning');
+    if (max_usage === 0)
+        return
+    for (replicaIndex = 0; replicaIndex < replicas.length; replicaIndex++) {
+        var replica = replicas[replicaIndex]
+        if (replica_usage[replica] === undefined)
+            continue
+        var relative = (replica_usage[replica] / max_usage) * 100
+
+        var relativeUsagePercent = Math.round(relative)
+        updateStateForReplica(replica, {relativeUsagePercent: relativeUsagePercent})
+
+        var severity = getStateForReplica(replica).maximumWarningSeverity
+
+        // If a replica's relativeUsagePercent is lagging behind the other replicas, it may be experiencing issues, so warn
+        if (relative < 98 && severity !== "critical") {
+            updateStateForReplica(replica, {maximumWarningSeverity: "warning"})
         }
     }
 }
 
-var replica_status;
+// TODO: Remove replica_status global
+// This global is updated through the process of generating the status display.
+// It is the maximum severity of all the status warnings for a replica.
+var replica_status
 
 function update_status(replica) {
     return function (status) {
-        flush_status();
-        running_status--;
-        replica_status = 'ok';
-        var html = '';
-        var address = config.clblob.client.replicas[replica].ip + ':' +
-            config.clblob.client.replicas[replica].port;
-        html += '<div class="group">';
-        html += '<div class="name replica_name_' + replica + '"><b>' +
-            replica + '</b></div>';
-        html += button(address, 'http://' + address + '/_console');
-        html += '<div class="button" onclick="refresh(\'' + replica +
-            '\');"><b>refresh</b></div>';
-        html += '</div>';
-        html += '<div class="group">';
-
-        html += button('sync', '/_sync/' + replica, true);
-        html += hover_help(
-            metric('sync status', status.sync_status, 0, 0, null,
-                status.sync_status.indexOf('failed') == 0 ? 1 : 0),
-            sync_status_help(status.sync_status));
-
-        html += button('purge', '/_purge/' + replica, true);
-        html += hover_help(
-            metric('purge status', status.purge_status, 0, 0, null,
-                status.purge_status.indexOf('failed') == 0 ? 1 : 0),
-            purge_status_help(status.purge_status));
-
-        html += button('buffer', '/_buffer/' + replica, true);
-        html += hover_help(
-            metric('buffer status', status.buffer_status, 0, 0, null,
-                status.buffer_status.indexOf('failed') == 0 ? 1 : 0),
-            buffer_status_help(status.buffer_status));
-
-        html += '</div>';
-        html += '<div class="group">';
-        summary['replica events']['values'][replica] = 0;
-        html += iterate_sorted_object(status.replicas,
-            replica_metrics(replica));
-        summary['cluster events']['values'][replica] = 0;
-        html += iterate_sorted_object(status.clusters,
-            cluster_metrics(replica));
-        html += '</div>';
-
-        html += '<div class="group">';
-        html += hover_help(iterate_sorted_object(status.events, event_metrics),
-            'The &lt;current&gt;/&lt;max&gt;/&lt;total&gt; number of events ' +
-            'this replica has created.');
-        html += '</div>';
-
-        if ('index_sqlite' in status) {
-            html += '<div class="group">';
-            html += index_sqlite_metrics(replica, status.index_sqlite);
-            html += '</div>';
-        }
-
-        if ('store_disk' in status) {
-            html += '<div class="group">';
-            html += store_disk_metrics(replica, status.store_disk);
-            html += '</div>';
-        }
-
-        $('#replica_' + replica).html(html);
-        $('#replica_' + replica).removeClass('warning');
-        update_replica_status(replica, replica_status);
-        update_summary();
-        update_replica_usage(status.cluster, status.bucket);
+        flush_status()
+        running_status--
+        
+        updateStateForReplica(replica, {
+            requestResult: "success", 
+            status: status, 
+            maximumWarningSeverity: "ok", 
+            updating: false
+        })
+
+        summary["replica events"]["values"][replica] = 0
+        iterate_sorted_object(status.replicas, update_replica_metrics(replica))
+
+        summary["cluster events"]["values"][replica] = 0
+        iterate_sorted_object(status.clusters, update_cluster_metrics(replica))
+        
+        if ("store_disk" in status) update_store_disk_metrics(replica, status.store_disk)
+
+        update_summary()
+
+        update_replica_usage(status.cluster, status.bucket)
+
+        // TODO: Remove wastefully throwing away a generated div to ensure maximumWarningSeverity is correct
+        // Otherwise, some labels may have incorrect CSS status because they depend
+        // on maximum warning severity calculations in metric function
+        generate_replica_status_success_div(replica)
     }
 }
 
+function generate_replica_status_success_div(replica) {
+    // TODO: This replica_status global is updated as a side effect of generating displays for metrics
+    replica_status = "ok"
+    var address = allReplicasByName[replica].ip + ":" + allReplicasByName[replica].port
+    var status = getStateForReplica(replica).status
+    var sync_status_severity = (status.sync_status || "").indexOf("failed") === 0 ? 1 : 0
+    var purge_status_severity = (status.purge_status || "").indexOf("failed") === 0 ? 1 : 0
+    var buffer_status_severity = (status.buffer_status || "").indexOf("failed") === 0 ? 1 : 0
+    var result = [
+        m(".group",
+            getReplicaLabel(replica, "name"),
+            button(address, "http://" + address + "/_console"),
+            m(".button", {
+                onclick: refresh.bind(null, replica)
+            }, m("b", "refresh"))
+        ),
+        m(".group",
+            button("sync", "/_sync/" + replica, true),
+            hover_help(
+                metric("sync status", status.sync_status, 0, 0, null, sync_status_severity),
+                sync_status_help(status.sync_status)
+            ),
+
+            button("purge", "/_purge/" + replica, true),
+            hover_help(
+                metric("purge status", status.purge_status, 0, 0, null, purge_status_severity),
+                purge_status_help(status.purge_status)
+            ),
+
+            button("buffer", "/_buffer/" + replica, true),
+            hover_help(
+                metric("buffer status", status.buffer_status, 0, 0, null, buffer_status_severity),
+                buffer_status_help(status.buffer_status)
+            )
+        ),
+
+        m(".group",
+            iterate_sorted_object(status.replicas, replica_metrics(replica)),
+            iterate_sorted_object(status.clusters, cluster_metrics(replica))
+        ),
+
+        m(".group",
+            hover_help(
+                iterate_sorted_object(status.events, event_metrics),
+                "The &lt;current&gt;/&lt;max&gt;/&lt;total&gt; number of events this replica has created."
+            )
+        ),
+
+        ("index_sqlite" in status) ? m(".group", index_sqlite_metrics(replica, status.index_sqlite)) : [],
+        ("store_disk" in status) ? m(".group", store_disk_metrics(replica, status.store_disk)) : []
+    ]
+
+    // TODO: Improve so do not have to store value of global replica_status which may have changed
+    updateStateForReplica(replica, {maximumWarningSeverity: replica_status})
+    return result
+}
+
 function sync_status_help(status) {
-    if (status.indexOf('start delay') == 0)
-        return 'Sync has not been run since server start.';
-    if (status.indexOf('failed') == 0)
-        return 'Sync failed to complete.';
-    if (status.indexOf('local checksums') == 0)
-        help = 'Sync is running and is currently computing a list of ' +
-            'checksums for this replica.';
-    else if (status.indexOf('source checksums') == 0)
-        help = 'Sync is running and is currently computing a list of ' +
-            'checksums for a peer replica.';
-    else if (status.indexOf('diff checksums') == 0)
-        help = 'Sync is running and is currently comparing a list of ' +
-            'checksums between this replica and a peer replica.';
-    else if (status.indexOf('local blobs') == 0)
-        help = 'Sync is running and is currently getting a list of blobs ' +
-            'for this replica.';
-    else if (status.indexOf('source blobs') == 0)
-        help = 'Sync is running and is currently getting a list of blobs ' +
-            'for a peer replica.';
-    else if (status.indexOf('diff blobs') == 0)
-        help = 'Sync is running and is currently comparing a list of blobs ' +
-            'between this replica and a peer replica.';
-    else if (status.indexOf('put') == 0)
-        help = 'Sync is running and is currently grabbing a blob from a ' +
-            'peer to put into this replica.';
-    else if (status.indexOf('delete') == 0)
-        help = 'Sync is running and is currently updating the delete time ' +
-            'for a blob in this replica.';
-    else if (status.indexOf('synced') == 0)
-        help = 'Sync is done running.';
+    var help
+    if (status.indexOf("start delay") === 0)
+        return "Sync has not been run since server start."
+    if (status.indexOf("failed") === 0)
+        return "Sync failed to complete."
+    if (status.indexOf("local checksums") === 0)
+        help = "Sync is running and is currently computing a list of " +
+            "checksums for this replica."
+    else if (status.indexOf("source checksums") === 0)
+        help = "Sync is running and is currently computing a list of " +
+            "checksums for a peer replica."
+    else if (status.indexOf("diff checksums") === 0)
+        help = "Sync is running and is currently comparing a list of " +
+            "checksums between this replica and a peer replica."
+    else if (status.indexOf("local blobs") === 0)
+        help = "Sync is running and is currently getting a list of blobs " +
+            "for this replica."
+    else if (status.indexOf("source blobs") === 0)
+        help = "Sync is running and is currently getting a list of blobs " +
+            "for a peer replica."
+    else if (status.indexOf("diff blobs") === 0)
+        help = "Sync is running and is currently comparing a list of blobs " +
+            "between this replica and a peer replica."
+    else if (status.indexOf("put") === 0)
+        help = "Sync is running and is currently grabbing a blob from a " +
+            "peer to put into this replica."
+    else if (status.indexOf("delete") === 0)
+        help = "Sync is running and is currently updating the delete time " +
+            "for a blob in this replica."
+    else if (status.indexOf("synced") === 0)
+        help = "Sync is done running."
     else
-        help = 'Status of current/last sync operation.';
-    return help + ' The counts are the number of blobs skipped, put, ' +
-        'deleted, or failed for each peer.';
+        help = "Status of current/last sync operation."
+    return help + " The counts are the number of blobs skipped, put, " +
+        "deleted, or failed for each peer."
 }
 
 function purge_status_help(status) {
-    if (status.indexOf('start delay') == 0)
-        return 'Purge has not been run since server start.';
-    if (status.indexOf('failed') == 0)
-        return 'Purge failed to complete.';
-    if (status.indexOf('get_expired') == 0)
-        help = 'Purge is running and is currently getting a list of expired ' +
-            'blobs from the index.';
-    else if (status.indexOf('delete') == 0)
-        help = 'Purge is running and is currently deleting an expired blob ' +
-            'from disk.';
-    else if (status.indexOf('delete_expired') == 0)
-        help = 'Purge is running and is currently deleting expired blobs ' +
-            'from the index.';
-    else if (status.indexOf('purged') == 0)
-        help = 'Purge is done running.';
+    var help
+    if (status.indexOf("start delay") === 0)
+        return "Purge has not been run since server start."
+    if (status.indexOf("failed") === 0)
+        return "Purge failed to complete."
+    if (status.indexOf("get_expired") === 0)
+        help = "Purge is running and is currently getting a list of expired " +
+            "blobs from the index."
+    else if (status.indexOf("delete") === 0)
+        help = "Purge is running and is currently deleting an expired blob " +
+            "from disk."
+    else if (status.indexOf("delete_expired") === 0)
+        help = "Purge is running and is currently deleting expired blobs " +
+            "from the index."
+    else if (status.indexOf("purged") === 0)
+        help = "Purge is done running."
     else
-        help = 'Status of current/last purge operation.';
-    return help + ' The count is the number of blobs that were purged ' +
-            'during this run.';
+        help = "Status of current/last purge operation."
+    return help + " The count is the number of blobs that were purged " +
+            "during this run."
 }
 
 function buffer_status_help(status) {
-    if (status.indexOf('start delay') == 0)
-        return 'Buffer has not been run since server start.';
-    if (status.indexOf('failed') == 0)
-        help = 'Buffer failed to complete.';
-    if (status.indexOf('get_replica_events') == 0)
-        help = 'Buffer is running and is currently getting a list of ' +
-            'replica events from the index to buffer into memory.';
-    else if (status.indexOf('get_cluster_events') == 0)
-        help = 'Buffer is running and is currently getting a list of ' +
-            'cluster events from the index to buffer into memory.';
-    else if (status.indexOf('buffered') == 0)
-        help = 'Buffer is done running.';
+    var help
+    if (status.indexOf("start delay") === 0)
+        return "Buffer has not been run since server start."
+    if (status.indexOf("failed") === 0)
+        help = "Buffer failed to complete."
+    if (status.indexOf("get_replica_events") === 0)
+        help = "Buffer is running and is currently getting a list of " +
+            "replica events from the index to buffer into memory."
+    else if (status.indexOf("get_cluster_events") === 0)
+        help = "Buffer is running and is currently getting a list of " +
+            "cluster events from the index to buffer into memory."
+    else if (status.indexOf("buffered") === 0)
+        help = "Buffer is done running."
     else
-        help = 'Status of current/last buffer operation.';
-    return help + ' The counts are the number of replica/cluster events ' +
-            'that could be buffered during this run.';
+        help = "Status of current/last buffer operation."
+    return help + " The counts are the number of replica/cluster events " +
+            "that could be buffered during this run."
 }
 
-function update_replica_status(replica, replica_status) {
-    $('#grid_replica_' + replica).removeClass().addClass(
-        'grid_replica ' + replica_status);
-    $('div.replica_name_' + replica).removeClass().addClass(
-        'name replica_name_' + replica + ' ' + replica_status);
+function index_sqlite_metrics(replica, status) {
+    return [
+        metric("sqlite database", status.database),
+        hover_help(
+            usage_metric("sqlite size", status.max_size, status.size, 60, 80, 1024),
+            "The &lt;used&gt;/&lt;total&gt; amount of disk space for the index."
+        ),
+        hover_help(
+            metric("sqlite queue size", status.queue_size, 10, 20),
+            "The number of events in the index thread queue."
+        )
+    ]
 }
 
-function index_sqlite_metrics(replica, status) {
-    var html = '';
-    html += metric('sqlite database', status.database);
-    html += hover_help(
-        usage_metric('sqlite size', status.max_size, status.size, 60, 80, 1024),
-        'The &lt;used&gt;/&lt;total&gt; amount of disk space for the index.');
-    html += hover_help(
-        metric('sqlite queue size', status.queue_size, 10, 20),
-        'The number of events in the index thread queue.');
-    return html;
+function update_store_disk_metrics(replica, status) {
+    summary["disk space"]["values"][status.device_id] = 
+        [status.total_space - status.free_space, status.total_space]
+    summary["disk inodes"]["values"][status.device_id] = 
+        [status.total_inodes - status.free_inodes, status.total_inodes]
+    replica_usage[replica] = status.total_inodes - status.free_inodes
 }
 
 function store_disk_metrics(replica, status) {
-    var html = '';
-    html += metric('disk path', status.path);
-    html += hover_help(
-        usage_metric('disk space', status.total_space,
-            status.total_space - status.free_space, 60, 80, 1024),
-        'The &lt;used&gt;/&lt;total&gt; amount of disk space.');
-    summary['disk space']['values'][status.device_id] = 
-        [status.total_space - status.free_space, status.total_space];
-    html += hover_help(
-        usage_metric('disk inodes', status.total_inodes,
-            status.total_inodes - status.free_inodes, 60, 80, 1000),
-        'The &lt;used&gt;/&lt;total&gt; number of disk inodes.');
-    summary['disk inodes']['values'][status.device_id] = 
-        [status.total_inodes - status.free_inodes, status.total_inodes];
-    replica_usage[replica] = status.total_inodes - status.free_inodes
-    html += hover_help(
-        metric('disk queue size', status.queue_size, 10, 20),
-        'The number of events in the disk thread queue.');
-    return html;
+    return [
+        metric("disk path", status.path),
+        hover_help(
+            usage_metric("disk space", status.total_space,
+                status.total_space - status.free_space, 60, 80, 1024),
+            "The &lt;used&gt;/&lt;total&gt; amount of disk space."
+        ),
+        hover_help(
+            usage_metric("disk inodes", status.total_inodes,
+                status.total_inodes - status.free_inodes, 60, 80, 1000),
+            "The &lt;used&gt;/&lt;total&gt; number of disk inodes."
+        ),
+        hover_help(
+            metric("disk queue size", status.queue_size, 10, 20),
+            "The number of events in the disk thread queue."
+        )
+    ]
 }
 
-function replica_metrics(summary_replica) {
+function update_replica_metrics(summary_replica) {
     return function (replica, status) {
-        var html = '';
-        if ('events' in status) {
-            html += hover_help(
-                metric(replica + ' events',
-                    status.buffer_events + '/' + status.events,
-                    config.clblob.client.replica_event_buffer_size,
-                    config.clblob.client.replica_event_buffer_size * 10,
-                    1000, status.events),
-                'The number of &lt;buffered&gt;/&lt;total&gt; events queued ' +
-                    'up to go to replica ' + replica + '.');
-            summary['replica events']['values'][summary_replica] += status.events;
+        if ("events" in status) {
+            summary["replica events"]["values"][summary_replica] += status.events
         }
-        var replica_retry = config.clblob.client.replica_retry;
-        if ('last_failed' in status && status.last_failed < replica_retry) {
-            html += metric(replica + ' failed', status.last_failed,
-                replica_retry, 0, null);
+    }
+}
+
+function replica_metrics(summary_replica) {
+    return function (replica, status) {
+        var replica_retry = config.clblob.client.replica_retry
+        return [
+            ("events" in status) ?
+                hover_help(
+                    metric(replica + " events",
+                        status.buffer_events + "/" + status.events,
+                        config.clblob.client.replica_event_buffer_size,
+                        config.clblob.client.replica_event_buffer_size * 10,
+                        1000, status.events),
+                    "The number of &lt;buffered&gt;/&lt;total&gt; events queued " +
+                        "up to go to replica " + replica + "."
+                    ) :
+                [],
+            ("last_failed" in status && status.last_failed < replica_retry) ?
+                metric(replica + " failed", status.last_failed, replica_retry, 0, null) :
+                []
+        ]
+    }
+}
+
+function update_cluster_metrics(replica) {
+    return function (cluster, status) {
+        if ("events" in status) {
+            summary["cluster events"]["values"][replica] += status.events
         }
-        return html;
     }
 }
 
 function cluster_metrics(replica) {
     return function (cluster, status) {
-        var html = '';
-        if ('events' in status) {
-            html += hover_help(
-                metric('cluster ' + cluster + ' events',
-                    status.buffer_events + '/' + status.events,
+        if ("events" in status) {
+            return hover_help(
+                metric("cluster " + cluster + " events",
+                    status.buffer_events + "/" + status.events,
                     config.clblob.client.cluster_event_buffer_size,
                     config.clblob.client.cluster_event_buffer_size * 10,
                     1000, status.events),
-                'The number of &lt;buffered&gt;/&lt;total&gt; events queued ' +
-                    'up to go to cluster ' + cluster + '.');
-            summary['cluster events']['values'][replica] += status.events;
+                "The number of &lt;buffered&gt;/&lt;total&gt; events queued " +
+                    "up to go to cluster " + cluster + ".")
         }
-        return html;
+        return []
     }
 }
 
 function event_metrics(event, status) {
-    return metric(event + ' events',
-        status.current + '/' + status.max + '/' + si_prefix(status.total), 250,
-        500, 1000, status.current);
+    return metric(event + " events",
+        status.current + "/" + status.max + "/" + si_prefix(status.total), 250,
+        500, 1000, status.current)
 }
 
 function update_status_fail(replica) {
-    return function (data) {
-        flush_status();
-        running_status--;
-        var html = '';
-        var address = config.clblob.client.replicas[replica].ip + ':' +
-            config.clblob.client.replicas[replica].port;
-        html += '<div class="group">' +
-            '<div class="name replica_name_' + replica + '"><b>' + replica +
-            '</b></div>' +
-            button(address, 'http://' + address + '/_console') +
-            metric('failed', data.statusText, 0, 0, null, 1) +
-            '</div>';
-
-        $('#replica_' + replica).html(html);
-        $('#replica_' + replica).addClass('warning');
-        update_replica_status(replica, 'critical');
+    return function (status) {
+        flush_status()
+        running_status--
+        updateStateForReplica(replica, {
+            requestResult: "error", 
+            status: status, 
+            maximumWarningSeverity: "critical", 
+            updating: false
+        })
     }
 }
 
+function generate_replica_status_fail_div(replica) {
+    var address = allReplicasByName[replica].ip + ":" + allReplicasByName[replica].port
+    var status = getStateForReplica(replica).status
+
+    return m(".group",
+        getReplicaLabel(replica, "name"),
+        button(address, "http://" + address + "/_console"),
+        metric("failed", status.statusText, 0, 0, null, 1)
+    )
+}
+
 function button(name, url, background) {
+    // This could be simplified to return one vdom node with an if statement to choose function action
     if (background) {
-        return '<div class="button" onclick="$.ajax(' +
-            "{url: '" + url + "', type: 'GET', timeout: replica_timeout});" +
-            '"><b>' + name + '</b></div>';
+        return m(".button", {
+            onclick: function() {
+                m.request({
+                    url: url,
+                    method: "GET",
+                    config: configXHRTimeout,
+                    // Don't try to convert the result to JSON
+                    deserialize: function(value) { return value }
+                })
+            }
+        }, m("b", name))
     }
-    return '<div class="button" onclick="' +
-        "location.href='" + url + "'" +
-        '"><b>' + name + '</b></div>';
+    return m(".button", {
+        onclick: function() {
+            location.href = url
+        }
+    }, m("b", name))
 }
 
 function metric(name, value, warning, critical, factor, notify_value) {
     if (notify_value === undefined)
-        notify_value = value;
-    var notify = get_notify_class(notify_value, warning, critical);
-    return '<div class="metric' + notify + '"><b>' + name + ':</b> ' +
-        si_prefix(value, factor) + '</div>';
+        notify_value = value
+    var notify = get_notify_class(notify_value, warning, critical)
+    return m(".metric." + notify, m("b", name + ":"), " ", si_prefix(value, factor))
 }
 
 function usage_metric(name, total, used, warning, critical, factor) {
-    var used_percent = Math.round((used / total) * 100);
-    return metric(name, si_prefix(used, factor) + '/' +
-        si_prefix(total, factor) + ' (' + used_percent + '%)', warning,
-        critical, null, used_percent);
+    var used_percent = Math.round((used / total) * 100)
+    return metric(
+        name, 
+        si_prefix(used, factor) + "/" + si_prefix(total, factor) + " (" + used_percent + "%)", 
+        warning,
+        critical,
+        null,
+        used_percent
+    )
 }
 
 function hover_help(content, help_text) {
-    return '<span class="hover_help_wrapper">' + content +
-        '<div class="hover_help">' + help_text + '</div></span>';
+    return m("span.hover_help_wrapper", content, m(".hover_help", m.trust(help_text)))
 }
 
 function iterate_sorted_object(key_values, callback) {
-    var keys = [];
-    for (var key in key_values)
-        keys.push(key);
-    keys.sort();
-    var html = '';
-    for (var key in keys) {
-        key = keys[key];
-        html += callback(key, key_values[key]);
+    var keys = []
+    var key
+    for (key in key_values)
+        keys.push(key)
+    keys.sort()
+    var result = []
+    for (key in keys) {
+        key = keys[key]
+        result.push(callback(key, key_values[key]))
     }
-    return html;
+    return result
 }
 
+// TODO: Remove global use from this function
+// This function has a side-effect of updating a global replica_status with increasingly severe status
 function get_notify_class(value, warning, critical) {
     if (warning > critical) {
         if (value < critical) {
-            replica_status = 'critical';
-            return ' critical';
+            replica_status = "critical"
+            return "critical"
         }
         else if (value < warning) {
-            if (replica_status != 'critical')
-                replica_status = 'warning';
-            return ' warning';
+            if (replica_status !== "critical")
+                replica_status = "warning"
+            return "warning"
         }
     }
     else {
         if (value > critical) {
-            replica_status = 'critical';
-            return ' critical';
+            replica_status = "critical"
+            return "critical"
         }
         else if (value > warning) {
-            if (replica_status != 'critical')
-                replica_status = 'warning';
-            return ' warning';
+            if (replica_status !== "critical")
+                replica_status = "warning"
+            return "warning"
         }
     }
-    return '';
+    return "normal"
 }
 
-SI_PREFIXES_LARGE = ['', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
-SI_PREFIXES_SMALL = ['', 'm', 'u', 'n', 'p', 'f', 'a', 'z', 'y'];
+var SI_PREFIXES_LARGE = ["", "k", "M", "G", "T", "P", "E", "Z", "Y"]
+var SI_PREFIXES_SMALL = ["", "m", "u", "n", "p", "f", "a", "z", "y"]
 
 function si_prefix(value, factor) {
     if (factor === null)
-        return value;
+        return value
     if (factor === undefined)
-        factor = 1000;
-    var prefix = 0;
+        factor = 1000
+    var prefix = 0
     if (value >= 1) {
         while (Math.round(value) >= factor) {
-            value /= factor;
-            prefix++;
+            value /= factor
+            prefix++
         }
-        prefix = SI_PREFIXES_LARGE[prefix];
+        prefix = SI_PREFIXES_LARGE[prefix]
     }
     else if (value > 0) {
         while (value < 1) {
-            value *= factor;
-            prefix++;
+            value *= factor
+            prefix++
         }
-        prefix = SI_PREFIXES_SMALL[prefix];
+        prefix = SI_PREFIXES_SMALL[prefix]
     }
     else
-        return value;
-    var adjust = Math.pow(10, 3 - Math.round(value).toString().length);
-    adjust = Math.max(1, adjust);
-    return (Math.round(value * adjust) / adjust) + prefix;
+        return value
+    var adjust = Math.pow(10, 3 - Math.round(value).toString().length)
+    adjust = Math.max(1, adjust)
+    return (Math.round(value * adjust) / adjust) + prefix
 }
 
+var isHelpHidden = true
+var isByIPHidden = true
+
+function key_help() {
+    var help = {
+        b: "Run buffer on visible replicas",
+        B: "Run buffer on all replicas",
+        h: "Hide all replicas",
+        H: "Show all replicas",
+        "i/I": "Toggle ip view",
+        p: "Run purge on visible replicas",
+        P: "Run purge on all replicas",
+        "r or &lt;space&gt": "Refresh visible replicas",
+        R: "Refresh all replicas",
+        s: "Run sync on visible replicas",
+        S: "Run sync on all replicas"
+    }
+
+    return m("#help", { class: isHelpHidden ? "hide" : "nohide" }, 
+        Object.keys(help).map(function (key) {
+            return m("div", m("b", m.trust(key)), " - ", help[key])
+        })
+    )
+}
+
+function body() {
+    return m("div", [
+        m("#header", [
+            m("h1", m.trust("&#9774;"), " craigslist blob console"),
+            m("a.clickable", {
+                onclick: function() { isHelpHidden = !isHelpHidden },
+            }, [
+                m("b", "shortcuts")
+            ]),
+            " - ",
+            m("a.clickable", {
+                onclick: function() { isByIPHidden = !isByIPHidden },
+            }, [
+                m("b", "by ip")
+            ])
+        ]),
+        key_help(),
+        m("#grid", grid()),
+        m("#summary", generate_summary_div()),
+        m("#by_ip", { class: isByIPHidden ? "hide" : "" }, iterate_sorted_object(allReplicasByIP, combine_ips)),
+        m("#main", main())
+    ])
+}
+
+function start() {
+   document.onkeypress = handle_keypress
+   m.mount(document.body, {view: body})
+   get_config()
+}
         </script>
     </head>
     <body>
-        <div id="header">
-            <h1>&#9774; craigslist blob console</h1>
-            <a class="clickable" onclick="$('#help').toggleClass('hide');">
-                <b>shortcuts</b>
-            </a> -
-            <a class="clickable" onclick="$('#by_ip').toggleClass('hide');">
-                <b>by ip</b>
-            </a>
-        </div>
-        <div id="help" class="hide">
-            <div><b>b</b> - Run buffer on visible replicas</div>
-            <div><b>B</b> - Run buffer on all replicas</div>
-            <div><b>h</b> - Hide all replicas</div>
-            <div><b>H</b> - Show all replicas</div>
-            <div><b>i/I</b> - Toggle ip view</div>
-            <div><b>p</b> - Run purge on visible replicas</div>
-            <div><b>P</b> - Run purge on all replicas</div>
-            <div><b>r or &lt;space&gt;</b> - Refresh visible replicas</div>
-            <div><b>R</b> - Refresh all replicas</div>
-            <div><b>s</b> - Run sync on visible replicas</div>
-            <div><b>S</b> - Run sync on all replicas</div>
-        </div>
-        <div id="grid"></div>
-        <div id="summary"></div>
-        <div id="by_ip" class="hide"></div>
-        <div id="main"></div>
+        <script>/* global start */ start();</script>
     </body>
 </html>