whatap 1.0.1 → 1.0.2

package/lib/step/activestack-step.js

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Step        = require('./step'),
+    StepEnum    = require('./stepenum'),
+    Long        = require('long');
+
+function ActiveStackStep(id) {
+    Step.call(this);
+
+    this.seq = Long.ZERO;
+    this.hasCallStack = false;
+    if(id instanceof Long) {
+        this.seq = id;
+    }
+};
+
+ActiveStackStep.prototype = new Step();
+ActiveStackStep.prototype.constructor = ActiveStackStep;
+ActiveStackStep.prototype.getStepType = function() {
+    return StepEnum.ACTIVE_STACK;
+};
+ActiveStackStep.prototype.write = function(dout) {
+    Step.prototype.write.call(this, dout);
+    dout.writeLong(this.seq);
+    dout.writeBoolean(this.hasCallStack);
+};
+ActiveStackStep.prototype.read = function(din) {
+    Step.prototype.read.call(this, din);
+    this.seq = din.readLong();
+    this.hasCallStack = din.readBoolean();
+    return this;
+};
+
+module.exports = ActiveStackStep;

package/lib/step/dbc-step.js

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Step = require('./step'),
+    StepEnum = require('./stepenum');
+
+function DBCStep() {
+    Step.call(this);
+    this.hash = 0;
+    this.elapsed = 0;
+    this.error = 0;
+}
+
+DBCStep.prototype = new Step();
+DBCStep.prototype.constructor = DBCStep;
+DBCStep.prototype.getStepType = function() {
+    return StepEnum.DBC;
+};
+DBCStep.prototype.write = function(dout) {
+    Step.prototype.write.call(this, dout);
+    dout.writeDecimal(this.hash);
+    dout.writeDecimal(this.elapsed);
+    dout.writeDecimal(this.error);
+};
+DBCStep.prototype.read = function(din) {
+    Step.prototype.read.call(this, din);
+    this.hash = din.readDecNumber();
+    this.elapsed = din.readDecNumber();
+    this.error = din.readDecNumber();
+    return this;
+};
+
+module.exports = DBCStep;

package/lib/step/http-stepx.js

@@ -0,0 +1,67 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Step = require('./step'),
+    StepEnum = require('./stepenum'),
+    Long = require('long');
+
+function HttpStepX() {
+    Step.call(this);
+
+    this.url = 0;
+    this.elapsed = 0;
+    this.error = Long.ZERO;
+    this.host = 0;
+    this.port = 0;
+
+    this.status = 0;
+    
+    this.start_cpu = 0;
+    this.start_mem = 0;
+    
+    this.stack = [];
+    this.callee = null;
+};
+
+HttpStepX.prototype = new Step();
+HttpStepX.prototype.constructor = HttpStepX;
+HttpStepX.prototype.getStepType = function () {
+    return StepEnum.HTTPCALL_X;
+};
+HttpStepX.prototype.write = function(dout) {
+    Step.prototype.write.call(this, dout);
+    dout.writeByte(1);
+    dout.writeDecimal(this.url);
+    dout.writeDecimal(this.elapsed);
+    dout.writeDecimal(this.error);
+    dout.writeDecimal(this.host);
+    dout.writeDecimal(this.port);
+
+    dout.writeDecimal(this.status);    
+    dout.writeDecimal(this.start_cpu);
+    dout.writeDecimal(this.start_mem);
+    dout.writeIntArray(this.stack);
+    dout.writeDecimal(this.callee);
+};
+HttpStepX.prototype.read = function(din) {
+    Step.prototype.read.call(this, din);
+    var ver=din.readByte();
+    this.url = din.readDecNumber();
+    this.elapsed = din.readDecNumber();
+    this.error = din.readDecNumber();
+    this.host = din.readDecNumber();
+    this.port = din.readDecNumber();
+
+    this.status = din.readDecNumber();
+    this.start_cpu = din.readDecNumber();
+    this.start_mem = din.readDecNumber();
+
+    this.stack = din.readIntArray();
+    this.callee = din.readDecLong();
+    return this;
+};
+
+module.exports = HttpStepX;

