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; }