/// <summary>
/// Configures a Turnout on the receive endpoint, which executes a long-running job and supervises the job until it
/// completes.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="busFactoryConfigurator">The bus factory configuration to use a separate endpoint for the control traffic</param>
/// <param name="queueName"></param>
/// <param name="configure"></param>
/// <param name="host"></param>
public static void TurnoutEndpoint <T>(this IServiceBusBusFactoryConfigurator busFactoryConfigurator, IServiceBusHost host, string queueName,
Action <ITurnoutServiceConfigurator <T> > configure)
where T : class
{
string expiredQueueName = $"{queueName}-expired";
// configure the message expiration endpoint, so it's available at startup
busFactoryConfigurator.ReceiveEndpoint(expiredQueueName, expiredEndpointConfigurator =>
{
expiredEndpointConfigurator.SubscribeMessageTopics = false;
// configure the turnout management endpoint
busFactoryConfigurator.ReceiveEndpoint(new TurnoutEndpointDefinition(), null, turnoutEndpointConfigurator =>
{
turnoutEndpointConfigurator.PrefetchCount = 100;
turnoutEndpointConfigurator.EnableExpress = true;
turnoutEndpointConfigurator.SubscribeMessageTopics = false;
turnoutEndpointConfigurator.EnableDeadLetteringOnMessageExpiration = true;
turnoutEndpointConfigurator.ForwardDeadLetteredMessagesTo = expiredQueueName;
turnoutEndpointConfigurator.AutoDeleteOnIdle = Defaults.TemporaryAutoDeleteOnIdle;
// configure the input queue endpoint
busFactoryConfigurator.ReceiveEndpoint(queueName, commandEndpointConfigurator =>
{
commandEndpointConfigurator.SubscribeMessageTopics = false;
commandEndpointConfigurator.ConfigureTurnoutEndpoints(busFactoryConfigurator, turnoutEndpointConfigurator, expiredEndpointConfigurator,
configure);
});
});
});
}
/// <summary>
/// Configures a Turnout on the receive endpoint, which executes a long-running job and supervises the job until it
/// completes.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="busFactoryConfigurator">The bus factory configuration to use a separate endpoint for the control traffic</param>
/// <param name="queueName"></param>
/// <param name="configure"></param>
/// <param name="host"></param>
public static void TurnoutEndpoint <T>(this IServiceBusBusFactoryConfigurator busFactoryConfigurator, IServiceBusHost host, string queueName,
Action <ITurnoutServiceConfigurator <T> > configure)
where T : class
{
string expiredQueueName = $"{queueName}-expired";
// configure the message expiration endpoint, so it's available at startup
busFactoryConfigurator.ReceiveEndpoint(host, expiredQueueName, expiredEndpointConfigurator =>
{
// configure the turnout management endpoint
var temporaryQueueName = host.GetTemporaryQueueName("turnout-");
busFactoryConfigurator.ReceiveEndpoint(host, temporaryQueueName, turnoutEndpointConfigurator =>
{
turnoutEndpointConfigurator.PrefetchCount = 100;
turnoutEndpointConfigurator.AutoDeleteOnIdle = TimeSpan.FromMinutes(5);
turnoutEndpointConfigurator.EnableExpress = true;
turnoutEndpointConfigurator.EnableDeadLetteringOnMessageExpiration = true;
turnoutEndpointConfigurator.ForwardDeadLetteredMessagesTo = expiredQueueName;
// configure the input queue endpoint
busFactoryConfigurator.ReceiveEndpoint(host, queueName, commandEndpointConfigurator =>
{
commandEndpointConfigurator.ConfigureTurnoutEndpoints(busFactoryConfigurator, turnoutEndpointConfigurator, expiredEndpointConfigurator,
configure);
});
});
});
}
public static void ConfigureFrameworkWebServices(IServiceBusBusFactoryConfigurator configurator)
{
ConfigureHost(configurator);
configurator.ReceiveEndpoint(Constants.FrameWorkQueue, e =>
{
e.Consumer <FrameworkStringIntConsumer>();
});
configurator.ReceiveEndpoint(Constants.FrameWorkRpcQueue, e =>
{
e.Consumer <FrameworkStringIntRpcConsumer>();
});
}
protected override void ConfigureBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host)
{
configurator.ReceiveEndpoint(host, "input_queue_error", x =>
{
_errorHandler = Handled<PingMessage>(x);
});
}
public static void ReceiveEndpoint(this IServiceBusBusFactoryConfigurator @this, IServiceBusHost host,
ServiceContext serviceContext,
ServicePartitionInformation partitionInformation,
Action <IServiceBusReceiveEndpointConfigurator> configureEndpoint)
{
@this.ReceiveEndpoint(host, UniqueQueueName(serviceContext, partitionInformation), configureEndpoint);
}
protected override void ConfigureServiceBusBus(IServiceBusBusFactoryConfigurator configurator)
{
configurator.ReceiveEndpoint("test_endpoint_scope/input_queue", e =>
{
_handler = Handled <PingMessage>(e);
});
}
protected override void ConfigureServiceBusBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host)
{
configurator.ReceiveEndpoint(host, "input_queue_error", x =>
{
_errorHandler = Handled <PingMessage>(x);
});
}
protected override void ConfigureServiceBusBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host)
{
configurator.UseServiceBusMessageScheduler();
base.ConfigureServiceBusBusHost(configurator, host);
configurator.TurnoutEndpoint <LongTimeJob>(host, "service_queue", endpoint =>
{
endpoint.SuperviseInterval = TimeSpan.FromSeconds(1);
endpoint.SetJobFactory(async context =>
{
Console.WriteLine("Starting job: {0}", context.Command.Id);
await Task.Delay(context.Command.Duration).ConfigureAwait(false);
Console.WriteLine("Finished job: {0}", context.Command.Id);
});
_serviceAddress = endpoint.InputAddress;
});
_stateMachine = new TurnoutJobStateMachine();
_repository = new MessageSessionSagaRepository <TurnoutJobState>();
configurator.ReceiveEndpoint(host, "service_state", endpoint =>
{
endpoint.RequiresSession = true;
endpoint.MessageWaitTimeout = TimeSpan.FromHours(8);
endpoint.StateMachineSaga(_stateMachine, _repository);
});
}
protected override void ConfigureServiceBusBus(IServiceBusBusFactoryConfigurator configurator)
{
configurator.ReceiveEndpoint("input-fault", endpointConfigurator =>
{
_faulted = Handled <Fault <TestCommand> >(endpointConfigurator);
});
}
public void Build(IServiceBusHost host, IServiceBusBusFactoryConfigurator configurator)
{
addressProvider.Register("error");
var consumerTypes = GetConsumerTypes();
var messageTypes = GetMessageTypes();
foreach (var messageType in messageTypes)
{
addressProvider.Register(messageType);
var messageConsumerTypes = GetConsumerTypes(messageType, consumerTypes);
if (messageConsumerTypes.Any())
{
foreach (var consumerType in messageConsumerTypes)
{
RegisterConsumerType(consumerType);
var queueName = addressProvider.GetQueueName(messageType);
var receiveConfigurator = GetReceiveEndpointConfigurator(messageType, consumerType);
configurator.ReceiveEndpoint(host, queueName, receiveConfigurator);
}
}
}
}
protected override void ConfigureServiceBusBus(IServiceBusBusFactoryConfigurator configurator)
{
configurator.ReceiveEndpoint(e =>
{
e.RemoveSubscriptions = true;
_consumer = HandledByConsumer <PingMessage>(e);
});
}
protected override void ConfigureServiceBusBus(IServiceBusBusFactoryConfigurator configurator)
{
configurator.ReceiveEndpoint("input_queue_error", x =>
{
x.ConfigureConsumeTopology = false;
_errorHandler = Handled <PingMessage>(x);
});
}
protected override void ConfigureServiceBusBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host)
{
base.ConfigureServiceBusBusHost(configurator, host);
configurator.ReceiveEndpoint(host, e =>
{
e.RemoveSubscriptions = true;
_consumer = HandledByConsumer <PingMessage>(e);
});
}
protected override void ConfigureServiceBusBus(IServiceBusBusFactoryConfigurator configurator)
{
configurator.ReceiveEndpoint("input_queue_dl", x =>
{
x.ConfigureConsumeTopology = false;
x.ConfigureDeadLetterQueueDeadLetterTransport();
});
}
public void ReceiveEndpoint(string queueName, int consumerLimit, Action <IReceiveEndpointConfigurator> configureEndpoint)
{
_configurator.ReceiveEndpoint(_host, queueName, x =>
{
x.PrefetchCount = (ushort)consumerLimit;
configureEndpoint(x);
});
}
/// <inheritdoc />
public override void SetEndpoint(IServiceBusBusFactoryConfigurator busCfg, IServiceBusHost host)
=> busCfg.ReceiveEndpoint(host, Name, endpointConfig =>
{
_configurator?.Invoke(endpointConfig);
foreach (Action <IServiceBusReceiveEndpointConfigurator> consumerConfig in _consumers)
{
consumerConfig?.Invoke(endpointConfig);
}
});
protected override void ConfigureServiceBusBus(IServiceBusBusFactoryConfigurator configurator)
{
configurator.ReceiveEndpoint("input_queue_dl", x =>
{
x.ConfigureConsumeTopology = false;
x.ConfigureDeadLetterQueueErrorTransport();
x.Handler <PongMessage>(async context => throw new IntentionalTestException());
});
}
public static void ConfigureCoreWebServices(IServiceBusBusFactoryConfigurator configurator,
IBusRegistrationContext context)
{
ConfigureHost(configurator);
configurator.ReceiveEndpoint(Constants.CoreRpcQueue, e =>
{
e.ConfigureConsumer <CoreStringIntRpcConsumer>(context);
});
configurator.ReceiveEndpoint(Constants.CoreWorkQueue, e =>
{
e.ConfigureConsumer <CoreStringIntConsumer>(context);
});
configurator.ReceiveEndpoint("CoreCorrelationStart", e =>
{
e.ConfigureConsumer <CorrelationStartConsumer>(context);
});
}
void ConfigureExecuteActivity <TActivity, TArguments>(IServiceBusBusFactoryConfigurator cfg, IServiceBusHost host)
where TActivity : class, ExecuteActivity <TArguments>, new()
where TArguments : class
{
cfg.ReceiveEndpoint(host, GetExecuteActivityQueueName(typeof(TActivity)), e =>
{
e.PrefetchCount = 16;
e.SubscribeMessageTopics = false;
e.ExecuteActivityHost <TActivity, TArguments>();
});
}
private void ConfigureBusEndpoints(IServiceBusBusFactoryConfigurator factoryConfigurator)
{
foreach (var consumerType in ConsumerTypes)
{
SetNames(consumerType, out var queueName, out var topicName, out var subscriptionName);
factoryConfigurator.ReceiveEndpoint(queueName, endpointConfigurator =>
{
endpointConfigurator.Subscribe(topicName, subscriptionName);
endpointConfigurator.ConfigureConsumer(_serviceProvider, consumerType);
});
}
}
/// <summary>
/// Declare a ReceiveEndpoint using a unique generated queue name. This queue defaults to auto-delete
/// and non-durable. By default all services bus instances include a default receiveEndpoint that is
/// of this type (created automatically upon the first receiver binding).
/// </summary>
/// <param name="configurator"></param>
/// <param name="host"></param>
/// <param name="configure"></param>
public static void ReceiveEndpoint(this IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host,
Action <IServiceBusReceiveEndpointConfigurator> configure)
{
var queueName = host.Topology.CreateTemporaryQueueName("endpoint");
configurator.ReceiveEndpoint(host, queueName, x =>
{
x.AutoDeleteOnIdle = Defaults.TemporaryAutoDeleteOnIdle;
configure(x);
});
}
protected override void ConfigureBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host)
{
base.ConfigureBusHost(configurator, host);
configurator.ReceiveEndpoint(host, "input_express", x =>
{
x.EnableExpress = true;
x.AutoDeleteOnIdle = TimeSpan.FromMinutes(5);
_handled = Handled<PingMessage>(x);
});
}
protected override void ConfigureBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host)
{
base.ConfigureBusHost(configurator, host);
configurator.ReceiveEndpoint(host, "input_express", x =>
{
x.EnableExpress = true;
x.AutoDeleteOnIdle = TimeSpan.FromMinutes(5);
_handled = Handled <PingMessage>(x);
});
}
/// <summary>
/// Declare a ReceiveEndpoint using a unique generated queue name. This queue defaults to auto-delete
/// and non-durable. By default all services bus instances include a default receiveEndpoint that is
/// of this type (created automatically upon the first receiver binding).
/// </summary>
/// <param name="configurator"></param>
/// <param name="host"></param>
/// <param name="configure"></param>
public static void ReceiveEndpoint(this IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host,
Action <IServiceBusReceiveEndpointConfigurator> configure)
{
var queueName = host.GetTemporaryQueueName("endpoint");
configurator.ReceiveEndpoint(host, queueName, x =>
{
x.AutoDeleteOnIdle = TimeSpan.FromMinutes(5);
x.EnableExpress = true;
configure(x);
});
}
/// <inheritdoc />
public override void SetEndpoint(IServiceBusBusFactoryConfigurator busCfg)
=> busCfg.ReceiveEndpoint(Name, endpointConfig =>
{
SetDefaults(endpointConfig);
endpointConfig.DuplicateDetectionHistoryTimeWindow = ConfigDefaults.DuplicateDetectionWindow;
_configurator?.Invoke(endpointConfig);
foreach (Action <IServiceBusReceiveEndpointConfigurator> consumerConfig in _consumers)
{
consumerConfig?.Invoke(endpointConfig);
}
});
/// <summary>
/// Configures a Turnout on the receive endpoint, which executes a long-running job and supervises the job until it
/// completes.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="configurator">The receive endpoint configurator</param>
/// <param name="busFactoryConfigurator">The bus factory configuration to use a separate endpoint for the control traffic</param>
/// <param name="configure"></param>
public static void Turnout <T>(this IServiceBusReceiveEndpointConfigurator configurator, IServiceBusBusFactoryConfigurator busFactoryConfigurator,
Action <ITurnoutHostConfigurator <T> > configure)
where T : class
{
var temporaryQueueName = busFactoryConfigurator.GetTemporaryQueueName("turnout-");
busFactoryConfigurator.ReceiveEndpoint(configurator.Host, temporaryQueueName, turnoutEndpointConfigurator =>
{
turnoutEndpointConfigurator.AutoDeleteOnIdle = TimeSpan.FromMinutes(5);
turnoutEndpointConfigurator.EnableExpress = true;
configurator.ConfigureTurnoutEndpoints(busFactoryConfigurator, turnoutEndpointConfigurator, configure);
});
}
void ConfigureActivity <TActivity, TArguments, TLog>(IServiceBusBusFactoryConfigurator cfg, IServiceBusHost host)
where TActivity : class, Activity <TArguments, TLog>, new()
where TArguments : class
where TLog : class
{
Uri compensateAddress = null;
cfg.ReceiveEndpoint(host, GetCompensateActivityQueueName(typeof(TActivity)), e =>
{
e.PrefetchCount = 16;
e.SubscribeMessageTopics = false;
e.CompensateActivityHost <TActivity, TLog>();
compensateAddress = e.InputAddress;
});
cfg.ReceiveEndpoint(host, GetExecuteActivityQueueName(typeof(TActivity)), e =>
{
e.PrefetchCount = 16;
e.SubscribeMessageTopics = false;
e.ExecuteActivityHost <TActivity, TArguments>(compensateAddress);
});
}
protected override void ConfigureServiceBusBus(IServiceBusBusFactoryConfigurator configurator)
{
configurator.ReceiveEndpoint("order-observer", e =>
{
e.Consumer <OrderSubmittedConsumer>();
});
configurator.ReceiveEndpoint("order-state", e =>
{
_machine = new OrderStateMachine();
_repository = new InMemorySagaRepository <OrderState>();
e.StateMachineSaga(_machine, _repository);
EndpointConvention.Map <OrderProcessed>(e.InputAddress);
});
configurator.ReceiveEndpoint("execute-process-order", e =>
{
e.ExecuteActivityHost <ProcessOrderActivity, ProcessOrderArguments>();
EndpointConvention.Map <ProcessOrderArguments>(e.InputAddress);
});
}
/// <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="configure"></param>
public static void ServiceInstance(this IServiceBusBusFactoryConfigurator configurator,
Action <IServiceInstanceConfigurator <IServiceBusReceiveEndpointConfigurator> > configure)
{
var instanceId = NewId.Next();
var instanceEndpointName = ServiceEndpointNameFormatter.Instance.EndpointName(instanceId);
configurator.ReceiveEndpoint(instanceEndpointName, endpointConfigurator =>
{
var instance = new ServiceInstance(instanceId, endpointConfigurator);
var instanceConfigurator = new ServiceBusServiceInstanceConfigurator(configurator, instance);
instanceConfigurator.ConfigureInstanceEndpoint(endpointConfigurator);
configure?.Invoke(instanceConfigurator);
});
}
/// <summary>
/// Creates a management endpoint which can be used by controllable filters on a bus intance
/// </summary>
/// <param name="configurator"></param>
/// <param name="host">The service bus host</param>
/// <param name="configure"></param>
/// <returns></returns>
public static IManagementEndpointConfigurator ManagementEndpoint(this IServiceBusBusFactoryConfigurator configurator,
IServiceBusHost host, Action <IReceiveEndpointConfigurator> configure = null)
{
var queueName = host.Topology.CreateTemporaryQueueName("manage-");
IServiceBusReceiveEndpointConfigurator specification = null;
configurator.ReceiveEndpoint(host, queueName, x =>
{
x.AutoDeleteOnIdle = Defaults.TemporaryAutoDeleteOnIdle;
configure?.Invoke(x);
specification = x;
});
return(new ManagementEndpointConfigurator(specification));
}
static void ConfigureBusEndpoints(IServiceBusBusFactoryConfigurator cfg, IServiceProvider provider, IServiceBusHost host)
{
const string subsriberName = "AnotherSubscriber";
cfg.SubscriptionEndpoint <AnotherThingHappened>(host, subsriberName, configurator =>
{
configurator.Handler <AnotherThingHappened>(context =>
{
Console.WriteLine(context.Message.AnotherThingType);
if (Random.NextDouble() < 0.1)
{
throw new Exception("Oups, I failed :(");
}
return(Task.CompletedTask);
});
});
cfg.SubscriptionEndpoint <ObjectCreatedA>(host, subsriberName, configurator =>
{
configurator.Consumer <ObjectACreatedEventHandler>();
});
cfg.ReceiveEndpoint(host, queueName: "AnotherSubscirber2", configure: configurator =>
{
configurator.Handler <ObjectCreatedB>(async context =>
{
Console.WriteLine("Another subscirber, object b created");
await context.SchedulePublish <ScheduledCommand>(TimeSpan.FromSeconds(30), new ScheduledCommandImpl
{
ExecutedIn = 30, IsReallyScheduled = true
});
ChangeCaseCommand changeCase = new ChangeCaseCommandImpl
{
IsScheduled = true,
Text = "Hello world"
};
await context.ScheduleSendConventional(TimeSpan.FromSeconds(15), changeCase);
});
});
cfg.CreateConventionalCommandHandlerEndpoint <DoAnotherThingCommandHandler, DoAnotherThingCommand>(provider);
}
protected override void ConfigureServiceBusBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host)
{
configurator.Send <PartitionedMessage>(x =>
{
x.UsePartitionKeyFormatter(p => p.Message.CorrelationId.ToString("N"));
});
configurator.Publish <PartitionedMessage>(x =>
{
x.EnablePartitioning = true;
});
configurator.ReceiveEndpoint(host, "partitioned-input-queue", x =>
{
x.EnablePartitioning = true;
_otherHandled = Handled <PartitionedMessage>(x);
});
}