static IBusControl Build(IBusFactory factory, IBusConfiguration busConfiguration, IEnumerable <ValidationResult> validationResult)
{
if (LogContext.Current == null)
{
LogContext.ConfigureCurrentLogContext();
}
busConfiguration.HostConfiguration.LogContext = LogContext.Current;
var result = BusConfigurationResult.CompileResults(validationResult);
try
{
var busReceiveEndpointConfiguration = factory.CreateBusEndpointConfiguration(x => x.ConfigureConsumeTopology = false);
var host = busConfiguration.HostConfiguration.Build();
var bus = new MassTransitBus(host, busConfiguration.BusObservers, busReceiveEndpointConfiguration);
TaskUtil.Await(() => busConfiguration.BusObservers.PostCreate(bus));
return(bus);
}
catch (Exception ex)
{
TaskUtil.Await(() => busConfiguration.BusObservers.CreateFaulted(ex));
throw new ConfigurationException(result, "An exception occurred during bus creation", ex);
}
}
public static IBusConfiguration UseAspNetCore(this IBusConfiguration bc, IServiceCollection service)
{
bc.DependencyAdapter = new AspNetCoreDependencyAdapter(service);
bc.SetBindings();
return(bc);
}
public BusManager(IBusConnection connection, IBusConfiguration config, ILogger <BusManager> logger = null)
{
_config = config;
_connection = connection;
_logger = logger;
InitQueues();
}
/// <summary>
/// Base class used to send and receive messages.
/// </summary>
/// <param name="configuration"></param>
/// <param name="configurationFactory"></param>
public AzureSenderReceiverBase(IBusConfiguration configuration, IServiceBusConfigurationFactory configurationFactory) {
Guard.ArgumentNotNull(configuration, "configuration");
Guard.ArgumentNotNull(configurationFactory, "configurationFactory");
this.configuration = configuration;
this.configurationFactory = configurationFactory;
EnsureTopic(configuration.TopicName, configuration.EnablePartitioning);
}
public static IBus Create <TRegistry>(IBusConfiguration configuration) where TRegistry : Registry
{
var container = new Container((conf) => conf.AddRegistry(Activator.CreateInstance <TRegistry>()));
container.Configure(conf => conf.For <IBusConfiguration>().Use(configuration));
var self = new Peer(Guid.NewGuid(), configuration.PeerName, configuration.Endpoint);
container.Configure(conf => conf.For <IPeer>().Use(self));
var peerDirectoryDescriptor = new Peer(Guid.NewGuid(), "PeerDirectory", configuration.DirectoryEndpoint);
var bus = new Bus(container, self, peerDirectoryDescriptor);
container.Configure(conf => conf.For <IBus>().Use(bus));
if (configuration.IsPeerDirectory)
{
var peerDirectory = new PeerDirectory(bus);
container.Configure(conf => conf.For <IPeerDirectory>().Use(peerDirectory));
bus.Register <PeerRegisterCommand>(peerDirectory);
bus.Register <PeerUpdatedEvent>(peerDirectory);
}
bus.Start();
return(bus);
}
private IBusControl CreateBusUsingAzureServiceBus(
IComponentContext context,
IBusConfiguration configuration)
{
return(Bus.Factory.CreateUsingAzureServiceBus(b =>
{
var uri = configuration.BusUri;
uri = ServiceBusEnvironment.CreateServiceUri("sb", uri.Host, "");
var host = b.Host(uri, h =>
{
h.SharedAccessSignature(s =>
{
s.KeyName = configuration.BusSecretName;
s.SharedAccessKey = configuration.BusSecret;
s.TokenTimeToLive = TimeSpan.FromDays(1);
s.TokenScope = TokenScope.Namespace;
});
});
b.ReceiveEndpoint(host, configuration.BusQueue, r =>
{
r.LoadFrom(context); // All registered consumers
});
b.ReceiveEndpoint(host, configuration.BusQueue + "_error", r =>
{
r.Consumer <ErrorConsumer>();
});
b.UseRetry(r => r.None());
}));
}
/// <summary>
/// Configure the input queue for send bus
/// </summary>
/// <param name="configuration">Configuration to modify</param>
/// <param name="messageTypes">Messages that can be published</param>
/// <param name="region">Amazon Region the topic is in</param>
/// <returns>Modified configuration</returns>
public static IConfigureEventPublishing PublishingMessages(this IBusConfiguration configuration, IEnumerable <Type> messageTypes, RegionEndpoint region)
{
if (messageTypes == null || !messageTypes.Any())
{
throw new JungleBusConfigurationException("messageTypes", "Cannot have a blank publish queue name");
}
if (region == null)
{
throw new JungleBusConfigurationException("region", "Region cannot be null");
}
if (configuration == null)
{
throw new JungleBusConfigurationException("configuration", "Configuration cannot be null");
}
if (configuration.Send != null)
{
throw new JungleBusConfigurationException("PublishingMessages", "PublishingMessages is already configured");
}
configuration.Send = new SendConfiguration();
configuration.Send.MessagePublisher = new AwsMessagePublisher(new SnsClient(region, configuration.SubscriptionFormatter), configuration.MessageLogger);
configuration.Send.MessagePublisher.SetupMessagesForPublishing(messageTypes);
return(configuration as IConfigureEventPublishing);
}
private IBusControl CreateBusUsingRabbitMq(
IComponentContext context,
IBusConfiguration configuration)
{
return(Bus.Factory.CreateUsingRabbitMq(b =>
{
var uri = configuration.BusUri;
uri = new UriBuilder(RabbitMqScheme, uri.Host, uri.Port, uri.AbsolutePath).Uri;
var host = b.Host(uri, h =>
{
h.Username(configuration.BusSecretName);
h.Password(configuration.BusSecret);
});
b.ReceiveEndpoint(host, configuration.BusQueue, r =>
{
r.Durable = true; // Queue should survive broker restart
r.AutoDelete = false; // Queue should survive service restart
r.LoadFrom(context); // All registered consumers
});
b.ReceiveEndpoint(host, configuration.BusQueue + "_error", r =>
{
r.BindMessageExchanges = false; // binding not required to get messages into queue
r.PurgeOnStartup = true; // we discard them anyway
r.Consumer <ErrorConsumer>();
});
b.UseRetry(r => r.None());
}));
}
public AzureBusSender(IBusConfiguration configuration, IServiceBusConfigurationFactory configurationFactory)
: base(configuration, configurationFactory)
{
retryPolicy.ExecuteAction(() => {
defaultClient = configurationFactory.MessageFactory.CreateTopicClient(defaultTopic.Path);
});
}
public EasyConnection(IBusConfiguration config)
{
_config = config;
_serializationStrategy = config.DataSerializationStrategy;
_clientId = Guid.NewGuid();
}
public void OnBusStarted(IBusConfiguration config, IBus bus)
{
// throw the ball!
bus.Send(new PongMessage {
Message = "Hey, Catch!"
});
}
public PeerDirectoryClient(IBusConfiguration configuration)
{
_configuration = configuration;
_messagesReceivedDuringRegister = new BlockingCollection <IEvent>();
_messagesReceivedDuringRegister.CompleteAdding();
}
/// <summary>
/// Configure the input queue for receive bus
/// </summary>
/// <param name="configuration">Configuration to modify</param>
/// <param name="sqsName">SQS queue name</param>
/// <param name="region">Amazon Region the queue is in</param>
/// <returns>Modified configuration</returns>
public static IConfigureEventReceiving SetInputQueue(this IBusConfiguration configuration, string sqsName, RegionEndpoint region)
{
if (string.IsNullOrWhiteSpace(sqsName))
{
throw new JungleBusConfigurationException("sqsName", "Cannot have a blank input queue name");
}
if (region == null)
{
throw new JungleBusConfigurationException("region", "Region cannot be null");
}
if (configuration == null)
{
throw new JungleBusConfigurationException("configuration", "Configuration cannot be null");
}
if (configuration.Receive == null)
{
configuration.Receive = new ReceiveConfiguration();
}
if (!string.IsNullOrWhiteSpace(configuration.BusName))
{
sqsName = string.Format("{0}_{1}", configuration.BusName, sqsName);
}
configuration.Receive.MessageRetryCount = 5;
configuration.Receive.InputQueue = new SqsQueue(region, sqsName, configuration.Receive.MessageRetryCount, new MessageParser(null));
return(configuration as IConfigureEventReceiving);
}
private static IBusControl CreateBusUsingAzureServiceBus(
IBusRegistrationContext context,
IBusConfiguration configuration)
{
const string UriDomain = ".servicebus.windows.net";
return(MassTransit.Bus.Factory.CreateUsingAzureServiceBus(b =>
{
var uri = configuration.HostUri;
uri = new UriBuilder(AzureServiceBusScheme, uri.Host + UriDomain).Uri;
b.Host(uri, h =>
{
h.SharedAccessSignature(s =>
{
s.KeyName = configuration.SecretName;
s.SharedAccessKey = configuration.Secret;
s.TokenTimeToLive = TimeSpan.FromDays(1);
s.TokenScope = TokenScope.Namespace;
});
});
b.ReceiveEndpoint(configuration.QueueName, r =>
{
TuneForReportExecution(r);
r.ConfigureConsumers(context);
});
}));
}
public IBus Start()
{
if (Logger == null || Logger is StartupLogger)
{
_busConfiguration = _busConfiguration.WithLogger <MSExtensionsLogging>();
}
if (DependencyInjector == null)
{
_busConfiguration = _busConfiguration.WithDependencyInjector <MSExtensionsDependencyInjection>();
}
if (Serializer == null)
{
_busConfiguration = _busConfiguration.WithSerializer <JSONSerializer>();
}
if (Transport == null)
{
_busConfiguration = _busConfiguration.WithTransport <InMemoryTransport>();
}
if (Persistence == null)
{
_busConfiguration = _busConfiguration.WithPersistence <InMemoryPersistence>();
}
return(new Bus(_busConfiguration).Start());
}
/// <summary>
/// Base class used to send and receive messages.
/// </summary>
/// <param name="configuration"></param>
public ReceiverBase(IBusConfiguration configuration)
{
Guard.ArgumentNotNull(configuration, "configuration");
this.configuration = configuration;
configurationFactory = configuration.Container.Resolve<IServiceBusConfigurationFactory>();
EnsureTopic(configuration.InboundTopicName);
}
public GenericServiceBusConfigurationFactory(IBusConfiguration configuration, IMessagingFactory messageFactory, INamespaceManager namespaceManager) {
Guard.ArgumentNotNull(configuration, "configuration");
Guard.ArgumentNotNull(messageFactory, "messageFactory");
Guard.ArgumentNotNull(namespaceManager, "namespaceManager");
this.configuration = configuration;
this.MessageFactory = messageFactory;
this.NamespaceManager = namespaceManager;
}
/// <summary>
/// Base class used to send and receive messages.
/// </summary>
/// <param name="configuration"></param>
/// <param name="configurationFactory"></param>
public AzureSenderReceiverBase(IBusConfiguration configuration, IServiceBusConfigurationFactory configurationFactory)
{
Guard.ArgumentNotNull(configuration, "configuration");
Guard.ArgumentNotNull(configurationFactory, "configurationFactory");
this.configuration = configuration;
this.configurationFactory = configurationFactory;
EnsureTopic(configuration.TopicName, configuration.EnablePartitioning);
}
/// <summary>
/// ctor
/// </summary>
/// <param name="config"></param>
/// <param name="sender"></param>
/// <param name="receiver"></param>
public AzureBus(IBusConfiguration config, IAzureBusSender sender, IAzureBusReceiver receiver)
{
Guard.ArgumentNotNull(config, "config");
Guard.ArgumentNotNull(sender, "sender");
Guard.ArgumentNotNull(receiver, "receiver");
this.config = config;
this.sender = sender;
this.receiver = receiver;
}
public void OnBusStarted(IBusConfiguration config, IBus bus)
{
#if DEBUG
if (config.IsConsoleMode)
{
bus.Send <GetProductsCommand>();
}
#endif
}
public void OnBusStarted(IBusConfiguration config, IBus bus)
{
#if DEBUG
if (config.IsConsoleMode)
{
bus.Send<GetCustomersCommand>();
}
#endif
}
public ServiceBusTokenProvider(IBusConfiguration configuration) {
Guard.ArgumentNotNull(configuration, "configuration");
this.configuration = configuration;
servicePath = string.Empty;
if (!string.IsNullOrWhiteSpace(configuration.ServicePath)) {
servicePath = configuration.ServicePath;
}
}
public GenericServiceBusConfigurationFactory(IBusConfiguration configuration, IMessagingFactory messageFactory, INamespaceManager namespaceManager)
{
Guard.ArgumentNotNull(configuration, "configuration");
Guard.ArgumentNotNull(messageFactory, "messageFactory");
Guard.ArgumentNotNull(namespaceManager, "namespaceManager");
this.configuration = configuration;
this.MessageFactory = messageFactory;
this.NamespaceManager = namespaceManager;
}
public ConfigurationBusBuilder(IBusConfiguration configuration, IReceiveEndpointConfiguration busReceiveEndpointConfiguration,
BusObservable busObservable)
{
_busEndpointSpecification = new ConfigurationReceiveEndpointSpecification(busReceiveEndpointConfiguration);
_configuration = configuration;
_busEndpointConfiguration = busReceiveEndpointConfiguration;
_busObservable = busObservable;
}
protected BusFactoryConfigurator(IBusConfiguration configuration, IEndpointConfiguration busEndpointConfiguration)
{
_configuration = configuration;
_busEndpointConfiguration = busEndpointConfiguration;
BusObservable = new BusObservable();
_specifications = new List <IBusFactorySpecification>();
_endpointSpecifications = new List <IReceiveEndpointSpecification <IBusBuilder> >();
}
private static IServiceProvider ConfigureServices(IBusConfiguration busConfiguration)
{
var services = new ServiceCollection()
.AddTransient <IAppService, AppService>()
.AddSingleton(busConfiguration);
RabbitMq.Publish.IoC.Configure(services);
return(services.BuildServiceProvider());
}
public BrokeredMessageReceiverServiceBusEndpointConfiguration(IBusConfiguration busConfiguration)
: base(busConfiguration)
{
HostAddress = busConfiguration.HostConfiguration.HostAddress;
InputAddress = new Uri(busConfiguration.HostConfiguration.HostAddress, "no-queue-specified");
var deadLetterPipe = Pipe.Execute <ReceiveContext>(context => throw new TransportException(context.InputAddress, "The message was not consumed"));
Receive.DeadLetterConfigurator.UseDeadLetter(deadLetterPipe);
}
/// <summary>
/// Configure the the bus to use log inbound and outbound messages
/// </summary>
/// <param name="configuration">Configuration to modify</param>
/// <returns>Modified configuration</returns>
public static IBusConfiguration EnableMessageLogging(this IBusConfiguration configuration)
{
if (configuration == null)
{
throw new JungleBusConfigurationException("configuration", "Configuration cannot be null");
}
configuration.MessageLogger = new MessageLogger();
return(configuration);
}
public PersistentTransport(IBusConfiguration configuration, ITransport innerTransport, IPeerDirectory peerDirectory)
{
_configuration = configuration;
_isPersistent = configuration.IsPersistent;
_innerTransport = innerTransport;
_peerDirectory = peerDirectory;
SetInitialPhase();
_innerTransport.MessageReceived += OnTransportMessageReceived;
}
public PersistentTransport(IBusConfiguration configuration, ITransport innerTransport, IPeerDirectory peerDirectory)
{
_configuration = configuration;
_isPersistent = configuration.IsPersistent;
_innerTransport = innerTransport;
_peerDirectory = peerDirectory;
SetInitialPhase();
_innerTransport.MessageReceived += OnTransportMessageReceived;
}
protected EndpointConfiguration(IBusConfiguration busConfiguration, ITopologyConfiguration topology)
{
Topology = topology;
Consume = new ConsumePipeConfiguration();
Send = new SendPipeConfiguration(busConfiguration.Send.Specification);
Publish = new PublishPipeConfiguration(busConfiguration.Publish.Specification);
Receive = new ReceivePipeConfiguration();
Serialization = busConfiguration.Serialization.CreateSerializationConfiguration();
}
public ServiceBusTokenProvider(IBusConfiguration configuration)
{
Guard.ArgumentNotNull(configuration, "configuration");
this.configuration = configuration;
servicePath = string.Empty;
if (!string.IsNullOrWhiteSpace(configuration.ServicePath))
{
servicePath = configuration.ServicePath;
}
}
protected BusFactoryConfigurator(IBusConfiguration busConfiguration)
{
_busConfiguration = busConfiguration;
busConfiguration.BusEndpointConfiguration.Consume.Configurator.AutoStart = false;
if (LogContext.Current == null)
{
LogContext.ConfigureCurrentLogContext();
}
}
/// <summary>
/// Runs validation general to building a bus
/// </summary>
/// <param name="configuration">Configuration to validate</param>
private static void RunGeneralConfigurationValidation(this IBusConfiguration configuration)
{
if (configuration == null)
{
throw new JungleBusConfigurationException("configuration", "Configuration cannot be null");
}
if (configuration.ObjectBuilder == null)
{
throw new JungleBusConfigurationException("ObjectBuilder", "Object builder has not been configured");
}
}
public Bus(IBusConfiguration cfg, ILogger <Bus> log, PullMessagesJob job)
{
this.cfg = cfg;
this.log = log;
this.job = job;
using (var db = this.cfg.DbConnectionFactory.Open())
{
db.CreateTableIfNotExists <MessageRow>();
db.CreateTableIfNotExists <MessageHandlerRow>();
}
}
protected BaseHostConfiguration(IBusConfiguration busConfiguration)
{
BusConfiguration = busConfiguration;
_endpoints = new List <TConfiguration>();
_endpointObservable = new EndpointConfigurationObservable();
_receiveObservers = new ReceiveObservable();
_consumeObservers = new ConsumeObservable();
_publishObservers = new PublishObservable();
_sendObservers = new SendObservable();
}
public void OnBusStarted(IBusConfiguration config, IBus bus)
{
if (config.IsConsoleMode)
{
Task.Factory.StartNew(() =>
{
// uncomment to send lots of messages
//for (int i = 0; i < 1000; i++)
{
bus.Send<GetCustomersCommand>();
bus.Send<GetInvoicesCommand>();
bus.Send<GetProductsCommand>();
}
});
}
}
public AzureReceiverHelper(TopicDescription topic, IServiceBusConfigurationFactory configurationFactory, IBusConfiguration config, IServiceBusSerializer serializer, RetryPolicy verifyRetryPolicy, RetryPolicy retryPolicy, ServiceBusEnpointData endpoint) {
Guard.ArgumentNotNull(topic, "topic");
Guard.ArgumentNotNull(configurationFactory, "configurationFactory");
Guard.ArgumentNotNull(config, "config");
Guard.ArgumentNotNull(serializer, "serializer");
Guard.ArgumentNotNull(retryPolicy, "retryPolicy");
Guard.ArgumentNotNull(endpoint, "endpoint");
this.topic = topic;
this.configurationFactory = configurationFactory;
this.config = config;
this.serializer = serializer;
this.verifyRetryPolicy = verifyRetryPolicy;
this.retryPolicy = retryPolicy;
this.endpoint = endpoint;
Configure(endpoint);
}
internal static void SubscribeOrUnsubscribeType(Action<string> logInfo, Type type, IBusConfiguration config, Action<ServiceBusEnpointData> callback) {
Guard.ArgumentNotNull(type, "type");
Guard.ArgumentNotNull(callback, "callback");
logInfo(string.Format("SubscribeOrUnsubscribeType={0}", type.FullName));
var interfaces = type.GetInterfaces()
.Where(i => i.IsGenericType && (i.GetGenericTypeDefinition() == typeof(IHandleMessages<>) || i.GetGenericTypeDefinition() == typeof(IHandleCompetingMessages<>)))
.ToList();
if (interfaces.Count == 0) {
throw new ApplicationException(string.Format("Type {0} does not implement IHandleMessages or IHandleCompetingMessages", type.FullName));
}
//for each interface we find, we need to register it with the bus.
foreach (var foundInterface in interfaces) {
var implementedMessageType = foundInterface.GetGenericArguments()[0];
//due to the limits of 50 chars we will take the name and a MD5 for the name.
var hashName = implementedMessageType.FullName + "|" + type.FullName;
var hash = MD5Helper.CalculateMD5(hashName);
var fullName = (IsCompetingHandler(foundInterface) ? "C_" : config.ServiceBusApplicationId + "_") + hash;
var info = new ServiceBusEnpointData() {
AttributeData = type.GetCustomAttributes(typeof(MessageHandlerConfigurationAttribute), false).FirstOrDefault() as MessageHandlerConfigurationAttribute,
DeclaredType = type,
MessageType = implementedMessageType,
SubscriptionName = fullName,
ServiceType = foundInterface
};
if (!config.Container.IsRegistered(type)) {
if (info.IsReusable) {
config.Container.Register(type, type);
}
else {
config.Container.Register(type, type, true);
}
}
callback(info);
}
config.Container.Build();
}
public BusFactory WithConfiguration(IBusConfiguration configuration, string environment)
{
_configuration = configuration;
_environment = environment;
return this;
}
/// <summary>
/// ctor
/// </summary>
/// <param name="configuration">The configuration data</param>
/// <param name="configurationFactory"></param>
/// <param name="serializer"></param>
public AzureBusReceiver(IBusConfiguration configuration, IServiceBusConfigurationFactory configurationFactory, IServiceBusSerializer serializer)
: base(configuration, configurationFactory) {
Guard.ArgumentNotNull(serializer, "serializer");
this.serializer = serializer;
}
protected MessageBus(IBusConfiguration<IMessagingConfiguration> configuration)
{
Configuration = configuration;
}
public void OnBusStopping(IBusConfiguration config, IBus bus)
{
}
public void OnBusStopped(IBusConfiguration config)
{
}
public void OnBusStarting(IBusConfiguration config)
{
}
public ReceiverHelper(IBusConfiguration config, RetryPolicy retryPolicy, BusReceiverState data)
{
this.config = config;
this.retryPolicy = retryPolicy;
this.data = data;
}
/// <summary>
/// ctor
/// </summary>
/// <param name="configuration">The configuration data</param>
public BusReceiver(IBusConfiguration configuration)
: base(configuration)
{
Guard.ArgumentNotNull(configuration, "configuration");
}
public void OnBusStarted(IBusConfiguration config, IBus bus)
{
// throw the ball!
bus.Send(new PongMessage { Message = "Hey, Catch!" });
}
