private string SubscribeToResponse <TRequest, TResponse>()
where TResponse : class
{
var rpcKey = new RpcKey {
Request = typeof(TRequest), Response = typeof(TResponse)
};
responseQueues.AddOrUpdate(rpcKey,
key =>
{
var queue = advancedBus.QueueDeclare(
conventions.RpcReturnQueueNamingConvention(),
passive: false,
durable: false,
exclusive: true,
autoDelete: true);
advancedBus.Consume <TResponse>(queue, (message, messageRecievedInfo) => Task.Factory.StartNew(() =>
{
ResponseAction responseAction;
if (responseActions.TryRemove(message.Properties.CorrelationId, out responseAction))
{
responseAction.OnSuccess(message);
}
}));
return(queue.Name);
},
(_, queueName) => queueName);
return(responseQueues[rpcKey]);
}
//listen to position messages
public void SubscribePositionMessageQueues()
{
try
{
if (Logger.IsInfoEnabled)
{
Logger.Info("Binding Position Message Queue: " + _positionMessageQueue.Name, _type.FullName,
"SubscribePositionMessageQueues");
}
// Listening to Position Messages
_rabbitBus.Consume <Position>(
_positionMessageQueue, (msg, messageReceivedInfo) =>
Task.Factory.StartNew(
() =>
{
if (PositionMessageArrived != null)
{
PositionMessageArrived(msg);
}
}));
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "SubscribePositionMessageQueues");
}
}
/// <summary>
/// Binds the Admin Message Queue
/// Starts listening to the incoming Admin Level messages
/// </summary>
public void SubscribeAdminMessageQueues()
{
try
{
if (Logger.IsInfoEnabled)
{
Logger.Info("Binding Admin Message Queue: " + _adminMessageQueue.Name, _type.FullName,
"SubscribeAdminMessageQueues");
}
// Listening to Login Messages
_easyNetQBus.Consume <string>(
_adminMessageQueue, (msg, messageReceivedInfo) =>
Task.Factory.StartNew(
() =>
{
if (msg.Body.Equals("OrderLogin"))
{
OrderExecutionLoginRequest();
}
else if (msg.Body.Equals("OrderLogout"))
{
OrderExecutionLogoutRequest();
}
}));
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "SubscribeAdminMessageQueues");
}
}
public void TransMedPublishesEvent()
{
//SystemX lytter
_advancedBus.Consume(_systemXQueue,
(IMessage <PatientHaveReceivedTreatmentAndCanBeInvoicedA97Event> msg, MessageReceivedInfo info) =>
{
Console.WriteLine($"SystemX mottok melding med routingkey {info.RoutingKey}: {JsonConvert.SerializeObject(msg.Body)}");
_waitForMessage.Set();
});
//TransMed publiserer event
var eventToPublish =
new Message <PatientHaveReceivedTreatmentAndCanBeInvoicedA97Event>(new PatientHaveReceivedTreatmentAndCanBeInvoicedA97Event
{
NIN = "12345678901",
TreatmentDescription = "Stivkrampevaksine",
UserId = "les-123"
});
//sett AMQP properties (correlationid settes av easynetq, trenger ikke reply-to siden vi ikke skal ha svar)
eventToPublish.Properties.Expiration =
TimeSpan.FromDays(2).TotalMilliseconds.ToString(CultureInfo.InvariantCulture); //ttl
eventToPublish.Properties.AppId = "TransMed"; //tilsvarer sanns. "sender"
//publish
_advancedBus.Publish(_systemXExchange, $"event.{nameof(PatientHaveReceivedTreatmentAndCanBeInvoicedA97Event)}", true, eventToPublish);
_waitForMessage.WaitOne(3000);
}
public virtual void SubscribeAsync <T>(string subscriptionId, Func <T, Task> onMessage, Action <ISubscriptionConfiguration <T> > configure)
{
Preconditions.CheckNotNull(subscriptionId, "subscriptionId");
Preconditions.CheckNotNull(onMessage, "onMessage");
var configuration = new SubscriptionConfiguration <T>();
configure(configuration);
var queueName = GetQueueName <T>(subscriptionId);
var exchangeName = GetExchangeName <T>();
var queue = advancedBus.QueueDeclare(queueName);
var exchange = advancedBus.ExchangeDeclare(exchangeName, ExchangeType.Topic);
if (configuration.Topics.Count == 0)
{
advancedBus.Bind(exchange, queue, "#");
}
else
{
foreach (var topic in configuration.Topics)
{
advancedBus.Bind(exchange, queue, topic);
}
}
advancedBus.Consume <T>(queue, (message, messageRecievedInfo) => onMessage(message.Body));
}
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");
}
public IDisposable Receive <T>(
string queue,
Func <T, Task> onMessage,
Action <IConsumerConfiguration> configure = null)
where T : class
{
var declaredQueue = DeclareQueue(queue);
return(advancedBus.Consume <T>(declaredQueue, (message, info) => onMessage(message.Body), configure));
}
public void SubscribeJobMessage()
{
var queue = _bus.QueueDeclare("JobMessage");
_bus.Consume <string>(queue, async(msg, info) =>
{
using var serviceScope = _pr.GetRequiredService <IServiceScopeFactory>().CreateScope();
var bookingService = serviceScope.ServiceProvider.GetService <IBookingService>();
await bookingService.CheckReservation(DeserializeJobMessage(msg.Body));
});
}
/// <inheritdoc/>
public IDisposable Subscribe <T>(Action <T> action, string queueName) where T : OutgoingMessage
{
var queue = bus.QueueDeclare(queueName);
return(bus.Consume(queue, (body, properties, info) =>
{
var jsonMessage = Encoding.UTF8.GetString(body);
var resultMessage = JsonConvert.DeserializeObject <T>(jsonMessage);
action.Invoke(resultMessage);
}));
}
public void ConsumeFromAQueue()
{
var queue = new Queue("my_queue", false);
advancedBus.Consume(queue, (body, properties, info) => Task.Factory.StartNew(() =>
{
var message = Encoding.UTF8.GetString(body);
Console.Out.WriteLine("Got message: '{0}'", message);
}));
Thread.Sleep(500);
}
public void Start(QueueReaderSettings config, ActiveQueueContext context)
{
var connectionString = config.ConnectionString.FetchConnectionSslOptions(out var configure);
_client = RabbitHutch
.CreateBus(x =>
{
var connectionConfig = x.Resolve <IConnectionStringParser>().Parse(connectionString);
return(configure(connectionConfig));
}, x => { })
.Advanced;
var queue = _client.QueueDeclare(config.QueueName);
_client.Consume(queue, (body, properties, info) => Task.Factory.StartNew(() =>
{
try
{
var msg = Event.Parser.ParseFrom(body);
context.OnReceivedMessage(msg);
}
catch (Exception ex)
{
context.OnError($"MessagePump.OnMessage RabbitMQ Parse Error: {ex.Message}");
}
}));
}
public void SubscriberToAlarmData(string[] keys)
{
foreach (var key in keys)
{
_bus.Bind(_exchange, _alarmDataQueue, key);
}
_bus.Consume(_alarmDataQueue, (body, properties, info) => Task.Run(() =>
{
var message = Encoding.UTF8.GetString(body);
var key = info.RoutingKey;
if (keys.Contains(key))
{
HandleAlarmData(message);
}
}));
}
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");
}
/// <summary>
/// 订阅消息。自定义主题、交换机名称。EasyNetQ高级API
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="work">消息处理方式</param>
/// <param name="subscriptionId">订阅者ID</param>
/// <param name="fail">失败处理方式</param>
/// <param name="exchangeName">交换机名称</param>
/// <param name="topics">主题</param>
public void Subscribe <T>(Action <T> work, Action fail = null, string subscriptionId = "topic_subid", string exchangeName = "default_exchange", params string[] topics) where T : class, IBaseMqMessage
{
this.Logger(this.GetType(), "订阅消息。自定义主题、交换机名称-Subscribe", () =>
{
IAdvancedBus advanced = bus.Advanced;
IExchange exchange = advanced.ExchangeDeclare(exchangeName, ExchangeType.Topic);
IQueue queue = advanced.QueueDeclare(subscriptionId);
foreach (var item in topics)
{
advanced.Bind(exchange, queue, item);
}
advanced.Consume(queue, registration =>
{
registration.Add <T>((message, info) =>
{
work(message.Body);
});
});
}, e =>
{
if (fail != null)
{
fail.Invoke();
}
});
}
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");
}
/// <summary>
/// 메세지 구독
/// </summary>
/// <param name="onMessage">메세지 도착시 실행될 Func</param>
/// <param name="messageConfig">메세지 구독 설정</param>
public IDisposable Subscribe(Func <byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, MessageConfiguration messageConfig)
{
var queue = new Queue(messageConfig.QueueName, false);
return(advancedBus.Consume(queue, onMessage, config => config.WithPrefetchCount(messageConfig.PrefetchCount)));
//return advancedBus.Consume(queue, onMessage);
}
public RabbitMQClient Consume <T>(string queueName, Action <IMessage <T>, MessageReceivedInfo> onMessage) where T : class
{
var queue = _queues[queueName];
_bus.Consume(queue, onMessage);
return(this);
}
private string SubscribeToResponse <TResponse>(Action <TResponse> onResponse)
where TResponse : class
{
var queue = advancedBus.QueueDeclare(
conventions.RpcReturnQueueNamingConvention(),
passive: false,
durable: false,
exclusive: true,
autoDelete: true).SetAsSingleUse();
advancedBus.Consume <TResponse>(queue, (message, messageRecievedInfo) =>
{
var tcs = new TaskCompletionSource <object>();
try
{
onResponse(message.Body);
tcs.SetResult(null);
}
catch (Exception exception)
{
tcs.SetException(exception);
}
return(tcs.Task);
});
return(queue.Name);
}
private void RunListeningBus()
{
_bus.Consume(_bus.QueueDeclare("auth-queue"), register =>
{
register.Add <AuthMessage>(async(message, info) =>
{
try
{
if (message.Body.IsSuccess)
{
_sessionRepo.Update(message.Body.UserId, (session) =>
{
session.State = SessionState.MainMenu;
});
await _telegramBotClient.SendTextMessageAsync(message.Body.ChatId, "Authentication completed \U0001F973", replyMarkup: Keyboards.GetMainMenuKeyboard());
}
}
catch (Exception ex)
{
_logger.LogError($"UserId={message.Body.UserId.ToString()}, ErrorMessage={ex.Message}, StackTrace={ex.StackTrace}");
}
});
});
}
protected void Application_Start()
{
RouteTable.Routes.MapHubs();
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
string connectionString = string.Format(
"host={0};virtualHost={1};username={2};password={3}",
rabbitMQBrokerHost, virtualHost, username, password);
_bus = RabbitHutch.CreateBus(connectionString).Advanced;
var exchange = _bus.ExchangeDeclare("machine", EasyNetQ.Topology.ExchangeType.Fanout);
var queue = _bus.QueueDeclare(
"machine.info",
durable: false,
exclusive: false,
autoDelete: true);
_bus.Bind(exchange, queue, "info");
_hubContext = GlobalHost.ConnectionManager.GetHubContext <MachineHub>();
_bus.Consume <MachineInfo>(queue, (body, info) => Task.Factory.StartNew(() =>
{
var machine = body.Body;
_hubContext.Clients.All.update(machine);
}));
}
public BoxViewModel(string name, IAdvancedBus bus)
{
Box = new Box
{
Name = name,
};
var exchange = bus.ExchangeDeclare("box", EasyNetQ.Topology.ExchangeType.Fanout);
var queue = bus.QueueDeclare(
"update." + Box.Name,
durable: false,
exclusive: true,
autoDelete: true);
bus.Bind(exchange, queue, name);
bus.Consume <Box>(queue, (body, info) => Task.Factory.StartNew(() =>
{
var box = body.Body;
X = box.X;
Y = box.Y;
}));
}
public virtual IDisposable 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 = conventions.QueueNamingConvention(typeof(T), subscriptionId);
var exchangeName = conventions.ExchangeNamingConvention(typeof(T));
var queue = advancedBus.QueueDeclare(queueName, autoDelete: configuration.AutoDelete, expires: configuration.Expires);
var exchange = advancedBus.ExchangeDeclare(exchangeName, ExchangeType.Topic);
foreach (var topic in configuration.Topics.AtLeastOneWithDefault("#"))
{
advancedBus.Bind(exchange, queue, topic);
}
return(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();
}
}));
}
public static void ConsumeTypeAgnostic <T>(this IAdvancedBus @this, IQueue queue, Action <T, MessageReceivedInfo> action) where T : class
{
@this.Consume <object>(queue, (body, properties) => {
var msg = JsonConvert.DeserializeObject <T>(body.Body.ToString());
action(msg, properties);
});
}
public async Task <IDisposable> AddSubscription <TEvent>(string sourceBoundedContextName,
string publishedLanguageEntity)
where TEvent : class
{
var queue = await _messageBus.QueueDeclareAsync(NamingConventions.QueueNamingConvention(_boundedContextName,
sourceBoundedContextName, publishedLanguageEntity, _subscriberId));
await _messageBus.BindAsync(
new Exchange(
NamingConventions.ExchangeNamingConvention(sourceBoundedContextName, publishedLanguageEntity)),
queue, "");
return(_messageBus.Consume(queue, async(bytes, properties, info) =>
{
var msg = Encoding.UTF8.GetString(bytes);
Console.WriteLine(msg);
var validationResult = await _schemaValidator.IsValid <TEvent>(msg);
if (validationResult.IsValid)
{
var envelope = System.Text.Json.JsonSerializer.Deserialize <Envelope <TEvent> >(msg);
var props = new MessageProperties();
properties.CopyTo(props);
await _eventDispatcher.HandleEvent(envelope, props);
}
else
{
throw new Exception($"Schema is invalid, errors: {string.Join(", ", validationResult.Errors)}");
}
}));
}
/// <summary>
/// Consume a stream of messages asynchronously
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="bus">The bus instance</param>
/// <param name="queue">The queue to take messages from</param>
/// <param name="onMessage">The message handler</param>
/// <returns>A disposable to cancel the consumer</returns>
public static IDisposable Consume <T>(
this IAdvancedBus bus, IQueue queue, Func <IMessage <T>, MessageReceivedInfo, Task> onMessage
)
{
Preconditions.CheckNotNull(bus, "bus");
return(bus.Consume(queue, onMessage, c => { }));
}
/// <summary>
/// Consume raw bytes from the queue.
/// </summary>
/// <param name="bus">The bus instance</param>
/// <param name="queue">The queue to subscribe to</param>
/// <param name="onMessage">
/// The message handler. Takes the message body, message properties and some information about the
/// receive context.
/// </param>
/// <returns>A disposable to cancel the consumer</returns>
public static IDisposable Consume(
this IAdvancedBus bus, IQueue queue, Action <byte[], MessageProperties, MessageReceivedInfo> onMessage
)
{
Preconditions.CheckNotNull(bus, "bus");
return(bus.Consume(queue, onMessage, c => { }));
}
protected override IDisposable ConfigureSubscription(IAdvancedBus bus, IQueue queue)
{
return(bus.Consume(
queue,
ConsumerHandler <IProcessingCommand, ProcessingCommandHandler>(),
conf => conf.WithPrefetchCount(1)
));
}
protected virtual string SubscribeToResponse <TRequest, TResponse>()
where TResponse : class
{
var responseType = typeof(TResponse);
var rpcKey = new RpcKey {
Request = typeof(TRequest), Response = responseType
};
if (responseQueues.TryGetValue(rpcKey, out ResponseQueueWithCancellation queueWithCancellation))
{
return(queueWithCancellation.QueueName);
}
lock (responseQueuesAddLock)
{
if (responseQueues.TryGetValue(rpcKey, out queueWithCancellation))
{
return(queueWithCancellation.QueueName);
}
var queue = advancedBus.QueueDeclare(
conventions.RpcReturnQueueNamingConvention(),
passive: false,
durable: false,
exclusive: true,
autoDelete: true);
var exchange = DeclareAndBindRpcExchange(
conventions.RpcResponseExchangeNamingConvention(responseType),
queue,
queue.Name);
var cancellation = 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, new ResponseQueueWithCancellation {
QueueName = queue.Name, Cancellation = cancellation
});
return(queue.Name);
}
}
public void Subscribe <TMessage>(Action <TMessage> handler) where TMessage : class
{
var queue = advancedBus.QueueDeclare();
var exchange = advancedBus.ExchangeDeclare(EXCHANGE_NAME, ExchangeType.Direct);
var binding = advancedBus.Bind(exchange, queue, ROUTING_KEY);
advancedBus.Consume(queue, x => x
.Add <TMessage>((message, info) => handler(message.Body)));
}
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)));
}
/// <inheritdoc />
public void Subscribe(Func <BaseMessage, Task> handler)
{
CheckDisposed();
CheckAndReconnect();
_logger.LogDebug("Try to subscribe to queue with id: {queueId}", _configuration.Id);
_consumer =
_advancedBus.Consume(_queue, (body, messageProperties, info) => handler?.Invoke(body.ConvertToBaseMessage(messageProperties)));
_logger.LogDebug("Done to subscribe to queue with id: {queueId}", _configuration.Id);
}
/// <summary>
/// Consume a stream of messages asynchronously
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="bus">The bus instance</param>
/// <param name="queue">The queue to take messages from</param>
/// <param name="onMessage">The message handler</param>
/// <param name="configure">
/// Fluent configuration e.g. x => x.WithPriority(10)
/// </param>
/// <returns>A disposable to cancel the consumer</returns>
public static IDisposable Consume <T>(
this IAdvancedBus bus,
IQueue queue,
Func <IMessage <T>, MessageReceivedInfo, Task> onMessage,
Action <IConsumerConfiguration> configure
)
{
Preconditions.CheckNotNull(bus, "bus");
return(bus.Consume <T>(queue, (m, i, c) => onMessage(m, i), configure));
}
/// <summary>
/// Consume raw bytes from the queue.
/// </summary>
/// <param name="bus">The bus instance</param>
/// <param name="queue">The queue to subscribe to</param>
/// <param name="onMessage">
/// The message handler. Takes the message body, message properties and some information about the
/// receive context. Returns a Task.
/// </param>
/// <param name="configure">
/// Fluent configuration e.g. x => x.WithPriority(10)
/// </param>
/// <returns>A disposable to cancel the consumer</returns>
public static IDisposable Consume(
this IAdvancedBus bus,
IQueue queue,
Func <byte[], MessageProperties, MessageReceivedInfo, Task <AckStrategy> > onMessage,
Action <IConsumerConfiguration> configure
)
{
Preconditions.CheckNotNull(bus, "bus");
return(bus.Consume(queue, (m, p, i, c) => onMessage(m, p, i), configure));
}
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)));
}
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 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");
}
