<!doctype html>
<html>
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <title>HTTPing | Access servers based on network response time!</title>

    <script type="text/javascript">
/* Configuration start */
var test_url_list = [
      { name : 'Site 1',
        testurl: "http://site1.app.example.com/MYTESTFILE.txt",
        redirect: "http://site1.app.example.com"},
      { name : 'Site 2',
        testurl: "http://site2.app.example.com/MYTESTFILE.txt",
        redirect: "http://site2.app.example.com"}
    ];
/* Configuration finishes */
/* DO NOT EDIT BELOW */
      (function(globals) {
var define, requireModule;

(function() {
  var registry = {}, seen = {};

  define = function(name, deps, callback) {
    registry[name] = { deps: deps, callback: callback };
  };

  requireModule = function(name) {
    if (seen[name]) { return seen[name]; }
    seen[name] = {};

    var mod = registry[name];
    if (!mod) {
      throw new Error("Module '" + name + "' not found.");
    }

    var deps = mod.deps,
        callback = mod.callback,
        reified = [],
        exports;

    for (var i=0, l=deps.length; i<l; i++) {
      if (deps[i] === 'exports') {
        reified.push(exports = {});
      } else {
        reified.push(requireModule(deps[i]));
      }
    }

    var value = callback.apply(this, reified);
    return seen[name] = exports || value;
  };
})();

define("rsvp/all",
  ["rsvp/promise","exports"],
  function(__dependency1__, __exports__) {
    "use strict";
    var Promise = __dependency1__.Promise;
    /* global toString */


    function promiseAtLeast(expected_count, promises) {
      if (Object.prototype.toString.call(promises) !== "[object Array]") {
        throw new TypeError('You must pass an array to all.');
      }

      function canceller() {
        var promise;
        for (var i = 0; i < promises.length; i++) {
          promise = promises[i];

          if (promise && typeof promise.then === 'function' &&
              typeof promise.cancel === 'function') {
            promise.cancel();
          }
        }
      }

      return new Promise(function(resolve, reject) {
        var results = [], remaining = promises.length,
        promise, remaining_count = promises.length - expected_count;

        if (remaining === 0) {
          if (expected_count === 1) {
            resolve();
          } else {
            resolve([]);
          }
        }

        function resolver(index) {
          return function(value) {
            resolveAll(index, value);
          };
        }

        function resolveAll(index, value) {
          results[index] = value;
          if (--remaining === remaining_count) {
            if (remaining_count === 0) {
              resolve(results);
            } else {
              resolve(value);
              canceller();
            }
          }
        }

        function cancelAll(rejectionValue) {
          reject(rejectionValue);
          canceller();
        }

        for (var i = 0; i < promises.length; i++) {
          promise = promises[i];

          if (promise && typeof promise.then === 'function') {
            promise.then(resolver(i), cancelAll);
          } else {
            resolveAll(i, promise);
          }
        }
      }, canceller
      );
    }

    function all(promises) {
      return promiseAtLeast(promises.length, promises);
    }

    function any(promises) {
      return promiseAtLeast(1, promises);
    }


    __exports__.all = all;
    __exports__.any = any;
  });
define("rsvp/async",
  ["exports"],
  function(__exports__) {
    "use strict";
    var browserGlobal = (typeof window !== 'undefined') ? window : {};
    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
    var async;
    var local = (typeof global !== 'undefined') ? global : this;

    function checkNativePromise() {
      if (typeof Promise === "function" &&
          typeof Promise.resolve === "function") {
        try {
          /* global Promise */
          var promise = new Promise(function(){});
          if ({}.toString.call(promise) === "[object Promise]") {
            return true;
          }
        } catch (e) {}
      }
      return false;
    }

    function useNativePromise() {
      var nativePromise = Promise.resolve();
      return function(callback, arg) {
        nativePromise.then(function () {
          callback(arg);
        });
      };
    }

    // old node
    function useNextTick() {
      return function(callback, arg) {
        process.nextTick(function() {
          callback(arg);
        });
      };
    }

    // node >= 0.10.x
    function useSetImmediate() {
      return function(callback, arg) {
        /* global  setImmediate */
        setImmediate(function(){
          callback(arg);
        });
      };
    }

    function useMutationObserver() {
      var queue = [];

      var observer = new BrowserMutationObserver(function() {
        var toProcess = queue.slice();
        queue = [];

        toProcess.forEach(function(tuple) {
          var callback = tuple[0], arg= tuple[1];
          callback(arg);
        });
      });

      var element = document.createElement('div');
      observer.observe(element, { attributes: true });

      // Chrome Memory Leak: https://bugs.webkit.org/show_bug.cgi?id=93661
      window.addEventListener('unload', function(){
        observer.disconnect();
        observer = null;
      }, false);

      return function(callback, arg) {
        queue.push([callback, arg]);
        element.setAttribute('drainQueue', 'drainQueue');
      };
    }

    function useSetTimeout() {
      return function(callback, arg) {
        local.setTimeout(function() {
          callback(arg);
        }, 1);
      };
    }

    if (checkNativePromise()) {
      async = useNativePromise();
    } else if (typeof setImmediate === 'function') {
      async = useSetImmediate();
    } else if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
      async = useNextTick();
    } else if (BrowserMutationObserver) {
      async = useMutationObserver();
    } else {
      async = useSetTimeout();
    }


    __exports__.async = async;
  });
define("rsvp/cancellation_error",
  ["exports"],
  function(__exports__) {
    "use strict";
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
    function CancellationError(message) {
      this.name = "cancel";
      if ((message !== undefined) && (typeof message !== "string")) {
        throw new TypeError('You must pass a string.');
      }
      this.message = message || "Default Message";
    }
    CancellationError.prototype = new Error();
    CancellationError.prototype.constructor = CancellationError;


    __exports__.CancellationError = CancellationError;
  });
define("rsvp/config",
  ["rsvp/async","exports"],
  function(__dependency1__, __exports__) {
    "use strict";
    var async = __dependency1__.async;

    var config = {};
    config.async = async;


    __exports__.config = config;
  });
define("rsvp/defer",
  ["rsvp/promise","exports"],
  function(__dependency1__, __exports__) {
    "use strict";
    var Promise = __dependency1__.Promise;

    function defer() {
      var deferred = {
        // pre-allocate shape
        resolve: undefined,
        reject:  undefined,
        promise: undefined
      };

      deferred.promise = new Promise(function(resolve, reject) {
        deferred.resolve = resolve;
        deferred.reject = reject;
      });

      return deferred;
    }


    __exports__.defer = defer;
  });
define("rsvp/events",
  ["exports"],
  function(__exports__) {
    "use strict";
    var Event = function(type, options) {
      this.type = type;

      for (var option in options) {
        if (!options.hasOwnProperty(option)) { continue; }

        this[option] = options[option];
      }
    };

    var indexOf = function(callbacks, callback) {
      for (var i=0, l=callbacks.length; i<l; i++) {
        if (callbacks[i][0] === callback) { return i; }
      }

      return -1;
    };

    var callbacksFor = function(object) {
      var callbacks = object._promiseCallbacks;

      if (!callbacks) {
        callbacks = object._promiseCallbacks = {};
      }

      return callbacks;
    };

    var EventTarget = {
      mixin: function(object) {
        object.on = this.on;
        object.off = this.off;
        object.trigger = this.trigger;
        return object;
      },

      on: function(eventNames, callback, binding) {
        var allCallbacks = callbacksFor(this), callbacks, eventName;
        eventNames = eventNames.split(/\s+/);
        binding = binding || this;

        while (eventName = eventNames.shift()) {
          callbacks = allCallbacks[eventName];

          if (!callbacks) {
            callbacks = allCallbacks[eventName] = [];
          }

          if (indexOf(callbacks, callback) === -1) {
            callbacks.push([callback, binding]);
          }
        }
      },

      off: function(eventNames, callback) {
        var allCallbacks = callbacksFor(this), callbacks, eventName, index;
        eventNames = eventNames.split(/\s+/);

        while (eventName = eventNames.shift()) {
          if (!callback) {
            allCallbacks[eventName] = [];
            continue;
          }

          callbacks = allCallbacks[eventName];

          index = indexOf(callbacks, callback);

          if (index !== -1) { callbacks.splice(index, 1); }
        }
      },

      trigger: function(eventName, options) {
        var allCallbacks = callbacksFor(this),
            callbacks, callbackTuple, callback, binding, event;

        if (callbacks = allCallbacks[eventName]) {
          // Don't cache the callbacks.length since it may grow
          for (var i=0; i<callbacks.length; i++) {
            callbackTuple = callbacks[i];
            callback = callbackTuple[0];
            binding = callbackTuple[1];

            if (typeof options !== 'object') {
              options = { detail: options };
            }

            event = new Event(eventName, options);
            callback.call(binding, event);
          }
        }
      }
    };


    __exports__.EventTarget = EventTarget;
  });
define("rsvp/hash",
  ["rsvp/defer","exports"],
  function(__dependency1__, __exports__) {
    "use strict";
    var defer = __dependency1__.defer;

    function size(object) {
      var s = 0;

      for (var prop in object) {
        s++;
      }

      return s;
    }

    function hash(promises) {
      var results = {}, deferred = defer(), remaining = size(promises);

      if (remaining === 0) {
        deferred.resolve({});
      }

      var resolver = function(prop) {
        return function(value) {
          resolveAll(prop, value);
        };
      };

      var resolveAll = function(prop, value) {
        results[prop] = value;
        if (--remaining === 0) {
          deferred.resolve(results);
        }
      };

      var rejectAll = function(error) {
        deferred.reject(error);
      };

      for (var prop in promises) {
        if (promises[prop] && typeof promises[prop].then === 'function') {
          promises[prop].then(resolver(prop), rejectAll);
        } else {
          resolveAll(prop, promises[prop]);
        }
      }

      return deferred.promise;
    }


    __exports__.hash = hash;
  });
define("rsvp/node",
  ["rsvp/promise","rsvp/all","exports"],
  function(__dependency1__, __dependency2__, __exports__) {
    "use strict";
    var Promise = __dependency1__.Promise;
    var all = __dependency2__.all;

    function makeNodeCallbackFor(resolve, reject) {
      return function (error, value) {
        if (error) {
          reject(error);
        } else if (arguments.length > 2) {
          resolve(Array.prototype.slice.call(arguments, 1));
        } else {
          resolve(value);
        }
      };
    }

    function denodeify(nodeFunc) {
      return function()  {
        var nodeArgs = Array.prototype.slice.call(arguments), resolve, reject;
        var thisArg = this;

        var promise = new Promise(function(nodeResolve, nodeReject) {
          resolve = nodeResolve;
          reject = nodeReject;
        });

        all(nodeArgs).then(function(nodeArgs) {
          nodeArgs.push(makeNodeCallbackFor(resolve, reject));

          try {
            nodeFunc.apply(thisArg, nodeArgs);
          } catch(e) {
            reject(e);
          }
        });

        return promise;
      };
    }


    __exports__.denodeify = denodeify;
  });
define("rsvp/promise",
  ["rsvp/config","rsvp/events","rsvp/cancellation_error","exports"],
  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
    "use strict";
    var config = __dependency1__.config;
    var EventTarget = __dependency2__.EventTarget;
    var CancellationError = __dependency3__.CancellationError;

    function objectOrFunction(x) {
      return isFunction(x) || (typeof x === "object" && x !== null);
    }

    function isFunction(x){
      return typeof x === "function";
    }

    var Promise = function(resolver, canceller) {
      var promise = this,
      resolved = false;

      if (typeof resolver !== 'function') {
        throw new TypeError('You must pass a resolver function as the sole argument to the promise constructor');
      }

      if ((canceller !== undefined) && (typeof canceller !== 'function')) {
        throw new TypeError('You can only pass a canceller function' +
          ' as the second argument to the promise constructor');
      }

      if (!(promise instanceof Promise)) {
        return new Promise(resolver, canceller);
      }

      var resolvePromise = function(value) {
        if (resolved) { return; }
        resolved = true;
        resolve(promise, value);
      };

      var rejectPromise = function(value) {
        if (resolved) { return; }
        resolved = true;
        reject(promise, value);
      };

      this.on('promise:failed', function(event) {
        this.trigger('error', { detail: event.detail });
      }, this);

      this.on('error', onerror);

      this.cancel = function () {
        // For now, simply reject the promise and does not propagate the cancel
        // to parent or children
        if (resolved) { return; }
        if (canceller !== undefined) {
          try {
            canceller();
          } catch (e) {
            rejectPromise(e);
            return;
          }
        }
        // Trigger cancel?
        rejectPromise(new CancellationError());
      };

      try {
        resolver(resolvePromise, rejectPromise);
      } catch(e) {
        rejectPromise(e);
      }
    };

    function onerror(event) {
      if (config.onerror) {
        config.onerror(event.detail);
      }
    }

    var invokeCallback = function(type, promise, callback, event) {
      var hasCallback = isFunction(callback),
          value, error, succeeded, failed;

      if (promise.isFulfilled) { return; }
      if (promise.isRejected) { return; }

      if (hasCallback) {
        try {
          value = callback(event.detail);
          succeeded = true;
        } catch(e) {
          failed = true;
          error = e;
        }
      } else {
        value = event.detail;
        succeeded = true;
      }

      if (handleThenable(promise, value)) {
        return;
      } else if (hasCallback && succeeded) {
        resolve(promise, value);
      } else if (failed) {
        reject(promise, error);
      } else if (type === 'resolve') {
        resolve(promise, value);
      } else if (type === 'reject') {
        reject(promise, value);
      }
    };

    Promise.prototype = {
      constructor: Promise,

      isRejected: undefined,
      isFulfilled: undefined,
      rejectedReason: undefined,
      fulfillmentValue: undefined,

      then: function(done, fail) {
        this.off('error', onerror);

        var thenPromise = new this.constructor(function() {},
            function () {
              thenPromise.trigger('promise:cancelled', {});
            });

        if (this.isFulfilled) {
          config.async(function(promise) {
            invokeCallback('resolve', thenPromise, done, { detail: promise.fulfillmentValue });
          }, this);
        }

        if (this.isRejected) {
          config.async(function(promise) {
            invokeCallback('reject', thenPromise, fail, { detail: promise.rejectedReason });
          }, this);
        }

        this.on('promise:resolved', function(event) {
          invokeCallback('resolve', thenPromise, done, event);
        });

        this.on('promise:failed', function(event) {
          invokeCallback('reject', thenPromise, fail, event);
        });

        return thenPromise;
      },

      fail: function(fail) {
        return this.then(null, fail);
      },

      always: function(fail) {
        return this.then(fail, fail);
      }
    };

    EventTarget.mixin(Promise.prototype);

    function resolve(promise, value) {
      if (promise === value) {
        fulfill(promise, value);
      } else if (!handleThenable(promise, value)) {
        fulfill(promise, value);
      }
    }

    function handleThenable(promise, value) {
      var then = null,
      resolved;

      try {
        if (promise === value) {
          throw new TypeError("A promises callback cannot return that same promise.");
        }

        if (objectOrFunction(value)) {
          then = value.then;

          if (isFunction(then)) {
            promise.on('promise:cancelled', function(event) {
              if (isFunction(value.cancel)) {
                value.cancel();
              }
            });
            then.call(value, function(val) {
              if (resolved) { return true; }
              resolved = true;

              if (value !== val) {
                resolve(promise, val);
              } else {
                fulfill(promise, val);
              }
            }, function(val) {
              if (resolved) { return true; }
              resolved = true;

              reject(promise, val);
            });

            return true;
          }
        }
      } catch (error) {
        reject(promise, error);
        return true;
      }

      return false;
    }

    function fulfill(promise, value) {
      config.async(function() {
        if (promise.isFulfilled) { return; }
        if (promise.isRejected) { return; }
        promise.trigger('promise:resolved', { detail: value });
        promise.isFulfilled = true;
        promise.fulfillmentValue = value;
      });
    }

    function reject(promise, value) {
      config.async(function() {
        if (promise.isFulfilled) { return; }
        if (promise.isRejected) { return; }
        promise.trigger('promise:failed', { detail: value });
        promise.isRejected = true;
        promise.rejectedReason = value;
      });
    }


    __exports__.Promise = Promise;
  });
