public async static Task ReadInstrumentsFees()
{
//http://192.168.1.80:5123
// var writer = new MyNoSqlServerDataWriter<SpotInstrumentFeesNoSqlEntity>(GetUrl, SpotInstrumentFeesNoSqlEntity.TableName, false);
// var entities = await writer.GetAsync();
// Console.WriteLine(JsonConvert.SerializeObject(entities));
//192.168.1.80:5125
var myNoSqlClient = new MyNoSqlTcpClient(GetUrl, "local");
var subs = new MyNoSqlReadRepository <SpotInstrumentFeesNoSqlEntity>(myNoSqlClient,
SpotInstrumentFeesNoSqlEntity.TableName);
myNoSqlClient.Start();
Thread.Sleep(10000);
var entities = subs.Get();
Console.WriteLine(JsonConvert.SerializeObject(entities));
//
// var entity = subs.Get(SpotInstrumentFeesNoSqlEntity.GeneratePartitionKey("jetwallet"),
// SpotInstrumentFeesNoSqlEntity.GenerateRowKey("ALGOUSD"));
//
// Console.WriteLine(JsonConvert.SerializeObject(entity));
//
// var entities = subs.Get(SpotInstrumentFeesNoSqlEntity.GeneratePartitionKey("jetwallet"));
//
// Console.WriteLine(JsonConvert.SerializeObject(entities));
//
// var entities1 = subs.Get();
//
// Console.WriteLine(JsonConvert.SerializeObject(entities1));
}
public LifetimeManager(
ILogger <LifetimeManager> logger,
MyNoSqlTcpClient client,
IMyNoSqlServerDataReader <SessionEntity> sessionReader,
IMyNoSqlServerDataReader <RegistrationTokenEntity> registrationTokenReader,
IMyNoSqlServerDataReader <ClientWalletEntity> clientWalletReader,
IMyNoSqlServerDataReader <AssetsEntity> assetsReader,
IMyNoSqlServerDataReader <AssetPairsEntity> assetPairsReader,
IMyNoSqlServerDataReader <PersonalDataEntity> personalDataReader,
IMyNoSqlServerDataReader <AuthDataEntity> authDataReader,
IMyNoSqlServerDataReader <AuthDataIndexByIdEntity> authIndexNyIdDataReader,
IMyNoSqlServerDataReader <ClientProfileEntity> clientProfileDataReader,
IMyNoSqlServerDataReader <OrderBookEntity> orderBookDataReader,
IMyNoSqlServerDataReader <PriceEntity> priceDataReader
)
{
_logger = logger;
_client = client;
_sessionReader = sessionReader;
_registrationTokenReader = registrationTokenReader;
_clientWalletReader = clientWalletReader;
_assetsReader = assetsReader;
_assetPairsReader = assetPairsReader;
_personalDataReader = personalDataReader;
_authDataReader = authDataReader;
_authIndexNyIdDataReader = authIndexNyIdDataReader;
_clientProfileDataReader = clientProfileDataReader;
_orderBookDataReader = orderBookDataReader;
_priceDataReader = priceDataReader;
}
private void MyNoSql(ContainerBuilder builder)
{
_noSqlClient = new MyNoSqlTcpClient(
() => Config.MyNoSqlServer.ReaderServiceUrl,
$"{ApplicationInformation.AppName}-{Environment.MachineName}");
builder.Register(ctx => _noSqlClient)
.AsSelf()
.SingleInstance();
RegisterNoSqlReaderAndWriter <SessionEntity>(builder, MyNoSqlServerTables.SessionsTableName);
RegisterNoSqlReaderAndWriter <RegistrationTokenEntity>(builder, MyNoSqlServerTables.RegistrationTokenTableName);
RegisterNoSqlReaderAndWriter <ClientWalletEntity>(builder, MyNoSqlServerTables.ClientWalletTableName);
RegisterNoSqlReaderAndWriter <ClientWalletIndexByIdEntity>(builder, MyNoSqlServerTables.ClientWalletIndexedByIdTableName);
RegisterNoSqlReaderAndWriter <ClientProfileEntity>(builder, MyNoSqlServerTables.ClientProfileTableName);
#region Mock
RegisterNoSqlReaderAndWriter <PersonalDataEntity>(builder, MyNoSqlServerTables.PersonalDataTableName);
RegisterNoSqlReaderAndWriter <AuthDataEntity>(builder, MyNoSqlServerTables.AuthDataTableName);
RegisterNoSqlReaderAndWriter <AuthDataIndexByIdEntity>(builder, MyNoSqlServerTables.AuthDataIndexByIdTableName);
#endregion
RegisterNoSqlReader <AssetsEntity>(builder, SetupMyNoSqlAssetService.AssetsTableName);
RegisterNoSqlReader <AssetPairsEntity>(builder, SetupMyNoSqlAssetService.AssetPairsTableName);
RegisterNoSqlReader <OrderBookEntity>(builder, OrderBookEntity.OrderBookTableName);
RegisterNoSqlReader <PriceEntity>(builder, PriceEntity.PriceTableName);
}
protected override void ConfigureContainerExt(ContainerBuilder builder)
{
builder.RegisterInstance(Config.Auth).AsSelf().SingleInstance();
builder.RegisterType <PushNotificator>()
.As <IPushNotificator>()
.As <IStartable>()
.AutoActivate()
.SingleInstance();
builder.RegisterInstance(Config.FireBaseMessaging)
.AsSelf()
.SingleInstance();
builder.RegisterType <MyNoSqlLifetimeManager>()
.As <IStartable>()
.AutoActivate()
.SingleInstance();
var noSqlClient = new MyNoSqlTcpClient(
() => Config.MyNoSqlServer.ReaderServiceUrl,
$"{ApplicationInformation.AppName}-{Environment.MachineName}");
builder.Register(ctx => noSqlClient)
.AsSelf()
.As <IMyNoSqlSubscriber>()
.SingleInstance();
RegisterNoSqlReaderAndWriter <ApprovalRequestMyNoSqlEntity>(builder, ApprovalRequestMyNoSqlEntity.TableName);
RegisterNoSqlReaderAndWriter <ValidatorLinkEntity>(builder, ValidatorLinkEntity.TableName);
RegisterNoSqlReaderAndWriter <PingMessageMyNoSqlEntity>(builder, PingMessageMyNoSqlEntity.TableName);
}
public ApplicationManager(
MyNoSqlTcpClient noSqlTcpClient,
IMyNoSqlServerDataReader <PriceEntity> pricesReader,
IMyNoSqlServerDataReader <TickerEntity> tickerReader,
IMyNoSqlServerDataReader <OrderbookEntity> orderbookReader,
IMyNoSqlServerDataReader <BalanceEntity> balanceReader,
IMyNoSqlServerDataReader <OrderEntity> orderReader,
IMyNoSqlServerDataReader <TradeEntity> tradeReader,
IStreamService <PriceUpdate> priceStraem,
IStreamService <TickerUpdate> tickerStream,
IStreamService <Orderbook> orderbookStream,
IStreamService <BalanceUpdate> balanceStream,
IStreamService <OrderUpdate> orderStream,
IStreamService <TradeUpdate> tradeStream,
IMapper mapper
)
{
_noSqlTcpClient = noSqlTcpClient;
_pricesReader = pricesReader;
_tickerReader = tickerReader;
_orderbookReader = orderbookReader;
_balanceReader = balanceReader;
_orderReader = orderReader;
_tradeReader = tradeReader;
_priceStraem = priceStraem;
_tickerStream = tickerStream;
_orderbookStream = orderbookStream;
_balanceStream = balanceStream;
_orderStream = orderStream;
_tradeStream = tradeStream;
_mapper = mapper;
}
public ApplicationLifetimeManager(IHostApplicationLifetime appLifetime,
ILogger <ApplicationLifetimeManager> logger,
MyNoSqlTcpClient myNoSqlClient)
: base(appLifetime)
{
_myNoSqlClient = myNoSqlClient;
_logger = logger;
}
public ApplicationLifetimeManager(IHostApplicationLifetime appLifetime,
ILogger <ApplicationLifetimeManager> logger, MyNoSqlTcpClient myNoSqlTcpClient,
LiquidityConverterSettingsManager liquidityConverterSettingsManager)
: base(appLifetime)
{
_logger = logger;
_myNoSqlTcpClient = myNoSqlTcpClient;
_liquidityConverterSettingsManager = liquidityConverterSettingsManager;
}
public Startup(IConfiguration configuration)
{
Configuration = configuration;
_myNoSqlClient = new MyNoSqlTcpClient(
Program.ReloadedSettings(e => e.MyNoSqlReaderHostPort),
ApplicationEnvironment.HostName ??
$"{ApplicationEnvironment.AppName}:{ApplicationEnvironment.AppVersion}");
}
public MarketServiceClient(
string myNoSqlServerReaderHost,
string marketServiceHttpApiUrl)
{
var host = Environment.GetEnvironmentVariable("HOST") ?? Environment.MachineName;
_httpClient = new LykkeMarketProfile(new Uri(marketServiceHttpApiUrl));
_myNoSqlClient = new MyNoSqlTcpClient(() => myNoSqlServerReaderHost, host);
_readerAssetPairNoSql = new MyNoSqlReadRepository <AssetPairPriceNoSql>(_myNoSqlClient, AssetPairPriceNoSql.TableName);
}
public AssetsServiceUserDataClient(string myNoSqlServerReaderHostPort, string assetServiceHttpApiUrl, ILogFactory logFactory)
{
_log = logFactory.CreateLog(this);
var host = Environment.GetEnvironmentVariable("HOST") ?? Environment.MachineName;
_httpClient = new AssetsServiceHttp(new Uri(assetServiceHttpApiUrl));
_myNoSqlClient = new MyNoSqlTcpClient(() => myNoSqlServerReaderHostPort, host);
_readerAssetConditionNoSql = new MyNoSqlReadRepository <AssetConditionNoSql>(_myNoSqlClient, AssetConditionNoSql.TableName);
_readerWatchListCustomNoSql = new MyNoSqlReadRepository <WatchListCustomNoSql>(_myNoSqlClient, WatchListCustomNoSql.TableNameCustomWatchList);
_readerWatchListPredefinedNoSql = new MyNoSqlReadRepository <WatchListPredefinedNoSql>(_myNoSqlClient, WatchListPredefinedNoSql.TableNamePredefinedWatchList);
}
public MyNoSqlLifetimeManager(
ILogger <MyNoSqlLifetimeManager> logger,
MyNoSqlTcpClient client,
IMyNoSqlServerDataReader <ApprovalRequestMyNoSqlEntity> approvalRequestReader,
IMyNoSqlServerDataReader <ValidatorLinkEntity> validatorLinkEntityReader,
IMyNoSqlServerDataReader <PingMessageMyNoSqlEntity> pingMessageReader)
{
_logger = logger;
_client = client;
_approvalRequestReader = approvalRequestReader;
_validatorLinkEntityReader = validatorLinkEntityReader;
_pingMessageReader = pingMessageReader;
}
public ApplicationLifetimeManager(
IHostApplicationLifetime appLifetime,
ILogger <ApplicationLifetimeManager> logger,
MyNoSqlTcpClient myNoSqlTcpClient,
ServiceBusLifeTime myServiceBusTcpClient,
WithdrawalProcessingJob withdrawalProcessingJob)
: base(appLifetime)
{
_logger = logger;
_myNoSqlTcpClient = myNoSqlTcpClient;
_myServiceBusTcpClient = myServiceBusTcpClient;
_withdrawalProcessingJob = withdrawalProcessingJob;
}
private void RegisterNoSqlClient(string brokerId)
{
MyNoSqlTcpClient client;
lock (_gate)
{
if (_myNoSqlSubscriberByBroker.TryGetValue(brokerId, out client))
{
return;
}
client = new MyNoSqlTcpClient(_getMyNoSqlHostPort, $"{_appName}-{brokerId}");
_minuteBidAskReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleBidAskNoSql>(client, CandleBidAskNoSql.TableNameMinute(brokerId));
_hourBidAskReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleBidAskNoSql>(client, CandleBidAskNoSql.TableNameHour(brokerId));
_dayBidAskReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleBidAskNoSql>(client, CandleBidAskNoSql.TableNameDay(brokerId));
_monthBidAskReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleBidAskNoSql>(client, CandleBidAskNoSql.TableNameMonth(brokerId));
_minuteTradeReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleTradeNoSql>(client, CandleTradeNoSql.TableNameMinute(brokerId));
_hourTradeReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleTradeNoSql>(client, CandleTradeNoSql.TableNameHour(brokerId));
_dayTradeReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleTradeNoSql>(client, CandleTradeNoSql.TableNameDay(brokerId));
_monthTradeReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleTradeNoSql>(client, CandleTradeNoSql.TableNameMonth(brokerId));
_myNoSqlSubscriberByBroker[brokerId] = client;
}
client.Start();
//todo: use wait initialization
var index = 0;
while (index < 50)
{
if (_minuteBidAskReaderByBroker[brokerId].Count() > 0 &&
_hourBidAskReaderByBroker[brokerId].Count() > 0 &&
_dayBidAskReaderByBroker[brokerId].Count() > 0 &&
_monthBidAskReaderByBroker[brokerId].Count() > 0 &&
_minuteTradeReaderByBroker[brokerId].Count() > 0 &&
_hourTradeReaderByBroker[brokerId].Count() > 0 &&
_dayTradeReaderByBroker[brokerId].Count() > 0 &&
_monthTradeReaderByBroker[brokerId].Count() > 0)
{
break;
}
Thread.Sleep(100);
index++;
}
}
protected override void Load(ContainerBuilder builder)
{
var myNoSqlClient = new MyNoSqlTcpClient(
Program.ReloadedSettings(e => e.MyNoSqlReaderHostPort),
ApplicationEnvironment.HostName ??
$"{ApplicationEnvironment.AppName}:{ApplicationEnvironment.AppVersion}");
builder.RegisterAssetsDictionaryClients(myNoSqlClient);
builder.RegisterMatchingEngineOrderBookClient(myNoSqlClient);
builder.RegisterFeesSettingsClients(myNoSqlClient);
builder.RegisterSpotInstrumentFeesClients(myNoSqlClient);
builder.RegisterMatchingEngineGrpcClient(cashServiceGrpcUrl: Program.Settings.MatchingEngineCashGrpcServiceUrl, tradingServiceGrpcUrl: Program.Settings.MatchingEngineTradingGrpcServiceUrl);
builder.RegisterInstance(myNoSqlClient).AsSelf().SingleInstance();
}
public AssetsServiceClient(
string myNoSqlServerReaderHostPort,
string assetServiceHttpApiUrl)
{
var host = Environment.GetEnvironmentVariable("HOST") ?? Environment.MachineName;
_httpClient = new AssetsServiceHttp(new Uri(assetServiceHttpApiUrl));
_myNoSqlClient = new MyNoSqlTcpClient(() => myNoSqlServerReaderHostPort, host);
_readerAssetAttributeNoSql = new MyNoSqlReadRepository <AssetAttributeNoSql>(_myNoSqlClient, AssetAttributeNoSql.TableName);
_readerAssetCategoryNoSql = new MyNoSqlReadRepository <AssetCategoryNoSql>(_myNoSqlClient, AssetCategoryNoSql.TableName);
_readerAssetExtendedInfoNoSql = new MyNoSqlReadRepository <AssetExtendedInfoNoSql>(_myNoSqlClient, AssetExtendedInfoNoSql.TableName);
_readerAssetNoSql = new MyNoSqlReadRepository <AssetNoSql>(_myNoSqlClient, AssetNoSql.TableName);
_readerAssetPairNoSql = new MyNoSqlReadRepository <AssetPairNoSql>(_myNoSqlClient, AssetPairNoSql.TableName);
}
protected override void Load(ContainerBuilder builder)
{
var myNoSqlClient = new MyNoSqlTcpClient(
Program.ReloadedSettings(e => e.MyNoSqlReaderHostPort),
ApplicationEnvironment.HostName ?? $"{ApplicationEnvironment.AppName}:{ApplicationEnvironment.AppVersion}");
builder.RegisterInstance(myNoSqlClient).AsSelf().SingleInstance();
RegisterMyNoSqlWriter <SpotSessionNoSql>(builder, SpotSessionNoSql.TableName);
builder.RegisterClientRegistrationClient(myNoSqlClient, Program.Settings.RegistrationGrpcServiceUrl);
builder.RegisterClientWalletsClients(myNoSqlClient, Program.Settings.ClientWalletsGrpcServiceUrl);
builder.RegisterType <DatabaseContextFactory>().AsSelf().SingleInstance();
builder.RegisterType <SessionAuditServiceService>().As <ISessionAuditService>().SingleInstance();
}
private static void CheckNoSql()
{
var myNoSqlClient = new MyNoSqlTcpClient(() => "192.168.10.80:5125", "TestApp");
var subs = new MyNoSqlReadRepository <OrderBookNoSql>(myNoSqlClient, OrderBookNoSql.TableName);
myNoSqlClient.Start();
IOrderBookService client = new OrderBookCache(subs);
Console.Write("Symbol: ");
var cmd = Console.ReadLine();
var symbol = "";
while (cmd != "exit")
{
Console.Clear();
if (!string.IsNullOrEmpty(cmd))
{
symbol = cmd;
}
Console.WriteLine($"Symbol: {symbol}");
var book = client.GetOrderBook("jetwallet", symbol);
if (book != null)
{
foreach (var level in book.Where(e => e.Volume < 0).OrderByDescending(e => e.Price))
{
Console.WriteLine($"\t{level.Price}\t{level.Volume}");
}
Console.WriteLine();
foreach (var level in book.Where(e => e.Volume > 0).OrderByDescending(e => e.Price))
{
Console.WriteLine($"{level.Volume}\t{level.Price}");
}
}
Console.WriteLine();
Console.WriteLine();
Console.Write("Symbol: ");
cmd = Console.ReadLine();
}
}
public static async Task TestReplaceAsync(string hostPort, string serverUrl)
{
var dataWriter = new MyNoSqlServerDataWriter <ReplaceEntity>(() => serverUrl, "test", false);
var client = new MyNoSqlTcpClient(() => hostPort, "test-app");
client.Start();
var dataReader = new MyNoSqlReadRepository <ReplaceEntity>(client, "test");
await Task.Delay(3000);
GetData(dataReader);
await UpdateData(dataWriter);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
//client.Stop();
}
public StreamsManager(
MyNoSqlTcpClient noSqlTcpClient,
IMyNoSqlServerDataReader <PriceEntity> pricesReader,
IMyNoSqlServerDataReader <TickerEntity> tickerReader,
IMyNoSqlServerDataReader <OrderbookEntity> orderbookReader,
IMyNoSqlServerDataReader <BalanceEntity> balanceReader,
PricesStreamService priceStraem,
TickersStreamService tickerStream,
OrderbookStreamService orderbookStream,
BalancesStreamService balanceStream,
IMapper mapper
)
{
_noSqlTcpClient = noSqlTcpClient;
_pricesReader = pricesReader;
_tickerReader = tickerReader;
_orderbookReader = orderbookReader;
_balanceReader = balanceReader;
_priceStraem = priceStraem;
_tickerStream = tickerStream;
_orderbookStream = orderbookStream;
_balanceStream = balanceStream;
_mapper = mapper;
}
static async Task Main(string[] args)
{
Console.Write("Press enter to start");
Console.ReadLine();
await GenerateAsstToBitgoMap();
MyNoSqlTcpClient myNoSqlClient = new MyNoSqlTcpClient(() => "192.168.10.80:5125", "test-bitgo-settings-app");
var mapper = new AssetMapper(
new MyNoSqlReadRepository <BitgoAssetMapEntity>(myNoSqlClient, BitgoAssetMapEntity.TableName),
new MyNoSqlReadRepository <BitgoCoinEntity>(myNoSqlClient, BitgoCoinEntity.TableName));
myNoSqlClient.Start();
await Task.Delay(5000);
var(coin, wallet) = mapper.AssetToBitgoCoinAndWallet("jetwallet", "BTC");
Console.WriteLine($"BTC (coin|wallet): {coin}|{wallet}");
Console.WriteLine("End");
Console.ReadLine();
}
public ApplicationManager(
MyNoSqlTcpClient noSqlTcpClient,
IMyNoSqlServerDataReader <PriceEntity> pricesReader,
IMyNoSqlServerDataReader <CandleEntity> candlesReader,
IMyNoSqlServerDataReader <TickerEntity> tickersReader,
IMyNoSqlServerDataReader <OrderbookEntity> orderbooksReader,
IMyNoSqlServerDataReader <SessionEntity> sessionsReader,
PricesStreamService priceStream,
CandlesStreamService candlesStream,
OrderbookStreamService orderbookStream,
IMapper mapper
)
{
_noSqlTcpClient = noSqlTcpClient;
_pricesReader = pricesReader;
_candlesReader = candlesReader;
_tickersReader = tickersReader;
_orderbooksReader = orderbooksReader;
_sessionsReader = sessionsReader;
_priceStream = priceStream;
_candlesStream = candlesStream;
_orderbookStream = orderbookStream;
_mapper = mapper;
}
static async Task Main(string[] args)
{
var writer = new MyNoSqlServer.DataWriter.MyNoSqlServerDataWriter <Entity>(() => "http://localhost:5123", "entity");
await writer.CleanAndKeepMaxPartitions(0);
int i = 1;
var t = Task.Run(async() =>
{
while (true)
{
await writer.InsertOrReplaceAsync(new Entity(i, $"{i}{i}{i}"));
Console.WriteLine($"-->{i}");
await Task.Delay(5000);
i++;
}
});
await Task.Delay(10000);
var client = new MyNoSqlTcpClient(() => "localhost:5125", "TestApp-client");
client.Start();
var reader = new MyNoSqlServer.DataReader.MyNoSqlReadRepository <Entity>(client, "entity");
await Task.Delay(3000);
var r = reader.Count("Entity-1");
Console.WriteLine($"count: {r}");
reader.SubscribeToChanges(list =>
{
foreach (var entity in list)
{
Console.WriteLine($"<-- {entity.Id}");
}
});
Console.ReadLine();
var e = reader.Get("Entity-1", "1");
Console.WriteLine($"{e.Id} :: {e.Name}");
r = reader.Count("Entity-1");
Console.WriteLine($"count: {r}");
r = reader.Count();
Console.WriteLine($"count: {r}");
Console.ReadLine();
/*
* output:
* -->1
* -->2
* -->3
* count: 0
* -->4
* -->5
*
* count: 0
* -->6
*/
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(ctx =>
{
var factory = ctx.Resolve<IHttpClientFactory>();
return new LykkeWalletAPIv1Client(factory.CreateClient(HttpClientNames.WalletApiV1));
})
.As<ILykkeWalletAPIv1Client>();
builder.Register(ctx =>
{
var factory = ctx.Resolve<IHttpClientFactory>();
return new LykkeWalletAPIv2Client(factory.CreateClient(HttpClientNames.WalletApiV2));
})
.As<ILykkeWalletAPIv2Client>();
builder.RegisterClientSessionClient(
new SessionServiceClientSettings {ServiceUrl = _config.Services.SessionServiceUrl});
builder.RegisterType<GrpcPrincipal>().As<IGrpcPrincipal>().InstancePerLifetimeScope();
builder.Register(ctx =>
{
var logger = ctx.Resolve<ILoggerFactory>();
_logFactory = logger.ToLykke();
return _logFactory;
})
.As<ILogFactory>();
builder.Register(ctx =>
{
var client = new MyNoSqlTcpClient(() => _config.MyNoSqlServer.ReaderServiceUrl,
$"{ApplicationInformation.AppName}-{Environment.MachineName}");
client.Start();
return client;
})
.AsSelf()
.SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository<PriceEntity>(ctx.Resolve<MyNoSqlTcpClient>(),
_config.MyNoSqlServer.PricesTableName)
)
.As<IMyNoSqlServerDataReader<PriceEntity>>()
.SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository<CandleEntity>(ctx.Resolve<MyNoSqlTcpClient>(),
_config.MyNoSqlServer.CandlesTableName)
)
.As<IMyNoSqlServerDataReader<CandleEntity>>()
.SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository<TickerEntity>(ctx.Resolve<MyNoSqlTcpClient>(),
_config.MyNoSqlServer.TickersTableName)
)
.As<IMyNoSqlServerDataReader<TickerEntity>>()
.SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository<OrderbookEntity>(ctx.Resolve<MyNoSqlTcpClient>(),
_config.MyNoSqlServer.OrderbooksTableName)
).As<IMyNoSqlServerDataReader<OrderbookEntity>>().SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository<SessionEntity>(ctx.Resolve<MyNoSqlTcpClient>(),
_config.MyNoSqlServer.SessionsTableName)
).As<IMyNoSqlServerDataReader<SessionEntity>>().SingleInstance();
builder.Register(ctx =>
{
return new MyNoSqlServer.DataWriter.MyNoSqlServerDataWriter<SessionEntity>(() =>
_config.MyNoSqlServer.WriterServiceUrl,
_config.MyNoSqlServer.SessionsTableName);
}).As<IMyNoSqlServerDataWriter<SessionEntity>>().SingleInstance();
builder.RegisterType<PricesStreamService>()
.WithParameter(TypedParameter.From(true))
.WithParameter("jobPeriod", TimeSpan.FromSeconds(1))
.AsSelf()
.SingleInstance();
builder.RegisterType<CandlesStreamService>()
.WithParameter(TypedParameter.From(true))
.AsSelf()
.SingleInstance();
builder.RegisterType<OrderbookStreamService>()
.WithParameter(TypedParameter.From(true))
.AsSelf()
.SingleInstance();
builder.RegisterType<PublicTradesStreamService>()
.WithParameter(TypedParameter.From(true))
.AsSelf()
.SingleInstance();
builder.RegisterType<ApplicationManager>()
.As<IStartable>()
.AutoActivate()
.SingleInstance();
builder.RegisterInstance(
new Candleshistoryservice(new Uri(_config.Services.CandlesHistoryServiceUrl), new HttpClient())
)
.As<ICandleshistoryservice>();
builder.RegisterAssetsClient(AssetServiceSettings.Create(new Uri(_config.Services.AssetsServiceUrl),
TimeSpan.FromMinutes(60)));
builder.RegisterBalancesClient(_config.Services.BalancesServiceUrl);
builder.RegisterMeClient(_config.MatchingEngine.GetIpEndPoint());
builder.RegisterClientAccountClient(_config.Services.ClientAccountServiceUrl);
builder.RegisterType<AssetsHelper>().AsSelf().SingleInstance();
builder.RegisterType<ValidationService>().AsSelf().SingleInstance();
builder.RegisterInstance(_config.WalletApi);
builder.RegisterRateCalculatorClient(_config.Services.RateCalculatorServiceUrl);
var cache = new RedisCache(new RedisCacheOptions
{
Configuration = _config.Redis.RedisConfiguration,
InstanceName = _config.Redis.InstanceName
});
builder.RegisterInstance(cache)
.As<IDistributedCache>()
.SingleInstance();
builder.RegisterType<OrderbooksService>()
.WithParameter(TypedParameter.From(_config.Redis.OrderBooksCacheKeyPattern))
.AsSelf()
.SingleInstance();
builder.Register(ctx =>
new TradesAdapterClient(_config.Services.TradesAdapterServiceUrl,
ctx.Resolve<ILogFactory>().CreateLog(nameof(TradesAdapterClient)))
)
.As<ITradesAdapterClient>()
.SingleInstance();
builder.RegisterRegistrationServiceClient(new RegistrationServiceClientSettings{ServiceUrl = _config.Services.RegistrationServiceUrl});
builder.RegisterType<SessionService>()
.WithParameter(TypedParameter.From(_config.SessionLifetimeInMins))
.AsSelf()
.SingleInstance();
builder.RegisterType<PublicTradesSubscriber>()
.As<IStartable>()
.AutoActivate()
.WithParameter("connectionString", _config.RabbitMq.PublicTrades.ConnectionString)
.WithParameter("exchangeName", _config.RabbitMq.PublicTrades.ExchangeName)
.SingleInstance();
builder.RegisterPushNotificationsClient(_config.Services.PushNotificationsServiceUrl);
}
public ClientsModule(MyNoSqlTcpClient myNoSqlClient)
{
_myNoSqlClient = myNoSqlClient;
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <AssetsService>()
.WithParameter(TypedParameter.From(_config.Cache.AssetsCacheDuration))
.As <IAssetsService>()
.As <IStartable>()
.AutoActivate();
builder.RegisterType <OrderbooksService>()
.As <IOrderbooksService>()
.WithParameter(TypedParameter.From(_config.Redis.OrderBooksCacheKeyPattern))
.SingleInstance();
var cache = new RedisCache(new RedisCacheOptions
{
Configuration = _config.Redis.RedisConfiguration,
InstanceName = _config.Redis.InstanceName
});
builder.RegisterInstance(cache)
.As <IDistributedCache>()
.SingleInstance();
builder.RegisterMarketDataClient(new MarketDataServiceClientSettings {
GrpcServiceUrl = _config.Services.MarketDataGrpcServiceUrl
});
builder.Register(ctx =>
{
var logger = ctx.Resolve <ILoggerFactory>();
return(logger.ToLykke());
}).As <ILogFactory>();
builder.RegisterMeClient(_config.MatchingEngine.GetIpEndPoint());
builder.RegisterType <KeyUpdateSubscriber>()
.As <IStartable>()
.AutoActivate()
.WithParameter("connectionString", _config.RabbitMq.HftInternal.ConnectionString)
.WithParameter("exchangeName", _config.RabbitMq.HftInternal.ExchangeName)
.SingleInstance();
builder.RegisterHftInternalClient(_config.Services.HftInternalServiceUrl);
builder.RegisterType <TokenService>()
.As <ITokenService>()
.SingleInstance();
builder.RegisterType <BalanceService>()
.As <IBalanceService>()
.SingleInstance();
builder.RegisterType <ValidationService>()
.AsSelf()
.SingleInstance();
builder.Register(ctx =>
{
var client = new MyNoSqlTcpClient(() => _config.MyNoSqlServer.ReaderServiceUrl, $"{ApplicationInformation.AppName}-{Environment.MachineName}");
client.Start();
return(client);
}).AsSelf().SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository <TickerEntity>(ctx.Resolve <MyNoSqlTcpClient>(), _config.MyNoSqlServer.TickersTableName)
).As <IMyNoSqlServerDataReader <TickerEntity> >().SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository <PriceEntity>(ctx.Resolve <MyNoSqlTcpClient>(), _config.MyNoSqlServer.PricesTableName)
).As <IMyNoSqlServerDataReader <PriceEntity> >().SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository <OrderbookEntity>(ctx.Resolve <MyNoSqlTcpClient>(), _config.MyNoSqlServer.OrderbooksTableName)
).As <IMyNoSqlServerDataReader <OrderbookEntity> >().SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository <BalanceEntity>(ctx.Resolve <MyNoSqlTcpClient>(), _config.MyNoSqlServer.BalancesTableName)
).As <IMyNoSqlServerDataReader <BalanceEntity> >().SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository <OrderEntity>(ctx.Resolve <MyNoSqlTcpClient>(), _config.MyNoSqlServer.OrdersTableName)
).As <IMyNoSqlServerDataReader <OrderEntity> >().SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository <TradeEntity>(ctx.Resolve <MyNoSqlTcpClient>(), _config.MyNoSqlServer.TradesTableName)
).As <IMyNoSqlServerDataReader <TradeEntity> >().SingleInstance();
builder.RegisterType <StreamService <PriceUpdate> >().As <IStreamService <PriceUpdate> >().SingleInstance();
builder.RegisterType <StreamService <TickerUpdate> >().As <IStreamService <TickerUpdate> >().SingleInstance();
builder.RegisterType <StreamService <Orderbook> >().As <IStreamService <Orderbook> >().SingleInstance();
builder.RegisterType <StreamService <BalanceUpdate> >()
.WithParameter(TypedParameter.From(true))
.As <IStreamService <BalanceUpdate> >()
.SingleInstance();
builder.RegisterType <StreamService <OrderUpdate> >()
.WithParameter(TypedParameter.From(true))
.As <IStreamService <OrderUpdate> >()
.SingleInstance();
builder.RegisterType <StreamService <TradeUpdate> >()
.WithParameter(TypedParameter.From(true))
.As <IStreamService <TradeUpdate> >()
.SingleInstance();
builder.RegisterType <ApplicationManager>().AsSelf().SingleInstance();
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <AssetsService>()
.WithParameter(TypedParameter.From(_config.Cache.AssetsCacheDuration))
.As <IAssetsService>()
.As <IStartable>()
.AutoActivate();
builder.RegisterType <OrderbooksService>()
.As <IOrderbooksService>()
.WithParameter(TypedParameter.From(_config.Redis.OrderBooksCacheKeyPattern))
.SingleInstance();
var cache = new RedisCache(new RedisCacheOptions
{
Configuration = _config.Redis.RedisConfiguration,
InstanceName = _config.Redis.InstanceName
});
builder.RegisterInstance(cache)
.As <IDistributedCache>()
.SingleInstance();
builder.RegisterMarketDataClient(new MarketDataServiceClientSettings {
GrpcServiceUrl = _config.Services.MarketDataGrpcServiceUrl
});
builder.Register(ctx =>
{
var logger = ctx.Resolve <ILoggerFactory>();
return(logger.ToLykke());
}).As <ILogFactory>();
builder.RegisterMeClient(_config.MatchingEngine.GetIpEndPoint());
builder.RegisterType <KeyUpdateSubscriber>()
.As <IStartable>()
.AutoActivate()
.WithParameter("connectionString", _config.RabbitMq.HftInternal.ConnectionString)
.WithParameter("exchangeName", _config.RabbitMq.HftInternal.ExchangeName)
.SingleInstance();
builder.RegisterHftInternalClient(_config.Services.HftInternalServiceUrl);
builder.RegisterType <TokenService>()
.As <ITokenService>()
.SingleInstance();
builder.RegisterType <BalanceService>()
.As <IBalanceService>()
.SingleInstance();
builder.RegisterType <ValidationService>()
.AsSelf()
.SingleInstance();
builder.RegisterType <IdempotencyService>()
.AsSelf()
.SingleInstance();
var reconnectTimeoutInSec = Environment.GetEnvironmentVariable("NOSQL_PING_INTERVAL") ?? "15";
builder.Register(ctx =>
{
var client = new MyNoSqlTcpClient(() => _config.MyNoSqlServer.ReaderServiceUrl, $"{ApplicationInformation.AppName}-{Environment.MachineName}", int.Parse(reconnectTimeoutInSec));
client.Start();
return(client);
}).AsSelf().SingleInstance();
builder.RegisterInstance(_config.FeeSettings)
.AsSelf();
builder.Register(ctx =>
new MyNoSqlReadRepository <TickerEntity>(ctx.Resolve <MyNoSqlTcpClient>(), _config.MyNoSqlServer.TickersTableName)
).As <IMyNoSqlServerDataReader <TickerEntity> >().SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository <PriceEntity>(ctx.Resolve <MyNoSqlTcpClient>(), _config.MyNoSqlServer.PricesTableName)
).As <IMyNoSqlServerDataReader <PriceEntity> >().SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository <OrderbookEntity>(ctx.Resolve <MyNoSqlTcpClient>(), _config.MyNoSqlServer.OrderbooksTableName)
).As <IMyNoSqlServerDataReader <OrderbookEntity> >().SingleInstance();
builder.Register(ctx =>
new MyNoSqlReadRepository <BalanceEntity>(ctx.Resolve <MyNoSqlTcpClient>(), _config.MyNoSqlServer.BalancesTableName)
).As <IMyNoSqlServerDataReader <BalanceEntity> >().SingleInstance();
builder.RegisterType <PricesStreamService>()
.WithParameter(TypedParameter.From(true))
.AsSelf()
.SingleInstance();
builder.RegisterType <TickersStreamService>()
.WithParameter(TypedParameter.From(true))
.AsSelf()
.SingleInstance();
builder.RegisterType <OrderbookStreamService>()
.WithParameter(TypedParameter.From(true))
.AsSelf()
.SingleInstance();
builder.RegisterType <BalancesStreamService>()
.WithParameter(TypedParameter.From(true))
.AsSelf()
.SingleInstance();
builder.RegisterType <OrdersStreamService>()
.WithParameter(TypedParameter.From(true))
.AsSelf()
.SingleInstance();
builder.RegisterType <TradesStreamService>()
.WithParameter(TypedParameter.From(true))
.AsSelf()
.SingleInstance();
builder.RegisterType <PublicTradesStreamService>()
.WithParameter(TypedParameter.From(true))
.AsSelf()
.SingleInstance();
builder.RegisterType <StreamsManager>().AsSelf().SingleInstance();
builder.RegisterType <SiriusWalletsService>()
.As <ISiriusWalletsService>()
.WithParameter(TypedParameter.From(_config.Services.SiriusApiServiceClient.BrokerAccountId))
.WithParameter(TypedParameter.From(_config.Services.SiriusApiServiceClient.WalletsActiveRetryCount))
.WithParameter(TypedParameter.From(_config.Services.SiriusApiServiceClient.WaitForActiveWalletsTimeout))
.SingleInstance();
builder.RegisterType <TradesSubscriber>()
.As <IStartable>()
.AutoActivate()
.WithParameter("connectionString", _config.RabbitMq.Orders.ConnectionString)
.WithParameter("exchangeName", _config.RabbitMq.Orders.ExchangeName)
.SingleInstance();
builder.Register(ctx =>
new TradesAdapterClient(_config.Services.TradesAdapterServiceUrl,
ctx.Resolve <ILogFactory>().CreateLog(nameof(TradesAdapterClient)))
)
.As <ITradesAdapterClient>()
.SingleInstance();
#pragma warning disable 618
builder.Register(x => new KycStatusServiceClient(_config.Services.KycServiceClient, x.Resolve <ILogFactory>()))
#pragma warning restore 618
.As <IKycStatusService>()
.SingleInstance();
builder.RegisterClientAccountClient(_config.Services.ClientAccountServiceUrl);
builder.RegisterOperationsClient(_config.Services.OperationsServiceUrl);
builder.RegisterClientDialogsClient(_config.Services.ClientDialogsServiceUrl);
builder.RegisterInstance(
new Swisschain.Sirius.Api.ApiClient.ApiClient(_config.Services.SiriusApiServiceClient.GrpcServiceUrl, _config.Services.SiriusApiServiceClient.ApiKey)
).As <Swisschain.Sirius.Api.ApiClient.IApiClient>();
builder.RegisterType <PublicTradesSubscriber>()
.As <IStartable>()
.AutoActivate()
.WithParameter("connectionString", _config.RabbitMq.PublicTrades.ConnectionString)
.WithParameter("exchangeName", _config.RabbitMq.PublicTrades.ExchangeName)
.SingleInstance();
builder.Register(ctx =>
AzureTableStorage <IdempotentEntity> .Create(ConstantReloadingManager.From(_config.Db.DataConnString),
"HftApiIdempotency", ctx.Resolve <ILogFactory>())
).As <INoSQLTableStorage <IdempotentEntity> >().SingleInstance();
}
