public void Start()
{
_bus = BusFactory.CreateAdvancedBus(ConfigurationReader.WorkflowSender);
var senderQueue = _bus.QueueDeclare("DataPlatform.DataProvider.Sender");
var senderExchange = _bus.ExchangeDeclare("DataPlatform.DataProvider.Sender", ExchangeType.Fanout);
_bus.Bind(senderExchange, senderQueue, string.Empty);
var receiverQueue = _bus.QueueDeclare("DataPlatform.DataProvider.Receiver");
var receiverExchange = _bus.ExchangeDeclare("DataPlatform.DataProvider.Receiver", ExchangeType.Fanout);
_bus.Bind(receiverExchange, receiverQueue, string.Empty);
_bus.Consume(senderQueue, x => x
.Add<SendRequestToDataProviderCommand>(
(message, info) => new SenderCauseFailureConsumers<SendRequestToDataProviderCommand>(message))
.Add<GetResponseFromDataProviderCommmand>(
(message, info) => new SenderCauseFailureConsumers<GetResponseFromDataProviderCommmand>(message))
.Add<CreateTransactionCommand>(
(message, info) => new SenderCauseFailureConsumers<CreateTransactionCommand>(message))
.Add<ReceiveEntryPointRequest>(
(message, info) => new SenderCauseFailureConsumers<ReceiveEntryPointRequest>(message))
.Add<ReturnEntryPointResponse>(
(message, info) => new SenderCauseFailureConsumers<ReturnEntryPointResponse>(message))
.Add<RaisingSecurityFlagCommand>(
(message, info) => new SenderCauseFailureConsumers<RaisingSecurityFlagCommand>(message))
.Add<ConfiguringDataProviderCommand>(
(message, info) => new SenderCauseFailureConsumers<ConfiguringDataProviderCommand>(message))
.Add<TransformingDataProviderResponseCommand>(
(message, info) => new SenderCauseFailureConsumers<TransformingDataProviderResponseCommand>(message))
.Add<ErrorInDataProviderCommand>(
(message, info) => new SenderCauseFailureConsumers<ErrorInDataProviderCommand>(message))
.Add<StartingCallCommand>(
(message, info) => new SenderCauseFailureConsumers<StartingCallCommand>(message))
.Add<EndingCallCommand>((message, info) => new SenderCauseFailureConsumers<EndingCallCommand>(message)));
_bus.Consume(receiverQueue, x => x
.Add<RequestToDataProvider>(
(message, info) => new ReceiverCauseFailureConsumers<RequestToDataProvider>(message))
.Add<EntryPointReceivedRequest>(
(message, info) => new ReceiverCauseFailureConsumers<EntryPointReceivedRequest>(message))
.Add<ResponseFromDataProvider>(
(message, info) => new ReceiverCauseFailureConsumers<ResponseFromDataProvider>(message))
.Add<EntryPointReturnedResponse>(
(message, info) => new ReceiverCauseFailureConsumers<EntryPointReturnedResponse>(message))
//.Add<BillTransactionMessage>(
// (message, info) => new ReceiverConsumers<BillTransactionMessage>(message))
.Add<SecurityFlagRaised>(
(message, info) => new ReceiverCauseFailureConsumers<SecurityFlagRaised>(message))
.Add<DataProviderCallEnded>(
(message, info) => new ReceiverCauseFailureConsumers<DataProviderCallEnded>(message))
.Add<DataProviderCallStarted>(
(message, info) => new ReceiverCauseFailureConsumers<DataProviderCallStarted>(message))
.Add<DataProviderError>(
(message, info) => new ReceiverCauseFailureConsumers<DataProviderError>(message))
.Add<DataProviderResponseTransformed>(
(message, info) => new ReceiverCauseFailureConsumers<DataProviderResponseTransformed>(message))
.Add<DataProviderConfigured>(
(message, info) => new ReceiverCauseFailureConsumers<DataProviderConfigured>(message)));
_log.DebugFormat("Data Provider Command Processor Service Started");
}
static OutboundServiceBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationManager.ConnectionStrings["rabbitMQ"].ConnectionString);
RequestPublisher = new ExchangePublisher<CreateValueInstructionFileRequest>(Bus);
// TODO: read from config
RequestPublisher.Declare("lombard.service.outclearings.createvalueinstructionfile.request");
RequestQueue = Bus.QueueDeclare("lombard.service.outclearings.createvalueinstructionfile.request.queue");
ResponseQueue = Bus.QueueDeclare("lombard.service.outclearings.createvalueinstructionfile.response.queue");
}
public void Start()
{
_log.DebugFormat("Started billing run service");
var container = new WindsorContainer().Install(
new NHibernateInstaller(),
new WindsorInstaller(),
new CacheProviderInstaller(),
new RepositoryInstaller(),
new AutoMapperInstaller(),
new ConsumerInstaller(),
new BusInstaller(),
new PublishReportQueueInstaller(),
new PivotInstaller(),
new ReportBuilderInstaller(),
new NotificationInstaller());
try
{
advancedBus = container.Resolve<IAdvancedBus>();
var q = advancedBus.QueueDeclare("DataPlatform.Transactions.BillingRun");
advancedBus.Consume(q, x => x
.Add<BillingMessage>((message, info) => new TransactionConsumer<BillingMessage>(message, container)));
}
catch (Exception e)
{
this.Error(() => e.Message);
}
_log.DebugFormat("Billing run service started");
}
public void Start()
{
_log.DebugFormat("Started billing service");
var container = new WindsorContainer().Install(
new NHibernateInstaller(),
new WindsorInstaller(),
new CacheProviderInstaller(),
new RepositoryInstaller(),
new AutoMapperInstaller(),
new ConsumerInstaller(),
new BusInstaller(),
new PublishReportQueueInstaller(),
new PivotInstaller(),
new ScheduleInstaller());
advancedBus = container.Resolve<IAdvancedBus>();
var q = advancedBus.QueueDeclare("DataPlatform.Transactions.Billing");
advancedBus.Consume(q, x => x
.Add<InvoiceTransactionCreated>((message, info) => new TransactionConsumer<InvoiceTransactionCreated> (message, container))
.Add<UserMessage>((message, info) => new TransactionConsumer<UserMessage> (message, container))
.Add<CustomerMessage>((message, info) => new TransactionConsumer<CustomerMessage>(message, container))
.Add<ClientMessage>((message, info) => new TransactionConsumer<ClientMessage>(message, container))
.Add<PackageMessage>((message, info) => new TransactionConsumer<PackageMessage>(message, container))
.Add<ContractMessage>((message, info) => new TransactionConsumer<ContractMessage>(message, container))
.Add<TransactionRequestMessage>((message, info) => new TransactionConsumer<TransactionRequestMessage>(message, container))
.Add<TransactionRequestCleanupMessage>((message, info) => new TransactionConsumer<TransactionRequestCleanupMessage>(message, container)));
_log.DebugFormat("Billing service started");
}
static OutboundServiceBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationManager.ConnectionStrings["rabbitMQ"].ConnectionString);
RequestPublisher = new ExchangePublisher<CreateImageExchangeFileRequest>(Bus);
RequestPublisher.Declare("lombard.service.outclearings.createimageexchangefile.request");
ResponseQueue = Bus.QueueDeclare("lombard.service.outclearings.createimageexchangefile.response.queue");
}
static ValidateCodelineBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher<ValidateBatchCodelineRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.ValidateCodelineResponseQueueName);
}
static GetVouchersInformationBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
ResponseExchange = new ExchangePublisher<GetVouchersInformationResponse>(Bus);
RequestQueue = Bus.QueueDeclare(ConfigurationHelper.GetPoolVouchersQueueName);
}
static GenerateCorrespondingVoucherBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher<GenerateCorrespondingVoucherRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.GenerateCorrespondingVoucherResponseQueueName);
}
static CorrectTransactionBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher<CorrectBatchTransactionRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.CorrectTransactionResponseQueueName);
}
static CreateAdjustmentLettersBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher<CreateBatchAdjustmentLettersRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.ResponseQueueName);
}
static AutoReadCarBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
InboundExchange = new ExchangePublisher<RecogniseBatchCourtesyAmountRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.OutboundQueueName);
}
static VifBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher<SendBatchValueInstructionFileRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.VifResponseQueueName);
}
static CheckThirdPartyBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher<CheckThirdPartyBatchRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.CheckThirdPartyResponseQueueName);
}
public void TestQueueWay2()
{
IAdvancedBus bus = RabbitHutch.CreateBus(ConfigurationAppSetting.RabbitMQHost, reg => reg.Register <IEasyNetQLogger>(log => new Log4NetLogger())).Advanced;
IExchange ex = bus.ExchangeDeclare("JinRi.Notify.Test.TestQueueWay2Ex", "fanout");
IQueue qu1 = bus.QueueDeclare("JinRi.Notify.Test.TestQueueWay2Queue1");
IQueue qu2 = bus.QueueDeclare("JinRi.Notify.Test.TestQueueWay2Queue2");
IQueue qu3 = bus.QueueDeclare("JinRi.Notify.Test.TestQueueWay2Queue3");
IBinding bi1 = bus.Bind(ex, qu1, "");
IBinding bi2 = bus.Bind(ex, qu2, "");
IBinding bi3 = bus.Bind(ex, qu3, "");
for (int i = 0; i < 100; i++)
{
int md = i % 3;
bus.Publish <string>(ex, "", false, false, new Message <string>(i.ToString()));
}
Thread.Sleep(5000);
}
public override void StartListening()
{
_receiveexchange = _bus.ExchangeDeclare(Configuration.ExchangeName, ExchangeType.Fanout);
_stampExchange = _bus.ExchangeDeclare(Configuration.StampExchangeName, "x-stamp");
_queue = Configuration.QueueName == null
? _bus.QueueDeclare()
: _bus.QueueDeclare(Configuration.QueueName);
_bus.Bind(_receiveexchange, _queue, "#");
_bus.Consume <RabbitMqMessageWrapper>(_queue,
(msg, messageReceivedInfo) =>
{
var message = msg.Body;
message.Id = (ulong)Convert.ToInt64(msg.Properties.Headers["stamp"]);
return(Task.Factory.StartNew(() => OnMessage(message)));
});
}
protected virtual string SubscribeToResponse <TRequest, TResponse>()
where TResponse : class
{
var responseType = typeof(TResponse);
var rpcKey = new RpcKey {
Request = typeof(TRequest), Response = responseType
};
string queueName;
if (responseQueues.TryGetValue(rpcKey, out queueName))
{
return(queueName);
}
lock (responseQueuesAddLock)
{
if (responseQueues.TryGetValue(rpcKey, out queueName))
{
return(queueName);
}
var queue = advancedBus.QueueDeclare(
conventions.RpcReturnQueueNamingConvention(),
passive: false,
durable: false,
exclusive: true,
autoDelete: true);
var exchange = DeclareAndBindRpcExchange(
conventions.RpcResponseExchangeNamingConvention(responseType),
queue,
queue.Name);
advancedBus.Consume <TResponse>(queue, (message, messageReceivedInfo) => Task.Factory.StartNew(() =>
{
ResponseAction responseAction;
if (responseActions.TryRemove(message.Properties.CorrelationId, out responseAction))
{
responseAction.OnSuccess(message);
}
}));
responseQueues.TryAdd(rpcKey, queue.Name);
return(queue.Name);
}
}
public void Subscribe <TMessage>(Action <TMessage> handler) where TMessage : class
{
var queue = advancedBus.QueueDeclare(QUEUE_NAME,
durable: true,
exclusive: false,
autoDelete: false);
advancedBus.Consume(queue, x => x
.Add <TMessage>((message, info) => handler(message.Body)));
}
public QueueInfoSnapshot GetQueueInfo(string subscriberName, bool temporary)
{
var queueName = _environmentNamingConventionController.GetQueueName(subscriberName);
var queue = _bus.QueueDeclare(queueName, true, true, temporary);
var countOfMessages = _bus.MessageCount(queue);
return(new QueueInfoSnapshot {
CountOfMessages = countOfMessages
});
}
static OutboundServiceBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationManager.ConnectionStrings["rabbitMQ"].ConnectionString);
requestPublisher = new ExchangePublisher<ExecuteBatchReportRequest>(Bus);
// TODO: read from config
requestPublisher.Declare("lombard.service.reporting.executereport.request");
ResponseQueue = Bus.QueueDeclare("lombard.service.reporting.executereport.response.queue");
}
public async Task Handle(CustomerWasCreated notification, CancellationToken cancellationToken)
{
var message = new Message <ICustomerWasCreated>(notification);
var exchange = _bus.ExchangeDeclare("customer-was-created", ExchangeType.Fanout);
var queue = _bus.QueueDeclare("customer-was-created");
_bus.Bind(exchange, queue, "");
await _bus.PublishAsync <ICustomerWasCreated>(exchange, "", true, message);
}
public async Task PublishPayment(Payment message)
{
var queueExhange = nameof(Payment);
var queue2 = _bus.QueueDeclare(queueExhange);
var exchange = _bus.ExchangeDeclare(queueExhange, ExchangeType.Topic);
_bus.Bind(exchange, queue2, "A.*");
var topic = $"ProjectId.CabinId";
var yourMessage = new Message <string>(JsonConvert.SerializeObject(message));
await _bus.PublishAsync(exchange, "A.*", true, yourMessage);
}
private IQueue DeclareQueue(string queueName)
{
IQueue queue = null;
if (!declaredQueues.TryGetValue(queueName, out queue))
{
var param = new QueueDeclareParam(queueName);
queue = advancedBus.QueueDeclare(param);
declaredQueues.TryAdd(queueName, queue);
}
return(queue);
}
private static void CreateConsumers(IDependencyResolver resolver, IAdvancedBus advancedBus, ExchangeItem exchangeItem)
{
if (exchangeItem.RabbitExchange == null)
{
throw new ArgumentException("rabbit exchange is null`");
}
foreach (var income in exchangeItem.In)
{
var queue = advancedBus.QueueDeclare(string.Format("{0}.{1}", exchangeItem.Name, income.Key));
advancedBus.Bind(exchangeItem.RabbitExchange, queue, income.Key);
var messageType = ReflectionHelper.ResolveType(income.Type);
if (messageType == null)
{
throw new Exception("no such message type");
}
Type consType = ReflectionHelper.ResolveType(income.React);
var consumer = resolver.Resolve(consType);
var endpointInfo = EndpointInfoFactory.Create(advancedBus, exchangeItem.RabbitExchange, income.Name, income.Key);
var handlerReg = GetHandlerRegistration(endpointInfo, consumer, messageType);
IList <object> consumeInvokeParams = new List <object>();
consumeInvokeParams.Add(queue);
var action = ConsumeWrapperProvider.GetConsumeActionWrapper(handlerReg, resolver);
consumeInvokeParams.Add(action);
if (!ConsumerActions.TryAdd(consumer.GetType(), action))
{
Logger.Warn("can't add consumer handler for {0}", consumer.GetType().ToString());
}
Action <IConsumerConfiguration> consConf = configuration => configuration.WithPrefetchCount(exchangeItem.PrefetchCount);
consumeInvokeParams.Add(consConf);
//NOTE: Such ugly shit to get generic overloaded method
var sbConsume = typeof(IAdvancedBus).GetMethods().Where(x => x.Name == "Consume").Select(m => new
{
Method = m,
Params = m.GetParameters(),
Args = m.GetGenericArguments()
}).Where(x => x.Params.Length == 3 && x.Args.Length == 0 &&
x.Params[1].ParameterType.Name == action.GetType().Name)
.Select(x => x.Method)
.First();
sbConsume.Invoke(advancedBus, consumeInvokeParams.ToArray());
}
}
public void DeclareTopology()
{
var queue = advancedBus.QueueDeclare("my_queue");
var exchange = advancedBus.ExchangeDeclare("my_exchange", ExchangeType.Direct);
advancedBus.Bind(exchange, queue, "routing_key");
}
public void SetUp()
{
_applicationController = ContextRegistry.GetContext()["ApplicationController"] as ApplicationController;
if (_applicationController != null)
{
_applicationController.StartServer();
}
// Initialize Advance Bus
_advancedBus = RabbitHutch.CreateBus("host=localhost").Advanced;
// Create a admin exchange
_adminExchange = _advancedBus.ExchangeDeclare("marketdata_exchange", ExchangeType.Direct, true, false, true);
// Create strategy admin Queue
_strategyAdminQueue = _advancedBus.QueueDeclare("admin_queue", false, false, true, true);
// Create strategy Tick Queue
_tickQueue = _advancedBus.QueueDeclare("tick_queue", false, false, true, true);
// Create strategy Live Bar Queue
_liveBarQueue = _advancedBus.QueueDeclare("bar_queue", false, false, true, true);
// Create strategy Tick Queue
_historicQueue = _advancedBus.QueueDeclare("historic_queue", false, false, true, true);
// Create admin Queue
_logonQueue = _advancedBus.QueueDeclare("marketdata_engine_logon_queue", false, false, true, true);
// Create inquiry Queue
_inquiryQueue = _advancedBus.QueueDeclare("inquiry_queue", false, false, true, true);
// Bind Strategy Admin Queue to already initialized Exchange with the specified Routing Key
_advancedBus.Bind(_adminExchange, _strategyAdminQueue, "admin.strategy.key");
// Bind Strategy Tick Queue to already initialized Exchange with the specified Routing Key
_advancedBus.Bind(_adminExchange, _tickQueue, "tick.strategy.key");
// Bind Strategy Live Bar Queue to already initialized Exchange with the specified Routing Key
_advancedBus.Bind(_adminExchange, _liveBarQueue, "bar.strategy.key");
// Bind Strategy Historic Queue to already initialized Exchange with the specified Routing Key
_advancedBus.Bind(_adminExchange, _historicQueue, "historic.strategy.key");
// Bind Admin Queue to already initialized Exchange with the specified Routing Key
_advancedBus.Bind(_adminExchange, _inquiryQueue, "inquiry.strategy.key");
// Bind Admin Queue to already initialized Exchange with the specified Routing Key
_advancedBus.Bind(_adminExchange, _logonQueue, "marketdata.engine.login");
var appInfoMessage = new Message <Dictionary <string, string> >(appInfo);
appInfoMessage.Properties.AppId = "test_app_id";
string routingKey = "marketdata.engine.appinfo";
//using (var channel = _advancedBus.OpenPublishChannel())
{
_advancedBus.Publish(_adminExchange, routingKey, true, false, appInfoMessage);
}
}
public EasyNetQPublisher()
{
Console.WriteLine("*** Using EasyNetQ Publisher");
Console.WriteLine($"***** RabbitMQ Host: {RABBITMQ_HOST}");
Console.WriteLine($"***** Queue Name: {QUEUE_NAME}");
advancedBus = RabbitHutch.CreateBus($"host={RABBITMQ_HOST}").Advanced;
// declare a durable queue
var queue = advancedBus.QueueDeclare(QUEUE_NAME,
durable: true,
exclusive: false,
autoDelete: false);
}
public async Task RegisterHandlerAsync(string route, Func <Message, CancellationToken, Task> handler, CancellationToken cancellationToken = default)
{
var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
var exchange = await DeclareBusExchangeAsync(cts.Token);
var queue = _bus.QueueDeclare(route);
_bus.Bind(exchange, queue, route);
// TODO token passed into handler?
_bus.Consume(queue, (body, props, info) => handler(MessageHelpers.FromArgs(body, props), CancellationToken.None));
}
public void Start()
{
var infExchanger = _bus.ExchangeDeclare(ExchangerNames.Tasks, ExchangeType.Topic);
_finishedProductsExchange = _bus.ExchangeDeclare(_settings.FinishedProductExchanger, ExchangeType.Fanout);
var queue = _bus.QueueDeclare("CheckProductReadyQueue");
_bus.Bind(infExchanger, queue, "*");
_bus.Consume(queue, registration => registration
.Add <TaskArguments>((message, info) => { ConsumeAndProcess(message.Body); })
);
}
public void TestQueueWay4()
{
IAdvancedBus bus = RabbitHutch.CreateBus(ConfigurationAppSetting.RabbitMQHost, reg => reg.Register <IEasyNetQLogger>(log => new Log4NetLogger())).Advanced;
IExchange ex = bus.ExchangeDeclare("JinRi.Notify.Test.TestQueueWay4Ex", "topic");
IQueue qu1 = bus.QueueDeclare("JinRi.Notify.Test.TestQueueWay4Queue1");
IQueue qu2 = bus.QueueDeclare("JinRi.Notify.Test.TestQueueWay4Queue2");
IQueue qu3 = bus.QueueDeclare("JinRi.Notify.Test.TestQueueWay4Queue3");
IBinding bi1 = bus.Bind(ex, qu1, "*.0.*");
IBinding bi2 = bus.Bind(ex, qu2, "*.1.*");
IBinding bi3 = bus.Bind(ex, qu3, "*.2.*");
for (int i = 0; i < 100; i++)
{
int md = i % 3;
bus.Publish <string>(ex, "a." + md.ToString() + ".b", false, false, new Message <string>(i.ToString()));
}
bus.Consume <string>(qu1, (a, b) =>
{
Debug.WriteLine(a.Body);
});
Thread.Sleep(5000);
}
public void SetUp()
{
mockBuilder = new MockBuilder();
advancedBus = mockBuilder.Bus.Advanced;
queue = advancedBus.QueueDeclare(
"my_queue",
passive: false,
durable: false,
exclusive: true,
autoDelete: true,
perQueueTtl: 1000,
expires: 2000);
}
public void SetUp()
{
mockBuilder = new MockBuilder();
advancedBus = mockBuilder.Bus.Advanced;
queue = advancedBus.QueueDeclare(
"my_queue",
passive: false,
durable: false,
exclusive: true,
autoDelete: true,
perQueueTtl: 1000,
expires: 2000);
}
public void Start()
{
var finishedProductExchanger = _bus.ExchangeDeclare(_settings.FinishedProductExchanger, ExchangeType.Fanout);
var queue = _bus.QueueDeclare("ProductQueue");
_bus.Bind(finishedProductExchanger, queue, "*");
_bus.Consume(queue, registration => registration
.Add <TaskArguments>((message, info) =>
{
Process(message.Body);
}));
}
/// <summary>
/// 创建消息队列
/// </summary>
/// <param name="adbus"></param>
/// <param name="queueName"></param>
/// <returns></returns>
private async Task <IQueue> CreateQueue <T>(IAdvancedBus adbus)
{
var mqInfo = this.GetMqInfo <T>();
if (adbus == null)
{
return(null);
}
if (string.IsNullOrEmpty(mqInfo.QueueName))
{
return(adbus.QueueDeclare());
}
return(await adbus.QueueDeclareAsync(mqInfo.QueueName));
}
/// <inheritdoc />
/// <summary>
/// Создает соединение с очередью
/// </summary>
public void Connect()
{
_logger.LogDebug("Trying to connect to queue with id: {queueId}", _configuration.Id);
CheckDisposed();
if (IsConnected)
{
_logger.LogDebug("Already connected to queue with id: {queueId}", _configuration.Id);
return;
}
lock (_connectionLock)
{
try
{
_advancedBus = _advancedBusFactory.Create(_configuration.Server, _configuration.Port, _configuration.VirtualHost ?? "/",
_configuration.User, _configuration.Password, DefaultRequestedHeartbeat, x => {});
var isQueueNameSpecified = !string.IsNullOrWhiteSpace(_configuration.QueueName);
var isExchangeNameSpecified = !string.IsNullOrWhiteSpace(_configuration.ExchangeName);
if (isQueueNameSpecified)
{
_queue = _advancedBus.QueueDeclare(_configuration.QueueName);
}
if (isExchangeNameSpecified)
{
var type = string.IsNullOrWhiteSpace(_configuration.ExchangeType)
? ExchangeType.Fanout
: _configuration.ExchangeType;
_exchange = _advancedBus.ExchangeDeclare(_configuration.ExchangeName, type);
}
if (isQueueNameSpecified && isExchangeNameSpecified)
{
InitializeBinds();
}
_logger.LogDebug("Established connection to queue with id: {queueId}", _configuration.Id);
}
catch (Exception e)
{
_logger.LogError(e, "Fail to connection to queue with id: {queueId}", _configuration.Id);
Disconnect();
throw;
}
}
}
public When_a_queue_is_declared()
{
mockBuilder = new MockBuilder();
advancedBus = mockBuilder.Bus.Advanced;
queue = advancedBus.QueueDeclare(
"my_queue",
passive: false,
durable: false,
exclusive: true,
autoDelete: true,
perQueueMessageTtl: 1000,
expires: 2000,
maxPriority: 10);
}
private void InitializeBus()
{
try
{
_bus = RabbitHutch.CreateBus("host=www.sitech365.com:5672;username=Test;password=123Li456").Advanced;
_exchange = _bus.ExchangeDeclare("DEFAULT_EXCHANGE", ExchangeType.Topic, passive: true);
var macString = SystemHelper.GetMACAddress(string.Empty);
_realTimeDataQueue = _bus.QueueDeclare($"Smart365Client_{macString}_RealTime_Queue", maxLength: 1000);
_alarmDataQueue = _bus.QueueDeclare($"Smart365Client_{macString}_Alarm_Queue");
var principal = Thread.CurrentPrincipal as SystemPrincipal;
var agentId = principal.Identity.Id;
var customerList = _customerService.GetCustomersBy(agentId);
var customerIdList = customerList.Select(c => c.Id.ToString()).Distinct();
var subscriberKeys = customerIdList.Select(i => $"A.C{i}").ToArray();
SubscriberToAlarmData(subscriberKeys);
}
catch (Exception ex)
{
throw ex;
}
}
/// <inheritdoc/>
public void DeclareDeadLetterQueueForPublish(
string name,
bool addQueueNamePrefix = true,
bool durable = true,
int messageTtl = 10,
int maxPriority = (int)Priority.High,
string deadLetterExchange = "",
string deadLetterRoutingKey = QueueName.Outbox)
{
if (addQueueNamePrefix)
{
name = $"{configuration.QueuesNamePrefix}{name}";
}
bus.QueueDeclare(name: name, config =>
{
config
.AsDurable(true)
.WithMessageTtl(new TimeSpan(0, 0, 0, 0, messageTtl))
.WithMaxPriority(maxPriority)
.WithDeadLetterExchange(new Exchange(deadLetterExchange))
.WithDeadLetterRoutingKey(deadLetterRoutingKey);
});
}
public void Start()
{
this.Info(() => "Started reporting service");
var container = new WindsorContainer().Install(
new WindsorInstaller(),
new BusInstaller(),
new NotificationInstaller(),
new ConsumerInstaller());
advancedBus = container.Resolve<IAdvancedBus>();
var q = advancedBus.QueueDeclare("DataPlatform.Reports.Billing");
advancedBus.Consume(q, x => x
.Add<ReportMessage>((message, info) => new TransactionConsumer<ReportMessage>(message, container)));
}
/// <summary>
/// Initializes a new instance of the <see cref="MailUserDispatcher"/> class.
/// </summary>
/// <param name="bus"></param>
/// <param name="config"></param>
/// <param name="userTestResultRepository"></param>
public MailUserDispatcher(
IBus bus,
IOptions <SendEmailConfig> config,
IUserTestResultRepository userTestResultRepository,
ITestResultRepository testResultRepository)
{
_userTestResultRepository = userTestResultRepository;
_testResultRepository = testResultRepository;
_config = config.Value;
_advancedBus = bus.Advanced;
var queue = _advancedBus.QueueDeclare(_config.EmailQueue);
_exchange = _advancedBus.ExchangeDeclare(_config.EmailExchange, ExchangeType.Direct);
_advancedBus.Bind(_exchange, queue, _config.RoutingKey);
}
/// <summary>
/// Initializes RabbitMQ Queue
/// </summary>
private IQueue InitializeQueue(IExchange exchange, string queueName, string routingKey)
{
try
{
// Initialize specified Queue
IQueue queue = _easyNetQBus.QueueDeclare(queueName, false, false, true, true);
// Bind Queue to already initialized Exchange with the specified Routing Key
_easyNetQBus.Bind(exchange, queue, routingKey);
return(queue);
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "InitializeQueue");
return(null);
}
}
public async Task Publish(string mes)
{
var queueExhange = nameof(PublishMessage);
var queue2 = _bus.QueueDeclare(queueExhange);
var exchange = _bus.ExchangeDeclare(queueExhange, ExchangeType.Topic);
_bus.Bind(exchange, queue2, "A.*");
var newMessage = new PublishMessage()
{
Text = "Hello"
};
var topic = $"ProjectId.CabinId";
var yourMessage = new Message <string>(JsonConvert.SerializeObject(new PublishMessage {
Text = mes
}));
await _bus.PublishAsync(exchange, "A.*", true, yourMessage);
}
public void SetUp()
{
mockBuilder = new MockBuilder();
advancedBus = mockBuilder.Bus.Advanced;
queue = advancedBus.QueueDeclare(
"my_queue",
passive: false,
durable: false,
exclusive: true,
autoDelete: true,
perQueueMessageTtl: 1000,
expires: 2000,
maxPriority: 10,
deadLetterExchange: "my_exchange",
deadLetterRoutingKey: "my_routing_key");
}
public When_a_queue_is_declared_With_EmptyDeadLetterExchange()
{
mockBuilder = new MockBuilder();
advancedBus = mockBuilder.Bus.Advanced;
queue = advancedBus.QueueDeclare(
"my_queue",
passive: false,
durable: false,
exclusive: true,
autoDelete: true,
perQueueMessageTtl: 1000,
expires: 2000,
maxPriority: 10,
deadLetterExchange: "",
deadLetterRoutingKey: "my_queue2");
}
public virtual ISubscriptionResult SubscribeAsync <T>(string subscriptionId, Func <T, Task> onMessage, Action <ISubscriptionConfiguration> configure) where T : class
{
Preconditions.CheckNotNull(subscriptionId, "subscriptionId");
Preconditions.CheckNotNull(onMessage, "onMessage");
Preconditions.CheckNotNull(configure, "configure");
var configuration = new SubscriptionConfiguration(connectionConfiguration.PrefetchCount);
configure(configuration);
var queueName = configuration.QueueName ?? conventions.QueueNamingConvention(typeof(T), subscriptionId);
var exchangeName = conventions.ExchangeNamingConvention(typeof(T));
var queue = advancedBus.QueueDeclare(
queueName,
autoDelete: configuration.AutoDelete,
durable: configuration.Durable,
expires: configuration.Expires,
maxPriority: configuration.MaxPriority,
maxLength: configuration.MaxLength,
maxLengthBytes: configuration.MaxLengthBytes,
consumerRepariable: true);
var exchange = advancedBus.ExchangeDeclare(exchangeName, ExchangeType.Topic);
foreach (var topic in configuration.Topics.DefaultIfEmpty("#"))
{
advancedBus.Bind(exchange, queue, topic);
}
var consumerCancellation = advancedBus.Consume <T>(
queue,
(message, messageReceivedInfo) => onMessage(message.Body),
x =>
{
x.WithPriority(configuration.Priority)
.WithCancelOnHaFailover(configuration.CancelOnHaFailover)
.WithPrefetchCount(configuration.PrefetchCount);
if (configuration.IsExclusive)
{
x.AsExclusive();
}
});
return(new SubscriptionResult(exchange, queue, consumerCancellation));
}
public void StartCalculation()
{
var calculationId = InitializeDistributedCalculation();
var exchange = _bus.ExchangeDeclare("fibonacciExchange", "direct", durable: true, autoDelete: true);
var queue = _bus.QueueDeclare();
var routingId = calculationId.ToString();
_bus.Bind(exchange, queue, routingId);
_bus.Consume(queue, (bytes, properties, info) =>
{
CalculateNextNumber(bytes, calculationId);
});
SendNumber(InitialFibonacciNumber, calculationId);
}
public IDisposable SubscribeAsync
(
[NotNull] Type type,
[NotNull] string subscriptionId,
[NotNull] Func <object, Task> onMessage,
[NotNull] Action <IAdvancedSubscriptionConfiguration> configure
)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (subscriptionId == null)
{
throw new ArgumentNullException("subscriptionId");
}
if (onMessage == null)
{
throw new ArgumentNullException("onMessage");
}
if (configure == null)
{
throw new ArgumentNullException("configure");
}
var configuration = new AdvancedSubscriptionConfiguration();
configure(configuration);
var queueName = conventions.QueueNamingConvention(type, subscriptionId);
var exchangeName = conventions.ExchangeNamingConvention(type);
var queue = advancedBus.QueueDeclare(queueName, durable: configuration.Durable, autoDelete: configuration.AutoDelete);
var exchange = advancedBus.ExchangeDeclare(exchangeName, ExchangeType.Topic);
foreach (var topic in configuration.Topics.AtLeastOneWithDefault("#"))
{
advancedBus.Bind(exchange, queue, topic);
}
Func <IMessage <object>, MessageReceivedInfo, Task> oms = (message, messageRecievedInfo) => onMessage(message.Body);
return(advancedBus.Consume(queue, x => x.Add(oms)));
}
public void Start()
{
_log.DebugFormat("Started billing cache service");
var container = new WindsorContainer().Install(
new NHibernateInstaller(),
new WindsorInstaller(),
new CacheProviderInstaller(),
new RepositoryInstaller(),
new ConsumerInstaller(),
new BusInstaller());
advancedBus = container.Resolve<IAdvancedBus>();
var cache = advancedBus.QueueDeclare("DataPlatform.Cache.Billing");
advancedBus.Consume(cache, x => x
.Add<BillCacheMessage>((message, info) => new TransactionConsumer<BillCacheMessage>(message, container)));
_log.DebugFormat("Billing cache service started");
}
public void Start()
{
Log.Debug("Starting Cache Worker");
var properties = new NameValueCollection();
properties["quartz.scheduler.instanceName"] = "RemoteServer";
properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz";
properties["quartz.threadPool.threadCount"] = "5";
properties["quartz.threadPool.threadPriority"] = "Normal";
properties["quartz.plugin.xml.type"] = "Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin, Quartz";
properties["quartz.plugin.xml.fileNames"] = "jobs.xml";
ISchedulerFactory schedulerFactory = new StdSchedulerFactory(properties);
_scheduler = schedulerFactory.GetScheduler();
_scheduler.JobFactory = new JobFactory(_container);
_scheduler.Start();
_bus = _container.Resolve<IAdvancedBus>();
var receiverQueue = _bus.QueueDeclare("DataPlatform.DataProvider.Cache.Receiver");
var receiverExchange = _bus.ExchangeDeclare("DataPlatform.DataProvider.Cache.Receiver", ExchangeType.Fanout);
_bus.Bind(receiverExchange, receiverQueue, string.Empty);
_bus.Consume(receiverQueue, q => q
.Add<ClearCacheCommand>(
(message, info) => new ReceiverConsumers<ClearCacheCommand>(message, _container))
.Add<RefreshCacheCommand>(
(message, info) => new ReceiverConsumers<RefreshCacheCommand>(message, _container))
.Add<RestartCacheDataStoreCommand>(
(message, info) => new ReceiverConsumers<RestartCacheDataStoreCommand>(message, _container)));
Log.Debug("Cache Worker has started");
}
public static IQueue CreatQueue(IAdvancedBus bus)
{
var environment = new Environment();
var queue = bus.QueueDeclare(environment.GetEnvironmentVariable("QueueName"));
return queue;
}
static CopyImageBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
Queue = Bus.QueueDeclare(ConfigurationHelper.CopyImagesQueueName);
}
static IncidentBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
Queue = Bus.QueueDeclare(ConfigurationHelper.IncidentQueueName);
}
public void Start()
{
_log.DebugFormat("Data Provider Command Processor Service being fired up...");
var container = new WindsorContainer().Install(
new WindsorInstaller(),
new RepositoryInstaller(),
new ConsumerInstaller(),
new BusInstaller());
_bus = container.Resolve<IAdvancedBus>();
var senderQueue = _bus.QueueDeclare("DataPlatform.DataProvider.Sender");
var senderExchange = _bus.ExchangeDeclare("DataPlatform.DataProvider.Sender", ExchangeType.Fanout);
_bus.Bind(senderExchange, senderQueue, string.Empty);
var receiverQueue = _bus.QueueDeclare("DataPlatform.DataProvider.Receiver");
var receiverExchange = _bus.ExchangeDeclare("DataPlatform.DataProvider.Receiver", ExchangeType.Fanout);
_bus.Bind(receiverExchange, receiverQueue, string.Empty);
_bus.Consume(senderQueue, q => q
.Add<SendRequestToDataProviderCommand>(
(message, info) => new SenderConsumers<SendRequestToDataProviderCommand>(message, container))
.Add<GetResponseFromDataProviderCommmand>(
(message, info) => new SenderConsumers<GetResponseFromDataProviderCommmand>(message, container))
.Add<CreateTransactionCommand>(
(message, info) => new SenderConsumers<CreateTransactionCommand>(message, container))
.Add<ReceiveEntryPointRequest>(
(message, info) => new SenderConsumers<ReceiveEntryPointRequest>(message, container))
.Add<ReturnEntryPointResponse>(
(message, info) => new SenderConsumers<ReturnEntryPointResponse>(message, container))
.Add<RaisingSecurityFlagCommand>(
(message, info) => new SenderConsumers<RaisingSecurityFlagCommand>(message, container))
.Add<ConfiguringDataProviderCommand>(
(message, info) => new SenderConsumers<ConfiguringDataProviderCommand>(message, container))
.Add<TransformingDataProviderResponseCommand>(
(message, info) => new SenderConsumers<TransformingDataProviderResponseCommand>(message, container))
.Add<ErrorInDataProviderCommand>(
(message, info) => new SenderConsumers<ErrorInDataProviderCommand>(message, container))
.Add<StartingCallCommand>(
(message, info) => new SenderConsumers<StartingCallCommand>(message, container))
.Add<EndingCallCommand>((message, info) => new SenderConsumers<EndingCallCommand>(message, container)));
_bus.Consume(receiverQueue, q => q
.Add<RequestToDataProvider>(
(message, info) => new ReceiverConsumers<RequestToDataProvider>(message, container))
.Add<EntryPointReceivedRequest>(
(message, info) => new ReceiverConsumers<EntryPointReceivedRequest>(message, container))
.Add<ResponseFromDataProvider>(
(message, info) => new ReceiverConsumers<ResponseFromDataProvider>(message, container))
.Add<EntryPointReturnedResponse>(
(message, info) => new ReceiverConsumers<EntryPointReturnedResponse>(message, container))
.Add<BillTransactionMessage>(
(message, info) => new ReceiverConsumers<BillTransactionMessage>(message, container))
.Add<SecurityFlagRaised>(
(message, info) => new ReceiverConsumers<SecurityFlagRaised>(message, container))
.Add<DataProviderCallEnded>(
(message, info) => new ReceiverConsumers<DataProviderCallEnded>(message, container))
.Add<DataProviderCallStarted>(
(message, info) => new ReceiverConsumers<DataProviderCallStarted>(message, container))
.Add<DataProviderError>(
(message, info) => new ReceiverConsumers<DataProviderError>(message, container))
.Add<DataProviderResponseTransformed>(
(message, info) => new ReceiverConsumers<DataProviderResponseTransformed>(message, container))
.Add<DataProviderConfigured>(
(message, info) => new ReceiverConsumers<DataProviderConfigured>(message, container)));
var apiReceiverQueue = _bus.QueueDeclare("DataPlatform.Api");
var apiReceiverExchange = _bus.ExchangeDeclare("DataPlatform.Api", ExchangeType.Fanout);
_bus.Bind(apiReceiverExchange, apiReceiverQueue, string.Empty);
_bus.Consume(apiReceiverQueue,
q => q.Add<RequestMetadataMessage>((message, info) => new ReceiverConsumers<RequestMetadataMessage>(message, container)));
_log.DebugFormat("Data Provider Command Processor Service Started");
}
public void SetUp()
{
mockBuilder = new MockBuilder();
advancedBus = mockBuilder.Bus.Advanced;
queue = advancedBus.QueueDeclare(
"my_queue",
passive: false,
durable: false,
exclusive: true,
autoDelete: true,
perQueueMessageTtl: 1000,
expires: 2000,
maxPriority: 10,
deadLetterExchange: "my_exchange",
deadLetterRoutingKey: "my_routing_key");
}