define("rsvp/queue",
  ["rsvp/promise","rsvp/resolve","exports"],
  function(__dependency1__, __dependency2__, __exports__) {
    "use strict";
    var Promise = __dependency1__.Promise;
    var resolve = __dependency2__.resolve;

    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
    function ResolvedQueueError(message) {
      this.name = "resolved";
      if ((message !== undefined) && (typeof message !== "string")) {
        throw new TypeError('You must pass a string.');
      }
      this.message = message || "Default Message";
    }
    ResolvedQueueError.prototype = new Error();
    ResolvedQueueError.prototype.constructor = ResolvedQueueError;

    var Queue = function() {
      var queue = this,
        promise_list = [],
        promise,
        fulfill,
        reject,
        resolved;

      if (!(this instanceof Queue)) {
        return new Queue();
      }

      function canceller() {
        for (var i = 0; i < 2; i++) {
          promise_list[i].cancel();
        }
      }

      promise = new Promise(function(done, fail) {
        fulfill = function (fulfillmentValue) {
          if (resolved) {return;}
          queue.isFulfilled = true;
          queue.fulfillmentValue = fulfillmentValue;
          resolved = true;
          return done(fulfillmentValue);
        };
        reject = function (rejectedReason) {
          if (resolved) {return;}
          queue.isRejected = true;
          queue.rejectedReason = rejectedReason ;
          resolved = true;
          return fail(rejectedReason);
        };
      }, canceller);

      promise_list.push(resolve());
      promise_list.push(promise_list[0].then(function () {
        promise_list.splice(0, 2);
        if (promise_list.length === 0) {
          fulfill();
        }
      }));

      queue.cancel = function () {
        if (resolved) {return;}
        resolved = true;
        promise.cancel();
        promise.fail(function (rejectedReason) {
          queue.isRejected = true;
          queue.rejectedReason = rejectedReason;
        });
      };
      queue.then = function () {
        return promise.then.apply(promise, arguments);
      };

      queue.push = function(done, fail) {
        var last_promise = promise_list[promise_list.length - 1],
          next_promise;

        if (resolved) {
          throw new ResolvedQueueError();
        }

        next_promise = last_promise.then(done, fail);
        promise_list.push(next_promise);

        // Handle pop
        promise_list.push(next_promise.then(function (fulfillmentValue) {
          promise_list.splice(0, 2);
          if (promise_list.length === 0) {
            fulfill(fulfillmentValue);
          } else {
            return fulfillmentValue;
          }
        }, function (rejectedReason) {
          promise_list.splice(0, 2);
          if (promise_list.length === 0) {
            reject(rejectedReason);
          } else {
            throw rejectedReason;
          }
        }));

        return this;
      };
    };

    Queue.prototype = Object.create(Promise.prototype);
    Queue.prototype.constructor = Queue;


    __exports__.Queue = Queue;
    __exports__.ResolvedQueueError = ResolvedQueueError;
  });
