Added logging, changed some directory structure

goTorrentWebUI/node_modules/react-scripts/node_modules/handle-thing/.npmignore

@@ -0,0 +1,2 @@
+node_modules/
+npm-debug.log

goTorrentWebUI/node_modules/react-scripts/node_modules/handle-thing/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - "0.10"
+  - "0.12"
+  - "iojs"

goTorrentWebUI/node_modules/react-scripts/node_modules/handle-thing/README.md

@@ -0,0 +1,31 @@
+# Handle Thing
+
+[![Build Status](https://secure.travis-ci.org/indutny/handle-thing.png)](http://travis-ci.org/indutny/handle-thing)
+[![NPM version](https://badge.fury.io/js/handle-thing.svg)](http://badge.fury.io/js/handle-thing)
+
+The right thing when you need it
+
+## LICENSE
+
+This software is licensed under the MIT License.
+
+Copyright Fedor Indutny, 2015.
+
+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.

goTorrentWebUI/node_modules/react-scripts/node_modules/handle-thing/lib/handle.js

@@ -0,0 +1,437 @@
+var assert = require('assert');
+var util = require('util');
+
+var EventEmitter = require('events').EventEmitter;
+var Buffer = require('buffer').Buffer;
+
+var Queue = require('./queue');
+
+// Node.js version
+var mode = /^v0\.8\./.test(process.version) ? 'rusty' :
+           /^v0\.(9|10)\./.test(process.version) ? 'old' :
+           'modern';
+
+function Handle(stream, options) {
+  EventEmitter.call(this);
+
+  this._stream = stream;
+  this._flowing = false;
+  this._reading = false;
+  this._options = options || {};
+
+  this.onread = null;
+
+  // Pending requests
+  this.pending = new Queue();
+
+  // Start handle once `onread` is set
+  if (mode === 'rusty') {
+    var self = this;
+    Object.defineProperty(this, 'onread', {
+      set: function(value) {
+        Object.defineProperty(self, 'onread', {
+          value: value
+        });
+        process.nextTick(function() {
+          self.readStart();
+        });
+      }
+    });
+  }
+
+  // NOTE: v0.8 has some odd .pause()/.resume() semantics in http.js
+  if (mode === 'rusty')
+    this.writeQueueSize = 0;
+  else if (mode !== 'modern')
+    this.writeQueueSize = 1;
+
+  if (mode === 'rusty') {
+    if (this._stream)
+      this._rustyInit();
+    else
+      this.once('stream', this._rustyInit);
+  }
+}
+util.inherits(Handle, EventEmitter);
+module.exports = Handle;
+
+Handle.mode = mode;
+
+Handle.create = function create(stream, options) {
+  return new Handle(stream, options);
+};
+
+Handle.prototype._queueReq = function _queueReq(type, req) {
+  return this.pending.append(type, req);
+};
+
+Handle.prototype._pendingList = function _pendingList() {
+  var list = [];
+  while (!this.pending.isEmpty())
+    list.push(this.pending.first().dequeue());
+  return list;
+};
+
+Handle.prototype.setStream = function setStream(stream) {
+  assert(this._stream === null, 'Can\'t set stream two times');
+  this._stream = stream;
+
+  this.emit('stream', stream);
+};
+
+Handle.prototype.readStart = function readStart() {
+  this._reading = true;
+
+  if (!this._stream) {
+    this.once('stream', this.readStart);
+    return 0;
+  }
+
+  if (!this._flowing) {
+    this._flowing = true;
+    this._flow();
+  }
+
+  this._stream.resume();
+  return 0;
+};
+
+Handle.prototype.readStop = function readStop() {
+  this._reading = false;
+
+  if (!this._stream) {
+    this.once('stream', this.readStop);
+    return 0;
+  }
+  this._stream.pause();
+  return 0;
+};
+
+if (mode === 'modern') {
+  var uv = process.binding('uv');
+
+  Handle.prototype._flow = function flow() {
+    var self = this;
+    this._stream.on('data', function(chunk) {
+      self.onread(chunk.length, chunk);
+    });
+
+    this._stream.on('end', function() {
+      self.onread(uv.UV_EOF, new Buffer(0));
+    });
+
+    this._stream.on('close', function() {
+      setImmediate(function() {
+        if (self._reading)
+          self.onread(uv.UV_ECONNRESET, new Buffer(0));
+      });
+    });
+  };
+
+  Handle.prototype._close = function _close() {
+    var list = this._pendingList();
+
+    var self = this;
+    setImmediate(function() {
+      for (var i = 0; i < list.length; i++) {
+        var req = list[i];
+        req.oncomplete(uv.UV_ECANCELED, self, req);
+      }
+    });
+
+    this.readStop();
+  };
+} else if (mode === 'old') {
+  Handle.prototype._flow = function flow() {
+    var self = this;
+    this._stream.on('data', function(chunk) {
+      self.onread(chunk, 0, chunk.length);
+    });
+
+    this._stream.on('end', function() {
+      var errno = process._errno;
+      process._errno = 'EOF';
+      self.onread(null, 0, 0);
+      if (process._errno === 'EOF')
+        process._errno = errno;
+    });
+
+    this._stream.on('close', function() {
+      setImmediate(function() {
+        if (!self._reading)
+          return;
+
+        var errno = process._errno;
+        process._errno = 'ECONNRESET';
+        self.onread(null, 0, 0);
+        if (process._errno === 'ECONNRESET')
+          process._errno = errno;
+      });
+    });
+  };
+
+  Handle.prototype._close = function _close() {
+    var list = this._pendingList();
+
+    var self = this;
+    setImmediate(function() {
+      for (var i = 0; i < list.length; i++) {
+        process._errno = 'CANCELED';
+        var req = list[i];
+        req.oncomplete(-1, self, req);
+      }
+    });
+
+    this.readStop();
+  };
+} else {
+  Handle.prototype._rustyInit = function _rustyInit() {
+    var self = this;
+
+    this._stream.on('close', function() {
+      process.nextTick(function() {
+        if (!self._reading)
+          return;
+
+        var errno = global.errno;
+        global.errno = 'ECONNRESET';
+        self.onread(null, 0, 0);
+        if (global.errno === 'ECONNRESET')
+          global.errno = errno;
+      });
+    });
+  };
+
+  Handle.prototype._flow = function flow() {
+    var self = this;
+    this._stream.on('data', function(chunk) {
+      self.onread(chunk, 0, chunk.length);
+    });
+
+    this._stream.on('end', function() {
+      var errno = global.errno;
+      global.errno = 'EOF';
+      self.onread(null, 0, 0);
+      if (global.errno === 'EOF')
+        global.errno = errno;
+    });
+  };
+
+  Handle.prototype._close = function _close() {
+    var list = this._pendingList();
+
+    var self = this;
+    process.nextTick(function() {
+      for (var i = 0; i < list.length; i++) {
+        var req = list[i];
+        global.errno = 'CANCELED';
+        req.oncomplete(-1, self, req);
+      }
+    });
+
+    this.readStop();
+  };
+}
+
+if (mode === 'modern') {
+  Handle.prototype.shutdown = function shutdown(req) {
+    var wrap = this._queueReq('shutdown', req);
+
+    if (!this._stream) {
+      this.once('stream', function() {
+        this._shutdown(wrap);
+      });
+      return 0;
+    }
+
+    return this._shutdown(wrap);
+  };
+
+  Handle.prototype._shutdown = function _shutdown(wrap) {
+    var self = this;
+    this._stream.end(function() {
+      var req = wrap.dequeue();
+      if (!req)
+        return;
+
+      req.oncomplete(0, self, req);
+    });
+    return 0;
+  };
+} else {
+  Handle.prototype.shutdown = function shutdown(req) {
+    if (!req)
+      req = {};
+
+    var wrap = this._queueReq('shutdown', req);
+
+    if (!this._stream) {
+      this.once('stream', function() {
+        this._shutdown(wrap);
+      });
+      return req;
+    }
+
+    this._shutdown(wrap);
+
+    return req;
+  };
+
+  Handle.prototype._shutdown = function _shutdown(wrap) {
+    var self = this;
+    this._stream.end(function() {
+      var req = wrap.dequeue();
+      if (!req)
+        return;
+      req.oncomplete(0, self, req);
+    });
+  };
+}
+
+if (mode !== 'rusty') {
+  Handle.prototype.close = function close(callback) {
+    this._close();
+
+    if (!this._stream) {
+      this.once('stream', function() {
+        this.close(callback);
+      });
+      return 0;
+    }
+
+    if (this._options.close)
+      this._options.close(callback);
+    else
+      process.nextTick(callback);
+
+    return 0;
+  };
+} else {
+  Handle.prototype.close = function close() {
+    this._close();
+
+    if (!this._stream)
+      this.once('stream', this.close);
+    else if (this._options.close)
+      this._options.close(function() {});
+
+    return 0;
+  };
+}
+
+if (mode === 'modern') {
+  Handle.prototype.writeEnc = function writeEnc(req, data, enc) {
+    var wrap = this._queueReq('write', req);
+
+    if (!this._stream) {
+      this.once('stream', function() {
+        this._writeEnc(wrap, req, data, enc);
+      });
+
+      return 0;
+    }
+
+    return this._writeEnc(wrap, req, data, enc);
+  };
+
+  Handle.prototype._writeEnc = function _writeEnc(wrap, req, data, enc) {
+    var self = this;
+
+    req.async = true;
+    req.bytes = data.length;
+
+    if (wrap.isEmpty())
+      return 0;
+
+    this._stream.write(data, enc, function() {
+      var req = wrap.dequeue();
+      if (!req)
+        return;
+      req.oncomplete(0, self, req);
+    });
+
+    return 0;
+  };
+} else {
+  Handle.prototype.writeEnc = function writeEnc(data, ignored, enc, req) {
+    if (!req)
+      req = { bytes: data.length };
+
+    var wrap = this._queueReq('write', req);
+
+    if (!this._stream) {
+      this.once('stream', function() {
+        this._writeEnc(data, ignored, enc, wrap);
+      });
+      return req;
+    }
+
+    this._writeEnc(data, ignored, enc, wrap);
+    return req;
+  };
+
+  Handle.prototype._writeEnc = function _writeEnc(data, ignored, enc, wrap) {
+    var self = this;
+    var buffer = new Buffer(data, enc);
+
+    if (wrap.isEmpty())
+      return;
+
+    this._stream.write(buffer, function() {
+      var req = wrap.dequeue();
+      if (!req)
+        return;
+      req.oncomplete(0, self, req);
+    });
+  };
+}
+
+Handle.prototype.writeBuffer = function writeBuffer(req, data) {
+  return this.writeEnc(req, data, null);
+};
+
+Handle.prototype.writeAsciiString = function writeAsciiString(req, data) {
+  return this.writeEnc(req, data, 'ascii');
+};
+
+Handle.prototype.writeUtf8String = function writeUtf8String(req, data) {
+  return this.writeEnc(req, data, 'utf8');
+};
+
+Handle.prototype.writeUcs2String = function writeUcs2String(req, data) {
+  return this.writeEnc(req, data, 'ucs2');
+};
+
+Handle.prototype.writeBinaryString = function writeBinaryString(req, data) {
+  return this.writeEnc(req, data, 'binary');
+};
+
+Handle.prototype.writeLatin1String = function writeLatin1String(req, data) {
+  return this.writeEnc(req, data, 'binary');
+};
+
+// v0.8
+Handle.prototype.getsockname = function getsockname() {
+  if (this._options.getPeerName)
+    return this._options.getPeerName();
+  return null;
+};
+
+if (mode === 'modern') {
+  Handle.prototype.getpeername = function getpeername(out) {
+    var res = this.getsockname();
+    if (!res)
+      return -1;
+
+    Object.keys(res).forEach(function(key) {
+      out[key] = res[key];
+    });
+
+    return 0;
+  };
+} else {
+  // v0.10
+  Handle.prototype.getpeername = function getpeername() {
+    return this.getsockname();
+  };
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/handle-thing/lib/queue.js

@@ -0,0 +1,48 @@
+function Queue() {
+  this.head = new Item('head', null);
+}
+module.exports = Queue;
+
+Queue.prototype.append = function append(kind, value) {
+  var item = new Item(kind, value);
+  this.head.prepend(item);
+  return item;
+};
+
+Queue.prototype.isEmpty = function isEmpty() {
+  return this.head.prev === this.head;
+};
+
+Queue.prototype.first = function first() {
+  return this.head.next;
+};
+
+function Item(kind, value) {
+  this.prev = this;
+  this.next = this;
+  this.kind = kind;
+  this.value = value;
+}
+
+Item.prototype.prepend = function prepend(other) {
+  other.prev = this.prev;
+  other.next = this;
+  other.prev.next = other;
+  other.next.prev = other;
+};
+
+Item.prototype.dequeue = function dequeue() {
+  var prev = this.prev;
+  var next = this.next;
+
+  prev.next = next;
+  next.prev = prev;
+  this.prev = this;
+  this.next = this;
+
+  return this.value;
+};
+
+Item.prototype.isEmpty = function isEmpty() {
+  return this.prev === this;
+};

goTorrentWebUI/node_modules/react-scripts/node_modules/handle-thing/package.json

@@ -0,0 +1,60 @@
+{
+  "_args": [
+    [
+      "handle-thing@1.2.5",
+      "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project"
+    ]
+  ],
+  "_from": "handle-thing@1.2.5",
+  "_id": "handle-thing@1.2.5",
+  "_inBundle": false,
+  "_integrity": "sha1-/Xqtcmvxpf0W38KbL3pmAdJxOcQ=",
+  "_location": "/react-scripts/handle-thing",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "handle-thing@1.2.5",
+    "name": "handle-thing",
+    "escapedName": "handle-thing",
+    "rawSpec": "1.2.5",
+    "saveSpec": null,
+    "fetchSpec": "1.2.5"
+  },
+  "_requiredBy": [
+    "/react-scripts/spdy"
+  ],
+  "_resolved": "https://registry.npmjs.org/handle-thing/-/handle-thing-1.2.5.tgz",
+  "_spec": "1.2.5",
+  "_where": "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project",
+  "author": {
+    "name": "Fedor Indutny",
+    "email": "fedor@indutny.com"
+  },
+  "bugs": {
+    "url": "https://github.com/indutny/handle-thing/issues"
+  },
+  "description": "Wrap Streams2 instance into a HandleWrap",
+  "devDependencies": {
+    "mocha": "^2.2.5",
+    "readable-stream": "^2.0.1",
+    "stream-pair": "^1.0.0"
+  },
+  "homepage": "https://github.com/indutny/handle-thing#readme",
+  "keywords": [
+    "handle",
+    "net",
+    "streams2"
+  ],
+  "license": "MIT",
+  "main": "lib/handle.js",
+  "name": "handle-thing",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/indutny/handle-thing.git"
+  },
+  "scripts": {
+    "test": "mocha --reporter=spec test/*-test.js"
+  },
+  "version": "1.2.5"
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/handle-thing/test/api-test.js

@@ -0,0 +1,116 @@
+var assert = require('assert');
+var net = require('net');
+var streamPair = require('stream-pair');
+
+var thing = require('../');
+
+describe('Handle Thing', function() {
+  var handle;
+  var pair;
+  var socket;
+
+  [ 'normal', 'lazy' ].forEach(function(mode) {
+    describe(mode, function() {
+      beforeEach(function() {
+        pair = streamPair.create();
+        handle = thing.create(mode === 'normal' ? pair.other : null);
+        socket = new net.Socket({ handle: handle });
+
+        if (mode === 'lazy') {
+          setTimeout(function() {
+            handle.setStream(pair.other);
+          }, 50);
+        }
+
+        // For v0.8
+        socket.readable = true;
+        socket.writable = true;
+      });
+
+      afterEach(function() {
+        assert(handle._stream);
+      });
+
+      it('should write data to Socket', function(done) {
+        pair.write('hello');
+        pair.write(' world');
+        pair.end('... ok');
+
+        var chunks = '';
+        socket.on('data', function(chunk) {
+          chunks += chunk;
+        });
+        socket.on('end', function() {
+          assert.equal(chunks, 'hello world... ok');
+
+          // allowHalfOpen is `false`, so the `end` should be followed by `close`
+          socket.once('close', function() {
+            done();
+          });
+        });
+      });
+
+      it('should read data from Socket', function(done) {
+        socket.write('hello');
+        socket.write(' world');
+        socket.end('... ok');
+
+        var chunks = '';
+        pair.on('data', function(chunk) {
+          chunks += chunk;
+        });
+        pair.on('end', function() {
+          assert.equal(chunks, 'hello world... ok');
+
+          done();
+        });
+      });
+
+      it('should invoke `close` callback', function(done) {
+        handle._options.close = function(callback) {
+          done();
+          process.nextTick(callback);
+        };
+
+        pair.end('hello');
+        socket.resume();
+      });
+
+      it('should kill pending requests', function(done) {
+        handle._options.close = function() {
+          setTimeout(done, 75);
+        };
+
+        socket.write('hello');
+        socket.destroy();
+      });
+
+      if (mode === 'normal') {
+        it('should invoke `getPeerName` callback', function() {
+          handle._options.getPeerName = function() {
+            return { address: 'ohai' };
+          };
+
+          assert.equal(socket.remoteAddress, 'ohai');
+        });
+
+        it('should emit ECONNRESET at `close` event', function(done) {
+          pair.other.emit('close');
+
+          // No error emitted in v0.8
+          if (thing.mode === 'rusty') {
+            socket.on('close', function() {
+              done();
+            });
+            return;
+          }
+
+          socket.on('error', function(err) {
+            assert(/ECONNRESET/.test(err.message));
+            done();
+          });
+        });
+      }
+    });
+  });
+});