static async Task Main(string[] args)
{
GrpcClientFactory.AllowUnencryptedHttp2 = true;
Console.Write("Press enter to start");
Console.ReadLine();
//CheckNoSql();
using ILoggerFactory loggerFactory =
LoggerFactory.Create(builder =>
builder.AddSimpleConsole(options =>
{
options.IncludeScopes = true;
options.SingleLine = true;
options.TimestampFormat = "hh:mm:ss ";
}));
ILogger <Program> logger = loggerFactory.CreateLogger <Program>();
var serviceBusClient = new MyServiceBusTcpClient(() => "servicebus-test.infrastructure.svc.cluster.local:6421", "TestApp");
Console.WriteLine("End");
Console.ReadLine();
}
/// <summary>
/// Register IPublisher for BidAsk
/// </summary>
public static void RegisterBidAskPublisher(this ContainerBuilder builder, MyServiceBusTcpClient client)
{
builder
.RegisterInstance(new BidAskMyServiceBusPublisher(client))
.As <IPublisher <BidAsk> >()
.SingleInstance();
}
public MyServiceBusPublisher(MyServiceBusTcpClient client, string topicName, bool immediatelyPersist)
{
this._client = client;
_topicName = topicName;
_immediatelyPersist = immediatelyPersist;
this._client.CreateTopicIfNotExists(topicName);
}
public static void RegisterManualBalanceChangeOperationSubscriber(this ContainerBuilder builder,
MyServiceBusTcpClient serviceBusClient, string queue)
{
builder.RegisterMyServiceBusSubscriberBatch <ManualChangeBalanceMessage>(serviceBusClient,
ManualChangeBalanceMessage.TopicName, queue,
TopicQueueType.Permanent);
}
public ApplicationLifetimeManager(IHostApplicationLifetime appLifetime, ILogger <ApplicationLifetimeManager> logger,
MyServiceBusTcpClient busTcpClient)
: base(appLifetime)
{
_logger = logger;
_busTcpClient = busTcpClient;
}
public ApplicationLifetimeManager(IHostApplicationLifetime appLifetime,
ILogger <ApplicationLifetimeManager> logger,
MyServiceBusTcpClient serviceBusTcpClient,
OrderBookAggregator bookAggregator)
: base(appLifetime)
{
_logger = logger;
_serviceBusTcpClient = serviceBusTcpClient;
_bookAggregator = bookAggregator;
}
protected override void Load(ContainerBuilder builder)
{
var appName = ApplicationEnvironment.HostName ?? ApplicationEnvironment.AppName;
var serviceBusClient = new MyServiceBusTcpClient(Program.ReloadedSettings(model => model.ServiceBusHostPort), appName);
builder.RegisterInstance(serviceBusClient).AsSelf().SingleInstance();
builder.RegisterInstance(new PriceServiceBusSubscriber(serviceBusClient, "Candles-History-1", Program.Settings.PricesTopicName))
.As <ISubscriber <PriceMessage> >()
.SingleInstance();
builder
.RegisterType <CandleBidAskCollectorJob>()
.AutoActivate()
.SingleInstance();
builder
.RegisterType <CandleTradeCollectorJob>()
.AutoActivate()
.SingleInstance();
builder
.RegisterType <DatabaseClearingJob>()
.As <IDatabaseClearingJob>()
.As <IStartable>()
.AutoActivate()
.SingleInstance();
builder
.RegisterType <CandleBidAskNoSqlWriterManager>()
.As <ICandleBidAskNoSqlWriterManager>()
.SingleInstance();
builder
.RegisterType <CandleTradeNoSqlWriterManager>()
.As <ICandleTradeNoSqlWriterManager>()
.SingleInstance();
builder
.RegisterType <CandleBidAskStoreJob>()
.As <ICandleBidAskStoreJob>()
.As <IStartable>()
.AutoActivate()
.SingleInstance();
builder
.RegisterType <CandleTradeStoreJob>()
.As <ICandleTradeStoreJob>()
.As <IStartable>()
.AutoActivate()
.SingleInstance();
}
public static void RegisterSignalBitGoSessionStateUpdateSubscriber(this ContainerBuilder builder,
MyServiceBusTcpClient client,
string queueName,
TopicQueueType queryType)
{
var subs = new SignalBitGoSessionStateUpdateSubscriber(client, queueName, queryType);
builder
.RegisterInstance(subs)
.As <ISubscriber <SignalBitGoSessionStateUpdate> >()
.SingleInstance();
}
public static MyServiceBusTcpClient Create(Func <string> getHostPort, string name, ILogger logger)
{
var serviceBusClient = new MyServiceBusTcpClient(getHostPort, name);
serviceBusClient.Log.AddLogException(ex => logger.LogInformation(ex, "Exception in MyServiceBusTcpClient"));
serviceBusClient.Log.AddLogInfo(info => logger.LogDebug($"MyServiceBusTcpClient[info]: {info}"));
serviceBusClient.SocketLogs.AddLogInfo((context, msg) => logger.LogInformation($"MyServiceBusTcpClient[Socket {context?.Id}|{context?.ContextName}|{context?.Inited}][Info] {msg}"));
serviceBusClient.SocketLogs.AddLogException((context, exception) => logger.LogInformation(exception, $"MyServiceBusTcpClient[Socket {context?.Id}|{context?.ContextName}|{context?.Inited}][Exception] {exception.Message}"));
return(serviceBusClient);
}
/// <summary>
/// Register ISubscriber for BidAsk
/// </summary>
public static void RegisterBidAskSubscriber(this ContainerBuilder builder, MyServiceBusTcpClient client, string queueName, TopicQueueType queryType, bool batchSubscribe)
{
if (batchSubscribe)
{
builder
.RegisterInstance(new BidAskMyServiceBusSubscriber(client, queueName, queryType, true))
.As <ISubscriber <IReadOnlyList <BidAsk> > >()
.SingleInstance();
}
else
{
builder
.RegisterInstance(new BidAskMyServiceBusSubscriber(client, queueName, queryType, false))
.As <ISubscriber <IReadOnlyList <BidAsk> > >()
.SingleInstance();
}
}
private static void RegisterCandlePublisher(ContainerBuilder builder)
{
ServiceBusLogger = Program.LogFactory.CreateLogger(nameof(MyServiceBusTcpClient));
var serviceBusClient = new MyServiceBusTcpClient(Program.ReloadedSettings(e => e.CandleServiceBusHostPort), ApplicationEnvironment.HostName);
serviceBusClient.Log.AddLogException(ex => ServiceBusLogger.LogError(ex as Exception, "[CANDLE] Exception in MyServiceBusTcpClient"));
serviceBusClient.Log.AddLogInfo(info => ServiceBusLogger.LogInformation($"[CANDLE] {info}"));
serviceBusClient.SocketLogs.AddLogException((context, ex) => ServiceBusLogger.LogError(ex as Exception, $"[CANDLE] [Socket {context?.Id}|{context?.Inited}]Exception in MyServiceBusTcpClient on Socket level"));
serviceBusClient.SocketLogs.AddLogInfo((context, info) => ServiceBusLogger.LogInformation($"[CANDLE] MyServiceBusTcpClient[Socket {context?.Id}|{context?.Inited}] {info}"));
var candlePublisher = new BidAskMyServiceBusPublisher(serviceBusClient, "spot-bidask");
builder
.RegisterInstance(candlePublisher)
.As <IPublisher <IBidAsk> >()
.SingleInstance();
serviceBusClient.Start();
}
public static ContainerBuilder RegisterPositionPortfolioSubscriber(this ContainerBuilder builder, MyServiceBusTcpClient client, string queryName, TopicQueueType queryType)
{
builder.RegisterMyServiceBusSubscriberBatch <PositionPortfolio>(client, PositionPortfolio.TopicName, queryName, queryType);
return(builder);
}
public static void RegisterTradeHistoryServiceBusClient(this ContainerBuilder builder, MyServiceBusTcpClient client, string queueName, TopicQueueType queryType, bool batchSubscriber)
{
if (batchSubscriber)
{
builder
.RegisterInstance(new WalletTradeServiceBusSubscriber(client, queueName, queryType, true))
.As <ISubscriber <IReadOnlyList <WalletTradeMessage> > >()
.SingleInstance();
}
else
{
builder
.RegisterInstance(new WalletTradeServiceBusSubscriber(client, queueName, queryType, false))
.As <ISubscriber <WalletTradeMessage> >()
.SingleInstance();
}
}
public BidAskMyServiceBusPublisher(MyServiceBusTcpClient client)
{
_client = client;
_client.CreateTopicIfNotExists(TopicNames.BidAsk);
}
public TradeVolumeServiceBusSubscriber(MyServiceBusTcpClient client, string queueName, TopicQueueType queryType, bool batchSubscribe) :
base(client, TopicNames.PriceTradeVolume, queueName, queryType,
bytes => bytes.ByteArrayToServiceBusContract <TradeVolume>(), batchSubscribe)
{
}
public ClientRegistrationServiceBusSubscriber(MyServiceBusTcpClient client, string queueName, TopicQueueType queryType, bool batchSubscribe) :
base(client, TopicNames.ClientRegistration, queueName, queryType,
bytes => bytes.ByteArrayToServiceBusContract <ClientRegistrationMessage>(), batchSubscribe)
{
}
public static void RegisterWithdrawalVerificationPublisher(this ContainerBuilder builder, MyServiceBusTcpClient serviceBusClient)
{
builder.RegisterMyServiceBusPublisher <WithdrawalVerifiedMessage>(serviceBusClient, WithdrawalVerifiedMessage.TopicName, true);
}
public static void RegisterOperationHistoryPublisher(this ContainerBuilder builder,
MyServiceBusTcpClient client)
{
builder.RegisterMyServiceBusPublisher <OperationUpdate>(client,
OperationUpdate.TopicName, false);
}
public WalletTradeServiceBusSubscriber(MyServiceBusTcpClient client, string queueName, TopicQueueType queryType, bool batchSubscriber) :
base(client, WalletTradeMessage.TopicName, queueName, queryType,
bytes => bytes.ByteArrayToServiceBusContract <WalletTradeMessage>(), batchSubscriber)
{
}
public PriceServiceBusSubscriber(MyServiceBusTcpClient client, string queueName, string topicName) :
base(client, topicName, queueName, TopicQueueType.Permanent,
bytes => bytes.ByteArrayToServiceBusContract())
{
}
public BidAskMyServiceBusSubscriber(MyServiceBusTcpClient client, string queueName, TopicQueueType queryType, bool batchSubscribe) :
base(client, TopicNames.BidAsk, queueName, queryType,
bytes => bytes.ByteArrayToServiceBusContract <BidAsk>(), batchSubscribe)
{
}
public static void RegisterDepositOperationSubscriberBatch(this ContainerBuilder builder,
MyServiceBusTcpClient serviceBusClient, string queue)
{
builder.RegisterMyServiceBusSubscriberBatch <Deposit>(serviceBusClient, Deposit.TopicName, queue,
TopicQueueType.Permanent);
}
/// <summary>
/// Register IPublisher for ClientRegistrationMessage
/// </summary>
public static void RegisterClientRegistrationPublisher(this ContainerBuilder builder, MyServiceBusTcpClient client)
{
builder
.RegisterInstance(new ClientRegistrationServiceBusPublisher(client))
.As <IPublisher <ClientRegistrationMessage> >()
.SingleInstance();
}
public static ContainerBuilder RegisterMyServiceBusPublisher <T>(this ContainerBuilder builder, MyServiceBusTcpClient client, string topicName, bool immediatelyPersist)
{
// publisher
builder
.RegisterInstance(new MyServiceBusPublisher <T>(client, topicName, immediatelyPersist))
.As <IPublisher <T> >()
.SingleInstance();
return(builder);
}
public static ContainerBuilder RegisterMyServiceBusSubscriberBatch <T>(this ContainerBuilder builder, MyServiceBusTcpClient client, string topicName, string queueName, TopicQueueType queryType)
{
// batch subscriber
builder
.RegisterInstance(new MyServiceBusSubscriber <T>(client, topicName, queueName, queryType, true))
.As <ISubscriber <IReadOnlyList <T> > >()
.SingleInstance();
return(builder);
}
public static void RegisterClientRegisterFailAlreadyExistsSubscriber(this ContainerBuilder builder, MyServiceBusTcpClient serviceBusClient, string queue)
{
builder.RegisterMyServiceBusSubscriberBatch <ClientRegisterFailAlreadyExistsMessage>(serviceBusClient, ClientRegisterFailAlreadyExistsMessage.TopicName, queue,
TopicQueueType.Permanent);
}
public static void RegisterWithdrawalOperationSubscriber(this ContainerBuilder builder, MyServiceBusTcpClient serviceBusClient, string queue)
{
builder.RegisterMyServiceBusSubscriberBatch <Withdrawal>(serviceBusClient, Withdrawal.TopicName, queue,
TopicQueueType.Permanent);
}
public ClientRegistrationServiceBusPublisher(MyServiceBusTcpClient client)
{
_client = client;
_client.CreateTopicIfNotExists(TopicNames.ClientRegistration);
}
public Subscriber(MyServiceBusTcpClient client, string topicName, string queueName, TopicQueueType queryType, Func <ReadOnlyMemory <byte>, T> deserializer)
{
_deserializer = deserializer;
client.Subscribe(topicName, queueName, queryType, Reader);
}
/// <summary>
/// Register IPublisher for TradeVolume
/// </summary>
public static void RegisterTradeVolumePublisher(this ContainerBuilder builder, MyServiceBusTcpClient client)
{
builder
.RegisterInstance(new TradeVolumeServiceBusPublisher(client))
.As <IPublisher <TradeVolume> >()
.SingleInstance();
}