define("rsvp/reject",
  ["rsvp/promise","exports"],
  function(__dependency1__, __exports__) {
    "use strict";
    var Promise = __dependency1__.Promise;

    function reject(reason) {
      return new Promise(function (resolve, reject) {
        reject(reason);
      });
    }


    __exports__.reject = reject;
  });
define("rsvp/resolve",
  ["rsvp/promise","exports"],
  function(__dependency1__, __exports__) {
    "use strict";
    var Promise = __dependency1__.Promise;

    function resolve(thenable) {
      return new Promise(function(resolve, reject) {
        if (typeof thenable === "object" && thenable !== null) {
          var then = thenable.then;
          if ((then !== undefined) && (typeof then === "function")) {
            return then.apply(thenable, [resolve, reject]);
          }
        }
        return resolve(thenable);
      }, function () {
        if ((thenable !== undefined) && (thenable.cancel !== undefined)) {
          thenable.cancel();
        }
      });
    }


    __exports__.resolve = resolve;
  });
define("rsvp/rethrow",
  ["exports"],
  function(__exports__) {
    "use strict";
    var local = (typeof global === "undefined") ? this : global;

    function rethrow(reason) {
      local.setTimeout(function() {
        throw reason;
      });
      throw reason;
    }


    __exports__.rethrow = rethrow;
  });
