public static Task <IStartableEndpoint> Create(Settings.Settings settings, TransportCustomization transportCustomization, TransportSettings transportSettings, LoggingSettings loggingSettings, IContainer container, Action <ICriticalErrorContext> onCriticalError, EmbeddableDocumentStore documentStore, EndpointConfiguration configuration, bool isRunningAcceptanceTests) { var endpointName = settings.ServiceName; if (configuration == null) { configuration = new EndpointConfiguration(endpointName); var assemblyScanner = configuration.AssemblyScanner(); assemblyScanner.ExcludeAssemblies("ServiceControl.Plugin"); } configuration.Pipeline.Register(typeof(FullTypeNameOnlyBehavior), "Remove asm qualified name from the message type header"); // HACK: Yes I know, I am hacking it to pass it to RavenBootstrapper! configuration.GetSettings().Set(documentStore); configuration.GetSettings().Set("ServiceControl.Settings", settings); configuration.SendOnly(); transportCustomization.CustomizeSendOnlyEndpoint(configuration, transportSettings); //DisablePublishing API is available only on TransportExtensions for transports that implement IMessageDrivenPubSub so we need to set settings directly configuration.GetSettings().Set("NServiceBus.PublishSubscribe.EnablePublishing", false); var routing = new RoutingSettings(configuration.GetSettings()); routing.RouteToEndpoint(typeof(RegisterNewEndpoint), settings.ServiceControlQueueAddress); routing.RouteToEndpoint(typeof(MarkMessageFailureResolvedByRetry), settings.ServiceControlQueueAddress); configuration.GetSettings().Set(loggingSettings); configuration.SetDiagnosticsPath(loggingSettings.LogPath); // sagas are not auto-disabled for send-only endpoints configuration.DisableFeature <Sagas>(); configuration.UseSerialization <NewtonsoftSerializer>(); configuration.Conventions().DefiningEventsAs(t => typeof(IEvent).IsAssignableFrom(t) || IsExternalContract(t)); if (!isRunningAcceptanceTests) { configuration.ReportCustomChecksTo(settings.ServiceControlQueueAddress); } #pragma warning disable CS0618 // Type or member is obsolete configuration.UseContainer <AutofacBuilder>(c => c.ExistingLifetimeScope(container)); #pragma warning restore CS0618 // Type or member is obsolete configuration.DefineCriticalErrorAction(criticalErrorContext => { onCriticalError(criticalErrorContext); return(Task.FromResult(0)); }); if (Environment.UserInteractive && Debugger.IsAttached) { configuration.EnableInstallers(); } return(Endpoint.Create(configuration)); }
public static void ApplyRouting(this RoutingSettings config) { config.RouteToEndpoint(typeof(TestCommand), EndpointNames.SagaEndpoint); config.RouteToEndpoint(typeof(FinishSaga), EndpointNames.SagaEndpoint); config.RouteToEndpoint(typeof(TestMessage), EndpointNames.ExternalHandler); config.RouteToEndpoint(typeof(DoWorkCommand), EndpointNames.ExternalHandler); }
private static void ConfigureRouting(RoutingSettings <RabbitMQTransport> routing) { routing.RouteToEndpoint(typeof(DeviceDeleteCommand), "sdms.device-listener.host"); routing.RouteToEndpoint(typeof(DeviceVerificationMessage), "sdms.device-listener.host"); routing.RouteToEndpoint(typeof(DeviceAssignCommand), "sdms.device-listener.host"); routing.RouteToEndpoint(typeof(DeviceCommandExecute), "sdms.device-enactor.host"); }
public void ConfigureRouting(RoutingSettings <SqlServerTransport> routingSettings) { routingSettings.RouteToEndpoint(typeof(PlaceOrder), "Order"); routingSettings.RouteToEndpoint(typeof(PlaceOrderResult), "Client"); routingSettings.RouteToEndpoint(typeof(PlaceReservation), "Warehouse"); routingSettings.RouteToEndpoint(typeof(PlaceReservationResult), "Order"); }
private static void RegisterPublishers(RoutingSettings routing) { var assembly = typeof(ICreateOrderEvent).Assembly; routing.RouteToEndpoint(assembly: assembly, destination: "MultiPull.Clients.ClientProcessor"); routing.RouteToEndpoint(assembly: assembly, destination: "MultiPull.Clients.OrderProcessor"); }
private static void RegisterPublishers(RoutingSettings <KafkaTransport> routing) { var assembly = typeof(ICreateOrderEvent).Assembly; routing.RouteToEndpoint(assembly: assembly, destination: "MultiPull.Clients.StoreProcessor"); routing.RouteToEndpoint(typeof(CreateOrderCommand).Assembly, "MultiPull.MessageBusWithKafka"); }
private static void SetupRouting(RoutingSettings <RabbitMQTransport> routing) { routing.RouteToEndpoint(typeof(PostRequest).Assembly , "Varian.Contracts.Commands.SubscriberEndpoint" , "Varian.Subscriber"); routing.RouteToEndpoint(typeof(PostRequest).Assembly , "Varian.Contracts.Commands.PublisherEndpoint" , "Varian.Publisher"); }
public async Task AddOrUpdateElasticNews(NewsUpdateOrCreateCommand newsUpdateOrCreate) { _routing.RouteToEndpoint(typeof(NewsUpdateOrCreateCommand), _messageQueueName); var endpointInstance = await Endpoint.Start(_endPoint).ConfigureAwait(false); await endpointInstance.Send(newsUpdateOrCreate).ConfigureAwait(false); await endpointInstance.Stop().ConfigureAwait(false); }
private static void ConfigureRouting(RoutingSettings routing) { routing.RouteToEndpoint( typeof(ImportLevyDeclarationsCommand).Assembly, typeof(ImportLevyDeclarationsCommand).Namespace, "SFA.DAS.EmployerFinance.MessageHandlers" ); routing.RouteToEndpoint( typeof(SendEmailCommand).Assembly, typeof(SendEmailCommand).Namespace, "SFA.DAS.Notifications.MessageHandlers" ); }
private static async Task MainAsync() { const string EndpointName = "Finance.Endpoint"; Console.Title = EndpointName; var endpointConfiguration = new EndpointConfiguration(EndpointName); endpointConfiguration.UsePersistence <LearningPersistence>(); TransportExtensions <LearningTransport> transport = endpointConfiguration.UseTransport <LearningTransport>(); RoutingSettings <LearningTransport> routing = transport.Routing(); routing.RouteToEndpoint(typeof(ChargeCreditCardRequest), "ItOps.CreditCardProcessor.Gateway"); endpointConfiguration.EnableFeature <RoutingSlips>(); endpointConfiguration.RegisterComponents( configureComponents => { configureComponents.ConfigureComponent <InMemoryOrders>(DependencyLifecycle.SingleInstance); }); var endpoint = await Endpoint.Start(endpointConfiguration).ConfigureAwait(false); Console.WriteLine("Press any key to exit"); Console.ReadKey(); await endpoint.Stop().ConfigureAwait(false); }
internal virtual RoutingSettings <SqsTransport> BuildEndpointSQSRouting( RoutingSettings <SqsTransport> routing) { routing.RouteToEndpoint(typeof(PlaceOrder), "NSB.Server"); routing.RegisterPublisher(typeof(OrderPlaced), "NSB.Server"); return(routing); }
public void WhenPassingTransportAddressForSenderInsteadOfEndpointName_ShouldThrowException() { var routingSettings = new RoutingSettings(new SettingsHolder()); var expectedExceptionMessage = expectedExceptionMessageForWrongEndpointName; var exception = Assert.Throws <ArgumentException>(() => routingSettings.RouteToEndpoint(typeof(MessageWithoutNamespace), "EndpointName@MyHost")); Assert.AreEqual(expectedExceptionMessage, exception.Message); }
public SenderWithInvalidMappingFile() { EndpointSetup <DefaultServer>(c => { var routingSettings = new RoutingSettings <MsmqTransport>(c.GetSettings()); routingSettings.RouteToEndpoint(typeof(Message), "someReceiver"); routingSettings.InstanceMappingFile().FilePath(mappingFilePath); }); }
public SenderWithEmptyMappingFile() { EndpointSetup <DefaultServer>(c => { var routingSettings = new RoutingSettings <MsmqTransport>(c.GetSettings()); routingSettings.RouteToEndpoint(typeof(Message), logicalEndpointName); routingSettings.InstanceMappingFile().FilePath(mappingFilePath); }); }
public void WhenPassingTransportAddressForSenderInsteadOfEndpointName_UsingAssemblyAndNamespace_ShouldThrowException() { var routingSettings = new RoutingSettings(settings); var expectedExceptionMessage = expectedExceptionMessageForWrongEndpointName; var exception = Assert.Throws <ArgumentException>(() => routingSettings.RouteToEndpoint(Assembly.GetExecutingAssembly(), nameof(MessageNamespaceA), "EndpointName@MyHost")); Assert.AreEqual(expectedExceptionMessage, exception.Message); }
public SendingEndpointUsingRoutingApi() { EndpointSetup <DefaultServer>(c => { c.Conventions().DefiningCommandsAs(t => t == typeof(SomeCommand)); var routing = new RoutingSettings(c.GetSettings()); routing.RouteToEndpoint(typeof(SomeCommand).Assembly, Conventions.EndpointNamingConvention(typeof(ReceivingEndpoint))); }).ExcludeType <SomeCommand>(); //exclude type to simulate an unobtrusive message assembly which isn't automatically loaded. }
private static void RouteSampleCommands(RoutingSettings <AzureServiceBusTransport> routing) { var endpointName = "prospaworkernsb"; if (ProspaConstants.Environments.IsDevelopment) { endpointName += $".{Environment.MachineName.ToLower()}"; } routing.RouteToEndpoint(typeof(SampleCommand), endpointName); }
public Sender() { EndpointSetup <DefaultServer>(c => { var routing = new RoutingSettings <MsmqTransport>(c.GetSettings()); // only configure logical endpoint in routing routing.RouteToEndpoint(typeof(Message), ReceiverEndpointName); routing.InstanceMappingFile().FilePath(mappingFilePath); }); }
private static void RouteSampleCommands(RoutingSettings <AzureServiceBusTransport> routing) { var endpointName = "TODO: Endpoint Name"; if (Constants.Environments.IsDevelopment) { endpointName += $".{Environment.MachineName}"; } routing.RouteToEndpoint(typeof(SampleCommand), endpointName); }
public void WhenRoutingMessageTypeToEndpoint_ShouldConfigureMessageTypeInRoutingTable() { var routingSettings = new RoutingSettings(settings); routingSettings.RouteToEndpoint(typeof(SomeMessageType), "destination"); var routingTable = ApplyConfiguredRoutes(routingSettings); var route = routingTable.GetRouteFor(typeof(SomeMessageType)); Assert.That(route, Is.Not.Null); Assert.That(route.Endpoint, Is.EqualTo("destination")); }
public static void AddRouting(this RoutingSettings routingSettings) { routingSettings.RouteToEndpoint(typeof(RunHealthCheckCommand), CommitmentsV2MessageHandler); routingSettings.RouteToEndpoint(typeof(ProviderApproveCohortCommand), CommitmentsV2MessageHandler); routingSettings.RouteToEndpoint(typeof(ProviderSendCohortCommand), CommitmentsV2MessageHandler); routingSettings.RouteToEndpoint(typeof(SendEmailToEmployerCommand), CommitmentsV2MessageHandler); routingSettings.RouteToEndpoint(typeof(ApproveTransferRequestCommand), CommitmentsV2MessageHandler); routingSettings.RouteToEndpoint(typeof(RejectTransferRequestCommand), CommitmentsV2MessageHandler); routingSettings.RouteToEndpoint(typeof(SendEmailCommand), NotificationsMessageHandler); }
public virtual RoutingSettings <LearningTransport> BuildEndpointRouting( RoutingSettings <LearningTransport> routing) { var routes = typeScanner.GetAllTypesWithPublishingEndpoints(); foreach (var route in routes) { var assemblyType = route.Item1; var endpoint = GetEndpointNameWithPrefixedEnvironment(GetEnvironmentName(), route.Item2); routing.RouteToEndpoint(assemblyType, endpoint); } return(routing); }
public static void AddRouting(this RoutingSettings routingSettings) { routingSettings.RouteToEndpoint(typeof(CreateIncentiveCommand), QueueNames.ApprenticeshipIncentivesCreate); routingSettings.RouteToEndpoint(typeof(CalculateEarningsCommand), QueueNames.ApprenticeshipIncentivesCalculateEarnings); routingSettings.RouteToEndpoint(typeof(CompleteEarningsCalculationCommand), QueueNames.CompleteEarningsCalculation); routingSettings.RouteToEndpoint(typeof(AddEmployerVendorIdCommand), QueueNames.AddEmployerVendorId); routingSettings.RouteToEndpoint(typeof(WithdrawCommand), QueueNames.ApprenticeshipIncentivesWithdraw); routingSettings.RouteToEndpoint(typeof(UpdateVendorRegistrationCaseStatusForAccountCommand), QueueNames.UpdateVendorRegistrationCaseStatus); }
public void WhenRoutingAssemblyWithNamespaceToEndpoint_ShouldOnlyConfigureMessagesWithinThatNamespace() { var routingSettings = new RoutingSettings(settings); routingSettings.RouteToEndpoint(Assembly.GetExecutingAssembly(), nameof(MessageNamespaceA), "destination"); var routingTable = ApplyConfiguredRoutes(routingSettings); var someMessageRoute = routingTable.GetRouteFor(typeof(SomeMessageType)); var otherMessageRoute = routingTable.GetRouteFor(typeof(OtherMessageType)); var messageWithoutNamespaceRoute = routingTable.GetRouteFor(typeof(MessageWithoutNamespace)); Assert.That(someMessageRoute, Is.Not.Null, "because SomeMessageType is in the given namespace"); Assert.That(otherMessageRoute, Is.Null, "because OtherMessageType is not in the given namespace"); Assert.That(messageWithoutNamespaceRoute, Is.Null, "because MessageWithoutNamespace is not in the given namespace"); }
public void WhenRoutingAssemblyToEndpoint_ShouldConfigureAllContainedMessagesInRoutingTable() { var routingSettings = new RoutingSettings(settings); routingSettings.RouteToEndpoint(Assembly.GetExecutingAssembly(), "destination"); var routingTable = ApplyConfiguredRoutes(routingSettings); var someMessageRoute = routingTable.GetRouteFor(typeof(SomeMessageType)); var otherMessageRoute = routingTable.GetRouteFor(typeof(OtherMessageType)); var messageWithoutNamespaceRoute = routingTable.GetRouteFor(typeof(MessageWithoutNamespace)); Assert.That(someMessageRoute, Is.Not.Null); Assert.That(otherMessageRoute, Is.Not.Null); Assert.That(messageWithoutNamespaceRoute, Is.Not.Null); }
public void WhenRoutingAssemblyWithNamespaceToEndpointAndSpecifyingEmptyNamespace_ShouldOnlyConfigureMessagesWithinEmptyNamespace(string emptyNamespace) { var routingSettings = new RoutingSettings(settings); routingSettings.RouteToEndpoint(Assembly.GetExecutingAssembly(), emptyNamespace, "destination"); var routingTable = ApplyConfiguredRoutes(routingSettings); var someMessageRoute = routingTable.GetRouteFor(typeof(SomeMessageType)); var otherMessageRoute = routingTable.GetRouteFor(typeof(OtherMessageType)); var messageWithoutNamespaceRoute = routingTable.GetRouteFor(typeof(MessageWithoutNamespace)); Assert.That(someMessageRoute, Is.Null); Assert.That(otherMessageRoute, Is.Null); Assert.That(messageWithoutNamespaceRoute, Is.Not.Null); }
private static async Task Main(string[] args) { Console.Title = "ClientUI"; var endpointConfiguration = new EndpointConfiguration("ClientUI"); TransportExtensions <LearningTransport> transport = endpointConfiguration.UseTransport <LearningTransport>(); RoutingSettings <LearningTransport> routing = transport.Routing(); routing.RouteToEndpoint(typeof(PlaceOrder), "Sales"); IEndpointInstance endpointInstance = await Endpoint.Start(endpointConfiguration).ConfigureAwait(false); await RunLoop(endpointInstance).ConfigureAwait(false); await endpointInstance.Stop().ConfigureAwait(false); }
public IServiceProvider ConfigureServices(IServiceCollection services) { services .AddMvcCore() .AddCors() .AddJsonFormatters() .AddApiExplorer() .SetCompatibilityVersion(CompatibilityVersion.Version_2_2); services .AddSignalR(); services.AddSpaStaticFiles(configuration => { configuration.RootPath = "ClientApp/dist"; }); services.AddSingleton <IEquipmentRepository, EquipmentRepository>(); services.AddScoped <EquipmentFilter>(); services.AddSingleton(serviceProvider => _endpoint); var endpointConfiguration = new EndpointConfiguration("Bondora.ConstructionEquipmentRental.Service"); // It's used for development, for real case we should use any real transport (RabbitMQ and so on). TransportExtensions <LearningTransport> transport = endpointConfiguration.UseTransport <LearningTransport>(); UpdateableServiceProvider container = null; endpointConfiguration.UseContainer <ServicesBuilder>(customizations => { customizations.ExistingServices(services); customizations.ServiceProviderFactory(serviceCollection => { container = new UpdateableServiceProvider(serviceCollection); return(container); }); }); RoutingSettings <LearningTransport> routing = transport.Routing(); routing.RouteToEndpoint( assembly: typeof(GetInvoiceCommand).Assembly, destination: "Bondora.ConstructionEquipmentRental.Billing"); _endpoint = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult(); return(container); }
public virtual RoutingSettings <SqlServerTransport> BuildEndpointRouting( RoutingSettings <SqlServerTransport> routing) { var routes = typeScanner.GetAllTypesWithPublishingEndpoints(); foreach (var route in routes) { var assemblyType = route.Item1; var endpoint = GetEndpointNameWithPrefixedEnvironment(GetEnvironmentName(), route.Item2); if (assemblyType.IsInterface) { routing.RegisterPublisher(assemblyType, endpoint); } else if (assemblyType.IsClass && !assemblyType.IsAbstract) { routing.RouteToEndpoint(assemblyType, endpoint); } } return(routing); }
public static void AddRouting(this RoutingSettings routingSettings) { routingSettings.RouteToEndpoint(typeof(SendEmailCommand), NotificationsMessageHandler); }