@glue42/bbg-market-data
Version:
A high-level API that wraps existing Glue42 Bloomberg Bridge Market Data interop methods. The API is based on the jBloomberg open source wrapper.
199 lines (198 loc) • 9.39 kB
JavaScript
import { __awaiter, __rest } from "tslib";
import CallbackRegistryFactory from "callback-registry";
import { RequestStatus } from "../request-status";
import { BloombergError, } from "./types";
import { getFailureReason, getMessageDetails, isEventOfType, isMessageOfType, isPending, setSubscriptionCreatedStatus, setSubscriptionIds, toTerminalSubscription, } from "./helpers";
import { serviceOpenedFailureHandler, sessionStartUpFailureHandler, sessionTerminatedHandler, } from "./message-handlers";
import { EventTypes } from "./event-types";
import { SubscriptionStatus } from "./types/subscription";
import { MessageTypes } from "./message-types";
import { callSafe } from "./../utils";
import CorrelationId from "./../correlationId";
const DATA_EVENT = "data-event";
const ERROR_EVENT = "error-event";
const STATUS_EVENT = "status-event";
const FAIL_EVENT = "fail-event";
const BBG_EVENT = "bbg-event";
export class SubscriptionRequestImpl {
constructor(sessionManager, config, subscriptions, subscriptionDataHandler) {
this.sessionManager = sessionManager;
this.config = config;
this.subscriptions = subscriptions;
this.subscriptionDataHandler = subscriptionDataHandler;
this.registry = CallbackRegistryFactory();
this._status = RequestStatus.Created;
this.subscriptionsByInternalIdMap = new Map();
this.sessionInstance = this.sessionManager.getSubscriptionReqSessionInstance();
}
get api() {
const requestImpl = this;
return {
get id() {
return requestImpl.requestId;
},
get settings() {
return {
operation: requestImpl.config.operation,
service: requestImpl.config.service,
};
},
get status() {
return requestImpl._status;
},
open: requestImpl.open.bind(requestImpl),
close: requestImpl.close.bind(requestImpl),
onData: (callback) => {
return requestImpl.registry.add(DATA_EVENT, callback);
},
onError: (callback) => {
return requestImpl.registry.add(ERROR_EVENT, callback);
},
onEvent: (callback) => {
return requestImpl.registry.add(BBG_EVENT, callback);
},
onStatus: (callback) => {
callSafe(callback, requestImpl._status);
return requestImpl.registry.add(STATUS_EVENT, callback);
},
onFail: (callback) => {
return requestImpl.registry.add(FAIL_EVENT, callback);
},
};
}
open(options) {
if (isPending(this._status)) {
throw new Error("Request can be opened/reopened if its status is Created, Failed, Closed or Completed. Either close the request or wait it to complete.");
}
const _a = options !== null && options !== void 0 ? options : {}, { session } = _a, otherSettings = __rest(_a, ["session"]);
this.sessionInstance = this.sessionManager.getSubscriptionReqSessionInstance(session);
this.reset();
this.requestId = new CorrelationId(this.config.service, this.config.operation).value;
const handleOpenSuccess = () => {
this.requestActivated();
};
const handleOpenFail = (error) => {
this.requestFailed(error);
};
const handleEvent = (event) => {
this.registry.execute(BBG_EVENT, event);
};
const messageProcessor = (msg) => __awaiter(this, void 0, void 0, function* () {
yield this.processEventMessage(msg);
});
this.requestOpened();
const terminalSubscriptions = Array.from(this.subscriptionsByInternalIdMap.values()).map(toTerminalSubscription);
this.sessionInstance.openSubscriptionRequest(this.requestId, this.config, terminalSubscriptions, otherSettings !== null && otherSettings !== void 0 ? otherSettings : {}, handleEvent, messageProcessor, handleOpenSuccess, handleOpenFail);
}
close() {
return __awaiter(this, void 0, void 0, function* () {
yield this.sessionInstance.closeRequest(this.requestId, () => this.requestClosed());
});
}
processEventMessage(eventMessage) {
return __awaiter(this, void 0, void 0, function* () {
const error = [
sessionStartUpFailureHandler(eventMessage),
sessionTerminatedHandler(eventMessage),
serviceOpenedFailureHandler(eventMessage),
].find(({ match }) => match);
if (error != null) {
this.requestFailed(error.data);
return;
}
this.processSubscriptionErrors(eventMessage);
if (isEventOfType(eventMessage, EventTypes.SubscriptionData)) {
this.processSubscriptionData(eventMessage);
}
});
}
processSubscriptionData(eventMessage) {
try {
const subscriptionDataByInternalIdMap = this.subscriptionDataHandler(eventMessage);
const response = [];
subscriptionDataByInternalIdMap.forEach((data, internalId) => {
const subscription = this.subscriptionsByInternalIdMap.get(internalId);
if (subscription) {
response.push(Object.assign(Object.assign({}, data), { subscriptionId: subscription.subscriptionId, security: subscription.security }));
}
});
this.registry.execute(DATA_EVENT, response);
}
catch (error) {
console.error(error);
}
}
processSubscriptionErrors(eventMessage) {
const subscriptionStatusHandler = (_a, messageType) => {
var { correlationIds } = _a, eventMessage = __rest(_a, ["correlationIds"]);
const errorsMap = new Map();
if (!isMessageOfType(eventMessage, messageType)) {
return errorsMap;
}
const messageDetails = getMessageDetails(eventMessage, messageType);
(correlationIds !== null && correlationIds !== void 0 ? correlationIds : []).forEach((id) => {
errorsMap.set(id, messageDetails === null || messageDetails === void 0 ? void 0 : messageDetails.reason);
});
return errorsMap;
};
const errors = [];
const failureErrorsByInternalIdMap = subscriptionStatusHandler(eventMessage, MessageTypes.SubscriptionFailure);
failureErrorsByInternalIdMap.forEach((error, internalId) => {
const subscription = this.subscriptionsByInternalIdMap.get(internalId);
if (subscription) {
subscription.status = SubscriptionStatus.SubscriptionFailure;
error.subscriptionId = subscription.subscriptionId;
}
errors.push(error);
});
const terminatedErrorsMap = subscriptionStatusHandler(eventMessage, MessageTypes.SubscriptionTerminated);
terminatedErrorsMap.forEach((error, internalId) => {
const subscription = this.subscriptionsByInternalIdMap.get(internalId);
if (subscription) {
subscription.status = SubscriptionStatus.SubscriptionTerminated;
error.subscriptionId = subscription.subscriptionId;
}
errors.push(error);
});
if (errors.length > 0) {
this.raiseSubscriptionErrors(errors);
const hasActiveSubscriptions = Array.from(this.subscriptionsByInternalIdMap.values()).some(({ status }) => status != SubscriptionStatus.SubscriptionFailure && status != SubscriptionStatus.SubscriptionTerminated);
if (!hasActiveSubscriptions) {
const error = new BloombergError(EventTypes.SubscriptionStatus, "SubscriptionFailure|SubscriptionTerminated", "All subscriptions are inactive. No more updates will be received for them.");
return this.requestFailed(error);
}
}
}
raiseSubscriptionErrors(errors) {
this.registry.execute(FAIL_EVENT, errors);
}
requestOpened() {
this._status = RequestStatus.Opened;
this.raiseStatusChanged();
}
requestActivated() {
this._status = RequestStatus.Active;
this.raiseStatusChanged();
}
requestClosed() {
this._status = RequestStatus.Closed;
this.raiseStatusChanged();
}
requestFailed(error) {
const reason = getFailureReason(this.requestId, error);
this.sessionInstance.disposeRequest(this.requestId, reason);
this._status = RequestStatus.Failed;
this.raiseStatusChanged();
this.registry.execute(ERROR_EVENT, error);
}
raiseStatusChanged() {
this.registry.execute(STATUS_EVENT, this._status);
}
reset() {
this.subscriptionsByInternalIdMap.clear();
this.subscriptions.forEach((s) => {
s = setSubscriptionIds(setSubscriptionCreatedStatus(s));
this.subscriptionsByInternalIdMap.set(s.internalId, s);
});
}
}