public IControlBus Build() { ServiceBus bus = CreateServiceBus(_settings.EndpointCache); try { ConfigureBusSettings(bus); RunPostCreateActions(bus); ConfigureMessageInterceptors(bus); RunBusServiceConfigurators(bus); if (_settings.AutoStart) { bus.Start(); } return(bus); } catch { try { bus.Dispose(); } catch (Exception ex) { _log.Error("Exception disposing of failed bus instance", ex); } throw; } }
static void Main(string[] args) { var serviceBus = ServiceBus.Setup( new InitializationRequest { Namespace = "YOUR NAMESPACE", Issuer = "YOR ISSUER", IssuerKey = "YOUR KEY" }) .ClearTopics() .Subscribe <SimpleMessage>(HandleSimpleMessage, ReceiveMode.ReceiveAndDelete); Console.Write("Message: "); var message = Console.ReadLine(); while (!string.IsNullOrEmpty(message)) { serviceBus.Publish <SimpleMessage>(new SimpleMessage { Title = message, Id = Guid.NewGuid() }); Console.Write("Message:"); message = Console.ReadLine(); } }
/// <summary> /// Initialization routine /// </summary> /// <param name="action">action</param> /// <returns>initialization task</returns> private async Task Initialize(Action action) { // load the environment configuration file from UtilsInternal var sr = new FileSettingsReader(ConfigurationManager.AppSettings["ConfigRelativePath"] + Path.DirectorySeparatorChar + environmentName + ".config"); var certThumbprint = sr.ReadValue(SocialPlusCertThumbprint); var clientID = sr.ReadValue(EmbeddedSocialClientIdSetting); var storeLocation = StoreLocation.CurrentUser; var vaultUrl = sr.ReadValue(SocialPlusVaultUrlSetting); ICertificateHelper cert = new CertificateHelper(certThumbprint, clientID, storeLocation); IKeyVaultClient client = new AzureKeyVaultClient(cert); var log = new Log(LogDestination.Console, Log.DefaultCategoryName); var kv = new KV(log, clientID, vaultUrl, certThumbprint, storeLocation, client); var kvReader = new KVSettingsReader(sr, kv); IConnectionStringProvider connectionStringProvider = new ConnectionStringProvider(kvReader); int queueBatchIntervalMs = int.Parse(sr.ReadValue(ServiceBusBatchIntervalMsSetting)); QueueManager queueManager = new QueueManager(connectionStringProvider, queueBatchIntervalMs); var sbConnect = await connectionStringProvider.GetServiceBusConnectionString(ServiceBusInstanceType.Default); // the ListQueues action requires an instance of a ServiceBus object if (action == Action.ListQueues) { this.sb = new ServiceBus(sbConnect); } // all the remaining actions operate on an instance of a ServiceBusQueue object if (action != Action.ListQueues) { // ParseArgs() ensures that queueName is valid here this.sbQueue = await ServiceBusQueue.Create(sbConnect, queueName, queueBatchIntervalMs); this.selectedQueue = await queueManager.GetQueue((QueueIdentifier)selectedQueueId); } }
private static void Main() { Log.Assign(new Log4NetLog(LogManager.GetLogger(typeof(Program)))); var bus = ServiceBus .Create() .AddCompressionAlgorithm(new GZipCompressionAlgorithm()) .AddEnryptionAlgorithm(new TripleDesEncryptionAlgorithm()) .Start(); Console.WriteLine("Client bus started. Press CTRL+C to stop."); Console.WriteLine(); Console.WriteLine("Press enter to send a message with random text to the server for reversal."); Console.WriteLine(); while (true) { Console.ReadLine(); var command = new ReverseTextCommand { Text = Guid.NewGuid().ToString().Substring(0, 5) }; bus.OutgoingCorrelationId = "correlation-id"; bus.OutgoingHeaders.Add(new TransportHeader { Key = "header1", Value = "value1" }); bus.OutgoingHeaders.Add(new TransportHeader { Key = "header2", Value = "value2" }); Console.WriteLine("Message (id: {0}) sent. Text: {1}", bus.Send(command).MessageId, command.Text); } }
static void Main(string[] args) { var bus = new ServiceBus(); Console.WriteLine("Informe o Id da Barragem:"); var idBarragem = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("Informe o intervalo de envio de dados:"); var tempoIntervaloSensoresSeg = Convert.ToInt32(Console.ReadLine()); while (true) { var info = SensorInfo.GenerateRandom(); var evento = new SensorInfoAlteradoEvent() { BarragemId = idBarragem, HorarioMedicao = DateTime.Now, Pressao = info.Pressao, Temperatura = info.Temperatura, Volume = info.Volume }; bus.PublicarEvento <SensorInfoAlteradoEvent>(evento); Console.WriteLine(info.ToString()); System.Threading.Thread.Sleep(tempoIntervaloSensoresSeg * 1000); } }
private static void Main(string[] args) { var brokerUri = Environment.GetEnvironmentVariable("ACTIVEMQ_BROKER_URI") ?? "tcp://localhost:61616"; var serviceName = Environment.GetEnvironmentVariable("OBVS_SERVICE_NAME") ?? "Service1"; Console.WriteLine($"Starting {serviceName}, connecting to broker {brokerUri}"); var serviceBus = ServiceBus.Configure() .WithActiveMQEndpoints <IServiceMessage1>() .Named(serviceName) .UsingQueueFor <ICommand>() .ConnectToBroker(brokerUri) .WithCredentials("TESTUSER", "testpassword1") .SerializedAsJson() .AsClient() .CreateClient(); serviceBus.Events.Subscribe(c => Console.WriteLine("Received an event!")); Console.WriteLine("Hit <Enter> to send a command."); while (true) { string data = Console.ReadLine(); serviceBus.SendAsync(new Command1 { Data = data }); } }
public void VerifyMessageTypesMappedEntit() { IEnumerable <MessageTypeMessagingEntityMappingDetails> configuredMessageTypePathMappings = null; _mockMessagingEntityVerifier.Setup(mev => mev.EnsureMessagingEntitiesExist(It.IsAny <IEnumerable <MessageTypeMessagingEntityMappingDetails> >())) .Callback <IEnumerable <MessageTypeMessagingEntityMappingDetails> >(mtpm => configuredMessageTypePathMappings = mtpm); ServiceBus.Configure() .WithAzureServiceBusEndpoint <TestMessage>() .Named("Test Service Bus") .WithMessagingFactory(_mockMessagingFactory.Object) .WithMessagingEntityVerifier(_mockMessagingEntityVerifier.Object) .UsingQueueFor <ICommand>("commands", MessagingEntityCreationOptions.VerifyAlreadyExists) .UsingQueueFor <IRequest>("requests", MessagingEntityCreationOptions.VerifyAlreadyExists) .UsingQueueFor <IResponse>("responses", MessagingEntityCreationOptions.VerifyAlreadyExists) .UsingTopicFor <IEvent>("events", MessagingEntityCreationOptions.VerifyAlreadyExists) .UsingSubscriptionFor <IEvent>("events", "my-event-subscription", MessagingEntityCreationOptions.VerifyAlreadyExists) .SerializedWith(_mockMessageSerializer.Object, _mockMessageDeserializerFactory.Object) .FilterMessageTypeAssemblies(assembly => assembly.GetName().Name == "Obvs.AzureServiceBus.Tests") .AsClientAndServer() .CreateServiceBus(); _mockMessagingEntityVerifier.Verify(mev => mev.EnsureMessagingEntitiesExist(It.IsAny <IEnumerable <MessageTypeMessagingEntityMappingDetails> >()), Times.Once()); configuredMessageTypePathMappings.Should().NotBeNull(); configuredMessageTypePathMappings.Should().BeEquivalentTo(new [] { new MessageTypeMessagingEntityMappingDetails(typeof(ICommand), "commands", MessagingEntityType.Queue, MessagingEntityCreationOptions.VerifyAlreadyExists, MessageReceiveMode.PeekLock), new MessageTypeMessagingEntityMappingDetails(typeof(IRequest), "requests", MessagingEntityType.Queue, MessagingEntityCreationOptions.VerifyAlreadyExists, MessageReceiveMode.PeekLock), new MessageTypeMessagingEntityMappingDetails(typeof(IResponse), "responses", MessagingEntityType.Queue, MessagingEntityCreationOptions.VerifyAlreadyExists, MessageReceiveMode.PeekLock), new MessageTypeMessagingEntityMappingDetails(typeof(IEvent), "events", MessagingEntityType.Topic, MessagingEntityCreationOptions.VerifyAlreadyExists, MessageReceiveMode.PeekLock), new MessageTypeMessagingEntityMappingDetails(typeof(IEvent), "events/subscriptions/my-event-subscription", MessagingEntityType.Subscription, MessagingEntityCreationOptions.VerifyAlreadyExists, MessageReceiveMode.PeekLock), }); }
private async Task <Domain.Order> EntryAggregate(Guid entryId) { return(await ServiceBus.Send(new Domain.OrderByIdQuery { Id = entryId })); }
public void MakeFundIn(Guid playerId, Guid destinationWalletStructureId, decimal amount, string bonusCode = null, Guid?bonusId = null) { if (bonusId.HasValue || string.IsNullOrWhiteSpace(bonusCode) == false) { BonusCommands.ApplyForBonus(new FundInBonusApplication { PlayerId = playerId, BonusId = bonusId, BonusCode = bonusCode, Amount = amount, DestinationWalletTemplateId = destinationWalletStructureId }); } ServiceBus.PublishMessage(new TransferFundCreated { PlayerId = playerId, DestinationWalletStructureId = destinationWalletStructureId, Amount = amount, BonusCode = bonusCode, Type = TransferFundType.FundIn, Status = TransferFundStatus.Approved }); // Here we need somehow create an event to mimic a wallet fund-in }
public void ShouldOnlySubscribeToUnderlyingEndpointCommandsOnce() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IObservable<ICommand> observable1 = A.Fake<IObservable<ICommand>>(); IObservable<ICommand> observable2 = A.Fake<IObservable<ICommand>>(); IObserver<ICommand> observer1 = A.Fake<IObserver<ICommand>>(); IObserver<ICommand> observer2 = A.Fake<IObserver<ICommand>>(); A.CallTo(() => serviceEndpoint1.Commands).Returns(observable1); A.CallTo(() => serviceEndpoint2.Commands).Returns(observable2); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2 }, new[] { serviceEndpoint1, serviceEndpoint2 }); IDisposable sub1 = serviceBus.Commands.Subscribe(observer1); IDisposable sub2 = serviceBus.Commands.Subscribe(observer2); A.CallTo(() => serviceEndpoint1.Commands).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpoint2.Commands).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observable1.Subscribe(A<IObserver<ICommand>>._)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observable2.Subscribe(A<IObserver<ICommand>>._)).MustHaveHappened(Repeated.Exactly.Once); sub1.Dispose(); sub2.Dispose(); }
public static async Task Handler( [ServiceBusTrigger("agroqueue", Connection = "ServiceBusConnectionString", IsSessionsEnabled = true)] Message message, [SignalR(HubName = "AsyncConnection")] IAsyncCollector <SignalRMessage> signalRMessages, ILogger log) { var opInstance = ServiceBus.Deserialize(message.Body); var ObjectIdAAD = opInstance.Value <string>("ObjectIdAAD"); var queries = new CommonQueries(ConfigManager.GetDbArguments); var userId = await queries.GetUserIdFromAAD(ObjectIdAAD); var EntityName = opInstance.Value <string>("EntityName"); var agro = await ContainerMethods.AgroManager(ObjectIdAAD, false); var entityType = opInstance["EntityType"].ToObject <Type>(); var repo = agro.GetOperationByInputType(entityType); dynamic element = opInstance["Element"].ToObject(entityType); element.Id = opInstance.Value <string>("Id"); try { var saveReturn = await repo.SaveInput(element, false); await agro.UserActivity.SaveInput(new UserActivityInput { Action = opInstance.Value <string>("HttpMethod").Equals("post") ? UserActivityAction.CREATE : UserActivityAction.MODIFY, Date = DateTime.Now, EntityName = EntityName, EntityId = saveReturn.IdRelated }, false); await signalRMessages.AddAsync(new SignalRMessage { Target = "Success", UserId = userId, Arguments = new object[] { EntityName } }); } catch (Exception ex) { log.LogError(ex, ex.Message); await signalRMessages.AddAsync(new SignalRMessage { Target = "Error", UserId = userId, Arguments = new object[] { ex is Validation_Exception ? ((Validation_Exception)ex).ErrorMessages : (object)new string[] { $"{ex.Message}" } } }); } }
private static void Main(string[] args) { var container = new SimpleInjectorComponentContainer(new Container()); ServiceBus.Register(container); var transportMessageFactory = container.Resolve <ITransportMessageFactory>(); using (var bus = ServiceBus.Create(container).Start()) { string userName; while (!string.IsNullOrEmpty(userName = Console.ReadLine())) { var command = new RegisterMemberCommand { UserName = userName }; var transportMessage = transportMessageFactory.Create(command, c => { }); for (var i = 0; i < 5; i++) { bus.Dispatch(transportMessage); // will be processed once since message id is the same } bus.Send(command); // will be processed since it has a new message id bus.Send(command); // will also be processed since it too has a new message id } } }
private Task StartWatcher(int i, int count) { IServiceBus serviceBus = ServiceBus.Configure() .WithKafkaEndpoints <ITestMessage1>() .Named("Obvs.TestService") .ConnectToKafka(_kafkaAddresses) .SerializedAsJson() .AsServer() //.UsingConsoleLogging() .Create(); double?[] times = new double?[count]; long[] received = { 0 }; var dis = serviceBus.Commands.OfType <TestCommand>().Subscribe(x => { Interlocked.Increment(ref received[0]); var ms = (Stopwatch.GetTimestamp() - x.Ticks) / ((double)Stopwatch.Frequency / 1000); times[x.Id] = ms; }); return(Task.Run(() => { SpinWait.SpinUntil(() => Interlocked.Read(ref received[0]) == count); Console.WriteLine($"******* Watcher {i}: Total {_sw.ElapsedMilliseconds}ms ({count} msgs), Min/Avg/Max (ms) = {times.Min(d=>d.Value):0}/{times.Average(d => d.Value):0}/{times.Max(d => d.Value):0}"); dis.Dispose(); ((IDisposable)serviceBus).Dispose(); })); }
internal UserStoreWrapper(Uri evernoteUri, string consumerKey, string consumerSecret, ServiceBus servicebus) : base(new Uri(evernoteUri, "/edam/user")) { this.consumerKey = consumerKey; this.consumerSecret = consumerSecret; this.servicebus = servicebus; }
private async Task SendCommands(int count) { IServiceBus serviceBus = ServiceBus.Configure() .WithKafkaEndpoints <ITestMessage1>() .Named("Obvs.TestService") .WithKafkaSourceConfiguration(new KafkaSourceConfiguration()) .WithKafkaProducerConfiguration(new KafkaProducerConfiguration()) .ConnectToKafka(_kafkaAddresses) .SerializedAsJson() .AsClient() //.UsingConsoleLogging() .Create(); Stopwatch sw = Stopwatch.StartNew(); var sendTasks = Enumerable.Range(0, count) .Select(i => serviceBus.SendAsync(new TestCommand { Id = i })); await Task.WhenAll(sendTasks); _sw = Stopwatch.StartNew(); Console.WriteLine($"###$$$$### Sends: {sw.ElapsedMilliseconds}ms"); ((IDisposable)serviceBus).Dispose(); }
public void Start() { Log.Assign(new Log4NetLog(LogManager.GetLogger(typeof(Host)))); _container = new WindsorContainer(); var container = new WindsorComponentContainer(_container); container.RegisterSuffixed("Shuttle.ProcessManagement"); ServiceBus.Register(container); var subscriptionManager = container.Resolve <ISubscriptionManager>(); subscriptionManager.Subscribe <OrderProcessRegisteredEvent>(); subscriptionManager.Subscribe <OrderProcessCancelledEvent>(); subscriptionManager.Subscribe <OrderProcessAcceptedEvent>(); subscriptionManager.Subscribe <OrderProcessCompletedEvent>(); subscriptionManager.Subscribe <OrderProcessArchivedEvent>(); subscriptionManager.Subscribe <OrderCreatedEvent>(); subscriptionManager.Subscribe <CancelOrderProcessRejectedEvent>(); subscriptionManager.Subscribe <ArchiveOrderProcessRejectedEvent>(); subscriptionManager.Subscribe <InvoiceCreatedEvent>(); subscriptionManager.Subscribe <EMailSentEvent>(); _bus = ServiceBus.Create(container).Start(); }
public MonitoredNode(string nodeId, Uri incoming, IDocumentStore store) { Policies.Local.Add <ErrorHandlingPolicy>(); AlterSettings <MonitoringSettings>(x => x.Incoming = "memory://jobs".ToUri()); Channel(x => x.Incoming).ReadIncoming(); NodeName = "Monitoring"; NodeId = nodeId; _nodeId = nodeId; ServiceBus.EnableInMemoryTransport(incoming); Services.ReplaceService(store); Services.AddService <ILogListener, ScheduledJobListener>(); ScheduledJob.DefaultJobChannel(x => x.Incoming); ScheduledJob.RunJob <AlwaysGoodJob>().ScheduledBy <TenMinuteIncrements>(); ScheduledJob.RunJob <FailsFirstTwoTimes>().ScheduledBy <SevenMinuteIncrements>(); ScheduledJob.RunJob <FailsSometimes>().ScheduledBy <FiveMinuteIncrements>(); ScheduledJob.RunJob <TimesOutSometimes>().ScheduledBy <ThreeMinuteIncrements>().Timeout(10.Seconds()); }
static void Main(string[] args) { using (var bus = ServiceBus.Create().Start()) { string userName; while (!string.IsNullOrEmpty(userName = Console.ReadLine())) { var command = new RegisterMemberCommand { UserName = userName }; var transportMessage = bus.CreateTransportMessage(command, null); for (var i = 0; i < 5; i++) { bus.Dispatch(transportMessage); // will be processed once since message id is the same } bus.Send(command); // will be processed since it has a new message id bus.Send(command); // will also be processed since it also has a new message id } } }
public void Should_be_able_to_handle_expired_message() { var handlerInvoker = new FakeMessageHandlerInvoker(); var fakeQueue = new FakeQueue(2); var configuration = new ServiceBusConfiguration { Inbox = new InboxQueueConfiguration { WorkQueue = fakeQueue, ErrorQueue = fakeQueue, ThreadCount = 1 }, MessageHandlerInvoker = handlerInvoker }; using (var bus = new ServiceBus(configuration)) { bus.Start(); var timeout = DateTime.Now.AddMilliseconds(5000); while (fakeQueue.MessageCount < 2 && DateTime.Now < timeout) { Thread.Sleep(5); } } Assert.AreEqual(1, handlerInvoker.GetInvokeCount("SimpleCommand"), "FakeHandlerInvoker was not invoked exactly once."); Assert.AreEqual(2, fakeQueue.MessageCount, "FakeQueue was not invoked exactly twice."); }
protected void TestInboxError(string queueSchemeAndHost, bool useJournal, bool isTransactional) { var configuration = GetTestInboxConfiguration(queueSchemeAndHost, useJournal, 1, isTransactional); using (var bus = new ServiceBus(configuration)) { var message = bus.CreateTransportMessage(new NoHandlerCommand()); configuration.Inbox.WorkQueue.Enqueue(message.MessageId, configuration.Serializer.Serialize(message)); var working = true; bus.Events.ThreadWaiting += (sender, args) => { working = false; }; bus.Start(); while (working) { Thread.Sleep(5); } } Assert.NotNull(configuration.Inbox.ErrorQueue.Dequeue()); AttemptDropQueues(queueSchemeAndHost, useJournal); }
public async Task StartAsync(CancellationToken cancellationToken) { // delay startup to let broker start first var delay = TimeSpan.FromSeconds(10); Console.WriteLine($"Starting in {delay}"); await Task.Delay(delay, cancellationToken); // get env variables _brokerUri = Environment.GetEnvironmentVariable("ACTIVEMQ_BROKER_URI") ?? "tcp://localhost:61616"; _serviceName = Environment.GetEnvironmentVariable("OBVS_SERVICE_NAME") ?? "MyService"; Console.WriteLine($"Starting {_serviceName}, connecting to broker {_brokerUri}"); // create singleton ServiceBus var serviceBus = ServiceBus.Configure() .WithActiveMQEndpoints <IServiceMessage1>() // you can use different transports for each service .Named(_serviceName) // used to prefix AMQ topic names .UsingQueueFor <ICommand>() // optional, default is topic .ConnectToBroker(_brokerUri) .WithCredentials("admin", "admin") .SerializedAsJson() // you can use different serialization formats for each service .AsServer() // will subscribe to commands and requests, and publish events and responses .UsingConsoleLogging() // optional logging extensions available .Create(); // subscribe to commands and publish events _subscription = serviceBus.Commands.OfType <Command1>().Subscribe(async cmd => { await serviceBus.PublishAsync(new Event1 { Data = cmd.Data }); }); }
protected void TestInboxDeferred(string queueSchemeAndHost) { var configuration = GetTestInboxConfiguration(queueSchemeAndHost, false, 1, false); var messageId = Guid.Empty; var messageType = typeof(ReceivePipelineCommand).FullName; using (var bus = new ServiceBus(configuration)) { var id = messageId; var type = messageType; var waiting = true; bus.Events.AfterTransportMessageDeserialization += (sender, eventArgs) => { Assert.True(id.Equals(eventArgs.TransportMessage.MessageId)); Assert.True(type.Equals(eventArgs.TransportMessage.MessageType, StringComparison.OrdinalIgnoreCase)); waiting = false; }; bus.Events.ThreadWaiting += (sender, args) => { waiting = false; }; bus.Start(); messageId = bus.SendDeferred(DateTime.Now.AddMilliseconds(500), new ReceivePipelineCommand(), configuration.Inbox.WorkQueue).MessageId; while (waiting) { Thread.Sleep(5); } } }
public Guid SubmitDeposit(Guid playerId, decimal depositAmount = 200, string bonusCode = null, Guid?bonusId = null) { var depositId = Guid.NewGuid(); ServiceBus.PublishMessage(new DepositSubmitted { DepositId = depositId, PlayerId = playerId, Amount = depositAmount }); if (bonusId.HasValue || string.IsNullOrWhiteSpace(bonusCode) == false) { BonusCommands.ApplyForBonus(new DepositBonusApplication { PlayerId = playerId, BonusId = bonusId, BonusCode = bonusCode, Amount = depositAmount, DepositId = depositId }); } return(depositId); }
public void Start() { DbProviderFactories.RegisterFactory("System.Data.SqlClient", SqlClientFactory.Instance); Log.Assign(new Log4NetLog(LogManager.GetLogger(typeof(Host)))); _container = new WindsorContainer(); var container = new WindsorComponentContainer(_container); container.RegisterSuffixed("Shuttle.Abacus"); EventStore.Register(container); ServiceBus.Register(container); container.Register <ArgumentHandler>(); container.Register <FormulaHandler>(); container.Register <MatrixHandler>(); container.Register <TestHandler>(); _eventProcessor = container.Resolve <IEventProcessor>(); _eventProcessor.AddProjection(new Projection("Argument").AddEventHandler(container.Resolve <ArgumentHandler>())); _eventProcessor.AddProjection(new Projection("Formula").AddEventHandler(container.Resolve <FormulaHandler>())); _eventProcessor.AddProjection(new Projection("Matrix").AddEventHandler(container.Resolve <MatrixHandler>())); _eventProcessor.AddProjection(new Projection("Test").AddEventHandler(container.Resolve <TestHandler>())); container.Resolve <IDatabaseContextFactory>().ConfigureWith("Abacus"); _bus = ServiceBus.Create(container).Start(); _eventProcessor.Start(); }
public void Start() { Log.Assign(new Log4NetLog(LogManager.GetLogger(typeof(Host)))); _container = new WindsorContainer(); _container.RegisterDataAccessCore(); _container.RegisterDataAccess("Shuttle.ProcessManagement"); var subscriptionManager = SubscriptionManager.Default(); subscriptionManager.Subscribe <OrderProcessRegisteredEvent>(); subscriptionManager.Subscribe <OrderProcessCancelledEvent>(); subscriptionManager.Subscribe <OrderProcessAcceptedEvent>(); subscriptionManager.Subscribe <OrderProcessCompletedEvent>(); subscriptionManager.Subscribe <OrderProcessArchivedEvent>(); subscriptionManager.Subscribe <OrderCreatedEvent>(); subscriptionManager.Subscribe <CancelOrderProcessRejectedEvent>(); subscriptionManager.Subscribe <ArchiveOrderProcessRejectedEvent>(); subscriptionManager.Subscribe <InvoiceCreatedEvent>(); subscriptionManager.Subscribe <EMailSentEvent>(); _bus = ServiceBus.Create( c => { c .MessageHandlerFactory(new CastleMessageHandlerFactory(_container)) .SubscriptionManager(subscriptionManager); }).Start(); }
public virtual void Start() { // init logging Log.Assign(new ConsoleLog(typeof(ShuttleESBHost)) { LogLevel = LogLevel.Trace }); // init depedency injection container InitializeContainer(); // init message handler factory var messageHandlerFactory = InitializeMessageHandlerFactory(); // init subscription manager var subscriptionManager = InitializeSubscriptionManager(); // init message serializer var messageSerializer = InitializeMessageSerializer(); // init compression algorithm var compressionAlgorithm = InitializeCompressionAlgorithm(); // init encryption algorithm var encryptionAlgorithm = InitializeEncryptionAlgorithm(); // start service bus Bus = ServiceBus .Create(c => { if (subscriptionManager != null) { c.SubscriptionManager(subscriptionManager); } if (messageHandlerFactory != null) { c.MessageHandlerFactory(messageHandlerFactory); } if (messageSerializer != null) { c.MessageSerializer(messageSerializer); } if (compressionAlgorithm != null) { c.AddCompressionAlgorithm(compressionAlgorithm); } if (encryptionAlgorithm != null) { c.AddEnryptionAlgorithm(encryptionAlgorithm); } }); Contract.Assume(Bus != null); Bus.Start(); }
public IServiceProvider ConfigureServices(IServiceCollection services) { services.AddMvc(); services.AddCors(); var container = new WindsorContainer(); var componentContainer = new WindsorComponentContainer(container); componentContainer.RegisterInstance <IAccessConfiguration>(AccessSection.Configuration()); componentContainer.RegisterSuffixed("Shuttle.Sentinel"); componentContainer.RegisterSuffixed("Shuttle.Access.Sql"); componentContainer.Register <IInspectionQueue, DefaultInspectionQueue>(); componentContainer.Register <IHttpContextAccessor, HttpContextAccessor>(); componentContainer.Register <IDatabaseContextCache, ContextDatabaseContextCache>(); ServiceBus.Register(componentContainer); EventStore.Register(componentContainer); componentContainer.Resolve <IDataStoreDatabaseContextFactory>().ConfigureWith("Sentinel"); componentContainer.Resolve <IDatabaseContextFactory>().ConfigureWith("Sentinel"); var inspectionQueue = componentContainer.Resolve <IInspectionQueue>(); _bus = ServiceBus.Create(componentContainer).Start(); return(WindsorRegistrationHelper.CreateServiceProvider(container, services)); }
private static async Task StartService(string host, int port) { //服务信息 var serviceInfo = new ServiceInformation() { Host = host, Port = port, Description = "我的小服务, 老火了", Key = "Foo.Services", Name = "我的小服务", ServiceType = ServiceType.Grpc, }; //启动服务 Server service = new Server { Services = { Greeter.BindService(new GreeterImpl()) }, Ports = { new ServerPort(serviceInfo.Host, port, ServerCredentials.Insecure) } }; service.Start(); using (IZookeeperClient zon = await ServiceBus.Register(serviceInfo)) { Console.WriteLine("Greeter server listening on port " + port); Console.WriteLine("Press any key to stop the server..."); Console.ReadKey(); service.ShutdownAsync().Wait(); } }
public async Task ServiceBus_PublishIntegrationEventsAsyncPersistsChangesToContext() { var @event = new FakeIntegrationEvent("Fake Value"); var options = SetupContext(); using (var context = new InfrastructureContext(options)) { var mockSerializer = new Mock <IMessageSerializer>(); var sut = new ServiceBus( Mock.Of <IMessageSerializer>(), Mock.Of <IHttpContextAccessor>(), Mock.Of <IQueueClient>(), Mock.Of <ITopicClient>(), Mock.Of <ILogger>(), context); await sut.PublishEventsAsync(@event); } using (var context = new InfrastructureContext(options)) { var eventEntity = await context.IntegrationEvents.FindAsync(@event.MessageId); Assert.NotNull(eventEntity); Assert.Equal(@event.MessageId, eventEntity.Id); } }
public override async Task <SpeechletResponse> HandleIntentAsync(IntentRequest intentRequest, Session session) { if (intentRequest.DialogState == IntentRequest.DialogStateEnum.STARTED || intentRequest.DialogState == IntentRequest.DialogStateEnum.IN_PROGRESS) { return(new SpeechletResponse { Directives = new List <Directive> { new DialogDelegateDirective() { UpdatedIntent = intentRequest?.Intent } } }); } var result = String.Empty; var intent = intentRequest?.Intent; var command = intent.Name; var argument = String.Empty; switch (intent.Name) { case GitIntents.Status: return(BuildSpeechletResponse("Okay", "The file changes dot txt has been modified.", true)); case GitIntents.Add: result = "All changes have been staged."; break; case GitIntents.Commit: intent.Slots.TryGetValue(GitSlots.CommitMessage, out Slot slot); argument = slot?.Value; result = "I committed your changes."; break; case GitIntents.Pull: result = "Upstream branches have been pulled."; break; case GitIntents.Push: intent.Slots.TryGetValue(GitSlots.RemoteBranch, out Slot branchSlot); intent.Slots.TryGetValue(GitSlots.RemoteRepository, out Slot repositorySlot); argument = repositorySlot?.Value + " " + branchSlot?.Value; result = $"I successfully pushed your changes to {repositorySlot?.Value} {branchSlot?.Value}."; break; } var commandDto = new Command { CommandText = command.ToLower(), Argument = argument }; var serviceBus = new ServiceBus(ServiceBusQueues.GitQueue); await serviceBus.SendMessage(JsonConvert.SerializeObject(commandDto)); return(BuildSpeechletResponse("Okay", result, true)); }
public void Start() { Log.Assign(new Log4NetLog(LogManager.GetLogger(typeof(Host)))); _container = new WindsorContainer(); _container.RegisterDataAccessCore(); _container.RegisterDataAccess("Shuttle.ProcessManagement"); _container.Register(Component.For <IEventStore>().ImplementedBy <EventStore>()); _container.Register(Component.For <IKeyStore>().ImplementedBy <KeyStore>()); _container.Register(Component.For <ISerializer>().ImplementedBy <DefaultSerializer>()); _container.Register(Component.For <IEventStoreQueryFactory>().ImplementedBy <EventStoreQueryFactory>()); _container.Register(Component.For <IKeyStoreQueryFactory>().ImplementedBy <KeyStoreQueryFactory>()); var subscriptionManager = SubscriptionManager.Default(); subscriptionManager.Subscribe <OrderCreatedEvent>(); subscriptionManager.Subscribe <InvoiceCreatedEvent>(); subscriptionManager.Subscribe <EMailSentEvent>(); var processConfiguration = ProcessSection.Configuration(); ((DefaultProcessActivator)processConfiguration.ProcessActivator).RegisterMappings(); _bus = ServiceBus.Create( c => { c.MessageHandlerFactory(new CastleMessageHandlerFactory(_container)); c.SubscriptionManager(subscriptionManager); c.AddModule(new ProcessModule(_container.Resolve <IDatabaseContextFactory>(), _container.Resolve <IEventStore>(), _container.Resolve <IKeyStore>(), processConfiguration)); }).Start(); }
static void Main(string[] args) { var bus = ServiceBus.Run(c => c .SetServiceLocator(AppDomainUnityServiceLocator.Current) .MsmqTransport() .SetInputQueue("PSB.App2.Input") .SetErrorQueue("PSB.App2.Error") .AddEndpoint("Shared.ClientMessages", "PSB.App1.Input") .Dispatcher(d => d .AddHandlers(typeof(Program).Assembly) ) ); Console.WriteLine("Server started. Press enter to send message"); while (true) { Console.ReadKey(); var message = new SayHelloToClientMessage() { Message = "Hello Client!" }; bus.Send(message); } }
private void InitializeServiceBus() { var serviceBus = new ServiceBus(); serviceBus.Subscribe<MarketStateChangeRequest>( changeRequest => StockMarket.MarketState = changeRequest.NewState); ServiceBus = serviceBus; }
static void Main(string[] args) { var bus = new ServiceBus("test_queue"); bus.Start(); string textMessage; while (!String.IsNullOrWhiteSpace((textMessage = Console.ReadLine()))) { var message = new TestMessage { Id = Guid.NewGuid(), Timestamp = DateTime.Now, Message = textMessage }; bus.Publish(message); } }
static void Main(string[] args) { using (var bus = new ServiceBus("test_queue")) { bus.RegisterReplyGenerator<TestMessage>(m => new TestReply(m.Id)); bus.MessageHandlers.Add<TestMessage>(m => Console.WriteLine("{0} : {1}", m.Timestamp, m.Message)); bus.Start(); while (!Console.KeyAvailable) { Thread.Sleep(1); } } }
static void Main() { var bus = new ServiceBus { LocalEndpoint = "minibuss_publisher1" }; bus.HandleSubscriptionsFor<SomethingHappenedEvent>(); bus.Start(); Task.Factory.StartNew(() => PublishingThread(bus), TaskCreationOptions.LongRunning); Console.WriteLine("Working, press ENTER to exit"); Console.ReadLine(); }
/// <summary> /// create this factory. all parameters are mandatory. /// </summary> /// <param name="evernoteUri">evernote base url, like http://sandbox.evernote.com/</param> /// <param name="consumerKey">your personal consumer key that you got from Evernote</param> /// <param name="consumerSecret">your secret key that you got from Evernote</param> public StoreFactory(Uri evernoteUri, string consumerKey, string consumerSecret) { ParamCheck.NotNull("evernoteUri", evernoteUri); ParamCheck.NullNorEmpty("consumerKey", consumerKey); ParamCheck.NullNorEmpty("consumerSecret", consumerSecret); this.evernoteUri = evernoteUri; this.consumerKey = consumerKey; this.consumerSecret = consumerSecret; this.servicebus = new ServiceBus(); //we are interested in auth event this.servicebus.AddSubscriber<AuthenticationEvent>(authenticationEventHandler); }
protected override void Before_each() { _builder = MockRepository.GenerateMock<IObjectBuilder>(); _builder.Stub(x => x.GetInstance<XmlMessageSerializer>()).Return(new XmlMessageSerializer()); _endpointResolver = EndpointFactoryConfigurator.New(x => { x.SetObjectBuilder(_builder); x.RegisterTransport<LoopbackEndpoint>(); }); _mockEndpoint = _endpointResolver.GetEndpoint(queueUri); _subscription = new Subscription(typeof (PingMessage), queueUri); _serviceBus = new ServiceBus(_mockEndpoint, _builder, _endpointResolver); }
private static void StartSubscriber(string queueName) { using (var bus = new ServiceBus(queueName)) { bus.Start(); bus.SubscribeTo<TestMessage>(publisherEndpoint, TestMessageHandler); while (!_tokenSource.Token.IsCancellationRequested) { Thread.Sleep(1); } bus.Unsubscribe<TestMessage>(publisherEndpoint); } }
static void Main(string[] args) { using (var bus = new ServiceBus("my_test_queue")) { bus.MessageHandlers.Add<TestReply>(r => Console.WriteLine("Got reply to: {0}, Sent on second: {1}", r.ReplyTo, r.SecondSent)); bus.TargetEndpoints.SetFor<TestMessage>(new BusEndpoint(".", "test_queue")); bus.Start(); var textMessage = Console.ReadLine(); while (!String.IsNullOrWhiteSpace(textMessage)) { bus.Send(new SpecialTestMessage { Id = Guid.NewGuid(), Timestamp = DateTime.Now, Message = textMessage, SpecialnessFactor = 3 }); textMessage = Console.ReadLine(); } } }
static void Main() { var bus = new ServiceBus { LocalEndpoint = "minibuss_receiver1" }; bus.RegisterMessageHandler<HelloCommand>(command => { Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine(command.Message + " Guid: " + command.Guid + ", Number: " + command.Number); bus.Reply(command, new HelloResponse { Guid = Guid.NewGuid(), Message = "Hello back!" }); }); bus.Start(); Console.WriteLine("Waiting for commands, press ENTER to exit"); Console.ReadLine(); }
private void InitService() { ServiceBus bus = new ServiceBus(); EventStore eventStore = new EventStore(bus); var repository = new Repository<InventoryItem>(eventStore); var commands = new CommandHandler<InventoryItem>(repository); bus.RegisterHandler<CreateInventoryItem>(commands.Create); bus.RegisterHandler<DeleteInventoryItem>(commands.Delete); var detail = new InventoryItemCreatedHandle(); bus.RegisterHandler<InventoryItemCreated>(detail.Create); bus.RegisterHandler<ItemsDeletedFromInventory>(detail.Delete); bus.RegisterHandler<InventoryItemRenamed>(detail.Update); ServiceLocator.Bus = bus; }
private static void StartListener(int listenerId) { var token = _tokenSource.Token; if(token.IsCancellationRequested) return; using (var bus = new ServiceBus("test_queue")) { bus.MessageHandlers.Add<TestMessage>(m => Console.WriteLine(String.Format("Listener {0} received \"{1}\"", listenerId, m.Message))); bus.Start(); while (!token.IsCancellationRequested) { Thread.Sleep(1); } } }
static void Main() { var bus = new ServiceBus { LocalEndpoint = "minibuss_sender1" }; bus.RegisterMessageEndpoint<HelloCommand>("minibuss_receiver1@localhost"); bus.RegisterMessageHandler<HelloResponse>(reply => { Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("Reply from receiver: " + reply.Message); }); bus.Start(); //start bus if expecting replies Task.Factory.StartNew(() => SendThread(bus), TaskCreationOptions.LongRunning); Console.WriteLine("Working, press ENTER to exit"); Console.ReadLine(); }
public void SimpleTest() { var unity = new UnityContainer(); var tracker = new Tracker(); unity.RegisterInstance(tracker); var config = new Configuration(unity) .SetInputQueue("PSB.App1.Input1") .SetErrorQueue("PSB.App1.Error") .AddEndpoint("Paralect.ServiceBus.Test.Messages", "PSB.App2.Input1"); var bus = new ServiceBus(config); bus.Run(); var config2 = new Configuration(unity) .SetInputQueue("PSB.App2.Input1") .SetErrorQueue("PSB.App2.Error") .AddEndpoint("Paralect.ServiceBus.Test.Messages", "PSB.App1.Input1") .AddHandlers(Assembly.GetExecutingAssembly()) .AddInterceptor(typeof(FirstInterceptor)) .AddInterceptor(typeof(SecondInterceptor)); var bus2 = new ServiceBus(config2); bus2.Run(); var msg = new SimpleMessage3 { Id = Guid.NewGuid(), Text = "From dddbfdfdgfgusd! Muaha!" }; bus.Send(msg); Thread.Sleep(3000); Assert.AreEqual(1, tracker.Handlers.Count); Assert.AreEqual(2, tracker.Interceptors.Count); Assert.AreEqual(typeof(SimpleMessage3), tracker.Handlers[0]); Assert.AreEqual(typeof(FirstInterceptor), tracker.Interceptors[0]); Assert.AreEqual(typeof(SecondInterceptor), tracker.Interceptors[1]); }
public void Test() { Parallel.For(0, 15, (i, state) => { var unity = new UnityContainer(); var tracker = new Tracker(); unity.RegisterInstance(tracker); var config = new Configuration(unity) .SetName("PS " + i) .SetInputQueue("PSB.App1.Input") .SetErrorQueue("PSB.App1.Error") .AddEndpoint("Paralect.ServiceBus.Test.Messages", "PSB.App2.Input"); using (var bus = new ServiceBus(config)) { bus.Run(); Thread.Sleep(10); } }); }
public void ShouldSendCommandsToCorrectEndpoints() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient3 = A.Fake<IServiceEndpointClient>(); ICommand command1 = A.Fake<ICommand>(); ICommand command2 = A.Fake<ICommand>(); ICommand command3 = A.Fake<ICommand>(); A.CallTo(() => serviceEndpointClient1.CanHandle(A<ICommand>._)).Returns(true); A.CallTo(() => serviceEndpointClient2.CanHandle(A<ICommand>._)).Returns(false); A.CallTo(() => serviceEndpointClient3.CanHandle(A<ICommand>._)).Returns(true); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2, serviceEndpointClient3 }, new[] { serviceEndpoint1, serviceEndpoint2 }); serviceBus.SendAsync(command1); A.CallTo(() => serviceEndpointClient1.SendAsync(command1)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpointClient2.SendAsync(command1)).MustNotHaveHappened(); A.CallTo(() => serviceEndpointClient3.SendAsync(command1)).MustHaveHappened(Repeated.Exactly.Once); serviceBus.SendAsync(new[]{command2, command3}); A.CallTo(() => serviceEndpointClient1.SendAsync(command2)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpointClient2.SendAsync(command2)).MustNotHaveHappened(); A.CallTo(() => serviceEndpointClient3.SendAsync(command2)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpointClient1.SendAsync(command3)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpointClient2.SendAsync(command3)).MustNotHaveHappened(); A.CallTo(() => serviceEndpointClient3.SendAsync(command3)).MustHaveHappened(Repeated.Exactly.Once); }
public void ShouldSendRequestsToCorrectEndpoints() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient3 = A.Fake<IServiceEndpointClient>(); IRequest request = A.Fake<IRequest>(); A.CallTo(() => serviceEndpointClient1.CanHandle(request)).Returns(true); A.CallTo(() => serviceEndpointClient2.CanHandle(request)).Returns(false); A.CallTo(() => serviceEndpointClient3.CanHandle(request)).Returns(true); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2, serviceEndpointClient3 }, new[] { serviceEndpoint1, serviceEndpoint2 }); IDisposable sub1 = serviceBus.GetResponses(request).Subscribe(A.Fake<IObserver<IResponse>>()); A.CallTo(() => serviceEndpointClient1.GetResponses(request)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpointClient2.GetResponses(request)).MustNotHaveHappened(); A.CallTo(() => serviceEndpointClient3.GetResponses(request)).MustHaveHappened(Repeated.Exactly.Once); IDisposable sub2 = serviceBus.GetResponses<IResponse>(request).Subscribe(A.Fake<IObserver<IResponse>>()); A.CallTo(() => serviceEndpointClient1.GetResponses(request)).MustHaveHappened(Repeated.Exactly.Twice); A.CallTo(() => serviceEndpointClient2.GetResponses(request)).MustNotHaveHappened(); A.CallTo(() => serviceEndpointClient3.GetResponses(request)).MustHaveHappened(Repeated.Exactly.Twice); sub1.Dispose(); sub2.Dispose(); }
public void ShouldSetRequestIdsOnRequestsWhenUsingDefaultRequestCorrelationProvider() { const string requestId = "MyOwnRequestId"; IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IObservable<IResponse> observable1 = A.Fake<IObservable<IResponse>>(); IObservable<IResponse> observable2 = A.Fake<IObservable<IResponse>>(); IObserver<IResponse> observer1 = A.Fake<IObserver<IResponse>>(); IObserver<IResponse> observer2 = A.Fake<IObserver<IResponse>>(); IRequest request1 = A.Fake<IRequest>(); IRequest request2 = A.Fake<IRequest>(); request2.RequestId = requestId; A.CallTo(() => serviceEndpointClient1.CanHandle(request1)).Returns(true); A.CallTo(() => serviceEndpointClient2.CanHandle(request2)).Returns(true); A.CallTo(() => serviceEndpointClient1.GetResponses(request1)).Returns(observable1); A.CallTo(() => serviceEndpointClient2.GetResponses(request2)).Returns(observable2); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2 }, new[] { serviceEndpoint1, serviceEndpoint2 }); IObservable<IResponse> responses1 = serviceBus.GetResponses(request1); IObservable<IResponse> responses2 = serviceBus.GetResponses(request2); IDisposable sub1 = responses1.Subscribe(observer1); IDisposable sub2 = responses2.Subscribe(observer2); Assert.That(!string.IsNullOrEmpty(request1.RequestId), "RequestId not set on request"); Assert.That(!string.IsNullOrEmpty(request1.RequesterId), "RequesterId not set on request"); Assert.That(request2.RequestId, Is.EqualTo(requestId), "Custom RequestId was overriden"); Assert.That(!string.IsNullOrEmpty(request2.RequesterId), "RequesterId not set on request"); Assert.That(request1.RequesterId, Is.EqualTo(request2.RequesterId), "RequesterId should the same on both requests"); sub1.Dispose(); sub2.Dispose(); }
public void ShouldPublishEventsToCorrectEndpoints() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint3 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IEvent ev = A.Fake<IEvent>(); A.CallTo(() => serviceEndpoint1.CanHandle(ev)).Returns(true); A.CallTo(() => serviceEndpoint2.CanHandle(ev)).Returns(false); A.CallTo(() => serviceEndpoint3.CanHandle(ev)).Returns(true); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2 }, new[] { serviceEndpoint1, serviceEndpoint2, serviceEndpoint3 }); serviceBus.PublishAsync(ev); A.CallTo(() => serviceEndpoint1.PublishAsync(ev)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpoint2.PublishAsync(ev)).MustNotHaveHappened(); A.CallTo(() => serviceEndpoint3.PublishAsync(ev)).MustHaveHappened(Repeated.Exactly.Once); }
internal NoteStoreWrapper(Uri evernoteUri, string authToken, string shardId, ServiceBus servicebus) : base(new Uri(evernoteUri, "/edam/note/" + shardId)) { this.authToken = authToken; servicebus.AddSubscriber<AuthenticationEvent>(this.authenticationHandler); }
public void ShouldDisposeEndpointsWhenDisposed() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2 }, new[] { serviceEndpoint1, serviceEndpoint2 }); ((IDisposable)serviceBus).Dispose(); A.CallTo(() => serviceEndpoint1.Dispose()).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpoint2.Dispose()).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpointClient1.Dispose()).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpointClient2.Dispose()).MustHaveHappened(Repeated.Exactly.Once); }
public void ShouldDisposeUnderlyingRequestSubscriptionOnlyWhenAllSubscriptionsDisposed() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IObservable<IRequest> observable1 = A.Fake<IObservable<IRequest>>(); IObservable<IRequest> observable2 = A.Fake<IObservable<IRequest>>(); IObserver<IRequest> observer1 = A.Fake<IObserver<IRequest>>(); IObserver<IRequest> observer2 = A.Fake<IObserver<IRequest>>(); A.CallTo(() => serviceEndpoint1.Requests).Returns(observable1); A.CallTo(() => serviceEndpoint2.Requests).Returns(observable2); IObserver<IRequest> requestSource1 = null; IObserver<IRequest> requestSource2 = null; A.CallTo(() => observable1.Subscribe(A<IObserver<IRequest>>._)).Invokes(call => requestSource1 = call.GetArgument<IObserver<IRequest>>(0)); A.CallTo(() => observable2.Subscribe(A<IObserver<IRequest>>._)).Invokes(call => requestSource2 = call.GetArgument<IObserver<IRequest>>(0)); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2 }, new[] { serviceEndpoint1, serviceEndpoint2 }); IDisposable requestSub1 = serviceBus.Requests.Subscribe(observer1); IDisposable requestSub2 = serviceBus.Requests.Subscribe(observer2); Assert.That(requestSource1, Is.Not.Null); Assert.That(requestSource2, Is.Not.Null); IRequest request = A.Fake<IRequest>(); requestSource1.OnNext(request); A.CallTo(() => observer1.OnNext(request)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observer2.OnNext(request)).MustHaveHappened(Repeated.Exactly.Once); // dispose of first subscriptions requestSub1.Dispose(); // second subscription should still be active requestSource1.OnNext(request); A.CallTo(() => observer1.OnNext(request)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observer2.OnNext(request)).MustHaveHappened(Repeated.Exactly.Twice); // dispose of second subscriptions requestSub2.Dispose(); // no subscriptions should be active requestSource1.OnNext(request); A.CallTo(() => observer1.OnNext(request)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observer2.OnNext(request)).MustHaveHappened(Repeated.Exactly.Twice); }
public void ShouldHandleUnderlyingRequestSubscriptionErrorsOnTheExceptionChannel() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IObservable<IRequest> observable1 = A.Fake<IObservable<IRequest>>(); IObservable<IRequest> observable2 = A.Fake<IObservable<IRequest>>(); IObserver<IRequest> observer1 = A.Fake<IObserver<IRequest>>(); IObserver<IRequest> observer2 = A.Fake<IObserver<IRequest>>(); IObserver<Exception> observer3 = A.Fake<IObserver<Exception>>(); A.CallTo(() => serviceEndpoint1.Requests).Returns(observable1); A.CallTo(() => serviceEndpoint2.Requests).Returns(observable2); IObserver<IRequest> requestSource1 = null; IObserver<IRequest> requestSource2 = null; A.CallTo(() => observable1.Subscribe(A<IObserver<IRequest>>._)).Invokes(call => requestSource1 = call.GetArgument<IObserver<IRequest>>(0)); A.CallTo(() => observable2.Subscribe(A<IObserver<IRequest>>._)).Invokes(call => requestSource2 = call.GetArgument<IObserver<IRequest>>(0)); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2 }, new[] { serviceEndpoint1, serviceEndpoint2 }); IDisposable eventSub1 = serviceBus.Requests.Subscribe(observer1); IDisposable eventSub2 = serviceBus.Requests.Subscribe(observer2); IDisposable exceptionSub = serviceBus.Exceptions.Subscribe(observer3); Assert.That(requestSource1, Is.Not.Null); Assert.That(requestSource2, Is.Not.Null); IRequest request1 = A.Fake<IRequest>(); IRequest request2 = A.Fake<IRequest>(); requestSource1.OnNext(request1); A.CallTo(() => observer1.OnNext(request1)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observer2.OnNext(request1)).MustHaveHappened(Repeated.Exactly.Once); Exception exception = new Exception(); requestSource1.OnError(exception); requestSource1.OnError(new Exception()); requestSource1.OnError(new Exception()); requestSource1.OnError(new Exception()); A.CallTo(() => observer1.OnError(exception)).MustNotHaveHappened(); A.CallTo(() => observer2.OnError(exception)).MustNotHaveHappened(); requestSource2.OnNext(request2); A.CallTo(() => observer1.OnNext(request2)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observer2.OnNext(request2)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observer3.OnNext(A<Exception>._)).WhenArgumentsMatch(call => call.Get<Exception>(0).InnerException == exception).MustHaveHappened(Repeated.Exactly.Once); eventSub1.Dispose(); eventSub2.Dispose(); exceptionSub.Dispose(); }
public void ShouldOnlySubscribeToUnderlyingEndpointResponsesOnce() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IObservable<IResponse> observable1 = A.Fake<IObservable<IResponse>>(); IObservable<IResponse> observable2 = A.Fake<IObservable<IResponse>>(); IObserver<IResponse> observer1 = A.Fake<IObserver<IResponse>>(); IObserver<IResponse> observer2 = A.Fake<IObserver<IResponse>>(); IRequest request = A.Fake<IRequest>(); A.CallTo(() => serviceEndpointClient1.CanHandle(request)).Returns(true); A.CallTo(() => serviceEndpointClient2.CanHandle(request)).Returns(true); A.CallTo(() => serviceEndpointClient1.GetResponses(request)).Returns(observable1); A.CallTo(() => serviceEndpointClient2.GetResponses(request)).Returns(observable2); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2 }, new[] { serviceEndpoint1, serviceEndpoint2 }); IObservable<IResponse> responses = serviceBus.GetResponses(request); IDisposable sub1 = responses.Subscribe(observer1); IDisposable sub2 = responses.Subscribe(observer2); A.CallTo(() => serviceEndpointClient1.GetResponses(request)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpointClient2.GetResponses(request)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observable1.Subscribe(A<IObserver<IResponse>>._)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observable2.Subscribe(A<IObserver<IResponse>>._)).MustHaveHappened(Repeated.Exactly.Once); sub1.Dispose(); sub2.Dispose(); }
private void SubscribeToImageMessages() { Log("Subscribing to ImageMessage messages"); _serviceBus = ServiceBus .Setup(ServiceBusUtilities.GetServiceBusCredentials()) .Subscribe<ImageMessage>(this.SaveImageToBlobStorage); Log("Subscribed to ImageMessage messages"); }
public void ShouldAttemptToSendResponseToAllEndpointsWhenExceptionsAreThrown() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint3 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IRequest request = A.Fake<IRequest>(); IResponse response = A.Fake<IResponse>(); A.CallTo(() => serviceEndpoint1.CanHandle(A<IResponse>._)).Returns(true); A.CallTo(() => serviceEndpoint2.CanHandle(A<IResponse>._)).Returns(true); A.CallTo(() => serviceEndpoint3.CanHandle(A<IResponse>._)).Returns(true); Exception originalException = new Exception("Something went wrong"); A.CallTo(() => serviceEndpoint2.ReplyAsync(request, response)).Throws(originalException); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2 }, new[] { serviceEndpoint1, serviceEndpoint2, serviceEndpoint3 }); AggregateException aggregateException = null; try { serviceBus.ReplyAsync(request, response); } catch (AggregateException ex) { aggregateException = ex; Console.WriteLine(ex); } Assert.That(aggregateException != null, "No aggregate exception was thrown"); Assert.That(aggregateException.InnerExceptions.Any(e => e.InnerException == originalException), "Aggregate exception did not contain original exception"); A.CallTo(() => serviceEndpoint1.ReplyAsync(request, response)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpoint2.ReplyAsync(request, response)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpoint3.ReplyAsync(request, response)).MustHaveHappened(Repeated.Exactly.Once); }
public void ShouldAttemptToSendCommandToAllEndpointsWhenExceptionsAreThrown() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient3 = A.Fake<IServiceEndpointClient>(); ICommand command = A.Fake<ICommand>(); ICommand command2 = A.Fake<ICommand>(); A.CallTo(() => serviceEndpointClient1.CanHandle(A<ICommand>._)).Returns(true); A.CallTo(() => serviceEndpointClient2.CanHandle(A<ICommand>._)).Returns(true); A.CallTo(() => serviceEndpointClient3.CanHandle(A<ICommand>._)).Returns(true); Exception originalException = new Exception("Something went wrong"); A.CallTo(() => serviceEndpointClient1.SendAsync(A<ICommand>._)).Returns(Task.FromResult(true)); A.CallTo(() => serviceEndpointClient2.SendAsync(A<ICommand>._)).Throws(originalException); A.CallTo(() => serviceEndpointClient3.SendAsync(A<ICommand>._)).Returns(Task.FromResult(true)); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2, serviceEndpointClient3 }, new[] { serviceEndpoint1, serviceEndpoint2 }); AggregateException aggregateException = null; try { serviceBus.SendAsync(new[] {command, command2}); } catch (AggregateException ex) { aggregateException = ex; Console.WriteLine(ex); } Assert.That(aggregateException != null, "No aggregate exception was thrown"); Assert.That(aggregateException.InnerExceptions.Any(e => e.InnerException == originalException), "Aggregate exception did not contain original exception"); A.CallTo(() => serviceEndpointClient1.SendAsync(command)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpointClient2.SendAsync(command)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpointClient3.SendAsync(command)).MustHaveHappened(Repeated.Exactly.Once); }
public void ShouldSendResponsesToCorrectEndpoints() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint3 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IRequest request = A.Fake<IRequest>(); IResponse response = A.Fake<IResponse>(); A.CallTo(() => serviceEndpoint1.CanHandle(response)).Returns(true); A.CallTo(() => serviceEndpoint2.CanHandle(response)).Returns(false); A.CallTo(() => serviceEndpoint3.CanHandle(response)).Returns(true); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2 }, new[] { serviceEndpoint1, serviceEndpoint2, serviceEndpoint3 }); serviceBus.ReplyAsync(request, response); A.CallTo(() => serviceEndpoint1.ReplyAsync(request, response)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => serviceEndpoint2.ReplyAsync(request, response)).MustNotHaveHappened(); A.CallTo(() => serviceEndpoint3.ReplyAsync(request, response)).MustHaveHappened(Repeated.Exactly.Once); }
public void ShouldReturnEventsFromUnderlyingEndpoints() { IServiceEndpoint serviceEndpoint1 = A.Fake<IServiceEndpoint>(); IServiceEndpoint serviceEndpoint2 = A.Fake<IServiceEndpoint>(); IServiceEndpointClient serviceEndpointClient1 = A.Fake<IServiceEndpointClient>(); IServiceEndpointClient serviceEndpointClient2 = A.Fake<IServiceEndpointClient>(); IObservable<IEvent> observable1 = A.Fake<IObservable<IEvent>>(); IObservable<IEvent> observable2 = A.Fake<IObservable<IEvent>>(); IObserver<IEvent> observer1 = A.Fake<IObserver<IEvent>>(); IObserver<IEvent> observer2 = A.Fake<IObserver<IEvent>>(); A.CallTo(() => serviceEndpointClient1.Events).Returns(observable1); A.CallTo(() => serviceEndpointClient2.Events).Returns(observable2); IObserver<IEvent> internalObserver1 = null; IObserver<IEvent> internalObserver2 = null; A.CallTo(() => observable1.Subscribe(A<IObserver<IEvent>>._)).Invokes(call => internalObserver1 = call.GetArgument<IObserver<IEvent>>(0)); A.CallTo(() => observable2.Subscribe(A<IObserver<IEvent>>._)).Invokes(call => internalObserver2 = call.GetArgument<IObserver<IEvent>>(0)); IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2 }, new[] { serviceEndpoint1, serviceEndpoint2 }); IDisposable sub1 = serviceBus.Events.Subscribe(observer1); IDisposable sub2 = serviceBus.Events.Subscribe(observer2); Assert.That(internalObserver1, Is.Not.Null); Assert.That(internalObserver2, Is.Not.Null); IEvent event1 = A.Fake<IEvent>(); IEvent event2 = A.Fake<IEvent>(); internalObserver1.OnNext(event1); internalObserver2.OnNext(event2); A.CallTo(() => observer1.OnNext(event1)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observer2.OnNext(event1)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observer1.OnNext(event2)).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => observer2.OnNext(event2)).MustHaveHappened(Repeated.Exactly.Once); sub1.Dispose(); sub2.Dispose(); }