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)
205 lines (204 loc) • 23.7 kB
JavaScript
;
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _async_to_generator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
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;
}
import LoggerManager from '../logger';
import MetaApiConnection from './metaApiConnection';
import TimeoutError from '../clients/timeoutError';
let RpcMetaApiConnection = class RpcMetaApiConnection extends MetaApiConnection {
/**
* 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
*/ connect(instanceId) {
var _this = this;
return _async_to_generator(function*() {
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
*/ close(instanceId) {
var _this = this;
return _async_to_generator(function*() {
if (_this._opened) {
_this._openedInstances = _this._openedInstances.filter((id)=>id !== instanceId);
if (!_this._openedInstances.length && !_this._closed) {
yield _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
*/ onConnected(instanceIndex, replicas) {
var _this = this;
return _async_to_generator(function*() {
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
*/ onDisconnected(instanceIndex) {
var _this = this;
return _async_to_generator(function*() {
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
*/ onStreamClosed(instanceIndex) {
var _this = this;
return _async_to_generator(function*() {
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
*/ waitSynchronized(timeoutInSeconds = 300) {
var _this = this;
return _async_to_generator(function*() {
_this._checkIsConnectionActive();
const startTime = Date.now();
let synchronized = _this.isSynchronized();
while(!synchronized && startTime + timeoutInSeconds * 1000 > Date.now()){
yield new Promise((res)=>setTimeout(res, 1000));
synchronized = _this.isSynchronized();
}
if (!synchronized) {
throw new TimeoutError('Timed out waiting for MetaApi to synchronize to MetaTrader account ' + _this._account.id);
}
// eslint-disable-next-line
while(true){
try {
yield _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
*/ onReconnected(region, instanceNumber) {
var _this = this;
return _async_to_generator(function*() {
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 = LoggerManager.getLogger('MetaApiConnection');
}
};
/**
* Exposes MetaApi MetaTrader RPC API connection to consumers
*/ export { RpcMetaApiConnection as default };
//# 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":["LoggerManager","MetaApiConnection","TimeoutError","RpcMetaApiConnection","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","undefined","err","onReconnected","instanceNumber","instanceTemplate","key","startsWith","constructor","options","websocketClient","connectionRegistry","addSynchronizationListener","replicaId","addReconnectListener","getLogger"],"mappings":"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"}