/// <summary>
/// Enables the data bus and configures which implementation of <see cref="IDataBusStorage"/> to use.
/// </summary>
public RebusConfigurer DataBus(Action <StandardConfigurer <IDataBusStorage> > configurer)
{
if (configurer == null)
{
throw new ArgumentNullException(nameof(configurer));
}
configurer(new StandardConfigurer <IDataBusStorage>(_injectionist, _options));
if (_injectionist.Has <IDataBusStorage>())
{
_injectionist.Register <IDataBus>(c =>
{
var dataBusStorage = c.Get <IDataBusStorage>();
return(new DefaultDataBus(dataBusStorage));
});
_injectionist.Decorate <IPipeline>(c =>
{
var dataBusStorage = c.Get <IDataBusStorage>();
var pipeline = c.Get <IPipeline>();
var step = new DataBusIncomingStep(dataBusStorage);
return(new PipelineStepInjector(pipeline)
.OnReceive(step, PipelineRelativePosition.After, typeof(DeserializeIncomingMessageStep)));
});
}
return(this);
}
void VerifyRequirements()
{
if (_hasBeenStarted)
{
throw new InvalidOperationException("This configurer has already had .Start() called on it - this is not allowed, because it cannot be guaranteed that configuration extensions make their registrations in a way that allows for being called more than once. If you need to create multiple bus instances, please wrap the configuration from Configure.With(...) and on in a function that you can call multiple times.");
}
if (!_injectionist.Has <ITransport>())
{
throw new ConfigurationErrorsException(
"No transport has been configured! You need to call .Transport(t => t.Use***) in order" +
" to select which kind of queueing system you want to use to transport messages. If" +
" you want something lightweight (possibly for testing?) you can use .Transport(t => t.UseInMemoryTransport(...))");
}
}
public ToposConsumerConfigurer Topics(Action <SubscriptionsRegistrar> topicRegistrarCallback)
{
if (topicRegistrarCallback == null)
{
throw new ArgumentNullException(nameof(topicRegistrarCallback));
}
if (!_injectionist.Has <Topics>())
{
_injectionist.Register(c => _topics);
}
topicRegistrarCallback(new SubscriptionsRegistrar(_topics));
return(this);
}
void InstallDefaults()
{
_logger.Verbose("Installing defaults");
if (!_injectionist.Has <INanosInstance>())
{
_injectionist.Register <INanosInstance>(c => new DefaultNanosInstance());
}
}
public IConfigDrive Build()
{
if (!_container.Has <IConfigDriveDataSource>())
{
throw new CloudInitConfigurationException("No data source has been configured");
}
return(_container.Get <IConfigDrive>().Instance);
}
public ToposProducerConfigurer Topics(Action <TopicMapper> mapper)
{
if (mapper == null)
{
throw new ArgumentNullException(nameof(mapper));
}
if (!_injectionist.Has <ITopicMapper>())
{
_injectionist.Register(c => _topicMappings.BuildTopicMapper());
}
mapper(new TopicMapper(_topicMappings));
return(this);
}
/// <summary>
/// Finishes the setup of the bus, using default implementations for the options that have not explicitly been set.
/// The only requirement, is that you must call <see cref="Transport"/> and select which transport to use - everything
/// else can run with a default option. It should be noted though, that several of the defaults (e.g. in-mem persistence
/// options for saga storage, subscriptions, and timeouts) are not meant for production use, and should probably be
/// replaced by something that is actually persistent.
/// </summary>
public IBus Start()
{
VerifyRequirements();
PossiblyRegisterDefault <IRouter>(c => new TypeBasedRouter());
PossiblyRegisterDefault <ISubscriptionStorage>(c => new InMemorySubscriptionStorage());
PossiblyRegisterDefault <ISagaStorage>(c => new InMemorySagaStorage());
PossiblyRegisterDefault <ISerializer>(c => new JsonSerializer());
PossiblyRegisterDefault <IPipelineInvoker>(c => new DefaultPipelineInvoker());
PossiblyRegisterDefault <IWorkerFactory>(c =>
{
var transport = c.Get <ITransport>();
var pipeline = c.Get <IPipeline>();
var pipelineInvoker = c.Get <IPipelineInvoker>();
return(new ThreadWorkerFactory(transport, pipeline, pipelineInvoker, _options.MaxParallelism));
});
PossiblyRegisterDefault <IRetryStrategy>(c =>
{
var transport = c.Get <ITransport>();
var simpleRetryStrategySettings = c.Get <SimpleRetryStrategySettings>();
return(new SimpleRetryStrategy(transport, simpleRetryStrategySettings));
});
PossiblyRegisterDefault(c => new SimpleRetryStrategySettings());
PossiblyRegisterDefault <ITimeoutManager>(c => new InMemoryTimeoutManager());
PossiblyRegisterDefault(c =>
{
var transport = c.Get <ITransport>();
var timeoutManager = c.Get <ITimeoutManager>();
return(new HandleDeferredMessagesStep(timeoutManager, transport));
});
PossiblyRegisterDefault(c => c.Get <IRetryStrategy>().GetRetryStep());
PossiblyRegisterDefault <IPipeline>(c => new DefaultPipeline()
.OnReceive(c.Get <IRetryStrategyStep>())
.OnReceive(c.Get <HandleDeferredMessagesStep>())
.OnReceive(new DeserializeIncomingMessageStep(c.Get <ISerializer>()))
.OnReceive(new ActivateHandlersStep(c.Get <IHandlerActivator>()))
.OnReceive(new LoadSagaDataStep(c.Get <ISagaStorage>()))
.OnReceive(new DispatchIncomingMessageStep())
.OnSend(new AssignGuidMessageIdStep())
.OnSend(new AssignReturnAddressStep(c.Get <ITransport>()))
.OnSend(new AssignDateTimeOffsetHeader())
.OnSend(new FlowCorrelationIdStep())
.OnSend(new SerializeOutgoingMessageStep(c.Get <ISerializer>()))
.OnSend(new SendOutgoingMessageStep(c.Get <ITransport>()))
);
RegisterDecorator <IPipeline>(c => new PipelineCache(c.Get <IPipeline>()));
PossiblyRegisterDefault <IBus>(c =>
{
var bus = new RebusBus(
c.Get <IWorkerFactory>(),
c.Get <IRouter>(),
c.Get <ITransport>(),
c.Get <IPipeline>(),
c.Get <IPipelineInvoker>(),
c.Get <ISubscriptionStorage>());
bus.Disposed += () =>
{
var disposableInstances = c.GetTrackedInstancesOf <IDisposable>().Reverse();
foreach (var disposableInstance in disposableInstances)
{
disposableInstance.Dispose();
}
};
var initializableInstances = c.GetTrackedInstancesOf <IInitializable>();
foreach (var initializableInstance in initializableInstances)
{
initializableInstance.Initialize();
}
if (_injectionist.Has <IContainerAdapter>())
{
c.Get <IContainerAdapter>().SetBus(bus);
}
bus.Start(_options.NumberOfWorkers);
return(bus);
});
_injectionist.Register <IHandlerActivator>(c =>
{
var handlerActivator = c.Get <IHandlerActivator>();
var subscriptionStorage = c.Get <ISubscriptionStorage>();
var internalHandlersContributor = new InternalHandlersContributor(handlerActivator, subscriptionStorage);
return(internalHandlersContributor);
}, isDecorator: true);
var busInstance = _injectionist.Get <IBus>();
return(busInstance);
}
/// <summary>
/// Gets whether a primary implementation resolver has been registered for the <typeparamref name="TService"/> service
/// </summary>
public bool Has <TService>()
{
return(_injectionist.Has <TService>());
}
/// <summary>
/// Finishes the setup of the bus, using default implementations for the options that have not explicitly been set.
/// The only requirement, is that you must call <see cref="Transport"/> and select which transport to use - everything
/// else can run with a default option. It should be noted though, that several of the defaults (e.g. in-mem persistence
/// options for saga storage, subscriptions, and timeouts) are not meant for production use, and should probably be
/// replaced by something that is actually persistent.
/// </summary>
public IBus Start()
{
VerifyRequirements();
PossiblyRegisterDefault <IRebusLoggerFactory>(c => new ConsoleLoggerFactory(true));
PossiblyRegisterDefault <IAsyncTaskFactory>(c => new TplAsyncTaskFactory(c.Get <IRebusLoggerFactory>()));
PossiblyRegisterDefault <IRouter>(c =>
{
var rebusLoggerFactory = c.Get <IRebusLoggerFactory>();
return(new TypeBasedRouter(rebusLoggerFactory));
});
PossiblyRegisterDefault <ISubscriptionStorage>(c => new InMemorySubscriptionStorage());
PossiblyRegisterDefault <ISagaStorage>(c => new InMemorySagaStorage());
PossiblyRegisterDefault <ISerializer>(c => new JsonSerializer());
PossiblyRegisterDefault <IPipelineInvoker>(c => new DefaultPipelineInvoker());
PossiblyRegisterDefault <IBackoffStrategy>(c => new SimpleConstantPollingBackoffStrategy());
PossiblyRegisterDefault <IWorkerFactory>(c =>
{
var transport = c.Get <ITransport>();
var pipeline = c.Get <IPipeline>();
var pipelineInvoker = c.Get <IPipelineInvoker>();
var backoffStrategy = c.Get <IBackoffStrategy>();
var rebusLoggerFactory = c.Get <IRebusLoggerFactory>();
return(new ThreadWorkerFactory(transport, pipeline, pipelineInvoker, _options.MaxParallelism, backoffStrategy, rebusLoggerFactory));
});
PossiblyRegisterDefault <IErrorTracker>(c =>
{
var settings = c.Get <SimpleRetryStrategySettings>();
var rebusLoggerFactory = c.Get <IRebusLoggerFactory>();
var asyncTaskFactory = c.Get <IAsyncTaskFactory>();
return(new InMemErrorTracker(settings.MaxDeliveryAttempts, rebusLoggerFactory, asyncTaskFactory));
});
PossiblyRegisterDefault <IRetryStrategy>(c =>
{
var transport = c.Get <ITransport>();
var simpleRetryStrategySettings = c.Get <SimpleRetryStrategySettings>();
var errorTracker = c.Get <IErrorTracker>();
var rebusLoggerFactory = c.Get <IRebusLoggerFactory>();
return(new SimpleRetryStrategy(transport, simpleRetryStrategySettings, errorTracker, rebusLoggerFactory));
});
PossiblyRegisterDefault(c => new SimpleRetryStrategySettings());
PossiblyRegisterDefault <ITimeoutManager>(c => new InMemoryTimeoutManager());
PossiblyRegisterDefault(c =>
{
var transport = c.Get <ITransport>();
var timeoutManager = c.Get <ITimeoutManager>();
var rebusLoggerFactory = c.Get <IRebusLoggerFactory>();
var asyncTaskFactory = c.Get <IAsyncTaskFactory>();
return(new HandleDeferredMessagesStep(timeoutManager, transport, _options, rebusLoggerFactory, asyncTaskFactory));
});
PossiblyRegisterDefault(c => c.Get <IRetryStrategy>().GetRetryStep());
PossiblyRegisterDefault <IPipeline>(c =>
{
var serializer = c.Get <ISerializer>();
var transport = c.Get <ITransport>();
var rebusLoggerFactory = c.Get <IRebusLoggerFactory>();
return(new DefaultPipeline()
.OnReceive(c.Get <IRetryStrategyStep>())
.OnReceive(c.Get <HandleDeferredMessagesStep>())
.OnReceive(new DeserializeIncomingMessageStep(serializer))
.OnReceive(new ActivateHandlersStep(c.Get <IHandlerActivator>()))
.OnReceive(new LoadSagaDataStep(c.Get <ISagaStorage>(), rebusLoggerFactory))
.OnReceive(new DispatchIncomingMessageStep())
.OnSend(new AssignGuidMessageIdStep())
.OnSend(new AssignReturnAddressStep(transport))
.OnSend(new AssignDateTimeOffsetHeader())
.OnSend(new FlowCorrelationIdStep())
.OnSend(new AutoHeadersOutgoingStep())
.OnSend(new AssignTypeHeaderStep())
.OnSend(new SerializeOutgoingMessageStep(serializer))
.OnSend(new SendOutgoingMessageStep(transport, rebusLoggerFactory)));
});
RegisterDecorator <IPipeline>(c => new PipelineCache(c.Get <IPipeline>()));
// configuration hack - keep these two bad boys around to have them available at the last moment before returning the built bus instance...
IContainerAdapter containerAdapter = null;
Action startAction = null;
PossiblyRegisterDefault <IBus>(c =>
{
var bus = new RebusBus(
c.Get <IWorkerFactory>(),
c.Get <IRouter>(),
c.Get <ITransport>(),
c.Get <IPipeline>(),
c.Get <IPipelineInvoker>(),
c.Get <ISubscriptionStorage>(),
_options,
c.Get <IRebusLoggerFactory>());
bus.Disposed += () =>
{
var disposableInstances = c.GetTrackedInstancesOf <IDisposable>().Reverse();
foreach (var disposableInstance in disposableInstances)
{
disposableInstance.Dispose();
}
};
var initializableInstances = c.GetTrackedInstancesOf <IInitializable>();
foreach (var initializableInstance in initializableInstances)
{
initializableInstance.Initialize();
}
if (_injectionist.Has <IContainerAdapter>())
{
containerAdapter = c.Get <IContainerAdapter>();
}
startAction = () => bus.Start(_options.NumberOfWorkers);
return(bus);
});
_injectionist.Decorate <IHandlerActivator>(c =>
{
var handlerActivator = c.Get <IHandlerActivator>();
var subscriptionStorage = c.Get <ISubscriptionStorage>();
var internalHandlersContributor = new InternalHandlersContributor(handlerActivator, subscriptionStorage);
return(internalHandlersContributor);
});
var busInstance = _injectionist.Get <IBus>();
containerAdapter?.SetBus(busInstance);
startAction?.Invoke();
_hasBeenStarted = true;
return(busInstance);
}
public bool HasService(bool primary = true)
{
return(_injectionist.Has <TService>(primary: primary));
}
