private void InitializeMessageBus()
{
Log4NetLogger.Use();
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
x.Host(GetDefaultRabbitMqBusUri(), h => { }));
_busHandle = _busControl.Start();
}
public void SetupSecondAzureServiceBusTestFixture()
{
_secondBus = CreateSecondBus();
_secondBusHandle = _secondBus.Start();
try
{
_secondBusSendEndpoint = Await(() => _secondBus.GetSendEndpoint(_secondBus.Address));
_secondInputQueueSendEndpoint = Await(() => _secondBus.GetSendEndpoint(_secondInputQueueAddress));
}
catch (Exception)
{
try
{
using (var tokenSource = new CancellationTokenSource(TestTimeout))
{
_secondBusHandle.Stop(tokenSource.Token);
}
}
finally
{
_secondBusHandle = null;
_secondBus = null;
}
throw;
}
}
public bool Start(HostControl hostControl)
{
_log.Info("Creating bus...");
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
IRabbitMqHost host = x.Host(new Uri(ConfigurationManager.AppSettings["RabbitMQHost"]), h =>
{
h.Username("guest");
h.Password("guest");
});
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["ServiceQueueName"],
e => { e.Consumer<RequestConsumer>(); });
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["ValidationAddress"],
e => { e.Consumer<ValidateConsumer>(); });
});
_log.Info("Starting bus...");
_busControl.Start();
return true;
}
public bool Start(HostControl hostControl)
{
_log.Info("Creating bus...");
_sagaRepository = GetSagaRepository();
ITrackingEventWriter writer = GetTrackingEventWriter();
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
var host = x.Host(GetHostAddress(), h =>
{
h.Username(ConfigurationManager.AppSettings["RabbitMQUsername"]);
h.Password(ConfigurationManager.AppSettings["RabbitMQPassword"]);
});
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["BookingStateQueueName"], e =>
{
e.StateMachineSaga(_stateMachine, _sagaRepository);
});
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["EventTrackingQueueName"], e =>
{
e.Consumer(() => new EventTrackingConsumer(writer));
});
});
_log.Info("Starting bus...");
_busHandle = _busControl.Start();
TaskUtil.Await(() => _busHandle.Ready);
return true;
}
protected void Application_Start()
{
var container = new Container();
HttpContext.Current.Application.Add("Container", container); // Add the container to the context so the ObjectFactory can use it later.
container.Configure(cfg =>
{
cfg.AddRegistry<ServiceRegistry>();
cfg.AddRegistry<LoggerRegistry>();
cfg.AddRegistry<MessagingRegistry>();
});
_busControl = MassTransitConfig.ConfigureBus(container);
container.Configure(cfg =>
{
cfg.For<IBusControl>().Use(_busControl);
cfg.Forward<IBus, IBusControl>(); // Doesn't seem to work
});
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
LoggingConfig.ConfigureLog4Net();
_busControl.Start();
}
public MassTransitPublisher()
{
Log4NetLogger.Use();
_bus = Bus.Factory.CreateUsingRabbitMq(x =>
x.Host(new Uri("rabbitmq://localhost/"), h => { }));
var busHandle = _bus.Start();
}
static MassTransitWithRabbitMQ()
{
_bus = Bus.Factory.CreateUsingRabbitMq(x =>
{
x.Host(new Uri(_baseurl), h =>
{
h.Username("iot");
h.Password("iot");
});
});
_handle = _bus.Start();
}
public bool Start(HostControl hostControl)
{
_settings = new Settings();
_fetchAvatarActivitySettings = new FetchAvatarSettings();
_log.Info("Creating bus...");
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
var host = x.Host(GetHostAddress(), h =>
{
h.Username(ConfigurationManager.AppSettings["RabbitMQUsername"]);
h.Password(ConfigurationManager.AppSettings["RabbitMQPassword"]);
});
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["BookMeetingQueueName"], e =>
{
e.Consumer(() =>
{
var handler = new BookingRequestHandler(_settings);
return new BookMeetingConsumer(handler);
});
});
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["FetchAvatarActivityQueue"], e =>
{
e.ExecuteActivityHost<FetchAvatarActivity, FetchAvatarArguments>(() => new FetchAvatarActivity(_fetchAvatarActivitySettings));
});
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["ReserveRoomCompensateQueue"], c =>
{
var compensateAddress = c.InputAddress;
c.ExecuteActivityHost<ReserveRoomActivity, ReserveRoomArguments>();
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["ReserveRoomExecuteQueue"], e =>
{
e.ExecuteActivityHost<ReserveRoomActivity, ReserveRoomArguments>(compensateAddress);
});
});
});
_log.Info("Starting bus...");
_busHandle = _busControl.Start();
TaskUtil.Await(() => _busHandle.Ready);
return true;
}
public void Start()
{
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
_host = x.Host(new Uri(_baseurl), h =>
{
h.Username("iot");
h.Password("iot");
});
x.ReceiveEndpoint(_host, "rest_requests", e => { e.Consumer<RequestConsumer>(); });
});
_busHandle = _busControl.Start();
}
public bool Start(HostControl hostControl)
{
_log.Info("Creating bus...");
_metrics = new RoutingSlipMetrics("Routing Slip");
_activityMetrics = new RoutingSlipMetrics("Validate Activity");
_machine = new RoutingSlipStateMachine();
_provider = new SQLiteSessionFactoryProvider(false, typeof(RoutingSlipStateSagaMap));
_sessionFactory = _provider.GetSessionFactory();
_repository = new NHibernateSagaRepository<RoutingSlipState>(_sessionFactory);
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
IRabbitMqHost host = x.Host(new Uri(ConfigurationManager.AppSettings["RabbitMQHost"]), h =>
{
h.Username("guest");
h.Password("guest");
});
x.ReceiveEndpoint(host, "routing_slip_metrics", e =>
{
e.PrefetchCount = 100;
e.UseRetry(Retry.None);
e.Consumer(() => new RoutingSlipMetricsConsumer(_metrics));
});
x.ReceiveEndpoint(host, "routing_slip_activity_metrics", e =>
{
e.PrefetchCount = 100;
e.UseRetry(Retry.None);
e.Consumer(() => new RoutingSlipActivityConsumer(_activityMetrics, "Validate"));
});
x.ReceiveEndpoint(host, "routing_slip_state", e =>
{
e.PrefetchCount = 8;
e.UseConcurrencyLimit(1);
e.StateMachineSaga(_machine, _repository);
});
});
_log.Info("Starting bus...");
_busHandle = _busControl.Start();
return true;
}
public void Start()
{
_container = CreateContainer();
_bus = CreateBus(_container);
_container.Inject(_bus);
_bus.Start();
var rdb = _container.GetInstance<ReadStoreDb>();
var wdb = _container.GetInstance<MyContext>();
rdb.Database.Initialize(true);
wdb.Database.Initialize(true);
Thread.Sleep(2000);
DoStuff();
}
public bool Start(HostControl hostControl)
{
int workerThreads;
int completionPortThreads;
ThreadPool.GetMinThreads(out workerThreads, out completionPortThreads);
Console.WriteLine("Min: {0}", workerThreads);
ThreadPool.SetMinThreads(200, completionPortThreads);
_log.Info("Creating bus...");
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
IRabbitMqHost host = x.Host(new Uri(ConfigurationManager.AppSettings["RabbitMQHost"]), h =>
{
h.Username("guest");
h.Password("guest");
});
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["ValidateActivityQueue"], e =>
{
e.PrefetchCount = 100;
e.ExecuteActivityHost<ValidateActivity, ValidateArguments>(
DefaultConstructorExecuteActivityFactory<ValidateActivity, ValidateArguments>.ExecuteFactory);
});
string compQueue = ConfigurationManager.AppSettings["CompensateRetrieveActivityQueue"];
Uri compAddress = host.Settings.GetQueueAddress(compQueue);
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["RetrieveActivityQueue"], e =>
{
e.PrefetchCount = 100;
// e.Retry(Retry.Selected<HttpRequestException>().Interval(5, TimeSpan.FromSeconds(1)));
e.ExecuteActivityHost<RetrieveActivity, RetrieveArguments>(compAddress);
});
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["CompensateRetrieveActivityQueue"],
e => e.CompensateActivityHost<RetrieveActivity, RetrieveLog>());
});
_log.Info("Starting bus...");
_busHandle = _busControl.Start();
return true;
}
public void GivenARunningBusThatIsListeningToABigTestMessageThatIsUsingMongoMessageDataRepository()
{
_busControl = Bus.Factory.CreateUsingInMemory(cfg =>
{
cfg.ReceiveEndpoint("test-" + new Guid().ToString(), ep =>
{
ep.Handler<BigTestMessage>((context) => { _bigTestMessages.Add(context.Message);
return Task.FromResult(0);
});
ep.UseMessageData<BigTestMessage>(MessageDataRepository.Instance);
});
});
_busHandle = _busControl.Start();
_busHandle.Ready.Wait();
}
public bool Start(HostControl hostControl)
{
_bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(new Uri("rabbitmq://localhost"), h =>
{
h.Username("guest");
h.Password("guest");
});
cfg.ReceiveEndpoint(host, "checkin", e => { e.Consumer<CheckinCommandConsumer>(); });
});
_bus.Start();
return true;
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
_bus = MassTransit.Bus.Factory.CreateUsingRabbitMq(x =>
{
x.Host(new Uri(ConfigurationManager.AppSettings["RabbitMQHost"]), h =>
{
h.Username("guest");
h.Password("guest");
});
});
_busHandle = _bus.Start();
}
public MassTransitBus(List<BusConsumer> consumers )
{
_configManager = new RequiredConfigManager();
_bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
cfg.Host(new Uri(_configManager.Get("Bus.Url")), h =>
{
h.Username(_configManager.Get("Bus.UserName"));
h.Password(_configManager.Get("Bus.Password"));
});
foreach (BusConsumer consumer in consumers)
{
cfg.ReceiveEndpoint(consumer.QueueName, consumer.ConsumerAction);
}
});
_bus.Start();
}
private void ConfigureServiceBus()
{
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
IRabbitMqHost host = x.Host(new Uri(ConfigurationManager.AppSettings["RabbitMQHost"]), h =>
{
h.Username(ConfigurationManager.AppSettings["RabbitMQUser"]);
h.Password(ConfigurationManager.AppSettings["RabbitMQPassword"]);
});
x.ReceiveEndpoint(host, "clearing", e =>
{
e.Durable = true;
e.StateMachineSaga(_machine, _repository.Value);
e.UseConsoleLog(async (ev, lc) => string.Format("Received message Id:{0} of type: {1}", ev.MessageId, string.Join(",",ev.SupportedMessageTypes)));
});
});
_busHandle = _busControl.Start();
}
public void SetupSecondAzureServiceBusTestFixture()
{
_secondBus = CreateSecondBus();
_secondBusHandle = _secondBus.Start();
try
{
_secondBusSendEndpoint = Await(() => _secondBus.GetSendEndpoint(_secondBus.Address));
_secondInputQueueSendEndpoint = Await(() => _secondBus.GetSendEndpoint(_secondInputQueueAddress));
}
catch (Exception ex)
{
Console.WriteLine("The bus creation failed: {0}", ex);
_secondBusHandle.Stop();
throw;
}
}
public bool Start(HostControl hostControl)
{
NLogLogger.Use();
var container = new Container(cfg =>
{
// register each consumer
cfg.ForConcreteType<SimpleRequestConsumer>();
cfg.ForConcreteType<ComplexRequestConsumer>();
cfg.ForConcreteType<MessageRequestConsumer>();
//or use StructureMap's excellent scanning capabilities
});
Console.WriteLine("Creating bus...");
_log.Info("Creating bus");
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
IRabbitMqHost host = x.Host(new Uri("rabbitmq://localhost/"), h =>
{
h.Username("guest");
h.Password("guest");
});
x.UseNLog();
x.AutoDelete = true;
x.ReceiveEndpoint(host, "request_service", ec => { ec.LoadFrom(container); });
});
//container.Configure(cfg =>
//{
// cfg.For<IBusControl>().Use(_busControl);
// cfg.Forward<IBus, IBusControl>();
//});
Console.WriteLine("Starting bus...");
_busControl.Start();
return true;
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
_bus = MassTransit.Bus.Factory.CreateUsingRabbitMq(x =>
{
x.Host(GetHostAddress(), h =>
{
h.Username(ConfigurationManager.AppSettings["RabbitMQUsername"]);
h.Password(ConfigurationManager.AppSettings["RabbitMQPassword"]);
});
});
_busHandle = _bus.Start();
TaskUtil.Await(() => _busHandle.Ready);
}
public void Start()
{
try
{
var busConfig = ServiceBusConfig.LoadFromConfig();
var container = new WindsorContainer().Install(FromAssembly.This());
RegisterTypes(container);
logger.Trace(string.Format("Connecting to RabbitMQ at endpoint {0}", busConfig.EndpointAddress));
_bus = Bus.Factory.CreateUsingRabbitMq(busControl =>
{
var host = busControl.Host(new Uri(busConfig.EndpointAddress), h =>
{
h.Username(busConfig.RabbitMqUserName);
h.Password(busConfig.RabbitMqPassword);
});
busControl.UseRetry(Retry.Immediate(5));
// If queue name isn't specified, an auto-delete queue will be created
if (string.IsNullOrEmpty(busConfig.QueueName))
{
busControl.ReceiveEndpoint(host, x => x.LoadFrom(container));
}
else
{
busControl.ReceiveEndpoint(host, busConfig.QueueName, x => x.LoadFrom(container));
logger.Trace(string.Format("Connecting to RabbitMQ queue {0}", busConfig.QueueName));
}
});
_bus.Start();
}
catch (Exception e)
{
logger.Error(e.ToString);
throw;
}
}
public bool Start(HostControl hostControl)
{
if (_log.IsInfoEnabled)
_log.InfoFormat("Creating bus for hosted service: {0}", _serviceName);
try
{
_busControl = _hostBusFactory.CreateBus(_serviceConfigurator, _serviceName);
_busHandle = _busControl.Start();
if (_log.IsInfoEnabled)
_log.InfoFormat("Created bus for hosted service: {0}", _serviceName);
return true;
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
_log.Error($"Creating bus for hosted service: {_serviceName}", ex);
throw;
}
}
public BusTestScenario(TimeSpan timeout, IBusControl busControl)
{
_timeout = timeout;
_busControl = busControl;
Received = new ReceivedMessageList(timeout);
_skipped = new ReceivedMessageList(timeout);
_published = new PublishedMessageList(timeout);
_tokenSource = new CancellationTokenSource(timeout);
CancellationToken = _tokenSource.Token;
var testSendObserver = new TestSendObserver(timeout);
Sent = testSendObserver.Messages;
_subjectSendEndpoint = GetSendEndpoint(testSendObserver);
var consumeObserver = new TestConsumeObserver(timeout);
Received = consumeObserver.Messages;
busControl.ConnectConsumeObserver(consumeObserver);
_busHandle = _busControl.Start();
}
//public void SendBusPing()
//{
// _bus.Publish<IOrderStartedEvent>(new CreateOrderMessage()
// {
// Email = "hello" + DateTime.Now.ToFileTimeUtc().ToString(),
// Timestamp = DateTime.Now,
// UserName = "******" + DateTime.Now.ToFileTimeUtc().ToString()
// });
// //_bus.Publish<IOrderStartedEvent>(new CreateOrderMessage());
//}
protected void Init()
{
Console.WriteLine("Bus init ... ");
// MessagingFactory factory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, string.Empty), _credentials);
//_basketEventsQueue = !_namespaceClient.QueueExists("BasketsQueue") ? _namespaceClient.CreateQueue("BasketsQueue") : _namespaceClient.GetQueue("BasketsQueue");
//_topic = !_namespaceClient.TopicExists("BasketsTopic") ? _namespaceClient.CreateTopic("BasketsTopic") : _namespaceClient.GetTopic("BasketsTopic");
//_queueClient = factory.CreateQueueClient("BasketsQueue");
_machine = new BasketStateMachine();
_bus = Bus.Factory.CreateUsingAzureServiceBus(bus =>
{
var busHost = bus.Host(new Uri("sb://dominosbasket.servicebus.windows.net"), host =>
{
host.OperationTimeout = TimeSpan.FromSeconds(20);
host.TokenProvider = _credentials;
});
//bus.UseMessageScheduler();
//var queue = busHost.GetQueuePath(new QueueDescription("BasketsQueue") {});
bus.ReceiveEndpoint(busHost, "basketevents", e =>
{
//e.Handler<IOrderStartedEvent>(o=>
// {
// Console.WriteLine("received");
// return Task.FromResult(o);
// });
e.PrefetchCount = 8;
e.StateMachineSaga(_machine, _repository.Value);
});
bus.UseInMemoryScheduler();
bus.UsePublishMessageScheduler();
//bus.ReceiveEndpoint(busHost, "quartz", e =>
//{
// bus.UseMessageScheduler(e.InputAddress);
// e.PrefetchCount = 1;
// e.Consumer(() => new ScheduleMessageConsumer(_scheduler));
// e.Consumer(() => new CancelScheduledMessageConsumer(_scheduler));
//});
//bus.UsePublishMessageScheduler();
//bus.UseInMemoryScheduler();
_scheduler.Start();
// cfg
//bus.ReceiveEndpoint(busHost, "my-srv1",
// conf =>
// {
// conf.Consumer(componentContext.Resolve<Func<Notify1Consumer>>());
// });
//bus.UseServiceBusMessageScheduler();
// bus.UseMessageScheduler();
//bus.UseInMemoryMessageScheduler();
//_scheduler.Start();
//bus.ReceiveEndpoint(busHost, "quartz", e =>
//{
// bus.UseMessageScheduler(e.InputAddress);
// e.PrefetchCount = 2;
// e.Consumer(() => new ScheduleMessageConsumer(_scheduler));
// e.Consumer(() => new CancelScheduledMessageConsumer(_scheduler));
//});
});
_bus.Start();
//_bus.Publish<IOrderStartedEvent>(new CreateOrderMessage());
//{
// Email = "thierry"
//})
//_bus.Send<IOrderStartedEvent>(new CreateOrderMessage()
//{
// Email = "thierry"
//}).Wait();
Console.WriteLine("Bus ready");
// Once the machine and repository are declared, the receive endpoint is declared on the bus configuration.
//_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
//{
// IRabbitMqHost host = x.Host(...);
// x.ReceiveEndpoint(host, "shopping_cart_state", e =>
// {
// e.PrefetchCount = 8;
// e.StateMachineSaga(_machine, _repository.Value);
// });
// x.ReceiveEndpoint(host, "scheduler", e =>
// {
// x.UseMessageScheduler(e.InputAddress);
// e.PrefetchCount = 1;
// e.Consumer(() => new ScheduleMessageConsumer(_scheduler));
// e.Consumer(() => new CancelScheduledMessageConsumer(_scheduler));
// });
//});
}
/// <summary>
/// Starts the Order Service.
/// Called by the service host when the service is started.
/// </summary>
public void Start()
{
Log.Information("Order service is starting");
// Configure Bus
var helper = new ParameterBusHelper();
bus = BusConfigurator.ConfigureBus(MonitoredServices.OrderService, (cfg, host) =>
{
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(AddToBasketRequest)),
ec => { ec.Consumer(() => kernel.Get <SimpleConsumer <AddToBasketRequest, AddToBasketResponse, IPublicOrder> >()); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerFindOrderItemsRequestQueue,
ec => { ec.Consumer(() => new FindOrderItemsRequestConsumer(kernel.Get <IPublicOrder>())); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerGetStatusHistoryForOrderItemRequestQueue,
ec => { ec.Consumer(() => new GetStatusHistoryForOrderItemConsumer(kernel.Get <IPublicOrder>())); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerFindOrderingHistoryForVeRequestQueue,
ec => { ec.Consumer(() => new FindOrderHistoryForVeConsumer(kernel.Get <IPublicOrder>())); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerGetOrderingRequestQueue,
ec => { ec.Consumer(() => new GetOrderingRequestConsumer(kernel.Get <IPublicOrder>())); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerUpdateOrderDetailRequestQueue,
ec => { ec.Consumer(() => new UpdateOrderDetailRequestConsumer(kernel.Get <IPublicOrder>())); });
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(AddToBasketCustomRequest)),
ec => { ec.Consumer(() => kernel.Get <SimpleConsumer <AddToBasketCustomRequest, AddToBasketCustomResponse, IPublicOrder> >()); });
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(RemoveFromBasketRequest)),
ec => { ec.Consumer(() => kernel.Get <SimpleConsumer <RemoveFromBasketRequest, RemoveFromBasketResponse, IPublicOrder> >()); });
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(UpdateCommentRequest)),
ec => { ec.Consumer(() => kernel.Get <SimpleConsumer <UpdateCommentRequest, UpdateCommentResponse, IPublicOrder> >()); });
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(UpdateBenutzungskopieRequest)),
ec =>
{
ec.Consumer(() => kernel.Get <SimpleConsumer <UpdateBenutzungskopieRequest, UpdateBenutzungskopieResponse, IPublicOrder> >());
});
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(UpdateBewilligungsDatumRequest)),
ec =>
{
ec.Consumer(() =>
kernel.Get <SimpleConsumer <UpdateBewilligungsDatumRequest, UpdateBewilligungsDatumResponse, IPublicOrder> >());
});
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(UpdateReasonRequest)),
ec => { ec.Consumer(() => kernel.Get <SimpleConsumer <UpdateReasonRequest, UpdateReasonResponse, IPublicOrder> >()); });
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(OrderCreationRequest)),
ec => { ec.Consumer(() => kernel.Get <CreateOrderFromBasketRequestConsumer>()); });
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(GetBasketRequest)),
ec => { ec.Consumer(() => kernel.Get <SimpleConsumer <GetBasketRequest, GetBasketResponse, IPublicOrder> >()); });
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(GetOrderingsRequest)),
ec => { ec.Consumer(() => kernel.Get <SimpleConsumer <GetOrderingsRequest, GetOrderingsResponse, IPublicOrder> >()); });
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(IsUniqueVeInBasketRequest)),
ec => { ec.Consumer(() => kernel.Get <SimpleConsumer <IsUniqueVeInBasketRequest, IsUniqueVeInBasketResponse, IPublicOrder> >()); });
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(GetDigipoolRequest)),
ec => { ec.Consumer(() => kernel.Get <SimpleConsumer <GetDigipoolRequest, GetDigipoolResponse, IPublicOrder> >()); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerSetStatusAushebungBereitRequestQueue,
ec => { ec.Consumer(() => kernel.Get <SetStatusAushebungBereitConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerSetStatusDigitalisierungExternRequestQueue,
ec => { ec.Consumer(() => kernel.Get <SetStatusDigitalisierungExternConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerSetStatusDigitalisierungAbgebrochenRequestQueue,
ec => { ec.Consumer(() => kernel.Get <SetStatusDigitalisierungAbgebrochenConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerSetStatusZumReponierenBereitRequestQueue,
ec => { ec.Consumer(() => kernel.Get <SetStatusZumReponierenBereitConsumer>()); });
cfg.ReceiveEndpoint(string.Format(BusConstants.OrderManagagerRequestBase, nameof(UpdateDigipoolRequest)),
ec => { ec.Consumer(() => kernel.Get <SimpleConsumer <UpdateDigipoolRequest, UpdateDigipoolResponse, IPublicOrder> >()); });
cfg.ReceiveEndpoint(BusConstants.EntscheidFreigabeHinterlegenRequestQueue,
ec => { ec.Consumer(() => kernel.Get <EntscheidFreigabeHinterlegenRequestConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.EntscheidGesuchHinterlegenRequestQueue,
ec => { ec.Consumer(() => kernel.Get <EntscheidGesuchHinterlegenRequestConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.InVorlageExportierenRequestQueue,
ec => { ec.Consumer(() => kernel.Get <InVorlageExportierenRequestConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.ReponierenRequestQueue,
ec => { ec.Consumer(() => kernel.Get <SetStatusZumReponierenBereitConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.AbschliessenRequestQueue, ec => { ec.Consumer(() => kernel.Get <AbschliessenRequestConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.AbbrechenRequestQueue, ec => { ec.Consumer(() => kernel.Get <AbbrechenRequestConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.ZuruecksetzenRequestQueue, ec => { ec.Consumer(() => kernel.Get <ZuruecksetzenRequestConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.AuftraegeAusleihenRequestQueue,
ec => { ec.Consumer(() => kernel.Get <AuftraegeAusleihenRequestConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.AushebungsauftraegeDruckenRequestQueue,
ec => { ec.Consumer(() => kernel.Get <AushebungsauftraegeDruckenRequestConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.RecalcIndivTokens, ec => { ec.Consumer(() => kernel.Get <RecalcIndivTokensConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.DigitalisierungAusloesenRequestQueue,
ec => { ec.Consumer(() => kernel.Get <DigitalisierungAusloesenRequestConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.DigitalisierungsAuftragErledigtEvent, ec =>
{
ec.Consumer(() => kernel.Get <DigitalisierungsAuftragErledigtConsumer>());
ec.UseRetry(BusConfigurator.ConfigureDefaultRetryPolicy);
});
cfg.ReceiveEndpoint(BusConstants.OrderManagerArchiveRecordUpdatedEventQueue, ec =>
{
ec.Consumer(() => kernel.Get <ArchiveRecordUpdatedConsumer>());
ec.UseRetry(BusConfigurator.ConfigureDefaultRetryPolicy);
});
cfg.ReceiveEndpoint(BusConstants.DigitalisierungsAuftragErledigtEventError,
ec => { ec.Consumer(() => kernel.Get <DigitalisierungsAuftragErledigtErrorConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.BenutzungskopieAuftragErledigtEvent, ec =>
{
ec.Consumer(() => kernel.Get <BenutzungskopieAuftragErledigtConsumer>());
// Wenn Vecteur meldet, dass Auftrag erledigt ist, kann es sein, dass die Daten eventuell noch nicht in den SFTP hochgeladen wurden.
// Der Consumer löst in diesem Fall eine Exception aus. Durch den Retry versuchen wir es noch ein paar mal
#if DEBUG
ec.UseRetry(retryPolicy => retryPolicy.Interval(5, TimeSpan.FromSeconds(2)));
#else
ec.UseRetry(retryPolicy => retryPolicy.Interval(10, TimeSpan.FromMinutes(30)));
#endif
});
cfg.ReceiveEndpoint(BusConstants.BenutzungskopieAuftragErledigtEventError,
ec => { ec.Consumer(() => kernel.Get <BenutzungskopieAuftragErledigtErrorConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerAssetReadyEventQueue, ec => { ec.Consumer(() => kernel.Get <AssetReadyConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerMarkOrderAsFaultedQueue,
ec => { ec.Consumer(() => kernel.Get <SimpleConsumer <MarkOrderAsFaultedRequest, MarkOrderAsFaultedResponse, OrderManager> >()); });
cfg.ReceiveEndpoint(BusConstants.OrderManagerResetFaultedOrdersQueue,
ec =>
{
ec.Consumer(() =>
kernel.Get <SimpleConsumer <ResetAufbereitungsfehlerRequest, ResetAufbereitungsfehlerResponse, OrderManager> >());
});
cfg.ReceiveEndpoint(BusConstants.OrderManagerMahnungVersendenRequestQueue,
ec => { ec.Consumer(() => kernel.Get <MahnungVersendenRequestConsumer>()); });
helper.SubscribeAllSettingsInAssembly(Assembly.GetExecutingAssembly(), cfg, host);
cfg.UseSerilog();
});
// Add the bus instance to the IoC container
kernel.Bind <IBus>().ToMethod(context => bus).InSingletonScope();
kernel.Bind <IBusControl>().ToMethod(context => bus).InSingletonScope();
kernel.Bind <IRequestClient <FindArchiveRecordRequest, FindArchiveRecordResponse> >()
.ToMethod(CreateFindArchiveRecordRequestClient);
bus.Start();
recalcTermineListener.Start();
Log.Information("Order service started");
}
public void SetupAzureServiceBusTestFixture()
{
_bus = CreateBus();
_bus.ConnectReceiveEndpointObserver(new ReceiveEndpointObserver());
_busHandle = _bus.Start();
try
{
Await(() => _busHandle.Ready);
_busSendEndpoint = _bus.GetSendEndpoint(_bus.Address).Result;
_busSendEndpoint.ConnectSendObserver(_sendObserver);
_inputQueueSendEndpoint = _bus.GetSendEndpoint(_inputQueueAddress).Result;
_inputQueueSendEndpoint.ConnectSendObserver(_sendObserver);
}
catch (Exception ex)
{
Console.WriteLine("The bus creation failed: {0}", ex);
_busHandle.Stop();
throw;
}
}
public void Start()
{
_busControl = _messageBus.Create();
_busControl.Start();
}
static void Main(string[] args)
{
string rabbitMqAddress = "rabbitmq://localhost:5672";
string virtualHost = "/";
string rabbitMqQueue = "StayWell.SWIQ.CreateParticipant";
Uri rabbitMqRootUri = new Uri(string.Concat(rabbitMqAddress, virtualHost));
IBusControl rabbitBusControl = Bus.Factory.CreateUsingRabbitMq(rabbit =>
{
rabbit.Host(rabbitMqRootUri, settings =>
{
settings.Password("guest");
settings.Username("guest");
});
});
rabbitBusControl.Start();
Task <ISendEndpoint> sendEndpointTask = rabbitBusControl.GetSendEndpoint(new Uri(string.Concat(rabbitMqAddress, virtualHost, rabbitMqQueue)));
ISendEndpoint sendEndpoint = sendEndpointTask.Result;
do
{
Console.WriteLine("Enter message type ('command', 'event', 'rpc') (or 'quit' to exit)");
Console.Write("> ");
string type = Console.ReadLine();
if ("quit".Equals(type, StringComparison.OrdinalIgnoreCase))
{
break;
}
Console.WriteLine("Enter data");
Console.Write("> ");
string data = Console.ReadLine();
if (type.ToLower() == "command")
{
sendEndpoint.Send <ICreateParticipant>(new
{
CreationDate = DateTime.UtcNow,
Data = data
});
}
else if (type.ToLower() == "event")
{
rabbitBusControl.Publish <IParticipantUpdated>(new
{
DateUpdated = DateTime.UtcNow,
FirstName = data
});
}
else if (type.ToLower() == "rpc")
{
IRequestClient <ICreateParticipant, ICreateParticipantResponse> client =
rabbitBusControl.CreateRequestClient <ICreateParticipant, ICreateParticipantResponse>(new Uri(string.Concat(rabbitMqAddress, virtualHost, rabbitMqQueue)), TimeSpan.FromSeconds(10));
Task.Run(async() =>
{
ICreateParticipantResponse response = await client.Request(new CreateParticipant
{
CreationDate = DateTime.UtcNow,
Data = data
});
Console.WriteLine("Participant creation response: ParticipantId: {0}, Data: {1}", response.ParticipantId, response.Data);
}).Wait();
}
else
{
Console.WriteLine("Wrong message type!");
Console.Write("> ");
}
}while (true);
rabbitBusControl.Stop();
}
public bool Start(HostControl hostControl)
{
Log.Information($"Service {Name} v.{Version} starting...");
Log.Information($"Name: {Name}");
Log.Information($"Title: {Title}");
Log.Information($"Description: {Description}");
Log.Information($"Version: {Version}");
var builder = new ContainerBuilder();
builder.Register(c => new GridFsStorage(
Environment.ExpandEnvironmentVariables(ConfigurationManager.AppSettings["OsdrConnectionSettings:ConnectionString"]),
ConfigurationManager.AppSettings["OsdrConnectionSettings:DatabaseName"]
)).As <IBlobStorage>();
builder.RegisterModule <Sds.Cvsp.Compounds.Autofac.PropertiesCalculationModule>();
builder.RegisterConsumers(Assembly.GetExecutingAssembly());
builder.Register(context =>
{
var busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var mtSettings = ConfigurationManager.AppSettings.MassTransitSettings();
var host = cfg.Host(new Uri(Environment.ExpandEnvironmentVariables(mtSettings.ConnectionString)), h => { });
cfg.RegisterConsumer <ChemicalPropertiesCommandHandler>(host, context, e =>
{
e.PrefetchCount = mtSettings.PrefetchCount;
});
cfg.UseConcurrencyLimit(mtSettings.ConcurrencyLimit);
});
return(busControl);
})
.SingleInstance()
.As <IBusControl>()
.As <IBus>();
var container = builder.Build();
ServiceLocator.SetLocatorProvider(() => new AutofacServiceLocator(container));
BusControl = container.Resolve <IBusControl>();
BusControl.ConnectPublishObserver(new PublishObserver());
BusControl.ConnectConsumeObserver(new ConsumeObserver());
BusControl.Start();
if (int.TryParse(ConfigurationManager.AppSettings["HeartBeat:TcpPort"], out int port))
{
Heartbeat.TcpPortListener.Start(port);
}
Log.Information($"Service {Name} v.{Version} started");
return(true);
}
public static void StartBus(IContainer container)
{
bus = container.Resolve <IBusControl>();
bus.Start();
Log.Information("CMI.Web.Management bus service started");
}
private void buttonConnect_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(textBoxQueueName.Text))
{
MessageBox.Show("Имя очереди незаполнено", "", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
if (comboBoxContarcts.SelectedIndex == -1)
{
MessageBox.Show("Контракт не выбран", "", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
if (_busControl != null)
{
IsConnected = false;
_busControl.Stop();
_busControl = null;
return;
}
IsConnected = true;
var s = Properties.Settings.Default;
switch (comboBoxContarcts.SelectedIndex)
{
case 0:
{
_busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(s.Url, s.VHost, h =>
{
h.Username(s.User);
h.Password(s.Password);
});
cfg.ReceiveEndpoint(host, textBoxQueueName.Text, c => c.Consumer <MessageContractConsumer>());
});
_busControl.Start();
break;
}
case 1:
{
_busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(s.Url, s.VHost, h =>
{
h.Username(s.User);
h.Password(s.Password);
});
cfg.ReceiveEndpoint(host, textBoxQueueName.Text, c => c.Consumer <SormoNewCaseContractConsumer>());
});
_busControl.Start();
break;
}
case 2:
{
_busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(s.Url, s.VHost, h =>
{
h.Username(s.User);
h.Password(s.Password);
});
cfg.ReceiveEndpoint(host, textBoxQueueName.Text, c => c.Consumer <DliFedNewResultConsumer>());
});
_busControl.Start();
break;
}
case 3:
{
_busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(s.Url, s.VHost, h =>
{
h.Username(s.User);
h.Password(s.Password);
});
cfg.ReceiveEndpoint(host, textBoxQueueName.Text, c => c.Consumer <DliMsgNewResultConsumer>());
});
_busControl.Start();
break;
}
}
}
public void Start()
{
_busControl.Start();
}
static void Main()
{
Dictionary <string, UnityContainer> unityContainer = new Dictionary <string, UnityContainer>();
List <ConsumerParam> consumerList = new List <ConsumerParam>();
foreach (ConsumerParam item in ConsumerManager.instance.ConsumerParams)
{
consumerList.Add(item);
}
//此处没有对消息队列名称进行去重
var queue_name_list = consumerList.Where(w => !string.IsNullOrEmpty(w.QueueName)).ToList();
foreach (var q in queue_name_list)
{
var result = consumerList.Where(w => w.QueueName.Equals(q.QueueName)).ToList();
if (result != null)
{
var uc = new UnityContainer();
foreach (var item in result)
{
Type t = Type.GetType(item.classname);
uc.RegisterType(typeof(IConsumer <>), t, item.Name);
}
unityContainer.Add(q.QueueName, uc);
}
}
var container = new UnityContainer();
//消息总线
IBusControl _busControl = MassTransitRabbitMQ.instance.CreateBus(
(cfg, host) =>
{
//cfg.ReceiveEndpoint(host, "Camera", configure =>
//{
// // configure.LoadFrom(item.Value);
// configure.Consumer<CameraMessageConsumer>();
//});
//cfg.ReceiveEndpoint(host, "TruckScaleData", configure =>
//{
// // configure.LoadFrom(item.Value);
// configure.Consumer<TruckScaleDataProvideMessageConsumer>();
//});
foreach (var item in unityContainer)
{
cfg.ReceiveEndpoint(host, item.Key, configure =>
{
configure.LoadFrom(item.Value);
});
}
});
_busControl.Start();
RabbitMQMessageTransferUtil transferUtil = new RabbitMQMessageTransferUtil();
container.RegisterInstance(transferUtil, new ContainerControlledLifetimeManager());
container.RegisterInstance(_busControl, new ContainerControlledLifetimeManager());
container.RegisterInstance <IBus>(_busControl, new ContainerControlledLifetimeManager());
IocManager.Initialize(new UnityDependencyResolver(container));
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new frmMqServer());
}
public void StartBus()
{
busControl = this.CreateBus();
busControl.Start();
}
public static void Start(this ICoolBrainsServiceBuilder builder)
{
Initialize();
_busControl.Start();
}
static void Main()
{
var consumerContainer = new UnityContainer();
foreach (ConsumerParam item in ConsumerManager.instance.ConsumerParams)
{
Type t = Type.GetType(item.classname);
consumerContainer.RegisterType(typeof(IConsumer <>), t, item.Name);
}
var container = new UnityContainer();
//死信对列绑定配置
var bus = MassTransitRabbitMQ.instance.CreateBus(
(cfg, host) =>
{
cfg.ReceiveEndpoint(host, "myQueue", x =>
{
x.BindDeadLetterQueue("myQueue-Dead-Letter");
x.Consumer <PrintMessageConsumer>();
});
cfg.ReceiveEndpoint(host, "myQueue10", x =>
{
x.BindDeadLetterQueue("myQueue10-Dead-Letter");
x.Consumer <Print10MessageConsumer>();
});
});
bus.Start();
bus.Stop();
//消息总线
//建议每个死信队列单独配置一个Endpoint
IBusControl _busControl = MassTransitRabbitMQ.instance.CreateBus(
(cfg, host) =>
{
//配置死信队列
cfg.ReceiveEndpoint(host, "myQueue-Dead-Letter", x =>
{
x.BindMessageExchanges = false;
x.Consumer <PrintMessageConsumer>();
});
//配置死信队列
cfg.ReceiveEndpoint(host, "myQueue10-Dead-Letter", x =>
{
x.BindMessageExchanges = false;
x.Consumer <Print10MessageConsumer>();
});
});
_busControl.Start();
RabbitMQMessageTransferUtil transferUtil = new RabbitMQMessageTransferUtil();
container.RegisterInstance(transferUtil, new ContainerControlledLifetimeManager());
container.RegisterInstance(_busControl, new ContainerControlledLifetimeManager());
container.RegisterInstance <IBus>(_busControl, new ContainerControlledLifetimeManager());
IocManager.Initialize(new UnityDependencyResolver(container));
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new frmMqClient());
}
public bool Start(HostControl hostControl)
{
_bus.Start();
return(true);
}
/// <summary>
/// Starts the Asset Service.
/// Called by the service host when the service is started.
/// </summary>
public async Task Start()
{
Log.Information("Asset service is starting");
scheduler = await SchedulerConfigurator.Configure(kernel);
EnsurePasswordSeedIsConfigured();
// Configure Bus
var helper = new ParameterBusHelper();
bus = BusConfigurator.ConfigureBus(MonitoredServices.AssetService, (cfg, host) =>
{
cfg.ReceiveEndpoint(BusConstants.AssetManagerExtractFulltextMessageQueue, ec =>
{
ec.Consumer(() => kernel.Get <ExtractFulltextPackageConsumer>());
ec.UseRetry(retryPolicy =>
retryPolicy.Exponential(10, TimeSpan.FromSeconds(1), TimeSpan.FromMinutes(5), TimeSpan.FromSeconds(5)));
BusConfigurator.SetPrefetchCountForEndpoint(ec);
});
cfg.ReceiveEndpoint(BusConstants.AssetManagerTransformAssetMessageQueue,
ec =>
{
ec.Consumer(() => kernel.Get <TransformPackageConsumer>());
BusConfigurator.SetPrefetchCountForEndpoint(ec);
});
cfg.ReceiveEndpoint(BusConstants.WebApiDownloadAssetRequestQueue, ec => { ec.Consumer(() => kernel.Get <DownloadAssetConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.WebApiGetAssetStatusRequestQueue,
ec => { ec.Consumer(() => kernel.Get <GetAssetStatusConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.WebApiPrepareAssetRequestQueue, ec => { ec.Consumer(() => kernel.Get <PrepareAssetConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.AssetManagerAssetReadyEventQueue, ec =>
{
ec.Consumer(() => kernel.Get <AssetReadyConsumer>());
// Retry or we have the situation where the job is not marked as terminated in the DB.
ec.UseRetry(retryPolicy =>
retryPolicy.Exponential(10, TimeSpan.FromSeconds(1), TimeSpan.FromMinutes(5), TimeSpan.FromSeconds(5)));
});
cfg.ReceiveEndpoint(BusConstants.MonitoringAbbyyOcrTestQueue, ec => { ec.Consumer(() => kernel.Get <AbbyyOcrTestConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.AssetManagerSchdeduleForPackageSyncMessageQueue,
ec => { ec.Consumer(() => kernel.Get <ScheduleForPackageSyncConsumer>()); });
cfg.ReceiveEndpoint(BusConstants.AssetManagerUpdatePrimaerdatenAuftragStatusMessageQueue,
ec => { ec.Consumer(() => kernel.Get <UpdatePrimaerdatenAuftragStatusConsumer>()); });
helper.SubscribeAllSettingsInAssembly(Assembly.GetExecutingAssembly(), cfg, host);
cfg.UseSerilog();
});
// Add the bus instance to the IoC container
kernel.Bind <IBus>().ToMethod(context => bus).InSingletonScope();
kernel.Bind <IBusControl>().ToMethod(context => bus).InSingletonScope();
kernel.Bind <IRequestClient <DoesExistInCacheRequest, DoesExistInCacheResponse> >().ToMethod(CreateDoesExistInCacheRequestClient);
kernel.Bind <IRequestClient <JobInitRequest, JobInitResult> >().ToMethod(CreateJobInitRequestClient);
kernel.Bind <IRequestClient <SupportedFileTypesRequest, SupportedFileTypesResponse> >().ToMethod(CreateSupportedFileTypesRequestClient);
kernel.Bind <IRequestClient <ConversionStartRequest, ConversionStartResult> >().ToMethod(CreateDocumentConversionRequestClient);
kernel.Bind <IRequestClient <ExtractionStartRequest, ExtractionStartResult> >().ToMethod(CreateDocumentExtractionRequestClient);
kernel.Bind <IRequestClient <FindArchiveRecordRequest, FindArchiveRecordResponse> >().ToMethod(CreateFindArchiveRecordRequestClient);
bus.Start();
// Start the timer
Log.Verbose("Starting scheduler");
await scheduler.Start();
Log.Information("Asset service started");
}
public static SillycoreAppBuilder UseRabbitMq(this SillycoreAppBuilder builder, string configKey = "RabbitMq")
{
RabbitMqConfiguration rabbitMqConfiguration = builder.Configuration.GetSection(configKey).Get <RabbitMqConfiguration>();
if (rabbitMqConfiguration == null)
{
throw new ConfigurationException($"No rabbit mq configuration found at section:{configKey}.");
}
List <ConsumerConfiguration> consumerConfigurations = new List <ConsumerConfiguration>();
foreach (TypeInfo typeInfo in Assembly.GetEntryAssembly().DefinedTypes)
{
ConsumerAttribute consumerAttribute = typeInfo.GetCustomAttribute <ConsumerAttribute>();
if (consumerAttribute != null && (String.IsNullOrWhiteSpace(consumerAttribute.RabbitMq) || consumerAttribute.RabbitMq.Equals(configKey)))
{
ConsumerConfiguration consumerConfiguration = CreateConsumerConfigurationForType(typeInfo.AsType(), consumerAttribute);
consumerConfigurations.Add(consumerConfiguration);
}
}
builder.Services.AddSingleton <IBusControlProvider>(BusControlProvider);
builder.Services.TryAddSingleton(sp =>
{
if (BusControlProvider.GetBusControls().Count > 1)
{
throw new ConfigurationException($"You cannot resolve IBusControl when there are multiple RabbitMq instances registered to services collection. Instead try to resolve IBusControlProvider and use GetBusControl method with config name you set for your desired RabbitMq instance.");
}
return(BusControlProvider.GetBusControls().First());
});
builder.BeforeBuild(() =>
{
IBusControl busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(new Uri(rabbitMqConfiguration.Url), h =>
{
h.Username(rabbitMqConfiguration.Username);
h.Password(rabbitMqConfiguration.Password);
});
foreach (ConsumerConfiguration consumerConfiguration in consumerConfigurations)
{
builder.Services.AddTransient(consumerConfiguration.Type);
cfg.ReceiveEndpoint(host, consumerConfiguration.Queue, consumerConfiguration.ConfigureAction);
}
cfg.UseExtensionsLogging(builder.LoggerFactory);
if (rabbitMqConfiguration.Retry != null)
{
if (rabbitMqConfiguration.Retry.Incremental != null)
{
cfg.UseRetry(rp => { rp.Incremental(rabbitMqConfiguration.Retry.Incremental.RetryLimit, rabbitMqConfiguration.Retry.Incremental.InitialInterval, rabbitMqConfiguration.Retry.Incremental.IntervalIncrement); });
}
}
if (rabbitMqConfiguration.UseDelayedExchangeMessageScheduler)
{
cfg.UseDelayedExchangeMessageScheduler();
}
if (rabbitMqConfiguration.ConcurrencyLimit > 0)
{
cfg.UseConcurrencyLimit(rabbitMqConfiguration.ConcurrencyLimit);
}
});
BusControlProvider.AddBusControl(configKey, busControl);
builder.WhenStart(() => busControl.Start());
builder.WhenStopped(() => busControl.Stop());
});
return(builder);
}
public void SetupAzureServiceBusTestFixture()
{
_bus = CreateBus();
_bus.ConnectReceiveEndpointObserver(new ReceiveEndpointObserver());
_busHandle = _bus.Start();
try
{
_busSendEndpoint = _bus.GetSendEndpoint(_bus.Address).Result;
_busSendEndpoint.ConnectSendObserver(_sendObserver);
_inputQueueSendEndpoint = _bus.GetSendEndpoint(_inputQueueAddress).Result;
_inputQueueSendEndpoint.ConnectSendObserver(_sendObserver);
}
catch (Exception)
{
try
{
using (var tokenSource = new CancellationTokenSource(TestTimeout))
{
_bus.Stop(tokenSource.Token);
}
}
finally
{
_busHandle = null;
_bus = null;
}
throw;
}
}
private void StartBus()
{
Bus = Startup.Container.Resolve <IBusControl>();
Bus.Start();
}
public bool Start(HostControl hostControl)
{
_log.Info("Creating bus...");
_machine = new ShoppingCartStateMachine();
SagaDbContextFactory sagaDbContextFactory =
() => new SagaDbContext<ShoppingCart, ShoppingCartMap>(SagaDbContextFactoryProvider.ConnectionString);
_repository = new Lazy<ISagaRepository<ShoppingCart>>(
() => new EntityFrameworkSagaRepository<ShoppingCart>(sagaDbContextFactory));
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
IRabbitMqHost host = x.Host(new Uri(ConfigurationManager.AppSettings["RabbitMQHost"]), h =>
{
h.Username("guest");
h.Password("guest");
});
x.ReceiveEndpoint(host, "shopping_cart_state", e =>
{
e.PrefetchCount = 8;
e.StateMachineSaga(_machine, _repository.Value);
});
x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["SchedulerQueueName"], e =>
{
x.UseMessageScheduler(e.InputAddress);
e.PrefetchCount = 1;
e.Consumer(() => new ScheduleMessageConsumer(_scheduler));
e.Consumer(() => new CancelScheduledMessageConsumer(_scheduler));
});
});
_log.Info("Starting bus...");
try
{
_busHandle = _busControl.Start();
_scheduler.JobFactory = new MassTransitJobFactory(_busControl);
_scheduler.Start();
}
catch (Exception)
{
_scheduler.Shutdown();
throw;
}
return true;
}
public static void Start()
{
_instanceControl = ConfigureBus();
_instanceControl.Start();
}
public void SetupInMemoryTestFixture()
{
_bus = CreateBus();
_busHandle = _bus.Start();
try
{
_busSendEndpoint = Await(() => _bus.GetSendEndpoint(_bus.Address));
_busSendEndpoint.ConnectSendObserver(_sendObserver);
_inputQueueSendEndpoint = Await(() => _bus.GetSendEndpoint(_inputQueueAddress));
_inputQueueSendEndpoint.ConnectSendObserver(_sendObserver);
}
catch (Exception)
{
try
{
using (var tokenSource = new CancellationTokenSource(TestTimeout))
{
_busHandle?.Stop(tokenSource.Token);
}
}
finally
{
_busHandle = null;
_bus = null;
}
throw;
}
}
public const string Letter = "c"; // lowercase
private static void Main(string[] args)
{
Console.WriteLine("Vita.DataImporter started...");
AppDomain.CurrentDomain.UnhandledException += CurrentDomainOnUnhandledException;
JsonConvert.DefaultSettings = () => VitaSerializerSettings.Settings;
var builder = new ContainerBuilder();
builder.RegisterModule <LoggingModule>();
builder.RegisterModule <CommonModule>();
builder.RegisterConsumers(Assembly.GetExecutingAssembly());
builder.RegisterType <DataImporter>().SingleInstance();
try
{
#region Mass Transit
builder.Register(ConfigureBus)
.SingleInstance()
.As <IBusControl>()
.As <IBus>();
_container = builder.Build();
_busControl = _container.Resolve <IBusControl>();
_busControl.Start();
CleanDatabase();
EnsureIndexes();
_container.Resolve <DataImporter>().Execute(companies: true);
//ExtractLocalities();
ExtractCompanies();
//ExtractKeywordClassifiers();
//ExtractPlaces();
// ExtractCharges();
long count = 1;
while (true)
{
if (count > 100000)
{
Console.Clear();
count = 1;
}
Util.WaitFor(1);
//Console.WriteLine($"{DateTime.Now.ToLongTimeString()}");
// if (count % 100 == 0) Console.Write($".");
count++;
}
Console.ReadLine();
_busControl.Stop();
#endregion
}
catch (Exception e)
{
Log.Error(e, "Error startup {err}", e.Message);
throw;
}
}
public static void Start(LocalSettings localSettings)
{
instanceControl = ConfigureBus(localSettings);
instanceControl.Start();
}
public void Start()
{
bus = container.GetInstance<IBusControl>();
bus.Start();
var w = container.WhatDoIHave();
service = container.GetInstance<ScannerService>();
}
public bool Start(HostControl hostControl)
{
_busControl = ConfigureBus();
_busControl.Start();
return(true);
}
public static void Start(Settings settings)
{
instanceControl = ConfigureBus();
instanceControl.Start();
}
// FUNCTIONS //////////////////////////////////////////////////////////////////////////////
public void Run()
{
_bus.Start();
ThreadPool.QueueUserWorkItem(MessageGeneratorThread);
}
public void StartBus(IEndpointConfiguration endpointConfiguration)
{
busControl = this.CreateBus();
busControl.Start();
}