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 virtual IDisposable Respond <TRequest, TResponse>(Func <TRequest, Task <TResponse> > responder, Action <IResponderConfiguration> configure) where TRequest : class where TResponse : class
{
Preconditions.CheckNotNull(responder, "responder");
Preconditions.CheckNotNull(configure, "configure");
// We're explicitely validating TResponse here because the type won't be used directly.
// It'll only be used when executing a successful responder, which will silently fail if TResponse serialized length exceeds the limit.
Preconditions.CheckShortString(typeNameSerializer.Serialize(typeof(TResponse)), "TResponse");
var configuration = new ResponderConfiguration(connectionConfiguration.PrefetchCount);
configure(configuration);
var routingKey = conventions.RpcRoutingKeyNamingConvention(typeof(TRequest));
var exchange = advancedBus.ExchangeDeclare(conventions.RpcExchangeNamingConvention(), ExchangeType.Direct);
var queue = advancedBus.QueueDeclare(routingKey, durable: configuration.Durable);
advancedBus.Bind(exchange, queue, routingKey);
return(advancedBus.Consume <TRequest>(queue, (requestMessage, messageRecievedInfo) => ExecuteResponder(responder, requestMessage),
c => c.WithPrefetchCount(configuration.PrefetchCount).WithRecoveryAction(() =>
{
//just in case we loose exchange and/or queue in case of owning cluster node went down, and they are nondurable
var exc = advancedBus.ExchangeDeclare(conventions.RpcExchangeNamingConvention(),
ExchangeType.Direct);
var q = advancedBus.QueueDeclare(routingKey, durable: configuration.Durable);
advancedBus.Bind(exc, q, routingKey);
})));
}
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));
}
private void FuturePublishInternal <T>(TimeSpan messageDelay, T message, string cancellationKey = null) where T : class
{
Preconditions.CheckNotNull(message, "message");
Preconditions.CheckLess(messageDelay, MaxMessageDelay, "messageDelay");
Preconditions.CheckNull(cancellationKey, "cancellationKey");
var exchangeName = conventions.ExchangeNamingConvention(typeof(T));
var futureExchangeName = exchangeName + "_delayed";
var queueName = conventions.QueueNamingConvention(typeof(T), null);
var futureExchange = advancedBus.ExchangeDeclare(futureExchangeName, ExchangeType.Direct, delayed: true);
var exchange = advancedBus.ExchangeDeclare(exchangeName, ExchangeType.Topic);
advancedBus.Bind(futureExchange, exchange, "#");
var queue = advancedBus.QueueDeclare(queueName);
advancedBus.Bind(exchange, queue, "#");
var easyNetQMessage = new Message <T>(message)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(typeof(T)),
Headers = new Dictionary <string, object>{
{ "x-delay", (int)messageDelay.TotalMilliseconds }
}
}
};
advancedBus.Publish(futureExchange, "#", false, false, easyNetQMessage);
}
public void DeclareTopology()
{
var queue = advancedBus.QueueDeclare("my_queue");
var exchange = advancedBus.ExchangeDeclare("my_exchange", ExchangeType.Direct);
advancedBus.Bind(exchange, queue, "routing_key");
}
private void InitialiseExchanges()
{
lock (_locker)
{
_topicExchange = _advancedBus.ExchangeDeclare(Exchanges.Topic, EasyNetQ.Topology.ExchangeType.Topic);
_entitiesUpdatedFanoutExchange = _advancedBus.ExchangeDeclare(Exchanges.ProductEntitiesUpdatedFanout, EasyNetQ.Topology.ExchangeType.Fanout);
}
}
/// <summary>
/// Returns the exchange or creates one if it does not exist
/// </summary>
/// <param name="exchangeName">The exchange name on the form exchange.[to|from].[AMKNAME]</param>
private IExchange GetExchange(string exchangeName)
{
try
{
return(_advancedBus.ExchangeDeclare(exchangeName, ExchangeType.Topic, passive: true));
}
catch (Exception)
{
Console.WriteLine("Exchange not declared, creating...");
return(_advancedBus.ExchangeDeclare(exchangeName, ExchangeType.Topic, durable: true));
}
}
public async Task PublishJobMessage(JobMessage message)
{
var queueExhange = nameof(JobMessage);
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);
}
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); })
);
}
private void FuturePublishInternal <T>(TimeSpan messageDelay, T message, string topic, string cancellationKey) where T : class
{
Preconditions.CheckNotNull(message, "message");
Preconditions.CheckLess(messageDelay, MaxMessageDelay, "messageDelay");
Preconditions.CheckNull(cancellationKey, "cancellationKey");
var delay = Round(messageDelay);
var delayString = delay.ToString(@"dd\_hh\_mm\_ss");
var exchangeName = conventions.ExchangeNamingConvention(typeof(T));
var futureExchangeName = exchangeName + "_" + delayString;
var futureQueueName = conventions.QueueNamingConvention(typeof(T), delayString);
var futureExchange = advancedBus.ExchangeDeclare(futureExchangeName, ExchangeType.Topic);
var futureQueue = advancedBus.QueueDeclare(
futureQueueName,
perQueueMessageTtl: (int)delay.TotalMilliseconds,
deadLetterExchange: exchangeName,
deadLetterRoutingKey: setDeadLetterRoutingKey ? topic : null
);
advancedBus.Bind(futureExchange, futureQueue, topic);
var easyNetQMessage = new Message <T>(message)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(typeof(T))
}
};
advancedBus.Publish(futureExchange, topic, false, easyNetQMessage);
}
/// <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 IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
{
IExchange exchange;
if (exchanges.TryGetValue(exchangeName, out exchange))
{
return(exchange);
}
semaphore.Wait();
try
{
if (exchanges.TryGetValue(exchangeName, out exchange))
{
return(exchange);
}
var param = new ExchangeDeclareParam(exchangeName, exchangeType);
exchange = advancedBus.ExchangeDeclare(param);
exchanges[exchangeName] = exchange;
return(exchange);
}
finally
{
semaphore.Release();
}
}
/// <summary>
/// 发布消息。自定义主题、交换机。EasyNetQ高级API
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="message"></param>
/// <param name="topic"></param>
/// <param name="exchangeName"></param>
/// <returns></returns>
public bool Publish <T>(T message, string topic, string exchangeName) where T : class, IBaseMqMessage
{
bool res = false;
this.Logger(this.GetType(), "发布消息。自定义主题、交换机-Publish", () =>
{
if (message != null)
{
if (!string.IsNullOrEmpty(topic))
{
IAdvancedBus advanced = bus.Advanced;
IExchange exchange = advanced.ExchangeDeclare(exchangeName, ExchangeType.Topic);
advanced.Publish(exchange, topic, false, new Message <T>(message));
}
else
{
bus.Publish(message);
}
res = true;
}
}, e =>
{
res = false;
});
return(res);
}
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 void SetUp()
{
mockBuilder = new MockBuilder();
advancedBus = mockBuilder.Bus.Advanced;
exchange = advancedBus.ExchangeDeclare("my_exchange", ExchangeType.Direct, passive: true);
}
public IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
{
return exchangeNames.AddOrUpdate(
exchangeName,
name => advancedBus.ExchangeDeclare(name, exchangeType),
(_, exchange) => exchange);
}
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;
}));
}
private static void CreateAndBindExchangeAndQueue(this IAdvancedBus advancedBus, string exchangeName, string queueName, string deadLetterExchange)
{
var exchange = advancedBus.ExchangeDeclare(exchangeName, ExchangeType.Topic);
var queue = advancedBus.QueueDeclare(queueName, deadLetterExchange: deadLetterExchange);
advancedBus.Bind(exchange, queue, "#");
}
public RabbitMQClient DeclareExchange(string exchangeName, string type)
{
var exchange = _bus.ExchangeDeclare(exchangeName, type);
_exchanges.Add(exchangeName, exchange);
return(this);
}
public void SetUp()
{
mockBuilder = new MockBuilder();
advancedBus = mockBuilder.Bus.Advanced;
exchange = advancedBus.ExchangeDeclare("my_exchange", ExchangeType.Direct, passive:true);
}
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 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 IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
{
return(exchangeNames.AddOrUpdate(
exchangeName,
name => advancedBus.ExchangeDeclare(name, exchangeType),
(_, exchange) => exchange));
}
public When_an_exchange_is_declared_passively()
{
mockBuilder = new MockBuilder();
advancedBus = mockBuilder.Bus.Advanced;
exchange = advancedBus.ExchangeDeclare("my_exchange", ExchangeType.Direct, passive: true);
}
static void Main(string[] args)
{
try
{
//DateTime stopDate = DateTime.Now.AddSeconds(300);
OrderLog orderLog = new OrderLog();
//orderLog.CreatedById = 1;
//orderLog.CreatedByName = "Hunk";
//orderLog.CreatedDate = DateTime.Now;
//orderLog.LogTypeId = "35";
//orderLog.Remark = "测试队列";
//orderLog.OrderId = 1792631;
string queueConnectionString = "host=192.168.9.24;virtualHost=net;username=netadmin;password=netadmin";
IAdvancedBus ad = MqClientFactory.CreateRabbitMqClient(queueConnectionString).GetAdvancedBus();
var exchange = ad.ExchangeDeclare("TestCreateExchange", EasyNetQ.Topology.ExchangeType.Direct, false);
ad.ExchangeDelete(exchange);
//MqClientFactory.CreateRabbitMqClient(queueConnectionString).SendAsync<OrderLog>("orderLogQueue", orderLog);
Thread.Sleep(30);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.Read();
}
public EventBus()
{
_bus = RabbitHutch.CreateBus("host=rabbit").Advanced;
if (_bus.IsConnected)
{
_exchange = _bus.ExchangeDeclare("exchangeName", "topic");
}
}
private static void InitTestConfig()
{
// 1.交换机
exchange_liugang_test = advancedBus.ExchangeDeclare(exchangeName, x => x.WithType(ExchangeType.Direct));
// 2.队列
queue_liugang_test = advancedBus.QueueDeclare(queueName, x => x.AsDurable(true));
// 3.绑定
advancedBus.Bind(exchange_liugang_test, queue_liugang_test, routingKey);
}
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)));
});
}
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 EasyNetQDirectPublisher()
{
Console.WriteLine("*** Using EasyNetQ Direct Publisher ***");
Console.WriteLine($"***** RabbitMQ Host: {RABBITMQ_HOST}");
Console.WriteLine($"***** Exchange Name: {EXCHANGE_NAME}");
advancedBus = RabbitHutch.CreateBus($"host={RABBITMQ_HOST}").Advanced;
// create a direct exchange
exchange = advancedBus.ExchangeDeclare(EXCHANGE_NAME, ExchangeType.Direct);
}
public void Start()
{
var infExchanger = _bus.ExchangeDeclare(ExchangerNames.InformationResource, ExchangeType.Topic);
var demoExchanger = _bus.ExchangeDeclare(ExchangerNames.DemoPicture, ExchangeType.Topic);
var quickLookExchanger = _bus.ExchangeDeclare(ExchangerNames.QuickLook, ExchangeType.Topic);
_finishedProductsExchange = _bus.ExchangeDeclare(_settings.FinishedProductExchanger, ExchangeType.Fanout);
var queue = _bus.QueueDeclare("CheckProductReadyQueue");
_bus.Bind(infExchanger, queue, "*");
_bus.Bind(demoExchanger, queue, "*");
_bus.Bind(quickLookExchanger, queue, "*");
_bus.Consume(queue, registration => registration
.Add <MessageMetadata>((message, info) => { ConsumeAndProcess(message.Body); })
);
}
public void SetUp()
{
_positionMqServer = new PositionEngineMqServer("PEMQConfig.xml");
_positionMqServer.Connect();
// Initialize Advance Bus
_advancedBus = RabbitHutch.CreateBus("host=localhost").Advanced;
// Create a admin exchange
_adminExchange = _advancedBus.ExchangeDeclare("position_exchange", ExchangeType.Direct, true, false, true);
}
private void InitializeBusConnection()
{
var connectionString = $"host={_eventBusSettings.HostName}; " +
$"virtualHost={_eventBusSettings.VirtualHost}; " +
$"username={_eventBusSettings.UserName}; " +
$"password={_eventBusSettings.Password}";
_bus = RabbitHutch.CreateBus(connectionString).Advanced;
_mainExchange = _bus.ExchangeDeclare(mainExchangeName, ExchangeType.Direct);
}
public void SetUp()
{
mockBuilder = new MockBuilder();
advancedBus = mockBuilder.Bus.Advanced;
mockBuilder.NextModel.Stub(x => x.ExchangeDeclare(null, null, false, false, null))
.IgnoreArguments()
.WhenCalled(x =>
{
arguments = x.Arguments[4] as IDictionary;
});
exchange = advancedBus.ExchangeDeclare(
"my_exchange",
ExchangeType.Direct,
false,
false,
true,
true,
"my.alternate.exchange");
}
public IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
{
IExchange exchange;
if (exchanges.TryGetValue(exchangeName, out exchange))
{
return exchange;
}
semaphore.Wait();
try
{
if (exchanges.TryGetValue(exchangeName, out exchange))
{
return exchange;
}
exchange = advancedBus.ExchangeDeclare(exchangeName, exchangeType);
exchanges[exchangeName] = exchange;
return exchange;
}
finally
{
semaphore.Release();
}
}
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");
}
public static IExchange CreatExchange(IAdvancedBus bus)
{
var environment = new Environment();
var exchange = bus.ExchangeDeclare(environment.GetEnvironmentVariable("ExchangeName"), ExchangeType.Topic);
return exchange;
}