package/lib/step/message-step.js

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Step = require('./step'),
+    StepEnum = require('./stepenum');
+
+function MessageStep(start_time) {
+    Step.call(this);
+    this.hash = 0;
+    this.time = 0;
+    this.value = 0;
+    this.desc = null;
+    this.start_time = start_time || 0;
+}
+
+MessageStep.prototype = new Step();
+MessageStep.prototype.constructor = MessageStep;
+MessageStep.prototype.getStepType = function () {
+    return StepEnum.MESSAGE;
+};
+MessageStep.prototype.write = function(dout) {
+    Step.prototype.write.call(this, dout);
+    dout.writeDecimal(this.hash);
+    dout.writeDecimal(this.time);
+    dout.writeDecimal(this.value);
+    dout.writeText(this.desc);
+};
+MessageStep.prototype.read = function(din) {
+    Step.prototype.read.call(this, din);
+    this.hash = din.readDecNumber();
+    this.time = din.readDecNumber();
+    this.value = din.readDecNumber();
+    this.desc = din.readText();
+    return this;
+};
+
+module.exports = MessageStep;

package/lib/step/method-stepx.js

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+module.exports = MethodStepX;
+
+var Step = require('./step'),
+    StepEnum = require('./stepenum');
+
+function MethodStepX() {
+    Step.call(this);
+
+    this.hash = 0;
+    this.elapsed = 0;
+    this.start_cpu = 0;
+    this.start_mem = 0;
+    this.stack = [];
+
+};
+MethodStepX.prototype = new Step();
+MethodStepX.prototype.constructor = MethodStepX;
+MethodStepX.prototype.getStepType = function () {
+    return StepEnum.METHOD_X;
+};
+MethodStepX.prototype.write = function(dout) {
+    Step.prototype.write.call(this, dout);
+    dout.writeByte(0);
+    dout.writeDecimal(this.hash);
+    dout.writeDecimal(this.elapsed);
+    dout.writeDecimal(this.start_cpu);
+    dout.writeDecimal(this.start_mem);
+    dout.writeIntArray(this.stack);
+};
+MethodStepX.prototype.read = function(din) {
+    Step.prototype.read.call(this, din);
+    var ver = din.readByte();
+    this.hash = din.readDecNumber();
+    this.elapsed = din.readDecNumber();
+    this.start_cpu = din.readDecNumber();
+    this.start_mem = din.readDecNumber();
+    this.stack = din.readIntArray();
+    return this;
+};

package/lib/step/resultset-step.js

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Step = require('./step'),
+    StepEnum = require('./stepenum');
+
+function ResultSetStep() {
+    Step.call(this);
+
+    this.dbc = 0;
+    this.sqlhash = 0;
+    this.elapsed = 0;
+    this.fetch = 0;
+};
+
+ResultSetStep.prototype = new Step();
+ResultSetStep.prototype.constructor = ResultSetStep;
+ResultSetStep.prototype.getStepType = function () {
+    return StepEnum.RESULTSET;
+};
+ResultSetStep.prototype.write = function(dout) {
+    Step.prototype.write.call(this, dout);
+    dout.writeDecimal(this.elapsed);
+    dout.writeDecimal(this.fetch);
+    dout.writeDecimal(this.dbc);
+    dout.writeDecimal(this.sqlhash);
+};
+ResultSetStep.prototype.read = function(din) {
+    Step.prototype.read.call(this, din);
+    this.elapsed = din.readDecNumber();
+    this.fetch = din.readDecNumber();
+    this.dbc = din.readDecNumber();
+    this.sqlhash = din.readDecNumber();
+    return this;
+};
+
+module.exports = ResultSetStep;

package/lib/step/securemsg-step.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Step = require('./step'),
+    StepEnum = require('./stepenum');
+
+function SecureMsgStep(start_time) {
+    Step.call(this);
+
+    this.hash = 0;
+    this.opt = 0;
+    this.crc = 0;
+    this.value = null;
+
+    if(start_time != null) {
+        this.start_time = start_time;
+    }
+};
+
+SecureMsgStep.prototype = new Step();
+SecureMsgStep.prototype.constructor = SecureMsgStep;
+SecureMsgStep.prototype.getStepType = function () {
+    return StepEnum.SECURE_MESSAGE;
+};
+SecureMsgStep.prototype.write = function(dout) {
+    Step.prototype.write.call(this, dout);
+    dout.writeDecimal(this.hash);
+    dout.writeByte(this.opt);
+    dout.writeByte(this.crc);
+    dout.writeBlob(this.value);
+};
+SecureMsgStep.prototype.read = function(din) {
+    Step.prototype.read.call(this, din);
+    this.hash = din.readDecNumber();
+    this.opt = din.readByte();
+    this.crc = din.readByte();
+    this.value = din.readBlob();
+    return this;
+};
+
+module.exports = SecureMsgStep;

