gremlin-secure
Version:
Private version of the gremlin websocket client module: https://github.com/jbmusso/gremlin-javascript. This private version supports SSL and SASL authentication, and is undergoing a PR with the main module. This package is created as a private, temporary
482 lines (379 loc) • 39.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _events = require('events');
var _nodeUuid = require('node-uuid');
var _nodeUuid2 = _interopRequireDefault(_nodeUuid);
var _lodash = require('lodash');
var _lodash2 = _interopRequireDefault(_lodash);
var _highland = require('highland');
var _highland2 = _interopRequireDefault(_highland);
var _WebSocketGremlinConnection = require('./WebSocketGremlinConnection');
var _WebSocketGremlinConnection2 = _interopRequireDefault(_WebSocketGremlinConnection);
var _MessageStream = require('./MessageStream');
var _MessageStream2 = _interopRequireDefault(_MessageStream);
var _executeHandler = require('./executeHandler');
var _executeHandler2 = _interopRequireDefault(_executeHandler);
var _utils = require('./utils');
var Utils = _interopRequireWildcard(_utils);
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /*jslint -W079 */
/*jslint node: true */
var GremlinClient = function (_EventEmitter) {
_inherits(GremlinClient, _EventEmitter);
function GremlinClient() {
var port = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 8182;
var host = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'localhost';
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
_classCallCheck(this, GremlinClient);
var _this = _possibleConstructorReturn(this, (GremlinClient.__proto__ || Object.getPrototypeOf(GremlinClient)).call(this));
_this.port = port;
_this.host = host;
var _options$path = options.path,
path = _options$path === undefined ? '' : _options$path;
_this.options = _extends({
language: 'gremlin-groovy',
session: false,
ssl: false,
user: '',
password: '',
op: 'eval',
processor: '',
accept: 'application/json',
executeHandler: _executeHandler2.default
}, options, {
path: path && path.length && !path.startsWith('/') ? '/' + path : path
});
_this.useSession = _this.options.session;
_this.user = _this.options.user;
_this.password = _this.options.password;
_this.ssl = _this.options.ssl;
if (_this.useSession) {
_this.sessionId = _nodeUuid2.default.v1();
}
_this.connected = false;
_this.queue = [];
_this.commands = {};
_this.connection = _this.createConnection({
port: port,
host: host,
path: _this.options.path,
ssl: _this.ssl
});
return _this;
}
_createClass(GremlinClient, [{
key: 'createConnection',
value: function createConnection(_ref) {
var _this2 = this;
var port = _ref.port,
host = _ref.host,
path = _ref.path,
ssl = _ref.ssl;
var connection = new _WebSocketGremlinConnection2.default({ port: port, host: host, path: path, ssl: ssl });
connection.on('open', function () {
return _this2.onConnectionOpen();
});
connection.on('error', function (error) {
return _this2.handleError(error);
});
connection.on('message', function (message) {
return _this2.handleProtocolMessage(message);
});
connection.on('close', function (event) {
return _this2.handleDisconnection(event);
});
return connection;
}
}, {
key: 'handleError',
value: function handleError(err) {
this.connected = false;
this.emit('error', err);
}
/**
* Process all incoming raw message events sent by Gremlin Server, and dispatch
* to the appropriate command.
*
* @param {MessageEvent} event
*/
}, {
key: 'handleProtocolMessage',
value: function handleProtocolMessage(message) {
var data = message.data;
var buffer = new Buffer(data, 'binary');
var rawMessage = JSON.parse(buffer.toString('utf-8'));
var requestId = rawMessage.requestId,
_rawMessage$status = rawMessage.status,
statusCode = _rawMessage$status.code,
statusMessage = _rawMessage$status.message;
var messageStream = this.commands[requestId].messageStream;
switch (statusCode) {
case 200:
// SUCCESS
delete this.commands[requestId]; // TODO: optimize performance
messageStream.push(rawMessage);
messageStream.push(null);
break;
case 204:
// NO_CONTENT
delete this.commands[requestId];
messageStream.push(null);
break;
case 206:
// PARTIAL_CONTENT
messageStream.push(rawMessage);
break;
case 407:
// AUTHENTICATE CHALLANGE
var challengeResponse = this.buildChallengeResponse(requestId);
this.sendMessage(challengeResponse);
break;
default:
delete this.commands[requestId];
messageStream.emit('error', new Error(statusMessage + ' (Error ' + statusCode + ')'));
break;
}
}
/**
* Handle the WebSocket onOpen event, flag the client as connected and
* process command queue.
*/
}, {
key: 'onConnectionOpen',
value: function onConnectionOpen() {
this.connected = true;
this.emit('connect');
this.executeQueue();
}
}, {
key: 'handleDisconnection',
/**
* @param {CloseEvent} event
*/
value: function handleDisconnection(event) {
this.cancelPendingCommands({
message: 'WebSocket closed',
details: event
});
}
}, {
key: 'executeQueue',
/**
* Process the current command queue, sending commands to Gremlin Server
* (First In, First Out).
*/
value: function executeQueue() {
while (this.queue.length > 0) {
var _queue$shift = this.queue.shift(),
message = _queue$shift.message;
this.sendMessage(message);
}
}
}, {
key: 'cancelPendingCommands',
/**
* @param {Object} reason
*/
value: function cancelPendingCommands(_ref2) {
var message = _ref2.message,
details = _ref2.details;
var commands = this.commands;
var command = void 0;
var error = new Error(message);
error.details = details;
// Empty queue
this.queue.length = 0;
this.commands = {};
Object.keys(commands).forEach(function (key) {
command = commands[key];
command.messageStream.emit('error', error);
});
}
}, {
key: 'buildMessage',
/**
* For a given script string and optional bound parameters, build a protocol
* message object to be sent to Gremlin Server.
*
* @param {String|Function} script
* @param {Object} bindings
* @param {Object} message
*/
value: function buildMessage(rawScript) {
var rawBindings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
var baseMessage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var _Utils$buildQueryFrom = Utils.buildQueryFromSignature(rawScript, rawBindings),
gremlin = _Utils$buildQueryFrom.gremlin,
bindings = _Utils$buildQueryFrom.bindings;
var _options = this.options,
processor = _options.processor,
op = _options.op,
accept = _options.accept,
language = _options.language,
aliases = _options.aliases;
var baseArgs = { gremlin: gremlin, bindings: bindings, accept: accept, language: language, aliases: aliases };
var args = _lodash2.default.defaults(baseMessage.args || {}, baseArgs);
var message = _extends({
requestId: _nodeUuid2.default.v1(),
processor: processor,
op: op,
args: args
}, baseMessage);
if (this.useSession) {
// Assume that people want to use the 'session' processor unless specified
message.processor = message.processor || processor || 'session';
message.args.session = this.sessionId;
}
return message;
}
}, {
key: 'buildChallengeResponse',
value: function buildChallengeResponse(requestId) {
var _options2 = this.options,
processor = _options2.processor,
op = _options2.op,
accept = _options2.accept,
language = _options2.language,
aliases = _options2.aliases;
var args = { SASL: '\0' + this.user + '\0' + this.password };
var message = {
requestId: requestId,
processor: processor,
op: 'authentication',
args: args
};
return message;
}
}, {
key: 'sendMessage',
value: function sendMessage(message) {
var serializedMessage = this.options.accept + JSON.stringify(message);
serializedMessage = unescape(encodeURIComponent(serializedMessage));
// Let's start packing the message into binary
// mimeLength(1) + mimeType Length + serializedMessage Length
var binaryMessage = new Uint8Array(1 + serializedMessage.length);
binaryMessage[0] = this.options.accept.length;
for (var i = 0; i < serializedMessage.length; i++) {
binaryMessage[i + 1] = serializedMessage.charCodeAt(i);
}
this.connection.sendMessage(binaryMessage);
}
}, {
key: 'execute',
/**
* Asynchronously send a script to Gremlin Server for execution and fire
* the provided callback when all results have been fetched.
*
* This method internally uses a stream to handle the potential concatenation
* of results.
*
* Callback signature: (Error, Array<result>)
*
* @public
* @param {String|Function} script
* @param {Object} bindings
* @param {Object} message
* @param {Function} callback
*/
value: function execute(script) {
var bindings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
var _ref3;
var message = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var callback = (_ref3 = (arguments.length <= 3 ? 0 : arguments.length - 3) - 1 + 3, arguments.length <= _ref3 ? undefined : arguments[_ref3]);
if (typeof message === 'function') {
callback = message;
message = {};
}
var messageStream = this.messageStream(script, bindings, message);
// TO CHECK: errors handling could be improved
// See https://groups.google.com/d/msg/nodejs/lJYT9hZxFu0/L59CFbqWGyYJ
// for an example using domains
var executeHandler = this.options.executeHandler;
executeHandler(messageStream, callback);
}
/**
* Execute the script and return a stream of distinct/single results.
* This method reemits a distinct data event for each returned result, which
* makes the stream behave as if `resultIterationBatchSize` was set to 1.
*
* If you do not wish this behavior, please use client.messageStream() instead.
*
* Even though this method uses Highland.js internally, it does not return
* a high level Highland readable stream so we do not risk having to deal
* with unexpected API breaking changes as Highland.js evolves.
*
* @return {ReadableStream} A Node.js Stream2
*/
}, {
key: 'stream',
value: function stream(script, bindings, message) {
var messageStream = this.messageStream(script, bindings, message);
var _ = _highland2.default; // override lo-dash locally
// Create a local highland 'through' pipeline so we don't expose
// a Highland stream to the end user, but a standard Node.js Stream2
var through = _.pipeline(_.map(function (_ref4) {
var data = _ref4.result.data;
return data;
}), _.sequence());
var rawStream = messageStream.pipe(through);
messageStream.on('error', function (e) {
rawStream.emit('error', new Error(e));
});
return rawStream;
}
}, {
key: 'messageStream',
/**
* Execute the script and return a stream of raw messages returned by Gremlin
* Server.
* This method does not reemit one distinct data event per result. It directly
* emits the raw messages returned by Gremlin Server as they are received.
*
* Although public, this is a low level method intended to be used for
* advanced usages.
*
* @public
* @param {String|Function} script
* @param {Object} bindings
* @param {Object} message
* @return {MessageStream}
*/
value: function messageStream(script, bindings, rawMessage) {
var stream = new _MessageStream2.default({ objectMode: true });
var command = {
message: this.buildMessage(script, bindings, rawMessage),
messageStream: stream
};
this.sendCommand(command); //todo improve for streams
return stream;
}
}, {
key: 'sendCommand',
/**
* Send a command to Gremlin Server, or add it to queue if the connection
* is not established.
*
* @param {Object} command
*/
value: function sendCommand(command) {
var message = command.message,
requestId = command.message.requestId;
this.commands[requestId] = command;
if (this.connected) {
this.sendMessage(message);
} else {
this.queue.push(command);
}
}
}]);
return GremlinClient;
}(_events.EventEmitter);
exports.default = GremlinClient;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/GremlinClient.js"],"names":["Utils","GremlinClient","port","host","options","path","language","session","ssl","user","password","op","processor","accept","executeHandler","length","startsWith","useSession","sessionId","v1","connected","queue","commands","connection","createConnection","on","onConnectionOpen","error","handleError","message","handleProtocolMessage","event","handleDisconnection","err","emit","data","buffer","Buffer","rawMessage","JSON","parse","toString","requestId","status","statusCode","code","statusMessage","messageStream","push","challengeResponse","buildChallengeResponse","sendMessage","Error","executeQueue","cancelPendingCommands","details","shift","command","Object","keys","forEach","key","rawScript","rawBindings","baseMessage","buildQueryFromSignature","gremlin","bindings","aliases","baseArgs","args","defaults","SASL","serializedMessage","stringify","unescape","encodeURIComponent","binaryMessage","Uint8Array","i","charCodeAt","script","callback","_","through","pipeline","map","result","sequence","rawStream","pipe","e","stream","objectMode","buildMessage","sendCommand"],"mappings":";;;;;;;;;;AAEA;;AAEA;;;;AACA;;;;AACA;;;;AAEA;;;;AACA;;;;AACA;;;;AACA;;IAAYA,K;;;;;;;;;;+eAXZ;AACA;;;IAaMC,a;;;AACJ,2BAA2D;AAAA,QAA/CC,IAA+C,uEAAxC,IAAwC;AAAA,QAAlCC,IAAkC,uEAA3B,WAA2B;AAAA,QAAdC,OAAc,uEAAJ,EAAI;;AAAA;;AAAA;;AAGzD,UAAKF,IAAL,GAAYA,IAAZ;AACA,UAAKC,IAAL,GAAYA,IAAZ;;AAJyD,wBAMnCC,OANmC,CAMjDC,IANiD;AAAA,QAMjDA,IANiD,iCAM1C,EAN0C;;;AAQzD,UAAKD,OAAL;AACEE,gBAAU,gBADZ;AAEEC,eAAS,KAFX;AAGEC,WAAK,KAHP;AAIEC,YAAM,EAJR;AAKEC,gBAAU,EALZ;AAMEC,UAAI,MANN;AAOEC,iBAAW,EAPb;AAQEC,cAAQ,kBARV;AASEC;AATF,OAUKV,OAVL;AAWEC,YAAMA,QAAQA,KAAKU,MAAb,IAAuB,CAACV,KAAKW,UAAL,CAAgB,GAAhB,CAAxB,SAAmDX,IAAnD,GAA4DA;AAXpE;;AAcA,UAAKY,UAAL,GAAkB,MAAKb,OAAL,CAAaG,OAA/B;AACA,UAAKE,IAAL,GAAY,MAAKL,OAAL,CAAaK,IAAzB;AACA,UAAKC,QAAL,GAAgB,MAAKN,OAAL,CAAaM,QAA7B;AACA,UAAKF,GAAL,GAAW,MAAKJ,OAAL,CAAaI,GAAxB;;AAEA,QAAI,MAAKS,UAAT,EAAqB;AACnB,YAAKC,SAAL,GAAiB,mBAAKC,EAAL,EAAjB;AACD;;AAED,UAAKC,SAAL,GAAiB,KAAjB;AACA,UAAKC,KAAL,GAAa,EAAb;;AAEA,UAAKC,QAAL,GAAgB,EAAhB;;AAEA,UAAKC,UAAL,GAAkB,MAAKC,gBAAL,CAAsB;AACtCtB,gBADsC;AAEtCC,gBAFsC;AAGtCE,YAAM,MAAKD,OAAL,CAAaC,IAHmB;AAItCG,WAAK,MAAKA;AAJ4B,KAAtB,CAAlB;AApCyD;AA0C1D;;;;2CAE2C;AAAA;;AAAA,UAAzBN,IAAyB,QAAzBA,IAAyB;AAAA,UAAnBC,IAAmB,QAAnBA,IAAmB;AAAA,UAAbE,IAAa,QAAbA,IAAa;AAAA,UAAPG,GAAO,QAAPA,GAAO;;AAC1C,UAAMe,aAAa,yCAA+B,EAAErB,UAAF,EAAQC,UAAR,EAAcE,UAAd,EAAoBG,QAApB,EAA/B,CAAnB;;AAEAe,iBAAWE,EAAX,CAAc,MAAd,EAAsB;AAAA,eAAM,OAAKC,gBAAL,EAAN;AAAA,OAAtB;AACAH,iBAAWE,EAAX,CAAc,OAAd,EAAuB,UAACE,KAAD;AAAA,eAAW,OAAKC,WAAL,CAAiBD,KAAjB,CAAX;AAAA,OAAvB;AACAJ,iBAAWE,EAAX,CAAc,SAAd,EAAyB,UAACI,OAAD;AAAA,eAAa,OAAKC,qBAAL,CAA2BD,OAA3B,CAAb;AAAA,OAAzB;AACAN,iBAAWE,EAAX,CAAc,OAAd,EAAuB,UAACM,KAAD;AAAA,eAAW,OAAKC,mBAAL,CAAyBD,KAAzB,CAAX;AAAA,OAAvB;;AAEA,aAAOR,UAAP;AACD;;;gCAEWU,G,EAAK;AACf,WAAKb,SAAL,GAAiB,KAAjB;AACA,WAAKc,IAAL,CAAU,OAAV,EAAmBD,GAAnB;AACD;;AAED;;;;;;;;;0CAMsBJ,O,EAAS;AAAA,UACrBM,IADqB,GACZN,OADY,CACrBM,IADqB;;AAE7B,UAAMC,SAAS,IAAIC,MAAJ,CAAWF,IAAX,EAAiB,QAAjB,CAAf;AACA,UAAMG,aAAaC,KAAKC,KAAL,CAAWJ,OAAOK,QAAP,CAAgB,OAAhB,CAAX,CAAnB;AAH6B,UAK3BC,SAL2B,GAUzBJ,UAVyB,CAK3BI,SAL2B;AAAA,+BAUzBJ,UAVyB,CAM3BK,MAN2B;AAAA,UAOnBC,UAPmB,sBAOzBC,IAPyB;AAAA,UAQhBC,aARgB,sBAQzBjB,OARyB;AAAA,UAYrBkB,aAZqB,GAYH,KAAKzB,QAAL,CAAcoB,SAAd,CAZG,CAYrBK,aAZqB;;;AAc7B,cAAQH,UAAR;AACE,aAAK,GAAL;AAAU;AACR,iBAAO,KAAKtB,QAAL,CAAcoB,SAAd,CAAP,CADF,CACmC;AACjCK,wBAAcC,IAAd,CAAmBV,UAAnB;AACAS,wBAAcC,IAAd,CAAmB,IAAnB;AACA;AACF,aAAK,GAAL;AAAU;AACR,iBAAO,KAAK1B,QAAL,CAAcoB,SAAd,CAAP;AACAK,wBAAcC,IAAd,CAAmB,IAAnB;AACA;AACF,aAAK,GAAL;AAAU;AACRD,wBAAcC,IAAd,CAAmBV,UAAnB;AACA;AACF,aAAK,GAAL;AAAU;AACR,cAAMW,oBAAoB,KAAKC,sBAAL,CAA4BR,SAA5B,CAA1B;AACA,eAAKS,WAAL,CAAiBF,iBAAjB;AACA;AACF;AACE,iBAAO,KAAK3B,QAAL,CAAcoB,SAAd,CAAP;AACAK,wBAAcb,IAAd,CAAmB,OAAnB,EAA4B,IAAIkB,KAAJ,CAAUN,gBAAgB,UAAhB,GAA4BF,UAA5B,GAAwC,GAAlD,CAA5B;AACA;AApBJ;AAsBD;;AAED;;;;;;;uCAImB;AACjB,WAAKxB,SAAL,GAAiB,IAAjB;AACA,WAAKc,IAAL,CAAU,SAAV;;AAEA,WAAKmB,YAAL;AACD;;;;;AAED;;;wCAGoBtB,K,EAAO;AACzB,WAAKuB,qBAAL,CAA2B;AACzBzB,iBAAS,kBADgB;AAEzB0B,iBAASxB;AAFgB,OAA3B;AAID;;;;;AAED;;;;mCAIe;AACb,aAAO,KAAKV,KAAL,CAAWN,MAAX,GAAoB,CAA3B,EAA8B;AAAA,2BACV,KAAKM,KAAL,CAAWmC,KAAX,EADU;AAAA,YACtB3B,OADsB,gBACtBA,OADsB;;AAE5B,aAAKsB,WAAL,CAAiBtB,OAAjB;AACD;AACF;;;;;AAED;;;iDAG4C;AAAA,UAApBA,OAAoB,SAApBA,OAAoB;AAAA,UAAX0B,OAAW,SAAXA,OAAW;;AAC1C,UAAMjC,WAAW,KAAKA,QAAtB;AACA,UAAImC,gBAAJ;AACA,UAAM9B,QAAQ,IAAIyB,KAAJ,CAAUvB,OAAV,CAAd;AACAF,YAAM4B,OAAN,GAAgBA,OAAhB;;AAEA;AACA,WAAKlC,KAAL,CAAWN,MAAX,GAAoB,CAApB;AACA,WAAKO,QAAL,GAAgB,EAAhB;;AAEAoC,aAAOC,IAAP,CAAYrC,QAAZ,EAAsBsC,OAAtB,CAA8B,UAACC,GAAD,EAAS;AACrCJ,kBAAUnC,SAASuC,GAAT,CAAV;AACAJ,gBAAQV,aAAR,CAAsBb,IAAtB,CAA2B,OAA3B,EAAoCP,KAApC;AACD,OAHD;AAID;;;;;AAED;;;;;;;;iCAQamC,S,EAA+C;AAAA,UAApCC,WAAoC,uEAAtB,EAAsB;AAAA,UAAlBC,WAAkB,uEAAJ,EAAI;;AAAA,kCAC9BhE,MAAMiE,uBAAN,CAA8BH,SAA9B,EAAyCC,WAAzC,CAD8B;AAAA,UACpDG,OADoD,yBACpDA,OADoD;AAAA,UAC3CC,QAD2C,yBAC3CA,QAD2C;;AAAA,qBAEL,KAAK/D,OAFA;AAAA,UAElDQ,SAFkD,YAElDA,SAFkD;AAAA,UAEvCD,EAFuC,YAEvCA,EAFuC;AAAA,UAEnCE,MAFmC,YAEnCA,MAFmC;AAAA,UAE3BP,QAF2B,YAE3BA,QAF2B;AAAA,UAEjB8D,OAFiB,YAEjBA,OAFiB;;;AAI1D,UAAMC,WAAW,EAAEH,gBAAF,EAAWC,kBAAX,EAAqBtD,cAArB,EAA6BP,kBAA7B,EAAuC8D,gBAAvC,EAAjB;AACA,UAAME,OAAO,iBAAEC,QAAF,CAAWP,YAAYM,IAAZ,IAAoB,EAA/B,EAAmCD,QAAnC,CAAb;;AAEA,UAAMxC;AACJa,mBAAW,mBAAKvB,EAAL,EADP;AAEJP,4BAFI;AAGJD,cAHI;AAIJ2D;AAJI,SAKDN,WALC,CAAN;;AAQA,UAAI,KAAK/C,UAAT,EAAqB;AACnB;AACAY,gBAAQjB,SAAR,GAAoBiB,QAAQjB,SAAR,IAAqBA,SAArB,IAAkC,SAAtD;AACAiB,gBAAQyC,IAAR,CAAa/D,OAAb,GAAuB,KAAKW,SAA5B;AACD;;AAED,aAAOW,OAAP;AACD;;;2CAEsBa,S,EAAW;AAAA,sBACqB,KAAKtC,OAD1B;AAAA,UACxBQ,SADwB,aACxBA,SADwB;AAAA,UACbD,EADa,aACbA,EADa;AAAA,UACTE,MADS,aACTA,MADS;AAAA,UACDP,QADC,aACDA,QADC;AAAA,UACS8D,OADT,aACSA,OADT;;AAEhC,UAAIE,OAAO,EAAEE,MAAM,OAAO,KAAK/D,IAAZ,GAAmB,IAAnB,GAA0B,KAAKC,QAAvC,EAAX;;AAEA,UAAMmB,UAAU;AACda,mBAAWA,SADG;AAEd9B,4BAFc;AAGdD,YAAI,gBAHU;AAId2D;AAJc,OAAhB;;AAOA,aAAOzC,OAAP;AACD;;;gCAEWA,O,EAAS;AACnB,UAAI4C,oBAAoB,KAAKrE,OAAL,CAAaS,MAAb,GAAsB0B,KAAKmC,SAAL,CAAe7C,OAAf,CAA9C;AACA4C,0BAAoBE,SAASC,mBAAmBH,iBAAnB,CAAT,CAApB;;AAEA;AACA;AACA,UAAII,gBAAgB,IAAIC,UAAJ,CAAe,IAAIL,kBAAkB1D,MAArC,CAApB;AACA8D,oBAAc,CAAd,IAAmB,KAAKzE,OAAL,CAAaS,MAAb,CAAoBE,MAAvC;;AAEA,WAAK,IAAIgE,IAAI,CAAb,EAAgBA,IAAIN,kBAAkB1D,MAAtC,EAA8CgE,GAA9C,EAAmD;AACjDF,sBAAcE,IAAI,CAAlB,IAAuBN,kBAAkBO,UAAlB,CAA6BD,CAA7B,CAAvB;AACD;;AAED,WAAKxD,UAAL,CAAgB4B,WAAhB,CAA4B0B,aAA5B;AACD;;;;;AAED;;;;;;;;;;;;;;;4BAeQI,M,EAA8C;AAAA,UAAtCd,QAAsC,uEAA3B,EAA2B;;AAAA;;AAAA,UAAvBtC,OAAuB,uEAAb,EAAa;;AACpD,UAAIqD,oBAAgB,qDAAc,CAA9B,+DAAJ;;AAEA,UAAI,OAAOrD,OAAP,KAAmB,UAAvB,EAAmC;AACjCqD,mBAAWrD,OAAX;AACAA,kBAAU,EAAV;AACD;;AAED,UAAMkB,gBAAgB,KAAKA,aAAL,CAAmBkC,MAAnB,EAA2Bd,QAA3B,EAAqCtC,OAArC,CAAtB;;AAEA;AACA;AACA;AAZoD,UAa5Cf,cAb4C,GAazB,KAAKV,OAboB,CAa5CU,cAb4C;;;AAepDA,qBAAeiC,aAAf,EAA8BmC,QAA9B;AACD;;AAED;;;;;;;;;;;;;;;;2BAaOD,M,EAAQd,Q,EAAUtC,O,EAAS;AAChC,UAAMkB,gBAAgB,KAAKA,aAAL,CAAmBkC,MAAnB,EAA2Bd,QAA3B,EAAqCtC,OAArC,CAAtB;AACA,UAAMsD,sBAAN,CAFgC,CAEZ;;AAEpB;AACA;AACA,UAAMC,UAAUD,EAAEE,QAAF,CACdF,EAAEG,GAAF,CAAM;AAAA,YAAanD,IAAb,SAAGoD,MAAH,CAAapD,IAAb;AAAA,eAAyBA,IAAzB;AAAA,OAAN,CADc,EAEdgD,EAAEK,QAAF,EAFc,CAAhB;;AAKA,UAAIC,YAAY1C,cAAc2C,IAAd,CAAmBN,OAAnB,CAAhB;;AAEArC,oBAActB,EAAd,CAAiB,OAAjB,EAA0B,UAACkE,CAAD,EAAO;AAC/BF,kBAAUvD,IAAV,CAAe,OAAf,EAAwB,IAAIkB,KAAJ,CAAUuC,CAAV,CAAxB;AACD,OAFD;;AAIA,aAAOF,SAAP;AACD;;;;;AAED;;;;;;;;;;;;;;;kCAecR,M,EAAQd,Q,EAAU7B,U,EAAY;AAC1C,UAAIsD,SAAS,4BAAkB,EAAEC,YAAY,IAAd,EAAlB,CAAb;;AAEA,UAAMpC,UAAU;AACd5B,iBAAS,KAAKiE,YAAL,CAAkBb,MAAlB,EAA0Bd,QAA1B,EAAoC7B,UAApC,CADK;AAEdS,uBAAe6C;AAFD,OAAhB;;AAKA,WAAKG,WAAL,CAAiBtC,OAAjB,EAR0C,CAQf;;AAE3B,aAAOmC,MAAP;AACD;;;;;AAED;;;;;;gCAMYnC,O,EAAS;AAAA,UAEjB5B,OAFiB,GAMf4B,OANe,CAEjB5B,OAFiB;AAAA,UAIfa,SAJe,GAMfe,OANe,CAGjB5B,OAHiB,CAIfa,SAJe;;;AAQnB,WAAKpB,QAAL,CAAcoB,SAAd,IAA2Be,OAA3B;;AAEA,UAAI,KAAKrC,SAAT,EAAoB;AAClB,aAAK+B,WAAL,CAAiBtB,OAAjB;AACD,OAFD,MAEO;AACL,aAAKR,KAAL,CAAW2B,IAAX,CAAgBS,OAAhB;AACD;AACF;;;;;;kBAGYxD,a","file":"GremlinClient.js","sourcesContent":["/*jslint -W079 */\n/*jslint node: true */\nimport { EventEmitter } from 'events';\n\nimport uuid from 'node-uuid';\nimport _ from 'lodash';\nimport highland from 'highland';\n\nimport WebSocketGremlinConnection from './WebSocketGremlinConnection';\nimport MessageStream from './MessageStream';\nimport executeHandler from './executeHandler';\nimport * as Utils from './utils';\n\n\nclass GremlinClient extends EventEmitter {\n  constructor(port = 8182, host = 'localhost', options = {}) {\n    super();\n\n    this.port = port;\n    this.host = host;\n\n    const { path = '' } = options;\n\n    this.options = {\n      language: 'gremlin-groovy',\n      session: false,\n      ssl: false,\n      user: '',\n      password: '',\n      op: 'eval',\n      processor: '',\n      accept: 'application/json',\n      executeHandler,\n      ...options,\n      path: path && path.length && !path.startsWith('/') ? `/${path}` : path\n    }\n\n    this.useSession = this.options.session;\n    this.user = this.options.user;\n    this.password = this.options.password;\n    this.ssl = this.options.ssl;\n\n    if (this.useSession) {\n      this.sessionId = uuid.v1();\n    }\n\n    this.connected = false;\n    this.queue = [];\n\n    this.commands = {};\n\n    this.connection = this.createConnection({\n      port,\n      host,\n      path: this.options.path,\n      ssl: this.ssl\n    });\n  }\n\n  createConnection({ port, host, path, ssl }) {\n    const connection = new WebSocketGremlinConnection({ port, host, path, ssl });\n\n    connection.on('open', () => this.onConnectionOpen());\n    connection.on('error', (error) => this.handleError(error));\n    connection.on('message', (message) => this.handleProtocolMessage(message));\n    connection.on('close', (event) => this.handleDisconnection(event))\n\n    return connection;\n  }\n\n  handleError(err) {\n    this.connected = false;\n    this.emit('error', err);\n  }\n\n  /**\n   * Process all incoming raw message events sent by Gremlin Server, and dispatch\n   * to the appropriate command.\n   *\n   * @param {MessageEvent} event\n   */\n  handleProtocolMessage(message) {\n    const { data } = message;\n    const buffer = new Buffer(data, 'binary');\n    const rawMessage = JSON.parse(buffer.toString('utf-8'));\n    const {\n      requestId,\n      status: {\n        code: statusCode,\n        message: statusMessage\n      }\n    } = rawMessage;\n\n    const { messageStream } = this.commands[requestId];\n\n    switch (statusCode) {\n      case 200: // SUCCESS\n        delete this.commands[requestId]; // TODO: optimize performance\n        messageStream.push(rawMessage);\n        messageStream.push(null);\n        break;\n      case 204: // NO_CONTENT\n        delete this.commands[requestId];\n        messageStream.push(null);\n        break;\n      case 206: // PARTIAL_CONTENT\n        messageStream.push(rawMessage);\n        break;\n      case 407: // AUTHENTICATE CHALLANGE\n        const challengeResponse = this.buildChallengeResponse(requestId);\n        this.sendMessage(challengeResponse);\n        break;\n      default:\n        delete this.commands[requestId];\n        messageStream.emit('error', new Error(statusMessage + ' (Error '+ statusCode +')'));\n        break;\n    }\n  }\n\n  /**\n   * Handle the WebSocket onOpen event, flag the client as connected and\n   * process command queue.\n   */\n  onConnectionOpen() {\n    this.connected = true;\n    this.emit('connect');\n\n    this.executeQueue();\n  };\n\n  /**\n   * @param {CloseEvent} event\n   */\n  handleDisconnection(event) {\n    this.cancelPendingCommands({\n      message: 'WebSocket closed',\n      details: event\n    });\n  };\n\n  /**\n   * Process the current command queue, sending commands to Gremlin Server\n   * (First In, First Out).\n   */\n  executeQueue() {\n    while (this.queue.length > 0) {\n      let { message } = this.queue.shift();\n      this.sendMessage(message);\n    }\n  };\n\n  /**\n   * @param {Object} reason\n   */\n  cancelPendingCommands({ message, details }) {\n    const commands = this.commands;\n    let command;\n    const error = new Error(message);\n    error.details = details;\n\n    // Empty queue\n    this.queue.length = 0;\n    this.commands = {};\n\n    Object.keys(commands).forEach((key) => {\n      command = commands[key];\n      command.messageStream.emit('error', error);\n    });\n  };\n\n  /**\n   * For a given script string and optional bound parameters, build a protocol\n   * message object to be sent to Gremlin Server.\n   *\n   * @param {String|Function} script\n   * @param {Object} bindings\n   * @param {Object} message\n   */\n  buildMessage(rawScript, rawBindings = {}, baseMessage = {}) {\n    let { gremlin, bindings } = Utils.buildQueryFromSignature(rawScript, rawBindings);\n    const { processor, op, accept, language, aliases } = this.options;\n\n    const baseArgs = { gremlin, bindings, accept, language, aliases };\n    const args = _.defaults(baseMessage.args || {}, baseArgs);\n\n    const message = {\n      requestId: uuid.v1(),\n      processor,\n      op,\n      args,\n      ...baseMessage\n    };\n\n    if (this.useSession) {\n      // Assume that people want to use the 'session' processor unless specified\n      message.processor = message.processor || processor || 'session';\n      message.args.session = this.sessionId;\n    }\n\n    return message;\n  };\n\n  buildChallengeResponse(requestId) {\n    const { processor, op, accept, language, aliases } = this.options;\n    var args = { SASL: '\\0' + this.user + '\\0' + this.password };\n    \n    const message = {\n      requestId: requestId,\n      processor,\n      op: 'authentication',\n      args\n    };\n\n    return message;\n  };\n\n  sendMessage(message) {\n    let serializedMessage = this.options.accept + JSON.stringify(message);\n    serializedMessage = unescape(encodeURIComponent(serializedMessage));\n\n    // Let's start packing the message into binary\n    // mimeLength(1) + mimeType Length + serializedMessage Length\n    let binaryMessage = new Uint8Array(1 + serializedMessage.length);\n    binaryMessage[0] = this.options.accept.length;\n\n    for (let i = 0; i < serializedMessage.length; i++) {\n      binaryMessage[i + 1] = serializedMessage.charCodeAt(i);\n    }\n\n    this.connection.sendMessage(binaryMessage);\n  };\n\n  /**\n   * Asynchronously send a script to Gremlin Server for execution and fire\n   * the provided callback when all results have been fetched.\n   *\n   * This method internally uses a stream to handle the potential concatenation\n   * of results.\n   *\n   * Callback signature: (Error, Array<result>)\n   *\n   * @public\n   * @param {String|Function} script\n   * @param {Object} bindings\n   * @param {Object} message\n   * @param {Function} callback\n   */\n  execute(script, bindings = {}, message = {}, ...args) {\n    let callback = args[args.length - 1];\n\n    if (typeof message === 'function') {\n      callback = message;\n      message = {};\n    }\n\n    const messageStream = this.messageStream(script, bindings, message);\n\n    // TO CHECK: errors handling could be improved\n    // See https://groups.google.com/d/msg/nodejs/lJYT9hZxFu0/L59CFbqWGyYJ\n    // for an example using domains\n    const { executeHandler } = this.options;\n\n    executeHandler(messageStream, callback);\n  }\n\n  /**\n   * Execute the script and return a stream of distinct/single results.\n   * This method reemits a distinct data event for each returned result, which\n   * makes the stream behave as if `resultIterationBatchSize` was set to 1.\n   *\n   * If you do not wish this behavior, please use client.messageStream() instead.\n   *\n   * Even though this method uses Highland.js internally, it does not return\n   * a high level Highland readable stream so we do not risk having to deal\n   * with unexpected API breaking changes as Highland.js evolves.\n   *\n   * @return {ReadableStream} A Node.js Stream2\n   */\n  stream(script, bindings, message) {\n    const messageStream = this.messageStream(script, bindings, message);\n    const _ = highland; // override lo-dash locally\n\n    // Create a local highland 'through' pipeline so we don't expose\n    // a Highland stream to the end user, but a standard Node.js Stream2\n    const through = _.pipeline(\n      _.map(({ result: { data }}) => data),\n      _.sequence()\n    );\n\n    let rawStream = messageStream.pipe(through);\n\n    messageStream.on('error', (e) => {\n      rawStream.emit('error', new Error(e));\n    });\n\n    return rawStream;\n  };\n\n  /**\n   * Execute the script and return a stream of raw messages returned by Gremlin\n   * Server.\n   * This method does not reemit one distinct data event per result. It directly\n   * emits the raw messages returned by Gremlin Server as they are received.\n   *\n   * Although public, this is a low level method intended to be used for\n   * advanced usages.\n   *\n   * @public\n   * @param {String|Function} script\n   * @param {Object} bindings\n   * @param {Object} message\n   * @return {MessageStream}\n   */\n  messageStream(script, bindings, rawMessage) {\n    let stream = new MessageStream({ objectMode: true });\n\n    const command = {\n      message: this.buildMessage(script, bindings, rawMessage),\n      messageStream: stream\n    };\n\n    this.sendCommand(command); //todo improve for streams\n\n    return stream;\n  };\n\n  /**\n   * Send a command to Gremlin Server, or add it to queue if the connection\n   * is not established.\n   *\n   * @param {Object} command\n   */\n  sendCommand(command) {\n    const {\n      message,\n      message: {\n        requestId\n      }\n    } = command;\n\n    this.commands[requestId] = command;\n\n    if (this.connected) {\n      this.sendMessage(message);\n    } else {\n      this.queue.push(command);\n    }\n  };\n}\n\nexport default GremlinClient;\n"]}