public MessagingModule()
{
Get["/send"] = parameters =>
{
return(View["SendMessage.sshtml"]);
};
Get["/send/command/{messagetype}"] = parameters =>
{
//code to send the message on Mass Transit
var queueName = "rabbitmq://localhost/commandqueue";
var bus = ServiceBusFactory.New(configurator =>
{
configurator.UseRabbitMq();
configurator.ReceiveFrom(queueName);
});
bus.Publish(new MakeAnElection
{
AdministratorCode = "admcode",
CompanyCode = "cocode",
ParticipantId = "empnum",
ElectionAmount = 1200,
ElectionReason = "reason",
});
return(View["SendMessage.sshtml"]);
};
}
public void Endpoint_receive_should_select_encrypted_serializer_based_on_content_type()
{
var serializer = new PreSharedKeyEncryptedMessageSerializer(_key, new TSerializer());
var pingMessage = new PingMessage(Guid.NewGuid());
const string self = "loopback://127.0.0.1/self";
using (var bus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(self);
// Ensure outbound message are serialized and encrypted
sbc.SetDefaultSerializer(serializer);
sbc.Subscribe(s => s.Handler <PingMessage>((context, message) => context.Respond(new PongMessage(message.CorrelationId))));
}))
{
var selfEndpoint = bus.GetEndpoint(new Uri(self));
selfEndpoint.ShouldNotBeNull();
try
{
selfEndpoint.SendRequest(pingMessage, bus, x =>
{
x.SetTimeout(TimeSpan.FromSeconds(5));
x.Handle <PongMessage>(pongMsg => pongMsg.CorrelationId.ShouldEqual(pingMessage.CorrelationId));
});
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
}
}
public void Setup()
{
if (_endpointFactoryConfigurator != null)
{
ConfigurationResult result = ConfigurationResultImpl.CompileResults(_endpointFactoryConfigurator.Validate());
try
{
EndpointFactory = _endpointFactoryConfigurator.CreateEndpointFactory();
_endpointCache = new EndpointCache(EndpointFactory);
EndpointCache = new EndpointCacheProxy(_endpointCache);
}
catch (Exception ex)
{
throw new ConfigurationException(result, "An exception was thrown during endpoint cache creation", ex);
}
}
ServiceBusFactory.ConfigureDefaultSettings(x =>
{
x.SetEndpointCache(EndpointCache);
x.SetConcurrentConsumerLimit(4);
x.SetReceiveTimeout(TimeSpan.FromMilliseconds(50));
x.EnableAutoStart();
x.DisablePerformanceCounters();
});
EstablishContext();
}
public override void Load()
{
Bind <ISagaRepository <OrderSaga> >()
.To <InMemorySagaRepository <OrderSaga> >()
.InSingletonScope();
Bind <OrderService>()
.To <OrderService>()
.InSingletonScope();
Bind <IServiceBus>().ToMethod(context =>
{
return(ServiceBusFactory.New(sbc =>
{
sbc.UseMsmq();
sbc.UseMulticastSubscriptionClient();
sbc.ReceiveFrom("msmq://localhost/starbucks_cashier");
sbc.SetConcurrentConsumerLimit(1); //a cashier cannot multi-task
sbc.UseControlBus();
sbc.EnableRemoteIntrospection();
}));
})
.InSingletonScope();
}
public void Setup_quartz_service()
{
ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
_scheduler = schedulerFactory.GetScheduler();
_receivedA = new ManualResetEvent(false);
_bus = ServiceBusFactory.New(x =>
{
x.ReceiveFrom("loopback://localhost/quartz");
x.UseJsonSerializer();
x.Subscribe(s =>
{
s.Handler <A>((msg, context) =>
{
_received = msg;
_receivedA.Set();
});
s.Consumer(() => new ScheduleMessageConsumer(_scheduler));
});
});
_scheduler.JobFactory = new MassTransitJobFactory(_bus);
_scheduler.Start();
}
public Form1()
{
//deviceService = new NetworkDeviceService();
InitializeComponent();
serviceBus = ServiceBusFactory.New(cfg =>
{
cfg.ReceiveFrom("rabbitmq://localhost/cqrs-poc");
cfg.UseRabbitMq(cf =>
{
cf.ConfigureHost(new Uri("rabbitmq://localhost/cqrs-poc"), hc =>
{
hc.SetUsername("petcar");
hc.SetPassword("?!Krone2009");
});
});
});
commandPublisher = new CommandPublisher(serviceBus);
service = new NetworkDeviceService(commandPublisher);
ndvb = new NetworkDeviceViewBuilder();
serviceBus.SubscribeHandler <HandlerNotification>(service.Handle);
//service.ServiceResultRecieved += (sender, result) =>
//{
// var a = result;
//};
service.ServiceResultRecieved += service_ServiceResultRecieved;
GetDevices();
}
public void Setup_quartz_service()
{
ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
_scheduler = schedulerFactory.GetScheduler();
_receivedA = new ManualResetEvent(false);
_receivedIA = new ManualResetEvent(false);
_bus = ServiceBusFactory.New(x =>
{
x.ReceiveFrom("loopback://localhost/quartz");
x.UseXmlSerializer();
x.SetConcurrentConsumerLimit(1);
x.Subscribe(s =>
{
s.Handler <A>(msg => _receivedA.Set());
s.Handler <IA>(msg => _receivedIA.Set());
s.Consumer(() => new ScheduleMessageConsumer(_scheduler));
s.Consumer(() => new CancelScheduledMessageConsumer(_scheduler));
});
});
_scheduler.JobFactory = new MassTransitJobFactory(_bus);
_scheduler.Start();
}
static void Main()
{
Log4NetLogger.Use("customer.log4net.xml");
//IContainer c = BootstrapContainer();
var container = new UnityContainer();
// register types directly
container.RegisterType <OrderDrinkForm>(new ContainerControlledLifetimeManager());
container.RegisterType(typeof(ISagaRepository <>), typeof(InMemorySagaRepository <>), new ContainerControlledLifetimeManager());
// Register the ServiceBus.
container.RegisterInstance <IServiceBus>(ServiceBusFactory.New(sbc =>
{
// Configure exchanges.
sbc.ReceiveFrom("msmq://localhost/starbucks_customer");
sbc.UseMsmq();
sbc.UseMulticastSubscriptionClient();
sbc.UseControlBus();
sbc.Subscribe(subs => { subs.LoadFrom(container); });
}));
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new OrderDrinkForm(container.Resolve <IServiceBus>()));
//Application.Run(new OrderDrinkForm(container.GetInstance<IServiceBus>()));
}
static void Main(string[] args)
{
IServiceBus bus = ServiceBusFactory.New(cfg =>
{
cfg.DisablePerformanceCounters();
cfg.ReceiveFrom("rabbitmq://localhost/qqqq-app");
cfg.UseRabbitMq(cf =>
{
cf.ConfigureHost(new Uri("rabbitmq://localhost/qqqq-app"), hc =>
{
hc.SetUsername("petcar");
hc.SetPassword("?!Krone2009");
});
});
});
EventPublisher publisher = new EventPublisher(bus);
TheCommandHandler handler = new TheCommandHandler(publisher);
bus.SubscribeHandler <AddItemCommand>(handler.Handle);
bus.SubscribeHandler <UpdateItemCommand>(handler.Handle);
bus.SubscribeHandler <DeleteItemCommand>(handler.Handle);
Console.ReadKey();
}
public void StartConsumer()
{
if (_consumerbusBuses != null)
{
return;
}
lock (lockObject)
{
if (_consumerbusBuses != null)
{
return;
}
_consumerbusBuses = new List <IServiceBus>();
var messageTextBus = ServiceBusFactory.New(x =>
{
x.UseRabbitMq();
x.ReceiveFrom("rabbitmq://localhost/poc_message_messageText_queue");
});
messageTextBus.SubscribeConsumer <MessageTextProcessor>();
_consumerbusBuses.Add(messageTextBus);
var timeToProcessBus = ServiceBusFactory.New(x =>
{
x.UseRabbitMq();
x.ReceiveFrom("rabbitmq://localhost/poc_message_timeToProcess_queue");
});
timeToProcessBus.SubscribeConsumer <TimeToProcessConsumer>();
_consumerbusBuses.Add(timeToProcessBus);
}
}
/// <summary>
/// 需要消费Event
/// </summary>
/// <param name="host">服务器ip</param>
/// <param name="queue">Queue名称</param>
/// <param name="concurrentConsumers">消费者数量</param>
/// <param name="configurator">消费者的配置对象</param>
public void SubscribeAt(string host, string queue, int concurrentConsumers, IConsumeConfigurator configurator)
{
var endpoint = string.Format("rabbitmq://{0}/{1}", host, queue);
var rabbitEndpoint = new[] { host };
var consumers = GetQueueConsumers(queue);
var bus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(endpoint);
sbc.UseRabbitMq(
x =>
{
x.UseRoundRobinConnectionPolicy(rabbitEndpoint);
x.PersistMessages(true);
}
);
sbc.SetConcurrentConsumerLimit(concurrentConsumers);
sbc.Subscribe(x => configurator.Configure(x, consumers));
});
//var publisher = new EventPublisher(bus);
//_reg.Inject<IEventPublisher>(publisher);
// 记录消费者服务总线对象
var consumerBus = new EventConsumerBus(bus);
_reg.Inject <IEventConsumerBus>(consumerBus);
}
public void Execute(IContainer container)
{
log4net.Config.XmlConfigurator.Configure();
container.Configure(x =>
{
x.Scan(scanner =>
{
scanner.AssembliesFromApplicationBaseDirectory(assembly => assembly.GetName().Name.StartsWith("Example"));
scanner.AddAllTypesOf(typeof(IStartup));
scanner.AddAllTypesOf(typeof(IConsumer));
scanner.SingleImplementationsOfInterface();
scanner.WithDefaultConventions();
});
x.For <ILog>().Use(LogManager.GetLogger(typeof(StartupTask)));
});
foreach (var task in container.GetAllInstances <IStartup>())
{
task.Execute(container);
}
// must be done out of the normal configuration due to the dependence on the
// scan for consumers having been completed.
container.Inject(typeof(IServiceBus),
ServiceBusFactory.New(sbc =>
{
sbc.UseRabbitMq();
sbc.UseControlBus();
sbc.ReceiveFrom(ConfigurationManager.AppSettings["WebDenormalizerMessageQueue"]);
sbc.Subscribe(subs => subs.LoadFrom(container));
}));
}
protected override void ConfigureApplicationContainer(ILifetimeScope container)
{
base.ConfigureApplicationContainer(container);
var builder = new ContainerBuilder();
builder.RegisterType <AppSettings>().As <IAppSettings>().SingleInstance();
builder.RegisterType <DummyMailChimpWebhooks>().As <IMailChimpWebhooks>().SingleInstance();
builder.RegisterType <DummyMailgunWebhooks>().As <IMailgunWebhooks>().SingleInstance();
builder.RegisterType <AzureTableStorageTodoService>().As <ITodoService>().SingleInstance();
// Consumers and sagas
builder.RegisterAssemblyTypes(typeof(Bootstrapper).Assembly)
.Where(t => t.Implements <ISaga>() ||
t.Implements <IConsumer>())
.AsSelf();
// Saga repositories
builder.RegisterGeneric(typeof(InMemorySagaRepository <>))
.As(typeof(ISagaRepository <>))
.SingleInstance();
// Service bus
builder.Register(c => ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom("loopback://localhost/queue");
sbc.Subscribe(x => x.LoadFrom(container));
})).As <IServiceBus>().SingleInstance();
builder.Update(container.ComponentRegistry);
}
public IServiceBus Start(ITransportConfigurator transportConfigurator)
{
OnStarting();
try
{
_log.InfoFormat("{0} Starting Service Bus for Queue: {1}({2})", GetType().GetServiceDescription(), _queueName, _consumerLimit);
IServiceBus bus = ServiceBusFactory.New(x =>
{
transportConfigurator.Configure(x, _queueName, _consumerLimit);
x.Subscribe(s =>
{
foreach (SubscriptionBusServiceBuilderConfigurator builderConfigurator in _configurators)
{
s.AddConfigurator(builderConfigurator);
}
});
});
OnStarted(bus);
_bus = bus;
return(bus);
}
catch (Exception ex)
{
OnStartFailed(ex);
throw;
}
}
public TimeoutServiceRegistry(IContainer container)
{
var configuration = container.GetInstance <IConfiguration>();
For <ISessionFactory>()
.Singleton()
.Use(context => CreateSessionFactory());
For(typeof(ISagaRepository <>))
.Add(typeof(NHibernateSagaRepository <>));
For <IServiceBus>()
.Singleton()
.Use(context =>
{
return(ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(configuration.TimeoutServiceDataUri);
sbc.UseControlBus();
sbc.UseLog4Net();
sbc.UseMsmq(x => x.UseSubscriptionService(configuration.SubscriptionServiceUri));
sbc.SetConcurrentConsumerLimit(1);
if (configuration.HealthServiceEnabled)
{
sbc.UseHealthMonitoring(10);
}
}));
});
}
static void Main(string[] args)
{
var builder = new ContainerBuilder();
// register each consumer manually
builder.RegisterType <PickConsumer>().AsSelf();
//or use Autofac's scanning capabilities -- SomeClass is any class in the correct assembly
//builder.RegisterAssemblyTypes(typeof(PickConsumer).Assembly)
// .Where(t => t.Implements<IConsumer>())
// .AsSelf();
//now we add the bus
builder.Register(c => ServiceBusFactory.New(sbc =>
{
sbc.UseRabbitMq();
sbc.ReceiveFrom(BusInitializer.GetUri("PickService"));
//this will find all of the consumers in the container and
//register them with the bus.
sbc.Subscribe(x => x.LoadFrom(c.Resolve <ILifetimeScope>()));
})).As <IServiceBus>().SingleInstance().AutoActivate();
builder.Build();
Console.WriteLine("Waiting..");
Console.ReadKey();
}
public void ActivityTestFixtureFixtureTeardown()
{
foreach (ActivityTestContext activityTestContext in ActivityTestContexts.Values)
{
activityTestContext.Dispose();
}
LocalBus.Dispose();
if (_cancellationTokenSource != null)
{
_cancellationTokenSource.Dispose();
}
if (_timer != null)
{
_timer.Dispose();
}
_endpointCache.Clear();
if (EndpointCache != null)
{
EndpointCache.Dispose();
EndpointCache = null;
}
ServiceBusFactory.ConfigureDefaultSettings(x => { x.SetEndpointCache(null); });
}
public void Should_support_the_username_password_for_a_host()
{
var inputAddress = new Uri("rabbitmq://localhost/mt/test_queue");
var future = new Future <IConsumeContext <A> >();
using (IServiceBus bus = ServiceBusFactory.New(c =>
{
c.ReceiveFrom(inputAddress);
c.UseRabbitMq(r =>
{
r.ConfigureHost(inputAddress, h =>
{
h.SetUsername("testUser");
h.SetPassword("test");
});
});
c.Subscribe(s => s.Handler <A>((context, message) => future.Complete(context)));
}))
{
bus.Publish(new A());
Assert.IsTrue(future.WaitUntilCompleted(TimeSpan.FromSeconds(8)));
}
Assert.AreEqual(inputAddress.ToString(), future.Value.SourceAddress.ToString());
}
private static IContainer BootstrapContainer(TransportSettings transportSettings, string appNameBase)
{
ObjectFactory.Initialize(cfg =>
{
cfg.AddRegistry <CentralMonRegistry>();
cfg.For <TransportSettings>().Singleton().Use(transportSettings);
cfg.For <IServiceBus>().Use(context => ServiceBusFactory.New(sbc =>
{
string rcvQueueUri = transportSettings.GetQueueUri(appNameBase);
sbc.ReceiveFrom(rcvQueueUri);
transportSettings.ApplyGlobalConfig(sbc);
sbc.UseControlBus();
sbc.Subscribe(sub =>
{
sub.LoadFrom(ObjectFactory.Container);
});
}));
});
var container = ObjectFactory.Container;
CentralMonRegistry.Build(container);
return(container);
}
public void an_interface_based_message_is_published()
{
_receivedAnyRat = new Future <TMesg>();
var details = new AccountDetails();
_publisherBus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(details.BuildUri("When_publishing_ordinary_interfaces_publisher"));
sbc.SetPurgeOnStartup(true);
sbc.UseAzureServiceBus();
sbc.UseAzureServiceBusRouting();
});
_subscriberBus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(details.BuildUri("When_publishing_ordinary_interfaces_subscriber"));
sbc.SetPurgeOnStartup(true);
sbc.Subscribe(s => s.Handler <TMesg>(_receivedAnyRat.Complete).Transient());
sbc.UseAzureServiceBus();
sbc.UseAzureServiceBusRouting();
});
// wait for the inbound transport to become ready before publishing
_subscriberBus.Endpoint.InboundTransport.Receive(c1 => c2 => { }, 1.Milliseconds());
_publisherBus.Publish <TMesg>(new
{
SoundsLike = "peep"
});
_receivedAnyRat.WaitUntilCompleted(35.Seconds()).ShouldBeTrue();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddLogging(loggingBuilder => loggingBuilder
.AddConsole()
.SetMinimumLevel(LogLevel.Debug));
services.AddDbContext<SeasonParticipantsDb>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddMvc(x => x.EnableEndpointRouting = false)
.SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddCors();
services.AddSwaggerDocument();
services.Configure<BusSettings>(Configuration.GetSection("ServiceBus"));
services.AddTransient<Func<string, IBusClient>>(serviceProvider => key =>
{
switch (key)
{
case "NewClubSeason":
return ServiceBusFactory.GetBus(Enum.Parse<BusHost>(Configuration.GetSection("ServiceBus")["ServiceBusHost"]),
Configuration.GetSection("ServiceBus")["ServiceBusConnectionString"],
Configuration.GetSection("ServiceBus")["NewClubSeasonAssociationTopicName"],
Configuration.GetSection("ServiceBus")["NewClubSeasonAssociationSubscriptionName"]);
case "NewSeason":
return ServiceBusFactory.GetBus(Enum.Parse<BusHost>(Configuration.GetSection("ServiceBus")["ServiceBusHost"]),
Configuration.GetSection("ServiceBus")["ServiceBusConnectionString"],
Configuration.GetSection("ServiceBus")["NewSeasonTopicName"],
Configuration.GetSection("ServiceBus")["NewSeasonSubscriptionName"]);
default:
throw new InvalidOperationException("Specified bus type does not exist!");
}
});
}
public void an_interface_based_message_is_published()
{
_receivedAnyRat = new Future <CorrelatedSwedishRat>();
var details = new AccountDetails();
_publisherBus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(details.BuildUri("When_publishing_correlated_interface_publisher"));
sbc.SetPurgeOnStartup(true);
sbc.UseAzureServiceBus();
sbc.UseAzureServiceBusRouting();
});
_subscriberBus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(details.BuildUri("When_publishing_correlated_interface_subscriber"));
sbc.SetPurgeOnStartup(true);
sbc.Subscribe(s => s.Handler <CorrelatedSwedishRat>(_receivedAnyRat.Complete).Transient());
sbc.UseAzureServiceBus();
sbc.UseAzureServiceBusRouting();
});
// wait for the inbound transport to become ready before publishing
_subscriberBus.Endpoint.InboundTransport.Receive(c1 => c2 => { }, 1.Milliseconds());
correlationId = CombGuid.Generate();
_publisherBus.Publish <CorrelatedSwedishRat>(new CorrImpl(correlationId, "meek"));
_receivedAnyRat.WaitUntilCompleted(15.Seconds()).ShouldBeTrue();
}
static void Main()
{
//IContainer c = BootstrapContainer();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
NodeContext nc = null;
NodeRecord rec = new NodeRecord();
string host = "localhost";
bool tryConnect = false;
var connectForm = new ConnectForm();
connectForm.FormClosing += (s, ea) =>
{
try
{
rec.NodeId = connectForm.NodeId;
rec.OrgNodeId = -1;
rec.QueueBaseName = connectForm.AppName;
rec.QueueTransportSettings = TransportSettings.UseRabbitMq(connectForm.Host);
host = connectForm.Host;
tryConnect = true;
}
catch (Exception ex)
{
ea.Cancel = true;
MessageBox.Show(connectForm, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
};
Application.Run(connectForm);
if (connectForm.DialogResult != DialogResult.Cancel && tryConnect)
{
connectForm = null;
var bus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(rec.QueueUri);
sbc.UseControlBus();
rec.QueueTransportSettings.ApplyGlobalConfig(sbc);
});
// We got a node context, yay.
// Launch a service which takes care of traffix, and provide some
// means for the ClientForm to xommunixate with that service:
var clientForm = new ClientForm(rec, bus);
//LaunchMessageService(nc, svc =>
//{
Application.Run(clientForm);
nc.Dispose();
//});
}
}
public SubscriptionServiceRegistry(IContainer container)
{
var configuration = container.GetInstance <IConfiguration>();
For <ISessionFactory>()
.Singleton()
.Use(context => CreateSessionFactory());
For(typeof(ISagaRepository <>))
.Add(typeof(NHibernateSagaRepository <>));
For <IServiceBus>()
.Singleton()
.Use(context =>
{
return(ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(configuration.SubscriptionServiceUri);
sbc.UseMsmq();
sbc.SetConcurrentConsumerLimit(1);
}));
});
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
// in proc bus
//var bus = new InProcessBus(container);
//container.Register(Component.For<IBus>().Instance(bus));
// for factory
if (!container.Kernel.GetFacilities()
.Any(x => x.GetType().Equals(typeof(TypedFactoryFacility))))
{
container.AddFacility <TypedFactoryFacility>();
}
// masstransit bus
//var busAdapter = new MassTransitPublisher(bus);
container.Register(
Component.For <IServiceBus>()
.UsingFactoryMethod(() => ServiceBusFactory.New(sbc =>
{
sbc.UseRabbitMq();
sbc.ReceiveFrom(_EndpointUri);
sbc.UseRabbitMqRouting();
sbc.Subscribe(c => c.LoadFrom(container));
})).LifeStyle.Singleton,
Component.For <IBus>()
.UsingFactoryMethod((k, c) =>
new MassTransitPublisher(k.Resolve <IServiceBus>()))
.Forward <IDispatchCommits>()
.LifeStyle.Singleton);
}
protected override void Load(ContainerBuilder builder)
{
// Register all consumers in this assembly
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.Where(t => t.Implements <IConsumer>())
.AsSelf();
builder.Register(c => ServiceBusFactory.New
(
sbc =>
{
sbc.UseMsmq(x =>
{
x.VerifyMsmqConfiguration();
x.UseMulticastSubscriptionClient();
});
sbc.ReceiveFrom(c.Resolve <IApplicationSettings>().MailSenderMessageQueueAddress);
// This will find all of the consumers in the container and register them with the bus.
// Resolve<ILifeTimeScope> is used to get all registrations from the container, the loadfrom method filters out all IConsumers and ISaga's
// Loadfrom is an extension method for autofac implemented in masstransit (Separate package: MassTransit.Autofac)
sbc.Subscribe(x => x.LoadFrom(c.Resolve <ILifetimeScope>()));
}
)
)
.As <IServiceBus>()
.SingleInstance();
}
public void Should_publish_to_non_transactional_queue()
{
using (IServiceBus transactionalBus = ServiceBusFactory.New(x =>
{
x.UseMsmq();
x.ReceiveFrom(_transactionalUri);
x.UseMulticastSubscriptionClient();
x.SetCreateMissingQueues(true);
x.SetCreateTransactionalQueues(true);
}))
{
using (IServiceBus nonTransactionalBus = ServiceBusFactory.New(x =>
{
x.UseMsmq();
x.ReceiveFrom(_nonTransactionalUri);
x.UseMulticastSubscriptionClient();
x.SetCreateMissingQueues(true);
x.SetCreateTransactionalQueues(false);
}))
{
var future = new Future <MyMessage>();
nonTransactionalBus.SubscribeHandler <MyMessage>(future.Complete);
transactionalBus.ShouldHaveSubscriptionFor <MyMessage>();
transactionalBus.Publish(new MyMessage(),
ctx => ctx.IfNoSubscribers(() => { throw new Exception("NoSubscribers"); }));
future.WaitUntilCompleted(8.Seconds()).ShouldBeTrue("The published message was not received>");
}
}
}
public void OnlyReceiverShouldReceiveCommands()
{
const string receiverGuid = "af486b11-0fad-4f5a-98d3-7308ec925708";
var receiverId = new Guid(receiverGuid);
using (var serviceBus = ServiceBusFactory.New(bus =>
{
bus.ReceiveFrom(Config.CommandPublisherAddress);
bus.UseRabbitMq();
}))
using (var handler1 = new TestCommandHandler(new Uri(Config.CommandHandlerAddress1), receiverId, "TestCommandHandler1", 5))
using (var handler2 = new TestCommandHandler(new Uri(Config.CommandHandlerAddress2), "TestCommandHandler2", 1))
{
serviceBus.SendTo(new TestCommand(), receiverId);
serviceBus.SendTo(new TestCommand(), receiverId);
serviceBus.SendTo(new TestCommand(), receiverId);
serviceBus.SendTo(new TestCommand(), receiverId);
serviceBus.SendTo(new TestCommand(), receiverId);
handler1.CommandReceived.WaitUntilCompleted(7.Seconds());
Assert.IsTrue(handler1.CommandReceived.IsCompleted && !handler2.CommandReceived.IsCompleted);
}
}
private void Initialize(Action <IServiceBusConfigurator> busConfigureAction)
{
_publishSettings.Validate();
if (_publishSettings.UsePublisherConfirms)
{
Action <IServiceBusConfigurator> publisherConfirmConfigureAction =
configurator =>
{
busConfigureAction(configurator);
configurator.UsePublisherConfirms(_publishSettings);
};
_serviceBus = ServiceBusFactory.New(publisherConfirmConfigureAction);
}
else
{
_serviceBus = ServiceBusFactory.New(busConfigureAction);
}
_confirmer = _publishSettings.Confirmer;
_messageRepository = UnconfirmedMessageRepositoryFactory.Create(_publishSettings);
_confirmer.PublicationFailed += OnPublicationFailed;
_confirmer.PublicationSucceeded += OnPublicationSucceeded;
_lastMessageBufferStoreTimestamp = DateTime.UtcNow.Ticks;
_lastPublishRetryTimestamp = DateTime.UtcNow.Ticks;
_checkOfflineTasksTimer = new Timer(CheckOfflineTasks, null, _publishSettings.TimerCheckInterval, _publishSettings.TimerCheckInterval);
}
public MessageSubscription[] GetMessageSubscriptions(ServerConfig3 server)
{
IViewSubscriptions sc = null;
if (server.ServiceBus == _mgr.ServiceBusName &&
server.ServiceBusVersion == _mgr.ServiceBusVersion &&
server.ServiceBusQueueType == _mgr.MessageQueueType)
{
sc = _mgr as IViewSubscriptions;
}
else
{
var mgr = ServiceBusFactory.CreateManager(server.ServiceBus, server.ServiceBusVersion, server.ServiceBusQueueType);
sc = mgr as IViewSubscriptions;
}
if (sc != null)
{
return(sc.GetMessageSubscriptions(server.ConnectionSettings, server.MonitorQueues.Select(q => q.Name)));
}
else
{
return(new MessageSubscription[0]);
}
}