package/lib/step/socket-step.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Step        = require('./step'),
+    StepEnum    = require('./stepenum'),
+    Long        = require('long');
+
+function SocketStep(ipaddr, port) {
+    Step.call(this);
+
+    this.ipaddr = null; /*Buffer*/
+    this.port = 0;
+    this.elapsed = 0;
+    this.error = Long.ZERO;
+
+    if(Array.isArray(ipaddr)) {
+        this.ipaddr = ipaddr;
+        this.port = port;
+    }
+}
+
+SocketStep.prototype = new Step();
+SocketStep.prototype.constructor = SocketStep;
+SocketStep.prototype.getStepType = function () {
+    return StepEnum.SOCKET;
+};
+SocketStep.prototype.write = function(dout) {
+    Step.prototype.write.call(this, dout);
+    dout.writeBlob(this.ipaddr);
+    dout.writeDecimal(this.port);
+    dout.writeDecimal(this.elapsed);
+    dout.writeDecimal(this.error);
+};
+SocketStep.prototype.read = function(din) {
+    Step.prototype.read.call(this, din);
+    this.ipaddr = din.readBlob();
+    this.port = din.readDecNumber();
+    this.elapsed = din.readDecNumber();
+    this.error = din.readDecLong();
+    return this;
+};
+
+module.exports = SocketStep;

package/lib/step/sql-stepx.js

@@ -0,0 +1,68 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Step        = require('./step'),
+    StepEnum    = require('./stepenum'),
+    Long        = require('long');
+
+function SqlStepX() {
+    Step.call(this);
+
+    this.xtype = 0;
+    this.hash = 0;
+    this.elapsed = 0;
+    this.error = Long.ZERO;
+    this.updated = 0;
+    this.dbc = 0;
+
+    this.p1 = null;
+    this.p2 = null;
+    this.pcrc = 0;
+
+    this.start_cpu = 0;
+    this.start_mem = 0;  
+    this.stack = [];
+
+};
+SqlStepX.prototype = new Step();
+SqlStepX.prototype.constructor = SqlStepX;
+SqlStepX.prototype.getStepType = function () {
+    return StepEnum.SQL_X;
+};
+SqlStepX.prototype.write = function (dout) {
+    Step.prototype.write.call(this, dout);
+    dout.writeByte(0);
+    dout.writeDecimal(this.hash);
+    dout.writeDecimal(this.elapsed);
+    dout.writeDecimal(this.error);
+    dout.writeByte(this.xtype);
+    dout.writeDecimal(this.dbc);
+    dout.writeBlob(this.p1);
+    dout.writeBlob(this.p2);
+    dout.writeByte(this.pcrc);
+    dout.writeDecimal(this.start_cpu);
+    dout.writeDecimal(this.start_mem);
+    dout.writeIntArray(this.stack);
+};
+SqlStepX.prototype.read = function (din) {
+    Step.prototype.read.call(this, din);
+    var ver = din.readByte();
+    this.hash = din.readDecNumber();
+    this.elapsed = din.readDecNumber();
+    this.error = din.readDecNumber();
+    this.xtype = din.readByte();
+    this.dbc = din.readDecNumber();
+    this.p1 = din.readBlob();
+    this.p2 = din.readBlob();
+    this.pcrc = din.readByte();
+    this.start_cpu = din.readDecNumber();
+    this.start_mem = din.readDecNumber();
+    this.stack = din.readIntArray();
+ 
+     return this;
+};
+
+module.exports = SqlStepX;

package/lib/step/sqlxtype.js

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+exports.STMT = 0x0;
+exports.PREPARED = 0x1;
+exports.METHOD_KNOWN = 0x00;
+exports.METHOD_EXECUTE = 0x10;
+exports.METHOD_UPDATE = 0x20;
+exports.METHOD_QUERY = 0x30;
+
+exports.getClassType = function(xtype) {
+    return (xtype & 0x0f);
+};

package/lib/step/step.js

