/// <summary>
/// Connect a consumer with a consumer type and object factory method for the consumer
/// </summary>
/// <param name="connector"></param>
/// <param name="consumerType"></param>
/// <param name="objectFactory"></param>
/// <returns></returns>
public static ConnectHandle ConnectConsumer(this IConsumePipeConnector connector, Type consumerType, Func <Type, object> objectFactory)
{
if (connector == null)
{
throw new ArgumentNullException(nameof(connector));
}
if (consumerType == null)
{
throw new ArgumentNullException(nameof(consumerType));
}
if (objectFactory == null)
{
throw new ArgumentNullException(nameof(objectFactory));
}
if (!consumerType.HasInterface <IConsumer>())
{
throw new ArgumentException("The consumer type must implement an IConsumer interface");
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Subscribing Consumer: {0} (by type, using object consumer factory)", consumerType);
}
return(ConsumerConnectorCache.Connect(connector, consumerType, objectFactory));
}
public ConnectHandle ConnectSaga <T>(IConsumePipeConnector consumePipe, ISagaRepository <T> sagaRepository, ISagaSpecification <T> specification)
where T : class, ISaga
{
var handles = new List <ConnectHandle>();
try
{
foreach (ISagaMessageConnector <T> connector in _connectors.Cast <ISagaMessageConnector <T> >())
{
var handle = connector.ConnectSaga(consumePipe, sagaRepository, specification);
handles.Add(handle);
}
return(new MultipleConnectHandle(handles));
}
catch (Exception)
{
foreach (var handle in handles)
{
handle.Dispose();
}
throw;
}
}
public SetPrefetchCountConsumer(IConsumePipeConnector managementPipe, ModelContext modelContext, ISetPrefetchCount filter)
{
_modelContext = modelContext;
_filter = filter;
_handle = managementPipe.ConnectInstance(this);
}
/// <summary>
/// Connects any consumers for the object to the message dispatcher
/// </summary>
/// <typeparam name="T">The consumer type</typeparam>
/// <param name="bus">The service bus instance to call this method on.</param>
/// <param name="instance">The instance to subscribe.</param>
/// <returns>The unsubscribe action that can be called to unsubscribe the instance
/// passed as an argument.</returns>
public static ConnectHandle ConnectInstance <T>(this IConsumePipeConnector bus, T instance)
where T : class, IConsumer
{
var connector = InstanceConnectorCache.GetInstanceConnector <T>();
return(connector.ConnectInstance(bus, instance));
}
/// <summary>
/// Connects the saga to the bus
/// </summary>
/// <typeparam name="T">The saga type</typeparam>
/// <param name="bus">The bus to which the saga is to be connected</param>
/// <param name="sagaRepository">The saga repository</param>
/// <param name="pipeSpecifications"></param>
public static ConnectHandle ConnectSaga <T>(this IConsumePipeConnector bus, ISagaRepository <T> sagaRepository,
params IPipeSpecification <SagaConsumeContext <T> >[] pipeSpecifications)
where T : class, ISaga
{
if (bus == null)
{
throw new ArgumentNullException(nameof(bus));
}
if (sagaRepository == null)
{
throw new ArgumentNullException(nameof(sagaRepository));
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Subscribing Saga: {0}", TypeMetadataCache <T> .ShortName);
}
ISagaSpecification <T> specification = SagaConnectorCache <T> .Connector.CreateSagaSpecification <T>();
foreach (IPipeSpecification <SagaConsumeContext <T> > pipeSpecification in pipeSpecifications)
{
specification.AddPipeSpecification(pipeSpecification);
}
return(SagaConnectorCache <T> .Connector.ConnectSaga(bus, sagaRepository, specification));
}
public ConnectHandle ConnectConsumer(IConsumePipeConnector consumePipe, IConsumerFactory <TConsumer> consumerFactory,
IConsumerSpecification <TConsumer> specification)
{
var options = specification.Options <BatchOptions>();
var messageLimit = options.MessageLimit;
var timeLimit = options.TimeLimit;
var concurrencyLimit = options.ConcurrencyLimit;
IConsumerMessageSpecification <TConsumer, Batch <TMessage> > batchMessageSpecification = specification.GetMessageSpecification <Batch <TMessage> >();
var consumeFilter = new MethodConsumerMessageFilter <TConsumer, Batch <TMessage> >();
IPipe <ConsumerConsumeContext <TConsumer, Batch <TMessage> > > batchConsumerPipe = batchMessageSpecification.Build(consumeFilter);
var factory = new BatchConsumerFactory <TConsumer, TMessage>(consumerFactory, messageLimit, concurrencyLimit, timeLimit, batchConsumerPipe);
IConsumerSpecification <IConsumer <TMessage> > messageConsumerSpecification =
ConsumerConnectorCache <IConsumer <TMessage> > .Connector.CreateConsumerSpecification <IConsumer <TMessage> >();
IConsumerMessageSpecification <IConsumer <TMessage>, TMessage> messageSpecification =
messageConsumerSpecification.GetMessageSpecification <TMessage>();
IPipe <ConsumerConsumeContext <IConsumer <TMessage>, TMessage> > consumerPipe =
messageSpecification.Build(new MethodConsumerMessageFilter <IConsumer <TMessage>, TMessage>());
IPipe <ConsumeContext <TMessage> > messagePipe = messageSpecification.BuildMessagePipe(x =>
{
x.UseFilter(new ConsumerMessageFilter <IConsumer <TMessage>, TMessage>(factory, consumerPipe));
});
var handle = consumePipe.ConnectConsumePipe(messagePipe);
return(new BatchConnectHandle(handle, factory));
}
ConnectHandle ConnectStartJobConsumer(IConsumePipeConnector consumePipe, IConsumerSpecification <StartJobConsumer <TJob> > specification,
JobOptions <TJob> options, IJobService jobService, IPipe <ConsumeContext <TJob> > pipe)
{
var consumerFactory = new DelegateConsumerFactory <StartJobConsumer <TJob> >(() => new StartJobConsumer <TJob>(jobService, options, pipe));
return(_startJobConsumerConnector.ConnectConsumer(consumePipe, consumerFactory, specification));
}
ConnectHandle ConnectSubmitJobConsumer(IConsumePipeConnector consumePipe,
IConsumerSpecification <SubmitJobConsumer <TJob> > specification, JobOptions <TJob> options)
{
var consumerFactory = new DelegateConsumerFactory <SubmitJobConsumer <TJob> >(() => new SubmitJobConsumer <TJob>(options));
return(_submitJobConsumerConnector.ConnectConsumer(consumePipe, consumerFactory, specification));
}
ConnectHandle ConnectCancelJobConsumer(IConsumePipeConnector consumePipe, IConsumerSpecification <CancelJobConsumer <TJob> > specification,
IJobService jobService)
{
var consumerFactory = new DelegateConsumerFactory <CancelJobConsumer <TJob> >(() => new CancelJobConsumer <TJob>(jobService));
return(_cancelJobConsumerConnector.ConnectConsumer(consumePipe, consumerFactory, specification));
}
ConnectHandle IConsumerConnector.ConnectConsumer <TConsumer>(IConsumePipeConnector consumePipe, IConsumerFactory <TConsumer> consumerFactory,
IConsumerSpecification <TConsumer> specification)
{
var handles = new List <ConnectHandle>();
try
{
foreach (IConsumerMessageConnector <TConsumer> connector in _connectors.Cast <IConsumerMessageConnector <TConsumer> >())
{
var handle = connector.ConnectConsumer(consumePipe, consumerFactory, specification);
handles.Add(handle);
}
return(new MultipleConnectHandle(handles));
}
catch (Exception)
{
foreach (var handle in handles)
{
handle.Dispose();
}
throw;
}
}
public ConnectHandle ConnectSaga <T>(IConsumePipeConnector consumePipe, ISagaRepository <T> sagaRepository,
params IPipeSpecification <SagaConsumeContext <T> >[] pipeSpecifications)
where T : class, ISaga
{
var handles = new List <ConnectHandle>();
try
{
foreach (var connector in _connectors)
{
var handle = connector.ConnectSaga(consumePipe, sagaRepository, pipeSpecifications);
handles.Add(handle);
}
return(new MultipleConnectHandle(handles));
}
catch (Exception)
{
foreach (var handle in handles)
{
handle.Dispose();
}
throw;
}
}
public static ConnectHandle ConnectStateMachineSaga <TInstance>(this IConsumePipeConnector pipe, IKernel kernel)
where TInstance : class, SagaStateMachineInstance
{
SagaStateMachine <TInstance> stateMachine = kernel.ResolveSagaStateMachine <TInstance>();
return(pipe.ConnectStateMachineSaga(stateMachine, kernel));
}
ConnectHandle IInstanceMessageConnector <TConsumer> .ConnectInstance(IConsumePipeConnector pipeConnector, TConsumer instance,
IConsumerSpecification <TConsumer> specification)
{
if (pipeConnector == null)
{
throw new ArgumentNullException(nameof(pipeConnector));
}
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
if (specification == null)
{
throw new ArgumentNullException(nameof(specification));
}
IConsumerMessageSpecification <TConsumer, TMessage> messageSpecification = specification.GetMessageSpecification <TMessage>();
IPipe <ConsumerConsumeContext <TConsumer, TMessage> > consumerPipe = messageSpecification.Build(_consumeFilter);
IPipe <ConsumeContext <TMessage> > messagePipe = Pipe.New <ConsumeContext <TMessage> >(x =>
{
x.UseFilter(new InstanceMessageFilter <TConsumer, TMessage>(instance, consumerPipe));
});
return(pipeConnector.ConnectConsumePipe(messagePipe));
}
public ConnectHandle ConnectInstance <T>(IConsumePipeConnector pipeConnector, T instance, IConsumerSpecification <T> specification)
where T : class
{
var handles = new List <ConnectHandle>();
try
{
foreach (IInstanceMessageConnector <T> connector in _connectors.Cast <IInstanceMessageConnector <T> >())
{
var handle = connector.ConnectInstance(pipeConnector, instance, specification);
handles.Add(handle);
}
return(new MultipleConnectHandle(handles));
}
catch (Exception)
{
foreach (var handle in handles)
{
handle.Dispose();
}
throw;
}
}
public ConnectHandle ConnectConsumer(IConsumePipeConnector consumePipe, IConsumerFactory <TConsumer> consumerFactory,
IConsumerSpecification <TConsumer> specification)
{
var options = specification.Options <BatchOptions>();
var messageLimit = options.MessageLimit;
var timeLimit = options.TimeLimit;
var concurrencyLimit = options.ConcurrencyLimit;
IConsumerMessageSpecification <TConsumer, Batch <TMessage> > batchMessageSpecification = specification.GetMessageSpecification <Batch <TMessage> >();
var consumeFilter = new MethodConsumerMessageFilter <TConsumer, Batch <TMessage> >();
IPipe <ConsumerConsumeContext <TConsumer, Batch <TMessage> > > batchConsumerPipe = batchMessageSpecification.Build(consumeFilter);
IPipe <ConsumeContext <Batch <TMessage> > > batchMessagePipe = batchMessageSpecification.BuildMessagePipe(x =>
{
x.UseFilter(new ConsumerMessageFilter <TConsumer, Batch <TMessage> >(consumerFactory, batchConsumerPipe));
});
IBatchCollector <TMessage> collector = null;
if (options.GroupKeyProvider == null)
{
collector = new BatchCollector <TMessage>(messageLimit, timeLimit, concurrencyLimit, batchMessagePipe);
}
else
{
if (options.GroupKeyProvider.GetType().ClosesType(typeof(IGroupKeyProvider <,>), out Type[] types))
ConnectHandle ConnectSuperviseJobConsumer(IConsumePipeConnector consumePipe, IConsumerSpecification <SuperviseJobConsumer> specification,
IJobService jobService)
{
var consumerFactory = new DelegateConsumerFactory <SuperviseJobConsumer>(() => new SuperviseJobConsumer(jobService));
return(_superviseJobConsumerConnector.ConnectConsumer(consumePipe, consumerFactory, specification));
}
public ConnectHandle ConnectConsumer(IConsumePipeConnector consumePipe, IConsumerFactory <TConsumer> consumerFactory,
IConsumerSpecification <TConsumer> specification)
{
var jobServiceOptions = specification.Options <JobServiceOptions>();
if (jobServiceOptions.JobService == null)
{
throw new ConfigurationException(
"The job service must be configured prior to configuring a job consumer, using either ConfigureJobServiceEndpoints or ConfigureJobService");
}
var options = specification.Options <JobOptions <TJob> >();
IConsumerMessageSpecification <TConsumer, TJob> messageSpecification = specification.GetMessageSpecification <TJob>();
var turnoutSpecification = messageSpecification as JobConsumerMessageSpecification <TConsumer, TJob>;
if (turnoutSpecification == null)
{
throw new ArgumentException("The consumer specification did not match the message specification type");
}
var submitJobHandle = ConnectSubmitJobConsumer(consumePipe, turnoutSpecification.SubmitJobSpecification, options);
var startJobHandle = ConnectStartJobConsumer(consumePipe, turnoutSpecification.StartJobSpecification, options, jobServiceOptions.JobService,
CreateJobPipe(consumerFactory, specification));
var cancelJobHandle = ConnectSuperviseJobConsumer(consumePipe, turnoutSpecification.SuperviseJobSpecification, jobServiceOptions.JobService);
return(new MultipleConnectHandle(submitJobHandle, startJobHandle, cancelJobHandle));
}
public static ConnectHandle ConnectStateMachineSaga <TInstance>(this IConsumePipeConnector bus, SagaStateMachine <TInstance> stateMachine,
ISagaRepository <TInstance> repository)
where TInstance : class, SagaStateMachineInstance
{
var connector = new StateMachineConnector <TInstance>(stateMachine);
return(connector.ConnectSaga(bus, repository));
}
public static ConnectHandle ConnectStateMachineSaga <TInstance>(this IConsumePipeConnector pipe, SagaStateMachine <TInstance> stateMachine,
IWindsorContainer container)
where TInstance : class, SagaStateMachineInstance
{
RegisterScopedContextProviderIfNotPresent(container);
return(ConnectStateMachineSaga(pipe, stateMachine, container.Kernel));
}
ConnectHandle ConnectFinalizeJobConsumer(IConsumePipeConnector consumePipe, IConsumerSpecification <FinalizeJobConsumer <TJob> > specification,
JobOptions <TJob> options, Guid jobTypeId, IJobService jobService)
{
var consumerFactory = new DelegateConsumerFactory <FinalizeJobConsumer <TJob> >(() => new FinalizeJobConsumer <TJob>(jobService, options, jobTypeId,
TypeMetadataCache <TConsumer> .ShortName));
return(_finalizeJobConsumerConnector.ConnectConsumer(consumePipe, consumerFactory, specification));
}
public ConnectHandle ConnectHandler(IConsumePipeConnector consumePipe, MessageHandler <TMessage> handler,
IBuildPipeConfigurator <ConsumeContext <TMessage> > configurator)
{
configurator ??= new PipeConfigurator <ConsumeContext <TMessage> >();
configurator.AddPipeSpecification(new HandlerPipeSpecification <TMessage>(handler));
return(consumePipe.ConnectConsumePipe(configurator.Build()));
}
public static ConnectHandle ConnectStateMachineSaga <TInstance>(this IConsumePipeConnector pipe, ILifetimeScope scope, string name = "message",
Action <ContainerBuilder, ConsumeContext> configureScope = null)
where TInstance : class, SagaStateMachineInstance
{
SagaStateMachine <TInstance> stateMachine = ResolveSagaStateMachine <TInstance>(scope);
return(pipe.ConnectStateMachineSaga(stateMachine, scope, name, configureScope));
}
public static ConnectHandle ConnectStateMachineSaga <TInstance>(this IConsumePipeConnector pipe, IContainer container,
Action <ConsumeContext> configureScope = null)
where TInstance : class, SagaStateMachineInstance
{
SagaStateMachine <TInstance> stateMachine = GetSagaStateMachine <TInstance>(container);
return(pipe.ConnectStateMachineSaga(stateMachine, container, configureScope));
}
public static ConnectHandle ConnectStateMachineSaga <TInstance>(this IConsumePipeConnector bus, SagaStateMachine <TInstance> stateMachine,
Container container, Action <ISagaConfigurator <TInstance> > configure = null)
where TInstance : class, SagaStateMachineInstance
{
ISagaRepository <TInstance> repository = CreateSagaRepository <TInstance>(container);
return(bus.ConnectStateMachineSaga(stateMachine, repository, configure));
}
public static ConnectHandle ConnectStateMachineSaga<TInstance>(this IConsumePipeConnector bus, SagaStateMachine<TInstance> stateMachine,
ISagaRepositoryFactory repositoryFactory, Action<ISagaConfigurator<TInstance>> configure = null)
where TInstance : class, SagaStateMachineInstance
{
var repository = repositoryFactory.CreateSagaRepository<TInstance>();
return ConnectStateMachineSaga(bus, stateMachine, repository, configure);
}
/// <summary>
/// Subscribe a consumer with a default constructor to the bus's default endpoint
/// </summary>
/// <typeparam name="TConsumer"></typeparam>
/// <param name="connector"></param>
/// <param name="pipeSpecifications"></param>
/// <returns></returns>
public static ConnectHandle ConnectConsumer<TConsumer>(this IConsumePipeConnector connector,
params IPipeSpecification<ConsumerConsumeContext<TConsumer>>[] pipeSpecifications)
where TConsumer : class, IConsumer, new()
{
if (connector == null)
throw new ArgumentNullException(nameof(connector));
return ConnectConsumer(connector, new DefaultConstructorConsumerFactory<TConsumer>(), pipeSpecifications);
}
public static ConnectHandle ConnectStateMachineSaga <TInstance>(this IConsumePipeConnector pipe, IWindsorContainer container)
where TInstance : class, SagaStateMachineInstance
{
ISagaStateMachineFactory stateMachineFactory = new WindsorSagaStateMachineFactory(container.Kernel);
SagaStateMachine <TInstance> stateMachine = stateMachineFactory.CreateStateMachine <TInstance>();
return(pipe.ConnectStateMachineSaga(stateMachine, container));
}
private void ConnectPipe <TMessage>(IConsumePipeConnector pipeConnector) where TMessage : class
{
var pipe = Pipe.New <ConsumeContext <TMessage> >(cfg =>
{
cfg.UseExecute(ctx => _workflow.ConsumeMessage(ctx.Message));
});
pipeConnector.ConnectConsumePipe(pipe);
}
public static ConnectHandle ConnectConsumer <T>(this IConsumePipeConnector filter, Func <T> factoryMethod, params IPipeSpecification <ConsumerConsumeContext <T> >[] specifications)
where T : class
{
var consumerFactory = new DelegateConsumerFactory <T>(factoryMethod);
IConsumerConnector connector = ConsumerConnectorCache.GetConsumerConnector <T>();
return(connector.ConnectConsumer(filter, consumerFactory, specifications));
}
public static ConnectHandle ConnectConsumer <T>(this IConsumePipeConnector filter,
params IPipeSpecification <ConsumerConsumeContext <T> >[] pipeSpecifications)
where T : class, new()
{
var consumerFactory = new DefaultConstructorConsumerFactory <T>();
IConsumerConnector connector = ConsumerConnectorCache.GetConsumerConnector <T>();
return(connector.ConnectConsumer(filter, consumerFactory, pipeSpecifications));
}
