public static ConnectHandle ConnectEventHub(this IBusInstance busInstance, RiderObservable observers, IEventHubProducerSharedContext sharedContext,
IEnumerable <IEventHubReceiveEndpoint> endpoints)
{
var rider = new EventHubRider(endpoints, sharedContext, observers);
return(busInstance.ConnectRider(rider));
}
public KafkaTopicReceiveEndpointConfiguration(IKafkaHostConfiguration hostConfiguration, ConsumerConfig consumerConfig, string topic,
IBusInstance busInstance, IReceiveEndpointConfiguration endpointConfiguration, IHeadersDeserializer headersDeserializer)
: base(endpointConfiguration)
{
_hostConfiguration = hostConfiguration;
_busInstance = busInstance;
_endpointConfiguration = endpointConfiguration;
_consumerConfig = consumerConfig;
_options = new OptionsSet();
Topic = topic;
if (!SerializationUtils.DeSerializers.IsDefaultKeyType <TKey>())
{
SetKeyDeserializer(new MassTransitJsonDeserializer <TKey>());
}
SetValueDeserializer(new MassTransitJsonDeserializer <TValue>());
SetHeadersDeserializer(headersDeserializer);
CheckpointInterval = TimeSpan.FromMinutes(1);
CheckpointMessageCount = 5000;
MessageLimit = 10000;
ConcurrencyLimit = 1;
_consumerConfigurator = new PipeConfigurator <ConsumerContext <TKey, TValue> >();
}
public static ConnectHandle ConnectKafka(this IBusInstance busInstance, RiderObservable observers,
IEnumerable <IKafkaReceiveEndpoint> endpoints,
IEnumerable <IKafkaProducerFactory> producers)
{
var rider = new KafkaRider(busInstance.HostConfiguration.HostAddress, endpoints, producers, observers);
return(busInstance.ConnectRider(rider));
}
public KafkaRider(IKafkaHostConfiguration hostConfiguration, IBusInstance busInstance, IReceiveEndpointCollection endpoints,
ITopicProducerProvider producerProvider, IRiderRegistrationContext registrationContext)
{
_hostConfiguration = hostConfiguration;
_busInstance = busInstance;
_endpoints = endpoints;
_producerProvider = producerProvider;
_registrationContext = registrationContext;
}
protected IBusInstance CreateBus <T, TConfigurator>(T configurator, IBusRegistrationContext context,
Action <IBusRegistrationContext, TConfigurator> configure, IEnumerable <IBusInstanceSpecification> specifications)
where T : TConfigurator, IBusFactory
where TConfigurator : IBusFactoryConfigurator
{
var loggerFactory = context.GetService <ILoggerFactory>();
if (loggerFactory != null)
{
LogContext.ConfigureCurrentLogContext(loggerFactory);
}
else if (LogContext.Current == null)
{
LogContext.ConfigureCurrentLogContext();
}
_hostConfiguration.LogContext = LogContext.Current;
context.UseHealthCheck(configurator);
configure?.Invoke(context, configurator);
specifications ??= Enumerable.Empty <IBusInstanceSpecification>();
IEnumerable <IBusInstanceSpecification> busInstanceSpecifications = specifications as IBusInstanceSpecification[] ?? specifications.ToArray();
IEnumerable <ValidationResult> validationResult = configurator.Validate()
.Concat(busInstanceSpecifications.SelectMany(x => x.Validate()));
var result = BusConfigurationResult.CompileResults(validationResult);
try
{
var busReceiveEndpointConfiguration = configurator.CreateBusEndpointConfiguration(x => x.ConfigureConsumeTopology = false);
var host = _hostConfiguration.Build() as IHost <TEndpointConfigurator>;
var bus = new MassTransitBus(host, _hostConfiguration.BusConfiguration.BusObservers, busReceiveEndpointConfiguration);
TaskUtil.Await(() => _hostConfiguration.BusConfiguration.BusObservers.PostCreate(bus));
IBusInstance instance = CreateBusInstance(bus, host, _hostConfiguration, context);
foreach (var specification in busInstanceSpecifications)
{
specification.Configure(instance);
}
return(instance);
}
catch (Exception ex)
{
TaskUtil.Await(() => _hostConfiguration.BusConfiguration.BusObservers.CreateFaulted(ex));
throw new ConfigurationException(result, "An exception occurred during bus creation", ex);
}
}
public void Configure(IBusInstance busInstance)
{
IEventHubReceiveEndpoint[] endpoints = _specifications
.Select(x => x.Create(busInstance))
.ToArray();
var sharedContext = _producerSpecification.CreateContext(busInstance);
busInstance.ConnectEventHub(_observer, sharedContext, endpoints);
}
public TaskService(IUnitOfWork unitOfWork, IBusInstance busInstance)
{
_unitOfWork = unitOfWork;
_busInstance = busInstance;
_taskRepository = unitOfWork.GetRepository <MentifiTask>();
_systemUserRepository = unitOfWork.GetRepository <SystemUser>();
_mentifiTaskChannelRepository = unitOfWork.GetRepository <MentifiChannelTask>();
_notificationRepository = unitOfWork.GetRepository <Notification>();
}
public EventHubProducerProvider(IEventHubHostConfiguration hostConfiguration, IBusInstance busInstance, ISendPipe sendPipe,
SendObservable sendObservable, IMessageSerializer messageSerializer)
{
_hostConfiguration = hostConfiguration;
_busInstance = busInstance;
_sendPipe = sendPipe;
_sendObservable = sendObservable;
_messageSerializer = messageSerializer;
}
public MessageBoardService(IUnitOfWork unitOfWork, IBusInstance busInstance)
{
_unitOfWork = unitOfWork;
_busInstance = busInstance;
_notificationRepository = unitOfWork.GetRepository <Notification>();
_businessToBusinessRepository = unitOfWork.GetRepository <BusinessToBusiness>();
_systemUserRepository = unitOfWork.GetRepository <SystemUser>();
_messageRepository = unitOfWork.GetRepository <MentifiMessage>();
_mentifiMessageBoardPostRepository = unitOfWork.GetRepository <MentifiMessageBoardPostChecker>();
}
public EventHubProducerSharedContext(IBusInstance busInstance, SendObservable sendObservers, ISendPipe sendPipe,
ISerializationConfiguration serializationConfiguration, IHostSettings hostSettings, EventHubProducerClientOptions options)
{
SendObservers = sendObservers;
SendPipe = sendPipe;
_busInstance = busInstance;
_serializationConfiguration = serializationConfiguration;
_hostSettings = hostSettings;
_options = options;
_clients = new ConcurrentDictionary <string, EventHubProducerClient>();
}
public GoalService(IUnitOfWork unitOfWork,
IBusInstance busInstance)
{
_unitOfWork = unitOfWork;
_busInstance = busInstance;
_goalRepository = unitOfWork.GetRepository <MentifiGoal>();
_systemUserRepository = unitOfWork.GetRepository <SystemUser>();
_notificationRepository = unitOfWork.GetRepository <Notification>();
_businessToBusinessRepository = unitOfWork.GetRepository <BusinessToBusiness>();
_goalProgressRepository = unitOfWork.GetRepository <MentifiGoalProgress>();
}
public void Configure(IBusInstance busInstance)
{
IKafkaReceiveEndpoint[] endpoints = _consumers
.Select(x => x.CreateReceiveEndpoint(busInstance))
.ToArray();
IKafkaProducerFactory[] producers = _producers
.Select(x => x.CreateProducerFactory(busInstance))
.ToArray();
busInstance.ConnectKafka(_observers, endpoints, producers);
}
public KafkaReceiveEndpointBuilder(IBusInstance busInstance, IReceiveEndpointConfiguration configuration,
IKafkaHostConfiguration hostConfiguration, ReceiveSettings receiveSettings, IHeadersDeserializer headersDeserializer,
Func <ConsumerBuilder <TKey, TValue> > consumerBuilderFactory)
: base(configuration)
{
_busInstance = busInstance;
_configuration = configuration;
_hostConfiguration = hostConfiguration;
_receiveSettings = receiveSettings;
_headersDeserializer = headersDeserializer;
_consumerBuilderFactory = consumerBuilderFactory;
}
public MessageService(IUnitOfWork unitOfWork, IBusInstance busInstance, IEmailApi emailApi, IConfiguration configuration)
{
_unitOfWork = unitOfWork;
_busInstance = busInstance;
_emailApi = emailApi;
_configuration = configuration;
_messageCheckerRepository = unitOfWork.GetRepository <MentifiMessageBoardPostChecker>();
_notificationRepository = unitOfWork.GetRepository <Notification>();
_businessToBusinessRepository = unitOfWork.GetRepository <BusinessToBusiness>();
_systemUserRepository = unitOfWork.GetRepository <SystemUser>();
_messageRepository = unitOfWork.GetRepository <Message>();
}
public EventHubReceiveEndpointContext(IEventHubHostConfiguration hostConfiguration, IBusInstance busInstance,
IReceiveEndpointConfiguration endpointConfiguration,
ReceiveSettings receiveSettings, Func <IStorageSettings, BlobContainerClient> blobContainerClientFactory,
Func <IHostSettings, BlobContainerClient, EventProcessorClient> clientFactory,
Func <PartitionClosingEventArgs, Task> partitionClosingHandler,
Func <PartitionInitializingEventArgs, Task> partitionInitializingHandler)
: base(busInstance.HostConfiguration, endpointConfiguration)
{
_busInstance = busInstance;
_contextSupervisor = new Recycle <IProcessorContextSupervisor>(() =>
new ProcessorContextSupervisor(hostConfiguration.ConnectionContextSupervisor, busInstance.HostConfiguration, receiveSettings,
blobContainerClientFactory, clientFactory, partitionClosingHandler, partitionInitializingHandler));
}
public IEventHubRider Build(IRiderRegistrationContext context, IBusInstance busInstance)
{
var endpoints = new ReceiveEndpointCollection();
foreach (var endpoint in _endpoints)
{
endpoints.Add(endpoint.EndpointName, endpoint.CreateReceiveEndpoint(busInstance));
}
var producerProvider = _producerSpecification.CreateProducerProvider(busInstance);
return(new EventHubRider(this, busInstance, endpoints, new CachedEventHubProducerProvider(producerProvider), context));
}
public GoalProgressService(IUnitOfWork unitOfWork, IBusInstance busInstance, IEmailApi emailApi, IConfiguration configuration, IMongoRepository <Resource> resourceRepository)
{
_unitOfWork = unitOfWork;
_busInstance = busInstance;
_emailApi = emailApi;
_configuration = configuration;
_resourceRepository = resourceRepository;
_goalProgressRepository = _unitOfWork.GetRepository <MentifiGoalProgress>();
_notificationRepository = _unitOfWork.GetRepository <Notification>();
_systemUserRepository = _unitOfWork.GetRepository <SystemUser>();
_businessToBusinessRepository = _unitOfWork.GetRepository <BusinessToBusiness>();
_universityRepository = _unitOfWork.GetRepository <EduUniversity>();
_goalRepository = _unitOfWork.GetRepository <MentifiGoal>();
}
public KafkaReceiveEndpointContext(IBusInstance busInstance, IReceiveEndpointConfiguration endpointConfiguration,
IKafkaHostConfiguration hostConfiguration,
ReceiveSettings receiveSettings,
IHeadersDeserializer headersDeserializer,
Func <ConsumerBuilder <TKey, TValue> > consumerBuilderFactory)
: base(busInstance.HostConfiguration, endpointConfiguration)
{
_busInstance = busInstance;
_settings = receiveSettings;
_consumerContext = new Recycle <IConsumerContextSupervisor <TKey, TValue> >(() =>
new ConsumerContextSupervisor <TKey, TValue>(hostConfiguration.ClientContextSupervisor, _settings, busInstance.HostConfiguration,
headersDeserializer, consumerBuilderFactory));
}
public EventHubReceiveEndpointConfigurator(string eventHubName, string consumerGroup, IHostSettings hostSettings, IStorageSettings storageSettings,
IBusInstance busInstance,
IReceiveEndpointConfiguration endpointConfiguration)
: base(endpointConfiguration)
{
_eventHubName = eventHubName;
_consumerGroup = consumerGroup;
_hostSettings = hostSettings;
_storageSettings = storageSettings;
_busInstance = busInstance;
_endpointConfiguration = endpointConfiguration;
CheckpointInterval = TimeSpan.FromMinutes(1);
CheckpointMessageCount = 5000;
ConcurrencyLimit = 1;
}
public KafkaTopicReceiveEndpointConfiguration(ConsumerConfig consumerConfig, string topic, IBusInstance busInstance,
IReceiveEndpointConfiguration endpointConfiguration, IHeadersDeserializer headersDeserializer)
: base(endpointConfiguration)
{
_busInstance = busInstance;
_endpointConfiguration = endpointConfiguration;
_consumerConfig = consumerConfig;
_topic = topic;
SetValueDeserializer(new MassTransitJsonDeserializer <TValue>());
SetKeyDeserializer(new MassTransitJsonDeserializer <TKey>());
SetHeadersDeserializer(headersDeserializer);
CheckpointInterval = TimeSpan.FromMinutes(1);
CheckpointMessageCount = 5000;
ConcurrencyLimit = 1;
}
public EventHubReceiveEndpointBuilder(IEventHubHostConfiguration hostConfiguration, IBusInstance busInstance,
IReceiveEndpointConfiguration configuration, ReceiveSettings receiveSettings,
Func <IStorageSettings, BlobContainerClient> blobContainerClientFactory,
Func <IHostSettings, BlobContainerClient, EventProcessorClient> clientFactory,
Func <PartitionClosingEventArgs, Task> partitionClosingHandler,
Func <PartitionInitializingEventArgs, Task> partitionInitializingHandler)
: base(configuration)
{
_hostConfiguration = hostConfiguration;
_busInstance = busInstance;
_configuration = configuration;
_receiveSettings = receiveSettings;
_blobContainerClientFactory = blobContainerClientFactory;
_clientFactory = clientFactory;
_partitionClosingHandler = partitionClosingHandler;
_partitionInitializingHandler = partitionInitializingHandler;
}
public EventHubReceiveEndpointConfigurator(IEventHubHostConfiguration hostConfiguration, string eventHubName, string consumerGroup,
IBusInstance busInstance,
IReceiveEndpointConfiguration endpointConfiguration)
: base(endpointConfiguration)
{
EventHubName = eventHubName;
ConsumerGroup = consumerGroup;
_hostConfiguration = hostConfiguration;
_busInstance = busInstance;
_endpointConfiguration = endpointConfiguration;
ConcurrencyLimit = 1;
CheckpointInterval = TimeSpan.FromMinutes(1);
CheckpointMessageCount = 5000;
_processorConfigurator = new PipeConfigurator <ProcessorContext>();
}
public ITopicProducer <TKey, TValue> CreateProducer <TKey, TValue>(IBusInstance busInstance, Uri address)
where TValue : class
{
if (busInstance == null)
{
throw new ArgumentNullException(nameof(busInstance));
}
if (address == null)
{
throw new ArgumentNullException(nameof(address));
}
var topicAddress = NormalizeAddress(busInstance.HostConfiguration.HostAddress, address);
IKafkaProducerFactory <TKey, TValue> factory = GetFactory <TKey, TValue>(topicAddress, busInstance);
return(factory.CreateProducer());
}
public ReceiveEndpoint CreateReceiveEndpoint(IBusInstance busInstance)
{
var endpointConfiguration = busInstance.HostConfiguration.CreateReceiveEndpointConfiguration(EndpointName);
endpointConfiguration.ConnectReceiveEndpointObserver(_endpointObservers);
var configurator = new EventHubReceiveEndpointConfigurator(_hostConfiguration, _eventHubName, _consumerGroup, busInstance, endpointConfiguration);
_configure?.Invoke(configurator);
var result = BusConfigurationResult.CompileResults(configurator.Validate());
try
{
return(configurator.Build());
}
catch (Exception ex)
{
throw new ConfigurationException(result, "An exception occurred creating the EventHub receive endpoint", ex);
}
}
public ReceiveEndpoint CreateReceiveEndpoint(IBusInstance busInstance)
{
var endpointConfiguration = busInstance.HostConfiguration.CreateReceiveEndpointConfiguration(EndpointName);
endpointConfiguration.ConnectReceiveEndpointObserver(_endpointObservers);
var configurator =
new KafkaTopicReceiveEndpointConfiguration<TKey, TValue>(_hostConfiguration, _consumerConfig, _topicName, busInstance, endpointConfiguration,
_headersDeserializer);
_configure?.Invoke(configurator);
var result = BusConfigurationResult.CompileResults(configurator.Validate());
try
{
return configurator.Build();
}
catch (Exception ex)
{
throw new ConfigurationException(result, "An exception occurred creating the Kafka receive endpoint", ex);
}
}
public IEventHubReceiveEndpoint Create(IBusInstance busInstance)
{
var endpointConfiguration = busInstance.HostConfiguration.CreateReceiveEndpointConfiguration($"{EventHubEndpointAddress.PathPrefix}/{Name}");
endpointConfiguration.ConnectReceiveEndpointObserver(_endpointObservers);
var configurator =
new EventHubReceiveEndpointConfigurator(Name, _consumerGroup, _hostSettings, _storageSettings, busInstance, endpointConfiguration);
_configure?.Invoke(configurator);
var result = BusConfigurationResult.CompileResults(configurator.Validate());
try
{
return(configurator.Build());
}
catch (Exception ex)
{
throw new ConfigurationException(result, "An exception occurred creating the EventDataReceiver", ex);
}
}
public IKafkaReceiveEndpoint CreateReceiveEndpoint(IBusInstance busInstance)
{
var endpointConfiguration = busInstance.HostConfiguration.CreateReceiveEndpointConfiguration($"{KafkaTopicAddress.PathPrefix}/{Name}");
endpointConfiguration.ConnectReceiveEndpointObserver(_endpointObservers);
var configurator =
new KafkaTopicReceiveEndpointConfiguration <TKey, TValue>(_consumerConfig, Name, busInstance, endpointConfiguration, _headersDeserializer);
_configure?.Invoke(configurator);
var result = BusConfigurationResult.CompileResults(configurator.Validate());
try
{
return(configurator.Build());
}
catch (Exception ex)
{
throw new ConfigurationException(result, $"An exception occurred creating the {nameof(IKafkaReceiveEndpoint)}", ex);
}
}
public RiderReceiveEndpointBuilder(IBusInstance busInstance, IReceiveEndpointConfiguration configuration)
: base(configuration)
{
_busInstance = busInstance;
_configuration = configuration;
}
public RiderReceiveEndpointContext(IBusInstance busInstance, IReceiveEndpointConfiguration configuration)
: base(configuration)
{
_busInstance = busInstance;
}
public MultiBusInstance(TBus bus, IBusInstance instance)
{
_instance = instance;
BusInstance = bus;
}
