public RabbitMqModule(IReloadingManager <AppSettings> settingsManager)
{
_settings = settingsManager.CurrentValue.SmartVouchersService.Rabbit;
}
public RabbitMqModule(IReloadingManager <AppSettings> appSettings)
{
_settings = appSettings.CurrentValue.SessionsService.RabbitMq;
}
public IndicesHistoryUpdatesPublisher(RabbitMqSettings settings, ILogFactory logFactory)
{
_logFactory = logFactory;
_settings = settings;
_log = logFactory.CreateLog(this);
}
public UpdateHandler(IModel channel, RabbitMqSettings rabbitMqSettings)
{
_channel = channel;
_rabbitMqSettings = rabbitMqSettings;
}
public CustomerController(IRepository repo, IBusConfigurator busConfig, IOptionsSnapshot <RabbitMqSettings> options)
{
_repo = repo;
_busConfig = busConfig;
_rabbit = options.Value;
}
public SettingsAdapter(RabbitMqSettings settings)
{
_settings = settings;
}
public TickPricePublisher(RabbitMqSettings settings, ILogFactory logFactory)
{
_logFactory = logFactory;
_settings = settings;
_log = logFactory.CreateLog(this);
}
public RabbitMqModule(IReloadingManager <AppSettings> appSettings)
{
_settings = appSettings.CurrentValue.RealEstateBonusAgentService.Rabbit;
}
public BusConfigurator(IOptionsSnapshot <RabbitMqSettings> options)
{
_rabbitSettings = options.Value;
}
public static IRabbitMqHost CreateRabbitMqHost(this IRabbitMqBusFactoryConfigurator configurator, RabbitMqSettings rabbitMqSettings)
{
return(configurator.Host(new Uri($"rabbitmq://{rabbitMqSettings.Host}/"), h =>
{
h.Username(rabbitMqSettings.Username);
h.Password(rabbitMqSettings.Password);
}));
}
public RabbitMqModule(IReloadingManager <AppSettings> appSettings)
{
_settings = appSettings.CurrentValue.CustomerManagementService.RabbitMq;
}
public RabbitMQService(IOptions <RabbitMqSettings> options)
{
_rabbitMqSettings = options.Value;
}
public async Task StartApplicationAsync()
{
await _logger.WriteInfoAsync(nameof(StartApplicationAsync), nameof(Application), $"Starting {ServiceName}");
if (_marginSettings.MarketMakerRabbitMqSettings == null &&
_marginSettings.StpAggregatorRabbitMqSettings == null)
{
throw new Exception("Both MM and STP connections are not configured. Can not start service.");
}
try
{
await _migrationService.InvokeAll();
if (_marginSettings.MarketMakerRabbitMqSettings != null)
{
_rabbitMqService.Subscribe(
_marginSettings.MarketMakerRabbitMqSettings, false, HandleNewOrdersMessage,
_rabbitMqService.GetJsonDeserializer <MarketMakerOrderCommandsBatchMessage>());
}
else
{
_logger.WriteInfo(ServiceName, nameof(StartApplicationAsync),
"MarketMakerRabbitMqSettings is not configured");
}
if (_marginSettings.FxRateRabbitMqSettings != null)
{
_rabbitMqService.Subscribe(_marginSettings.FxRateRabbitMqSettings, false,
_fxRateCacheService.SetQuote, _rabbitMqService.GetMsgPackDeserializer <ExternalExchangeOrderbookMessage>());
}
if (_marginSettings.StpAggregatorRabbitMqSettings != null)
{
_rabbitMqService.Subscribe(_marginSettings.StpAggregatorRabbitMqSettings,
false, HandleStpOrderbook,
_rabbitMqService.GetMsgPackDeserializer <ExternalExchangeOrderbookMessage>());
}
else
{
_logger.WriteInfo(ServiceName, nameof(StartApplicationAsync),
"StpAggregatorRabbitMqSettings is not configured");
}
if (_marginSettings.RisksRabbitMqSettings != null)
{
_rabbitMqService.Subscribe(_marginSettings.RisksRabbitMqSettings,
true, _matchingEngineRoutesManager.HandleRiskManagerCommand,
_rabbitMqService.GetJsonDeserializer <MatchingEngineRouteRisksCommand>());
}
else
{
_logger.WriteInfo(ServiceName, nameof(StartApplicationAsync),
"RisksRabbitMqSettings is not configured");
}
var settingsChanged = new RabbitMqSettings
{
ConnectionString = _marginSettings.MtRabbitMqConnString,
ExchangeName = _marginSettings.RabbitMqQueues.SettingsChanged.ExchangeName
};
_rabbitMqService.Subscribe(settingsChanged,
true, HandleChangeSettingsMessage,
_rabbitMqService.GetJsonDeserializer <SettingsChangedEvent>());
_rabbitMqService.Subscribe(_marginSettings.BrokerSettingsRabbitMqSettings, false,
_brokerSettingsChangedHandler.Handle,
_rabbitMqService.GetMsgPackDeserializer <BrokerSettingsChangedEvent>());
}
catch (Exception ex)
{
await _logger.WriteErrorAsync(ServiceName, "Application.RunAsync", null, ex);
}
}
public RabbitMqActivityUriProvider(RabbitMqSettings settings)
{
_settings = settings;
}
public RabbitMqModule(IReloadingManager <AppSettings> appSettings)
{
_appSettings = appSettings.CurrentValue;
_settings = _appSettings.WalletManagementService.RabbitMq;
}
public ConsumeRabbitMqHostedService(IServiceScopeFactory serviceScopeFactory, RabbitMqSettings configurations)
{
_serviceScopeFactory = serviceScopeFactory;
_configurations = configurations;
InitRabbitMq();
}
public static void AddMassTransitConfiguration(this IServiceCollection services, RabbitMqSettings rabbitMqSettings)
{
services.AddMassTransit(x =>
{
x.AddConsumer <ProcessBurgerOrderConsumer>(typeof(ProcessBurgerOrderConsumerDefinition));
x.AddActivitiesFromNamespaceContaining <ProcessBurgerOrderActivity>();
x.UsingRabbitMq((context, cfg) =>
{
cfg.Host(rabbitMqSettings.Host, "/", h =>
{
h.Username(rabbitMqSettings.Username);
h.Password(rabbitMqSettings.Password);
});
cfg.ConfigureEndpoints(context);
cfg.UseInMemoryOutbox();
});
});
}
public RabbitMqCommunicator(RabbitMqSettings rabbitMqSettings, IModel rabbitMqChannel, IMongoUnitOfWork mongoUnitOfWork)
{
_rabbitMqSettings = rabbitMqSettings;
_rabbitMqChannel = rabbitMqChannel;
_players = mongoUnitOfWork.GetRepository <PlayerInfo>();
}
public MessageBroker(RabbitMqSettings mqOptions, IBus bus)
{
_mqOptions = mqOptions;
_bus = bus;
}
public Program(RabbitMqSettings rabbitMqSettings, ILogger logger)
{
this.rabbitMqSettings = rabbitMqSettings;
this.logger = logger;
}
public TransferQueue(RabbitMqSettings rabbitConfig, IDelayWarmUp delayWampUpSubject, ILog log)
{
_rabbitConfig = rabbitConfig;
_delayWampUpSubject = delayWampUpSubject;
_log = log;
}
public RabbitMqModule(IReloadingManager <AppSettings> appSettings)
{
_settings = appSettings.CurrentValue.PartnersPaymentsService.RabbitMq;
}
public static void AddMassTransitConfiguration(this IServiceCollection services, RabbitMqSettings rabbitMqSettings)
{
services.AddMassTransit(x =>
{
x.AddConsumer <CreateBurgerOrderConsumer>(typeof(CreateBurgerOrderConsumerDefinition));
x.AddConsumer <OrderArchiverConsumer>(typeof(OrderArchiverConsumerDefinition));
x.UsingRabbitMq((context, cfg) =>
{
cfg.Host(rabbitMqSettings.Host, "/", h =>
{
h.Username(rabbitMqSettings.Username);
h.Password(rabbitMqSettings.Password);
});
cfg.ConfigureEndpoints(context);
});
});
}
public RabbitMqActivityUriProvider(RabbitMqSettings settings)
{
_settings = settings;
}
public MessageRelayBrokerActor(RabbitMqSettings settings)
{
_settings = settings;
}
public RabbitMqModule(IReloadingManager <AppSettings> settingsManager)
{
_settings = settingsManager.CurrentValue.AuditLogsService.Rabbit;
}
public RabbitMqModule(IReloadingManager <AppSettings> settings)
{
_settings = settings.CurrentValue.DashboardStatisticsService.RabbitMq;
}
public TestSettingsProvider(RabbitMqSettings settings)
{
_settings = settings;
}
public RabbitMqModule(IReloadingManager <AppSettings> appSettings)
{
_settings = appSettings.CurrentValue.EthereumBridgeJob.RabbitMq;
}
public RabbitMqEventBus(RabbitMqSettings rabbitMqSettings)
{
_rabbitMqSettings = rabbitMqSettings;
}
public RabbitMqModule(IReloadingManager <AppSettings> appSettings)
{
_settings = appSettings.CurrentValue.Rabbit;
}
public SettingsAdapter(RabbitMqSettings settings)
{
_settings = settings;
}
public RabbitMqTransportConfigurator(RabbitMqSettings settings)
{
_settings = settings;
}
