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