mirror of
https://github.com/aspnet/JavaScriptServices.git
synced 2025-12-23 01:58:29 +00:00
447 lines
19 KiB
JavaScript
447 lines
19 KiB
JavaScript
(function(e, a) { for(var i in a) e[i] = a[i]; }(exports, /******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId])
|
|
/******/ return installedModules[moduleId].exports;
|
|
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ exports: {},
|
|
/******/ id: moduleId,
|
|
/******/ loaded: false
|
|
/******/ };
|
|
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.loaded = true;
|
|
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
|
|
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "";
|
|
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(0);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
module.exports = __webpack_require__(7);
|
|
|
|
|
|
/***/ },
|
|
/* 1 */,
|
|
/* 2 */,
|
|
/* 3 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("path");
|
|
|
|
/***/ },
|
|
/* 4 */
|
|
/***/ function(module, exports) {
|
|
|
|
"use strict";
|
|
function parseArgs(args) {
|
|
// Very simplistic parsing which is sufficient for the cases needed. We don't want to bring in any external
|
|
// dependencies (such as an args-parsing library) to this file.
|
|
var result = {};
|
|
var currentKey = null;
|
|
args.forEach(function (arg) {
|
|
if (arg.indexOf('--') === 0) {
|
|
var argName = arg.substring(2);
|
|
result[argName] = undefined;
|
|
currentKey = argName;
|
|
}
|
|
else if (currentKey) {
|
|
result[currentKey] = arg;
|
|
currentKey = null;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
exports.parseArgs = parseArgs;
|
|
|
|
|
|
/***/ },
|
|
/* 5 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
var fs = __webpack_require__(6);
|
|
var path = __webpack_require__(3);
|
|
function autoQuitOnFileChange(rootDir, extensions) {
|
|
// Note: This will only work on Windows/OS X, because the 'recursive' option isn't supported on Linux.
|
|
// Consider using a different watch mechanism (though ideally without forcing further NPM dependencies).
|
|
fs.watch(rootDir, { persistent: false, recursive: true }, function (event, filename) {
|
|
var ext = path.extname(filename);
|
|
if (extensions.indexOf(ext) >= 0) {
|
|
console.log('Restarting due to file change: ' + filename);
|
|
// Temporarily, the file-watching logic is in Node, so we signal it's time to restart by
|
|
// sending the following message back to .NET. Soon the file-watching logic will move over
|
|
// to the .NET side, and this whole file can be removed.
|
|
console.log('[Microsoft.AspNetCore.NodeServices:Restart]');
|
|
}
|
|
});
|
|
}
|
|
exports.autoQuitOnFileChange = autoQuitOnFileChange;
|
|
|
|
|
|
/***/ },
|
|
/* 6 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("fs");
|
|
|
|
/***/ },
|
|
/* 7 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
// Limit dependencies to core Node modules. This means the code in this file has to be very low-level and unattractive,
|
|
// but simplifies things for the consumer of this module.
|
|
var net = __webpack_require__(8);
|
|
var path = __webpack_require__(3);
|
|
var readline = __webpack_require__(9);
|
|
var ArgsUtil_1 = __webpack_require__(4);
|
|
var AutoQuit_1 = __webpack_require__(5);
|
|
var virtualConnectionServer = __webpack_require__(10);
|
|
// Webpack doesn't support dynamic requires for files not present at compile time, so grab a direct
|
|
// reference to Node's runtime 'require' function.
|
|
var dynamicRequire = eval('require');
|
|
var parsedArgs = ArgsUtil_1.parseArgs(process.argv);
|
|
if (parsedArgs.watch) {
|
|
AutoQuit_1.autoQuitOnFileChange(process.cwd(), parsedArgs.watch.split(','));
|
|
}
|
|
// Signal to the .NET side when we're ready to accept invocations
|
|
var server = net.createServer().on('listening', function () {
|
|
console.log('[Microsoft.AspNetCore.NodeServices:Listening]');
|
|
});
|
|
// Each virtual connection represents a separate invocation
|
|
virtualConnectionServer.createInterface(server).on('connection', function (connection) {
|
|
readline.createInterface(connection, null).on('line', function (line) {
|
|
try {
|
|
// Get a reference to the function to invoke
|
|
var invocation = JSON.parse(line);
|
|
var invokedModule = dynamicRequire(path.resolve(process.cwd(), invocation.moduleName));
|
|
var invokedFunction = invocation.exportedFunctionName ? invokedModule[invocation.exportedFunctionName] : invokedModule;
|
|
// Prepare a callback for accepting non-streamed JSON responses
|
|
var hasInvokedCallback_1 = false;
|
|
var invocationCallback = function (errorValue, successValue) {
|
|
if (hasInvokedCallback_1) {
|
|
throw new Error('Cannot supply more than one result. The callback has already been invoked,'
|
|
+ ' or the result stream has already been accessed');
|
|
}
|
|
hasInvokedCallback_1 = true;
|
|
connection.end(JSON.stringify({
|
|
result: successValue,
|
|
errorMessage: errorValue && (errorValue.message || errorValue),
|
|
errorDetails: errorValue && (errorValue.stack || null)
|
|
}));
|
|
};
|
|
// Also support streamed binary responses
|
|
Object.defineProperty(invocationCallback, 'stream', {
|
|
enumerable: true,
|
|
get: function () {
|
|
hasInvokedCallback_1 = true;
|
|
return connection;
|
|
}
|
|
});
|
|
// Actually invoke it, passing through any supplied args
|
|
invokedFunction.apply(null, [invocationCallback].concat(invocation.args));
|
|
}
|
|
catch (ex) {
|
|
connection.end(JSON.stringify({
|
|
errorMessage: ex.message,
|
|
errorDetails: ex.stack
|
|
}));
|
|
}
|
|
});
|
|
});
|
|
// Begin listening now. The underlying transport varies according to the runtime platform.
|
|
// On Windows it's Named Pipes; on Linux/OSX it's Domain Sockets.
|
|
var useWindowsNamedPipes = /^win/.test(process.platform);
|
|
var listenAddress = (useWindowsNamedPipes ? '\\\\.\\pipe\\' : '/tmp/') + parsedArgs.listenAddress;
|
|
server.listen(listenAddress);
|
|
|
|
|
|
/***/ },
|
|
/* 8 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("net");
|
|
|
|
/***/ },
|
|
/* 9 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("readline");
|
|
|
|
/***/ },
|
|
/* 10 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
var events_1 = __webpack_require__(11);
|
|
var VirtualConnection_1 = __webpack_require__(12);
|
|
// Keep this in sync with the equivalent constant in the .NET code. Both sides split up their transmissions into frames with this max length,
|
|
// and both will reject longer frames.
|
|
var MaxFrameBodyLength = 16 * 1024;
|
|
/**
|
|
* Accepts connections to a net.Server and adapts them to behave as multiplexed connections. That is, for each physical socket connection,
|
|
* we track a list of 'virtual connections' whose API is a Duplex stream. The remote clients may open and close as many virtual connections
|
|
* as they wish, reading and writing to them independently, without the overhead of establishing new physical connections each time.
|
|
*/
|
|
function createInterface(server) {
|
|
var emitter = new events_1.EventEmitter();
|
|
server.on('connection', function (socket) {
|
|
// For each physical socket connection, maintain a set of virtual connections. Issue a notification whenever
|
|
// a new virtual connections is opened.
|
|
var childSockets = new VirtualConnectionsCollection(socket, function (virtualConnection) {
|
|
emitter.emit('connection', virtualConnection);
|
|
});
|
|
});
|
|
return emitter;
|
|
}
|
|
exports.createInterface = createInterface;
|
|
/**
|
|
* Tracks the 'virtual connections' associated with a single physical socket connection.
|
|
*/
|
|
var VirtualConnectionsCollection = (function () {
|
|
function VirtualConnectionsCollection(_socket, _onVirtualConnectionCallback) {
|
|
var _this = this;
|
|
this._socket = _socket;
|
|
this._onVirtualConnectionCallback = _onVirtualConnectionCallback;
|
|
this._currentFrameHeader = null;
|
|
this._virtualConnections = {};
|
|
// If the remote end closes the physical socket, treat all the virtual connections as being closed remotely too
|
|
this._socket.on('close', function () {
|
|
Object.getOwnPropertyNames(_this._virtualConnections).forEach(function (id) {
|
|
// A 'null' frame signals that the connection was closed remotely
|
|
_this._virtualConnections[id].onReceivedData(null);
|
|
});
|
|
});
|
|
this._socket.on('readable', this._onIncomingDataAvailable.bind(this));
|
|
}
|
|
/**
|
|
* This is called whenever the underlying socket signals that it may have some data available to read. It will synchronously read as many
|
|
* message frames as it can from the underlying socket, opens virtual connections as needed, and dispatches data to them.
|
|
*/
|
|
VirtualConnectionsCollection.prototype._onIncomingDataAvailable = function () {
|
|
var exhaustedAllData = false;
|
|
while (!exhaustedAllData) {
|
|
// We might already have a pending frame header from the previous time this method ran, but if not, that's the next thing we need to read
|
|
if (this._currentFrameHeader === null) {
|
|
this._currentFrameHeader = this._readNextFrameHeader();
|
|
}
|
|
if (this._currentFrameHeader === null) {
|
|
// There's not enough data to fill a frameheader, so wait until more arrives later
|
|
// The next attempt to read from the socket will start from the same place this one did (incomplete reads don't consume any data)
|
|
exhaustedAllData = true;
|
|
}
|
|
else {
|
|
var frameBodyLength = this._currentFrameHeader.bodyLength;
|
|
var frameBodyOrNull = frameBodyLength > 0 ? this._socket.read(this._currentFrameHeader.bodyLength) : null;
|
|
if (frameBodyOrNull !== null || frameBodyLength === 0) {
|
|
// We have a complete frame header+body pair, so we can now dispatch this to a virtual connection. We set _currentFrameHeader back to null
|
|
// so that the next thing we try to read is the next frame header.
|
|
var headerCopy = this._currentFrameHeader;
|
|
this._currentFrameHeader = null;
|
|
this._onReceivedCompleteFrame(headerCopy, frameBodyOrNull);
|
|
}
|
|
else {
|
|
// There's not enough data to fill the pending frame body, so wait until more arrives later
|
|
// The next attempt to read from the socket will start from the same place this one did (incomplete reads don't consume any data)
|
|
exhaustedAllData = true;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
VirtualConnectionsCollection.prototype._onReceivedCompleteFrame = function (header, bodyIfNotEmpty) {
|
|
// An incoming zero-length frame signals that there's no more data to read.
|
|
// Signal this to the Node stream APIs by pushing a 'null' chunk to it.
|
|
var virtualConnection = this._getOrOpenVirtualConnection(header);
|
|
virtualConnection.onReceivedData(header.bodyLength > 0 ? bodyIfNotEmpty : null);
|
|
};
|
|
VirtualConnectionsCollection.prototype._getOrOpenVirtualConnection = function (header) {
|
|
if (this._virtualConnections.hasOwnProperty(header.connectionIdString)) {
|
|
// It's an existing virtual connection
|
|
return this._virtualConnections[header.connectionIdString];
|
|
}
|
|
else {
|
|
// It's a new one
|
|
return this._openVirtualConnection(header);
|
|
}
|
|
};
|
|
VirtualConnectionsCollection.prototype._openVirtualConnection = function (header) {
|
|
var _this = this;
|
|
var beginWriteCallback = function (data, writeCompletedCallback) {
|
|
// Only send nonempty frames, since empty ones are a signal to close the virtual connection
|
|
if (data.length > 0) {
|
|
_this._sendFrame(header.connectionIdBinary, data, writeCompletedCallback);
|
|
}
|
|
};
|
|
var newVirtualConnection = new VirtualConnection_1.VirtualConnection(beginWriteCallback)
|
|
.on('end', function () {
|
|
// The virtual connection was closed remotely. Clean up locally.
|
|
_this._onVirtualConnectionWasClosed(header.connectionIdString);
|
|
}).on('finish', function () {
|
|
// The virtual connection was closed locally. Clean up locally, and notify the remote that we're done.
|
|
_this._onVirtualConnectionWasClosed(header.connectionIdString);
|
|
_this._sendFrame(header.connectionIdBinary, new Buffer(0));
|
|
});
|
|
this._virtualConnections[header.connectionIdString] = newVirtualConnection;
|
|
this._onVirtualConnectionCallback(newVirtualConnection);
|
|
return newVirtualConnection;
|
|
};
|
|
/**
|
|
* Attempts to read a complete frame header, synchronously, from the underlying socket.
|
|
* If not enough data is available synchronously, returns null without consuming any data from the socket.
|
|
*/
|
|
VirtualConnectionsCollection.prototype._readNextFrameHeader = function () {
|
|
var headerBuf = this._socket.read(12);
|
|
if (headerBuf !== null) {
|
|
// We have enough data synchronously
|
|
var connectionIdBinary = headerBuf.slice(0, 8);
|
|
var connectionIdString = connectionIdBinary.toString('hex');
|
|
var bodyLength = headerBuf.readInt32LE(8);
|
|
if (bodyLength < 0 || bodyLength > MaxFrameBodyLength) {
|
|
// Throwing here is going to bring down the whole process, so this cannot be allowed to happen in real use.
|
|
// But it won't happen in real use, because this is only used with our .NET client, which doesn't violate this rule.
|
|
throw new Error('Illegal frame body length: ' + bodyLength);
|
|
}
|
|
return { connectionIdBinary: connectionIdBinary, connectionIdString: connectionIdString, bodyLength: bodyLength };
|
|
}
|
|
else {
|
|
// Not enough bytes are available synchronously, so none were consumed
|
|
return null;
|
|
}
|
|
};
|
|
VirtualConnectionsCollection.prototype._sendFrame = function (connectionIdBinary, data, callback) {
|
|
// For all sends other than the last one, only invoke the callback if it failed.
|
|
// Also, only invoke the callback at most once.
|
|
var hasInvokedCallback = false;
|
|
var finalCallback = callback && (function (error) {
|
|
if (!hasInvokedCallback) {
|
|
hasInvokedCallback = true;
|
|
callback(error);
|
|
}
|
|
});
|
|
var notFinalCallback = callback && (function (error) {
|
|
if (error) {
|
|
finalCallback(error);
|
|
}
|
|
});
|
|
// The amount of data we're writing might exceed MaxFrameBodyLength, so split into frames as needed.
|
|
// Note that we always send at least one frame, even if it's empty (because that's the close-virtual-connection signal).
|
|
// If needed, this could be changed to send frames asynchronously, so that large sends could proceed in parallel
|
|
// (though that would involve making a clone of 'data', to avoid the risk of it being mutated during the send).
|
|
var bytesSent = 0;
|
|
do {
|
|
var nextFrameBodyLength = Math.min(MaxFrameBodyLength, data.length - bytesSent);
|
|
var isFinalChunk = (bytesSent + nextFrameBodyLength) === data.length;
|
|
this._socket.write(connectionIdBinary, notFinalCallback);
|
|
this._sendInt32LE(nextFrameBodyLength, notFinalCallback);
|
|
this._socket.write(data.slice(bytesSent, bytesSent + nextFrameBodyLength), isFinalChunk ? finalCallback : notFinalCallback);
|
|
bytesSent += nextFrameBodyLength;
|
|
} while (bytesSent < data.length);
|
|
};
|
|
/**
|
|
* Sends a number serialized in the correct format for .NET to receive as a System.Int32
|
|
*/
|
|
VirtualConnectionsCollection.prototype._sendInt32LE = function (value, callback) {
|
|
var buf = new Buffer(4);
|
|
buf.writeInt32LE(value, 0);
|
|
this._socket.write(buf, callback);
|
|
};
|
|
VirtualConnectionsCollection.prototype._onVirtualConnectionWasClosed = function (id) {
|
|
if (this._virtualConnections.hasOwnProperty(id)) {
|
|
delete this._virtualConnections[id];
|
|
}
|
|
};
|
|
return VirtualConnectionsCollection;
|
|
}());
|
|
|
|
|
|
/***/ },
|
|
/* 11 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("events");
|
|
|
|
/***/ },
|
|
/* 12 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
var __extends = (this && this.__extends) || function (d, b) {
|
|
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
var stream_1 = __webpack_require__(13);
|
|
/**
|
|
* Represents a virtual connection. Multiple virtual connections may be multiplexed over a single physical socket connection.
|
|
*/
|
|
var VirtualConnection = (function (_super) {
|
|
__extends(VirtualConnection, _super);
|
|
function VirtualConnection(_beginWriteCallback) {
|
|
_super.call(this);
|
|
this._beginWriteCallback = _beginWriteCallback;
|
|
this._flowing = false;
|
|
this._receivedDataQueue = [];
|
|
}
|
|
VirtualConnection.prototype._read = function () {
|
|
this._flowing = true;
|
|
// Keep pushing data until we run out, or the underlying framework asks us to stop.
|
|
// When we finish, the 'flowing' state is detemined by whether more data is still being requested.
|
|
while (this._flowing && this._receivedDataQueue.length > 0) {
|
|
var nextChunk = this._receivedDataQueue.shift();
|
|
this._flowing = this.push(nextChunk);
|
|
}
|
|
};
|
|
VirtualConnection.prototype._write = function (chunk, encodingIfString, callback) {
|
|
if (typeof chunk === 'string') {
|
|
chunk = new Buffer(chunk, encodingIfString);
|
|
}
|
|
this._beginWriteCallback(chunk, callback);
|
|
};
|
|
VirtualConnection.prototype.onReceivedData = function (dataOrNullToSignalEOF) {
|
|
if (this._flowing) {
|
|
this._flowing = this.push(dataOrNullToSignalEOF);
|
|
}
|
|
else {
|
|
this._receivedDataQueue.push(dataOrNullToSignalEOF);
|
|
}
|
|
};
|
|
return VirtualConnection;
|
|
}(stream_1.Duplex));
|
|
exports.VirtualConnection = VirtualConnection;
|
|
|
|
|
|
/***/ },
|
|
/* 13 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("stream");
|
|
|
|
/***/ }
|
|
/******/ ]))); |