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