public MassTransitBus(Uri address, IConsumePipe consumePipe, ISendEndpointProvider sendEndpointProvider,
IPublishEndpointProvider publishEndpointProvider, IBusHostCollection hosts,
IBusObserver busObservable, IBusTopology topology)
{
Address = address;
_consumePipe = consumePipe;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
_busObservable = busObservable;
Topology = topology;
_hosts = hosts;
_publishEndpoint = new Lazy <IPublishEndpoint>(() => publishEndpointProvider.CreatePublishEndpoint(address));
}
/// <summary>
/// Create a message scheduler that uses an external message scheduler, such as Quartz.NET or Hangfire, to
/// schedule messages. This should not be used with the broker-specific message schedulers. Scheduled messages
/// are published to the external message scheduler, rather than uses a preconfigured endpoint address.
/// NOTE that this should only be used to schedule messages outside of a message consumer. Consumers should
/// use the ScheduleSend extensions on ConsumeContext.
/// </summary>
/// <param name="publishEndpoint"></param>
/// <param name="busTopology"></param>
/// <returns></returns>
public static IMessageScheduler CreateMessageScheduler(this IPublishEndpoint publishEndpoint, IBusTopology busTopology)
{
return(new MessageScheduler(new PublishScheduleMessageProvider(publishEndpoint), busTopology));
}
/// <summary>
/// Create a message scheduler that uses an external message scheduler, such as Quartz.NET or Hangfire, to
/// schedule messages. This should not be used with the broker-specific message schedulers.
/// NOTE that this should only be used to schedule messages outside of a message consumer. Consumers should
/// use the ScheduleSend extensions on ConsumeContext.
/// </summary>
/// <param name="busTopology"></param>
/// <param name="schedulerEndpointAddress">The endpoint address of the scheduler service</param>
/// <param name="sendEndpointProvider"></param>
/// <returns></returns>
public static IMessageScheduler CreateMessageScheduler(this ISendEndpointProvider sendEndpointProvider, IBusTopology busTopology,
Uri schedulerEndpointAddress)
{
Task <ISendEndpoint> GetSchedulerEndpoint()
{
return(sendEndpointProvider.GetSendEndpoint(schedulerEndpointAddress));
}
return(new MessageScheduler(new EndpointScheduleMessageProvider(GetSchedulerEndpoint), busTopology));
}
/// <summary>
/// Create a message scheduler that uses the built-in transport message delay to schedule messages.
/// NOTE that this should only be used to schedule messages outside of a message consumer. Consumers should
/// use the ScheduleSend extensions on ConsumeContext.
/// </summary>
/// <param name="sendEndpointProvider"></param>
/// <param name="busTopology"></param>
/// <returns></returns>
public static IMessageScheduler CreateDelayedMessageScheduler(this ISendEndpointProvider sendEndpointProvider, IBusTopology busTopology)
{
return(new MessageScheduler(new DelayedScheduleMessageProvider(sendEndpointProvider), busTopology));
}
public MessageScheduler(IScheduleMessageProvider provider, IBusTopology busTopology)
{
_provider = provider;
_busTopology = busTopology;
}
/// <summary>
/// Create a message scheduler that uses the Azure Service Bus ScheduleEnqueueTimeUtc property to
/// schedule messages.
/// NOTE that this should only be used to schedule messages outside of a message consumer. Consumers should
/// use the ScheduleSend extensions on ConsumeContext.
/// </summary>
/// <param name="sendEndpointProvider"></param>
/// <param name="busTopology"></param>
/// <returns></returns>
public static IMessageScheduler CreateServiceBusMessageScheduler(this ISendEndpointProvider sendEndpointProvider, IBusTopology busTopology)
{
return(new MessageScheduler(new ServiceBusScheduleMessageProvider(sendEndpointProvider), busTopology));
}
/// <summary>
/// Create a message scheduler that uses the built-in ActiveMQ scheduler to schedule messages.
/// NOTE that this should only be used to schedule messages outside of a message consumer. Consumers should
/// use the ScheduleSend extensions on ConsumeContext.
/// </summary>
/// <param name="sendEndpointProvider"></param>
/// <param name="busTopology"></param>
/// <returns></returns>
public static IMessageScheduler CreateActiveMqMessageScheduler(this ISendEndpointProvider sendEndpointProvider, IBusTopology busTopology)
{
return(new MessageScheduler(new ActiveMqScheduleMessageProvider(sendEndpointProvider), busTopology));
}
/// <summary>
/// Create a message scheduler that uses the RabbitMQ Delayed Exchange plug-in to schedule messages.
/// NOTE that this should only be used to schedule messages outside of a message consumer. Consumers should
/// use the ScheduleSend extensions on ConsumeContext.
/// </summary>
/// <returns></returns>
public static IMessageScheduler CreateRabbitMqMessageScheduler(this ISendEndpointProvider sendEndpointProvider, IBusTopology busTopology)
{
if (busTopology is IRabbitMqHostTopology topology)
{
return(new MessageScheduler(new DelayedExchangeScheduleMessageProvider(sendEndpointProvider, topology), topology));
}
throw new ArgumentException("A RabbitMQ bus is required to use the RabbitMQ message scheduler");
}
public EndpointStartupMessageHandler(IBusTopology busTopology)
{
this.busTopology = busTopology;
}
public EndpointControlService(IBus bus, IBusTopology busTopology)
{
this.bus = bus;
this.busTopology = busTopology;
}
