Example #1
0
        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);
        }
Example #3
0
        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)));
        }
Example #4
0
        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);
        }
Example #6
0
        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;
 }
Example #10
0
 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());
 }
Example #11
0
 protected ConsumerBase(IModel model,
                        IConsumedMessageBuilder builder,
                        SubscriptionConfiguration configuration)
     : base(model)
 {
     Builder = builder;
     Configuration = configuration;
 }
Example #12
0
        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);
        }
Example #16
0
        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);
        }
Example #18
0
        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);
        }
Example #22
0
 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);
 }
Example #24
0
        /// <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);
        }
Example #27
0
 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);
 }
Example #28
0
        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));
        }
Example #29
0
 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;
 }
Example #30
0
        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");
        }
Example #32
0
        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();
        }
Example #34
0
        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);
        }
Example #35
0
        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));
            }
        }
Example #36
0
        /// <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);
        }
Example #37
0
 internal override Task<AggregateConsumingResult> ConsumeAsync(SubscriptionConfiguration configuration)
 {
     return Task.FromResult(_result(this));
 }
Example #38
0
 internal override Task<AggregateConsumingResult> ConsumeAsync(SubscriptionConfiguration configuration)
 {
     return Task.WhenAll(configuration.FindSubscriptions(this)
                                      .Select(_ => new OuterConsumer(_).ConsumeAsync(this)))
                .ContinueWith(_ => AggregateResult(_, this, configuration.FallbackStrategy));
 }
Example #39
0
 internal AtLeastOnceConsumer(IModel model,
                              IConsumedMessageBuilder builder,
                              SubscriptionConfiguration configuration)
     : base(model, builder, configuration)
 {
 }
Example #40
0
 internal override Task<AggregateConsumingResult> ConsumeAsync(SubscriptionConfiguration configuration)
 {
     return Task.FromResult<AggregateConsumingResult>(Result(configuration.FallbackStrategy));
 }