@@ -0,0 +1,66 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var DataOutputX = require('../io/data-outputx'),
+    DataInputX = require('../io/data-inputx');
+
+function Step() {
+    this.parent = 0;
+    this.index = 0;
+    this.start_time = 0;
+    this.opt = 0;
+};
+
+Step.prototype.getStepType = function() {};
+Step.prototype.getOrder = function () {
+    return this.index;
+};
+Step.prototype.write = function(dout) {
+    dout.writeDecimal(this.parent);
+    dout.writeDecimal(this.index);
+    dout.writeDecimal(this.start_time);
+};
+Step.prototype.read = function(din) {
+    this.parent = din.readDecNumber();
+    this.index = din.readDecNumber();
+    this.start_time = din.readDecNumber();
+    return this;
+};
+Step.prototype.compareTo = function(step) {
+    return this.getOrder() - step.getOrder();
+};
+Step.prototype.isTrue = function(flag) {
+    return (this.opt & flag) != 0;
+};
+Step.prototype.setTrue = function(flag) {
+    this.opt |= flag;
+};
+
+Step.toBytes = function(p) {
+    if(p == null ) {
+        return null;
+    }
+    var dout = new DataOutputX(p.length * 30);
+
+    for(var i=0; i< p.length; i++) {
+        dout.writeStep(p[i]);
+    }
+
+    return dout.toByteArray();
+};
+Step.toObjects = function(buff) {
+    if(buff == null ) {
+        return null;
+    }
+    var arr = [],
+        din = new DataInputX(buff);
+    while(din.available() > 0) {
+        arr.push(din.readStep());
+    }
+    return arr;
+};
+
+module.exports = Step;

package/lib/step/stepenum.js

@@ -0,0 +1,54 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var MethodStepX = require('./method-stepx'),
+    SqlStepX = require('./sql-stepx'),
+    ResultSetStep = require('./resultset-step'),
+    SocketStep = require('./socket-step'),
+    HTtpStepX = require('./http-stepx'),
+    ActiveStackStep = require('./activestack-step'),
+    MessageStep = require('./message-step'),
+    SecureMsgStep = require('./securemsg-step'),
+    DBCStep = require('./dbc-step');
+
+exports.METHOD = 1;
+exports.SQL = 2;
+exports.RESULTSET = 3;
+exports.HTTPCALL = 4;
+exports.SOCKET = 5;
+exports.ACTIVE_STACK = 6;
+exports.MESSAGE = 7;
+exports.DBC = 8;
+exports.SQL_2 = 9;
+exports.METHOD_2 = 11;
+exports.SECURE_MESSAGE = 15;
+
+exports.METHOD_X = 17;
+exports.SQL_X = 18;
+exports.HTTPCALL_X = 19;
+
+exports.create = function(type) {
+    switch (type) {
+        case this.METHOD_X:
+            return new MethodStepX();
+        case this.SQL_X:
+            return new SqlStepX();
+        case this.RESULTSET:
+            return new ResultSetStep();
+        case this.SOCKET:
+            return new SocketStep();
+        case this.HTTPCALL_X:
+            return new HTtpStepX();
+        case this.ACTIVE_STACK:
+            return new ActiveStackStep();
+        case this.MESSAGE:
+            return new MessageStep();
+        case this.SECURE_MESSAGE:
+            return new SecureMsgStep();
+        case this.DBC:
+            return new DBCStep();
+    };
+};

package/lib/topology/link.js

@@ -0,0 +1,63 @@
+var { InetAddress } = require('net');
+var CompareUtil = require('../util/compare-util');
+var HashUtil = require('../util/hashutil');
+
+function LINK() {
+    this.ip = null;
+    this.port = 0;
+
+    this.toString = function () {
+        if (this.ip === null) return `0.0.0.0:${this.port}`;
+        try {
+            return `${InetAddress.getByAddress(this.ip).getHostAddress()}:${this.port}`;
+        } catch (e) {
+            return `0.0.0.0:${this.port}`;
+        }
+    };
+
+    this.include = function (k) {
+        if (!CompareUtil.equals(this.ip, k.ip)) return false;
+        if (this.port === 0) return true;
+        return this.port === k.port;
+    };
+
+    this.equals = function (o) {
+        if (o.constructor !== this.constructor) return false;
+        var k = o;
+        if (!CompareUtil.equals(this.ip, k.ip)) return false;
+        return this.port === k.port;
+    };
+
+    this.hashCode = function () {
+        return HashUtil.hash(this.ip) | this.port;
+    };
+
+    this.toBytes = function (out) {
+        out.writeBlob(this.ip);
+        out.writeInt(this.port);
+        return this;
+    };
+
+    this.toObject = function (din) {
+        this.ip = din.readBlob();
+        this.port = din.readInt();
+        return this;
+    };
+}
+
+LINK.create = function (ipStr, port) {
+    var k = new LINK();
+    try {
+        k.ip = InetAddress.getByName(ipStr).getAddress();
+    } catch (e) {
+        k.ip = new Buffer(4);
+    }
+    k.port = port;
+    return k;
+};
+
+LINK.prototype = new LINK();
+LINK.prototype.constructor = LINK;
+
+module.exports = LINK;
+