define("rsvp/timeout",
  ["rsvp/promise","exports"],
  function(__dependency1__, __exports__) {
    "use strict";
    var Promise = __dependency1__.Promise;

    function promiseSetTimeout(millisecond, should_reject, message) {
      var timeout_id;

      function resolver(resolve, reject) {
        timeout_id = setTimeout(function () {
          if (should_reject) {
            reject(message);
          } else {
            resolve(message);
          }
        }, millisecond);
      }
      function canceller() {
        clearTimeout(timeout_id);
      }
      return new Promise(resolver, canceller);
    }

    function delay(millisecond, message) {
      return promiseSetTimeout(millisecond, false, message);
    }

    function timeout(millisecond) {
      return promiseSetTimeout(millisecond, true,
                               "Timed out after " + millisecond + " ms");
    }

    Promise.prototype.delay = function(millisecond) {
      return this.then(function (fulfillmentValue) {
        return delay(millisecond, fulfillmentValue);
      });
    };


    __exports__.delay = delay;
    __exports__.timeout = timeout;
  });
define("rsvp",
  ["rsvp/events","rsvp/cancellation_error","rsvp/promise","rsvp/node","rsvp/all","rsvp/queue","rsvp/timeout","rsvp/hash","rsvp/rethrow","rsvp/defer","rsvp/config","rsvp/resolve","rsvp/reject","exports"],
  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __exports__) {
    "use strict";
    var EventTarget = __dependency1__.EventTarget;
    var CancellationError = __dependency2__.CancellationError;
    var Promise = __dependency3__.Promise;
    var denodeify = __dependency4__.denodeify;
    var all = __dependency5__.all;
    var any = __dependency5__.any;
    var Queue = __dependency6__.Queue;
    var ResolvedQueueError = __dependency6__.ResolvedQueueError;
    var delay = __dependency7__.delay;
    var timeout = __dependency7__.timeout;
    var hash = __dependency8__.hash;
    var rethrow = __dependency9__.rethrow;
    var defer = __dependency10__.defer;
    var config = __dependency11__.config;
    var resolve = __dependency12__.resolve;
    var reject = __dependency13__.reject;

    function configure(name, value) {
      config[name] = value;
    }


    __exports__.CancellationError = CancellationError;
    __exports__.Promise = Promise;
    __exports__.EventTarget = EventTarget;
    __exports__.all = all;
    __exports__.any = any;
    __exports__.Queue = Queue;
    __exports__.ResolvedQueueError = ResolvedQueueError;
    __exports__.delay = delay;
    __exports__.timeout = timeout;
    __exports__.hash = hash;
    __exports__.rethrow = rethrow;
    __exports__.defer = defer;
    __exports__.denodeify = denodeify;
    __exports__.configure = configure;
    __exports__.resolve = resolve;
    __exports__.reject = reject;
  });
