public async Task <IActionResult> PostReport(ReportDto reportDto)
{
Guid ID = Guid.NewGuid();
reportDto.ID = ID;
reportDto.CreatedDate = DateTime.Now;
reportDto.Location = reportDto.Location;
reportDto.ReportName = reportDto.ReportName;
_reportService.ReportPost(reportDto);
//Ürün karşılanır.
//Gerekli ön çalışmalar yapılır.
var bus = BusConfigurator.ConfigureBus();
var sendToUri = new Uri($"{RabbitMqConstants.RabbitMqUri}/{RabbitMqConstants.RegistrationServiceQueue}");
var endPoint = await bus.GetSendEndpoint(sendToUri);
await endPoint.Send <IReportRegistrationCommand>(reportDto);
string message = "Rapor talebiniz başarılı bir şekilde tarafımıza ulaşmıştır. ";
return(Ok(message));
}
static void Main(string[] args)
{
Console.Title = "WriteSide";
string connectionString = new AppSettings("appsettings.json").GetConnectionString("DefaultConnection");
BaseCommandHandler.EventRepository = RepositoryFactory.GetArticlesEventRepository(connectionString);
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host, RabbitMqConstants.ArticleWriteServiceQueue, e =>
{
e.Consumer <ApproveArticleCommandHandler>();
e.Consumer <DeleteArticleCommandHandler>();
e.Consumer <DeleteCategoryCommandHandler>();
e.Consumer <DeleteCommentCommandHandler>();
e.Consumer <IncrementArticleViewCountCommandHandler>();
e.Consumer <InsertArticleCommandHandler>();
e.Consumer <InsertCategoryCommandHandler>();
e.Consumer <InsertCommentCommandHandler>();
e.Consumer <RateArticleCommandHandler>();
e.Consumer <UpdateArticleCommandHandler>();
e.Consumer <UpdateCategoryCommandHandler>();
e.Consumer <UpdateCommentCommandHandler>();
e.Consumer <CancelCommandHandler>();
});
});
bus.Start();
Console.WriteLine("Articles.WriteSide.Service");
Console.ReadLine();
bus.Stop();
}
static void Main(string[] args)
{
Console.Title = "OrderService";
var bus = BusConfigurator
.ConfigureBus((cfg) =>
{
cfg.ReceiveEndpoint(RabbitMqConsts.OrderStatusServiceQueue, e =>
{
e.Consumer <UpdateOrderStatusCommandConsumer>();
e.UseCircuitBreaker(cb =>
{
cb.TrackingPeriod = TimeSpan.FromMinutes(1); //reset interval süresinden(5dk) sonra 1 dk bekle bu sürede yine hata alınırsa diğer kuralları beklemeden yine 5dk bekle
cb.TripThreshold = 15; //alınan taleplerin yüzde 15 inde 5 dk bekle
cb.ActiveThreshold = 10; //10 hata alındığında 5 dk bekle
cb.ResetInterval = TimeSpan.FromMinutes(5); //5 dk bekletir
});
});
});
bus.Start();
Console.WriteLine("Listening order status command..");
Console.ReadLine();
}
private IContainer ConfigureContainer(HttpConfiguration config)
{
var builder = new ContainerBuilder();
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
builder.Register(c => BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.UseSerilog();
cfg.ReceiveEndpoint(
host,
"validation_data",
endpointConfigurator =>
{
endpointConfigurator.Consumer(() => new ValidationServiceConsumer());
});
}))
.As <IBus>()
.As <IBusControl>()
.As <ISendEndpointProvider>()
.SingleInstance();
var container = builder.Build();
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
return(container);
}
private static void Main(string[] args)
{
// Configure Bus
var bus = BusConfigurator.ConfigureBus(MonitoredServices.NotMonitored, (cfg, host) =>
{
cfg.ReceiveEndpoint(BusConstants.RepositoryTestPackageDownloadedEventQueue, ec => { ec.Consumer(() => new MyConsumer()); });
cfg.ReceiveEndpoint(BusConstants.AssetManagerAssetReadyEventQueue, ec => { ec.Consumer(() => new MyConsumer()); });
});
bus.Start();
var packageId = string.Empty;
while (packageId?.ToLowerInvariant() != "quit")
{
DownloadReceivedEvent = new ManualResetEvent(false);
AssetReadyReceivedEvent = new ManualResetEvent(false);
Console.WriteLine("Geben Sie eine AIP@DossierId Kennung ein, oder quit um das Programm zu beenden:");
packageId = Console.ReadLine();
Console.WriteLine("Geben D für DownlaodPackage oder A für AppendPackage an:");
var messageType = Console.ReadLine();
if (messageType == "D")
{
DownloadPackage(bus, packageId);
}
else
{
AppendPackage(bus, packageId);
}
}
}
static async System.Threading.Tasks.Task Main(string[] args)
{
var bus = BusConfigurator.ConfigureBus();
var address = new Uri($"{RabbitMqConstants.RabbitMqUri}{RabbitMqConstants.NotificationServiceQueue}");
var timeout = TimeSpan.FromSeconds(10);
var requestClient = bus.CreateRequestClient <IRequestMessage>(
address);
bus.Start();
Console.WriteLine("The message has been sent");
var result = await requestClient.GetResponse <IResponseMessage>(new RequestMessage
{
Id = 1,
Content = "hello f****r"
});
Console.WriteLine(result.Message.Content);
Console.ReadKey();
//var client = new MessageRequestClient<RequestMessage, ResponseMessage>(bus,
// address, timeout, timeout);
}
static void Main(string[] args)
{
Console.Title = "Saga";
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host, RabbitMqConstants.ArticleSagaQueue, e =>
{
e.StateMachineSaga(new ApproveArticleSaga(), new InMemorySagaRepository <ApproveArticleSagaState>());
e.StateMachineSaga(new DeleteArticleSaga(), new InMemorySagaRepository <DeleteArticleSagaState>());
e.StateMachineSaga(new DeleteCategorySaga(), new InMemorySagaRepository <DeleteCategorySagaState>());
e.StateMachineSaga(new DeleteCommentSaga(), new InMemorySagaRepository <DeleteCommentSagaState>());
e.StateMachineSaga(new InsertArticleSaga(), new InMemorySagaRepository <InsertArticleSagaState>());
e.StateMachineSaga(new InsertCommentSaga(), new InMemorySagaRepository <InsertCommentSagaState>());
e.StateMachineSaga(new RateArticleSaga(), new InMemorySagaRepository <RateArticleSagaState>());
e.StateMachineSaga(new UpdateArticleSaga(), new InMemorySagaRepository <UpdateArticleSagaState>());
e.StateMachineSaga(new UpdateCategorySaga(), new InMemorySagaRepository <UpdateCategorySagaState>());
e.StateMachineSaga(new UpdateCommentSaga(), new InMemorySagaRepository <UpdateCommentSagaState>());
});
});
bus.Start();
Console.WriteLine("Saga active.. Press enter to exit");
Console.ReadLine();
bus.Stop();
}
public void Start()
{
LogConfigurator.ConfigureForService();
Log.Information("Viaduc service is starting");
var containerBuilder = ContainerConfigurator.Configure();
BusConfigurator.ConfigureBus(containerBuilder, MonitoredServices.ViaducService, (cfg, ctx) =>
{
cfg.ReceiveEndpoint(BusConstants.ReadUserInformationQueue,
ec => { ec.Consumer(ctx.Resolve <ReadUserInformationConsumer>); }
);
cfg.ReceiveEndpoint(BusConstants.ReadStammdatenQueue,
ec => { ec.Consumer(ctx.Resolve <ReadStammdatenConsumer>); }
);
});
var container = containerBuilder.Build();
bus = container.Resolve <IBusControl>();
bus.Start();
Log.Information("Viaduc service started");
}
private static void RegisterBus(ContainerBuilder builder)
{
var helper = new ParameterBusHelper();
BusConfigurator.ConfigureBus(builder, MonitoredServices.VecteurService,
(cfg, ctx) => { helper.SubscribeAllSettingsInAssembly(Assembly.GetExecutingAssembly(), cfg); });
}
public async Task <IActionResult> Get()
{
StringBuilder responseMessageBuilder = new StringBuilder();
responseMessageBuilder.AppendLine("Gift Raffle is starting ! ");
responseMessageBuilder.AppendLine("Here is lucky employees; ");
var bus = BusConfigurator.ConfigureBus();
var sendToUri = new Uri($"{RabbitMQConstants.RabbitMqUri}{RabbitMQConstants.RabbitMqGiftRaffleQueueName}");
var endPoint = await bus.GetSendEndpoint(sendToUri);
const int LUCKY_EMPLOYEE_COUNT = 10000; //10k
for (int i = 0; i < LUCKY_EMPLOYEE_COUNT; i++)
{
var luckyEmployee = _fakeDataService.GetFakeFullName();
await endPoint.Send <IEmployee>(new
{
Name = luckyEmployee,
PhoneNumber = _fakeDataService.GetPhoneNumber(), // Due to fakedata lib does not any relation between name and number.
Email = _fakeDataService.GetEmailAddressByEmployeeName(luckyEmployee)
});
responseMessageBuilder.AppendLine($"{i+1}- {luckyEmployee}");
}
responseMessageBuilder.AppendLine("*************");
responseMessageBuilder.AppendLine("Email and SMS sent for them !");
return(Ok(responseMessageBuilder.ToString()));
}
static void Main(string[] args)
{
Console.Title = "Registration";
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(
RabbitMqConsts.RegisterDemandServiceQueue, e =>
{
e.Consumer <RegisterDemandCommandConsumer>();
e.UseCircuitBreaker(cb =>
{
cb.TrackingPeriod = TimeSpan.FromMinutes(1);
cb.TripThreshold = 15;
cb.ActiveThreshold = 10;
cb.ResetInterval = TimeSpan.FromMinutes(5);
});
});
});
bus.StartAsync();
Console.WriteLine("Listening for Register Demand commands.. " +
"Press enter to exit");
Console.ReadLine();
bus.StopAsync();
}
static void Main(string[] args)
{
Console.Title = "Inventory";
IUnityContainer container = CreateContainer();
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host, RabbitMqConstants.InventoryServiceQueue,
e =>
{
e.UseRetry(retryCfg => { retryCfg.Immediate(5); });
e.Consumer <ProductUpdatedEventConsumer>(container);
});
});
bus.ConnectConsumeObserver(new ConsumeObserver());
bus.ConnectPublishObserver(new PublishObserver());
bus.Start();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Inventory service started listening... Press [ENTER] to exit");
Console.ForegroundColor = ConsoleColor.Gray;
Console.ReadLine();
bus.Stop();
}
static void Main(string[] args)
{
Console.Title = "Consumer";
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(RabbitMqConsts.ExampleQueueName, e =>
{
e.Consumer <IExampleCommandConsumer>();
e.UseCircuitBreaker(cb =>
{
cb.TrackingPeriod = TimeSpan.FromMinutes(1);
cb.TripThreshold = 15;
cb.ActiveThreshold = 10;
cb.ResetInterval = TimeSpan.FromMinutes(5);
});
});
});
bus.StartAsync();
Console.WriteLine("Queue eritilmek için dinlenmekte. " + "Çıkmak için enter tuşuna basınız");
Console.ReadLine();
bus.StopAsync();
}
private void StartBus()
{
var helper = new ParameterBusHelper();
var containerBuilder = new ContainerBuilder();
BusConfigurator.ConfigureBus(containerBuilder, MonitoredServices.CacheService, (cfg, ctx) =>
{
cfg.ReceiveEndpoint(BusConstants.CacheDoesExistRequestQueue,
ec => { ec.Consumer(() => new DoesExistInCacheRequestConsumer()); });
cfg.ReceiveEndpoint(BusConstants.CacheConnectionInfoRequestQueue,
ec => { ec.Consumer(() => new CacheConnectionInfoRequestConsumer()); });
cfg.ReceiveEndpoint(BusConstants.CacheDeleteFile, ec =>
{
ec.Consumer(() => new DeleteFileFromCacheConsumer());
ec.UseRetry(BusConfigurator.ConfigureDefaultRetryPolicy);
});
helper.SubscribeAllSettingsInAssembly(Assembly.GetExecutingAssembly(), cfg);
});
var container = containerBuilder.Build();
Bus = container.Resolve <IBusControl>();
Bus.Start();
}
static void Main(string[] args)
{
try
{
//Set RabbitMQ properties
RabbitMqConfiguration.RabbitMqUri = "rabbitmq://localhost";
RabbitMqConfiguration.VirtualHost = "uservh";
RabbitMqConfiguration.UserName = "******";
RabbitMqConfiguration.Password = "******";
RabbitMqConfiguration.OAuthServiceQueue = "oauth.service";
RabbitMqConfiguration.Timeout = TimeSpan.FromSeconds(10);
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host, RabbitMqConfiguration.OAuthServiceQueue, e =>
{
//This consumer is fired when a request is sent from CreateUser method in UserController
e.Consumer <CreateUserCommandConsumer>();
});
});
TaskUtil.Await(() => bus.StartAsync());
Console.WriteLine("Receiver started ...");
}
catch (Exception e)
{
throw e;
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(
RabbitMqConsts.StudentRegisterServiceQueue, e =>
{
//Message yakalanýnca iþlem yapýcak consumer yazýlýr
e.Consumer <ConsumerStudent>();
e.UseCircuitBreaker(cb =>
{
//TripThreshold ile alýnan taleplerimizin %15'inde ve ActiveThreshold ile üst üste 10 hata alýndðýnda 5 dk beklemesi gerektiðini ResetInterval ile belirtiyoruz. TrackingPeriod ise ResetInterval süresinden sonra 1 dk daha tetikte beklemesi söylüyor. Bu sürede yine hata alýnýr ise ActiveThreshold ve TripThreshold limitlerini beklemeden yine 5 dk süre ile beklemeye geçecektir.
cb.TrackingPeriod = TimeSpan.FromMinutes(1);
cb.TripThreshold = 15;
cb.ActiveThreshold = 10;
cb.ResetInterval = TimeSpan.FromMinutes(5);
});
// RateLimit middlewere ile belirli süre içersinde iþlenecek mesaj adeti verebiliyoruz. Servise 1 dk içerisnde 1000 request yapabileceðimizi söyledik
//e.UseRateLimit(1000, TimeSpan.FromMinutes(1));
});
});
while (!stoppingToken.IsCancellationRequested)
{
await bus.StartAsync();
}
await bus.StopAsync();
}
static void Main(string[] args)
{
Console.Title = "Approver";
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(
RabbitMQConstants.RabbitMqGiftRaffleQueueName, e =>
{
e.Consumer <ApproverFinderConsumer>();
e.UseCircuitBreaker(cb =>
{
cb.TrackingPeriod = TimeSpan.FromMinutes(1);
cb.TripThreshold = 15;
cb.ActiveThreshold = 10;
cb.ResetInterval = TimeSpan.FromMinutes(5);
});
});
});
bus.StartAsync();
Console.WriteLine("Listening for Approvals ");
Console.ReadLine();
bus.StopAsync();
}
public void Start()
{
LogInformation("Notification service is starting");
// Configure Bus
bus = BusConfigurator.ConfigureBus(MonitoredServices.NotificationService, (cfg, host) =>
{
cfg.ReceiveEndpoint(BusConstants.NotificationManagerMessageQueue, ec =>
{
ec.Consumer(() => kernel.Get <EmailMessageConsumer>());
ec.UseRetry(retryPolicy =>
retryPolicy.Exponential(10, TimeSpan.FromSeconds(1), TimeSpan.FromMinutes(5), TimeSpan.FromSeconds(5)));
});
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();
PublishStartupTestMailIfNeccessary();
LogInformation("Notification service started");
}
private static void ConfigureServices(IServiceCollection serviceCollection)
{
//add logging
serviceCollection.AddSingleton(new LoggerFactory().AddConsole());
serviceCollection.AddLogging();
//add services
serviceCollection.AddTransient <IAppService, AppService>();
//MassTransit
var serviceBusSettings = new ServiceBusSettings
{
ServiceBusConnectionString = "",
ServiceBusKeyName = "",
ServiceBusSharedAccessKey = ""
};
serviceCollection.AddSingleton(provider => BusConfigurator.ConfigureBus(serviceBusSettings));
serviceCollection.AddSingleton <ISendEndpointProvider>(provider => provider.GetRequiredService <IBusControl>());
serviceCollection.AddSingleton <IPublishEndpoint>(provider => provider.GetRequiredService <IBusControl>());
serviceCollection.AddSingleton <IBus>(provider => provider.GetRequiredService <IBusControl>());
//add Services
serviceCollection.AddSingleton <IMassTransitService, MassTransitService>();
serviceCollection.AddTransient <IMessageSender, MessageSender>();
}
static BusHelper()
{
ParameterBus = BusConfigurator.ConfigureBus((cfg, host) =>
{
});
ParameterBus.Start();
}
public OrderStatusController()
{
var busControl = BusConfigurator.ConfigureBus();
var sendToUri = new Uri($"{RabbitMqConsts.RabbitMqUri}{RabbitMqConsts.OrderStatusServiceQueue}");
_bus = busControl.GetSendEndpoint(sendToUri).Result;
}
private static void Main(string[] args)
{
// Configure Bus
var bus = BusConfigurator.ConfigureBus(MonitoredServices.NotMonitored, (cfg, host) => { });
bus.Start();
var archiveRecordId = 30409399;
// Sending a testevent
var ep = bus.GetSendEndpoint(new Uri(bus.Address, BusConstants.DigitalisierungsAuftragErledigtEvent)).GetAwaiter().GetResult();
ep.Send <IDigitalisierungsAuftragErledigt>(new
{
ArchiveRecordId = archiveRecordId,
OrderItemId = 100,
OrderDate = DateTime.Now,
OrderUserId = "S51943653", // UserId Jörg
OrderUserRolePublicClient = "Oe3"
}).Wait();
// Wait until the obove message has been consumed
Thread.Sleep(10000);
// Now send a sync command, to initiate the second cyncle of the test
ep = bus.GetSendEndpoint(new Uri(bus.Address, BusConstants.HarvestManagerSyncArchiveRecordMessageQueue)).GetAwaiter().GetResult();
ep.Send <ISyncArchiveRecord>(new
{
MutationId = -1,
ArchiveRecordId = archiveRecordId,
Action = "Update"
}).Wait();
}
public bool Start(HostControl hostControl)
{
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host, RabbitMqConstants.RegisterOrderServiceQueue, e =>
{
cfg.UseNLog(new LogFactory());
e.UseRateLimit(1, TimeSpan.FromSeconds(30));
e.UseRetry(Retry.Interval(5, TimeSpan.FromSeconds(5)));
e.UseCircuitBreaker(cb =>
{
cb.TripThreshold = 15;
cb.ResetInterval(TimeSpan.FromMinutes(5));
cb.TrackingPeriod = TimeSpan.FromMinutes(1);
cb.ActiveThreshold = 10;
});
e.Consumer <OrderRegisteredConsumer>();
});
});
var consumeObserver = new LogConsumeObserver();
bus.ConnectConsumeObserver(consumeObserver);
_busHandle = bus.Start();
return(true);
}
public async Task TestMethod()
{
UserViewModel model =
new UserViewModel
{
FirstName = "Jan",
LastName = "Kowalski",
Address = "Street 23",
Age = 23,
IdNumber = 232323
};
var bus = BusConfigurator.ConfigureBus();
var sendToUri = new Uri($"{Constants.RabbitMqUri}" + $"{Constants.RegisterUserServiceQueue}");
var endPoint = await bus.GetSendEndpoint(sendToUri);
// no need to have a class implementing interface ( as we needed one during the implementation for rabbitmq
await endPoint.Send <IRegisterUserCommand>(
new
{
FirstName = model.FirstName,
LastName = model.LastName,
Address = model.Address,
Age = model.Age,
IdNumber = model.IdNumber
});
}
static void Main(string[] args)
{
Console.Title = "Enrollment service";
var builder = new ConfigurationBuilder();
IConfigurationRoot configuration = builder.Build();
var connectionString = configuration.GetConnectionString("Default");
var serviceProvider = new ServiceCollection()
.AddDbContext <OnlineCoursesContext>(options =>
{
options.UseSqlServer(connectionString);
})
.AddTransient <IDomainEventContext, OnlineCoursesContext>()
.AddTransient <IRepository <Course>, SqlRepository <Course, Guid> >()
.BuildServiceProvider();
var bus = BusConfigurator.ConfigureBus((cfg, host) =>
{
cfg.ReceiveEndpoint(host, RabbitMqConstants.EnrollStudentServiceQueue, e =>
{
e.Consumer <EnrollStudentCommandConsumer>();
});
});
bus.Start();
Console.WriteLine("Listening for commands.. Press enter to exit");
Console.ReadLine();
bus.Stop();
}
public void Start()
{
Log.Information($"{serviceName} is starting");
BusConfigurator.ConfigureBus(containerBuilder, MonitoredServices.DocumentConverterService, (cfg, ctx) =>
{
cfg.ReceiveEndpoint(BusConstants.DocumentConverterJobInitRequestQueue, ec =>
{
ec.Consumer(ctx.Resolve <JobInitConsumer>);
ec.UseRetry(BusConfigurator.ConfigureDefaultRetryPolicy);
});
cfg.ReceiveEndpoint(BusConstants.DocumentConverterConversionStartRequestQueue, ec =>
{
ec.Consumer(ctx.Resolve <ConversionStartConsumer>);
ec.UseRetry(BusConfigurator.ConfigureDefaultRetryPolicy);
BusConfigurator.SetPrefetchCountForEndpoint(ec);
});
cfg.ReceiveEndpoint(BusConstants.DocumentConverterExtractionStartRequestQueue, ec =>
{
ec.Consumer(ctx.Resolve <ExtractionStartConsumer>);
ec.UseRetry(BusConfigurator.ConfigureDefaultRetryPolicy);
BusConfigurator.SetPrefetchCountForEndpoint(ec);
});
cfg.ReceiveEndpoint(BusConstants.DocumentConverterSupportedFileTypesRequestQueue, ec =>
{
ec.Consumer(ctx.Resolve <SupportedFileTypesConsumer>);
ec.UseRetry(retry => retry.Incremental(3, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(0)));
});
cfg.ReceiveEndpoint(BusConstants.MonitoringDocumentConverterInfoQueue, ec =>
{
ec.Consumer(ctx.Resolve <DocumentConverterInfoConsumer>);
ec.PrefetchCount = 4;
});
cfg.ReceiveEndpoint(BusConstants.MonitoringAbbyyOcrTestQueue, ec =>
{
ec.Consumer(ctx.Resolve <AbbyyOcrTestConsumer>);
// Do not allow more than 4 concurrent Abbyy calls
ec.PrefetchCount = 4;
});
});
container = containerBuilder.Build();
bus = container.Resolve <IBusControl>();
bus.Start();
// Send event that document converter service is started
// Push an error message to indicate that the item has failed
bus.Publish <DocumentConverterServiceStartedEvent>(new
{
__TimeToLive = TimeSpan.FromSeconds(30),
StartTime = DateTime.Now
});
Log.Information($"{serviceName} started");
}
private void StartBus()
{
var helper = new ParameterBusHelper();
Bus = BusConfigurator.ConfigureBus(MonitoredServices.VecteurService,
(cfg, host) => { helper.SubscribeAllSettingsInAssembly(Assembly.GetExecutingAssembly(), cfg, host); });
Bus.Start();
}
public void Start()
{
BusConfigurator.ConfigureBus(builder, MonitoredServices.MonitoringService);
var container = builder.Build();
bus = container.Resolve <IBusControl>();
bus.Start();
}
public async Task <ISendEndpoint> GetEndPoint()
{
IBusControl bus = BusConfigurator.ConfigureBus();
Uri sendToUri = new Uri($"{RabbitMqConstants.RabbitMqUri}" + $"{RabbitMqConstants.ArticleSagaQueue}");
ISendEndpoint endPoint = await bus.GetSendEndpoint(sendToUri);
return(endPoint);
}
public PublisherStudent()
{
logger.Info("PublisherStudent dependency injection");
var bus = BusConfigurator.ConfigureBus();
var sendToUri = new Uri($"{RabbitMqConsts.RabbitMqUri}{RabbitMqConsts.StudentRegisterServiceQueue}");
endPoint = bus.GetSendEndpoint(sendToUri).Result;
}
