metaapi.cloud-sdk
Version:
SDK for MetaApi, a professional cloud forex API which includes MetaTrader REST API and MetaTrader websocket API. Supports both MetaTrader 5 (MT5) and MetaTrader 4 (MT4). CopyFactory copy trading API included. (https://metaapi.cloud)
618 lines (617 loc) • 106 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return StreamingMetaApiConnection;
}
});
const _terminalState = /*#__PURE__*/ _interop_require_default(require("./terminalState"));
const _memoryHistoryStorage = /*#__PURE__*/ _interop_require_default(require("./memoryHistoryStorage"));
const _timeoutError = /*#__PURE__*/ _interop_require_default(require("../clients/timeoutError"));
const _randomstring = /*#__PURE__*/ _interop_require_default(require("randomstring"));
const _connectionHealthMonitor = /*#__PURE__*/ _interop_require_default(require("./connectionHealthMonitor"));
const _errorHandler = require("../clients/errorHandler");
const _optionsValidator = /*#__PURE__*/ _interop_require_default(require("../clients/optionsValidator"));
const _logger = /*#__PURE__*/ _interop_require_default(require("../logger"));
const _metaApiConnection = /*#__PURE__*/ _interop_require_default(require("./metaApiConnection"));
function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
let StreamingMetaApiConnection = class StreamingMetaApiConnection extends _metaApiConnection.default {
/**
* Opens the connection. Can only be called the first time, next calls will be ignored.
* @param {string} instanceId connection instance id
* @return {Promise} promise resolving when the connection is opened
*/ async connect(instanceId) {
if (!this._openedInstances.includes(instanceId)) {
this._openedInstances.push(instanceId);
}
if (!this._opened) {
this._logger.trace(`${this._account.id}: Opening connection`);
this._opened = true;
try {
this._healthMonitor.start();
await this.initialize();
await this.subscribe();
} catch (err) {
await this.close();
throw err;
}
}
}
/**
* Clears the order and transaction history of a specified application and removes application
* @return {Promise} promise resolving when the history is cleared and application is removed
*/ removeApplication() {
this._checkIsConnectionActive();
this._historyStorage.clear();
return this._websocketClient.removeApplication(this._account.id);
}
/**
* Requests the terminal to start synchronization process
* (see https://metaapi.cloud/docs/client/websocket/synchronizing/synchronize/)
* @param {String} instanceIndex instance index
* @returns {Promise} promise which resolves when synchronization started
*/ async synchronize(instanceIndex) {
this._checkIsConnectionActive();
const region = this.getRegion(instanceIndex);
const instance = this.getInstanceNumber(instanceIndex);
const host = this.getHostName(instanceIndex);
let startingHistoryOrderTime = new Date(Math.max((this._historyStartTime || new Date(0)).getTime(), (await this._historyStorage.lastHistoryOrderTime(instance)).getTime()));
let startingDealTime = new Date(Math.max((this._historyStartTime || new Date(0)).getTime(), (await this._historyStorage.lastDealTime(instance)).getTime()));
let synchronizationId = _randomstring.default.generate(32);
this._getState(instanceIndex).lastSynchronizationId = synchronizationId;
const accountId = this._account.accountRegions[region];
this._logger.debug(`${this._account.id}:${instanceIndex}: initiating synchronization ${synchronizationId}`);
return this._websocketClient.synchronize(accountId, instance, host, synchronizationId, startingHistoryOrderTime, startingDealTime, this.terminalState.getHashes());
}
/**
* Initializes meta api connection
* @return {Promise} promise which resolves when meta api connection is initialized
*/ async initialize() {
this._checkIsConnectionActive();
await this._historyStorage.initialize(this._account.id, this._connectionRegistry.application);
this._websocketClient.addAccountCache(this._account.id, this._account.accountRegions);
}
/**
* Initiates subscription to MetaTrader terminal
* @returns {Promise} promise which resolves when subscription is initiated
*/ async subscribe() {
this._checkIsConnectionActive();
const accountRegions = this._account.accountRegions;
Object.entries(accountRegions).forEach(([region, replicaId])=>{
if (!this._options.region || this._options.region === region) {
this._websocketClient.ensureSubscribe(replicaId, 0);
this._websocketClient.ensureSubscribe(replicaId, 1);
}
});
}
/**
* Subscribes on market data of specified symbol (see
* https://metaapi.cloud/docs/client/websocket/marketDataStreaming/subscribeToMarketData/).
* @param {String} symbol symbol (e.g. currency pair or an index)
* @param {Array<MarketDataSubscription>} subscriptions array of market data subscription to create or update. Please
* note that this feature is not fully implemented on server-side yet
* @param {number} [timeoutInSeconds] timeout to wait for prices in seconds, default is 30
* @param {boolean} [waitForQuote] if set to false, the method will resolve without waiting for the first quote to
* arrive. Default is to wait for quote if quotes subscription is requested.
* @returns {Promise} promise which resolves when subscription request was processed
*/ async subscribeToMarketData(symbol, subscriptions, timeoutInSeconds, waitForQuote = true) {
this._checkIsConnectionActive();
if (!this._terminalState.specification(symbol)) {
throw new _errorHandler.ValidationError(`${this._account.id}: Cannot subscribe to market data for symbol ${symbol} because ` + "symbol does not exist");
} else {
subscriptions = subscriptions || [
{
type: "quotes"
}
];
if (this._subscriptions[symbol]) {
const prevSubscriptions = this._subscriptions[symbol].subscriptions;
subscriptions.forEach((subscription)=>{
const index = subscription.type === "candles" ? prevSubscriptions.findIndex((item)=>item.type === subscription.type && item.timeframe === subscription.timeframe) : prevSubscriptions.findIndex((item)=>item.type === subscription.type);
if (index === -1) {
prevSubscriptions.push(subscription);
} else {
prevSubscriptions[index] = subscription;
}
});
} else {
this._subscriptions[symbol] = {
subscriptions
};
}
await this._websocketClient.subscribeToMarketData(this._account.id, symbol, subscriptions, this._account.reliability);
if (waitForQuote !== false && subscriptions.find((s)=>s.type === "quotes")) {
return this.terminalState.waitForPrice(symbol, timeoutInSeconds);
}
}
}
/**
* Unsubscribes from market data of specified symbol (see
* https://metaapi.cloud/docs/client/websocket/marketDataStreaming/unsubscribeFromMarketData/).
* @param {String} symbol symbol (e.g. currency pair or an index)
* @param {Array<MarketDataUnsubscription>} unsubscriptions array of subscriptions to cancel
* @returns {Promise} promise which resolves when unsubscription request was processed
*/ unsubscribeFromMarketData(symbol, unsubscriptions) {
this._checkIsConnectionActive();
if (!unsubscriptions) {
delete this._subscriptions[symbol];
} else if (this._subscriptions[symbol]) {
this._subscriptions[symbol].subscriptions = this._subscriptions[symbol].subscriptions.filter((subscription)=>{
return !unsubscriptions.find((unsubscription)=>subscription.type === unsubscription.type && (!unsubscription.timeframe || subscription.timeframe === unsubscription.timeframe));
});
if (!this._subscriptions[symbol].subscriptions.length) {
delete this._subscriptions[symbol];
}
}
return this._websocketClient.unsubscribeFromMarketData(this._account.id, symbol, unsubscriptions, this._account.reliability);
}
/**
* Invoked when subscription downgrade has occurred
* @param {String} instanceIndex index of an account instance connected
* @param {string} symbol symbol to update subscriptions for
* @param {Array<MarketDataSubscription>} updates array of market data subscription to update
* @param {Array<MarketDataUnsubscription>} unsubscriptions array of subscriptions to cancel
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ // eslint-disable-next-line complexity
async onSubscriptionDowngraded(instanceIndex, symbol, updates, unsubscriptions) {
if (unsubscriptions === null || unsubscriptions === void 0 ? void 0 : unsubscriptions.length) {
this.unsubscribeFromMarketData(symbol, unsubscriptions).catch((err)=>{
let method = err.name !== "ValidationError" ? "error" : "trace";
this._logger[method](`${this._account.id}: failed do unsubscribe from market data on subscription downgraded`, err);
});
}
if (updates === null || updates === void 0 ? void 0 : updates.length) {
this.subscribeToMarketData(symbol, updates).catch((err)=>{
this._logger.error(`${this._account.id}: failed do subscribe from market data on subscription downgraded`, err);
});
}
}
/**
* Returns list of the symbols connection is subscribed to
* @returns {Array<String>} list of the symbols connection is subscribed to
*/ get subscribedSymbols() {
return Object.keys(this._subscriptions);
}
/**
* Returns subscriptions for a symbol
* @param {string} symbol symbol to retrieve subscriptions for
* @returns {Array<MarketDataSubscription>} list of market data subscriptions for the symbol
*/ subscriptions(symbol) {
this._checkIsConnectionActive();
return (this._subscriptions[symbol] || {}).subscriptions;
}
/**
* Returns local copy of terminal state
* @returns {TerminalState} local copy of terminal state
*/ get terminalState() {
return this._terminalState;
}
/**
* Returns local history storage
* @returns {HistoryStorage} local history storage
*/ get historyStorage() {
return this._historyStorage;
}
/**
* Invoked when connection to MetaTrader terminal established
* @param {String} instanceIndex index of an account instance connected
* @param {Number} replicas number of account replicas launched
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ async onConnected(instanceIndex, replicas) {
let key = _randomstring.default.generate(32);
let state = this._getState(instanceIndex);
const region = this.getRegion(instanceIndex);
this.cancelRefresh(region);
await this._terminalHashManager.refreshIgnoredFieldLists(region);
state.shouldSynchronize = key;
state.synchronizationRetryIntervalInSeconds = 1;
state.synchronized = false;
this._ensureSynchronized(instanceIndex, key);
this._logger.debug(`${this._account.id}:${instanceIndex}: connected to broker`);
}
/**
* Invoked when connection to MetaTrader terminal terminated
* @param {String} instanceIndex index of an account instance connected
*/ async onDisconnected(instanceIndex) {
let state = this._getState(instanceIndex);
state.lastDisconnectedSynchronizationId = state.lastSynchronizationId;
state.lastSynchronizationId = undefined;
state.shouldSynchronize = undefined;
state.synchronized = false;
state.disconnected = true;
const instanceNumber = this.getInstanceNumber(instanceIndex);
const region = this.getRegion(instanceIndex);
const instance = `${region}:${instanceNumber}`;
delete this._refreshMarketDataSubscriptionSessions[instance];
clearTimeout(this._refreshMarketDataSubscriptionTimeouts[instance]);
delete this._refreshMarketDataSubscriptionTimeouts[instance];
clearTimeout(state.synchronizationTimeout);
delete state.synchronizationTimeout;
clearTimeout(state.ensureSynchronizeTimeout);
delete state.ensureSynchronizeTimeout;
this._logger.debug(`${this._account.id}:${instanceIndex}: disconnected from broker`);
}
/**
* Invoked when a symbol specifications were updated
* @param {String} instanceIndex index of account instance connected
* @param {Array<MetatraderSymbolSpecification>} specifications updated specifications
* @param {Array<String>} removedSymbols removed symbols
*/ async onSymbolSpecificationsUpdated(instanceIndex, specifications, removedSymbols) {
this._scheduleSynchronizationTimeout(instanceIndex);
}
/**
* Invoked when position synchronization finished to indicate progress of an initial terminal state synchronization
* @param {string} instanceIndex index of an account instance connected
* @param {String} synchronizationId synchronization request id
*/ async onPositionsSynchronized(instanceIndex, synchronizationId) {
this._scheduleSynchronizationTimeout(instanceIndex);
}
/**
* Invoked when pending order synchronization fnished to indicate progress of an initial terminal state
* synchronization
* @param {string} instanceIndex index of an account instance connected
* @param {String} synchronizationId synchronization request id
*/ async onPendingOrdersSynchronized(instanceIndex, synchronizationId) {
this._scheduleSynchronizationTimeout(instanceIndex);
}
/**
* Invoked when a synchronization of history deals on a MetaTrader account have finished to indicate progress of an
* initial terminal state synchronization
* @param {String} instanceIndex index of an account instance connected
* @param {String} synchronizationId synchronization request id
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ async onDealsSynchronized(instanceIndex, synchronizationId) {
let state = this._getState(instanceIndex);
state.dealsSynchronized[synchronizationId] = true;
this._scheduleSynchronizationTimeout(instanceIndex);
this._logger.debug(`${this._account.id}:${instanceIndex}: finished synchronization ${synchronizationId}`);
}
/**
* Invoked when a synchronization of history orders on a MetaTrader account have finished to indicate progress of an
* initial terminal state synchronization
* @param {String} instanceIndex index of an account instance connected
* @param {String} synchronizationId synchronization request id
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ async onHistoryOrdersSynchronized(instanceIndex, synchronizationId) {
let state = this._getState(instanceIndex);
state.ordersSynchronized[synchronizationId] = true;
this._scheduleSynchronizationTimeout(instanceIndex);
}
/**
* Invoked when connection to MetaApi websocket API restored after a disconnect
* @param {String} region reconnected region
* @param {Number} instanceNumber reconnected instance number
* @return {Promise} promise which resolves when connection to MetaApi websocket API restored after a disconnect
*/ async onReconnected(region, instanceNumber) {
const instanceTemplate = `${region}:${instanceNumber}`;
Object.keys(this._stateByInstanceIndex).filter((key)=>key.startsWith(`${instanceTemplate}:`)).forEach((key)=>{
delete this._stateByInstanceIndex[key];
});
delete this._refreshMarketDataSubscriptionSessions[instanceTemplate];
clearTimeout(this._refreshMarketDataSubscriptionTimeouts[instanceTemplate]);
delete this._refreshMarketDataSubscriptionTimeouts[instanceTemplate];
}
/**
* Invoked when a stream for an instance index is closed
* @param {String} instanceIndex index of an account instance connected
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ async onStreamClosed(instanceIndex) {
delete this._stateByInstanceIndex[instanceIndex];
}
/**
* Invoked when MetaTrader terminal state synchronization is started
* @param {string} instanceIndex index of an account instance connected
* @param {string} specificationsHash specifications hash
* @param {string} positionsHash positions hash
* @param {string} ordersHash orders hash
* @param {string} synchronizationId synchronization id
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ async onSynchronizationStarted(instanceIndex, specificationsHash, positionsHash, ordersHash, synchronizationId) {
this._logger.debug(`${this._account.id}:${instanceIndex}: starting synchronization ${synchronizationId}`);
const instanceNumber = this.getInstanceNumber(instanceIndex);
const region = this.getRegion(instanceIndex);
const instance = `${region}:${instanceNumber}`;
const accountId = this._account.accountRegions[region];
delete this._refreshMarketDataSubscriptionSessions[instance];
let sessionId = _randomstring.default.generate(32);
this._refreshMarketDataSubscriptionSessions[instance] = sessionId;
clearTimeout(this._refreshMarketDataSubscriptionTimeouts[instance]);
delete this._refreshMarketDataSubscriptionTimeouts[instance];
await this._refreshMarketDataSubscriptions(accountId, instanceNumber, sessionId);
this._scheduleSynchronizationTimeout(instanceIndex);
let state = this._getState(instanceIndex);
if (state && !this._closed) {
state.lastSynchronizationId = synchronizationId;
}
}
/**
* Invoked when account region has been unsubscribed
* @param {String} region account region unsubscribed
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ async onUnsubscribeRegion(region) {
Object.keys(this._refreshMarketDataSubscriptionTimeouts).filter((instance)=>instance.startsWith(`${region}:`)).forEach((instance)=>{
clearTimeout(this._refreshMarketDataSubscriptionTimeouts[instance]);
delete this._refreshMarketDataSubscriptionTimeouts[instance];
delete this._refreshMarketDataSubscriptionSessions[instance];
});
Object.keys(this._stateByInstanceIndex).filter((instance)=>instance.startsWith(`${region}:`)).forEach((instance)=>delete this._stateByInstanceIndex[instance]);
}
/**
* Returns flag indicating status of state synchronization with MetaTrader terminal
* @param {String} instanceIndex index of an account instance connected
* @param {String} synchronizationId optional synchronization request id, last synchronization request id will be used
* by default
* @return {Promise<Boolean>} promise resolving with a flag indicating status of state synchronization with MetaTrader
* terminal
*/ async isSynchronized(instanceIndex, synchronizationId) {
return Object.values(this._stateByInstanceIndex).reduce((acc, s)=>{
if (instanceIndex !== undefined && s.instanceIndex !== instanceIndex) {
return acc;
}
const checkSynchronizationId = synchronizationId || s.lastSynchronizationId;
let synchronized = !!s.ordersSynchronized[checkSynchronizationId] && !!s.dealsSynchronized[checkSynchronizationId];
return acc || synchronized;
}, false);
}
/**
* @typedef {Object} SynchronizationOptions
* @property {String} [applicationPattern] application regular expression pattern, default is .*
* @property {String} [synchronizationId] synchronization id, last synchronization request id will be used by
* default
* @property {Number} [instanceIndex] index of an account instance to ensure synchronization on, default is to wait
* for the first instance to synchronize
* @property {Number} [timeoutInSeconds] wait timeout in seconds, default is 5m
* @property {Number} [intervalInMilliseconds] interval between account reloads while waiting for a change, default is 1s
*/ /**
* Waits until synchronization to MetaTrader terminal is completed
* @param {SynchronizationOptions} opts synchronization options
* @return {Promise} promise which resolves when synchronization to MetaTrader terminal is completed
* @throws {TimeoutError} if application failed to synchronize with the teminal within timeout allowed
*/ // eslint-disable-next-line complexity
async waitSynchronized(opts) {
this._checkIsConnectionActive();
opts = opts || {};
let instanceIndex = opts.instanceIndex;
let synchronizationId = opts.synchronizationId;
let timeoutInSeconds = opts.timeoutInSeconds || 300;
let intervalInMilliseconds = opts.intervalInMilliseconds || 1000;
let applicationPattern = opts.applicationPattern || (this._account.application === "CopyFactory" ? "CopyFactory.*|RPC" : "RPC");
let startTime = Date.now();
let synchronized;
while(!(synchronized = await this.isSynchronized(instanceIndex, synchronizationId)) && startTime + timeoutInSeconds * 1000 > Date.now()){
await new Promise((res)=>setTimeout(res, intervalInMilliseconds));
}
let state;
if (instanceIndex === undefined) {
for (let s of Object.values(this._stateByInstanceIndex)){
if (await this.isSynchronized(s.instanceIndex, synchronizationId)) {
state = s;
instanceIndex = s.instanceIndex;
}
}
} else {
state = Object.values(this._stateByInstanceIndex).find((s)=>s.instanceIndex === instanceIndex);
}
if (!synchronized) {
throw new _timeoutError.default("Timed out waiting for MetaApi to synchronize to MetaTrader account " + this._account.id + ", synchronization id " + (synchronizationId || state && state.lastSynchronizationId || state && state.lastDisconnectedSynchronizationId));
}
let timeLeftInSeconds = Math.max(0, timeoutInSeconds - (Date.now() - startTime) / 1000);
const region = this.getRegion(state.instanceIndex);
const accountId = this._account.accountRegions[region];
await this._websocketClient.waitSynchronized(accountId, this.getInstanceNumber(instanceIndex), applicationPattern, timeLeftInSeconds);
}
/**
* Closes the connection. The instance of the class should no longer be used after this method is invoked.
* @param {string} instanceId connection instance id
*/ async close(instanceId) {
if (this._opened) {
this._openedInstances = this._openedInstances.filter((id)=>id !== instanceId);
if (!this._openedInstances.length && !this._closed) {
this._logger.debug(`${this._account.id}: Closing connection`);
Object.values(this._stateByInstanceIndex).forEach((state)=>clearTimeout(state.synchronizationTimeout));
this._stateByInstanceIndex = {};
await this._connectionRegistry.removeStreaming(this._account);
this._terminalState.close();
const accountRegions = this._account.accountRegions;
this._websocketClient.removeSynchronizationListener(this._account.id, this);
this._websocketClient.removeSynchronizationListener(this._account.id, this._terminalState);
this._websocketClient.removeSynchronizationListener(this._account.id, this._historyStorage);
this._websocketClient.removeSynchronizationListener(this._account.id, this._healthMonitor);
this._websocketClient.removeReconnectListener(this);
this._healthMonitor.stop();
this._refreshMarketDataSubscriptionSessions = {};
Object.values(this._refreshMarketDataSubscriptionTimeouts).forEach((timeout)=>clearTimeout(timeout));
this._refreshMarketDataSubscriptionTimeouts = {};
Object.values(accountRegions).forEach((replicaId)=>this._websocketClient.removeAccountCache(replicaId));
this._closed = true;
this._logger.trace(`${this._account.id}: Closed connection`);
}
}
}
/**
* Returns synchronization status
* @return {boolean} synchronization status
*/ get synchronized() {
return Object.values(this._stateByInstanceIndex).reduce((acc, s)=>acc || s.synchronized, false);
}
/**
* Returns MetaApi account
* @return {MetatraderAccount} MetaApi account
*/ get account() {
return this._account;
}
/**
* Returns connection health monitor instance
* @return {ConnectionHealthMonitor} connection health monitor instance
*/ get healthMonitor() {
return this._healthMonitor;
}
async _refreshMarketDataSubscriptions(accountId, instanceNumber, session) {
const region = this._websocketClient.getAccountRegion(accountId);
const instance = `${region}:${instanceNumber}`;
try {
if (this._refreshMarketDataSubscriptionSessions[instance] === session) {
const subscriptionsList = [];
Object.keys(this._subscriptions).forEach((key)=>{
const subscriptions = this.subscriptions(key);
const subscriptionsItem = {
symbol: key
};
if (subscriptions) {
subscriptionsItem.subscriptions = subscriptions;
}
subscriptionsList.push(subscriptionsItem);
});
await this._websocketClient.refreshMarketDataSubscriptions(accountId, instanceNumber, subscriptionsList);
}
} catch (err) {
this._logger.error(`Error refreshing market data subscriptions job for account ${this._account.id} ` + `${instanceNumber}`, err);
} finally{
if (this._refreshMarketDataSubscriptionSessions[instance] === session) {
let refreshInterval = (Math.random() * (this._maxSubscriptionRefreshInterval - this._minSubscriptionRefreshInterval) + this._minSubscriptionRefreshInterval) * 1000;
this._refreshMarketDataSubscriptionTimeouts[instance] = setTimeout(()=>this._refreshMarketDataSubscriptions(accountId, instanceNumber, session), refreshInterval);
}
}
}
_generateStopOptions(stopLoss, takeProfit) {
let trade = {};
if (typeof stopLoss === "number") {
trade.stopLoss = stopLoss;
} else if (stopLoss) {
trade.stopLoss = stopLoss.value;
trade.stopLossUnits = stopLoss.units;
}
if (typeof takeProfit === "number") {
trade.takeProfit = takeProfit;
} else if (takeProfit) {
trade.takeProfit = takeProfit.value;
trade.takeProfitUnits = takeProfit.units;
}
return trade;
}
async _ensureSynchronized(instanceIndex, key) {
let state = this._getState(instanceIndex);
if (state && state.shouldSynchronize && !this._closed) {
try {
const synchronizationResult = await this.synchronize(instanceIndex);
if (synchronizationResult) {
state.synchronized = true;
state.synchronizationRetryIntervalInSeconds = 1;
delete state.ensureSynchronizeTimeout;
}
this._scheduleSynchronizationTimeout(instanceIndex);
} catch (err) {
const level = this._latencyService.getSynchronizedAccountInstances(this._account.id).length ? "debug" : "error";
this._logger[level]("MetaApi websocket client for account " + this._account.id + ":" + instanceIndex + " failed to synchronize", err);
if (state.shouldSynchronize === key) {
clearTimeout(state.ensureSynchronizeTimeout);
state.ensureSynchronizeTimeout = setTimeout(this._ensureSynchronized.bind(this, instanceIndex, key), state.synchronizationRetryIntervalInSeconds * 1000);
state.synchronizationRetryIntervalInSeconds = Math.min(state.synchronizationRetryIntervalInSeconds * 2, 300);
}
}
}
}
_getState(instanceIndex) {
if (!this._stateByInstanceIndex["" + instanceIndex]) {
this._stateByInstanceIndex["" + instanceIndex] = {
instanceIndex,
ordersSynchronized: {},
dealsSynchronized: {},
shouldSynchronize: undefined,
synchronizationRetryIntervalInSeconds: 1,
synchronized: false,
lastDisconnectedSynchronizationId: undefined,
lastSynchronizationId: undefined,
disconnected: false
};
}
return this._stateByInstanceIndex["" + instanceIndex];
}
_scheduleSynchronizationTimeout(instanceIndex) {
let state = this._getState(instanceIndex);
if (state && !this._closed) {
clearTimeout(state.synchronizationTimeout);
state.synchronizationTimeout = setTimeout(()=>this._checkSynchronizationTimedOut(instanceIndex), 2 * 60 * 1000);
this._logger.debug(`${this._account.id}:${instanceIndex}: scheduled synchronization timeout`);
}
}
_checkSynchronizationTimedOut(instanceIndex) {
this._logger.debug(`${this._account.id}:${instanceIndex}: checking if synchronization timed out out`);
let state = this._getState(instanceIndex);
if (state && !this._closed) {
let synchronizationId = state.lastSynchronizationId;
let synchronized = !!state.dealsSynchronized[synchronizationId];
if (!synchronized && synchronizationId && state.shouldSynchronize) {
this._logger.warn(`${this._account.id}:${instanceIndex}: resynchronized since latest synchronization ` + `${synchronizationId} did not finish in time`);
this._ensureSynchronized(instanceIndex, state.shouldSynchronize);
}
}
}
/**
* Constructs MetaApi MetaTrader streaming Api connection
* @param {MetaApiOpts} options metaapi options
* @param {MetaApiWebsocketClient} websocketClient MetaApi websocket client
* @param {TerminalHashManager} terminalHashManager terminal hash manager
* @param {MetatraderAccount} account MetaTrader account id to connect to
* @param {HistoryStorage} historyStorage terminal history storage. By default an instance of MemoryHistoryStorage
* will be used.
* @param {ConnectionRegistry} connectionRegistry metatrader account connection registry
* @param {Date} [historyStartTime] history start sync time
* @param {RefreshSubscriptionsOpts} [refreshSubscriptionsOpts] subscriptions refresh options
*/ constructor(options, websocketClient, terminalHashManager, account, historyStorage, connectionRegistry, historyStartTime, refreshSubscriptionsOpts){
super(options, websocketClient, account);
_define_property(this, "_minSubscriptionRefreshInterval", void 0);
_define_property(this, "_maxSubscriptionRefreshInterval", void 0);
_define_property(this, "_historyStartTime", void 0);
_define_property(this, "_terminalHashManager", void 0);
_define_property(this, "_terminalState", void 0);
_define_property(this, "_historyStorage", void 0);
_define_property(this, "_healthMonitor", void 0);
_define_property(this, "_subscriptions", void 0);
_define_property(this, "_refreshMarketDataSubscriptionSessions", void 0);
_define_property(this, "_refreshMarketDataSubscriptionTimeouts", void 0);
_define_property(this, "_openedInstances", void 0);
refreshSubscriptionsOpts = refreshSubscriptionsOpts || {};
const validator = new _optionsValidator.default();
this._minSubscriptionRefreshInterval = validator.validateNonZero(refreshSubscriptionsOpts.minDelayInSeconds, 1, "refreshSubscriptionsOpts.minDelayInSeconds");
this._maxSubscriptionRefreshInterval = validator.validateNonZero(refreshSubscriptionsOpts.maxDelayInSeconds, 600, "refreshSubscriptionsOpts.maxDelayInSeconds");
this._connectionRegistry = connectionRegistry;
this._historyStartTime = historyStartTime;
this._terminalHashManager = terminalHashManager;
this._terminalState = new _terminalState.default(account, terminalHashManager, this._websocketClient);
this._historyStorage = historyStorage || new _memoryHistoryStorage.default();
this._healthMonitor = new _connectionHealthMonitor.default(this);
this._websocketClient.addSynchronizationListener(account.id, this);
this._websocketClient.addSynchronizationListener(account.id, this._terminalState);
this._websocketClient.addSynchronizationListener(account.id, this._historyStorage);
this._websocketClient.addSynchronizationListener(account.id, this._healthMonitor);
Object.values(account.accountRegions).forEach((replicaId)=>this._websocketClient.addReconnectListener(this, replicaId));
this._subscriptions = {};
this._stateByInstanceIndex = {};
this._refreshMarketDataSubscriptionSessions = {};
this._refreshMarketDataSubscriptionTimeouts = {};
this._openedInstances = [];
this._logger = _logger.default.getLogger("MetaApiConnection");
}
};
//# sourceMappingURL=data:application/json;base64,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