internal static ScheduledHorizontalScaleForecastWorker[] GetScheduledHorizontalScaleForecastWorkers() { IConfigurationSource configurationSource = GetConfigurationSource(); ArrayList list = new ArrayList(); foreach (ScheduledHorizontalScaleConfiguration scheduledHorizontalScaleConfiguration in configurationSource.GetWindowsAzureScheduledHorizontalScaleConfigurations()) { SubscriptionConfiguration subscriptionConfiguration = configurationSource.GetWindowsAzureSubscriptionConfiguration(scheduledHorizontalScaleConfiguration.SubscriptionConfigurationId); foreach (ScheduleDefinitionConfiguration scheduleDefinitionConfiguration in scheduledHorizontalScaleConfiguration.Schedules) { HorizontalScale[] horizontalScales = GetHorizontalScalesFromHorizontalScaleConfiguration(scheduledHorizontalScaleConfiguration.HorizontalScales.ToArray()); ScheduleDay[] scheduleDays = GetScheduleDaysFromScheduleConfiguration(scheduleDefinitionConfiguration); ScheduledHorizontalScaleForecastWorker scheduledHorizontalScaleForecastWorker = new ScheduledHorizontalScaleForecastWorker( new Deployment(), new Operation(), subscriptionConfiguration.SubscriptionId, subscriptionConfiguration.CertificateThumbprint, scheduledHorizontalScaleConfiguration.ServiceName, scheduledHorizontalScaleConfiguration.DeploymentSlot, horizontalScales, scheduleDays, scheduledHorizontalScaleConfiguration.TreatWarningsAsError, scheduledHorizontalScaleConfiguration.Mode, scheduledHorizontalScaleConfiguration.PollingIntervalInMinutes); list.Add(scheduledHorizontalScaleForecastWorker); } } return((ScheduledHorizontalScaleForecastWorker[])list.ToArray(typeof(ScheduledHorizontalScaleForecastWorker))); }
public void UnitTestGetWindowsAzureSubscriptionConfiguration() { ConfigSectionConfigurationSource configSectionConfigurationSource = new ConfigSectionConfigurationSource(); SubscriptionConfiguration subscriptionConfiguration = configSectionConfigurationSource.GetWindowsAzureSubscriptionConfiguration("myArbitraryAzureSubscriptionName"); Assert.IsNotNull(subscriptionConfiguration); }
internal static DeploymentDeleteForecastWorker[] GetDeploymentDeleteForecastWorkers() { IConfigurationSource configurationSource = GetConfigurationSource(); ArrayList list = new ArrayList(); foreach (DeploymentDeleteConfiguration deploymentDeleteConfiguration in configurationSource.GetWindowsAzureDeploymentDeleteConfigurations()) { SubscriptionConfiguration subscriptionConfiguration = configurationSource.GetWindowsAzureSubscriptionConfiguration(deploymentDeleteConfiguration.SubscriptionConfigurationId); foreach (string deploymentSlot in deploymentDeleteConfiguration.DeploymentSlots) { foreach (ScheduleDefinitionConfiguration scheduleDefinitionConfiguration in deploymentDeleteConfiguration.Schedules) { ScheduleDay[] scheduleDays = GetScheduleDaysFromScheduleConfiguration(scheduleDefinitionConfiguration); DeploymentDeleteForecastWorker deploymentDeleteForecastWorker = new DeploymentDeleteForecastWorker( new Deployment(), new Operation(), subscriptionConfiguration.SubscriptionId, subscriptionConfiguration.CertificateThumbprint, deploymentDeleteConfiguration.ServiceName, deploymentSlot, scheduleDays, deploymentDeleteConfiguration.PollingIntervalInMinutes); list.Add(deploymentDeleteForecastWorker); } } } return((DeploymentDeleteForecastWorker[])list.ToArray(typeof(DeploymentDeleteForecastWorker))); }
internal static DeploymentCreateForecastWorker[] GetDeploymentCreateForecastWorkers() { IConfigurationSource configurationSource = GetConfigurationSource(); ArrayList list = new ArrayList(); foreach (DeploymentCreateConfiguration deploymentCreateConfiguration in configurationSource.GetWindowsAzureDeploymentCreateConfigurations()) { SubscriptionConfiguration subscriptionConfiguration = configurationSource.GetWindowsAzureSubscriptionConfiguration(deploymentCreateConfiguration.SubscriptionConfigurationId); PackageConfiguration packageConfiguration = configurationSource.GetWindowsAzurePackageConfiguration(deploymentCreateConfiguration.WindowsAzurePackageId); foreach (ScheduleDefinitionConfiguration scheduleDefinitionConfiguration in deploymentCreateConfiguration.Schedules) { ScheduleDay[] scheduleDays = GetScheduleDaysFromScheduleConfiguration(scheduleDefinitionConfiguration); Uri packageUrl = Blob.GetUrl(packageConfiguration.StorageAccountName, packageConfiguration.ContainerName, packageConfiguration.BlobName); DeploymentCreateForecastWorker deploymentCreateForecastWorker = new DeploymentCreateForecastWorker( new Deployment(), new Operation(), subscriptionConfiguration.SubscriptionId, subscriptionConfiguration.CertificateThumbprint, deploymentCreateConfiguration.ServiceName, deploymentCreateConfiguration.DeploymentSlot, scheduleDays, deploymentCreateConfiguration.DeploymentName, packageUrl, deploymentCreateConfiguration.DeploymentLabel, deploymentCreateConfiguration.PackageConfigurationFilePath, deploymentCreateConfiguration.StartDeployment, deploymentCreateConfiguration.TreatWarningsAsError, deploymentCreateConfiguration.PollingIntervalInMinutes); list.Add(deploymentCreateForecastWorker); } } return((DeploymentCreateForecastWorker[])list.ToArray(typeof(DeploymentCreateForecastWorker))); }
private SubscriptionManager GetSubscriptionManager(SubscribeOption subscribe) { var workQueue = new Mock <IQueue>(); workQueue.Setup(m => m.Uri).Returns(new Uri(WorkQueueUri)); var serviceBusConfiguration = new ServiceBusConfiguration { Inbox = new InboxQueueConfiguration { WorkQueue = workQueue.Object } }; var subscriptionConfiguration = new SubscriptionConfiguration { ConnectionString = ConnectionString, ProviderName = ProviderName, Subscribe = subscribe }; subscriptionConfiguration.Subscribe = subscribe; var serviceBusEvents = new ServiceBusEvents(); var subscriptionManager = new SubscriptionManager(serviceBusEvents, serviceBusConfiguration, subscriptionConfiguration, new ScriptProvider(new ScriptProviderConfiguration()), DatabaseContextFactory, DatabaseGateway); serviceBusEvents.OnStarted(this, new PipelineEventEventArgs(new Mock <IPipelineEvent>().Object)); return(subscriptionManager); }
public RavenConfiguration(string resourceName, ResourceType resourceType, string customConfigPath = null) { ResourceName = resourceName; ResourceType = resourceType; _configBuilder = new ConfigurationBuilder(); AddEnvironmentVariables(); AddJsonConfigurationVariables(customConfigPath); Settings = _configBuilder.Build(); Core = new CoreConfiguration(); Http = new HttpConfiguration(); Replication = new ReplicationConfiguration(); Cluster = new ClusterConfiguration(); Etl = new EtlConfiguration(); Storage = new StorageConfiguration(); Security = new SecurityConfiguration(); PerformanceHints = new PerformanceHintsConfiguration(); Indexing = new IndexingConfiguration(this); Monitoring = new MonitoringConfiguration(); Queries = new QueryConfiguration(); Patching = new PatchingConfiguration(); Logs = new LogsConfiguration(); Server = new ServerConfiguration(); Testing = new TestingConfiguration(); Databases = new DatabaseConfiguration(); Memory = new MemoryConfiguration(); Studio = new StudioConfiguration(); Licensing = new LicenseConfiguration(); Tombstones = new TombstoneConfiguration(); Subscriptions = new SubscriptionConfiguration(); }
public ISubscription SubscribeAsync <T>(Func <T, Task> subscribeMethod, SubscriptionConfiguration config) { var routingKey = config.RoutingKey; var topologyTask = _topologyProvider.BindQueueAsync(config.Queue, config.Exchange, routingKey); var channelTask = _channelFactory.CreateChannelAsync(); var subscriberTask = Task .WhenAll(topologyTask, channelTask) .ContinueWith(t => { if (topologyTask.IsFaulted) { throw topologyTask.Exception ?? new Exception("Topology Task Faulted"); } var consumer = _consumerFactory.CreateConsumer(config, channelTask.Result); consumer.OnMessageAsync = async(o, args) => { var body = _serializer.Deserialize <T>(args.Body); await subscribeMethod(body); }; consumer.Model.BasicConsume(config.Queue.FullQueueName, config.NoAck, consumer); _logger.LogDebug($"Setting up a consumer on channel '{channelTask.Result.ChannelNumber}' for queue {config.Queue.QueueName} with NoAck set to {config.NoAck}."); return(new Subscription(consumer, config.Queue.FullQueueName)); }); Task.WaitAll(subscriberTask); _subscriptions.Add(subscriberTask.Result); return(subscriberTask.Result); }
public TableSubscriptionRepository(SubscriptionConfiguration configuration) { var storageAccount = CloudStorageAccount.Parse(configuration.StorageConnectionString); var tableClient = storageAccount.CreateCloudTableClient(); _table = tableClient.GetTableReference(configuration.StorageTableName); }
public OrderListener(SubscriptionConfiguration subscriptionConfiguration, TopicConfiguration topicConfiguration, RestaurantManagementContext restaurantManagementContext) { this._subscriptionClient = new SubscriptionClient(subscriptionConfiguration.ConnectionString, subscriptionConfiguration.Topic, subscriptionConfiguration.Name); _topicClient = new TopicClient(topicConfiguration.ConnectionString, topicConfiguration.Name); this._restaurantManagementContext = restaurantManagementContext; }
public void NoSubscriptions() { var configuration = new SubscriptionConfiguration(); var args = FakeBasicDeliverEventArgs(); var message = new FakeConsumedMessage(new Foo(), args); var subscriptions = configuration.FindSubscriptions(message); Assert.Equal(0, subscriptions.Count()); }
protected ConsumerBase(IModel model, IConsumedMessageBuilder builder, SubscriptionConfiguration configuration) : base(model) { Builder = builder; Configuration = configuration; }
public ISubscription Subscribe <TMessage>(Action <TMessage, IDeliveryContext> onMessage, Action <ISubscriptionBuilder> builder) { var configuration = new SubscriptionConfiguration(); builder(configuration); return(Subscribe(onMessage, configuration)); }
public Task <Guid> Handle(CreateSubcriptionConfigurationCommand request, CancellationToken cancellationToken) { SubscriptionConfiguration configuration = SubscriptionConfiguration.Create(request.SubcriptionId, request.ConfigurationId, request.Enabled); _configurationRepository.Save(configuration); _unitOfWork.Save(); return(Task.FromResult(configuration.Id)); }
public IConfigurated WithConfiguration(SubscriptionConfiguration configuration) { var serviceBus = _resolver.Resolve <IServiceBus>(); if (_name == null) { return((IConfigurated)serviceBus.Subscribe(_resolver.Resolve <THandler>(), configuration)); } return((IConfigurated)serviceBus.Subscribe(_resolver.ResolveNamed <THandler>(_name))); }
public SubscriptionConfiguration[] GetAllWindowsAzureSubscriptionConfigurations() { SubscriptionConfiguration[] subscriptionConfigurations = new SubscriptionConfiguration[StealFocusForecastConfiguration.Instance.WindowsAzure.Subscriptions.Count]; for (int i = 0; i < StealFocusForecastConfiguration.Instance.WindowsAzure.Subscriptions.Count; i++) { subscriptionConfigurations[i] = this.GetWindowsAzureSubscriptionConfiguration(StealFocusForecastConfiguration.Instance.WindowsAzure.Subscriptions[i].Id); } return(subscriptionConfigurations); }
private void Subscribe(Action<SubscriptionConfiguration> configure, Func<IConsumedMessageBuilder, SubscriptionConfiguration, ConsumerBase> func, IFallbackStrategy fallbackStrategy) { var configuration = new SubscriptionConfiguration(fallbackStrategy); configure(configuration); var builder = new ConsumedMessageBuilder(new SerializerFactory(), _resolver); _model.BasicConsume(_name, false, func(builder, configuration)); }
public void Should_have_called_subscribe_with_no_expires() { var subscriptionConfiguration = new SubscriptionConfiguration(1); capturedAction(subscriptionConfiguration); subscriptionConfiguration.AutoDelete.ShouldBeTrue(); subscriptionConfiguration.Expires.ShouldEqual(null); subscriptionConfiguration.PrefetchCount.ShouldEqual((ushort)10); subscriptionConfiguration.Priority.ShouldEqual(10); }
public void Should_have_called_subscribe_with_attribute_values_notaction_values() { var subscriptionConfiguration = new SubscriptionConfiguration(1); capturedAction(subscriptionConfiguration); subscriptionConfiguration.AutoDelete.Should().BeTrue(); subscriptionConfiguration.Expires.Should().Be(10); subscriptionConfiguration.PrefetchCount.Should().Be(10); subscriptionConfiguration.Priority.Should().Be(10); }
public void Should_have_called_subscribe_with_action_capable_of_configuring_subscription() { var subscriptionConfiguration = new SubscriptionConfiguration(1); capturedAction(subscriptionConfiguration); subscriptionConfiguration.AutoDelete.Should().BeTrue(); subscriptionConfiguration.Expires.Should().Be(10); subscriptionConfiguration.PrefetchCount.Should().Be(10); subscriptionConfiguration.Priority.Should().Be(10); }
public void Should_have_called_subscribe_with_action_capable_of_configuring_subscription() { var subscriptionConfiguration = new SubscriptionConfiguration(1); capturedAction.Should().NotBeNull("SubscribeAsync should have been invoked"); capturedAction(subscriptionConfiguration); subscriptionConfiguration.AutoDelete.Should().BeTrue(); subscriptionConfiguration.Expires.Should().Be(10); subscriptionConfiguration.PrefetchCount.Should().Be((ushort)10); subscriptionConfiguration.Priority.Should().Be(10); }
public void Should_have_called_subscribe_with_action_capable_of_configuring_subscription() { var subscriptionConfiguration = new SubscriptionConfiguration(1); capturedAction(subscriptionConfiguration); subscriptionConfiguration.AutoDelete.ShouldBeTrue(); subscriptionConfiguration.CancelOnHaFailover.ShouldBeTrue(); subscriptionConfiguration.Expires.ShouldEqual(10); subscriptionConfiguration.PrefetchCount.ShouldEqual((ushort)10); subscriptionConfiguration.Priority.ShouldEqual(10); }
public void OnError() { var model = new Mock<IModel>(); var strategy = new Mock<IFallbackStrategy>(); var args = FakeBasicDeliverEventArgs(); var message = new FakeConsumedMessage(new Object(), args); var configuration = new SubscriptionConfiguration(strategy.Object); configuration.Consumes(new FakeConsumer(consumedMessage => { throw new Exception(); })); var result = message.ConsumeAsync(configuration).Result; Assert.IsType<ConsumingFailure>(result); result.Reply(model.Object); strategy.Verify(_ => _.Apply(model.Object), Times.Never); }
public OrderListener(SubscriptionConfiguration subscriptionConfiguration, TopicConfiguration topicConfiguration, RestaurantManagementContext restaurantManagementContext, IMapper mapper) { this._subscriptionClient = new SubscriptionClient(subscriptionConfiguration.ConnectionString, subscriptionConfiguration.Topic, subscriptionConfiguration.Name); _topicClient = new TopicClient(topicConfiguration.ConnectionString, topicConfiguration.Name); this._subscriptionConfiguration = subscriptionConfiguration; this._topicConfiguration = topicConfiguration; this._restaurantManagementContext = restaurantManagementContext; this._mapper = mapper; _serviceBusMessageSender = new ServiceBusMessageSender(topicConfiguration); }
/// <summary> /// Processes the cache event. /// </summary> /// <param name="cacheEventType">Type of the cache event.</param> /// <param name="subscriptionConfiguration">The subscription group.</param> /// <returns></returns> private async Task ProcessCacheEvent(CacheEventType cacheEventType, SubscriptionConfiguration subscriptionConfiguration) { if (cacheEventType == CacheEventType.Added) { // Create a new subscription ISubscription subscription = this.SubscriptionResolver(); // Start this subscription await subscription.StartSubscription(subscriptionConfiguration.SubscriptionId, subscriptionConfiguration.StreamName, subscriptionConfiguration.GroupName); // Add this to the cached subscription list this.SubscriptionList.Add(subscription); } else if (cacheEventType == CacheEventType.Removed) { // Find the item that has been removed based on the event argument ISubscription subscription = this.SubscriptionList.Single(x => x.SubscriptionId == subscriptionConfiguration.SubscriptionId); // Stop the subscription await subscription.StopSubscription(); // Now remove the item this.SubscriptionList.Remove(subscription); } else if (cacheEventType == CacheEventType.Updated) { // Find the item that has been updated based on the event argument ISubscription subscription = this.SubscriptionList.SingleOrDefault(x => x.SubscriptionId == subscriptionConfiguration.SubscriptionId); if (subscription != null) { // Stop the current subscription await subscription.StopSubscription(); // Re-Create the subscription // Start this subscription await subscription.StartSubscription(subscriptionConfiguration.SubscriptionId, subscriptionConfiguration.StreamName, subscriptionConfiguration.GroupName, subscriptionConfiguration.StreamPositionToRestartFrom); // Update the repository position INewConfigurationRepository configRepository = this.RepositoryResolver(); await configRepository.ResetSubscriptionStreamPosition(subscriptionConfiguration.SubscriptionId, CancellationToken.None); } } }
public Task <Guid> Handle(EditSubcriptionConfigurationCommand request, CancellationToken cancellationToken) { SubscriptionConfiguration configuration = _configurationRepository.Find(request.Id); if (configuration == null) { throw new Exception(typeof(SubscriptionConfiguration).Name + " not found."); } configuration.Edit(request.SubcriptionId, request.ConfigurationId, request.Enabled); _unitOfWork.Save(); return(Task.FromResult(configuration.Id)); }
public void Defaults_are_correct() { var configuration = new SubscriptionConfiguration(99); Assert.Equal(0, configuration.Topics.Count); Assert.False(configuration.AutoDelete); Assert.Equal(0, configuration.Priority); Assert.Equal(99, configuration.PrefetchCount); Assert.False(configuration.IsExclusive); Assert.True(configuration.Durable); Assert.Null(configuration.QueueName); Assert.Null(configuration.MaxLength); Assert.Null(configuration.MaxLengthBytes); }
public void AcknowledgeThrows() { const Int64 deliveryTag = 1234L; var model = new Mock<IModel>(); model.Setup(_ => _.BasicAck(deliveryTag, false)).Throws(new Exception()); var builder = new Mock<IConsumedMessageBuilder>(); var configuration = new SubscriptionConfiguration(); var consumer = new AtMostOnceConsumerWrapper(model.Object, builder.Object, configuration); var args = new BasicDeliverEventArgs { DeliveryTag = deliveryTag, BasicProperties = new BasicProperties() }; Assert.Throws<Exception>(() => consumer.CallConsumeInternal(args).Wait()); builder.Verify(_ => _.Build(args), Times.Never); }
public Task <SubcriptionConfigurationReadModel> Handle(SubscriptionConfigurationsDetailQuery request, CancellationToken cancellationToken) { SubscriptionConfiguration subscriptionConfiguration = _subscriptionRepository.Find(request.Id); SubcriptionConfigurationReadModel subscriptionReadModel = null; if (subscriptionConfiguration != null) { subscriptionReadModel = new SubcriptionConfigurationReadModel { Id = subscriptionConfiguration.Id, ConfigurationId = subscriptionConfiguration.ConfigurationId, SubcriptionId = subscriptionConfiguration.SubcriptionId, Enabled = subscriptionConfiguration.Enabled }; } return(Task.FromResult(subscriptionReadModel)); }
private static Mock<IModel> BuildModel(UInt64 deliveryTag, Func<ConsumedMessageBase, AggregateConsumingResult> func) { var args = new BasicDeliverEventArgs { DeliveryTag = deliveryTag, BasicProperties = new BasicProperties() }; var configuration = new SubscriptionConfiguration(); var builder = new Mock<IConsumedMessageBuilder>(); var message = new FakeConsumedMessage(args, func); builder.Setup(_ => _.Build(args)).Returns(message); var model = new Mock<IModel>(); var consumer = new AtLeastOnceConsumerWrapper(model.Object, builder.Object, configuration); consumer.CallConsumeInternal(args).Wait(); return model; }
public static ContainerBuilder SubscribeRead(this ContainerBuilder containerBuilder, Action <SubscriptionConfiguration> subscriptionConfiguration, ProjectorInvoker projectorInvoker = null) { SubscriptionConfiguration configuration = new SubscriptionConfiguration(); subscriptionConfiguration.Invoke(configuration); containerBuilder.RegisterInstance(configuration).As <ISubscriptionConfiguration>().SingleInstance(); if (projectorInvoker == null) { containerBuilder.RegisterType <EventInvoker>().As <ProjectorInvoker>().SingleInstance(); } else { containerBuilder.RegisterInstance(projectorInvoker).As <ProjectorInvoker>().SingleInstance(); } return(containerBuilder); }
public void Should_set_properties_on_SubscriptionConfiguration() { Action <ISubscriptionConfiguration <object> > configure = x => x .WithArgument("key1", "value1") .WithArgument("key2", "value2") .WithTopic("abc") .WithTopic("def"); var configuration = new SubscriptionConfiguration <object>(); configure(configuration); configuration.Topics[0].ShouldEqual("abc"); configuration.Topics[1].ShouldEqual("def"); configuration.Arguments["key1"].ShouldEqual("value1"); configuration.Arguments["key2"].ShouldEqual("value2"); }
public virtual async Task OnSubscriberExceptionAsync(IRawConsumer consumer, SubscriptionConfiguration config, BasicDeliverEventArgs args, Exception exception) { if (!config.NoAck) { consumer.Model.BasicAck(args.DeliveryTag, false); consumer.AcknowledgedTags.Add(args.DeliveryTag); } try { _logger.LogError($"Error thrown in Subscriber: ", exception); _logger.LogDebug($"Attempting to publish message '{args.BasicProperties.MessageId}' to error exchange."); await _topologyProvider.DeclareExchangeAsync(_errorExchangeCfg); var channel = await _channelFactory.GetChannelAsync(); var msg = _serializer.Deserialize(args); var actualException = UnwrapInnerException(exception); var errorMsg = new HandlerExceptionMessage { Exception = new ExceptionInformation { ExceptionType = actualException.GetType().FullName, InnerMessage = actualException.InnerException?.Message, Message = actualException.Message, StackTrace = actualException.StackTrace }, Time = DateTime.Now, Host = Environment.MachineName, Message = msg, }; channel.BasicPublish( exchange: _errorExchangeCfg.ExchangeName, routingKey: args.RoutingKey, basicProperties: args.BasicProperties, body: _serializer.Serialize(errorMsg) ); channel.Close(); } catch (Exception e) { _logger.LogWarning($"Unable to publish message '{args.BasicProperties.MessageId}' to default error exchange.", e); } }
private RavenConfiguration(string resourceName, ResourceType resourceType, string customConfigPath = null) { _logger = LoggingSource.Instance.GetLogger <RavenConfiguration>(resourceName); ResourceName = resourceName; ResourceType = resourceType; _customConfigPath = customConfigPath; PathSettingBase <string> .ValidatePath(_customConfigPath); _configBuilder = new ConfigurationBuilder(); AddEnvironmentVariables(); AddJsonConfigurationVariables(customConfigPath); Settings = _configBuilder.Build(); Core = new CoreConfiguration(); Http = new HttpConfiguration(); Replication = new ReplicationConfiguration(); Cluster = new ClusterConfiguration(); Etl = new EtlConfiguration(); Storage = new StorageConfiguration(); Security = new SecurityConfiguration(); Backup = new BackupConfiguration(); PerformanceHints = new PerformanceHintsConfiguration(); Indexing = new IndexingConfiguration(this); Monitoring = new MonitoringConfiguration(); Queries = new QueryConfiguration(); Patching = new PatchingConfiguration(); Logs = new LogsConfiguration(); Server = new ServerConfiguration(); Embedded = new EmbeddedConfiguration(); Databases = new DatabaseConfiguration(Storage.ForceUsing32BitsPager); Memory = new MemoryConfiguration(); Studio = new StudioConfiguration(); Licensing = new LicenseConfiguration(); Tombstones = new TombstoneConfiguration(); Subscriptions = new SubscriptionConfiguration(); TransactionMergerConfiguration = new TransactionMergerConfiguration(Storage.ForceUsing32BitsPager); Notifications = new NotificationConfiguration(); Updates = new UpdatesConfiguration(); Migration = new MigrationConfiguration(); }
public void SubscriptionConfigurationCreatedSuccessfully() { var _subscriptionConfigurationRepository = StartUpTests.ServiceProvider.GetService <ISubscriptionConfigurationRepository>(); Guid configurationId = Guid.NewGuid(); Guid subscriptionId = Guid.NewGuid(); SubscriptionConfiguration subsconfiguration = SubscriptionConfiguration.Create(subscriptionId, configurationId, true); _subscriptionConfigurationRepository.Save(subsconfiguration); StartUpTests.UnitOfWork.Save(); Assert.IsNotNull(subsconfiguration.Id); SubscriptionConfiguration subscriptionConfigurationRead = _subscriptionConfigurationRepository.Find(subsconfiguration.Id); Assert.IsNotNull(subscriptionConfigurationRead); Assert.AreEqual(subscriptionId, subscriptionConfigurationRead.SubcriptionId); Assert.AreEqual(configurationId, subscriptionConfigurationRead.ConfigurationId); Assert.AreEqual(true, subscriptionConfigurationRead.Enabled); }
public virtual Task OnSubscriberExceptionAsync(IRawConsumer consumer, SubscriptionConfiguration config, BasicDeliverEventArgs args, Exception exception) { if (!config.NoAck) { consumer.Model.BasicAck(args.DeliveryTag, false); consumer.AcknowledgedTags.Add(args.DeliveryTag); } try { _logger.LogError($"Error thrown in Subscriber: ", exception); _logger.LogDebug($"Attempting to publish message '{args.BasicProperties.MessageId}' to error exchange."); var topologyTask = _topologyProvider.DeclareExchangeAsync(_errorExchangeCfg); var channelTask = _channelFactory.GetChannelAsync(); return(Task .WhenAll(topologyTask, channelTask) .ContinueWith(t => { var msg = _serializer.Deserialize(args); var errorMsg = new HandlerExceptionMessage { Exception = exception, Time = DateTime.Now, Host = Environment.MachineName, Message = msg, }; channelTask.Result.BasicPublish( exchange: _errorExchangeCfg.ExchangeName, routingKey: args.RoutingKey, basicProperties: args.BasicProperties, body: _serializer.Serialize(errorMsg) ); channelTask.Result.Close(); })); } catch (Exception e) { _logger.LogWarning($"Unable to publish message '{args.BasicProperties.MessageId}' to default error exchange.", e); return(Task.FromResult(true)); } }
/// <summary> /// Gets the subscription configuration. /// </summary> /// <param name="subscriptionId">The subscription identifier.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns></returns> public async Task <SubscriptionConfiguration> GetSubscriptionConfiguration(Guid subscriptionId, CancellationToken cancellationToken) { SubscriptionConfiguration result = new SubscriptionConfiguration(); using (SubscriptionServiceConfigurationContext context = this.ContextResolver()) { Database.Models.SubscriptionConfiguration subscriptionConfiguration = await context.SubscriptionConfigurations.Where(s => s.SubscriptionId == subscriptionId).SingleOrDefaultAsync(cancellationToken); result = new SubscriptionConfiguration { EventStoreServerId = subscriptionConfiguration.EventStoreServerId, EndPointUri = subscriptionConfiguration.EndPointUri, GroupName = subscriptionConfiguration.GroupName, StreamName = subscriptionConfiguration.StreamName, StreamPositionToRestartFrom = subscriptionConfiguration.StreamPosition, SubscriptionId = subscriptionConfiguration.SubscriptionId }; } return(result); }
internal override Task<AggregateConsumingResult> ConsumeAsync(SubscriptionConfiguration configuration) { return Task.FromResult(_result(this)); }
internal override Task<AggregateConsumingResult> ConsumeAsync(SubscriptionConfiguration configuration) { return Task.WhenAll(configuration.FindSubscriptions(this) .Select(_ => new OuterConsumer(_).ConsumeAsync(this))) .ContinueWith(_ => AggregateResult(_, this, configuration.FallbackStrategy)); }
internal AtLeastOnceConsumer(IModel model, IConsumedMessageBuilder builder, SubscriptionConfiguration configuration) : base(model, builder, configuration) { }
internal override Task<AggregateConsumingResult> ConsumeAsync(SubscriptionConfiguration configuration) { return Task.FromResult<AggregateConsumingResult>(Result(configuration.FallbackStrategy)); }