//private void ConfigureSendHeader(IBusFactoryConfigurator cfg) //{ // cfg.ConfigureSend(x => x.UseSendExecute(sendContext => // { // //1. get current thread identity object. // var currentThreadIdentityObject = Thread.CurrentPrincipal.Identity is BarcodeIdentity ? ((BarcodeIdentity)Thread.CurrentPrincipal.Identity).IdentityObject : null; // if (currentThreadIdentityObject != null) // { // //2. set the headers. // sendContext.Headers.Set(AppSettingConfig.RabbitMqIdentityHeaderKey, currentThreadIdentityObject.StaffID.ToString()); // } // })); //} private void ConfigureEndPoints(IBusFactoryConfigurator cfg, IComponentContext context, params ReceiveEndPoint[] receiveEndPoints) { if (receiveEndPoints?.Length > 0) { var baseQueueName = AppSettingConfig.BaseQueueName; var rpcQueuePostfix = AppSettingConfig.RpcQueueNamePostfix; var commandQueuePostfix = AppSettingConfig.CommandQueueNamePostfix; var eventQueuePostfix = AppSettingConfig.EventQueueNamePostfix; var consumerMethod = typeof(AutofacExtensions).GetMethod("Consumer", new Type[] { typeof(IReceiveEndpointConfigurator), typeof(IComponentContext), typeof(string) }); foreach (var receiveEndPoint in receiveEndPoints) { if (receiveEndPoint == ReceiveEndPoint.Commnad) { cfg.ReceiveEndpoint(baseQueueName + "_" + commandQueuePostfix, ep => { var commandConsumers = System.Reflection.Assembly.GetAssembly(typeof(MassTransitModule)) .GetTypes() .Where(type => type.IsClass && type.Name.EndsWith("CommandConsumer")); foreach (var commandConsumer in commandConsumers) { consumerMethod.MakeGenericMethod(commandConsumer).Invoke(commandConsumer, new object[] { ep, context, "message" }); } }); } else if (receiveEndPoint == ReceiveEndPoint.Request) { cfg.ReceiveEndpoint(baseQueueName + "_" + rpcQueuePostfix, ep => { var requestConsumers = System.Reflection.Assembly.GetAssembly(typeof(MassTransitModule)) .GetTypes() .Where(type => type.IsClass && type.Name.EndsWith("RequestConsumer")); foreach (var requestConsumer in requestConsumers) { consumerMethod.MakeGenericMethod(requestConsumer).Invoke(requestConsumer, new object[] { ep, context, "message" }); } }); } else if (receiveEndPoint == ReceiveEndPoint.Event) { cfg.ReceiveEndpoint(baseQueueName + "_" + eventQueuePostfix, ep => { var eventConsumers = System.Reflection.Assembly.GetAssembly(typeof(MassTransitModule)) .GetTypes() .Where(type => type.IsClass && type.Name.EndsWith("EventConsumer")); foreach (var eventConsumer in eventConsumers) { consumerMethod.MakeGenericMethod(eventConsumer).Invoke(eventConsumer, new object[] { ep, context, "message" }); } }); } } } }
/// <summary> /// Configure a service instance, which supports one or more receive endpoints, all of which are managed by conductor. /// </summary> /// <param name="configurator"></param> /// <param name="options"></param> /// <param name="configure"></param> public static void ServiceInstance <TEndpointConfigurator>(this IBusFactoryConfigurator <TEndpointConfigurator> configurator, ServiceInstanceOptions options, Action <IServiceInstanceConfigurator <TEndpointConfigurator> > configure) where TEndpointConfigurator : IReceiveEndpointConfigurator { IServiceInstanceTransportConfigurator <TEndpointConfigurator> transportConfigurator = Cached <TEndpointConfigurator> .Instance; var instance = new ServiceInstance(); if (options.InstanceEndpointEnabled) { var definition = new InstanceEndpointDefinition(instance); configurator.ReceiveEndpoint(definition, options.EndpointNameFormatter, instanceEndpointConfigurator => { var instanceConfigurator = new ServiceInstanceConfigurator <TEndpointConfigurator>(configurator, transportConfigurator, instance, options, instanceEndpointConfigurator); configure?.Invoke(instanceConfigurator); }); } else { var instanceConfigurator = new ServiceInstanceConfigurator <TEndpointConfigurator>(configurator, transportConfigurator, instance, options); configure?.Invoke(instanceConfigurator); } }
public static void UseInMemoryScheduler(this IBusFactoryConfigurator configurator) { if (configurator == null) { throw new ArgumentNullException(nameof(configurator)); } ISchedulerFactory schedulerFactory = new StdSchedulerFactory(); var scheduler = schedulerFactory.GetScheduler(); configurator.ReceiveEndpoint("quartz", e => { var partitioner = configurator.CreatePartitioner(16); e.Consumer(() => new ScheduleMessageConsumer(scheduler), x => x.Message <ScheduleMessage>(m => m.UsePartitioner(partitioner, p => p.Message.CorrelationId))); e.Consumer(() => new CancelScheduledMessageConsumer(scheduler), x => x.Message <CancelScheduledMessage>(m => m.UsePartitioner(partitioner, p => p.Message.TokenId))); configurator.UseMessageScheduler(e.InputAddress); var specification = new SchedulerBusFactorySpecification(scheduler, e.InputAddress); configurator.AddBusFactorySpecification(specification); }); }
public static Uri UseInMemoryScheduler(this IBusFactoryConfigurator configurator, string queueName = "quartz") { if (configurator == null) { throw new ArgumentNullException(nameof(configurator)); } ISchedulerFactory schedulerFactory = new StdSchedulerFactory(); var scheduler = TaskUtil.Await(() => schedulerFactory.GetScheduler()); Uri inputAddress = null; configurator.ReceiveEndpoint(queueName, e => { var partitioner = configurator.CreatePartitioner(16); e.Consumer(() => new ScheduleMessageConsumer(scheduler), x => x.Message <ScheduleMessage>(m => m.UsePartitioner(partitioner, p => p.Message.CorrelationId))); e.Consumer(() => new CancelScheduledMessageConsumer(scheduler), x => x.Message <CancelScheduledMessage>(m => m.UsePartitioner(partitioner, p => p.Message.TokenId))); configurator.UseMessageScheduler(e.InputAddress); var observer = new SchedulerBusObserver(scheduler, e.InputAddress); configurator.ConnectBusObserver(observer); inputAddress = e.InputAddress; }); return(inputAddress); }
protected override void ConfigureNamedReceiveEndpoint(IBusFactoryConfigurator configurator, string queueName) { configurator.ReceiveEndpoint(queueName, x => { x.StateMachineSaga(_stateMachine, TestRepository); }); }
public static void AddScheduling(this IBusFactoryConfigurator configurator, Action <InMemorySchedulerOptions> configure) { if (configurator == null) { throw new ArgumentNullException(nameof(configurator)); } var options = new InMemorySchedulerOptions(); configure?.Invoke(options); if (options.SchedulerFactory == null) { throw new ArgumentNullException(nameof(options.SchedulerFactory)); } Uri inputAddress = null; var observer = new SchedulerBusObserver(options); configurator.ReceiveEndpoint(options.QueueName, e => { var partitioner = configurator.CreatePartitioner(Environment.ProcessorCount); e.Consumer(() => new ScheduleMessageConsumer(observer.Scheduler), x => x.Message <ScheduleMessage>(m => m.UsePartitioner(partitioner, p => p.Message.CorrelationId))); e.Consumer(() => new CancelScheduledMessageConsumer(observer.Scheduler), x => x.Message <CancelScheduledMessage>(m => m.UsePartitioner(partitioner, p => p.Message.TokenId))); configurator.UseMessageScheduler(e.InputAddress); configurator.ConnectBusObserver(observer); }); }
/// <summary> /// Applies the receive endpoints to the bus. /// </summary> /// <param name="configurator"></param> public void Apply(string busName, IBusFactoryConfigurator configurator) { foreach (var name in names.GetEndpointNames(busName)) { configurator.ReceiveEndpoint(name, endpoint => Apply(busName, name, endpoint, configurations.GetConfigurations(busName, name))); } }
public static void AddSignalRHubEndpoints <THub, TEndpointConfigurator>(this IBusFactoryConfigurator configurator, IServiceProvider serviceProvider, IHost host, Action <TEndpointConfigurator> configureEndpoint = null) where TEndpointConfigurator : class, IReceiveEndpointConfigurator where THub : Hub { var consumers = HubConsumersCache.GetOrAdd <THub>(); var queueNameBase = host.Topology.CreateTemporaryQueueName($"signalRBackplane-{typeof(THub).Name}-"); // Loop through our 5 hub consumers and create a temporary endpoint for each foreach (var consumerType in consumers) { // remove `1 from generic type var name = consumerType.Name; int index = name.IndexOf('`'); if (index > 0) { name = name.Remove(index); } configurator.ReceiveEndpoint(new HubEndpointDefinition <THub>(), null, e => { configureEndpoint?.Invoke((TEndpointConfigurator)e); e.ConfigureConsumer(serviceProvider, consumerType); }); } }
/// <summary> /// Method used to configure the available endpoints for a test case /// </summary> /// <param name="busFactoryConfigurator"> /// </param> public override void ConfigureEndpoints(IBusFactoryConfigurator busFactoryConfigurator) { busFactoryConfigurator.ReceiveEndpoint( QueueName, endpointConfigurator => endpointConfigurator.Consumer <Consumers.ConsumeConsumer>() ); }
protected virtual void ConfigureNamedReceiveEndpoint(IBusFactoryConfigurator configurator, string queueName) { configurator.ReceiveEndpoint(queueName, x => { x.Saga(TestRepository); }); }
public static void UseHangfireScheduler(this IBusFactoryConfigurator configurator, IHangfireComponentResolver hangfireComponentResolver, string queueName = "hangfire", Action <BackgroundJobServerOptions> configureServer = null) { if (configurator == null) { throw new ArgumentNullException(nameof(configurator)); } if (hangfireComponentResolver == null) { throw new ArgumentNullException(nameof(hangfireComponentResolver)); } configurator.ReceiveEndpoint(queueName, e => { var partitioner = configurator.CreatePartitioner(Environment.ProcessorCount); e.Consumer(() => new ScheduleMessageConsumer(hangfireComponentResolver), x => { x.Message <ScheduleMessage>(m => m.UsePartitioner(partitioner, p => p.Message.CorrelationId)); x.Message <CancelScheduledMessage>(m => m.UsePartitioner(partitioner, p => p.Message.TokenId)); }); e.Consumer(() => new ScheduleRecurringMessageConsumer(hangfireComponentResolver)); var observer = new SchedulerBusObserver(hangfireComponentResolver, e.InputAddress, configureServer); configurator.ConnectBusObserver(observer); configurator.UseMessageScheduler(e.InputAddress); }); }
void ConfigureBus(IBusFactoryConfigurator configurator) { configurator.ReceiveEndpoint(CompensateQueueName, x => { x.CompensateActivityHost(_activityFactory, _configureCompensate); CompensateAddress = x.InputAddress; }); configurator.ReceiveEndpoint(ExecuteQueueName, x => { x.ExecuteActivityHost(CompensateAddress, _activityFactory, _configureExecute); ExecuteAddress = x.InputAddress; }); }
/// <summary> /// Prefer using this method when configuring a receive endpoint, so that the consumers for a command/event will listen on the correct queue. /// </summary> /// <typeparam name="TMessage">Must end with either Command, Event or Query (convention)</typeparam> public static void ReceiveEndpoint <TMessage>(this IBusFactoryConfigurator cfg, Action <IReceiveEndpointConfigurator> conf) { var className = typeof(TMessage).Name; ValidationHelpers.EnsureNamingConventionForMessage(className); cfg.ReceiveEndpoint(className, conf); }
public static Task RegisterStateMachine(this IBusFactoryConfigurator configurator, Type stateMachineType, IServiceProvider provider) { configurator.ReceiveEndpoint(stateMachineType.FullName, e => { var instanceType = stateMachineType .GetTypeInfo() .BaseType .GetGenericArguments()[0]; var automatonymousIntegrationAssembly = Assembly.Load(new AssemblyName("MassTransit.AutomatonymousExtensions.DependencyInjectionIntegration")); var stateMachineSagaMethod = automatonymousIntegrationAssembly .GetTypes() .Where(t => t.GetTypeInfo().IsSealed&& !t.GetTypeInfo().IsGenericType&& !t.IsNested) .SelectMany(t => t.GetMethods(BindingFlags.Static | BindingFlags.Public)) .Where(m => m.IsDefined(typeof(ExtensionAttribute), false) && m.GetParameters()[0].ParameterType == typeof(IReceiveEndpointConfigurator) && m.GetParameters()[2].ParameterType == typeof(IServiceProvider)) .Single(m => m.Name == "StateMachineSaga") .MakeGenericMethod(instanceType); var stateMachine = provider.GetService(stateMachineType); stateMachineSagaMethod.Invoke(e, new object[] { e, stateMachine, provider, null }); }); return(Task.CompletedTask); }
public static void CreateConventionalCommandHandlerEndpoint <TConsumer, TMessage>(this IBusFactoryConfigurator cfg, IServiceProvider provider) where TMessage : class where TConsumer : class, IConsumer <TMessage> { cfg.ReceiveEndpoint(BuildConventionalPathForType(typeof(TMessage)), configurator => { configurator.Consumer <TConsumer>(provider); }); }
private void ConfigureConsumersListeningOnErrorQueue(IBusFactoryConfigurator busFactoryConfigurator) { busFactoryConfigurator.ReceiveEndpoint(ErrorQueueName, receiveEndpointConfigurator => { receiveEndpointConfigurator.Consumer(typeof(MyCommandFaultConsumer), _consumerFactory.Create); receiveEndpointConfigurator.Consumer(typeof(MyEventFaultConsumer), _consumerFactory.Create); }); }
public static void RegisterScopedConsumer <TConsumer>(this IBusFactoryConfigurator configurator, IServiceProvider provider, Action <IReceiveEndpointConfigurator> endpointConfigurator = null, Action <IConsumerConfigurator <TConsumer> > consumerConfigurator = null) where TConsumer : class, IConsumer { configurator.ReceiveEndpoint(typeof(TConsumer).FullName, e => { e.ScopedConsumer(provider, consumerConfigurator); endpointConfigurator?.Invoke(e); }); }
protected virtual void ConfigureNamedReceiveEndpoint(IBusFactoryConfigurator configurator, string queueName) { configurator.ReceiveEndpoint(queueName, x => { var decorator = new TestConsumerFactoryDecorator <TConsumer>(_consumerFactory, _consumed); x.Consumer(decorator); }); }
public static void RegisterConsumer <TConsumer>(this IBusFactoryConfigurator bus, IServiceProvider provider, Action <IReceiveEndpointConfigurator> endpointConfigurator = null, Action <IConsumerConfigurator <TConsumer> > consumerConfigurator = null) where TConsumer : class, IConsumer { bus.ReceiveEndpoint(typeof(TConsumer).FullName, e => { e.Consumer(() => provider.GetRequiredService <TConsumer>(), consumerConfigurator); endpointConfigurator?.Invoke(e); }); }
public static Task RegisterConsumer(this IBusFactoryConfigurator configurator, Type consumerType, IServiceProvider provider) { configurator.ReceiveEndpoint(consumerType.FullName, e => { e.Consumer(consumerType, t => provider.GetRequiredService(t)); e.UseInMemoryOutbox(); }); return(Task.CompletedTask); }
public static void RegisterStateMachine <TStateMachine, TState>(this IBusFactoryConfigurator configurator, IServiceProvider provider, Action <IReceiveEndpointConfigurator> endpointConfigurator = null) where TStateMachine : MassTransitStateMachine <TState> where TState : class, SagaStateMachineInstance { configurator.ReceiveEndpoint(typeof(TStateMachine).FullName, e => { e.StateMachineSaga(provider.GetRequiredService <TStateMachine>(), provider.GetRequiredService <ISagaRepository <TState> >()); endpointConfigurator?.Invoke(e); }); }
void ConfigureBus(IBusFactoryConfigurator configurator) { configurator.ReceiveEndpoint(ExecuteQueueName, x => { OnConfigureExecuteReceiveEndpoint?.Invoke(x); x.ExecuteActivityHost(_activityFactory, _configureExecute); ExecuteAddress = x.InputAddress; }); }
/// <summary> /// Creates a management endpoint which can be used by controllable filters on a bus instance /// </summary> /// <param name="configurator"></param> /// <param name="configure"></param> /// <returns></returns> public static void ManagementEndpoint(this IBusFactoryConfigurator configurator, Action <IReceiveEndpointConfigurator> configure = null) { IReceiveEndpointConfigurator specification = null; configurator.ReceiveEndpoint(new ManagementEndpointDefinition(), DefaultEndpointNameFormatter.Instance, x => { specification = x; configure?.Invoke(specification); }); }
/// <summary> /// Method used to configure the available endpoints for a test case /// </summary> /// <param name="busFactoryConfigurator"> /// </param> public override void ConfigureEndpoints(IBusFactoryConfigurator busFactoryConfigurator) { busFactoryConfigurator.ReceiveEndpoint( QueueName, endpointConfigurator => { endpointConfigurator.Consumer <Buyer>(); endpointConfigurator.Consumer <Bank>(); endpointConfigurator.Consumer <Shop>(); } ); }
public static void FutureEndpoint <TFuture, TRequest>(this IBusFactoryConfigurator configurator, IBusRegistrationContext context) where TFuture : class, SagaStateMachine <FutureState>, new() where TRequest : class { var endpointNameFormatter = context.GetRequiredService <IEndpointNameFormatter>(); configurator.ReceiveEndpoint(endpointNameFormatter.Message <TFuture>(), endpoint => { endpoint.ApplyFutureEndpointConfiguration <TRequest>(); endpoint.StateMachineSaga(new TFuture(), context); }); }
public static void AddSignalRHubEndpoints <THub>(this IBusFactoryConfigurator configurator, IRegistrationContext <IServiceProvider> context, Action <IReceiveEndpointConfigurator> configureEndpoint = null) where THub : Hub { var endpointNameFormatter = context.Container.GetService <IEndpointNameFormatter>(); var definition = new HubEndpointDefinition <THub>(); configurator.ReceiveEndpoint(definition, endpointNameFormatter, e => { configureEndpoint?.Invoke(e); e.ConfigureConsumer <AllConsumer <THub> >(context); }); configurator.ReceiveEndpoint(definition, endpointNameFormatter, e => { configureEndpoint?.Invoke(e); e.ConfigureConsumer <ConnectionConsumer <THub> >(context); }); configurator.ReceiveEndpoint(definition, endpointNameFormatter, e => { configureEndpoint?.Invoke(e); e.ConfigureConsumer <GroupConsumer <THub> >(context); }); configurator.ReceiveEndpoint(definition, endpointNameFormatter, e => { configureEndpoint?.Invoke(e); e.ConfigureConsumer <UserConsumer <THub> >(context); }); }
/// <summary> /// Configure a service instance for use with the job service /// </summary> /// <param name="configurator"></param> /// <param name="options"></param> /// <param name="configure"></param> public static void ServiceInstance <TEndpointConfigurator>(this IBusFactoryConfigurator <TEndpointConfigurator> configurator, ServiceInstanceOptions options, Action <IServiceInstanceConfigurator <TEndpointConfigurator> > configure) where TEndpointConfigurator : IReceiveEndpointConfigurator { var instance = new ServiceInstance(); var definition = new InstanceEndpointDefinition(instance); configurator.ReceiveEndpoint(definition, options.EndpointNameFormatter, endpointConfigurator => { var instanceConfigurator = new ServiceInstanceConfigurator <TEndpointConfigurator>(configurator, options, endpointConfigurator); configure?.Invoke(instanceConfigurator); }); }
public static void CreateBackplaneEndpoints <T>(this IBusFactoryConfigurator configurator, IServiceProvider serviceProvider, IHost host, IReadOnlyDictionary <Type, IReadOnlyList <Type> > hubConsumers, Action <T> configureEndpoint = null) where T : class, IReceiveEndpointConfigurator { var factoryType = typeof(ScopeConsumerFactory <>); var consumerConfiguratorType = typeof(ConsumerConfigurator <>); foreach (var hub in hubConsumers) { var queueNameBase = host.Topology.CreateTemporaryQueueName($"signalRBackplane-{hub.Key.Name}-"); // Loop through our 5 hub consumers and create a temporary endpoint for each foreach (var consumer in hub.Value) { // remove `1 from generic type var name = consumer.Name; int index = name.IndexOf('`'); if (index > 0) { name = name.Remove(index); } configurator.ReceiveEndpoint($"{queueNameBase}{name}-", e => { configureEndpoint?.Invoke((T)e); IConsumerScopeProvider scopeProvider = new DependencyInjectionConsumerScopeProvider(serviceProvider); var concreteFactoryType = factoryType.MakeGenericType(consumer); var consumerFactory = Activator.CreateInstance(concreteFactoryType, scopeProvider); var concreteConsumerConfiguratorType = consumerConfiguratorType.MakeGenericType(consumer); var consumerConfigurator = Activator.CreateInstance(concreteConsumerConfiguratorType, consumerFactory, e); e.AddEndpointSpecification((IReceiveEndpointSpecification)consumerConfigurator); }); } } }
private void InMemoryBuild(IBusFactoryConfigurator configurator) { var groupHandlers = _handlerInfos.GroupBy(_ => _.QueueName); foreach (var groupHandler in groupHandlers) { configurator.ReceiveEndpoint(groupHandler.Key, cfg => { foreach (var handlerInfo in groupHandler) { var handlerMethod = GetHandlerMethod(handlerInfo.MessageType); var methodInfo = DatabusExecutionContext.Current.GetType().GetMethod("Handler").MakeGenericMethod(handlerInfo.MessageType); var delgate = Delegate.CreateDelegate(typeof(MessageHandler <>).MakeGenericType(handlerInfo.MessageType), DatabusExecutionContext.Current, methodInfo); handlerMethod.Invoke(null, new object[] { cfg, delgate, null }); Console.WriteLine($"{handlerInfo.MessageHandlerType.Name} for message {handlerInfo.MessageType.Name} in queue {handlerInfo.QueueName} registered"); } EndpointConfigure(cfg, groupHandler.Key); }); } }
public static void UseInMemoryScheduler(this IBusFactoryConfigurator configurator) { if (configurator == null) { throw new ArgumentNullException(nameof(configurator)); } ISchedulerFactory schedulerFactory = new StdSchedulerFactory(); var scheduler = schedulerFactory.GetScheduler(); var specification = new InMemorySchedulerBusFactorySpecification(scheduler); configurator.AddBusFactorySpecification(specification); configurator.ReceiveEndpoint("quartz", e => { configurator.UseMessageScheduler(e.InputAddress); e.Consumer(() => new ScheduleMessageConsumer(scheduler)); e.Consumer(() => new CancelScheduledMessageConsumer(scheduler)); }); }