diff --git a/dashboard-ui/bower_components/alameda/.bower.json b/dashboard-ui/bower_components/alameda/.bower.json
new file mode 100644
index 0000000000..3a10ac7737
--- /dev/null
+++ b/dashboard-ui/bower_components/alameda/.bower.json
@@ -0,0 +1,34 @@
+{
+  "name": "alameda",
+  "version": "1.0.0",
+  "ignore": [
+    ".gitignore",
+    ".npmignore",
+    "node_modules",
+    "package.json",
+    "README.md",
+    "tests",
+    "tests-requirejs",
+    "copyrequirejstests.sh",
+    "testBaseUrl.js"
+  ],
+  "homepage": "https://github.com/requirejs/alameda",
+  "authors": [
+    "jrburke.com"
+  ],
+  "description": "AMD loader, like requirejs, but with promises and for modern browsers",
+  "main": "alameda.js",
+  "license": [
+    "MIT"
+  ],
+  "_release": "1.0.0",
+  "_resolution": {
+    "type": "version",
+    "tag": "1.0.0",
+    "commit": "f09e80862f0e40b4018531f360f5336c5ca8eaa2"
+  },
+  "_source": "git://github.com/requirejs/alameda.git",
+  "_target": "^1.0.0",
+  "_originalSource": "alameda",
+  "_direct": true
+}
\ No newline at end of file
diff --git a/dashboard-ui/bower_components/alameda/LICENSE b/dashboard-ui/bower_components/alameda/LICENSE
new file mode 100644
index 0000000000..cd164e2731
--- /dev/null
+++ b/dashboard-ui/bower_components/alameda/LICENSE
@@ -0,0 +1,45 @@
+Copyright jQuery Foundation and other contributors, https://jquery.org/
+
+This software consists of voluntary contributions made by many
+individuals. For exact contribution history, see the revision history
+available at https://github.com/requirejs/alameda
+
+The following license applies to all parts of this software except as
+documented below:
+
+====
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+====
+
+Copyright and related rights for sample code are waived via CC0. Sample
+code is defined as all source code displayed within the prose of the
+documentation.
+
+CC0: http://creativecommons.org/publicdomain/zero/1.0/
+
+====
+
+Files located in the node_modules directory, and certain utilities used
+to build or test the software in the tests and tests-requirejs directories, are
+externally maintained libraries used by this software which have their own
+licenses; we recommend you read them, as their terms may differ from the
+terms above.
diff --git a/dashboard-ui/bower_components/alameda/alameda.js b/dashboard-ui/bower_components/alameda/alameda.js
new file mode 100644
index 0000000000..a406dce589
--- /dev/null
+++ b/dashboard-ui/bower_components/alameda/alameda.js
@@ -0,0 +1,1253 @@
+/**
+ * @license alameda 1.0.0 Copyright jQuery Foundation and other contributors.
+ * Released under MIT license, http://github.com/requirejs/alameda/LICENSE
+ */
+// Going sloppy because loader plugin execs may depend on non-strict execution.
+/*jslint sloppy: true, nomen: true, regexp: true */
+/*global document, navigator, importScripts, Promise, setTimeout */
+
+var requirejs, require, define;
+(function (global, Promise, undef) {
+  if (!Promise) {
+    throw new Error('No Promise implementation available');
+  }
+
+  var topReq, dataMain, src, subPath,
+    bootstrapConfig = requirejs || require,
+    hasOwn = Object.prototype.hasOwnProperty,
+    contexts = {},
+    queue = [],
+    currDirRegExp = /^\.\//,
+    urlRegExp = /^\/|\:|\?|\.js$/,
+    commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
+    cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
+    jsSuffixRegExp = /\.js$/,
+    slice = Array.prototype.slice;
+
+  if (typeof requirejs === 'function') {
+    return;
+  }
+
+  // Could match something like ')//comment', do not lose the prefix to comment.
+  function commentReplace(match, multi, multiText, singlePrefix) {
+    return singlePrefix || '';
+  }
+
+  function hasProp(obj, prop) {
+    return hasOwn.call(obj, prop);
+  }
+
+  function getOwn(obj, prop) {
+    return obj && hasProp(obj, prop) && obj[prop];
+  }
+
+  /**
+   * Cycles over properties in an object and calls a function for each
+   * property value. If the function returns a truthy value, then the
+   * iteration is stopped.
+   */
+  function eachProp(obj, func) {
+    var prop;
+    for (prop in obj) {
+      if (hasProp(obj, prop)) {
+        if (func(obj[prop], prop)) {
+          break;
+        }
+      }
+    }
+  }
+
+  /**
+   * Simple function to mix in properties from source into target,
+   * but only if target does not already have a property of the same name.
+   */
+  function mixin(target, source, force, deepStringMixin) {
+    if (source) {
+      eachProp(source, function (value, prop) {
+        if (force || !hasProp(target, prop)) {
+          if (deepStringMixin && typeof value === 'object' && value &&
+            !Array.isArray(value) && typeof value !== 'function' &&
+            !(value instanceof RegExp)) {
+
+            if (!target[prop]) {
+              target[prop] = {};
+            }
+            mixin(target[prop], value, force, deepStringMixin);
+          } else {
+            target[prop] = value;
+          }
+        }
+      });
+    }
+    return target;
+  }
+
+  // Allow getting a global that expressed in
+  // dot notation, like 'a.b.c'.
+  function getGlobal(value) {
+    if (!value) {
+      return value;
+    }
+    var g = global;
+    value.split('.').forEach(function (part) {
+      g = g[part];
+    });
+    return g;
+  }
+
+  function newContext(contextName) {
+    var req, main, makeMap, callDep, handlers, checkingLater, load, context,
+      defined = {},
+      waiting = {},
+      config = {
+        // Defaults. Do not set a default for map
+        // config to speed up normalize(), which
+        // will run faster if there is no default.
+        waitSeconds: 7,
+        baseUrl: './',
+        paths: {},
+        bundles: {},
+        pkgs: {},
+        shim: {},
+        config: {}
+      },
+      mapCache = {},
+      requireDeferreds = [],
+      deferreds = {},
+      calledDefine = {},
+      calledPlugin = {},
+      loadCount = 0,
+      startTime = (new Date()).getTime(),
+      errCount = 0,
+      trackedErrors = {},
+      urlFetched = {},
+      bundlesMap = {},
+      asyncResolve = Promise.resolve();
+
+    /**
+     * Trims the . and .. from an array of path segments.
+     * It will keep a leading path segment if a .. will become
+     * the first path segment, to help with module name lookups,
+     * which act like paths, but can be remapped. But the end result,
+     * all paths that use this function should look normalized.
+     * NOTE: this method MODIFIES the input array.
+     * @param {Array} ary the array of path segments.
+     */
+    function trimDots(ary) {
+      var i, part, length = ary.length;
+      for (i = 0; i < length; i++) {
+        part = ary[i];
+        if (part === '.') {
+          ary.splice(i, 1);
+          i -= 1;
+        } else if (part === '..') {
+          // If at the start, or previous value is still ..,
+          // keep them so that when converted to a path it may
+          // still work when converted to a path, even though
+          // as an ID it is less than ideal. In larger point
+          // releases, may be better to just kick out an error.
+          if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
+            continue;
+          } else if (i > 0) {
+            ary.splice(i - 1, 2);
+            i -= 2;
+          }
+        }
+      }
+    }
+
+    /**
+     * Given a relative module name, like ./something, normalize it to
+     * a real name that can be mapped to a path.
+     * @param {String} name the relative name
+     * @param {String} baseName a real name that the name arg is relative
+     * to.
+     * @param {Boolean} applyMap apply the map config to the value. Should
+     * only be done if this normalization is for a dependency ID.
+     * @returns {String} normalized name
+     */
+    function normalize(name, baseName, applyMap) {
+      var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
+        foundMap, foundI, foundStarMap, starI,
+        baseParts = baseName && baseName.split('/'),
+        normalizedBaseParts = baseParts,
+        map = config.map,
+        starMap = map && map['*'];
+
+
+      //Adjust any relative paths.
+      if (name) {
+        name = name.split('/');
+        lastIndex = name.length - 1;
+
+        // If wanting node ID compatibility, strip .js from end
+        // of IDs. Have to do this here, and not in nameToUrl
+        // because node allows either .js or non .js to map
+        // to same file.
+        if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
+          name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
+        }
+
+        // Starts with a '.' so need the baseName
+        if (name[0].charAt(0) === '.' && baseParts) {
+          //Convert baseName to array, and lop off the last part,
+          //so that . matches that 'directory' and not name of the baseName's
+          //module. For instance, baseName of 'one/two/three', maps to
+          //'one/two/three.js', but we want the directory, 'one/two' for
+          //this normalization.
+          normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
+          name = normalizedBaseParts.concat(name);
+        }
+
+        trimDots(name);
+        name = name.join('/');
+      }
+
+      // Apply map config if available.
+      if (applyMap && map && (baseParts || starMap)) {
+        nameParts = name.split('/');
+
+        outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
+          nameSegment = nameParts.slice(0, i).join('/');
+
+          if (baseParts) {
+            // Find the longest baseName segment match in the config.
+            // So, do joins on the biggest to smallest lengths of baseParts.
+            for (j = baseParts.length; j > 0; j -= 1) {
+              mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
+
+              // baseName segment has config, find if it has one for
+              // this name.
+              if (mapValue) {
+                mapValue = getOwn(mapValue, nameSegment);
+                if (mapValue) {
+                  // Match, update name to the new value.
+                  foundMap = mapValue;
+                  foundI = i;
+                  break outerLoop;
+                }
+              }
+            }
+          }
+
+          // Check for a star map match, but just hold on to it,
+          // if there is a shorter segment match later in a matching
+          // config, then favor over this star map.
+          if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
+            foundStarMap = getOwn(starMap, nameSegment);
+            starI = i;
+          }
+        }
+
+        if (!foundMap && foundStarMap) {
+          foundMap = foundStarMap;
+          foundI = starI;
+        }
+
+        if (foundMap) {
+          nameParts.splice(0, foundI, foundMap);
+          name = nameParts.join('/');
+        }
+      }
+
+      // If the name points to a package's name, use
+      // the package main instead.
+      pkgMain = getOwn(config.pkgs, name);
+
+      return pkgMain ? pkgMain : name;
+    }
+
+    function makeShimExports(value) {
+      function fn() {
+        var ret;
+        if (value.init) {
+          ret = value.init.apply(global, arguments);
+        }
+        return ret || (value.exports && getGlobal(value.exports));
+      }
+      return fn;
+    }
+
+    function takeQueue(anonId) {
+      var i, id, args, shim;
+      for (i = 0; i < queue.length; i += 1) {
+        // Peek to see if anon
+        if (typeof queue[i][0] !== 'string') {
+          if (anonId) {
+            queue[i].unshift(anonId);
+            anonId = undef;
+          } else {
+            // Not our anon module, stop.
+            break;
+          }
+        }
+        args = queue.shift();
+        id = args[0];
+        i -= 1;
+
+        if (!hasProp(defined, id) && !hasProp(waiting, id)) {
+          if (hasProp(deferreds, id)) {
+            main.apply(undef, args);
+          } else {
+            waiting[id] = args;
+          }
+        }
+      }
+
+      // if get to the end and still have anonId, then could be
+      // a shimmed dependency.
+      if (anonId) {
+        shim = getOwn(config.shim, anonId) || {};
+        main(anonId, shim.deps || [], shim.exportsFn);
+      }
+    }
+
+    function makeRequire(relName, topLevel) {
+      var req = function (deps, callback, errback, alt) {
+        var name, cfg;
+
+        if (topLevel) {
+          takeQueue();
+        }
+
+        if (typeof deps === "string") {
+          if (handlers[deps]) {
+            return handlers[deps](relName);
+          }
+          // Just return the module wanted. In this scenario, the
+          // deps arg is the module name, and second arg (if passed)
+          // is just the relName.
+          // Normalize module name, if it contains . or ..
+          name = makeMap(deps, relName, true).id;
+          if (!hasProp(defined, name)) {
+            throw new Error('Not loaded: ' + name);
+          }
+          return defined[name];
+        } else if (deps && !Array.isArray(deps)) {
+          // deps is a config object, not an array.
+          cfg = deps;
+          deps = undef;
+
+          if (Array.isArray(callback)) {
+            // callback is an array, which means it is a dependency list.
+            // Adjust args if there are dependencies
+            deps = callback;
+            callback = errback;
+            errback = alt;
+          }
+
+          if (topLevel) {
+            // Could be a new context, so call returned require
+            return req.config(cfg)(deps, callback, errback);
+          }
+        }
+
+        // Support require(['a'])
+        callback = callback || function () {
+          // In case used later as a promise then value, return the
+          // arguments as an array.
+          return slice.call(arguments, 0);
+        };
+
+        // Complete async to maintain expected execution semantics.
+        return asyncResolve.then(function () {
+          // Grab any modules that were defined after a require call.
+          takeQueue();
+
+          return main(undef, deps || [], callback, errback, relName);
+        });
+      };
+
+      req.isBrowser = typeof document !== 'undefined' &&
+        typeof navigator !== 'undefined';
+
+      req.nameToUrl = function (moduleName, ext, skipExt) {
+        var paths, syms, i, parentModule, url,
+          parentPath, bundleId,
+          pkgMain = getOwn(config.pkgs, moduleName);
+
+        if (pkgMain) {
+          moduleName = pkgMain;
+        }
+
+        bundleId = getOwn(bundlesMap, moduleName);
+
+        if (bundleId) {
+          return req.nameToUrl(bundleId, ext, skipExt);
+        }
+
+        // If a colon is in the URL, it indicates a protocol is used and it is
+        // just an URL to a file, or if it starts with a slash, contains a query
+        // arg (i.e. ?) or ends with .js, then assume the user meant to use an
+        // url and not a module id. The slash is important for protocol-less
+        // URLs as well as full paths.
+        if (urlRegExp.test(moduleName)) {
+          // Just a plain path, not module name lookup, so just return it.
+          // Add extension if it is included. This is a bit wonky, only non-.js
+          // things pass an extension, this method probably needs to be
+          // reworked.
+          url = moduleName + (ext || '');
+        } else {
+          // A module that needs to be converted to a path.
+          paths = config.paths;
+
+          syms = moduleName.split('/');
+          // For each module name segment, see if there is a path
+          // registered for it. Start with most specific name
+          // and work up from it.
+          for (i = syms.length; i > 0; i -= 1) {
+            parentModule = syms.slice(0, i).join('/');
+
+            parentPath = getOwn(paths, parentModule);
+            if (parentPath) {
+              // If an array, it means there are a few choices,
+              // Choose the one that is desired
+              if (Array.isArray(parentPath)) {
+                parentPath = parentPath[0];
+              }
+              syms.splice(0, i, parentPath);
+              break;
+            }
+          }
+
+          // Join the path parts together, then figure out if baseUrl is needed.
+          url = syms.join('/');
+          url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));
+          url = (url.charAt(0) === '/' ||
+                url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
+        }
+
+        return config.urlArgs && !/^blob\:/.test(url) ?
+               url + config.urlArgs(moduleName, url) : url;
+      };
+
+      /**
+       * Converts a module name + .extension into an URL path.
+       * *Requires* the use of a module name. It does not support using
+       * plain URLs like nameToUrl.
+       */
+      req.toUrl = function (moduleNamePlusExt) {
+        var ext,
+          index = moduleNamePlusExt.lastIndexOf('.'),
+          segment = moduleNamePlusExt.split('/')[0],
+          isRelative = segment === '.' || segment === '..';
+
+        // Have a file extension alias, and it is not the
+        // dots from a relative path.
+        if (index !== -1 && (!isRelative || index > 1)) {
+          ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
+          moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
+        }
+
+        return req.nameToUrl(normalize(moduleNamePlusExt, relName), ext, true);
+      };
+
+      req.defined = function (id) {
+        return hasProp(defined, makeMap(id, relName, true).id);
+      };
+
+      req.specified = function (id) {
+        id = makeMap(id, relName, true).id;
+        return hasProp(defined, id) || hasProp(deferreds, id);
+      };
+
+      return req;
+    }
+
+    function resolve(name, d, value) {
+      if (name) {
+        defined[name] = value;
+        if (requirejs.onResourceLoad) {
+          requirejs.onResourceLoad(context, d.map, d.deps);
+        }
+      }
+      d.finished = true;
+      d.resolve(value);
+    }
+
+    function reject(d, err) {
+      d.finished = true;
+      d.rejected = true;
+      d.reject(err);
+    }
+
+    function makeNormalize(relName) {
+      return function (name) {
+        return normalize(name, relName, true);
+      };
+    }
+
+    function defineModule(d) {
+      d.factoryCalled = true;
+
+      var ret,
+        name = d.map.id;
+
+      try {
+         ret = d.factory.apply(defined[name], d.values);
+      } catch(err) {
+         return reject(d, err);
+      }
+
+      if (name) {
+        // Favor return value over exports. If node/cjs in play,
+        // then will not have a return value anyway. Favor
+        // module.exports assignment over exports object.
+        if (ret === undef) {
+          if (d.cjsModule) {
+            ret = d.cjsModule.exports;
+          } else if (d.usingExports) {
+            ret = defined[name];
+          }
+        }
+      } else {
+        // Remove the require deferred from the list to
+        // make cycle searching faster. Do not need to track
+        // it anymore either.
+        requireDeferreds.splice(requireDeferreds.indexOf(d), 1);
+      }
+      resolve(name, d, ret);
+    }
+
+    // This method is attached to every module deferred,
+    // so the "this" in here is the module deferred object.
+    function depFinished(val, i) {
+      if (!this.rejected && !this.depDefined[i]) {
+        this.depDefined[i] = true;
+        this.depCount += 1;
+        this.values[i] = val;
+        if (!this.depending && this.depCount === this.depMax) {
+          defineModule(this);
+        }
+      }
+    }
+
+    function makeDefer(name) {
+      var d = {};
+      d.promise = new Promise(function (resolve, reject) {
+        d.resolve = resolve;
+        d.reject = function(err) {
+          if (!name) {
+          requireDeferreds.splice(requireDeferreds.indexOf(d), 1);
+          }
+          reject(err);
+        };
+      });
+      d.map = name ? makeMap(name, null, true) : {};
+      d.depCount = 0;
+      d.depMax = 0;
+      d.values = [];
+      d.depDefined = [];
+      d.depFinished = depFinished;
+      if (d.map.pr) {
+        // Plugin resource ID, implicitly
+        // depends on plugin. Track it in deps
+        // so cycle breaking can work
+        d.deps = [makeMap(d.map.pr)];
+      }
+      return d;
+    }
+
+    function getDefer(name) {
+      var d;
+      if (name) {
+        d = hasProp(deferreds, name) && deferreds[name];
+        if (!d) {
+          d = deferreds[name] = makeDefer(name);
+        }
+      } else {
+        d = makeDefer();
+        requireDeferreds.push(d);
+      }
+      return d;
+    }
+
+    function makeErrback(d, name) {
+      return function (err) {
+        if (!d.rejected) {
+          if (!err.dynaId) {
+            err.dynaId = 'id' + (errCount += 1);
+            err.requireModules = [name];
+          }
+          reject(d, err);
+        }
+      };
+    }
+
+    function waitForDep(depMap, relName, d, i) {
+      d.depMax += 1;
+
+      // Do the fail at the end to catch errors
+      // in the then callback execution.
+      callDep(depMap, relName).then(function (val) {
+        d.depFinished(val, i);
+      }, makeErrback(d, depMap.id)).catch(makeErrback(d, d.map.id));
+    }
+
+    function makeLoad(id) {
+      var fromTextCalled;
+      function load(value) {
+        // Protect against older plugins that call load after
+        // calling load.fromText
+        if (!fromTextCalled) {
+          resolve(id, getDefer(id), value);
+        }
+      }
+
+      load.error = function (err) {
+        getDefer(id).reject(err);
+      };
+
+      load.fromText = function (text, textAlt) {
+        /*jslint evil: true */
+        var d = getDefer(id),
+          map = makeMap(makeMap(id).n),
+           plainId = map.id;
+
+        fromTextCalled = true;
+
+        // Set up the factory just to be a return of the value from
+        // plainId.
+        d.factory = function (p, val) {
+          return val;
+        };
+
+        // As of requirejs 2.1.0, support just passing the text, to reinforce
+        // fromText only being called once per resource. Still
+        // support old style of passing moduleName but discard
+        // that moduleName in favor of the internal ref.
+        if (textAlt) {
+          text = textAlt;
+        }
+
+        // Transfer any config to this other module.
+        if (hasProp(config.config, id)) {
+          config.config[plainId] = config.config[id];
+        }
+
+        try {
+          req.exec(text);
+        } catch (e) {
+          reject(d, new Error('fromText eval for ' + plainId +
+                  ' failed: ' + e));
+        }
+
+        // Execute any waiting define created by the plainId
+        takeQueue(plainId);
+
+        // Mark this as a dependency for the plugin
+        // resource
+        d.deps = [map];
+        waitForDep(map, null, d, d.deps.length);
+      };
+
+      return load;
+    }
+
+    load = typeof importScripts === 'function' ?
+        function (map) {
+          var url = map.url;
+          if (urlFetched[url]) {
+            return;
+          }
+          urlFetched[url] = true;
+
+          // Ask for the deferred so loading is triggered.
+          // Do this before loading, since loading is sync.
+          getDefer(map.id);
+          importScripts(url);
+          takeQueue(map.id);
+        } :
+        function (map) {
+          var script,
+            id = map.id,
+            url = map.url;
+
+          if (urlFetched[url]) {
+            return;
+          }
+          urlFetched[url] = true;
+
+          script = document.createElement('script');
+          script.setAttribute('data-requiremodule', id);
+          script.type = config.scriptType || 'text/javascript';
+          script.charset = 'utf-8';
+          script.async = true;
+
+          loadCount += 1;
+
+          script.addEventListener('load', function () {
+            loadCount -= 1;
+            takeQueue(id);
+          }, false);
+          script.addEventListener('error', function () {
+            loadCount -= 1;
+            var err,
+              pathConfig = getOwn(config.paths, id),
+              d = getOwn(deferreds, id);
+            if (pathConfig && Array.isArray(pathConfig) &&
+                pathConfig.length > 1) {
+              script.parentNode.removeChild(script);
+              // Pop off the first array value, since it failed, and
+              // retry
+              pathConfig.shift();
+              d.map = makeMap(id);
+              load(d.map);
+            } else {
+              err = new Error('Load failed: ' + id + ': ' + script.src);
+              err.requireModules = [id];
+              getDefer(id).reject(err);
+            }
+          }, false);
+
+          script.src = url;
+
+          document.head.appendChild(script);
+        };
+
+    function callPlugin(plugin, map, relName) {
+      plugin.load(map.n, makeRequire(relName), makeLoad(map.id), config);
+    }
+
+    callDep = function (map, relName) {
+      var args, bundleId,
+        name = map.id,
+        shim = config.shim[name];
+
+      if (hasProp(waiting, name)) {
+        args = waiting[name];
+        delete waiting[name];
+        main.apply(undef, args);
+      } else if (!hasProp(deferreds, name)) {
+        if (map.pr) {
+          // If a bundles config, then just load that file instead to
+          // resolve the plugin, as it is built into that bundle.
+          if ((bundleId = getOwn(bundlesMap, name))) {
+            map.url = req.nameToUrl(bundleId);
+            load(map);
+          } else {
+            return callDep(makeMap(map.pr)).then(function (plugin) {
+              // Redo map now that plugin is known to be loaded
+              var newMap = makeMap(name, relName, true),
+                newId = newMap.id,
+                shim = getOwn(config.shim, newId);
+
+              // Make sure to only call load once per resource. Many
+              // calls could have been queued waiting for plugin to load.
+              if (!hasProp(calledPlugin, newId)) {
+                calledPlugin[newId] = true;
+                if (shim && shim.deps) {
+                  req(shim.deps, function () {
+                    callPlugin(plugin, newMap, relName);
+                  });
+                } else {
+                  callPlugin(plugin, newMap, relName);
+                }
+              }
+              return getDefer(newId).promise;
+            });
+          }
+        } else if (shim && shim.deps) {
+          req(shim.deps, function () {
+            load(map);
+          });
+        } else {
+          load(map);
+        }
+      }
+
+      return getDefer(name).promise;
+    };
+
+    // Turns a plugin!resource to [plugin, resource]
+    // with the plugin being undefined if the name
+    // did not have a plugin prefix.
+    function splitPrefix(name) {
+      var prefix,
+        index = name ? name.indexOf('!') : -1;
+      if (index > -1) {
+        prefix = name.substring(0, index);
+        name = name.substring(index + 1, name.length);
+      }
+      return [prefix, name];
+    }
+
+    /**
+     * Makes a name map, normalizing the name, and using a plugin
+     * for normalization if necessary. Grabs a ref to plugin
+     * too, as an optimization.
+     */
+    makeMap = function (name, relName, applyMap) {
+      if (typeof name !== 'string') {
+        return name;
+      }
+
+      var plugin, url, parts, prefix, result,
+        cacheKey = name + ' & ' + (relName || '') + ' & ' + !!applyMap;
+
+      parts = splitPrefix(name);
+      prefix = parts[0];
+      name = parts[1];
+
+      if (!prefix && hasProp(mapCache, cacheKey)) {
+        return mapCache[cacheKey];
+      }
+
+      if (prefix) {
+        prefix = normalize(prefix, relName, applyMap);
+        plugin = hasProp(defined, prefix) && defined[prefix];
+      }
+
+      // Normalize according
+      if (prefix) {
+        if (plugin && plugin.normalize) {
+          name = plugin.normalize(name, makeNormalize(relName));
+        } else {
+          // If nested plugin references, then do not try to
+          // normalize, as it will not normalize correctly. This
+          // places a restriction on resourceIds, and the longer
+          // term solution is not to normalize until plugins are
+          // loaded and all normalizations to allow for async
+          // loading of a loader plugin. But for now, fixes the
+          // common uses. Details in requirejs#1131
+          name = name.indexOf('!') === -1 ?
+                   normalize(name, relName, applyMap) :
+                   name;
+        }
+      } else {
+        name = normalize(name, relName, applyMap);
+        parts = splitPrefix(name);
+        prefix = parts[0];
+        name = parts[1];
+
+        url = req.nameToUrl(name);
+      }
+
+      // Using ridiculous property names for space reasons
+      result = {
+        id: prefix ? prefix + '!' + name : name, // fullName
+        n: name,
+        pr: prefix,
+        url: url
+      };
+
+      if (!prefix) {
+        mapCache[cacheKey] = result;
+      }
+
+      return result;
+    };
+
+    handlers = {
+      require: function (name) {
+        return makeRequire(name);
+      },
+      exports: function (name) {
+        var e = defined[name];
+        if (typeof e !== 'undefined') {
+          return e;
+        } else {
+          return (defined[name] = {});
+        }
+      },
+      module: function (name) {
+        return {
+          id: name,
+          uri: '',
+          exports: handlers.exports(name),
+          config: function () {
+            return getOwn(config.config, name) || {};
+          }
+        };
+      }
+    };
+
+    function breakCycle(d, traced, processed) {
+      var id = d.map.id;
+
+      traced[id] = true;
+      if (!d.finished && d.deps) {
+        d.deps.forEach(function (depMap) {
+          var depId = depMap.id,
+            dep = !hasProp(handlers, depId) && getDefer(depId);
+
+          // Only force things that have not completed
+          // being defined, so still in the registry,
+          // and only if it has not been matched up
+          // in the module already.
+          if (dep && !dep.finished && !processed[depId]) {
+            if (hasProp(traced, depId)) {
+              d.deps.forEach(function (depMap, i) {
+                if (depMap.id === depId) {
+                  d.depFinished(defined[depId], i);
+                }
+              });
+            } else {
+              breakCycle(dep, traced, processed);
+            }
+          }
+        });
+      }
+      processed[id] = true;
+    }
+
+    function check(d) {
+      var err,
+        notFinished = [],
+        waitInterval = config.waitSeconds * 1000,
+        // It is possible to disable the wait interval by using waitSeconds 0.
+        expired = waitInterval &&
+                  (startTime + waitInterval) < (new Date()).getTime();
+
+    if (loadCount === 0) {
+        // If passed in a deferred, it is for a specific require call.
+        // Could be a sync case that needs resolution right away.
+        // Otherwise, if no deferred, means it was the last ditch
+        // timeout-based check, so check all waiting require deferreds.
+        if (d) {
+          if (!d.finished) {
+            breakCycle(d, {}, {});
+          }
+        } else if (requireDeferreds.length) {
+          requireDeferreds.forEach(function (d) {
+            breakCycle(d, {}, {});
+          });
+        }
+      }
+
+      // If still waiting on loads, and the waiting load is something
+      // other than a plugin resource, or there are still outstanding
+      // scripts, then just try back later.
+      if (expired) {
+        // If wait time expired, throw error of unloaded modules.
+        eachProp(deferreds, function (d) {
+          if (!d.finished) {
+            notFinished.push(d.map.id);
+          }
+        });
+        err = new Error('Timeout for modules: ' + notFinished);
+        err.requireModules = notFinished;
+        req.onError(err);
+      } else if (loadCount || requireDeferreds.length) {
+        // Something is still waiting to load. Wait for it, but only
+        // if a later check is not already scheduled. Using setTimeout
+        // because want other things in the event loop to happen,
+        // to help in dependency resolution, and this is really a
+        // last ditch check, mostly for detecting timeouts (cycles
+        // should come through the main() use of check()), so it can
+        // wait a bit before doing the final check.
+        if (!checkingLater) {
+          checkingLater = true;
+          setTimeout(function () {
+            checkingLater = false;
+            check();
+          }, 70);
+        }
+      }
+    }
+
+    // Used to break out of the promise try/catch chains.
+    function delayedError(e) {
+      setTimeout(function () {
+        if (!e.dynaId || !trackedErrors[e.dynaId]) {
+          trackedErrors[e.dynaId] = true;
+          req.onError(e);
+        }
+      });
+      return e;
+    }
+
+    main = function (name, deps, factory, errback, relName) {
+      // Only allow main calling once per module.
+      if (name && hasProp(calledDefine, name)) {
+        return;
+      }
+      calledDefine[name] = true;
+
+      var d = getDefer(name);
+
+      // This module may not have dependencies
+      if (deps && !Array.isArray(deps)) {
+        // deps is not an array, so probably means
+        // an object literal or factory function for
+        // the value. Adjust args.
+        factory = deps;
+        deps = [];
+      }
+
+      if (!errback) {
+        if (hasProp(config, 'defaultErrback')) {
+          if (config.defaultErrback) {
+            errback = config.defaultErrback;
+          }
+        } else {
+          errback = delayedError;
+        }
+      }
+
+      if (errback) {
+         d.promise.catch(errback);
+      }
+
+      // Use name if no relName
+      relName = relName || name;
+
+      // Call the factory to define the module, if necessary.
+      if (typeof factory === 'function') {
+
+        if (!deps.length && factory.length) {
+          // Remove comments from the callback string,
+          // look for require calls, and pull them into the dependencies,
+          // but only if there are function args.
+          factory
+            .toString()
+            .replace(commentRegExp, commentReplace)
+            .replace(cjsRequireRegExp, function (match, dep) {
+              deps.push(dep);
+            });
+
+          // May be a CommonJS thing even without require calls, but still
+          // could use exports, and module. Avoid doing exports and module
+          // work though if it just needs require.
+          // REQUIRES the function to expect the CommonJS variables in the
+          // order listed below.
+          deps = (factory.length === 1 ?
+              ['require'] :
+              ['require', 'exports', 'module']).concat(deps);
+        }
+
+        // Save info for use later.
+        d.factory = factory;
+        d.deps = deps;
+
+        d.depending = true;
+        deps.forEach(function (depName, i) {
+          var depMap;
+          deps[i] = depMap = makeMap(depName, relName, true);
+          depName = depMap.id;
+
+          // Fast path CommonJS standard dependencies.
+          if (depName === "require") {
+            d.values[i] = handlers.require(name);
+          } else if (depName === "exports") {
+            // CommonJS module spec 1.1
+            d.values[i] = handlers.exports(name);
+            d.usingExports = true;
+          } else if (depName === "module") {
+            // CommonJS module spec 1.1
+            d.values[i] = d.cjsModule = handlers.module(name);
+          } else if (depName === undefined) {
+            d.values[i] = undefined;
+          } else {
+            waitForDep(depMap, relName, d, i);
+          }
+        });
+        d.depending = false;
+
+        // Some modules just depend on the require, exports, modules, so
+        // trigger their definition here if so.
+        if (d.depCount === d.depMax) {
+          defineModule(d);
+        }
+      } else if (name) {
+        // May just be an object definition for the module. Only
+        // worry about defining if have a module name.
+        resolve(name, d, factory);
+      }
+
+      startTime = (new Date()).getTime();
+
+      if (!name) {
+        check(d);
+      }
+
+      return d.promise;
+    };
+
+    req = makeRequire(null, true);
+
+    /*
+     * Just drops the config on the floor, but returns req in case
+     * the config return value is used.
+     */
+    req.config = function (cfg) {
+      if (cfg.context && cfg.context !== contextName) {
+        return newContext(cfg.context).config(cfg);
+      }
+
+      // Since config changed, mapCache may not be valid any more.
+      mapCache = {};
+
+      // Make sure the baseUrl ends in a slash.
+      if (cfg.baseUrl) {
+        if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
+          cfg.baseUrl += '/';
+        }
+      }
+
+      // Convert old style urlArgs string to a function.
+      if (typeof cfg.urlArgs === 'string') {
+        var urlArgs = cfg.urlArgs;
+        cfg.urlArgs = function(id, url) {
+          return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
+        };
+      }
+
+      // Save off the paths and packages since they require special processing,
+      // they are additive.
+      var shim = config.shim,
+        objs = {
+          paths: true,
+          bundles: true,
+          config: true,
+          map: true
+        };
+
+      eachProp(cfg, function (value, prop) {
+        if (objs[prop]) {
+          if (!config[prop]) {
+            config[prop] = {};
+          }
+          mixin(config[prop], value, true, true);
+        } else {
+          config[prop] = value;
+        }
+      });
+
+      // Reverse map the bundles
+      if (cfg.bundles) {
+        eachProp(cfg.bundles, function (value, prop) {
+          value.forEach(function (v) {
+            if (v !== prop) {
+              bundlesMap[v] = prop;
+            }
+          });
+        });
+      }
+
+      // Merge shim
+      if (cfg.shim) {
+        eachProp(cfg.shim, function (value, id) {
+          // Normalize the structure
+          if (Array.isArray(value)) {
+            value = {
+              deps: value
+            };
+          }
+          if ((value.exports || value.init) && !value.exportsFn) {
+            value.exportsFn = makeShimExports(value);
+          }
+          shim[id] = value;
+        });
+        config.shim = shim;
+      }
+
+      // Adjust packages if necessary.
+      if (cfg.packages) {
+        cfg.packages.forEach(function (pkgObj) {
+          var location, name;
+
+          pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
+
+          name = pkgObj.name;
+          location = pkgObj.location;
+          if (location) {
+            config.paths[name] = pkgObj.location;
+          }
+
+          // Save pointer to main module ID for pkg name.
+          // Remove leading dot in main, so main paths are normalized,
+          // and remove any trailing .js, since different package
+          // envs have different conventions: some use a module name,
+          // some use a file name.
+          config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
+                 .replace(currDirRegExp, '')
+                 .replace(jsSuffixRegExp, '');
+        });
+      }
+
+      // If a deps array or a config callback is specified, then call
+      // require with those args. This is useful when require is defined as a
+      // config object before require.js is loaded.
+      if (cfg.deps || cfg.callback) {
+        req(cfg.deps, cfg.callback);
+      }
+
+      return req;
+    };
+
+    req.onError = function (err) {
+      throw err;
+    };
+
+    context = {
+      id: contextName,
+      defined: defined,
+      waiting: waiting,
+      config: config,
+      deferreds: deferreds
+    };
+
+    contexts[contextName] = context;
+
+    return req;
+  }
+
+  requirejs = topReq = newContext('_');
+
+  if (typeof require !== 'function') {
+    require = topReq;
+  }
+
+  /**
+   * Executes the text. Normally just uses eval, but can be modified
+   * to use a better, environment-specific call. Only used for transpiling
+   * loader plugins, not for plain JS modules.
+   * @param {String} text the text to execute/evaluate.
+   */
+  topReq.exec = function (text) {
+    /*jslint evil: true */
+    return eval(text);
+  };
+
+  topReq.contexts = contexts;
+
+  define = function () {
+    queue.push(slice.call(arguments, 0));
+  };
+
+  define.amd = {
+    jQuery: true
+  };
+
+  if (bootstrapConfig) {
+    topReq.config(bootstrapConfig);
+  }
+
+  // data-main support.
+  if (topReq.isBrowser && !contexts._.config.skipDataMain) {
+    dataMain = document.querySelectorAll('script[data-main]')[0];
+    dataMain = dataMain && dataMain.getAttribute('data-main');
+    if (dataMain) {
+      // Strip off any trailing .js since dataMain is now
+      // like a module name.
+      dataMain = dataMain.replace(jsSuffixRegExp, '');
+
+      // Set final baseUrl if there is not already an explicit one,
+      // but only do so if the data-main value is not a loader plugin
+      // module ID.
+      if ((!bootstrapConfig || !bootstrapConfig.baseUrl) &&
+          dataMain.indexOf('!') === -1) {
+        // Pull off the directory of data-main for use as the
+        // baseUrl.
+        src = dataMain.split('/');
+        dataMain = src.pop();
+        subPath = src.length ? src.join('/')  + '/' : './';
+
+        topReq.config({baseUrl: subPath});
+      }
+
+      topReq([dataMain]);
+    }
+  }
+}(this, (typeof Promise !== 'undefined' ? Promise : undefined)));
diff --git a/dashboard-ui/bower_components/alameda/bower.json b/dashboard-ui/bower_components/alameda/bower.json
new file mode 100644
index 0000000000..94eda88d74
--- /dev/null
+++ b/dashboard-ui/bower_components/alameda/bower.json
@@ -0,0 +1,24 @@
+{
+  "name": "alameda",
+  "version": "1.0.0",
+  "ignore": [
+    ".gitignore",
+    ".npmignore",
+    "node_modules",
+    "package.json",
+    "README.md",
+    "tests",
+    "tests-requirejs",
+    "copyrequirejstests.sh",
+    "testBaseUrl.js"
+  ],
+  "homepage": "https://github.com/requirejs/alameda",
+  "authors": [
+    "jrburke.com"
+  ],
+  "description": "AMD loader, like requirejs, but with promises and for modern browsers",
+  "main": "alameda.js",
+  "license": [
+    "MIT"
+  ]
+}
diff --git a/dashboard-ui/bower_components/alameda/shrinktest.sh b/dashboard-ui/bower_components/alameda/shrinktest.sh
new file mode 100644
index 0000000000..e0a539e52a
--- /dev/null
+++ b/dashboard-ui/bower_components/alameda/shrinktest.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+rm alameda.min.js.gz
+ls -la alameda.js
+uglifyjs -c -m -o alameda.min.js alameda.js
+ls -la alameda.min.js
+gzip alameda.min.js
+ls -la alameda.min.js.gz
+