window.RSVP = requireModule("rsvp");
})(window);
    </script>
    <script type="text/javascript">
      /*jslint indent: 2, maxlen: 80, nomen: true */
/*global console, window, document, RSVP, XMLHttpRequest */
(function (document, RSVP, XMLHttpRequest) {
  "use strict";
  var promise_list = [];

  function ajax(param) {
    var xhr = new XMLHttpRequest();
    return new RSVP.Promise(function (resolve, reject, notify) {
      var k;
      xhr.open(param.type || "GET", param.url, true);
      xhr.responseType = param.dataType || "";
      if (typeof param.headers === 'object' && param.headers !== null) {
        for (k in param.headers) {
          if (param.headers.hasOwnProperty(k)) {
            xhr.setRequestHeader(k, param.headers[k]);
          }
        }
      }
      xhr.addEventListener("load", function (e) {
        if (e.target.status >= 400) {
          return reject(e);
        }
        return resolve(e);
      });
      xhr.addEventListener("error", reject);
      xhr.addEventListener("progress", notify);
      if (typeof param.xhrFields === 'object' && param.xhrFields !== null) {
        for (k in param.xhrFields) {
          if (param.xhrFields.hasOwnProperty(k)) {
            xhr[k] = param.xhrFields[k];
          }
        }
      }
      if (typeof param.beforeSend === 'function') {
        param.beforeSend(xhr);
      }
      xhr.send(param.data);
    }, function () {
      xhr.abort();
    });
  }
  function testURL(url) {
    return RSVP.Queue()
      .push(function () {
        return ajax({
          url: url
        });
      })
      .push(function (evt) {
        return evt.target.responseText;
      }, function () {
        return "FAIL";
      });
  }

  function launchTest(test_case) {
    var start = new Date().getTime(),
      url = test_case.testurl;
    return new RSVP.Queue()
      .push(function () {
        return RSVP.any([RSVP.delay(4000),
          testURL(url + "?nocache=" + start)]);
      })
      .push(function (result) {
        var elapsed = new Date().getTime() - start;
        if (result === undefined) {
          return {url: test_case.redirect,
            time: 1000000001,
            name: test_case.name};
        }
        if (result === "FAIL") {
          return {url: test_case.redirect,
            time: 1000000000,
            name: test_case.name};
        }
        return {url: test_case.redirect,
          name: test_case.name,
          time: elapsed};
      });
  }

  function runOnce(test_queue) {
    return new RSVP.Queue()
      .push(function () {
        var u;
        for (u in test_url_list) {
          if (test_url_list.hasOwnProperty(u)) {
            test_queue.push(launchTest(test_url_list[u]));
          }
        }
        return RSVP.all(test_queue);
      })
      .push(undefined, function (reason) {
        console.log(reason);
        return "OK";
      });
  }

  function renderPartialResult(result, main_div, winner_div) {
    var u, y, interaction, winner = 0,
      t_i, table_dict = {}, interaction_dict = {}, msg = "";

    msg += "<table width=100%>";

    for (u in result) {
      if (result.hasOwnProperty(u)) {
        interaction = parseInt(u / test_url_list.length, 10);

        if (!interaction_dict.hasOwnProperty(interaction)) {
          interaction_dict[interaction] = 1;
        }
        if (!table_dict.hasOwnProperty(result[u].name)) {
          table_dict[result[u].name] = {
            total: 0,
            name: result[u].name,
            url: result[u].url
          };
        }
        if (result[u].time === 1000000000) {
          table_dict[result[u].name][interaction] = "FAIL";
          table_dict[result[u].name].total = "REJECT";
        } else  if (result[u].time === 1000000001) {
          table_dict[result[u].name][interaction] = "TIMEOUT";
          table_dict[result[u].name].total = "REJECT";
        } else {
          table_dict[result[u].name][interaction] = result[u].time;
          if (table_dict[result[u].name].total !== "REJECT") {
            table_dict[result[u].name].total += result[u].time;
          }
        }
      }
    }
    msg += "</tr> <th> </th>";
    t_i = 0;
    for (u in interaction_dict) {
      if (interaction_dict.hasOwnProperty(u)) {
        msg += '<th> Test ' + u + "</th>";
        t_i += 1;
      }
    }
    msg += "<th class='avg'> AVERAGE </th></tr>";

    for (u in table_dict) {
      if (table_dict.hasOwnProperty(u)) {
        if (winner === 0) {
          winner = table_dict[u];
        }
        if (table_dict[u].total !== "REJECT") {
          table_dict[u].average = table_dict[u].total / t_i;
          if (winner.average === "REJECT") {
            winner = table_dict[u];
          }
          if (winner.average > table_dict[u].average) {
            winner = table_dict[u];
          }
        } else {
          table_dict[u].average = "REJECT";
        }
      }
    }


    for (u in table_dict) {
      if (table_dict.hasOwnProperty(u)) {
        if (u === winner.name) {
          msg += "<tr class='winner'>";
        } else {
          msg += "<tr>";
        }
        msg += "<td>";
        if (table_dict[u].url) {
          msg += '<a href="' + table_dict[u].url + '">' + u + '</a>';
        } else {
          msg += u;
        }
        msg += "</td>";
        for (y in interaction_dict) {
          if (interaction_dict.hasOwnProperty(y)) {
            msg += "<td>" + table_dict[u][y] + "</td>";
          }
        }
        msg += "<td>" + table_dict[u].average + "</td>";
        msg += "</tr>";
      }
    }

    msg += "</table>";

    msg = "<h2> The best frontend for you is ... <strong>" +
      winner.name + " </strong> </h2>" + msg;

    main_div.innerHTML = msg;

    msg = "";
    msg += "<p><a class=btn href=" + winner.url + "> Click to Connect via ";
    msg +=  winner.name + "</a> </p>";

    winner_div.innerHTML = msg;
    return winner;
  }

  function runAll() {
    return runOnce(promise_list)
      .push(function () {
        return runOnce(promise_list)
          .push(function () {
            return runOnce(promise_list)
              .push(function () {
                return runOnce(promise_list)
                  .push(function () {
                    return runOnce(promise_list)
                      .push(function (result) {
                        var winner,
                          div = document.getElementsByClassName("table"),
                          winner_div = document.getElementsByClassName("link");

                        winner = renderPartialResult(result,
                          div[0],
                          winner_div[0]);

                        return winner;
                      });
                  });
              });
          });
      });
  }

  runAll();

}(document, RSVP, XMLHttpRequest));

    </script>
