protected override void Configure(BusConfigurator configurator, IServiceProvider serviceProvider)
{
configurator.Connect(endpoints => endpoints
.AddOutbound <IIntegrationEvent>(new KafkaProducerEndpoint("silverback-examples-events")
{
Configuration = new KafkaProducerConfig
{
BootstrapServers = "PLAINTEXT://localhost:9092"
}
}));
_cancellationTokenSource = new CancellationTokenSource();
Console.WriteLine("Starting OutboundWorker background process (press ESC to stop)...");
var service = serviceProvider.GetRequiredService <IHostedService>();
service.StartAsync(CancellationToken.None);
_cancellationTokenSource.Token.Register(() => service.StopAsync(CancellationToken.None));
}
static void Main(string[] args)
{
var orderSaga = new OrderSaga();
var repo = new InMemorySagaRepository <OrderSagaState>();
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host, RabbitMqConstants.SagaQueue, e =>
{
e.PrefetchCount = 10;
e.StateMachineSaga(orderSaga, repo);
});
});
bus.Start();
Console.WriteLine("Saga active.... Press <Enter> to exit");
Console.ReadLine();
bus.Stop();
}
private static IBusControl ConfigureBus()
{
var orderStateMachine = new ProposalStateMachine();
var repository = new InMemorySagaRepository <PersistedProposal>();
return(BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.UseSerilog();
cfg.ReceiveEndpoint(
host,
"proposal_saga",
e =>
{
e.UseInMemoryOutbox();
e.StateMachineSaga(orderStateMachine, repository);
});
cfg.UseInMemoryScheduler();
}));
}
private static async Task AsyncMain()
{
// This makes it easier to tell console windows apart
Console.Title = "MassTransitRabitMQ-POC.Client";
var bus = BusConfigurator.ConfigureBus();
await bus.StartAsync();
var sendToUri = new Uri(RabbitMqServerConstants.RabbitMqUri + RabbitMqQueueNames.OrderPublicationQueue);
var endpointInstance = await bus.GetSendEndpoint(sendToUri);
try
{
await SendOrders(endpointInstance);
}
finally
{
await bus.StopAsync();
}
}
static void Main(string[] args)
{
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(RabbitMqConstants.NotificationServiceQueue, e =>
{
e.Handler <IOrderRegisteredEvent>(c =>
{
return(Console.Out.WriteLineAsync($"Customer notification sent: " + $"Order id {c.Message.OrderId}"));
});
});
});
bus.Start();
Console.WriteLine("Listening for Order registered events.. Press enter to exit");
Console.ReadLine();
bus.Stop();
}
private static void RunMassTransitSendWithRabbit()
{
var rabbitBusControl = BusConfigurator.ConfigureBus();
var sendToUri = new Uri($"{RabbitMqConstants.RabbitMqUri}" + $"{RabbitMqConstants.NotificationServiceQueue}");
Task <ISendEndpoint> sendEndpointTask = rabbitBusControl.GetSendEndpoint(sendToUri);
var sendEndpoint = sendEndpointTask.Result;
Task sendTask = sendEndpoint.Send <IRegisterCustomer>(new
{
Id = Guid.NewGuid(),
Name = "Abdurabu",
Preferred = true,
Address = "Test",
RegisteredUtc = DateTime.UtcNow,
Type = 1,
DefaultDiscount = 0
});
Console.ReadKey();
}
static void Main(string[] args)
{
System.Console.Title = "City monitor";
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.EnablePerformanceCounters();
cfg.ReceiveEndpoint(host, RabbitMqConstants.CityMonitorServiceQueue, e =>
{
e.Consumer <CityMessageConsumer>();
});
});
bus.Start();
System.Console.WriteLine("Listening for city messages.. Press enter to exit");
System.Console.ReadLine();
bus.Stop();
}
static void Main(string[] args)
{
var appConfigurationRoot = new AppConfigurationRootProvider().Get();
var serverConfigurationHelper = new ServerConfigurationHelper(appConfigurationRoot);
var bus = new BusConfigurator(serverConfigurationHelper).ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host, RegisterOrderConstants.RegisterOrderServiceQueue, e =>
{
e.Consumer <RegisterOrderCommandConsumer>();
});
});
bus.Start();
Console.WriteLine("Listening...", Color.Cyan);
Console.ReadKey();
bus.Stop();
}
private static async Task AsyncMain()
{
Console.Title = "MassTransitRabitMQ-POC.Subscriber2";
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host,
$"{RabbitMqQueueNames.OrderPublicationQueue}.Subscriber2", e =>
{
e.Consumer <OrderCreatedCommandConsumer>();
e.Durable = true;
});
});
await bus.StartAsync();
Console.WriteLine("Press any key to exit");
Console.ReadKey();
await bus.StopAsync();
}
/// <summary>
/// Starts the ExternalContent Service.
/// Called by the service host when the service is started.
/// </summary>
public void Start()
{
Log.Information("ExternalContent service is starting");
// Configure Bus
bus = BusConfigurator.ConfigureBus(MonitoredServices.ExternalContentService, (cfg, host) =>
{
cfg.ReceiveEndpoint(BusConstants.ManagementApiGetDigitizationOrderData,
ec => { ec.Consumer(() => kernel.Get <DigitizationOrderConsumer>()); });
cfg.UseSerilog();
});
// Add the bus instance to the IoC container
kernel.Bind <IBus>().ToMethod(context => bus).InSingletonScope();
kernel.Bind <IBusControl>().ToMethod(context => bus).InSingletonScope();
bus.Start();
Log.Information("ExternalContent service started");
}
static void Main(string[] args)
{
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host,
RabbitMqConstants.RegisterOrderServiceQueue, e =>
{
e.Consumer <RegisteredOrderCommandConsumer>();
//e.Handler<IRegisterOrderCommand>(c => Console.Out.WriteLineAsync(c.Message.DeliverAddress)); // mini handler
});
});
bus.Start();
Console.WriteLine("Listening for Register order commands.. " +
"Press enter to exit");
Console.ReadLine();
bus.Stop();
}
public void Start()
{
LogConfigurator.ConfigureForService();
Log.Information("Viaduc service is starting");
bus = BusConfigurator.ConfigureBus(MonitoredServices.ViaducService, (cfg, host) =>
{
cfg.ReceiveEndpoint(BusConstants.ReadUserInformationQueue,
ec => { ec.Consumer(() => new ReadUserInformationConsumer()); }
);
cfg.ReceiveEndpoint(BusConstants.ReadStammdatenQueue,
ec => { ec.Consumer(() => new ReadStammdatenConsumer()); }
);
});
bus.Start();
Log.Information("Viaduc service started");
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddDbContextPool <KacharDbContext>(opt =>
{
opt.UseSqlServer(Configuration.GetValue <string>("ConnectionString"),
serverDbContextOptionsBuilder =>
{
var minutes = (int)TimeSpan.FromMinutes(3).TotalSeconds;
serverDbContextOptionsBuilder.CommandTimeout(minutes);
serverDbContextOptionsBuilder.EnableRetryOnFailure();
}
);
});
services.AddScoped <InsertCodingActivity>();
services.AddMassTransit(x =>
{
x.AddBus(provider => BusConfigurator.ConfigureBus((cfg) =>
{
cfg.ReceiveEndpoint("Kachar_Coding_Insert", e =>
{
e.PrefetchCount = 100;
e.ExecuteActivityHost <InsertCodingActivity, Coding>(new Uri(RabbitMqConstants.RabbitMqUri + "Comp_Kachar_Coding_Insert"), services.BuildServiceProvider(),
c => c.UseRetry(r => r.Immediate(5)));
});
cfg.ReceiveEndpoint("Comp_Kachar_Coding_Insert", e =>
{
e.PrefetchCount = 100;
e.CompensateActivityHost <InsertCodingActivity, Coding>(services.BuildServiceProvider(), c => c.UseRetry(r => r.Immediate(5)));
});
}));
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}
/// <summary>
/// Starts the Repository Service.
/// Called by the service host when the service is started.
/// </summary>
public void Start()
{
Log.Information("Repository service is starting");
// Configure Bus
var helper = new ParameterBusHelper();
BusConfigurator.ConfigureBus(containerBuilder, MonitoredServices.RepositoryService, (cfg, ctx) =>
{
cfg.ReceiveEndpoint(BusConstants.RepositoryManagerDownloadPackageMessageQueue, ec =>
{
ec.Consumer(ctx.Resolve <DownloadPackageConsumer>);
ec.UseRetry(retryPolicy =>
retryPolicy.Exponential(10, TimeSpan.FromSeconds(1), TimeSpan.FromMinutes(5), TimeSpan.FromSeconds(5)));
BusConfigurator.SetPrefetchCountForEndpoint(ec);
});
cfg.ReceiveEndpoint(BusConstants.RepositoryManagerArchiveRecordAppendPackageMessageQueue, ec =>
{
ec.Consumer(ctx.Resolve <AppendPackageConsumer>);
ec.UseRetry(retryPolicy =>
retryPolicy.Exponential(10, TimeSpan.FromSeconds(1), TimeSpan.FromMinutes(5), TimeSpan.FromSeconds(5)));
BusConfigurator.SetPrefetchCountForEndpoint(ec);
});
cfg.ReceiveEndpoint(BusConstants.RepositoryManagerReadPackageMetadataMessageQueue, ec =>
{
ec.Consumer(ctx.Resolve <ReadPackageMetadataConsumer>);
ec.UseRetry(retryPolicy => retryPolicy.Exponential(3, TimeSpan.FromSeconds(1), TimeSpan.FromMinutes(5), TimeSpan.FromSeconds(5)));
});
cfg.ReceiveEndpoint(BusConstants.MonitoringDirCheckQueue, ec => { ec.Consumer(ctx.Resolve <CheckDirConsumer>); });
helper.SubscribeAllSettingsInAssembly(Assembly.GetExecutingAssembly(), cfg);
});
containerBuilder.Register(GetArchiveRecordsForPackageRequestClientCallback);
var container = containerBuilder.Build();
bus = container.Resolve <IBusControl>();
bus.Start();
Log.Information("Repository service started");
}
static void Main(string[] args)
{
Console.Title = "Registration service";
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host,
Constants.RegisterUserServiceQueue, e =>
{
e.Consumer <RegisterUserCommandConsumer>();
});
});
bus.Start();
Console.WriteLine("Listening for register user command.. ");
Console.ReadLine();
bus.Stop();
}
/// <summary>
/// Starts the ExternalContent Service.
/// Called by the service host when the service is started.
/// </summary>
public void Start()
{
Log.Information("ExternalContent service is starting");
// Configure Bus
BusConfigurator.ConfigureBus(containerBuilder, MonitoredServices.ExternalContentService, (cfg, ctx) =>
{
cfg.ReceiveEndpoint(BusConstants.ManagementApiGetDigitizationOrderData,
ec => { ec.Consumer(ctx.Resolve <DigitizationOrderConsumer>); });
cfg.ReceiveEndpoint(BusConstants.ManagementApiGetReportExternalContent,
ec => { ec.Consumer(ctx.Resolve <ReportExternalConsumer>); });
});
// Add the bus instance to the IoC container
var container = containerBuilder.Build();
bus = container.Resolve <IBusControl>();
bus.Start();
Log.Information("ExternalContent service started");
}
static void Main(string[] args)
{
Console.Title = "Notification";
IContainer container = StructureMapBootStrapper.Init();
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host, RabbitMqConstants.NotificationServiceQueue, e =>
{
e.LoadFrom(container);
});
});
bus.Start();
Console.WriteLine("Listening for Order registered events...");
Console.ReadLine();
bus.Stop();
}
public static async Task Main(string[] args)
{
var sagaStateMachine = new BookingStateMachine();
var repository = new InMemorySagaRepository <BookingSagaState>();
// Register endpoint handle saga
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
Console.WriteLine("Register endpoint handle saga...");
cfg.ReceiveEndpoint(host, RabbitMqConstants.SagaQueue, e =>
{
e.StateMachineSaga(sagaStateMachine, repository);
});
});
await bus.StartAsync(CancellationToken.None);
Console.WriteLine("Saga active.. Press enter to exit");
Console.ReadLine();
await bus.StopAsync(CancellationToken.None);
}
static void Main(string[] args)
{
Console.Title = "Travel Registration Saga";
var bus = BusConfigurator.Configure((cfg, host) =>
{
var travelSaga = new TravelRegistrationSaga();
var repository = new InMemorySagaRepository <TravelSagaState>();
cfg.ReceiveEndpoint(host, Constants.SagaQueue, ce =>
{
ce.StateMachineSaga(travelSaga, repository);
});
});
bus.Start();
Console.WriteLine("Travel Registration Saga active..");
Console.WriteLine(Constants.DefaultConsoleMessage);
Console.ReadLine();
bus.Stop();
}
public async Task <IActionResult> Post([FromBody] OrderRequest orderRequest)
{
PulseRequest pulseRequest = new PulseRequest
{
Id = orderRequest.Id,
LocationCode = orderRequest.LocationCode
};
var bus = BusConfigurator.ConfigureBus();
await bus.StartAsync();
ISendEndpoint endPoint = await bus.GetSendEndpoint(new Uri($"{CustomKey.RABBITMQ_BASE_ENDPOINT}/{CustomKey.RABBITMQ_PRICE_ORDER_REQUEST_ENDPOINT}"));
await endPoint.Send <IPriceOrderRequest>(pulseRequest, x =>
{
x.Headers.Set(CustomKey.SIGNALR_CONNECTION_ID, orderRequest.ConnectionId);
x.Headers.Set(CustomKey.ORDER_REQUEST_KEY, pulseRequest);
});
return(Ok());
}
public static async Task Main(string[] args)
{
var requestedJobId = "3";
if (string.IsNullOrWhiteSpace(requestedJobId))
{
Console.WriteLine("Please enter any id!");
Console.ReadLine();
}
var bus = BusConfigurator.ConfigureBus();
var sendToUri = new Uri($"{"rabbitmq://localhost/"}{"saga.service"}");
var endPoint = await bus.GetSendEndpoint(sendToUri);
await endPoint.Send <IJobRequestCommand>(new JobRequestCommand
{
JobId = requestedJobId
});
Console.WriteLine("Message is sent!");
Environment.Exit(0);
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, BusConfigurator busConfigurator)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.ConfigureSwagger();
app.SilverbackConfigure(busConfigurator, Configuration);
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
static void Main(string[] args)
{
Console.Title = "Registration";
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host,
RabbitMqConstants.RegisterOrderServiceQueue, e =>
{
e.Consumer <RegisterOrderCommandConsumer>();
});
});
bus.StartSafely();
Console.WriteLine("Listening for Register order commands.. " +
"Press enter to exit");
Console.ReadLine();
bus.Stop();
}
public async Task <IActionResult> RegisterOrder(OrderViewModel model)
{
var bus = BusConfigurator.ConfigureBus();
var sendToUri = new Uri($"{RabbitMqConstants.RabbitMqUri}{RabbitMqConstants.SagaQueue}");
var endpoint = await bus.GetSendEndpoint(sendToUri);
await endpoint.Send <IRegisterOrderCommand>(new
{
PickupName = model.PickupName,
PickupAddress = model.PickupAddress,
PickupCity = model.PickupCity,
DeliverName = model.DeliverName,
DeliverAddress = model.DeliverAddress,
DeliverCity = model.DeliverCity,
Weight = model.Weight,
Fragile = model.Fragile,
Oversized = model.Oversized
});
return(View("Thanks"));
}
public void ConfigureServices(IServiceCollection services)
{
try
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
#region MassTransit
//Set RabbitMQ properties
RabbitMqConfiguration.RabbitMqUri = Configuration["RabbitMq:Url"];
RabbitMqConfiguration.VirtualHost = Configuration["RabbitMq:VirtualHost"];
RabbitMqConfiguration.UserName = Configuration["RabbitMq:UserName"];
RabbitMqConfiguration.Password = Configuration["RabbitMq:Password"];
RabbitMqConfiguration.OAuthServiceQueue = Configuration["RabbitMq:OAuth2ServiceQueue"];
RabbitMqConfiguration.Timeout = TimeSpan.FromSeconds(Convert.ToInt32(Configuration["RabbitMq:Timeout"]));
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
//This receiver is fired when a response is created from CreateUserCommandConsumer
cfg.ReceiveEndpoint(host, RabbitMqConfiguration.OAuthServiceQueue, e =>
{
});
});
//Registration of the bus
services.AddSingleton <IPublishEndpoint>(bus);
services.AddSingleton <ISendEndpointProvider>(bus);
services.AddSingleton <IBus>(bus);
bus.StartAsync();
#endregion
}
catch (Exception e)
{
throw e;
}
}
public void AddMessageHandlers_should_add_all_available_message_handlers_from_assemblies()
{
var services = NSubstitute.Substitute.For <IServiceCollection>();
var sagaTypeResolver = NSubstitute.Substitute.For <ISagaTypeResolver>();
var typeResolver = NSubstitute.Substitute.For <ITypeResolver>();
var sysInfo = SystemInfo.New();
var sut = new BusConfigurator(services, sagaTypeResolver, typeResolver, sysInfo);
var result = sut.AddMessageHandlers <DummyMessage>(new[] { typeof(BusConfiguratorTests).Assembly });
result.Should().NotBeNull();
typeResolver.Received(1)
.Register(typeof(DummyMessage));
services.Received(1).Add(Arg.Any <ServiceDescriptor>());
services.Received(1)
.Add(Arg.Is <ServiceDescriptor>(sd => sd.Lifetime == ServiceLifetime.Transient &&
sd.ServiceType == typeof(IHandleMessage <DummyMessage>) &&
sd.ImplementationType.IsAssignableTo(typeof(DummyMessageHandler))));
}
static void Main(string[] args)
{
Console.Title = "Saga";
var saga = new OrderSaga();
var repo = new InMemorySagaRepository <OrderSagaState>();
var bus = BusConfigurator.ConfigureBus((config, host) =>
{
config.ReceiveEndpoint(host, RabbitMQConstants.SagaQueue, e =>
{
e.StateMachineSaga(saga, repo);
});
});
bus.Start();
Console.WriteLine("Saga active... Press enter to exit");
Console.ReadLine();
bus.Stop();
}
public MailErrorSink(string outputTemplate, IFormatProvider formatProvider)
{
try
{
messageTemplateTextFormatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
var containerBuilder = new ContainerBuilder();
BusConfigurator.ConfigureBus(containerBuilder, MonitoredServices.NotMonitored, (cfg, ctx) => { });
var container = containerBuilder.Build();
bus = container.Resolve <IBusControl>();
bus.Start();
ReadConfig();
initOk = true;
}
catch (Exception exception)
{
// Da der Logger noch nicht bereit ist auf die Console schreiben
Console.WriteLine($" ***** Exception beim initialisieren der Klasse MailErrorSink *****\nException: {exception}");
}
}
static async Task Main(string[] args)
{
Console.Title = "Super Duper MassTransit Tester";
var bus = BusConfigurator.CreateBus();
var busUri = BusConfigurator.GetBusUri("quartz-test");
var endpoint = await bus.GetSendEndpoint(busUri);
OutputPrompt();
var testRunId = Guid.NewGuid();
do
{
var input = Console.ReadLine();
if (input == "q")
{
break;
}
if (input.StartsWith("t"))
{
var testRuns = int.Parse(input.Split(':')[1]);
for (var i = 0; i < testRuns; i++)
{
var testId = $"{testRunId}-{i + 1}";
await endpoint.Send(new StartTest { TestId = testId });
Console.WriteLine($"Sent StartTest {testId}.");
}
Console.WriteLine();
OutputPrompt();
}
} while (true);
}
public static async Task Main(string[] args)
{
var requestedReportId = args.ElementAtOrDefault(0);
if (string.IsNullOrWhiteSpace(requestedReportId))
{
Console.WriteLine("Please enter any report id!");
Console.ReadLine();
}
var bus = BusConfigurator.ConfigureBus();
var sendToUri = new Uri($"{RabbitMqConstants.RabbitMqUri}{RabbitMqConstants.SagaQueue}");
var endPoint = await bus.GetSendEndpoint(sendToUri);
await endPoint.Send <IBookingRequestCommand>(new ReportRequestCommand
{
CustomerId = "customer-1234",
ReportId = requestedReportId,
RequestTime = DateTime.Now
});
Console.WriteLine("Message is sent!");
Environment.Exit(0);
}
