pingerchips-js 1.0.0-a

package/src/runtimes/web/dom/sockjs/lib/utils.js

@@ -0,0 +1,297 @@
+/*
+ * ***** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2011-2012 VMware, Inc.
+ *
+ * For the license see COPYING.
+ * ***** END LICENSE BLOCK *****
+ */
+
+var random_string_chars = 'abcdefghijklmnopqrstuvwxyz0123456789_';
+
+utils.random_string = function(length, max) {
+    max = max || random_string_chars.length;
+    var i, ret = [];
+    for(i=0; i < length; i++) {
+        ret.push( random_string_chars.substr(Math.floor(Math.random() * max),1) );
+    }
+    return ret.join('');
+};
+
+utils.random_number = function(max) {
+    return Math.floor(Math.random() * max);
+};
+
+utils.random_number_string = function(max) {
+    var t = (''+(max - 1)).length;
+    var p = Array(t+1).join('0');
+    return (p + utils.random_number(max)).slice(-t);
+};
+
+utils.getOrigin = function(url) {
+    if (url.match(/^file:\/\//)) {
+        // no origin when using file protocol
+        return null;
+    }
+
+    var parts = url.match(/^(https?):\/\/([^\/:]+)(:([0-9]+))?/);
+    var protocol = parts[1];
+    var hostname = parts[2];
+    var port = parts[4];
+
+    if (!port) {
+        port = (protocol === "https") ? 443 : 80;
+    }
+
+    return protocol + "://" + hostname + ":" + port;
+};
+
+utils.isSameOriginUrl = function(url_a, url_b) {
+    // location.origin would do, but it's not always available.
+    if (!url_b) url_b = _window.location.href;
+
+    return utils.getOrigin(url_a) === utils.getOrigin(url_b);
+};
+
+utils.objectExtend = function(dst, src) {
+    for(var k in src) {
+        if (src.hasOwnProperty(k)) {
+            dst[k] = src[k];
+        }
+    }
+    return dst;
+};
+
+var WPrefix = '_jp';
+
+utils.polluteGlobalNamespace = function() {
+    if (!(WPrefix in _window)) {
+        _window[WPrefix] = {};
+    }
+};
+
+utils.closeFrame = function (code, reason) {
+    return 'c'+JSON.stringify([code, reason]);
+};
+
+utils.userSetCode = function (code) {
+    return code === 1000 || (code >= 3000 && code <= 4999);
+};
+
+// See: http://www.erg.abdn.ac.uk/~gerrit/dccp/notes/ccid2/rto_estimator/
+// and RFC 2988.
+utils.countRTO = function (rtt) {
+    var rto;
+    if (rtt > 100) {
+        rto = 3 * rtt; // rto > 300msec
+    } else {
+        rto = rtt + 200; // 200msec < rto <= 300msec
+    }
+    return rto;
+}
+
+utils.log = function() {
+    if (_window.console && console.log && console.log.apply) {
+        console.log.apply(console, arguments);
+    }
+};
+
+utils.bind = function(fun, that) {
+    if (fun.bind) {
+        return fun.bind(that);
+    } else {
+        return function() {
+            return fun.apply(that, arguments);
+        };
+    }
+};
+
+utils.flatUrl = function(url) {
+    return url.indexOf('?') === -1 && url.indexOf('#') === -1;
+};
+
+utils.amendUrl = function(url) {
+    var dl = _document.location;
+    if (!url) {
+        throw new Error('Wrong url for SockJS');
+    }
+    if (!utils.flatUrl(url)) {
+        throw new Error('Only basic urls are supported in SockJS');
+    }
+
+    //  '//abc' --> 'http://abc'
+    if (url.indexOf('//') === 0) {
+        url = dl.protocol + url;
+    }
+    // '/abc' --> 'http://localhost:80/abc'
+    if (url.indexOf('/') === 0) {
+        url = dl.protocol + '//' + dl.host + url;
+    }
+    // strip trailing slashes
+    url = url.replace(/[/]+$/,'');
+    return url;
+};
+
+// IE doesn't support [].indexOf.
+utils.arrIndexOf = function(arr, obj){
+    for(var i=0; i < arr.length; i++){
+        if(arr[i] === obj){
+            return i;
+        }
+    }
+    return -1;
+};
+
+utils.arrSkip = function(arr, obj) {
+    var idx = utils.arrIndexOf(arr, obj);
+    if (idx === -1) {
+        return arr.slice();
+    } else {
+        var dst = arr.slice(0, idx);
+        return dst.concat(arr.slice(idx+1));
+    }
+};
+
+// Via: https://gist.github.com/1133122/2121c601c5549155483f50be3da5305e83b8c5df
+utils.isArray = Array.isArray || function(value) {
+    return {}.toString.call(value).indexOf('Array') >= 0
+};
+
+utils.delay = function(t, fun) {
+    if(typeof t === 'function') {
+        fun = t;
+        t = 0;
+    }
+    return setTimeout(fun, t);
+};
+
+
+// Chars worth escaping, as defined by Douglas Crockford:
+//   https://github.com/douglascrockford/JSON-js/blob/47a9882cddeb1e8529e07af9736218075372b8ac/json2.js#L196
+var json_escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+    json_lookup = {
+"\u0000":"\\u0000","\u0001":"\\u0001","\u0002":"\\u0002","\u0003":"\\u0003",
+"\u0004":"\\u0004","\u0005":"\\u0005","\u0006":"\\u0006","\u0007":"\\u0007",
+"\b":"\\b","\t":"\\t","\n":"\\n","\u000b":"\\u000b","\f":"\\f","\r":"\\r",
+"\u000e":"\\u000e","\u000f":"\\u000f","\u0010":"\\u0010","\u0011":"\\u0011",
+"\u0012":"\\u0012","\u0013":"\\u0013","\u0014":"\\u0014","\u0015":"\\u0015",
+"\u0016":"\\u0016","\u0017":"\\u0017","\u0018":"\\u0018","\u0019":"\\u0019",
+"\u001a":"\\u001a","\u001b":"\\u001b","\u001c":"\\u001c","\u001d":"\\u001d",
+"\u001e":"\\u001e","\u001f":"\\u001f","\"":"\\\"","\\":"\\\\",
+"\u007f":"\\u007f","\u0080":"\\u0080","\u0081":"\\u0081","\u0082":"\\u0082",
+"\u0083":"\\u0083","\u0084":"\\u0084","\u0085":"\\u0085","\u0086":"\\u0086",
+"\u0087":"\\u0087","\u0088":"\\u0088","\u0089":"\\u0089","\u008a":"\\u008a",
+"\u008b":"\\u008b","\u008c":"\\u008c","\u008d":"\\u008d","\u008e":"\\u008e",
+"\u008f":"\\u008f","\u0090":"\\u0090","\u0091":"\\u0091","\u0092":"\\u0092",
+"\u0093":"\\u0093","\u0094":"\\u0094","\u0095":"\\u0095","\u0096":"\\u0096",
+"\u0097":"\\u0097","\u0098":"\\u0098","\u0099":"\\u0099","\u009a":"\\u009a",
+"\u009b":"\\u009b","\u009c":"\\u009c","\u009d":"\\u009d","\u009e":"\\u009e",
+"\u009f":"\\u009f","\u00ad":"\\u00ad","\u0600":"\\u0600","\u0601":"\\u0601",
+"\u0602":"\\u0602","\u0603":"\\u0603","\u0604":"\\u0604","\u070f":"\\u070f",
+"\u17b4":"\\u17b4","\u17b5":"\\u17b5","\u200c":"\\u200c","\u200d":"\\u200d",
+"\u200e":"\\u200e","\u200f":"\\u200f","\u2028":"\\u2028","\u2029":"\\u2029",
+"\u202a":"\\u202a","\u202b":"\\u202b","\u202c":"\\u202c","\u202d":"\\u202d",
+"\u202e":"\\u202e","\u202f":"\\u202f","\u2060":"\\u2060","\u2061":"\\u2061",
+"\u2062":"\\u2062","\u2063":"\\u2063","\u2064":"\\u2064","\u2065":"\\u2065",
+"\u2066":"\\u2066","\u2067":"\\u2067","\u2068":"\\u2068","\u2069":"\\u2069",
+"\u206a":"\\u206a","\u206b":"\\u206b","\u206c":"\\u206c","\u206d":"\\u206d",
+"\u206e":"\\u206e","\u206f":"\\u206f","\ufeff":"\\ufeff","\ufff0":"\\ufff0",
+"\ufff1":"\\ufff1","\ufff2":"\\ufff2","\ufff3":"\\ufff3","\ufff4":"\\ufff4",
+"\ufff5":"\\ufff5","\ufff6":"\\ufff6","\ufff7":"\\ufff7","\ufff8":"\\ufff8",
+"\ufff9":"\\ufff9","\ufffa":"\\ufffa","\ufffb":"\\ufffb","\ufffc":"\\ufffc",
+"\ufffd":"\\ufffd","\ufffe":"\\ufffe","\uffff":"\\uffff"};
+
+// Some extra characters that Chrome gets wrong, and substitutes with
+// something else on the wire.
+var extra_escapable = /[\x00-\x1f\ud800-\udfff\ufffe\uffff\u0300-\u0333\u033d-\u0346\u034a-\u034c\u0350-\u0352\u0357-\u0358\u035c-\u0362\u0374\u037e\u0387\u0591-\u05af\u05c4\u0610-\u0617\u0653-\u0654\u0657-\u065b\u065d-\u065e\u06df-\u06e2\u06eb-\u06ec\u0730\u0732-\u0733\u0735-\u0736\u073a\u073d\u073f-\u0741\u0743\u0745\u0747\u07eb-\u07f1\u0951\u0958-\u095f\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b5c-\u0b5d\u0e38-\u0e39\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f72-\u0f76\u0f78\u0f80-\u0f83\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1939-\u193a\u1a17\u1b6b\u1cda-\u1cdb\u1dc0-\u1dcf\u1dfc\u1dfe\u1f71\u1f73\u1f75\u1f77\u1f79\u1f7b\u1f7d\u1fbb\u1fbe\u1fc9\u1fcb\u1fd3\u1fdb\u1fe3\u1feb\u1fee-\u1fef\u1ff9\u1ffb\u1ffd\u2000-\u2001\u20d0-\u20d1\u20d4-\u20d7\u20e7-\u20e9\u2126\u212a-\u212b\u2329-\u232a\u2adc\u302b-\u302c\uaab2-\uaab3\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa2d\ufa30-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4e\ufff0-\uffff]/g,
+    extra_lookup;
+
+// JSON Quote string. Use native implementation when possible.
+var JSONQuote = (JSON && JSON.stringify) || function(string) {
+    json_escapable.lastIndex = 0;
+    if (json_escapable.test(string)) {
+        string = string.replace(json_escapable, function(a) {
+            return json_lookup[a];
+        });
+    }
+    return '"' + string + '"';
+};
+
+// This may be quite slow, so let's delay until user actually uses bad
+// characters.
+var unroll_lookup = function(escapable) {
+    var i;
+    var unrolled = {}
+    var c = []
+    for(i=0; i<65536; i++) {
+        c.push( String.fromCharCode(i) );
+    }
+    escapable.lastIndex = 0;
+    c.join('').replace(escapable, function (a) {
+        unrolled[ a ] = '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+        return '';
+    });
+    escapable.lastIndex = 0;
+    return unrolled;
+};
+
+// Quote string, also taking care of unicode characters that browsers
+// often break. Especially, take care of unicode surrogates:
+//    http://en.wikipedia.org/wiki/Mapping_of_Unicode_characters#Surrogates
+utils.quote = function(string) {
+    var quoted = JSONQuote(string);
+
+    // In most cases this should be very fast and good enough.
+    extra_escapable.lastIndex = 0;
+    if(!extra_escapable.test(quoted)) {
+        return quoted;
+    }
+
+    if(!extra_lookup) extra_lookup = unroll_lookup(extra_escapable);
+
+    return quoted.replace(extra_escapable, function(a) {
+        return extra_lookup[a];
+    });
+}
+
+var _all_protocols = [
+    'iframe-eventsource',
+    'iframe-htmlfile',
+    'iframe-xhr-polling',
+    'jsonp-polling'
+];
+
+utils.probeProtocols = function(url) {
+    var probed = {};
+    for(var i=0; i<_all_protocols.length; i++) {
+        var protocol = _all_protocols[i];
+        // User can have a typo in protocol name.
+        probed[protocol] = SockJS[protocol] &&
+                           SockJS[protocol].enabled(url);
+    }
+    return probed;
+};
+
+utils.detectProtocols = function(protocols_probed, protocols_whitelist, info) {
+    protocols_whitelist = protocols_whitelist || _all_protocols;
+
+    var protocols = [];
+    for (var i = 0; i < protocols_whitelist.length; i++) {
+        var protocol = protocols_whitelist[i];
+        if (protocols_probed[protocol]) {
+            protocols.push(protocol);
+        }
+    }
+    return protocols;
+}
+
+utils.defaultOptions = function(){
+    return {
+        devel: false,
+        debug: false,
+        protocols_whitelist: [],
+        info: undefined,
+        rtt: undefined,
+        max_window_time: 4000,
+        init_window_size: 4096
+    };
+}

package/src/runtimes/web/dom/sockjs/package.json

@@ -0,0 +1,18 @@
+{
+	"name"        : "sockjs-client",
+	"author"      : "Marek Majkowski",
+    "version"     : "0.0.0-unreleasable",
+    "description" : "SockJS-client is a browser JavaScript library that provides a WebSocket-like object. SockJS gives you a coherent, cross-browser, Javascript API which creates a low latency, full duplex, cross-domain communication channel between the browser and the web server.",
+    "keywords"    : ["websockets", "websocket"],
+    "homepage"    : "http://sockjs.org",
+
+    "repository": {"type" : "git",
+                   "url" : "https://github.com/sockjs/sockjs-client.git"},
+    "devDependencies": {
+        "uglify-js"     : "1.2.5",
+        "coffee-script" : "1.2.x",
+        "optparse"      : "1.0.3",
+        "node-static"   : "0.5.9"
+    },
+    "main": "sockjs.js"
+}

package/src/runtimes/web/dom/sockjs/version

@@ -0,0 +1 @@
+0.3.4

package/src/runtimes/web/http/http.ts

@@ -0,0 +1,8 @@
+import xdrHooks from './http_xdomain_request';
+import HTTP from 'isomorphic/http/http';
+
+HTTP.createXDR = function(method, url) {
+  return this.createRequest(xdrHooks, method, url);
+};
+
+export default HTTP;

package/src/runtimes/web/http/http_xdomain_request.ts

@@ -0,0 +1,37 @@
+import HTTPRequest from 'core/http/http_request';
+import RequestHooks from 'core/http/request_hooks';
+import Ajax from 'core/http/ajax';
+import * as Errors from 'core/errors';
+
+var hooks: RequestHooks = {
+  getRequest: function(socket: HTTPRequest): Ajax {
+    var xdr = new (<any>window).XDomainRequest();
+    xdr.ontimeout = function() {
+      socket.emit('error', new Errors.RequestTimedOut());
+      socket.close();
+    };
+    xdr.onerror = function(e) {
+      socket.emit('error', e);
+      socket.close();
+    };
+    xdr.onprogress = function() {
+      if (xdr.responseText && xdr.responseText.length > 0) {
+        socket.onChunk(200, xdr.responseText);
+      }
+    };
+    xdr.onload = function() {
+      if (xdr.responseText && xdr.responseText.length > 0) {
+        socket.onChunk(200, xdr.responseText);
+      }
+      socket.emit('finished', 200);
+      socket.close();
+    };
+    return xdr;
+  },
+  abortRequest: function(xdr: Ajax) {
+    xdr.ontimeout = xdr.onerror = xdr.onprogress = xdr.onload = null;
+    xdr.abort();
+  }
+};
+
+export default hooks;

package/src/runtimes/web/net_info.ts

@@ -0,0 +1,50 @@
+import Reachability from 'core/reachability';
+import { default as EventsDispatcher } from 'core/events/dispatcher';
+
+/** Really basic interface providing network availability info.
+ *
+ * Emits:
+ * - online - when browser goes online
+ * - offline - when browser goes offline
+ */
+export class NetInfo extends EventsDispatcher implements Reachability {
+  constructor() {
+    super();
+    var self = this;
+    // This is okay, as IE doesn't support this stuff anyway.
+    if (window.addEventListener !== undefined) {
+      window.addEventListener(
+        'online',
+        function() {
+          self.emit('online');
+        },
+        false
+      );
+      window.addEventListener(
+        'offline',
+        function() {
+          self.emit('offline');
+        },
+        false
+      );
+    }
+  }
+
+  /** Returns whether browser is online or not
+   *
+   * Offline means definitely offline (no connection to router).
+   * Inverse does NOT mean definitely online (only currently supported in Safari
+   * and even there only means the device has a connection to the router).
+   *
+   * @return {Boolean}
+   */
+  isOnline(): boolean {
+    if (window.navigator.onLine === undefined) {
+      return true;
+    } else {
+      return window.navigator.onLine;
+    }
+  }
+}
+
+export var Network = new NetInfo();

package/src/runtimes/web/runtime.ts

@@ -0,0 +1,174 @@
+import Browser from './browser';
+import { Dependencies, DependenciesReceivers } from './dom/dependencies';
+import { AuthTransport, AuthTransports } from 'core/auth/auth_transports';
+import xhrAuth from 'isomorphic/auth/xhr_auth';
+import jsonpAuth from './auth/jsonp_auth';
+import TimelineTransport from 'core/timeline/timeline_transport';
+import TimelineSender from 'core/timeline/timeline_sender';
+import ScriptRequest from './dom/script_request';
+import JSONPRequest from './dom/jsonp_request';
+import * as Collections from 'core/utils/collections';
+import { ScriptReceivers } from './dom/script_receiver_factory';
+import jsonpTimeline from './timeline/jsonp_timeline';
+import Transports from './transports/transports';
+import Ajax from 'core/http/ajax';
+import { Network } from './net_info';
+import getDefaultStrategy from './default_strategy';
+import transportConnectionInitializer from './transports/transport_connection_initializer';
+import HTTPFactory from './http/http';
+import HTTPRequest from 'core/http/http_request';
+
+var Runtime: Browser = {
+  // for jsonp auth
+  nextAuthCallbackID: 1,
+  auth_callbacks: {},
+  ScriptReceivers,
+  DependenciesReceivers,
+  getDefaultStrategy,
+  Transports,
+  transportConnectionInitializer,
+  HTTPFactory,
+
+  TimelineTransport: jsonpTimeline,
+
+  getXHRAPI() {
+    return window.XMLHttpRequest;
+  },
+
+  getWebSocketAPI() {
+    return window.WebSocket || window.MozWebSocket;
+  },
+
+  setup(PusherClass): void {
+    (<any>window).Pusher = PusherClass; // JSONp requires Pusher to be in the global scope.
+    var initializeOnDocumentBody = () => {
+      this.onDocumentBody(PusherClass.ready);
+    };
+    if (!(<any>window).JSON) {
+      Dependencies.load('json2', {}, initializeOnDocumentBody);
+    } else {
+      initializeOnDocumentBody();
+    }
+  },
+
+  getDocument(): Document {
+    return document;
+  },
+
+  getProtocol(): string {
+    return this.getDocument().location.protocol;
+  },
+
+  getAuthorizers(): AuthTransports {
+    return { ajax: xhrAuth, jsonp: jsonpAuth };
+  },
+
+  onDocumentBody(callback: Function) {
+    if (document.body) {
+      callback();
+    } else {
+      setTimeout(() => {
+        this.onDocumentBody(callback);
+      }, 0);
+    }
+  },
+
+  createJSONPRequest(url: string, data: any): JSONPRequest {
+    return new JSONPRequest(url, data);
+  },
+
+  createScriptRequest(src: string): ScriptRequest {
+    return new ScriptRequest(src);
+  },
+
+  getLocalStorage() {
+    try {
+      return window.localStorage;
+    } catch (e) {
+      return undefined;
+    }
+  },
+
+  createXHR(): Ajax {
+    if (this.getXHRAPI()) {
+      return this.createXMLHttpRequest();
+    } else {
+      return this.createMicrosoftXHR();
+    }
+  },
+
+  createXMLHttpRequest(): Ajax {
+    var Constructor = this.getXHRAPI();
+    return new Constructor();
+  },
+
+  createMicrosoftXHR(): Ajax {
+    return new ActiveXObject('Microsoft.XMLHTTP');
+  },
+
+  getNetwork() {
+    return Network;
+  },
+
+  createWebSocket(url: string): any {
+    var Constructor = this.getWebSocketAPI();
+    return new Constructor(url);
+  },
+
+  createSocketRequest(method: string, url: string): HTTPRequest {
+    if (this.isXHRSupported()) {
+      return this.HTTPFactory.createXHR(method, url);
+    } else if (this.isXDRSupported(url.indexOf('https:') === 0)) {
+      return this.HTTPFactory.createXDR(method, url);
+    } else {
+      throw 'Cross-origin HTTP requests are not supported';
+    }
+  },
+
+  isXHRSupported(): boolean {
+    var Constructor = this.getXHRAPI();
+    return (
+      Boolean(Constructor) && new Constructor().withCredentials !== undefined
+    );
+  },
+
+  isXDRSupported(useTLS?: boolean): boolean {
+    var protocol = useTLS ? 'https:' : 'http:';
+    var documentProtocol = this.getProtocol();
+    return (
+      Boolean(<any>window['XDomainRequest']) && documentProtocol === protocol
+    );
+  },
+
+  addUnloadListener(listener: any) {
+    if (window.addEventListener !== undefined) {
+      window.addEventListener('unload', listener, false);
+    } else if (window.attachEvent !== undefined) {
+      window.attachEvent('onunload', listener);
+    }
+  },
+
+  removeUnloadListener(listener: any) {
+    if (window.addEventListener !== undefined) {
+      window.removeEventListener('unload', listener, false);
+    } else if (window.detachEvent !== undefined) {
+      window.detachEvent('onunload', listener);
+    }
+  },
+
+  randomInt(max: number): number {
+    /**
+     * Return values in the range of [0, 1[
+     */
+    const random = function() {
+      const crypto = window.crypto || window['msCrypto'];
+      const random = crypto.getRandomValues(new Uint32Array(1))[0];
+
+      return random / 2 ** 32;
+    };
+
+    return Math.floor(random() * max);
+  }
+};
+
+export default Runtime;

package/src/runtimes/web/timeline/jsonp_timeline.ts

@@ -0,0 +1,34 @@
+import TimelineSender from 'core/timeline/timeline_sender';
+import TimelineTransport from 'core/timeline/timeline_transport';
+import Browser from 'runtime';
+import { AuthTransport } from 'core/auth/auth_transports';
+import { ScriptReceivers } from '../dom/script_receiver_factory';
+
+var getAgent = function(sender: TimelineSender, useTLS: boolean) {
+  return function(data: any, callback: Function) {
+    var scheme = 'http' + (useTLS ? 's' : '') + '://';
+    var url =
+      scheme + (sender.host || sender.options.host) + sender.options.path;
+    var request = Browser.createJSONPRequest(url, data);
+
+    var receiver = Browser.ScriptReceivers.create(function(error, result) {
+      ScriptReceivers.remove(receiver);
+      request.cleanup();
+
+      if (result && result.host) {
+        sender.host = result.host;
+      }
+      if (callback) {
+        callback(error, result);
+      }
+    });
+    request.send(receiver);
+  };
+};
+
+var jsonp = {
+  name: 'jsonp',
+  getAgent
+};
+
+export default jsonp;

package/src/runtimes/web/transports/transport_connection_initializer.ts

@@ -0,0 +1,39 @@
+import { Dependencies } from '../dom/dependencies';
+
+/** Initializes the transport.
+ *
+ * Fetches resources if needed and then transitions to initialized.
+ */
+export default function() {
+  var self = this;
+
+  self.timeline.info(
+    self.buildTimelineMessage({
+      transport: self.name + (self.options.useTLS ? 's' : '')
+    })
+  );
+
+  if (self.hooks.isInitialized()) {
+    self.changeState('initialized');
+  } else if (self.hooks.file) {
+    self.changeState('initializing');
+    Dependencies.load(
+      self.hooks.file,
+      { useTLS: self.options.useTLS },
+      function(error, callback) {
+        if (self.hooks.isInitialized()) {
+          self.changeState('initialized');
+          callback(true);
+        } else {
+          if (error) {
+            self.onError(error);
+          }
+          self.onClose();
+          callback(false);
+        }
+      }
+    );
+  } else {
+    self.onClose();
+  }
+}