<style type="text/css">
      /* === animation === */
      @-ms-keyframes spin {
          from { -ms-transform: rotate(0deg); }
          to { -ms-transform: rotate(360deg); }
      }
      @-moz-keyframes spin {
          from { -moz-transform: rotate(0deg); }
          to { -moz-transform: rotate(360deg); }
      }
      @-webkit-keyframes spin {
          from { -webkit-transform: rotate(0deg); }
          to { -webkit-transform: rotate(360deg); }
      }
      @keyframes spin {
          from {
              transform:rotate(0deg);
          }
          to {
              transform:rotate(360deg);
          }
      }
      /* === font (embedded icons (hehe) and text === */
      @charset "UTF-8";
      body {
        font-family: Arial;
      }
      @font-face {
        font-family: "untitled-font-1";
        src: url('untitled-font-1.eot') format('embedded-opentype');
        /*
        src:url("fonts/untitled-font-1.eot");
        src:url("fonts/untitled-font-1.eot?#iefix") format("embedded-opentype"),
          url("fonts/untitled-font-1.woff") format("woff"),
          url("fonts/untitled-font-1.ttf") format("truetype"),
          url("fonts/untitled-font-1.svg#untitled-font-1") format("svg");
        */
        font-weight: normal;
        font-style: normal;
      }
      @font-face {
        font-family: 'untitled-font-1';
        src:  url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff'), url('untitled-font-1.ttf')  format('truetype'), url('untitled-font-1.svg#untitled-font-1') format('svg');
        font-weight: normal;
        font-style: normal;
      }
      /* === set font on classes === */
      [class^="custom-icon-"]:before,
      [class*=" custom-icon-"]:before {
        font-family: "untitled-font-1" !important;
        font-style: normal !important;
        font-weight: normal !important;
        font-variant: normal !important;
        text-transform: none !important;
        speak: none;
        line-height: 1;
        -webkit-font-smoothing: antialiased;
        -moz-osx-font-smoothing: grayscale;
      }
      .custom-icon-spinner:before {
        content: "a";
      }
      .custom-icon-user:before {
        content: "b";
      }
      .custom-icon-forward:before {
        content: "c";
      }
      .custom-icon-harddrive:before {
        content: "e";
      }
      /* === logo === */
      .custom-grandenet-logo {
        background: url(data:image/svg+xml;base64,<?xml version="1.0"?>
<svg width="200" height="120" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
 <!-- Created with Method Draw - http://github.com/duopixel/Method-Draw/ -->
 <g>
  <title>background</title>
  <rect fill="#fff" id="canvas_background" height="122" width="202" y="-1" x="-1"/>
  <g display="none" overflow="visible" y="0" x="0" height="100%" width="100%" id="canvasGrid">
   <rect fill="url(#gridpattern)" stroke-width="0" y="0" x="0" height="100%" width="100%"/>
  </g>
 </g>
 <g>
  <title>Layer 1</title>
  <image stroke="null" xlink:href="data:image/png;base64,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" id="svg_1" height="98.206521" width="194.999998" y="10.793479" x="3.000002"/>
 </g>
</svg>) no-repeat center center;
        display: block;
      }
      .custom-header-logo {
        width: 200px;
        height: 120px;
        margin: 0 auto;
      }
      .custom-icon-logo {
        width: 100px;
        height: 60px;
      }

      /* === corners === */
      .custom-corner-all {
        border: 1px solid #9FD9F2;
        -webkit-border-radius: .375em;
        border-radius: .375em;
      }
      /* === wrapper === */
      .custom-wrapper {
        max-width: 40em; 
        padding: 0 1em;
        -moz-box-sizing: border-box;
        -webkit-box-sizing: border-box;
        box-sizing: border-box;
        display: block;
        margin: 0 auto;
      }
      @media (max-width: 40em) {
        .custom-wrapper {
          max-width: none;
          width: 100%;
        }
      }
      
      /* === description === */
      .custom-description {
        padding: .5em 0;
      }
      .custom-description > span {
        display: inline-block;
        vertical-align: middle;
        text-align: center;
        width: 15%;
        line-height: 90px;
        height: 90px;
      }
      .custom-description .custom-icon {
        color: #24A9E1;
        font-size: 2em;
      }
      .custom-description > .custom-icon-logo {
        width: 35%;
      }
      /* === ipv4/6 info === */
      .custom-description .custom-icon:nth-child(2):after {
        content: "IPv4";
      }
      .custom-description .custom-icon:nth-child(4):after {
        content: "IPv6";
      }
      .custom-description .custom-icon:nth-child(2):after,
      .custom-description .custom-icon:nth-child(4):after {
        display: block;
        line-height: 1em;
        font-family: Arial;
        font-size: .6em;
        margin-top: -32px;
      }
      @media (max-width: 40em) {
        .custom-description > .custom-grandenet-logo {
          background-position: 13px 0px;
          background-size: 9em;
        }
        .custom-description > .custom-grandenet-logo {
          width: 30%;
        }
      }
      /* === button === */
      .btn {
        background-color:#FFC131;
        background-image:-webkit-linear-gradient(left top, #FFC131 42%, #FFB100 70%);
        background-image:linear-gradient(left top, #FFC131 42%, #FFB100 70%);
        display: block;
        text-align: center;
        padding: .5em 0;
        -webkit-border-radius: .375em;
        border-radius: .375em;
        color: black;
        text-decoration: none;
        font-weight: bold;
      }
      .btn:hover {
        background: #FFB100;
        text-decoration: none;
        font-weight: bold;
      }
      .btn:hover {
        background: #FFC131;
        text-decoration: none;
      }
      /* === table === */
      table {
        background: rgba(159,217,242,.15);
        border: 1px solid #24A9E1;
        border-radius: .375em;
        padding: .5em;
        margin-bottom: 1em;
      }
      table th, table td {
        text-align: right;
      }
      table tr td:first-child {
        text-align: left;
      }
      table tr {
        border: 1px solid #24A9E1;
      }
      /* result */
      .table h2 {
        font-weight: normal;
        text-align: center;
      }
      .table p {
        display: inline-block;
        vertical-align: middle;
        max-width: 80%;
      }
      .winner th, .winner td {
        background: #24A9E1;
      }
      @media (max-width: 26em) {
        table {
          padding: 0;
        }
        table tr td, table tr th {
          font-size: .6em;
        }
      }
      /* spinner */
      .custom-icon-spinner {
        margin-right: .25em;
        padding-top: 10px;
        -webkit-animation-name: spin;
        -webkit-animation-duration: 600ms;
        -webkit-animation-iteration-count: infinite;
        -webkit-animation-timing-function: linear;
        animation-name: spin;
        animation-duration: 600ms;
        animation-iteration-count: infinite;
        animation-timing-function: linear;
        font-size: 2em;
        display: inline-block;
        width: auto;
        height: auto;
        vertical-align: middle;
      }
  </style>
  </head>
  <body>
    <div class="custom-wrapper custom-corner-all">
      <header>
        <span class="custom-grandenet-logo custom-header-logo"></span>
      </header>
      <div class="table">
        <span class="custom-icon custom-icon-spinner"></span>
        <p>Testing all possible frontends, please wait...</p>
      </div>
      <div class="custom-description">
        <span class="custom-corner-all custom-icon custom-icon-user"></span>
        <span class="custom-icon custom-icon-forward"></span>
        <span class="custom-corner-all custom-grandenet-logo custom-icon-logo"></span>
        <span class="custom-icon custom-icon-forward"></span>
        <span class="custom-corner-all custom-icon custom-icon-harddrive"></span>
      </div>
      <div class=link></div>
     </div>
   </body>

</html>