ajsfw
Version:
Ajs Framework
210 lines (209 loc) • 8.43 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Protocol_1 = require("../message-transport/Protocol");
var exceptions = require("./exceptions");
var constants_1 = require("./constants");
var enums_1 = require("./enums");
var RMIEndpoint = (function () {
function RMIEndpoint(transport, service) {
var _this = this;
this.__initialized = false;
this.__transport = transport;
this.__nextCallId = 0;
this.__endPointId = Math.floor(Math.random() * (9999999 - 1000000)) + 1000000;
this.__callPromises = {};
this.__send = transport.send;
this.__service = service;
this.__registrationWaiters = [];
this.__transport.registerReceiver(Protocol_1.Protocol.AjsRMI, function (iface, data) { _this.__processMessage(data); });
this.__registerRmiEndpoint();
}
Object.defineProperty(RMIEndpoint.prototype, "endPointId", {
get: function () { return this.__endPointId; },
enumerable: true,
configurable: true
});
RMIEndpoint.prototype.waitRegistered = function () {
var _this = this;
if (this.__initialized) {
return Promise.resolve();
}
return new Promise(function (resolve, reject) {
_this.__registrationWaiters.push({
resolver: resolve,
rejector: reject
});
});
};
RMIEndpoint.prototype.makeCall = function (target, method) {
var _this = this;
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
if (!this.__initialized && target !== constants_1.RMI_ROUTER) {
console.log("EP-EPNotInit");
throw new exceptions.RMIEndpointNotInitializedException();
}
return new Promise(function (resolve, reject) {
var callId = _this.__getNextCallId();
_this.__callPromises[callId] = {
resolver: resolve,
rejector: reject
};
var rmiCall = {
callId: callId,
method: method,
args: args
};
_this.__sendRMIMessage(target, enums_1.RmiMessageType.Call, rmiCall);
});
};
RMIEndpoint.prototype.notify = function (target, method) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
var rmiNotify = {
method: method,
args: args
};
this.__sendRMIMessage(target, enums_1.RmiMessageType.Notify, rmiNotify);
};
RMIEndpoint.prototype.__registerRmiEndpoint = function () {
return __awaiter(this, void 0, void 0, function () {
var _a, _i, _b, waiter;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_a = this;
return [4, this.makeCall(constants_1.RMI_ROUTER, "registerRmiEndpoint")];
case 1:
_a.__endPointId = _c.sent();
this.__initialized = true;
this.__confirmRmiEndpointRegistration();
for (_i = 0, _b = this.__registrationWaiters; _i < _b.length; _i++) {
waiter = _b[_i];
waiter.resolver();
}
this.__registrationWaiters = [];
return [2];
}
});
});
};
RMIEndpoint.prototype.__confirmRmiEndpointRegistration = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
this.notify(constants_1.RMI_ROUTER, "endpointRegistrationConfirmed");
return [2];
});
});
};
RMIEndpoint.prototype.__getNextCallId = function () {
return this.__nextCallId++;
};
RMIEndpoint.prototype.__returnOk = function (target, callId, data) {
var ret = {
errorCode: 0,
callId: callId,
data: data
};
this.__sendRMIMessage(target, enums_1.RmiMessageType.Return, ret);
};
RMIEndpoint.prototype.__returnError = function (target, callId, errorCode, error) {
var ret = {
errorCode: errorCode,
callId: callId,
data: error.toString()
};
this.__sendRMIMessage(target, enums_1.RmiMessageType.Return, ret);
};
RMIEndpoint.prototype.__sendRMIMessage = function (target, rmiType, data) {
var rmiMessage = {
rmiDestinationId: target,
rmiSourceId: this.__endPointId,
rmiType: rmiType,
data: data
};
this.__transport.send(Protocol_1.Protocol.AjsRMI, rmiMessage);
};
RMIEndpoint.prototype.__processMessage = function (message) {
if (message.rmiDestinationId !== this.__endPointId) {
return;
}
switch (message.rmiType) {
case enums_1.RmiMessageType.Call:
this.__processCall(message.rmiSourceId, message.data);
break;
case enums_1.RmiMessageType.Notify:
this.__processNotify(message.data);
break;
case enums_1.RmiMessageType.Return:
this.__processReturn(message.data);
break;
default:
console.error("Invalid RMI message type!");
break;
}
};
RMIEndpoint.prototype.__processCall = function (sourceId, call) {
return __awaiter(this, void 0, void 0, function () {
var result, e_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
if (this.__service === undefined || this.__service === null) {
console.error("InvalidService");
throw new exceptions.InvalidServiceException();
}
if (!(call.method in this.__service) || !(this.__service[call.method] instanceof Function)) {
console.error("Invalid method");
throw new exceptions.InvalidServiceMethodException();
}
return [4, this.__service[call.method].apply(this.__service, call.args)];
case 1:
result = _a.sent();
this.__returnOk(sourceId, call.callId, result);
return [3, 3];
case 2:
e_1 = _a.sent();
this.__returnError(sourceId, call.callId, -1, e_1);
return [3, 3];
case 3: return [2];
}
});
});
};
RMIEndpoint.prototype.__processNotify = function (notify) {
try {
if (this.__service === undefined || this.__service === null) {
throw new exceptions.InvalidServiceException();
}
if (!(notify.method in this.__service) || !(this.__service instanceof Function)) {
throw new exceptions.InvalidServiceMethodException();
}
this.__service[notify.method].apply(this.__service, notify.args);
}
catch (e) {
console.error(e);
}
};
RMIEndpoint.prototype.__processReturn = function (ret) {
if (!(ret.callId in this.__callPromises)) {
console.error(new exceptions.InvalidReturnDataException());
return;
}
var callPromise = this.__callPromises[ret.callId];
delete this.__callPromises[ret.callId];
if (ret.errorCode === 0) {
callPromise.resolver(ret.data);
}
else {
callPromise.rejector(ret.data);
}
};
return RMIEndpoint;
}());
exports.RMIEndpoint = RMIEndpoint;