public Service(IBus bus, IQueryProcessor processor, ISubscriptionManager manager, IDocumentStore store) { _bus = bus; _processor = processor; _manager = manager; _store = store; }
public EventTestProvider(ISubscriptionManager subscriptionManager) { task = new Task(Loop); task.Start(); this.subscriptionManager = subscriptionManager; }
public QueueSubscriptionFactory( ISubscriptionManager subscriptions, IDispatcher dispatcher, IChannelProxyFactory proxyFactory ) { Subscriptions = subscriptions; Dispatcher = dispatcher; ProxyFactory = proxyFactory; }
public async Task WhenStoreIsEmpty_CanUpdate_And_GetSubscriptions(bool useRealBroker) { // arrange if (!useRealBroker) { // tests the same behavior, even without receiving any broker notifications for the updates this.manager = new SubscriptionManager(this.store, CreateBrokerMock().Object); } await manager.UpdateEndpointSubscriptions( "c1", new[] { new Subscription("t1", "e1", "c1"), new Subscription("t1", "e1", "c2"), new Subscription("t2", "e1", "c2"), }); // act var t1Subscriptions = await manager.GetSubscriptions("t1"); var t2Subscriptions = await manager.GetSubscriptions("t2"); // assert Assert.AreEqual(2, t1Subscriptions.Count()); Assert.AreEqual(1, t2Subscriptions.Count()); }
public void SetUp() { this.subscriptionStore = new LocalSubscriptionStore(); this.subscriptionManager = new SubscriptionManager( this.subscriptionStore, new LocalSubscriptionBroker()); }
public EventSubscriptionController(ISubscriptionManager eventShardedSubscriptionManager) { jsonSerializerSettings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() }; eventShardedSubscriber = eventShardedSubscriptionManager; }
public SubscriptionMessageDispatcher(ILogger logger, ISubscriptionManager subscriptionManager, IBrokeredMessageFactory brokeredMessageFactory, IEndpointNamingPolicy endpointNamingPolicy, MaxConcurrentReceiverCallsSetting maxConcurrentReceiverCallsSetting) { _logger = logger; _brokeredMessageFactory = brokeredMessageFactory; _endpointNamingPolicy = endpointNamingPolicy; _maxConcurrentReceiverCallsSetting = maxConcurrentReceiverCallsSetting; _subscriptionManager = subscriptionManager; }
public BusBootstrapper(IAssemblyScanner assemblyScanner, ZmqTransportConfiguration zmqTransportConfiguration, IBusBootstrapperConfiguration bootstrapperConfiguration, IMessageSender messageSender, IPeerManager peerManager, ISubscriptionManager subscriptionManager, IPeerConfiguration peerConfiguration) { _assemblyScanner = assemblyScanner; _zmqTransportConfiguration = zmqTransportConfiguration; _bootstrapperConfiguration = bootstrapperConfiguration; _messageSender = messageSender; _peerManager = peerManager; _subscriptionManager = subscriptionManager; _peerConfiguration = peerConfiguration; }
public EventSystemFactory(ActorSystem actorSystem, IEnumerable<ISubsytemConfiguration> subsystemConfigurations) { this.actorSystem = actorSystem; shardedSubscriptionManager = new ShardedSubscriptionManager(actorSystem); distributedPubSubEventPublisher = new DistributedPubSubEventPublisher(actorSystem); foreach (var subsytemConfiguration in subsystemConfigurations) { subsytemConfiguration.Configure(actorSystem); } }
public MessageSubscription( ISubscriptionManager manager, Action<IMessage> action, Type actionType) { if (manager == null) throw new ArgumentNullException(nameof(manager)); if (action == null) throw new ArgumentNullException(nameof(action)); Manager = manager; Action = action; ActionType = actionType; }
public RabbitMqEventSubscriber( ISubscriptionManager subscriptionManager, IRabbitMqPersistentConnection persistentConnection, IRabbitConsumerInitializer rabbitConsumerInitializer, IOptions <RabbitMqEventBusOptions> rabbitMqEventBusOptons, ILogger <RabbitMqEventSubscriber> logger) { _subscriptionManager = subscriptionManager; _persistentConnection = persistentConnection; _rabbitConsumerInitializer = rabbitConsumerInitializer; _logger = logger; _rabbitMqEventBusOptions = rabbitMqEventBusOptons.Value; }
public DefaultMessageHandlerInvoker(IComponentResolver resolver, IPipelineFactory pipelineFactory, ISubscriptionManager subscriptionManager, ITransportMessageFactory transportMessageFactory) { Guard.AgainstNull(resolver, nameof(resolver)); Guard.AgainstNull(pipelineFactory, nameof(pipelineFactory)); Guard.AgainstNull(subscriptionManager, nameof(subscriptionManager)); Guard.AgainstNull(transportMessageFactory, nameof(transportMessageFactory)); _resolver = resolver; _pipelineFactory = pipelineFactory; _subscriptionManager = subscriptionManager; _transportMessageFactory = transportMessageFactory; }
private void SetNotifyBySubsriptionTypes(IList <string> notifyByList, ISubscriptionManager subscriptionManager) { var subscriptionTypes = subscriptionManager.GetSubscriptionTypes(); if (subscriptionTypes != null) { foreach (var type in subscriptionTypes) { SetNotifyBySubsriptionTypes(notifyByList, subscriptionManager, type.NotifyAction); } } }
public SocketOperationStreamExecutor( Func <CancellationToken, Task <ISocketConnection> > connectionFactory, ISubscriptionManager subscriptionManager, IResultParserResolver resultParserResolver) { _connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory)); _subscriptionManager = subscriptionManager ?? throw new ArgumentNullException(nameof(subscriptionManager)); _resultParserResolver = resultParserResolver ?? throw new ArgumentNullException(nameof(resultParserResolver)); }
public ServiceBus(IServiceBusConfiguration configuration, ITransportMessageFactory transportMessageFactory, IPipelineFactory pipelineFactory, ISubscriptionManager subscriptionManager) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(transportMessageFactory, nameof(transportMessageFactory)); Guard.AgainstNull(pipelineFactory, nameof(pipelineFactory)); Guard.AgainstNull(subscriptionManager, nameof(subscriptionManager)); _configuration = configuration; _pipelineFactory = pipelineFactory; _messageSender = new MessageSender(transportMessageFactory, _pipelineFactory, subscriptionManager); }
public AddSubscriptionCommand( IMessageBoxDisplayService messageBoxDisplayService, INewSubscriptionService newSubscriptionService, IPodcastLoader podcastLoader, ISubscriptionManager subscriptionManager) { this.messageBoxDisplayService = messageBoxDisplayService; this.newSubscriptionService = newSubscriptionService; this.podcastLoader = podcastLoader; this.subscriptionManager = subscriptionManager; Icon = IconResources.add_icon_32; ToolTip = "Add Subscription"; }
public MessageSender(ITransportMessageFactory transportMessageFactory, IPipelineFactory pipelineFactory, ISubscriptionManager subscriptionManager, TransportMessage transportMessageReceived) { Guard.AgainstNull(transportMessageFactory, "transportMessageFactory"); Guard.AgainstNull(pipelineFactory, "pipelineFactory"); Guard.AgainstNull(subscriptionManager, "subscriptionManager"); _transportMessageFactory = transportMessageFactory; _pipelineFactory = pipelineFactory; _subscriptionManager = subscriptionManager; _transportMessageReceived = transportMessageReceived; _log = Log.For(this); }
// Token: 0x060005C5 RID: 1477 RVA: 0x00022969 File Offset: 0x00020B69 public EnhancedNodeStatusCalculationSubscriber(ISubscriptionManager subscriptionManager, ISqlHelper sqlHelper) { if (subscriptionManager == null) { throw new ArgumentNullException("subscriptionManager"); } this.subscriptionManager = subscriptionManager; if (sqlHelper == null) { throw new ArgumentNullException("sqlHelper"); } this.sqlHelper = sqlHelper; }
public Manager( ISettings settings, ISubscriptionManager subscriptionManager, ILog log, IReportManager reportManager, IReportingServiceProxy reportingServiceProxy) { _reportManager = reportManager; _settings = settings; _subscriptionManager = subscriptionManager; _log = log; _reportingServiceProxy = reportingServiceProxy; }
/// <summary> /// Create trigger from writer group /// </summary> /// <param name="writerGroupConfig"></param> /// <param name="subscriptionManager"></param> /// <param name="logger"></param> public WriterGroupMessageTrigger(IWriterGroupConfig writerGroupConfig, ISubscriptionManager subscriptionManager, ILogger logger) { _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _subscriptionManager = subscriptionManager ?? throw new ArgumentNullException(nameof(subscriptionManager)); _writerGroup = writerGroupConfig?.WriterGroup?.Clone() ?? throw new ArgumentNullException(nameof(writerGroupConfig.WriterGroup)); _subscriptions = _writerGroup.DataSetWriters? .Select(g => new DataSetWriterSubscription(this, g)) .ToList(); _publisherId = writerGroupConfig.PublisherId ?? Guid.NewGuid().ToString(); }
public IndexModel( IEmailSender emailSender, UserManager <User> userManager, ILogger <IndexModel> logger, ISubscriptionManager subscriptionManager, SignInManager <User> signInManager) { _emailSender = emailSender; _userManager = userManager; _logger = logger; _subscriptionManager = subscriptionManager; _signInManager = signInManager; }
// Token: 0x060005E0 RID: 1504 RVA: 0x00023334 File Offset: 0x00021534 public RollupModeChangedSubscriber(ISubscriptionManager subscriptionManager, ISqlHelper sqlHelper) { if (subscriptionManager == null) { throw new ArgumentNullException("subscriptionManager"); } this.subscriptionManager = subscriptionManager; if (sqlHelper == null) { throw new ArgumentNullException("sqlHelper"); } this.sqlHelper = sqlHelper; }
/// <summary> /// Default constructor for GreatEagle /// </summary> /// <param name="memberName">Observing tribe member name </param> /// <param name="subscriptionManager"></param> /// <param name="serializer"></param> /// <param name="localCacheProvider"></param> /// <param name="remoteCacheProvider"></param> /// <param name="logger"></param> public GreatEagle(string memberName, ISubscriptionManager subscriptionManager, ISerializer serializer, ILocalCacheProvider localCacheProvider, IRemoteCacheProvider remoteCacheProvider, ILogger logger) { _memberName = memberName; _subscriptionManager = subscriptionManager; _logger = logger; _serializer = serializer; _localCacheProvider = localCacheProvider; _remoteCacheProvider = remoteCacheProvider; _subscriptionManager.OnMessageReceived += MessageSubscriberMessageReceived; StartObserving(); LoadFromRemote(); }
private static SubscriptionManager GuardedSubscriptionManager(ISubscriptionManager subscriptionManager) { Guard.AgainstNull(subscriptionManager, nameof(subscriptionManager)); var result = subscriptionManager as SubscriptionManager; if (result == null) { throw new InvalidOperationException(string.Format(Resources.SubscriptionManagerCastException, subscriptionManager.GetType().FullName)); } return(result); }
public RabbitMQEventBus(IRabbitMQConnection connection, ILogger <RabbitMQEventBus> logger, ILifetimeScope autofac, ISubscriptionManager subsManager, string broker, string queueName = null, int retryCount = 5) { _connection = connection ?? throw new ArgumentNullException(nameof(connection)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _subsManager = subsManager ?? new DefaultSubscriptionManager(); _broker = broker; _queueName = queueName; _channel = CreateConsumerChannel(); _autofac = autofac; _retryCount = retryCount; _subsManager.OnEventRemoved += SubsManager_OnEventRemoved; }
public QueryService(ISubscriptionManager subscriptionManager, IEventQuery <XDocument> eventQuery) { if (subscriptionManager == null) { throw new ArgumentNullException("subscriptionManager"); } if (eventQuery == null) { throw new ArgumentNullException("eventQuery"); } _subscriptionManager = subscriptionManager; _eventQuery = eventQuery; }
public ServiceBus(IServiceBusConfiguration configuration, ITransportMessageFactory transportMessageFactory, IPipelineFactory pipelineFactory, ISubscriptionManager subscriptionManager, ICancellationTokenSource cancellationTokenSource) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(transportMessageFactory, nameof(transportMessageFactory)); Guard.AgainstNull(pipelineFactory, nameof(pipelineFactory)); Guard.AgainstNull(subscriptionManager, nameof(subscriptionManager)); _configuration = configuration; _pipelineFactory = pipelineFactory; _cancellationTokenSource = cancellationTokenSource ?? new DefaultCancellationTokenSource(); _messageSender = new MessageSender(transportMessageFactory, _pipelineFactory, subscriptionManager); }
public HandlerContext(ITransportMessageFactory transportMessageFactory, IPipelineFactory pipelineFactory, ISubscriptionManager subscriptionManager, TransportMessage transportMessage, T message, CancellationToken cancellationToken) { Guard.AgainstNull(transportMessage, nameof(transportMessage)); Guard.AgainstNull(message, nameof(message)); _messageSender = new MessageSender(transportMessageFactory, pipelineFactory, subscriptionManager, transportMessage); TransportMessage = transportMessage; Message = message; CancellationToken = cancellationToken; }
public static bool IsUserSubscriptionActive( this UserManager <IdentityUser> userManager, ClaimsPrincipal pageUser, ISubscriptionManager subscriptionManager) { if (pageUser.Identity.Name == null) { return(false); } var subscription = subscriptionManager.GetSubscriptionAsync(pageUser.Identity.Name).Result; return(subscription.State == SubscriptionState.Complete); }
public BusClientBase(ILifetimeScope lifeTimeScope, ISubscriptionManager subscriptionManager, ILogger <TClient> logger, string exchangeName) { this.lifetimeScope = lifeTimeScope; this.subsManager = subscriptionManager; this.logger = logger; if (string.IsNullOrWhiteSpace(exchangeName)) { exchangeName = "MessageBus"; } AutofacScopeName = exchangeName; BrokerName = exchangeName; }
public EventBusRabbitMQ(IRabbitMQPersistentConnection persistentConnection, ILogger <EventBusRabbitMQ> logger, ILifetimeScope autofac, ISubscriptionManager subsManager, string queueName = null, int retryCount = 5, string xchangeSuffix = "", string xchangeType = "direct") { _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _xchangeType = xchangeType; RABITMQ_EXCHANGE += xchangeSuffix; _persistentConnection = persistentConnection ?? throw new ArgumentNullException(nameof(persistentConnection)); _subsManager = subsManager ?? new SubscriptionManager(); _queueName = queueName; _consumerChannel = CreateConsumerChannel(); _autofac = autofac; _retryCount = retryCount; }
public WebSocketConnection( WebSocket socket, string connectionId, ISubscriptionManager subscriptionManager, IEnumerable <IOperationMessageListener> messageListeners, ILoggerFactory loggerFactory) { ConnectionId = connectionId; _socket = socket; _subscriptionManager = subscriptionManager; _messageListeners = messageListeners; _loggerFactory = loggerFactory; _logger = loggerFactory.CreateLogger <WebSocketConnection>(); }
public LearningTransportMessagePump(string id, string basePath, Action <string, Exception, CancellationToken> criticalErrorAction, ISubscriptionManager subscriptionManager, ReceiveSettings receiveSettings, TransportTransactionMode transactionMode) { Id = id; this.basePath = basePath; this.criticalErrorAction = criticalErrorAction; Subscriptions = subscriptionManager; this.receiveSettings = receiveSettings; this.transactionMode = transactionMode; }
private void btnInit_Click(object sender, EventArgs e) { var url = comboBox2.Text; var str = (string)comboBox1.SelectedItem; Task.Run(() => { reptile = Reptile.Instance(); Console.WriteLine("Init WorkManager"); workManager = new IbcWorkManager(); workManager.Init(); var id = Convert.ToInt32(str.Substring(4)); reptile.Init(workManager, dicServerLine[id].ServerIP, dicServerLine[id].ServerPort); reptile.Start(); subsManager = IocUnity.GetService <ISubscriptionManager>("SubscriptionManager"); matchManager = IocUnity.GetService <IMatchEntityManager>("MatchEntityManager"); if (string.IsNullOrEmpty(user) || string.IsNullOrEmpty(passWord)) { Console.WriteLine("Has no user or passWord"); return; } var loginParam = new LoginParam() { Username = user, Password = passWord, WebUrl = url, TakeMode = TakeMode.Pull }; subsManager.Subscribe(loginParam); var ibcSyncTimeParam = new NormalParam() { Stage = (int)MatchStageEnum.Live, TakeMode = TakeMode.Push, SubscribeType = "time", TimeParam = new SyncTimeParam() { id = "c1", rev = 0, condition = CommonTools.ToUnixTimeSpan(DateTime.Now) + "" } }; subsManager.Subscribe(ibcSyncTimeParam); }); }
public MessageReceiver(SqlServerTransport transport, ReceiveSettings receiveSettings, HostSettings hostSettings, Func <TransportTransactionMode, ProcessStrategy> processStrategyFactory, Func <string, TableBasedQueue> queueFactory, IPurgeQueues queuePurger, IExpiredMessagesPurger expiredMessagesPurger, IPeekMessagesInQueue queuePeeker, QueuePeekerOptions queuePeekerOptions, SchemaInspector schemaInspector, TimeSpan waitTimeCircuitBreaker, ISubscriptionManager subscriptionManager) { this.transport = transport; this.receiveSettings = receiveSettings; this.hostSettings = hostSettings; this.processStrategyFactory = processStrategyFactory; this.queuePurger = queuePurger; this.queueFactory = queueFactory; this.expiredMessagesPurger = expiredMessagesPurger; this.queuePeeker = queuePeeker; this.queuePeekerOptions = queuePeekerOptions; this.schemaInspector = schemaInspector; this.waitTimeCircuitBreaker = waitTimeCircuitBreaker; Subscriptions = subscriptionManager; }
public SubscriptionPresenter(ISubscriptionManager subscriptionManager, IGroupManager groupManager, IMessager messager, IClientManager clientManager, ISubscriptionView view) { this.view = view; this.groupManager = groupManager; this.subscriptionManager = subscriptionManager; this.messager = messager; this.clientManager = clientManager; view.AddNewSubscription += new EventHandler(view_AddNewSubscription); view.Refresh += new EventHandler(view_Refresh); view.AddNewSubscription += view_Refresh; view.CloseSubscription += View_CloseSubscription; view.ChangeSubscription += View_ChangeSubscription; view.RemoveSubscription += new EventHandler(view_RemoveSubscription); }
public YakariPack(ILocalCacheProviderOptions localCacheProviderOptions, string tribeName, string memberName, string redisConnectionString, LogLevel loglevel) { _logger = new ConsoleLogger(loglevel); // Default Serializer _serializer = new JsonNetSerializer(); //Redis Remote Cache Provider for Yakari _remoteCacheProvider = new RedisCacheProvider(redisConnectionString, _serializer, _logger); //Redis Subscription Manager for tribe communication. _subscriptionManager = new RedisSubscriptionManager(redisConnectionString, tribeName, _logger); // Little Thunder the Local Cache Provider _localCacheProvider = new LittleThunder(localCacheProviderOptions, _logger); // The Great Eagle _observer = new GreatEagle(memberName, _subscriptionManager, _serializer, _localCacheProvider, _remoteCacheProvider, _logger); // Great eagle start observing and loads every previous remote cache items in seperate thread }
public KafkaConsumer(ILogger <KafkaConsumer> logger, KafkaConfiguration configuration, ISubscriptionManager subscriptionManager, IMediator mediator) { ConsumerConfig consumerConfig = new ConsumerConfig { BootstrapServers = configuration.Servers, GroupId = configuration.ConsumerGroupId, AutoOffsetReset = AutoOffsetReset.Latest, Acks = Acks.Leader }; _consumerConfig = consumerConfig; _logger = logger; _subscriptionManager = subscriptionManager; _mediator = mediator; }
public SubscriptionManagerTests(ITestOutputHelper outputHelper) { this._outputHelper = outputHelper; var optionsBuilder = new DbContextOptionsBuilder <EfAsLicenceContext>(); optionsBuilder.UseSqlServer("Integrated Security=SSPI;Persist Security Info=False;Initial Catalog=AS_LICENCE;Data Source=."); EfAsLicenceContext context = new EfAsLicenceContext(optionsBuilder.Options); _unitOfWork = new EfUnitOfWork(context); _customerManager = new CustomerService(_unitOfWork); _softwareManager = new SoftwareService(_unitOfWork); _subscriptionManager = new SubscriptionService(_unitOfWork, _softwareManager); }
public QueueProvider( IPersistentConnection persistentConnection, ISubscriptionManager subsManager, ILifetimeScope autofac, string queueName = null, int retryCount = 5) { _persistentConnection = persistentConnection ?? throw new ArgumentNullException(nameof(persistentConnection)); _subsManager = subsManager; _autofac = autofac; _queueName = queueName; _consumerChannel = CreateConsumerChannel(); _retryCount = retryCount; //_subsManager.OnEventRemoved += SubsManager_OnEventRemoved; }
public async Task WhenStoreIsNotEmpty_CanGetExistingSubscriptions(bool useRealBroker) { // arrange if (!useRealBroker) { // tests the same behavior, even without receiving any broker notifications for the updates this.manager = new SubscriptionManager(this.store, CreateBrokerMock().Object); } var nSubscriptions = 4; for (var i = 0; i < nSubscriptions; ++i) { // adding subscriptions from component2 for topics 1-4 await this.store.AddSubscription(new Subscription("t" + i, "e2", "c1")); } // act var t2Subs = await this.manager.GetSubscriptions("t2"); // assert Assert.AreEqual(1, t2Subs.Count()); }
private int ConvertToNotifyByValue(ISubscriptionManager subscriptionManager, INotifyAction action) { var notifyByArray = subscriptionManager.SubscriptionProvider.GetSubscriptionMethod(action, GetCurrentRecipient()); if (notifyByArray.Length == 1) { if (notifyByArray.Contains(ASC.Core.Configuration.Constants.NotifyEMailSenderSysName)) { return 0; } if (notifyByArray.Contains(ASC.Core.Configuration.Constants.NotifyMessengerSenderSysName)) { return 1; } } if (notifyByArray.Length == 2) { if (notifyByArray.Contains(ASC.Core.Configuration.Constants.NotifyEMailSenderSysName) && notifyByArray.Contains(ASC.Core.Configuration.Constants.NotifyMessengerSenderSysName)) { return 2; } } return 0; }
public async Task WhenDeprecatedSubscriptionsAreFound_BrokerIsNotified() { // mock broker var broker = CreateBrokerMock(); this.manager = new SubscriptionManager(this.store, broker.Object); // arrange var deprecated = new Subscription("t2", "e1", "c1"); await this.store.AddSubscription(new Subscription("t1", "e1", "c1")); await this.store.AddSubscription(deprecated); await this.store.AddSubscription(new Subscription("t3", "e1", "c1")); // act // the deprecated subscription isn't included here, meaning the broker must get notified await this.manager.UpdateEndpointSubscriptions( "e1", new[] { new Subscription("t1", "e1", "c1"), new Subscription("t3", "e1", "c1") }); // assert //verifies that broker was notified only once and for the expected subscription broker.Verify(b => b.NotifyChange(It.IsAny<SubscriptionChange>(), It.IsAny<Subscription>()), Times.Exactly(1)); broker.Verify(b => b.NotifyChange(SubscriptionChange.Remove, It.Is<Subscription>(s => s.Equals(deprecated))), Times.Once); }
/// <summary> /// ... /// </summary> /// <param name="Source">...</param> /// <returns>...</returns> public bool Initialise() { _subscribers = new SubscriptionManagerBase(); return true; }
public EventHub(ISubscriptionManager subscriptionManager, EventTestProvider e) { this.subscriptionManager = subscriptionManager; this.e = e; }
public async Task WhenNewSubscriptionsAreFound_BrokerIsNotified() { // mock broker var broker = CreateBrokerMock(); this.manager = new SubscriptionManager(this.store, broker.Object); // arrange var existingSubscription = new Subscription("t1", "e1", "c1"); await this.store.AddSubscription(existingSubscription); // act var newSubscription1 = new Subscription("t2", "e1", "c1"); var newSubscription2 = new Subscription("t3", "e1", "c1"); await this.manager.UpdateEndpointSubscriptions( "e1", new[] { existingSubscription, newSubscription1, newSubscription2 }); // assert //verifies that broker was notified two times and for the expected subscriptions broker.Verify(b => b.NotifyChange(It.IsAny<SubscriptionChange>(), It.IsAny<Subscription>()), Times.Exactly(2)); broker.Verify(b => b.NotifyChange(SubscriptionChange.Add, It.Is<Subscription>(s => s.Equals(newSubscription1))), Times.Once); broker.Verify(b => b.NotifyChange(SubscriptionChange.Add, It.Is<Subscription>(s => s.Equals(newSubscription2))), Times.Once); }
//// INITIALISE /// Boolean Initialise() { _subscriptions = new SubscriptionManagerBase(); _queries = new Dictionary<String, IQuery>(); return true; }
protected override void TestSetUp() { manager = new SqlSubscriptionManager(); manager.Start(); }
public MessageBus(ISubscriptionManager subscriptionManager, IOutboundTransport transport, ILoggerFactory loggerFactory) { this.subscriptionManager = subscriptionManager; this.transport = transport; this.logger = loggerFactory.GetLogger(typeof(MessageBus)); }
/// <summary> /// ... /// </summary> /// <param name="Source">...</param> /// <returns>...</returns> public bool Initialise() { _diagnostics = new Dictionary<string, string>(); _subscribers = new SubscriptionManagerBase(); return true; }
private int ConvertToNotifyByValue(ISubscriptionManager subscriptionManager, SubscriptionType s) { return ConvertToNotifyByValue(subscriptionManager, s.NotifyAction); }
public Service(IBus bus, IQueryProcessor processor, ISubscriptionManager manager) { _bus = bus; _processor = processor; _manager = manager; }
private void SetNotifyBySubsriptionTypes(IList<string> notifyByList, ISubscriptionManager subscriptionManager) { var subscriptionTypes = subscriptionManager.GetSubscriptionTypes(); if (subscriptionTypes != null) { foreach (var type in subscriptionTypes) SetNotifyBySubsriptionTypes(notifyByList, subscriptionManager, type.NotifyAction); } }
public PullSubscription(string identifier, string deliveryUri, Type eventType, Filter filter, Expires expires, IEnumerable<Selector> selectors, ISubscriptionManager manager) : base(identifier, deliveryUri, eventType, filter, expires, selectors, manager) { }
public DefaultConfigurator SubscriptionManager(ISubscriptionManager manager) { Guard.AgainstNull(manager, "manager"); _configuration.SubscriptionManager = manager; return this; }
private void SetNotifyBySubsriptionTypes(IList<string> notifyByList, ISubscriptionManager subscriptionManager, INotifyAction action) { subscriptionManager .SubscriptionProvider .UpdateSubscriptionMethod( action, GetCurrentRecipient(), notifyByList.ToArray()); }
public IServiceBusConfigurationBuilder SubscriptionManager(ISubscriptionManager manager) { Guard.AgainstNull(manager, "manager"); configuration.SubscriptionManager = manager; return this; }