/// <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))); }