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));
}
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));
}
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));
}
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 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 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 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 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 UntypedConsumerConfigurator(Func <Type, object> consumerFactory, IConsumerConfigurationObserver observer)
{
_consumerFactory = new DelegateConsumerFactory <TConsumer>(() => (TConsumer)consumerFactory(typeof(TConsumer)));
_specification = ConsumerConnectorCache <TConsumer> .Connector.CreateConsumerSpecification <TConsumer>();
_specification.ConnectConsumerConfigurationObserver(observer);
}
public ConsumerConfigurator(IConsumerFactory <TConsumer> consumerFactory, IConsumerConfigurationObserver observer)
{
_consumerFactory = consumerFactory;
_specification = ConsumerConnectorCache <TConsumer> .Connector.CreateConsumerSpecification <TConsumer>();
_specification.ConnectConsumerConfigurationObserver(observer);
}
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 JobConsumerMessageSpecification()
{
_submitJobSpecification = ConsumerConnectorCache <SubmitJobConsumer <TJob> > .Connector.CreateConsumerSpecification <SubmitJobConsumer <TJob> >();
_startJobSpecification = ConsumerConnectorCache <StartJobConsumer <TJob> > .Connector.CreateConsumerSpecification <StartJobConsumer <TJob> >();
_cancelJobSpecification = ConsumerConnectorCache <CancelJobConsumer <TJob> > .Connector.CreateConsumerSpecification <CancelJobConsumer <TJob> >();
_consumerSpecification = new ConsumerMessageSpecification <TConsumer, TJob>();
}
ConnectHandle IInstanceConnector.ConnectInstance(IConsumePipeConnector pipeConnector, object instance)
{
if (instance is TConsumer consumer)
{
IConsumerSpecification <TConsumer> specification = CreateConsumerSpecification <TConsumer>();
return(ConnectInstance(pipeConnector, consumer, specification));
}
throw new ConsumerException(
$"The instance type {TypeMetadataCache.GetShortName(instance.GetType())} does not match the consumer type: {TypeMetadataCache<TConsumer>.ShortName}");
}
ConnectHandle IInstanceConnector.ConnectInstance(IConsumePipeConnector pipeConnector, object instance)
{
var consumer = instance as TConsumer;
if (consumer == null)
{
throw new ConsumerException(
$"The instance type {instance.GetType().GetTypeName()} does not match the consumer type: {TypeMetadataCache<TConsumer>.ShortName}");
}
IConsumerSpecification <TConsumer> specification = CreateConsumerSpecification <TConsumer>();
return(ConnectInstance(pipeConnector, consumer, specification));
}
public ConnectHandle ConnectConsumer(IConsumePipeConnector consumePipe, IConsumerFactory <TConsumer> consumerFactory,
IConsumerSpecification <TConsumer> specification)
{
IConsumerMessageSpecification <TConsumer, TMessage> messageSpecification = specification.GetMessageSpecification <TMessage>();
IPipe <ConsumerConsumeContext <TConsumer, TMessage> > consumerPipe = messageSpecification.Build(_consumeFilter);
IPipe <ConsumeContext <TMessage> > messagePipe = messageSpecification.BuildMessagePipe(x =>
{
x.UseFilter(new ConsumerMessageFilter <TConsumer, TMessage>(consumerFactory, consumerPipe));
});
return(consumePipe.ConnectConsumePipe(messagePipe));
}
/// <summary>
/// Connect a consumer to the bus instance's default endpoint
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connector"></param>
/// <param name="consumerFactory"></param>
/// <param name="pipeSpecifications"></param>
/// <returns></returns>
public static ConnectHandle ConnectConsumer<T>(this IConsumePipeConnector connector, IConsumerFactory<T> consumerFactory,
params IPipeSpecification<ConsumerConsumeContext<T>>[] pipeSpecifications)
where T : class, IConsumer
{
if (connector == null)
throw new ArgumentNullException(nameof(connector));
if (consumerFactory == null)
throw new ArgumentNullException(nameof(consumerFactory));
IConsumerSpecification<T> specification = ConsumerConnectorCache<T>.Connector.CreateConsumerSpecification<T>();
foreach (IPipeSpecification<ConsumerConsumeContext<T>> pipeSpecification in pipeSpecifications)
{
specification.AddPipeSpecification(pipeSpecification);
}
return ConsumerConnectorCache<T>.Connector.ConnectConsumer(connector, consumerFactory, specification);
}
public ConnectHandle ConnectConsumer(IConsumePipeConnector consumePipe, IConsumerFactory <TConsumer> consumerFactory,
IConsumerSpecification <TConsumer> specification)
{
var jobServiceOptions = specification.Options <JobServiceOptions>();
var jobService = jobServiceOptions.JobService;
if (jobService == null || jobServiceOptions.InstanceEndpointConfigurator == 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> >();
var jobTypeId = jobService.GetJobTypeId <TJob>();
IConsumerMessageSpecification <TConsumer, TJob> messageSpecification = specification.GetMessageSpecification <TJob>();
var jobSpecification = messageSpecification as JobConsumerMessageSpecification <TConsumer, TJob>;
if (jobSpecification == null)
{
throw new ArgumentException("The consumer specification did not match the message specification type");
}
var submitJobHandle = ConnectSubmitJobConsumer(consumePipe, jobSpecification.SubmitJobSpecification, options, jobTypeId);
IPipe <ConsumeContext <TJob> > jobPipe = CreateJobPipe(consumerFactory, specification);
var startJobHandle = ConnectStartJobConsumer(consumePipe, jobSpecification.StartJobSpecification, options, jobService, jobPipe);
ConfigureStartJobConsumer(jobServiceOptions.InstanceEndpointConfigurator, options, jobService, jobPipe);
var finalizeJobHandle = ConnectFinalizeJobConsumer(consumePipe, jobSpecification.FinalizeJobSpecification, options, jobService);
var superviseJobHandle = ConnectSuperviseJobConsumer(consumePipe, jobSpecification.SuperviseJobSpecification, jobService);
ConfigureSuperviseJobConsumer(jobServiceOptions.InstanceEndpointConfigurator, jobService);
return(new MultipleConnectHandle(submitJobHandle, startJobHandle, finalizeJobHandle, superviseJobHandle));
}
/// <summary>
/// Connect a consumer to the bus instance's default endpoint
/// </summary>
/// <typeparam name="TConsumer"></typeparam>
/// <param name="connector"></param>
/// <param name="consumerFactory"></param>
/// <param name="pipeSpecifications"></param>
/// <returns></returns>
public static ConnectHandle ConnectConsumer <TConsumer>(this IConsumePipeConnector connector, IConsumerFactory <TConsumer> consumerFactory,
params IPipeSpecification <ConsumerConsumeContext <TConsumer> >[] pipeSpecifications)
where TConsumer : class, IConsumer
{
if (connector == null)
{
throw new ArgumentNullException(nameof(connector));
}
if (consumerFactory == null)
{
throw new ArgumentNullException(nameof(consumerFactory));
}
LogContext.Debug?.Log("Connecting Consumer: {ConsumerType} (using supplied consumer factory)", TypeMetadataCache <TConsumer> .ShortName);
IConsumerSpecification <TConsumer> specification = ConsumerConnectorCache <TConsumer> .Connector.CreateConsumerSpecification <TConsumer>();
foreach (IPipeSpecification <ConsumerConsumeContext <TConsumer> > pipeSpecification in pipeSpecifications)
{
specification.AddPipeSpecification(pipeSpecification);
}
return(ConsumerConnectorCache <TConsumer> .Connector.ConnectConsumer(connector, consumerFactory, specification));
}
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;
}
}
static IPipe <ConsumeContext <TJob> > CreateJobPipe(IConsumerFactory <TConsumer> consumerFactory, IConsumerSpecification <TConsumer> specification)
{
IConsumerMessageSpecification <TConsumer, TJob> messageSpecification = specification.GetMessageSpecification <TJob>();
var options = specification.Options <JobOptions <TJob> >();
var jobFilter = new JobConsumerMessageFilter <TConsumer, TJob>(options.RetryPolicy);
IPipe <ConsumerConsumeContext <TConsumer, TJob> > consumerPipe = messageSpecification.Build(jobFilter);
IPipe <ConsumeContext <TJob> > messagePipe = messageSpecification.BuildMessagePipe(x =>
{
x.UseFilter(new ConsumerMessageFilter <TConsumer, TJob>(consumerFactory, consumerPipe));
});
return(messagePipe);
}