public ReplyHandlerStep(ConcurrentDictionary <string, TimedMessage> messages, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, TimeSpan replyMaxAge) { _messages = messages ?? throw new ArgumentNullException(nameof(messages)); _log = rebusLoggerFactory?.GetLogger <ReplyHandlerStep>() ?? throw new ArgumentNullException(nameof(rebusLoggerFactory)); _cleanupTask = asyncTaskFactory?.Create("CleanupAbandonedRepliesTask", CleanupAbandonedReplies) ?? throw new ArgumentNullException(nameof(asyncTaskFactory)); _replyMaxAge = replyMaxAge; }
/// <summary> /// Constructs the periodic background task with the given <paramref name="description"/>, periodically executing the given <paramref name="action"/>, /// waiting <see cref="Interval"/> between invocations. /// </summary> public TimerAsyncTask(string description, Func<Task> action, IRebusLoggerFactory rebusLoggerFactory, bool prettyInsignificant) { _log = rebusLoggerFactory.GetLogger<TimerAsyncTask>(); _description = description; _action = action; _prettyInsignificant = prettyInsignificant; Interval = DefaultInterval; }
/// <summary> /// Constructs the step, using the given transport and settings /// </summary> public SimpleRetryStrategyStep(SimpleRetryStrategySettings simpleRetryStrategySettings, IRebusLoggerFactory rebusLoggerFactory, IErrorTracker errorTracker, IErrorHandler errorHandler, CancellationToken cancellationToken) { _simpleRetryStrategySettings = simpleRetryStrategySettings ?? throw new ArgumentNullException(nameof(simpleRetryStrategySettings)); _errorTracker = errorTracker ?? throw new ArgumentNullException(nameof(errorTracker)); _errorHandler = errorHandler ?? throw new ArgumentNullException(nameof(errorHandler)); _logger = rebusLoggerFactory?.GetLogger <SimpleRetryStrategyStep>() ?? throw new ArgumentNullException(nameof(rebusLoggerFactory)); _cancellationToken = cancellationToken; }
/// <summary> /// Constructs the step, using the given transport and settings /// </summary> public ArkRetryStrategyStep(SimpleRetryStrategySettings arkRetryStrategySettings, IRebusLoggerFactory rebusLoggerFactory, IErrorTracker errorTracker, IErrorHandler errorHandler, IFailFastChecker failFastChecker, CancellationToken cancellationToken) { _arkRetryStrategySettings = arkRetryStrategySettings ?? throw new ArgumentNullException(nameof(arkRetryStrategySettings)); _errorTracker = errorTracker ?? throw new ArgumentNullException(nameof(errorTracker)); _errorHandler = errorHandler ?? throw new ArgumentNullException(nameof(errorHandler)); _failFastChecker = failFastChecker; _logger = rebusLoggerFactory?.GetLogger <ArkRetryStrategyStep>() ?? throw new ArgumentNullException(nameof(rebusLoggerFactory)); _cancellationToken = cancellationToken; }
/// <summary> /// Resilient Rebus decorator /// </summary> /// <param name="bus">The bus to decorate</param> /// <param name="policy">Retry policy, if not set default will be ued (10 times 1 second delay)</param> /// <param name="logger">Rebus logger</param> public TransientFaultBusDecorator(IBus bus, IAsyncPolicy policy = null, IRebusLoggerFactory logger = null) { this.innerBus = bus; Logger = logger?.GetLogger <TransientFaultBusDecorator>(); retryPolicy = policy ?? Policy.Handle <BrokerUnreachableException>().Or <OperationInterruptedException>() .WaitAndRetryAsync(Enumerable.Repeat(TimeSpan.FromSeconds(1), 10), (exception, delay, retryCount, context) => Logger?.Warn("Bus operation failed", exception)); MessageContextWrapper = () => MessageContext.Current; }
public MainCircuitBreaker(IList <ICircuitBreaker> circuitBreakers, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, Lazy <IBus> bus, CircuitBreakerEvents circuitBreakerEvents, Options options) { _log = rebusLoggerFactory?.GetLogger <MainCircuitBreaker>() ?? throw new ArgumentNullException(nameof(rebusLoggerFactory)); _circuitBreakers = circuitBreakers ?? new List <ICircuitBreaker>(); _bus = bus ?? throw new ArgumentNullException(nameof(bus)); _circuitBreakerEvents = circuitBreakerEvents; _options = options; _resetCircuitBreakerTask = asyncTaskFactory.Create(BackgroundTaskName, Reset, prettyInsignificant: true, intervalSeconds: 2); }
/// <summary> /// Creates the bucket in Google if it does not exist /// </summary> /// <param name="client">Google storage client</param> /// <param name="loggerFactory">Reference to the logger factory to create the logger</param> /// <param name="options">Options to configure the storage bus</param> internal static void CreateBucketIfNotExists(StorageClient client, IRebusLoggerFactory loggerFactory, GoogleCloudStorageOptions options) { if (options.AutoCreateBucket) { var log = loggerFactory?.GetLogger <GoogleCloudStorageDataBusStorage>() ?? throw new ArgumentNullException(nameof(loggerFactory)); if (!BucketExists(client, options.BucketName)) { log.Info("Bucket {0} does not exist - will create it now", options.BucketName); CreateBucket(client, options.ProjectId, options.BucketName); } } }
/// <summary> /// Creates the data storage /// </summary> public SqlServerDataBusStorage(IDbConnectionProvider connectionProvider, string tableName, bool ensureTableIsCreated, IRebusLoggerFactory rebusLoggerFactory, int commandTimeout) { if (tableName == null) { throw new ArgumentNullException(nameof(tableName)); } if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } _connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider)); _tableName = TableName.Parse(tableName); _ensureTableIsCreated = ensureTableIsCreated; _commandTimeout = commandTimeout; _log = rebusLoggerFactory.GetLogger <SqlServerDataBusStorage>(); }
/// <summary> /// Get the registered implementation of <seealso cref="ISagaTypeNamingStrategy"/> or the default <seealso cref="LegacySagaTypeNamingStrategy"/> if one is not configured /// </summary> private static ISagaTypeNamingStrategy GetSagaTypeNamingStrategy(IResolutionContext resolutionContext, IRebusLoggerFactory rebusLoggerFactory) { ISagaTypeNamingStrategy sagaTypeNamingStrategy; if (resolutionContext.Has <ISagaTypeNamingStrategy>() == false) { rebusLoggerFactory.GetLogger <SqlServerSagaStorage>().Debug($"An implementation of {nameof(ISagaTypeNamingStrategy)} was not registered. A default, backward compatible, implementation will be used ({nameof(LegacySagaTypeNamingStrategy)})."); sagaTypeNamingStrategy = new LegacySagaTypeNamingStrategy(); } else { sagaTypeNamingStrategy = resolutionContext.Get <ISagaTypeNamingStrategy>(); } return(sagaTypeNamingStrategy); }
/// <summary> /// Constructs the bus. /// </summary> public RebusBus(IWorkerFactory workerFactory, IRouter router, ITransport transport, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage, Options options, IRebusLoggerFactory rebusLoggerFactory, BusLifetimeEvents busLifetimeEvents, IDataBus dataBus) { _workerFactory = workerFactory; _router = router; _transport = transport; _pipelineInvoker = pipelineInvoker; _subscriptionStorage = subscriptionStorage; _options = options; _busLifetimeEvents = busLifetimeEvents; _dataBus = dataBus; _log = rebusLoggerFactory.GetLogger <RebusBus>(); var defaultBusName = $"Rebus {Interlocked.Increment(ref _busIdCounter)}"; _busName = options.OptionalBusName ?? defaultBusName; }
private void BuildInternal(string inputQueueAddress, IRebusLoggerFactory rebusLoggerFactory, int maxMessagesToPrefetch) { if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } if (maxMessagesToPrefetch <= 0) { throw new ArgumentException($"Cannot set 'maxMessagesToPrefetch' to {maxMessagesToPrefetch} - it must be at least 1!"); } _maxMessagesToPrefetch = (ushort)maxMessagesToPrefetch; _log = rebusLoggerFactory.GetLogger <RabbitMqTransport>(); Address = inputQueueAddress; }
/// <summary> /// Constructs a MySql transport. /// </summary> public MySqlTransport(MySqlConnectionHelper connectionHelper, string tableName, string inputQueueName, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, IRebusTime rebusTime) { if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } _connectionHelper = connectionHelper; _tableName = tableName; _inputQueueName = inputQueueName; _asyncTaskFactory = asyncTaskFactory ?? throw new ArgumentNullException(nameof(asyncTaskFactory)); _rebusTime = rebusTime ?? throw new ArgumentNullException(nameof(rebusTime)); ExpiredMessagesCleanupInterval = DefaultExpiredMessagesCleanupInterval; _expiredMessagesCleanupTask = asyncTaskFactory.Create("ExpiredMessagesCleanup", PerformExpiredMessagesCleanupCycle, intervalSeconds: 60); _log = rebusLoggerFactory.GetLogger <MySqlTransport>(); }
internal ThreadPoolWorker(string name, ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipelineInvoker pipelineInvoker, ParallelOperationsManager parallelOperationsManager, RebusBus owningBus, Options options, IBackoffStrategy backoffStrategy) { Name = name; _log = rebusLoggerFactory.GetLogger <ThreadPoolWorker>(); _transport = transport; _pipelineInvoker = pipelineInvoker; _parallelOperationsManager = parallelOperationsManager; _owningBus = owningBus; _options = options; _backoffStrategy = backoffStrategy; _workerThread = new Thread(Run) { Name = name, IsBackground = true }; _workerThread.Start(); }
/// <summary> /// Constructs the storage using the specified connection provider and table to store its subscriptions. If the subscription /// storage is shared by all subscribers and publishers, the <paramref name="isCentralized"/> parameter can be set to true /// in order to subscribe/unsubscribe directly instead of sending subscription/unsubscription requests /// </summary> public SqlServerSubscriptionStorage(IDbConnectionProvider connectionProvider, string tableName, bool isCentralized, IRebusLoggerFactory rebusLoggerFactory) { _connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider)); if (tableName == null) { throw new ArgumentNullException(nameof(tableName)); } if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } IsCentralized = isCentralized; _log = rebusLoggerFactory.GetLogger <SqlServerSubscriptionStorage>(); _tableName = TableName.Parse(tableName); }
/// <summary> /// Constructs the bus. /// </summary> public RebusBus(IWorkersCoordinatorFactory workerFactory, IRouter router, ITransport transport, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage, Options options, IRebusLoggerFactory rebusLoggerFactory, BusLifetimeEvents busLifetimeEvents, ITopicNameConvention topicNameConvention) { _workerFactory = workerFactory; _router = router; _transport = transport; _pipelineInvoker = pipelineInvoker; _subscriptionStorage = subscriptionStorage; _options = options; _busLifetimeEvents = busLifetimeEvents; _log = rebusLoggerFactory.GetLogger <RebusBus>(); _topicNameConvention = topicNameConvention; var defaultBusName = $"Rebus {Interlocked.Increment(ref _busIdCounter)}"; _busName = options.OptionalBusName ?? defaultBusName; _workers = new Lazy <IWorkersCoordinator>(() => _workerFactory.CreateWorkersCoordinator("RebusBus WorkersCoordinator", 0), true); }
public ConnectionManager(string connectionString, string inputQueueAddress, IRebusLoggerFactory rebusLoggerFactory) { if (connectionString == null) { throw new ArgumentNullException(nameof(connectionString)); } if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } _log = rebusLoggerFactory.GetLogger <ConnectionManager>(); if (inputQueueAddress != null) { _log.Info("Initializing RabbitMQ connection manager for transport with input queue '{0}'", inputQueueAddress); } else { _log.Info("Initializing RabbitMQ connection manager for one-way transport"); } var uriStrings = connectionString.Split(";,".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); if (uriStrings.Length == 0) { throw new ArgumentException("Please remember to specify at least one connection string for a RabbitMQ server somewhere. You can also add multiple connection strings separated by ; or , which Rebus will use in failover scenarios"); } if (uriStrings.Length > 1) { _log.Info("RabbitMQ transport has {0} connection strings available", uriStrings.Length); } _connectionFactory = new ConnectionFactory { Uri = uriStrings.First(), //Use the first URI in the list for ConnectionFactory to pick the AMQP credentials (if any) AutomaticRecoveryEnabled = true, NetworkRecoveryInterval = TimeSpan.FromSeconds(30), ClientProperties = CreateClientProperties(inputQueueAddress) }; _amqpTcpEndpoints = uriStrings .Select(GetAmqpTcpEndpoint) .ToList(); }
/// <summary> /// Constructs the timeout manager, using the specified connection provider and table to store the messages until they're due. /// </summary> public SqlServerTimeoutManager(IDbConnectionProvider connectionProvider, string tableName, IRebusLoggerFactory rebusLoggerFactory, IRebusTime rebusTime) { if (tableName == null) { throw new ArgumentNullException(nameof(tableName)); } if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } _connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider)); _rebusTime = rebusTime ?? throw new ArgumentNullException(nameof(rebusTime)); _tableName = TableName.Parse(tableName); _log = rebusLoggerFactory.GetLogger <SqlServerTimeoutManager>(); }
public AutoScaler(ITransport transport, IRebusLoggerFactory rebusLoggerFactory, int maximumNumberOfWorkers, IAsyncTaskFactory asyncTaskFactory, Func <IBus> busFactory, int adjustmentIntervalSeconds) { if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } if (asyncTaskFactory == null) { throw new ArgumentNullException(nameof(asyncTaskFactory)); } _logger = rebusLoggerFactory.GetLogger <AutoScaler>(); _transport = transport ?? throw new ArgumentNullException(nameof(transport)); _maximumNumberOfWorkers = maximumNumberOfWorkers; _busFactory = busFactory ?? throw new ArgumentNullException(nameof(busFactory)); _task = asyncTaskFactory.Create("AutoScale", Tick, intervalSeconds: adjustmentIntervalSeconds); }
/// <summary> /// Constructor /// </summary> /// <param name="connectionProvider">A <see cref="IDbConnection"/> to obtain a database connection</param> /// <param name="inputQueueName">Name of the queue this transport is servicing</param> /// <param name="rebusLoggerFactory">A <seealso cref="IRebusLoggerFactory"/> for building loggers</param> /// <param name="asyncTaskFactory">A <seealso cref="IAsyncTaskFactory"/> for creating periodic tasks</param> /// <param name="rebusTime">A <seealso cref="IRebusTime"/> to provide the current time</param> /// <param name="options">Additional options</param> public MySqlTransport( IDbConnectionProvider connectionProvider, string inputQueueName, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, IRebusTime rebusTime, MySqlTransportOptions options) { if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } if (asyncTaskFactory == null) { throw new ArgumentNullException(nameof(asyncTaskFactory)); } _rebusTime = rebusTime ?? throw new ArgumentNullException(nameof(rebusTime)); _connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider)); _receiveTableName = inputQueueName != null?TableName.Parse(inputQueueName) : null; _log = rebusLoggerFactory.GetLogger <MySqlTransport>(); var cleanupInterval = options.ExpiredMessagesCleanupInterval ?? DefaultExpiredMessagesCleanupInterval; var intervalSeconds = (int)cleanupInterval.TotalSeconds; _expiredMessagesCleanupTask = asyncTaskFactory.Create("ExpiredMessagesCleanup", PerformExpiredMessagesCleanupCycle, intervalSeconds: intervalSeconds); _autoDeleteQueue = options.AutoDeleteQueue; _leasedByFactory = options.LeasedByFactory ?? (() => Environment.MachineName); _leaseInterval = options.LeaseInterval ?? DefaultLeaseTime; _leaseTolerance = options.LeaseInterval ?? DefaultLeaseTolerance; _ensureTablesAreCreated = options.EnsureTablesAreCreated; var automaticLeaseRenewalInterval = options.LeaseAutoRenewInterval; if (!automaticLeaseRenewalInterval.HasValue) { _automaticLeaseRenewal = false; } else { _automaticLeaseRenewal = true; _automaticLeaseRenewalInterval = automaticLeaseRenewalInterval.Value; } }
/// <summary> /// Constructs the transport, connecting to the service bus pointed to by the connection string. /// </summary> public AzureServiceBusTransport(string connectionString, string queueName, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, INameFormatter nameFormatter, CancellationToken cancellationToken = default(CancellationToken), ITokenProvider tokenProvider = null) { if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } if (asyncTaskFactory == null) { throw new ArgumentNullException(nameof(asyncTaskFactory)); } _nameFormatter = nameFormatter; if (queueName != null) { // this never happens if (queueName.StartsWith(MagicSubscriptionPrefix)) { throw new ArgumentException($"Sorry, but the queue name '{queueName}' cannot be used because it conflicts with Rebus' internally used 'magic subscription prefix': '{MagicSubscriptionPrefix}'. "); } Address = _nameFormatter.FormatQueueName(queueName); _subscriptionName = _nameFormatter.FormatSubscriptionName(queueName); } _connectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString)); _cancellationToken = cancellationToken; _log = rebusLoggerFactory.GetLogger <AzureServiceBusTransport>(); if (tokenProvider != null) { var connectionStringBuilder = new ServiceBusConnectionStringBuilder(connectionString); _managementClient = new ManagementClient(connectionStringBuilder, tokenProvider); _endpoint = connectionStringBuilder.Endpoint; _transportType = connectionStringBuilder.TransportType; } else { _managementClient = new ManagementClient(connectionString); } _tokenProvider = tokenProvider; _messageLockRenewalTask = asyncTaskFactory.Create("Peek Lock Renewal", RenewPeekLocks, prettyInsignificant: true, intervalSeconds: 10); }
/// <summary> /// Constructs the step /// </summary> public IdempotentMessageIncomingStep(ITransport transport, IMessageStorage messageStorage, IRebusLoggerFactory rebusLoggerFactory) { if (transport == null) { throw new ArgumentNullException(nameof(transport)); } if (messageStorage == null) { throw new ArgumentNullException(nameof(messageStorage)); } if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } _transport = transport; _msgStorage = messageStorage; _log = rebusLoggerFactory.GetLogger <IdempotentMessageIncomingStep>(); }
/// <summary> /// Constructs the timeout manager /// </summary> public MySqlTimeoutManager(MySqlConnectionHelper connectionHelper, string tableName, IRebusLoggerFactory rebusLoggerFactory) { if (connectionHelper == null) { throw new ArgumentNullException(nameof(connectionHelper)); } if (tableName == null) { throw new ArgumentNullException(nameof(tableName)); } if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } _connectionHelper = connectionHelper; _tableName = tableName; _log = rebusLoggerFactory.GetLogger <MySqlTimeoutManager>(); }
/// <summary> /// Constructs the step /// </summary> public ForwardTransportMessageStep(Func <TransportMessage, Task <ForwardAction> > routingFunction, ITransport transport, IRebusLoggerFactory rebusLoggerFactory) { if (routingFunction == null) { throw new ArgumentNullException(nameof(routingFunction)); } if (transport == null) { throw new ArgumentNullException(nameof(transport)); } if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } _routingFunction = routingFunction; _transport = transport; _log = rebusLoggerFactory.GetLogger <ForwardTransportMessageStep>(); }
/// <summary> /// Creates the error handler /// </summary> public PoisonQueueErrorHandler(SimpleRetryStrategySettings simpleRetryStrategySettings, ITransport transport, IRebusLoggerFactory rebusLoggerFactory) { if (simpleRetryStrategySettings == null) { throw new ArgumentNullException(nameof(simpleRetryStrategySettings)); } if (transport == null) { throw new ArgumentNullException(nameof(transport)); } if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } _simpleRetryStrategySettings = simpleRetryStrategySettings; _transport = transport; _log = rebusLoggerFactory.GetLogger <PoisonQueueErrorHandler>(); }
public KafkaTransport( IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, ISerializer customSerializer, string brokerList, string groupId, string topicPrefix) { _log = rebusLoggerFactory.GetLogger <KafkaTransport>(); _brokerList = brokerList; _customSerializer = customSerializer; _groupId = groupId; _knownRoutes = new ConcurrentBag <string>(); _knownRoutes.Add($"^{topicPrefix}.*"); _knownRoutes.Add($"{topicPrefix}"); _topicPrefix = topicPrefix; _asyncTaskFactory = asyncTaskFactory ?? throw new ArgumentNullException(nameof(asyncTaskFactory)); }
/// <summary> /// Constructs the timeout manager /// </summary> public MongoDbTimeoutManager(IRebusTime rebusTime, IMongoDatabase database, string collectionName, IRebusLoggerFactory rebusLoggerFactory) { if (database == null) { throw new ArgumentNullException(nameof(database)); } if (collectionName == null) { throw new ArgumentNullException(nameof(collectionName)); } if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } _rebusTime = rebusTime ?? throw new ArgumentNullException(nameof(rebusTime)); _log = rebusLoggerFactory.GetLogger <MongoDbTimeoutManager>(); _timeouts = database.GetCollection <Timeout>(collectionName); }
/// <summary> /// Creates the data bus storage /// </summary> public AzureBlobsDataBusStorage(CloudStorageAccount storageAccount, string containerName, IRebusLoggerFactory loggerFactory) { if (storageAccount == null) { throw new ArgumentNullException(nameof(storageAccount)); } if (containerName == null) { throw new ArgumentNullException(nameof(containerName)); } if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } _containerName = containerName.ToLowerInvariant(); _client = storageAccount.CreateCloudBlobClient(); _log = loggerFactory.GetLogger <AzureBlobsDataBusStorage>(); }
internal KafkaSubscriptionStorage(IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory , string brokerList, string inputQueueName, string groupId = null, CancellationToken cancellationToken = default(CancellationToken)) { if (string.IsNullOrWhiteSpace(brokerList)) { throw new NullReferenceException(nameof(brokerList)); } var maxNameLength = 249; if (inputQueueName.Length > maxNameLength && _topicRegex.IsMatch(inputQueueName)) { throw new ArgumentException("Invalid characters or length of a topic (file)", nameof(inputQueueName)); } if (inputQueueName.StartsWith(_magicSubscriptionPrefix)) { throw new ArgumentException($"Sorry, but the queue name '{inputQueueName}' cannot be used because it conflicts with Rebus' internally used 'magic subscription prefix': '{_magicSubscriptionPrefix}'. "); } _config = new ConsumerConfig { BootstrapServers = brokerList, ApiVersionRequest = true, GroupId = !string.IsNullOrEmpty(groupId) ? groupId : Guid.NewGuid().ToString("N"), EnableAutoCommit = false, FetchWaitMaxMs = 5, FetchErrorBackoffMs = 5, QueuedMinMessages = 1000, SessionTimeoutMs = 6000, //StatisticsIntervalMs = 5000, #if DEBUG TopicMetadataRefreshIntervalMs = 20000, // Otherwise it runs maybe five minutes Debug = "msg", #endif AutoOffsetReset = AutoOffsetReset.Latest, EnablePartitionEof = true }; _config.Set("fetch.message.max.bytes", "10240"); _asyncTaskFactory = asyncTaskFactory ?? throw new ArgumentNullException(nameof(asyncTaskFactory)); _log = rebusLoggerFactory.GetLogger <KafkaSubscriptionStorage>(); _cancellationToken = cancellationToken; _subscriptions.TryAdd(inputQueueName, new[] { inputQueueName }); }
public TplWorker(string workerName, RebusBus owningBus, ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipelineInvoker pipelineInvoker, ParallelOperationsManager parallelOperationsManager, Options options, IBackoffStrategy backoffStrategy, CancellationToken busDisposalCancellationToken) { _owningBus = owningBus; _transport = transport; _pipelineInvoker = pipelineInvoker; _parallelOperationsManager = parallelOperationsManager; _options = options; _backoffStrategy = backoffStrategy; _busDisposalCancellationToken = busDisposalCancellationToken; Name = workerName; _cancellationToken = _cancellationTokenSource.Token; _log = rebusLoggerFactory.GetLogger <TplWorker>(); Task.Run(Run); }
/// <summary> /// Enables message validation for incoming messages using FluentValidation. /// <para> /// When an incoming message fails to validate, by default it is wrapped in a <see cref="IValidationFailed{TMessage}"/> message and dispatched to handlers implementing this wrapped message type. Use the <paramref name="onFailed"/> builder to configure if messages should be handled differently (f.ex. move to error queue, drop, etc.). /// </para> /// </summary> /// <param name="configurer">The options configurer.</param> /// <param name="validatorFactory">The FluentValidation validator factory to resolve message validators from.</param> /// <param name="onFailed">A builder to configure how messages should be handled when validation fails.</param> public static void ValidateIncomingMessages(this OptionsConfigurer configurer, IValidatorFactory validatorFactory, Action <ValidationConfigurer>?onFailed = null) { if (configurer is null) { throw new ArgumentNullException(nameof(configurer)); } if (validatorFactory is null) { throw new ArgumentNullException(nameof(validatorFactory)); } var opts = new ValidationConfigurer(configurer); onFailed?.Invoke(opts); configurer.Register(ctx => { IRebusLoggerFactory loggerFactory = ctx.Get <IRebusLoggerFactory>(); return(new ValidateIncomingStep( loggerFactory.GetLogger <ValidateIncomingStep>(), validatorFactory, ctx.Get <IReadOnlyDictionary <Type, IValidationFailedStrategy> >(), // By default, handle as IValidationFailed<> ctx.Get <WrapAsValidationFailed>() )); }); configurer.Decorate <IPipeline>(ctx => { IPipeline pipeline = ctx.Get <IPipeline>(); var pipelineInjector = new PipelineStepInjector(pipeline); ValidateIncomingStep incomingStep = ctx.Get <ValidateIncomingStep>(); pipelineInjector.OnReceive( incomingStep, PipelineRelativePosition.After, typeof(DeserializeIncomingMessageStep) ); return(pipelineInjector); }); }
/// <summary> /// Constructs the transport /// </summary> public AzureStorageQueuesTransport(CloudStorageAccount storageAccount, string inputQueueName, IRebusLoggerFactory rebusLoggerFactory) { if (storageAccount == null) { throw new ArgumentNullException(nameof(storageAccount)); } if (rebusLoggerFactory == null) { throw new ArgumentNullException(nameof(rebusLoggerFactory)); } _queueClient = storageAccount.CreateCloudQueueClient(); _log = rebusLoggerFactory.GetLogger <AzureStorageQueuesTransport>(); if (inputQueueName != null) { _inputQueueName = inputQueueName.ToLowerInvariant(); } }