public DefaultEventService( IJsonSerializer jsonSerializer, IScheduleService scheduleService, ITypeNameProvider typeNameProvider, IMemoryCache memoryCache, IAggregateRootFactory aggregateRootFactory, IAggregateStorage aggregateStorage, IEventStore eventStore, IMessagePublisher<DomainEventStreamMessage> domainEventPublisher, IOHelper ioHelper, ILoggerFactory loggerFactory) { _eventMailboxDict = new ConcurrentDictionary<string, EventMailBox>(); _ioHelper = ioHelper; _jsonSerializer = jsonSerializer; _scheduleService = scheduleService; _typeNameProvider = typeNameProvider; _memoryCache = memoryCache; _aggregateRootFactory = aggregateRootFactory; _aggregateStorage = aggregateStorage; _eventStore = eventStore; _domainEventPublisher = domainEventPublisher; _logger = loggerFactory.Create(GetType().FullName); _batchSize = ENodeConfiguration.Instance.Setting.EventMailBoxPersistenceMaxBatchSize; }
public AdminController(IFileStorage fileStorage, IMessagePublisher messagePublisher, IOrganizationRepository organizationRepository, IQueue<EventPost> eventPostQueue, IQueue<WorkItemData> workItemQueue) { _fileStorage = fileStorage; _messagePublisher = messagePublisher; _organizationRepository = organizationRepository; _eventPostQueue = eventPostQueue; _workItemQueue = workItemQueue; }
public DataOperations(ILogger logger, IMessagePublisher publisher, IRepository<SampleEntity, string> sampleRepository, IEnvironment environment) { _logger = logger; _publisher = publisher; _sampleEntityRepository = sampleRepository; _environment = environment; }
public OrderController() { _publisher = JustSaying.CreateMeABus.InRegion("eu-west-1") .ConfigurePublisherWith(conf => conf.PublishFailureReAttempts = 1) .WithSnsMessagePublisher<PlaceOrder>(Constants.OrderProcessingTopic); }
public ContentFinderJob(string contentPattern, IContentProvider contentProvider, IMessagePublisher messagePublisher) { _contentPattern = contentPattern; _contentProvider = contentProvider; _messagePublisher = messagePublisher; if (string.IsNullOrWhiteSpace(contentPattern)) throw new ArgumentNullException(nameof(contentPattern)); if (contentProvider == null) throw new ArgumentNullException(nameof(contentProvider)); if (messagePublisher == null) throw new ArgumentNullException(nameof(messagePublisher)); }
public CommandConsumer(IHandlerProvider handlerProvider, IMessagePublisher messagePublisher, string commandQueueName) { _commandQueueName = commandQueueName; _handlerProvider = handlerProvider; _messagePublisher = messagePublisher; _messageQueueClient = IoCFactory.Resolve<IMessageQueueClient>(); _logger = IoCFactory.Resolve<ILoggerFactory>().Create(this.GetType()); }
public PublishingViewModel(ISettings settings, IMessagePublisher publisher, IUserInteraction interaction) { _settings = settings; _publisher = publisher; _interaction = interaction; PublishDate = DateTime.Today; Time = DateTime.UtcNow.ToShortTimeString(); LoadStoredServers(); _publisher.Publish(new QueryPotentialTitleUiMsg(pt => Title = pt)); }
public AssignToStackAction(IStackRepository stackRepository, FormattingPluginManager formattingPluginManager, IMessagePublisher publisher) { if (stackRepository == null) throw new ArgumentNullException("stackRepository"); if (formattingPluginManager == null) throw new ArgumentNullException("formattingPluginManager"); _stackRepository = stackRepository; _formattingPluginManager = formattingPluginManager; _publisher = publisher; }
public WorkloadQueueMonitor(string instanceId, IMessageReceiver messageReceiver, IMessagePublisher statusPublisher, int httpWorkerCount) : base(instanceId, messageReceiver) { if(statusPublisher == null) throw new ArgumentNullException("statusPublisher"); _batchQueue = new ConcurrentQueue<WorkloadBatchMessage>(); _httpWorkerCount = httpWorkerCount; _statusPublisher = statusPublisher; }
public AssignToStackAction(IStackRepository stackRepository, FormattingPluginManager formattingPluginManager, IMessagePublisher publisher, ILoggerFactory loggerFactory = null) : base(loggerFactory) { if (stackRepository == null) throw new ArgumentNullException(nameof(stackRepository)); if (formattingPluginManager == null) throw new ArgumentNullException(nameof(formattingPluginManager)); _stackRepository = stackRepository; _formattingPluginManager = formattingPluginManager; _publisher = publisher; }
public StatusController(ICacheClient cacheClient, IMessagePublisher messagePublisher, SystemHealthChecker healthChecker, IQueue<EventPost> eventQueue, IQueue<MailMessage> mailQueue, IQueue<EventNotificationWorkItem> notificationQueue, IQueue<WebHookNotification> webHooksQueue, IQueue<EventUserDescription> userDescriptionQueue, IMetricsClient metricsClient) { _cacheClient = cacheClient; _messagePublisher = messagePublisher; _healthChecker = healthChecker; _eventQueue = eventQueue; _mailQueue = mailQueue; _notificationQueue = notificationQueue; _webHooksQueue = webHooksQueue; _userDescriptionQueue = userDescriptionQueue; _metricsClient = metricsClient; }
public TradeGeneratorJob(IMessagePublisher<Trade> publisher, ITradeGenerator tradeGenerator, Lazy<ITradesCache> tradeService, ISchedulerProvider schedulerProvider, ILogger logger) { _publisher = publisher; _tradeGenerator = tradeGenerator; _tradeService = tradeService; _schedulerProvider = schedulerProvider; _logger = logger; _runner = GenerateTradesAndMaintainCache(); }
static WebApiApplication() { try { Configuration.Instance.UseLog4Net(); _Logger = IoCFactory.Resolve<ILoggerFactory>().Create(typeof(WebApiApplication)); Configuration.Instance .CommandHandlerProviderBuild(null, "CommandHandlers") .RegisterDisposeModule() .RegisterMvc(); #region EventPublisher init _MessagePublisher = IoCFactory.Resolve<IMessagePublisher>(); _MessagePublisher.Start(); #endregion #region event subscriber init _DomainEventConsumer = IoCFactory.Resolve<IMessageConsumer>("DomainEventSubscriber"); _DomainEventConsumer.Start(); #endregion #region application event subscriber init _ApplicationEventConsumer = IoCFactory.Resolve<IMessageConsumer>("ApplicationEventConsumer"); _ApplicationEventConsumer.Start(); #endregion #region CommandBus init _CommandBus = IoCFactory.Resolve<ICommandBus>(); _CommandBus.Start(); #endregion #region Command Consuemrs init var commandHandlerProvider = IoCFactory.Resolve<ICommandHandlerProvider>(); _CommandConsumer1 = new CommandConsumer(commandHandlerProvider, _MessagePublisher, "commandqueue1"); _CommandConsumer2 = new CommandConsumer(commandHandlerProvider, _MessagePublisher, "commandqueue2"); _CommandConsumer3 = new CommandConsumer(commandHandlerProvider, _MessagePublisher, "commandqueue3"); _CommandConsumer1.Start(); _CommandConsumer2.Start(); _CommandConsumer3.Start(); #endregion } catch (Exception ex) { _Logger.Error(ex.GetBaseException().Message, ex); } }
public EventSubscriber(IMessageQueueClient messageQueueClient, IHandlerProvider handlerProvider, ICommandBus commandBus, IMessagePublisher messagePublisher, string subscriptionName, params string[] topics) { _MessageQueueClient = messageQueueClient; _handlerProvider = handlerProvider; _topics = topics; _subscriptionName = subscriptionName; _messagePublisher = messagePublisher; _commandBus = commandBus; _logger = IoCFactory.Resolve<ILoggerFactory>().Create(this.GetType()); }
public void Setup() { receivedMessages = new List<IServerToClientMessage>(); loggerMock = MockRepository.GenerateMock<ILogger>(); serverPublihser = new MessagePublisher(loggerMock, new ProtobufSerializer()); clientSubscriber = new ServerMessageSubscriber(loggerMock, new ProtobufSerializer()); var port = TcpHelper.AvailableTcpPort(); serverPublihser.Start(port); Thread.Sleep(100); clientSubscriber.Start("localhost", port, 1, receivedMessages.Add); Thread.Sleep(100); }
public Publisher(KwwikaTweetStreamerPublisherConfig config) { KwwikaTweetStreamerPublisherConfig.CheckConfiguration(config); _logger = new LoggerWrapper(); _config = config; string twitterParams = BuildTwitterParams(config.SearchDefinitions); _connection = new TweetStreamer.Connection(config.TwitterConfig.Username, config.TwitterConfig.Password, config.TwitterConfig.Url, twitterParams, "POST", _logger); _connection.ConnectionStatusChanged += new TweetStreamer.Connection.OnConnectionStatusChangedEventHandler(connection_ConnectionStatusChanged); _connection.StatusMessageReceived += new TweetStreamer.Connection.OnStatusMessageReceivedEventHandler(connection_StatusMessageReceived); _messagePublisher = new MessagePublisherProxy(_logger, config); }
public DefaultAgentBroker(IMessagePublisher messagePublisher, IMessageConverter messageConverter, IContextData<MessageContext> context) { _messagePublisher = messagePublisher; _messageConverter = messageConverter; _context = context; _onSenderThreadSubject = new Subject<AgentBrokerPayload>(); _offSenderThreadSubject = new Subject<AgentBrokerPayload>(); _offSenderThreadInternalSubject = new Subject<AgentBrokerPayload>(); _publisherInternalSubject = new Subject<AgentBrokerPayload>(); OnSenderThread = new AgentBrokerObservations(_onSenderThreadSubject); OffSenderThread = new AgentBrokerObservations(_offSenderThreadSubject); // ensure off-request data is observed onto a different thread _offSenderThreadInternalSubject.Subscribe(payload => Observable.Start(() => _offSenderThreadSubject.OnNext(payload), TaskPoolScheduler.Default)); _publisherInternalSubject.Subscribe(x => Observable.Start(() => PublishMessage(x), TaskPoolScheduler.Default)); }
private static void InitializeENode( bool useMockCommandStore = false, bool useMockEventStore = false, bool useMockPublishedVersionStore = false, bool useMockDomainEventPublisher = false, bool useMockApplicationMessagePublisher = false, bool useMockPublishableExceptionPublisher = false) { var setting = new ConfigurationSetting(ConfigurationManager.AppSettings["connectionString"]); var assemblies = new[] { Assembly.GetExecutingAssembly() }; _enodeConfiguration = ECommonConfiguration .Create() .UseAutofac() .RegisterCommonComponents() .UseLog4Net() .UseJsonNet() .RegisterUnhandledExceptionHandler() .CreateENode(setting) .RegisterENodeComponents() .UseCommandStore(useMockCommandStore) .UseEventStore(useMockEventStore) .UsePublishedVersionStore(useMockPublishedVersionStore) .RegisterBusinessComponents(assemblies) .InitializeBusinessAssemblies(assemblies) .UseEQueue(useMockDomainEventPublisher, useMockApplicationMessagePublisher, useMockPublishableExceptionPublisher) .StartEQueue(); _commandService = ObjectContainer.Resolve<ICommandService>(); _memoryCache = ObjectContainer.Resolve<IMemoryCache>(); _commandStore = ObjectContainer.Resolve<ICommandStore>(); _eventStore = ObjectContainer.Resolve<IEventStore>(); _publishedVersionStore = ObjectContainer.Resolve<IPublishedVersionStore>(); _domainEventPublisher = ObjectContainer.Resolve<IMessagePublisher<DomainEventStreamMessage>>(); _applicationMessagePublisher = ObjectContainer.Resolve<IMessagePublisher<IApplicationMessage>>(); _publishableExceptionPublisher = ObjectContainer.Resolve<IMessagePublisher<IPublishableException>>(); _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(typeof(BaseTest)); _logger.Info("ENode initialized."); }
public void SetUp() { A.Fake<IConnectionFactory>(); _connection = A.Fake<IConnection>(); _lazyConnection = new Lazy<IConnection>(() => { _connection.Start(); return _connection; }); _session = A.Fake<ISession>(); _producer = A.Fake<IMessageProducer>(); _serializer = A.Fake<IMessageSerializer>(); _destination = A.Fake<IDestination>(); _message = A.Fake<IBytesMessage>(); _messagePropertyProvider = A.Fake<IMessagePropertyProvider<IMessage>>(); A.CallTo(() => _connection.CreateSession(A<Apache.NMS.AcknowledgementMode>.Ignored)).Returns(_session); A.CallTo(() => _session.CreateProducer(_destination)).Returns(_producer); A.CallTo(() => _producer.CreateBytesMessage()).Returns(_message); _publisher = new MessagePublisher<IMessage>(_lazyConnection, _destination, _serializer, _messagePropertyProvider, _testScheduler); }
public DefaultEventService( IJsonSerializer jsonSerializer, IScheduleService scheduleService, ITypeNameProvider typeNameProvider, IMemoryCache memoryCache, IAggregateRootFactory aggregateRootFactory, IAggregateStorage aggregateStorage, IEventStore eventStore, IMessagePublisher<DomainEventStreamMessage> domainEventPublisher, IOHelper ioHelper, ILoggerFactory loggerFactory) { var setting = ENodeConfiguration.Instance.Setting; _enableGroupCommit = setting.EnableGroupCommitEvent; _groupCommitInterval = setting.GroupCommitEventIntervalMilliseconds; _groupCommitMaxSize = setting.GroupCommitMaxSize; _ioHelper = ioHelper; Ensure.Positive(_groupCommitInterval, "_groupCommitInterval"); Ensure.Positive(_groupCommitMaxSize, "_groupCommitMaxSize"); _toCommitContextQueue = new ConcurrentQueue<EventCommittingContext>(); _successPersistedContextQueue = new BlockingCollection<IEnumerable<EventCommittingContext>>(); _failedPersistedContextQueue = new BlockingCollection<IEnumerable<EventCommittingContext>>(); _jsonSerializer = jsonSerializer; _scheduleService = scheduleService; _typeNameProvider = typeNameProvider; _memoryCache = memoryCache; _aggregateRootFactory = aggregateRootFactory; _aggregateStorage = aggregateStorage; _eventStore = eventStore; _domainEventPublisher = domainEventPublisher; _logger = loggerFactory.Create(GetType().FullName); _processSuccessPersistedEventsWorker = new Worker("ProcessSuccessPersistedEvents", ProcessSuccessPersistedEvents); _processFailedPersistedEventsWorker = new Worker("ProcessFailedPersistedEvents", ProcessFailedPersistedEvents); Start(); }
public DefaultEventService( IJsonSerializer jsonSerializer, IScheduleService scheduleService, ITypeNameProvider typeNameProvider, IMemoryCache memoryCache, IAggregateRootFactory aggregateRootFactory, IAggregateStorage aggregateStorage, IEventStore eventStore, IMessagePublisher<DomainEventStreamMessage> domainEventPublisher, IOHelper ioHelper, ILoggerFactory loggerFactory) { _ioHelper = ioHelper; _jsonSerializer = jsonSerializer; _scheduleService = scheduleService; _typeNameProvider = typeNameProvider; _memoryCache = memoryCache; _aggregateRootFactory = aggregateRootFactory; _aggregateStorage = aggregateStorage; _eventStore = eventStore; _domainEventPublisher = domainEventPublisher; _logger = loggerFactory.Create(GetType().FullName); }
public static Task PublishAsync(this IMessagePublisher publisher, Func <MqttMessageBuilder, MqttMessageBuilder> builder) { var message = builder(new MqttMessageBuilder()).Build(); return(publisher.PublishAsync(message)); }
public StackRepository(IElasticClient elasticClient, IEventRepository eventRepository, IValidator <Stack> validator = null, ICacheClient cacheClient = null, IMessagePublisher messagePublisher = null) : base(elasticClient, validator, cacheClient, messagePublisher) { _eventRepository = eventRepository; }
public PublishEdiAsnSentSpecification(IMessagePublisher serviceBus) { _publisher = serviceBus; }
public MessagePublisher(IMessagePublisher messagePublisher, string topic) { _messagePublisher = messagePublisher; _topic = topic; }
public InMemoryEventBus(IMessagePublisher messageProcessor) { this.messageProcessor = messageProcessor; eventQueueDict = new ConcurrentDictionary <string, ConcurrentQueue <Event> >(); taskDict = new ConcurrentDictionary <string, Task>(); }
protected override void Given() { base.Given(); _publisher = Substitute.For <IMessagePublisher>(); }
public TopicController(IMessagePublisher messagePublisher) { this.messagePublisher = messagePublisher; }
protected override void Given() { base.Given(); _publisher = Substitute.For <IMessagePublisher>(); RecordAnyExceptionsThrown(); }
public BlobMessagePublisher(IMessagePublisher messagePublisher, IBlobContainer blobContainer, int maxMessageSize) : base(messagePublisher) { _blobContainer = blobContainer; _maxMessageSize = maxMessageSize; }
public WorkshopPlanningController(IWorkshopPlanningRepository planningRepo, IMessagePublisher messagePublisher) { _planningRepo = planningRepo; _messagePublisher = messagePublisher; }
public SentTransferConnectionRequestEventHandler(IMessagePublisher messagePublisher) { _messagePublisher = messagePublisher; }
public CustomerController(ICustomerService customerService, IMapper mapper, IConfiguration configuration, IMessagePublisher rabbitMQPublisher) { _customerService = customerService; _mapper = mapper; _configuration = configuration; _rabbitMQPublisher = rabbitMQPublisher; }
protected ElasticSearchRepository(IElasticClient elasticClient, IValidator <T> validator = null, ICacheClient cacheClient = null, IMessagePublisher messagePublisher = null) : base(elasticClient, cacheClient) { _validator = validator; _messagePublisher = messagePublisher; }
/// <summary> /// Compresses the published messages using GZip (requires GZip compression on the receiver). /// </summary> /// <param name="messagePublisher">The message receiver.</param> /// <param name="compressionLevel">The compression level.</param> /// <returns>The wrapped message receiver.</returns> public static IMessagePublisher WithGZipCompression(this IMessagePublisher messagePublisher, CompressionLevel compressionLevel) { return(new GZipMessagePublisher <object>(messagePublisher, compressionLevel)); }
public void Setup() { var publishPort = TcpHelper.AvailableTcpPort(); loggerMock = MockRepository.GenerateMock<ILogger>(); // Server messagePublisher = new MessagePublisher(loggerMock, new ProtobufSerializer()); messagePublisher.Start(publishPort); // Client clientMessageConnectionMock = MockRepository.GenerateMock<IMessageConnection>(); clientMessageSubscriber = new ServerMessageSubscriber(loggerMock, new ProtobufSerializer()); client= new ClientApi.Client(clientMessageConnectionMock, clientMessageSubscriber); client.Start(88, "localhost", 9090, publishPort); Thread.Sleep(100); }
public MongoRepositoryOwnedByStack(MongoDatabase database, ICacheClient cacheClient = null, IMessagePublisher messagePublisher = null) : base(database, cacheClient, messagePublisher) { }
public ImportCustomContractViewModel( IMessagePublisher messagePublisher) { this.messagePublisher = messagePublisher; }
private void InitializeENode( bool useMockEventStore = false, bool useMockPublishedVersionStore = false, bool useMockDomainEventPublisher = false, bool useMockApplicationMessagePublisher = false, bool useMockDomainExceptionPublisher = false) { var connectionString = ConfigurationManager.AppSettings["connectionString"]; var assemblies = new[] { Assembly.GetExecutingAssembly() }; if (_serilogLoggerFactory == null) { _serilogLoggerFactory = new SerilogLoggerFactory(defaultLoggerFileName: "logs\\default") .AddFileLogger("ECommon", "logs\\ecommon") .AddFileLogger("EQueue", "logs\\equeue") .AddFileLogger("ENode", "logs\\enode"); } var configurationSetting = new ConfigurationSetting { ProcessTryToRefreshAggregateIntervalMilliseconds = 1000 }; _enodeConfiguration = ECommonConfiguration .Create() .UseAutofac() .RegisterCommonComponents() .UseSerilog(_serilogLoggerFactory) .UseJsonNet() .RegisterUnhandledExceptionHandler() .CreateENode(configurationSetting) .RegisterENodeComponents() .UseEventStore(useMockEventStore) .UsePublishedVersionStore(useMockPublishedVersionStore) .RegisterBusinessComponents(assemblies) .InitializeEQueue() .UseEQueue(useMockDomainEventPublisher, useMockApplicationMessagePublisher, useMockDomainExceptionPublisher) .BuildContainer(); if (!useMockEventStore) { _enodeConfiguration.InitializeSqlServerEventStore(connectionString); } if (!useMockPublishedVersionStore) { _enodeConfiguration.InitializeSqlServerPublishedVersionStore(connectionString); } _enodeConfiguration .InitializeBusinessAssemblies(assemblies) .StartEQueue() .Start(); _commandService = ObjectContainer.Resolve <ICommandService>(); _memoryCache = ObjectContainer.Resolve <IMemoryCache>(); _eventStore = ObjectContainer.Resolve <IEventStore>(); _publishedVersionStore = ObjectContainer.Resolve <IPublishedVersionStore>(); _domainEventPublisher = ObjectContainer.Resolve <IMessagePublisher <DomainEventStreamMessage> >(); _applicationMessagePublisher = ObjectContainer.Resolve <IMessagePublisher <IApplicationMessage> >(); _domainExceptionPublisher = ObjectContainer.Resolve <IMessagePublisher <IDomainException> >(); _logger = ObjectContainer.Resolve <ILoggerFactory>().Create(typeof(BaseTest)); _logger.Info("----ENode initialized."); }
public void DeleteQueueWithResponse() { // Create the publisher _publisher = _channel.CreatePublisherBuilder() .WithExchangeName(ExchangeNameDefaults.TOPIC) .WithRoutingKey(_routingKey) .Create(); _logger.Info("Publisher created..."); SendTestMessage("DeleteQueueWithResponse Message 1"); SendTestMessage("DeleteQueueWithResponse Message 2"); // delete the queue, the server must respond _channel.DeleteQueue(_queueName, false, false, false); }
public ConferenceMessagePublisher(IMessagePublisher <IApplicationMessage> messagePublisher) { _messagePublisher = messagePublisher; }
public AppMenuEntries(IMessagePublisher publisher) { _publisher = publisher; }
public Form1(IMessagePublisher publisher) { _publisher = publisher; InitializeComponent(); ClearForm(); }
public MovieService(IMovieRepository movieRepository, IMessagePublisher messagePublisher, TargetClient targetClient) { _movieRepository = movieRepository; _messagePublisher = messagePublisher; this._targetClient = targetClient; }
public void DeleteEmptyQueue() { // Create the publisher _publisher = _channel.CreatePublisherBuilder() .WithExchangeName(ExchangeNameDefaults.TOPIC) .WithRoutingKey(_routingKey) .Create(); _logger.Info("Publisher created..."); // delete an empty queue with ifEmpty = true _channel.DeleteQueue(_queueName, false, true, true); Assert.IsNull(_lastException); }
/// <summary> /// Adds a generic message type to the message publisher. /// </summary> /// <typeparam name="T">The message type.</typeparam> /// <param name="messagePublisher">The message publisher.</param> /// <returns>The wrapped message publisher.</returns> public static IMessagePublisher <T> AsPublisher <T>(this IMessagePublisher messagePublisher) { return(new MessagePublisher <T>(messagePublisher)); }
public void PurgeQueueWithOutResponse() { _publisher = _channel.CreatePublisherBuilder() .WithExchangeName(ExchangeNameDefaults.TOPIC) .WithRoutingKey(_routingKey) .Create(); _logger.Info("Pubisher created"); SendTestMessage("Message 1"); SendTestMessage("Message 2"); _channel.PurgeQueue(_queueName, true); }
public ConsumerContext(IConnection connection, IConsumeInfo consumeInfo, ISerializationStrategy defaultSerializationStrategy, IDeadLetterStrategy deadLetterStrategy, IMessagePublisher messagePublisher) { _consumeInfo = consumeInfo; _defaultSerializationStrategy = defaultSerializationStrategy; _deadLetterStrategy = deadLetterStrategy; _messagePublisher = messagePublisher; _channel = connection.CreateModel(); Logger.Current.Write(string.Format("Declaring exchange:\'{0}\' durable:{1} auto-delete:{2}", consumeInfo.ExchangeName, consumeInfo.IsExchangeDurable.ToString(CultureInfo.InvariantCulture), consumeInfo.IsExchangeAutoDelete.ToString(CultureInfo.InvariantCulture)), TraceEventType.Information); _channel.ExchangeDeclare(consumeInfo.ExchangeName, consumeInfo.ExchangeType, consumeInfo.IsExchangeDurable, consumeInfo.IsExchangeAutoDelete, null); Logger.Current.Write(string.Format("Declaring queue:\'{0}\' durable:{1} auto-delete:{2}", consumeInfo.QueueName, consumeInfo.IsQueueDurable.ToString(CultureInfo.InvariantCulture), consumeInfo.IsQueueAutoDelete.ToString(CultureInfo.InvariantCulture)), TraceEventType.Information); _channel.QueueDeclare(consumeInfo.QueueName, consumeInfo.IsQueueDurable, consumeInfo.Exclusive, consumeInfo.IsQueueAutoDelete, null); Logger.Current.Write(string.Format("Binding queue \'{0}\' to exchange \'{1}\'", consumeInfo.QueueName, consumeInfo.ExchangeName), TraceEventType.Information); _channel.QueueBind(consumeInfo.QueueName, consumeInfo.ExchangeName, consumeInfo.DefaultRoutingKey); }
public PlanMaintenanceJobCommandHandler(IMessagePublisher messagePublisher, IWorkshopPlanningRepository planningRepo) { _messagePublisher = messagePublisher; _planningRepo = planningRepo; }
public ElasticSearchRepositoryOwnedByOrganizationAndProjectAndStack(IElasticClient elasticClient, IValidator <T> validator = null, ICacheClient cacheClient = null, IMessagePublisher messagePublisher = null) : base(elasticClient, validator, cacheClient, messagePublisher) { }
public ApplicationRepository(MongoDatabase database, IValidator <Application> validator = null, ICacheClient cacheClient = null, IMessagePublisher messagePublisher = null) : base(database, validator, cacheClient, messagePublisher) { _getIdValue = s => s; }
/// <summary> /// Compresses the published messages using GZip (requires GZip compression on the receiver). /// </summary> /// <param name="messagePublisher">The message receiver.</param> /// <param name="compressionLevel">The compression level.</param> /// <returns>The wrapped message receiver.</returns> public static IMessagePublisher <T> WithGZipCompression <T>(this IMessagePublisher <T> messagePublisher, CompressionLevel compressionLevel) { return(new GZipMessagePublisher <T>(messagePublisher, compressionLevel)); }
public Logger() { messagePublisher = new ConsolePublisher(); }
/// <summary> /// Adds a generic message type to the message publisher. /// </summary> /// <typeparam name="T">The message type.</typeparam> /// <param name="messagePublisher">The message publisher.</param> /// <returns>The wrapped message publisher.</returns> public static IMessagePublisher AsPublisher(this IMessagePublisher messagePublisher) { return(messagePublisher); }
public NotifySignalRAction(IMessagePublisher publisher) { _publisher = publisher; }
public Logger(IMessagePublisher publisher) { messagePublisher = publisher; }
/// <summary> /// Handles messages of type OrderPlacedEvent /// Takes a dependency on IMessagePublisher so that further messages can be published /// </summary> public OrderPlacedEventHandler(IMessagePublisher publisher, ILogger <OrderPlacedEventHandler> log) { _publisher = publisher; _logger = log; }
public UserRepository(MongoDatabase database, IValidator <User> validator = null, ICacheClient cacheClient = null, IMessagePublisher messagePublisher = null) : base(database, validator, cacheClient, messagePublisher) { }
public AdminController(IOrganizationRepository repository, BillingManager billingManager, IMessagePublisher messagePublisher) { _repository = repository; _billingManager = billingManager; _messagePublisher = messagePublisher; }
public PingerService(IMessagePublisher publisher) { _publisher = publisher; }