/// <summary>
/// Configures Rebus to encrypt messages.
/// </summary>
public static void EnableJsonEncryption(this RebusConfigurer configurer, EncryptionFactory encryptionFactory, EncryptStateBuilder encryptStateBuilder, DecryptStateBuilder decryptStateBuilder)
{
Guard.AgainstNull(nameof(configurer), configurer);
Guard.AgainstNull(nameof(encryptionFactory), encryptionFactory);
Guard.AgainstNull(nameof(encryptStateBuilder), encryptStateBuilder);
Guard.AgainstNull(nameof(decryptStateBuilder), decryptStateBuilder);
configurer.Options(options =>
{
options.Decorate <IPipeline>(
resolutionContext =>
{
var pipeline = resolutionContext.Get <IPipeline>();
var injector = new PipelineStepInjector(pipeline);
var decryptStep = new DecryptStep(encryptionFactory, decryptStateBuilder);
injector.OnReceive(decryptStep, PipelineRelativePosition.Before, typeof(DeserializeIncomingMessageStep));
var encryptStep = new EncryptStep(encryptionFactory, encryptStateBuilder);
injector.OnSend(encryptStep, PipelineRelativePosition.Before, typeof(SerializeOutgoingMessageStep));
return(injector);
});
});
}
/// <summary>
/// Configures Rebus to use an outbox.
/// This will store a (message ID, source queue) tuple for all processed messages, and under this tuple any messages sent/published will
/// also be stored, thus enabling truly idempotent message processing.
/// </summary>
public static RebusConfigurer Outbox(this RebusConfigurer configurer, Action <StandardConfigurer <IOutboxStorage> > configure)
{
if (configurer == null)
{
throw new ArgumentNullException(nameof(configurer));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
configurer.Options(o =>
{
configure(StandardConfigurer <IOutboxStorage> .GetConfigurerFrom(o));
// if no outbox storage was registered, no further calls must have been made... that's ok, so we just bail out here
if (!o.Has <IOutboxStorage>())
{
return;
}
o.Decorate <ITransport>(c => new OutboxClientTransportDecorator(c.Get <ITransport>(), c.Get <IOutboxStorage>()));
o.Register(c =>
{
var asyncTaskFactory = c.Get <IAsyncTaskFactory>();
var rebusLoggerFactory = c.Get <IRebusLoggerFactory>();
var outboxStorage = c.Get <IOutboxStorage>();
var transport = c.Get <ITransport>();
return(new OutboxForwarder(asyncTaskFactory, rebusLoggerFactory, outboxStorage, transport));
});
o.Decorate(c =>
{
_ = c.Get <OutboxForwarder>();
return(c.Get <Options>());
});
o.Decorate <IPipeline>(c =>
{
var pipeline = c.Get <IPipeline>();
var outboxConnectionProvider = c.Get <IOutboxConnectionProvider>();
var step = new OutboxIncomingStep(outboxConnectionProvider);
return(new PipelineStepInjector(pipeline)
.OnReceive(step, PipelineRelativePosition.After, typeof(SimpleRetryStrategyStep)));
});
});
return(configurer);
}
/// <summary>
/// Starts the bus with 0 workers, thus creating a fully functional bus, only without starting message processing.
/// The returned <see cref="IBusStarter"/> can then be used to start the bus by calling <see cref="IBusStarter.Start"/>
/// on it.
/// </summary>
public static IBusStarter Create(this RebusConfigurer configurer)
{
var desiredNumberOfWorkersWhenStarted = 0;
var bus = configurer
.Options(o =>
{
// modify Options by setting number of workers to 0
o.Decorate(c =>
{
var options = c.Get <Options>();
desiredNumberOfWorkersWhenStarted = options.NumberOfWorkers;
// delay bus start by doing this
options.NumberOfWorkers = 0;
return(options);
});
})
.Start();
return(new BusStarter(bus, desiredNumberOfWorkersWhenStarted));
}
internal static RebusConfigurer UseTopicNameSameAsMessageTypeNameConvetion(this RebusConfigurer rebus) => rebus
.Options(o =>
{
o.Register <ITopicNameConvention>(c => new TopicNameSameAsMessageTypeNameConvetion(c.Get <IMessageTypeNameConvention>()));
});
internal static RebusConfigurer UseTopicNameAsMessageTypePipeline(this RebusConfigurer rebus) => rebus
.Options(config => config
.Decorate <IPipeline>(c =>
{
var pipeline = c.Get <IPipeline>();
var step = new TopicNameAsMessageTypePipeline();
return(new PipelineStepInjector(pipeline)
.OnSend(step, PipelineRelativePosition.Before, typeof(AssignDefaultHeadersStep)));
}));
public static RebusConfigurer SetupUnitOfWork(this RebusConfigurer configurer, IWindsorContainer container)
{
return(configurer.Options(x => x.EnableUnitOfWork(c => Create(c, container), Commit, Rollback, Dispose)));
}
