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)
166 lines (165 loc) • 22.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return RpcMetaApiConnection;
}
});
const _logger = /*#__PURE__*/ _interop_require_default(require("../logger"));
const _metaApiConnection = /*#__PURE__*/ _interop_require_default(require("./metaApiConnection"));
const _timeoutError = /*#__PURE__*/ _interop_require_default(require("../clients/timeoutError"));
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 RpcMetaApiConnection = class RpcMetaApiConnection 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._opened = true;
const accountRegions = this._account.accountRegions;
this._websocketClient.addAccountCache(this._account.id, accountRegions);
Object.keys(accountRegions).forEach((region)=>{
if (!this._options.region || this._options.region === region) {
this._websocketClient.ensureSubscribe(accountRegions[region], 0);
this._websocketClient.ensureSubscribe(accountRegions[region], 1);
}
});
}
}
/**
* 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) {
await this._connectionRegistry.removeRpc(this.account);
this._websocketClient.removeSynchronizationListener(this.account.id, this);
this._websocketClient.removeAccountCache(this.account.id);
this._websocketClient.removeReconnectListener(this);
this._closed = true;
}
}
}
/**
* 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) {
const state = this._getState(instanceIndex);
state.synchronized = true;
const region = this.getRegion(instanceIndex);
this.cancelRefresh(region);
}
/**
* Invoked when connection to MetaTrader terminal terminated
* @param {String} instanceIndex index of an account instance connected
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ async onDisconnected(instanceIndex) {
const state = this._getState(instanceIndex);
state.synchronized = false;
this._logger.debug(`${this._account.id}:${instanceIndex}: disconnected from broker`);
}
/**
* Invoked when a stream for an instance index is closed
* @param {String} instanceIndex index of an account instance connected
*/ async onStreamClosed(instanceIndex) {
delete this._stateByInstanceIndex[instanceIndex];
}
/**
* Returns flag indicating status of state synchronization with MetaTrader terminal
* @returns {Boolean} a flag indicating status of state synchronization with MetaTrader terminal
*/ isSynchronized() {
return Object.values(this._stateByInstanceIndex).map((instance)=>instance.synchronized).includes(true);
}
/**
* Waits until synchronization to RPC application is completed
* @param {Number} timeoutInSeconds synchronization timeout in seconds. Defaults to 5 minutes
* @return {Promise} promise which resolves when synchronization to RPC application is completed
* @throws {TimeoutError} if application failed to synchronize with the teminal within timeout allowed
*/ async waitSynchronized(timeoutInSeconds = 300) {
this._checkIsConnectionActive();
const startTime = Date.now();
let synchronized = this.isSynchronized();
while(!synchronized && startTime + timeoutInSeconds * 1000 > Date.now()){
await new Promise((res)=>setTimeout(res, 1000));
synchronized = this.isSynchronized();
}
if (!synchronized) {
throw new _timeoutError.default("Timed out waiting for MetaApi to synchronize to MetaTrader account " + this._account.id);
}
// eslint-disable-next-line
while(true){
try {
await this._websocketClient.waitSynchronized(this._account.id, undefined, "RPC", 5, "RPC");
break;
} catch (err) {
if (Date.now() > startTime + timeoutInSeconds * 1000) {
throw err;
}
}
}
}
/**
* 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];
});
}
_getState(instanceIndex) {
if (!this._stateByInstanceIndex[instanceIndex]) {
this._stateByInstanceIndex[instanceIndex] = {
instanceIndex,
synchronized: false
};
}
return this._stateByInstanceIndex[instanceIndex];
}
/**
* Constructs MetaApi MetaTrader RPC Api connection
* @param {MetaApiOpts} options MetaApi options
* @param {MetaApiWebsocketClient} websocketClient MetaApi websocket client
* @param {MetatraderAccount} account MetaTrader account id to connect to
* @param {ConnectionRegistry} connectionRegistry metatrader account connection registry
*/ constructor(options, websocketClient, account, connectionRegistry){
super(options, websocketClient, account, "RPC");
_define_property(this, "_openedInstances", void 0);
this._connectionRegistry = connectionRegistry;
this._websocketClient.addSynchronizationListener(account.id, this);
this._stateByInstanceIndex = {};
this._openedInstances = [];
Object.values(account.accountRegions).forEach((replicaId)=>this._websocketClient.addReconnectListener(this, replicaId));
this._logger = _logger.default.getLogger("MetaApiConnection");
}
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport LoggerManager from '../logger';\nimport MetaApiConnection from './metaApiConnection';\nimport TimeoutError from '../clients/timeoutError';\n\n/**\n * Exposes MetaApi MetaTrader RPC API connection to consumers\n */\nexport default class RpcMetaApiConnection extends MetaApiConnection {\n  \n  private _openedInstances: any[];\n\n  /**\n   * Constructs MetaApi MetaTrader RPC Api connection\n   * @param {MetaApiOpts} options MetaApi options\n   * @param {MetaApiWebsocketClient} websocketClient MetaApi websocket client\n   * @param {MetatraderAccount} account MetaTrader account id to connect to\n   * @param {ConnectionRegistry} connectionRegistry metatrader account connection registry\n   */\n  constructor(options, websocketClient, account, connectionRegistry) {\n    super(options, websocketClient, account, 'RPC');\n    this._connectionRegistry = connectionRegistry;\n    this._websocketClient.addSynchronizationListener(account.id, this);\n    this._stateByInstanceIndex = {};\n    this._openedInstances = [];\n    Object.values(account.accountRegions)\n      .forEach(replicaId => this._websocketClient.addReconnectListener(this, replicaId));\n    this._logger = LoggerManager.getLogger('MetaApiConnection');\n  }\n\n  /**\n   * Opens the connection. Can only be called the first time, next calls will be ignored.\n   * @param {string} instanceId connection instance id\n   * @return {Promise} promise resolving when the connection is opened\n   */\n  async connect(instanceId) {\n    if (!this._openedInstances.includes(instanceId)) {\n      this._openedInstances.push(instanceId);\n    }\n    if (!this._opened) {\n      this._opened = true;\n      const accountRegions = this._account.accountRegions;\n      this._websocketClient.addAccountCache(this._account.id, accountRegions);\n      Object.keys(accountRegions).forEach(region => {\n        if (!this._options.region || this._options.region === region) {\n          this._websocketClient.ensureSubscribe(accountRegions[region], 0);\n          this._websocketClient.ensureSubscribe(accountRegions[region], 1);\n        }\n      });\n    }\n  }\n\n  /**\n   * Closes the connection. The instance of the class should no longer be used after this method is invoked.\n   * @param {string} instanceId connection instance id\n   */\n  async close(instanceId) {\n    if (this._opened) {\n      this._openedInstances = this._openedInstances.filter(id => id !== instanceId);\n      if (!this._openedInstances.length && !this._closed) {\n        await this._connectionRegistry.removeRpc(this.account);\n        this._websocketClient.removeSynchronizationListener(this.account.id, this);\n        this._websocketClient.removeAccountCache(this.account.id);\n        this._websocketClient.removeReconnectListener(this);\n        this._closed = true;\n      }\n    }\n  }\n  \n  /**\n   * Invoked when connection to MetaTrader terminal established\n   * @param {String} instanceIndex index of an account instance connected\n   * @param {Number} replicas number of account replicas launched\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onConnected(instanceIndex, replicas) {\n    const state = this._getState(instanceIndex);\n    state.synchronized = true;\n    const region = this.getRegion(instanceIndex);\n    this.cancelRefresh(region);\n  }\n\n  /**\n   * Invoked when connection to MetaTrader terminal terminated\n   * @param {String} instanceIndex index of an account instance connected\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onDisconnected(instanceIndex) {\n    const state = this._getState(instanceIndex);\n    state.synchronized = false;\n    this._logger.debug(`${this._account.id}:${instanceIndex}: disconnected from broker`);\n  }\n\n  /**\n   * Invoked when a stream for an instance index is closed\n   * @param {String} instanceIndex index of an account instance connected\n   */\n  async onStreamClosed(instanceIndex) {\n    delete this._stateByInstanceIndex[instanceIndex];\n  }\n\n  /**\n   * Returns flag indicating status of state synchronization with MetaTrader terminal\n   * @returns {Boolean} a flag indicating status of state synchronization with MetaTrader terminal\n   */\n  isSynchronized() {\n    return Object.values<any>(this._stateByInstanceIndex)\n      .map(instance => instance.synchronized)\n      .includes(true);\n  }\n\n  /**\n   * Waits until synchronization to RPC application is completed\n   * @param {Number} timeoutInSeconds synchronization timeout in seconds. Defaults to 5 minutes\n   * @return {Promise} promise which resolves when synchronization to RPC application is completed\n   * @throws {TimeoutError} if application failed to synchronize with the teminal within timeout allowed\n   */\n  async waitSynchronized(timeoutInSeconds=300) {\n    this._checkIsConnectionActive();\n    const startTime = Date.now();\n    let synchronized = this.isSynchronized();\n    while (!synchronized && startTime + timeoutInSeconds * 1000 > Date.now()) {\n      await new Promise(res => setTimeout(res, 1000));\n      synchronized = this.isSynchronized();\n    }\n    if (!synchronized) {\n      throw new TimeoutError('Timed out waiting for MetaApi to synchronize to MetaTrader account ' +\n        this._account.id);\n    }\n    // eslint-disable-next-line\n    while (true) {\n      try {\n        await this._websocketClient.waitSynchronized(this._account.id, undefined, 'RPC', 5, 'RPC');\n        break;\n      } catch (err) {\n        if (Date.now() > startTime + timeoutInSeconds * 1000) {\n          throw err;\n        }\n      }\n    }\n  }\n\n  /**\n   * Invoked when connection to MetaApi websocket API restored after a disconnect\n   * @param {String} region reconnected region\n   * @param {Number} instanceNumber reconnected instance number\n   * @return {Promise} promise which resolves when connection to MetaApi websocket API restored after a disconnect\n   */\n  async onReconnected(region, instanceNumber) {\n    const instanceTemplate = `${region}:${instanceNumber}`;\n    Object.keys(this._stateByInstanceIndex)\n      .filter(key => key.startsWith(`${instanceTemplate}:`)).forEach(key => {\n        delete this._stateByInstanceIndex[key];\n      });\n  }\n\n  _getState(instanceIndex) {\n    if (!this._stateByInstanceIndex[instanceIndex]) {\n      this._stateByInstanceIndex[instanceIndex] = {\n        instanceIndex,\n        synchronized: false,\n      };\n    }\n    return this._stateByInstanceIndex[instanceIndex];\n  }\n\n}\n"],"names":["RpcMetaApiConnection","MetaApiConnection","connect","instanceId","_openedInstances","includes","push","_opened","accountRegions","_account","_websocketClient","addAccountCache","id","Object","keys","forEach","region","_options","ensureSubscribe","close","filter","length","_closed","_connectionRegistry","removeRpc","account","removeSynchronizationListener","removeAccountCache","removeReconnectListener","onConnected","instanceIndex","replicas","state","_getState","synchronized","getRegion","cancelRefresh","onDisconnected","_logger","debug","onStreamClosed","_stateByInstanceIndex","isSynchronized","values","map","instance","waitSynchronized","timeoutInSeconds","_checkIsConnectionActive","startTime","Date","now","Promise","res","setTimeout","TimeoutError","undefined","err","onReconnected","instanceNumber","instanceTemplate","key","startsWith","constructor","options","websocketClient","connectionRegistry","addSynchronizationListener","replicaId","addReconnectListener","LoggerManager","getLogger"],"mappings":"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"}