public LunchFilter(IFiber fiber, ISubscriber<SimpleYouTubeClip> input, IPublisher<SimpleYouTubeClip> output) { this.output = output; this.subscription = input.Subscribe(fiber, NewClip); }
public void Add(ISubscriber subscriber) { if (!subscribers.ContainsKey(subscriber.GetType())) { subscribers.Add(subscriber.GetType(), subscriber); } }
void IPublisher.subscribe(ISubscriber subscriber, IList<int> channelsToSubscribe) { int[] subscribedChannels = subscriberChannels.GetOrAdd(subscriber, getInitialArray(this.channelsCapacity)); foreach (var channel in channelsToSubscribe) { if (0 <= channel && channel < channelSubscribers.Length - 1 && subscribedChannels[channel] == -1) { for (int i = 0; i < this.subscribersCapacity; i++) { if (channelSubscribers[channel][i] == null) { locks[channel][i].EnterWriteLock(); try { subscribedChannels[channel] = channel; if (channelSubscribers[channel][i] == null) { channelSubscribers[channel][i] = subscriber; break; } } finally { locks[channel][i].ExitWriteLock(); } } } } } }
public DomainParticipantTransportSource(IDomainParticipant participant, string senderTopic, string receiverTopic) { _participant = participant; var bdt = new ByteDataTypeSupport(); var result = bdt.RegisterType(participant, bdt.TypeName); if (result != ReturnCode.Ok) throw new Exception("Unable to register type: " + result); _publisher = _participant.CreatePublisher(); _subscriber = _participant.CreateSubscriber(); var senderTopicQos = new TopicQos(); participant.GetDefaultTopicQos(ref senderTopicQos); var receiverTopicQos = new TopicQos(); participant.GetDefaultTopicQos(ref receiverTopicQos); _senderTopic = participant.CreateTopic(senderTopic, bdt.TypeName, senderTopicQos); _receiverTopic = participant.CreateTopic(receiverTopic, bdt.TypeName, receiverTopicQos); _dataWriter = (ByteDataWriter)_publisher.CreateDataWriter(_senderTopic); _dataToSendHandle = _dataWriter.RegisterInstance(_dataToSend); var dataReaderQos = new DataReaderQos(); _subscriber.GetDefaultDataReaderQos(ref dataReaderQos); _dataReader = (ByteDataReader)_subscriber.CreateDataReader(_receiverTopic, dataReaderQos, this, StatusKind.Any); }
public void Remove(ISubscriber subscriber) { if (subscribers.ContainsKey(subscriber.GetType())) { subscribers.Remove(subscriber.GetType()); } }
static void Main(string[] args) { IPublisher publisher = new Publisher(countOfChannels, countOfSubscribers); IDataMediator dataMediator = (IDataMediator) publisher; ISubscriber[] subscribers = new ISubscriber[countOfSubscribers]; for (int i = countOfSubscribers - 1; i >= 0; i--) { subscribers[i] = new Subscriber(publisher); } runSubscribe(subscribers, publisher); Thread.CurrentThread.Priority = ThreadPriority.Highest; for (int i = 0; i < 1000; i++) { Stopwatch latency = Stopwatch.StartNew(); int onLoadSubscribersCount = dataMediator.onLoad(randomBytes(10000), rnd.Next(countOfChannels)); latency.Stop(); Console.Write("latency is\t" + latency.Elapsed.Milliseconds + "\tfor\t" + onLoadSubscribersCount + "\tsubscribers"); Console.WriteLine(); } Console.WriteLine("thats all"); Console.ReadLine(); }
public MainWindow(ISubscriber<PlayerCommand> commandChannel, IPublisher<RichYouTubeClip> finishedChannel) { InitializeComponent(); this.finishedChannel = finishedChannel; finishedTimer = new Timer(TimerExpired); progressTimer = new System.Timers.Timer(1000); progressTimer.AutoReset = true; progressTimer.Elapsed += new System.Timers.ElapsedEventHandler(progressTimer_Elapsed); var fiber = new DispatcherFiber(Dispatcher); commandChannel.Subscribe(fiber, OnPlayerCommand); fiber.Start(); WindowStyle = WindowStyle.None; WindowState = WindowState.Maximized; ShowInTaskbar = false; Cursor = Cursors.None; try { tv.Initialize(); } catch (Exception ex) { MessageBox.Show(ex.Message, "Error initialize remote control", MessageBoxButton.OK, MessageBoxImage.Error); } }
private void TestMassivePublish(ISubscriber conn, string caption) { const int loop = 100000; GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced); GC.WaitForPendingFinalizers(); var tasks = new Task[loop]; var withFAF = Stopwatch.StartNew(); for (int i = 0; i < loop; i++) conn.Publish("foo", "bar", CommandFlags.FireAndForget); withFAF.Stop(); GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced); GC.WaitForPendingFinalizers(); var withAsync = Stopwatch.StartNew(); for (int i = 0; i < loop; i++) tasks[i] = conn.PublishAsync("foo", "bar"); conn.WaitAll(tasks); withAsync.Stop(); Assert.Less(1, 2, "sanity check"); Assert.Less(withFAF.ElapsedMilliseconds, withAsync.ElapsedMilliseconds, caption); Console.WriteLine("{2}: {0}ms (F+F) vs {1}ms (async)", withFAF.ElapsedMilliseconds, withAsync.ElapsedMilliseconds, caption); }
public void Subscribe(ISubscriber subscriber) { if (!_subscribers.Contains(subscriber)) { _subscribers.Add(subscriber); } }
public void SetupMessaging(ISubscriber mainBus) { mainBus.Subscribe<SystemMessage.StateChangeMessage>(_projectionManager); if (_runProjections >= RunProjections.System) { mainBus.Subscribe<ProjectionManagementMessage.Post>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.UpdateQuery>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.GetQuery>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.Delete>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.GetStatistics>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.GetState>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.GetResult>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.Disable>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.Enable>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.Abort>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.SetRunAs>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.Reset>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.StartSlaveProjections>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.RegisterSystemProjection>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.Internal.CleanupExpired>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.Internal.RegularTimeout>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.Internal.Deleted>(_projectionManager); mainBus.Subscribe<ProjectionManagementMessage.RegisterSystemProjection>(_projectionManager); mainBus.Subscribe<CoreProjectionManagementMessage.Started>(_projectionManager); mainBus.Subscribe<CoreProjectionManagementMessage.Stopped>(_projectionManager); mainBus.Subscribe<CoreProjectionManagementMessage.Faulted>(_projectionManager); mainBus.Subscribe<CoreProjectionManagementMessage.Prepared>(_projectionManager); mainBus.Subscribe<CoreProjectionManagementMessage.StateReport>(_projectionManager); mainBus.Subscribe<CoreProjectionManagementMessage.ResultReport>(_projectionManager); mainBus.Subscribe<CoreProjectionManagementMessage.StatisticsReport>(_projectionManager); mainBus.Subscribe<CoreProjectionManagementMessage.SlaveProjectionReaderAssigned>(_projectionManager); } mainBus.Subscribe<ClientMessage.WriteEventsCompleted>(_projectionManager); mainBus.Subscribe<ClientMessage.ReadStreamEventsBackwardCompleted>(_projectionManager); }
public void UnSubscribe(ISubscriber subscriber) { if (_subscribers.Contains(subscriber)) { _subscribers.Remove(subscriber); } }
public EventStoreEmbeddedNodeConnection(ConnectionSettings settings, string connectionName, IPublisher publisher, ISubscriber bus, IAuthenticationProvider authenticationProvider) { Ensure.NotNull(publisher, "publisher"); Ensure.NotNull(settings, "settings"); Guid connectionId = Guid.NewGuid(); _settings = settings; _connectionName = connectionName; _publisher = publisher; _authenticationProvider = authenticationProvider; _subscriptionBus = new InMemoryBus("Embedded Client Subscriptions"); _subscriptions = new EmbeddedSubscriber(_subscriptionBus, _authenticationProvider, _settings.Log, connectionId); _subscriptionBus.Subscribe<ClientMessage.SubscriptionConfirmation>(_subscriptions); _subscriptionBus.Subscribe<ClientMessage.SubscriptionDropped>(_subscriptions); _subscriptionBus.Subscribe<ClientMessage.StreamEventAppeared>(_subscriptions); _subscriptionBus.Subscribe<ClientMessage.PersistentSubscriptionConfirmation>(_subscriptions); _subscriptionBus.Subscribe<ClientMessage.PersistentSubscriptionStreamEventAppeared>(_subscriptions); _subscriptionBus.Subscribe(new AdHocHandler<ClientMessage.SubscribeToStream>(_publisher.Publish)); _subscriptionBus.Subscribe(new AdHocHandler<ClientMessage.UnsubscribeFromStream>(_publisher.Publish)); _subscriptionBus.Subscribe(new AdHocHandler<ClientMessage.ConnectToPersistentSubscription>(_publisher.Publish)); bus.Subscribe(new AdHocHandler<SystemMessage.BecomeShutdown>(_ => Disconnected(this, new ClientConnectionEventArgs(this, new IPEndPoint(IPAddress.None, 0))))); }
public void Subscribe(ISubscriber subscriber) { if(_subscribers.Contains(subscriber) == false) { _subscribers.Add(subscriber); } }
public TestWindow() { InitializeComponent(); this.DataContext = this; this.m_DB = YellowstonePathology.Business.RedisConnection.Instance.GetDatabase(); this.m_SUB = YellowstonePathology.Business.RedisConnection.Instance.GetSubscriber(); }
protected override Task WarmUp() { return Task.Run(() => { _subscriber = _connectionMultiplexerFunc().GetSubscriber(); _subscriber.Subscribe(_redisKey, OnNotificationReceived); }).ConfigureAwaitFalse(); }
public void Register( TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService, ITimeProvider timeProvider, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendService) { _projections = new EventStore.Projections.Core.Projections( db, mainQueue, mainBus, timerService, timeProvider, httpForwarder, httpServices, networkSendService, projectionWorkerThreadCount: _projectionWorkerThreadCount, runProjections: _runProjections); }
public PlaylistController(IFiber fiber, ISubscriber<RichYouTubeClip> newClips, ISubscriber<RichYouTubeClip> finishedPlaying, IPublisher<PlayerCommand> playerCommands) { this.playerCommands = playerCommands; this.newClipSubscription = newClips.Subscribe(fiber, NewClip); this.finishedSubscription = finishedPlaying.Subscribe(fiber, Finished); }
public RedisConnection(IDatabase redis, ISubscriber subscriber, string jobStorageIdentity) { _subscriber = subscriber; _jobStorageIdentity = jobStorageIdentity; Redis = redis; mre = new ManualResetEvent(false); _subscriber.Subscribe(string.Format("{0}JobFetchChannel", RedisStorage.Prefix), (channel, val) => { mre.Set();}); }
public RedisSubscriberTests() { _subscriber = A.Fake<ISubscriber>(); _remoteCache = A.Fake<ICacheAside>(); _itemSerializer = A.Fake<IItemSerializer>(); _connection = A.Fake<IConnectionMultiplexer>(); A.CallTo(() => _connection.GetSubscriber(A<object>._)).Returns(_subscriber); }
public async Task OnMessageAsync(Func<string, Task> processMessageAsync) { var connection = RedisClient.CreateConnectionFromConnectionString(_config.ConnectionString); _subscriber = connection.GetSubscriber(); await _subscriber.SubscribeAsync(_channel, async (rc, m) => await processMessageAsync(m), CommandFlags.None); _trace.Verbose(string.Format("Subscribed to {0} channel", _channel)); }
protected void Page_Load(object sender, EventArgs e) { sub = redis.GetSubscriber(); sub.Subscribe("message", (channel, message) => { messageList.Add((string)message); System.Diagnostics.Trace.Write((string)message); }); }
/// <summary> /// Initializes a new instance of the <see cref="RedisCommandQueue"/> class. /// </summary> /// <param name="configuration">The configuration string.</param> /// <param name="collection">The collection to use as the underlying data store.</param> public RedisCommandQueue(string configuration, IProducerConsumerCollection<ICommand> collection) { this.queue = new BlockingCollection<ICommand>(collection); this.multiplexer = ConnectionMultiplexer.Connect(configuration); this.database = this.multiplexer.GetDatabase(); this.pubsub = this.multiplexer.GetSubscriber(); this.pubsub.Subscribe(ChannelKey, this.HandleMessage); this.timer = new Timer(this.FlushQueue, null, EmptyQueueInterval, EmptyQueueInterval); }
public RedisSubscribe(ISubscriber Subscriber, string Prefix) { Channel = Prefix + "announce"; _Subscriber = Subscriber; _Event = new ManualResetEvent(false); _Subscriber.Subscribe(Channel, delegate { _Event.Set(); }); }
public Listener(string server, string userId, string pwd, string topicName, NotifyCallBack callback, string filterCondition, List<string> pPermKeyList, bool pIsSuperUser) { this.topicName = topicName; this.callback = callback; handler = new CallbackHandler(callback, pPermKeyList, pIsSuperUser); handler.TopicName = this.topicName; JMSFactory factory = JMSFactory.getFactory(server, userId, pwd); subscriber = factory.GetInstance(topicName,handler,filterCondition); this.filterCondition = filterCondition; }
public Projections( TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService, ITimeProvider timeProvider, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendQueue, int projectionWorkerThreadCount, RunProjections runProjections) { _projectionWorkerThreadCount = projectionWorkerThreadCount; SetupMessaging( db, mainQueue, mainBus, timerService, timeProvider, httpForwarder, httpServices, networkSendQueue, runProjections); }
public void RemoveAll(ISubscriber subscriber) { lock (_registering) { RegistryEntry entry; if (_bySubscriber.TryGetValue(subscriber, out entry)) { _byGuid.Remove(entry.Guid); removeByType(entry); } } }
public PersistentSubscriptionConsumerStrategyRegistry(IPublisher mainQueue, ISubscriber mainBus, IPersistentSubscriptionConsumerStrategyFactory[] additionalConsumerStrategies) { _mainQueue = mainQueue; _mainBus = mainBus; Register(new DelegatePersistentSubscriptionConsumerStrategyFactory(SystemConsumerStrategies.RoundRobin, (subId, queue, bus) => new RoundRobinPersistentSubscriptionConsumerStrategy())); Register(new DelegatePersistentSubscriptionConsumerStrategyFactory(SystemConsumerStrategies.DispatchToSingle, (subId, queue, bus) => new DispatchToSinglePersistentSubscriptionConsumerStrategy())); Register(new DelegatePersistentSubscriptionConsumerStrategyFactory(SystemConsumerStrategies.Pinned, (subId, queue, bus) => new PinnedPersistentSubscriptionConsumerStrategy(new XXHashUnsafe()))); foreach (var consumerStrategyFactory in additionalConsumerStrategies) { Register(consumerStrategyFactory); } }
public FibonacciCalculator(ThreadFiber fiber, string name, ISubscriber<IntPair> inboundChannel, IChannel<IntPair> outboundChannel, int limit) { _threadFiber = fiber; _name = name; _inboundChannel = inboundChannel; _outboundChannel = outboundChannel; _inboundChannel.Subscribe(fiber, CalculateNext); _limit = limit; }
/// <summary> /// Subscribers can subscribe here by submitting the topic they are interested in. /// The broker will then invoke the handleMessage method on all the intrested subscribers. /// </summary> /// <param name="topic"></param> /// <param name="subscriber"></param> void subscribe(string topic, ref ISubscriber subscriber) { List<ISubscriber> tempSubscribers; if (subscribers.TryGetValue(topic, out tempSubscribers)) { tempSubscribers.Add(subscriber); } else { tempSubscribers = new List<ISubscriber>(); tempSubscribers.Add(subscriber); subscribers.Add(topic, tempSubscribers); } }
public RedisClient() { /* var redisIP = "198.211.107.101"; var redisPort = 6379; */ var redisIP = "127.0.0.1"; var redisPort = 6379; var options = ConfigurationOptions.Parse($"{redisIP}:{redisPort}"); options.SyncTimeout = 10*1000; ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(options); database = redis.GetDatabase(); subscriber = redis.GetSubscriber(); lateTaskManager = new LateTaskManager<RedisMessage>(); }
public Consumer(IConnectionMultiplexer connectionMultiplexer, ILogger <Consumer> logger) { this.connectionMultiplexer = connectionMultiplexer ?? throw new ArgumentNullException(nameof(connectionMultiplexer)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); consumer = connectionMultiplexer.GetSubscriber(); }
protected override Subscription CreateSubscription(ISubscriber subscriber, string cursor, Func <MessageResult, object, Task <bool> > callback, int messageBufferSize, object state) { return(new ScaleoutSubscription(subscriber.Identity, subscriber.EventKeys, cursor, StreamManager.Streams, callback, messageBufferSize, _traceManager, Counters, state)); }
public static NavigationController Wire(INavigationView view, IMessageQueue queue, ISubscriber bus, ClientPerspective model) { var adapter = new NavigationController(view, queue, model); bus.Subscribe<Dumb.StuffAddedToInbox>(adapter); bus.Subscribe<Dumb.StuffRemovedFromInbox>(adapter); bus.Subscribe<Dumb.ProjectAdded>(adapter); bus.Subscribe<Dumb.ClientModelLoaded>(adapter); bus.Subscribe<UI.InboxDisplayed>(adapter); bus.Subscribe<UI.ProjectDisplayed>(adapter); bus.Subscribe<UI.DragStarted>(adapter); bus.Subscribe<UI.DragCompleted>(adapter); return adapter ; }
public LockPubSub(ConnectionMultiplexer connection) { _pubSub = connection.GetSubscriber(); Latch = new SemaphoreSlim(0, 1); }
public TestSubscriber(ISubscriber <T> sdelegate) : this(sdelegate, long.MaxValue) { }
public DeferredResponseService( IConnectionMultiplexer connectionMultiplexer) { _database = connectionMultiplexer.GetDatabase(); _subscriber = connectionMultiplexer.GetSubscriber(); }
public void Subscribe(ISubscriber <T> subscriber) { subscriber.OnSubscribe(new StreamTestKit.CompletedSubscription <T>(subscriber)); }
public ClusterVNode(TFChunkDb db, ClusterVNodeSettings vNodeSettings, IGossipSeedSource gossipSeedSource, InfoController infoController, params ISubsystem[] subsystems) { Ensure.NotNull(db, "db"); Ensure.NotNull(vNodeSettings, "vNodeSettings"); Ensure.NotNull(gossipSeedSource, "gossipSeedSource"); var isSingleNode = vNodeSettings.ClusterNodeCount == 1; _nodeInfo = vNodeSettings.NodeInfo; _mainBus = new InMemoryBus("MainBus"); var forwardingProxy = new MessageForwardingProxy(); if (vNodeSettings.EnableHistograms) { HistogramService.CreateHistograms(); //start watching jitter HistogramService.StartJitterMonitor(); } // MISC WORKERS _workerBuses = Enumerable.Range(0, vNodeSettings.WorkerThreads).Select(queueNum => new InMemoryBus(string.Format("Worker #{0} Bus", queueNum + 1), watchSlowMsg: true, slowMsgThreshold: TimeSpan.FromMilliseconds(200))).ToArray(); _workersHandler = new MultiQueuedHandler( vNodeSettings.WorkerThreads, queueNum => new QueuedHandlerThreadPool(_workerBuses[queueNum], string.Format("Worker #{0}", queueNum + 1), groupName: "Workers", watchSlowMsg: true, slowMsgThreshold: TimeSpan.FromMilliseconds(200))); _subsystems = subsystems; _controller = new ClusterVNodeController((IPublisher)_mainBus, _nodeInfo, db, vNodeSettings, this, forwardingProxy, _subsystems); _mainQueue = QueuedHandler.CreateQueuedHandler(_controller, "MainQueue"); _controller.SetMainQueue(_mainQueue); //SELF _mainBus.Subscribe <SystemMessage.StateChangeMessage>(this); _mainBus.Subscribe <SystemMessage.BecomeShutdown>(this); // MONITORING var monitoringInnerBus = new InMemoryBus("MonitoringInnerBus", watchSlowMsg: false); var monitoringRequestBus = new InMemoryBus("MonitoringRequestBus", watchSlowMsg: false); var monitoringQueue = new QueuedHandlerThreadPool(monitoringInnerBus, "MonitoringQueue", true, TimeSpan.FromMilliseconds(100)); var monitoring = new MonitoringService(monitoringQueue, monitoringRequestBus, _mainQueue, db.Config.WriterCheckpoint, db.Config.Path, vNodeSettings.StatsPeriod, _nodeInfo.ExternalHttp, vNodeSettings.StatsStorage, _nodeInfo.ExternalTcp, _nodeInfo.ExternalSecureTcp); _mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.SystemInit, Message>()); _mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.StateChangeMessage, Message>()); _mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>()); _mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShutdown, Message>()); _mainBus.Subscribe(monitoringQueue.WidenFrom <ClientMessage.WriteEventsCompleted, Message>()); monitoringInnerBus.Subscribe <SystemMessage.SystemInit>(monitoring); monitoringInnerBus.Subscribe <SystemMessage.StateChangeMessage>(monitoring); monitoringInnerBus.Subscribe <SystemMessage.BecomeShuttingDown>(monitoring); monitoringInnerBus.Subscribe <SystemMessage.BecomeShutdown>(monitoring); monitoringInnerBus.Subscribe <ClientMessage.WriteEventsCompleted>(monitoring); monitoringInnerBus.Subscribe <MonitoringMessage.GetFreshStats>(monitoring); monitoringInnerBus.Subscribe <MonitoringMessage.GetFreshTcpConnectionStats>(monitoring); var truncPos = db.Config.TruncateCheckpoint.Read(); if (truncPos != -1) { Log.Info("Truncate checkpoint is present. Truncate: {0} (0x{0:X}), Writer: {1} (0x{1:X}), Chaser: {2} (0x{2:X}), Epoch: {3} (0x{3:X})", truncPos, db.Config.WriterCheckpoint.Read(), db.Config.ChaserCheckpoint.Read(), db.Config.EpochCheckpoint.Read()); var truncator = new TFChunkDbTruncator(db.Config); truncator.TruncateDb(truncPos); } // STORAGE SUBSYSTEM db.Open(vNodeSettings.VerifyDbHash); var indexPath = vNodeSettings.Index ?? Path.Combine(db.Config.Path, "index"); var readerPool = new ObjectPool <ITransactionFileReader>( "ReadIndex readers pool", ESConsts.PTableInitialReaderCount, ESConsts.PTableMaxReaderCount, () => new TFChunkReader(db, db.Config.WriterCheckpoint)); var tableIndex = new TableIndex(indexPath, new XXHashUnsafe(), new Murmur3AUnsafe(), () => new HashListMemTable(vNodeSettings.IndexBitnessVersion, maxSize: vNodeSettings.MaxMemtableEntryCount * 2), () => new TFReaderLease(readerPool), vNodeSettings.IndexBitnessVersion, maxSizeForMemory: vNodeSettings.MaxMemtableEntryCount, maxTablesPerLevel: 2, inMem: db.Config.InMemDb, skipIndexVerify: vNodeSettings.SkipIndexVerify, indexCacheDepth: vNodeSettings.IndexCacheDepth); var readIndex = new ReadIndex(_mainQueue, readerPool, tableIndex, ESConsts.StreamInfoCacheCapacity, Application.IsDefined(Application.AdditionalCommitChecks), Application.IsDefined(Application.InfiniteMetastreams) ? int.MaxValue : 1, vNodeSettings.HashCollisionReadLimit, vNodeSettings.SkipIndexScanOnReads, db.Config.ReplicationCheckpoint); var writer = new TFChunkWriter(db); var epochManager = new EpochManager(_mainQueue, ESConsts.CachedEpochCount, db.Config.EpochCheckpoint, writer, initialReaderCount: 1, maxReaderCount: 5, readerFactory: () => new TFChunkReader(db, db.Config.WriterCheckpoint)); epochManager.Init(); var storageWriter = new ClusterStorageWriterService(_mainQueue, _mainBus, vNodeSettings.MinFlushDelay, db, writer, readIndex.IndexWriter, epochManager, () => readIndex.LastCommitPosition); // subscribes internally monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageWriter); var storageReader = new StorageReaderService(_mainQueue, _mainBus, readIndex, vNodeSettings.ReaderThreadsCount, db.Config.WriterCheckpoint); _mainBus.Subscribe <SystemMessage.SystemInit>(storageReader); _mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageReader); _mainBus.Subscribe <SystemMessage.BecomeShutdown>(storageReader); monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageReader); var indexCommitterService = new IndexCommitterService(readIndex.IndexCommitter, _mainQueue, db.Config.ReplicationCheckpoint, db.Config.WriterCheckpoint, vNodeSettings.CommitAckCount); _mainBus.Subscribe <SystemMessage.StateChangeMessage>(indexCommitterService); _mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(indexCommitterService); _mainBus.Subscribe <StorageMessage.CommitAck>(indexCommitterService); var chaser = new TFChunkChaser(db, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint); var storageChaser = new StorageChaser(_mainQueue, db.Config.WriterCheckpoint, chaser, indexCommitterService, epochManager); #if DEBUG QueueStatsCollector.InitializeCheckpoints( _nodeInfo.DebugIndex, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint); #endif _mainBus.Subscribe <SystemMessage.SystemInit>(storageChaser); _mainBus.Subscribe <SystemMessage.SystemStart>(storageChaser); _mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageChaser); // AUTHENTICATION INFRASTRUCTURE - delegate to plugins _internalAuthenticationProvider = vNodeSettings.AuthenticationProviderFactory.BuildAuthenticationProvider(_mainQueue, _mainBus, _workersHandler, _workerBuses); Ensure.NotNull(_internalAuthenticationProvider, "authenticationProvider"); { // EXTERNAL TCP if (!vNodeSettings.DisableInsecureTCP) { var extTcpService = new TcpService(_mainQueue, _nodeInfo.ExternalTcp, _workersHandler, TcpServiceType.External, TcpSecurityType.Normal, new ClientTcpDispatcher(), vNodeSettings.ExtTcpHeartbeatInterval, vNodeSettings.ExtTcpHeartbeatTimeout, _internalAuthenticationProvider, null, vNodeSettings.ConnectionPendingSendBytesThreshold); _mainBus.Subscribe <SystemMessage.SystemInit>(extTcpService); _mainBus.Subscribe <SystemMessage.SystemStart>(extTcpService); _mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(extTcpService); } // EXTERNAL SECURE TCP if (_nodeInfo.ExternalSecureTcp != null) { var extSecTcpService = new TcpService(_mainQueue, _nodeInfo.ExternalSecureTcp, _workersHandler, TcpServiceType.External, TcpSecurityType.Secure, new ClientTcpDispatcher(), vNodeSettings.ExtTcpHeartbeatInterval, vNodeSettings.ExtTcpHeartbeatTimeout, _internalAuthenticationProvider, vNodeSettings.Certificate, vNodeSettings.ConnectionPendingSendBytesThreshold); _mainBus.Subscribe <SystemMessage.SystemInit>(extSecTcpService); _mainBus.Subscribe <SystemMessage.SystemStart>(extSecTcpService); _mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(extSecTcpService); } if (!isSingleNode) { // INTERNAL TCP if (!vNodeSettings.DisableInsecureTCP) { var intTcpService = new TcpService(_mainQueue, _nodeInfo.InternalTcp, _workersHandler, TcpServiceType.Internal, TcpSecurityType.Normal, new InternalTcpDispatcher(), vNodeSettings.IntTcpHeartbeatInterval, vNodeSettings.IntTcpHeartbeatTimeout, _internalAuthenticationProvider, null, ESConsts.UnrestrictedPendingSendBytes); _mainBus.Subscribe <SystemMessage.SystemInit>(intTcpService); _mainBus.Subscribe <SystemMessage.SystemStart>(intTcpService); _mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(intTcpService); } // INTERNAL SECURE TCP if (_nodeInfo.InternalSecureTcp != null) { var intSecTcpService = new TcpService(_mainQueue, _nodeInfo.InternalSecureTcp, _workersHandler, TcpServiceType.Internal, TcpSecurityType.Secure, new InternalTcpDispatcher(), vNodeSettings.IntTcpHeartbeatInterval, vNodeSettings.IntTcpHeartbeatTimeout, _internalAuthenticationProvider, vNodeSettings.Certificate, ESConsts.UnrestrictedPendingSendBytes); _mainBus.Subscribe <SystemMessage.SystemInit>(intSecTcpService); _mainBus.Subscribe <SystemMessage.SystemStart>(intSecTcpService); _mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(intSecTcpService); } } } SubscribeWorkers(bus => { var tcpSendService = new TcpSendService(); // ReSharper disable RedundantTypeArgumentsOfMethod bus.Subscribe <TcpMessage.TcpSend>(tcpSendService); // ReSharper restore RedundantTypeArgumentsOfMethod }); var httpAuthenticationProviders = new List <HttpAuthenticationProvider> { new BasicHttpAuthenticationProvider(_internalAuthenticationProvider), }; if (vNodeSettings.EnableTrustedAuth) { httpAuthenticationProviders.Add(new TrustedHttpAuthenticationProvider()); } httpAuthenticationProviders.Add(new AnonymousHttpAuthenticationProvider()); var httpPipe = new HttpMessagePipe(); var httpSendService = new HttpSendService(httpPipe, forwardRequests: true); _mainBus.Subscribe <SystemMessage.StateChangeMessage>(httpSendService); _mainBus.Subscribe(new WideningHandler <HttpMessage.SendOverHttp, Message>(_workersHandler)); SubscribeWorkers(bus => { bus.Subscribe <HttpMessage.HttpSend>(httpSendService); bus.Subscribe <HttpMessage.HttpSendPart>(httpSendService); bus.Subscribe <HttpMessage.HttpBeginSend>(httpSendService); bus.Subscribe <HttpMessage.HttpEndSend>(httpSendService); bus.Subscribe <HttpMessage.SendOverHttp>(httpSendService); }); _mainBus.Subscribe <SystemMessage.StateChangeMessage>(infoController); var adminController = new AdminController(_mainQueue); var pingController = new PingController(); var histogramController = new HistogramController(); var statController = new StatController(monitoringQueue, _workersHandler); var atomController = new AtomController(httpSendService, _mainQueue, _workersHandler, vNodeSettings.DisableHTTPCaching); var gossipController = new GossipController(_mainQueue, _workersHandler, vNodeSettings.GossipTimeout); var persistentSubscriptionController = new PersistentSubscriptionController(httpSendService, _mainQueue, _workersHandler); var electController = new ElectController(_mainQueue); // HTTP SENDERS gossipController.SubscribeSenders(httpPipe); electController.SubscribeSenders(httpPipe); // EXTERNAL HTTP _externalHttpService = new HttpService(ServiceAccessibility.Public, _mainQueue, new TrieUriRouter(), _workersHandler, vNodeSettings.LogHttpRequests, vNodeSettings.GossipAdvertiseInfo.AdvertiseExternalIPAs, vNodeSettings.GossipAdvertiseInfo.AdvertiseExternalHttpPortAs, vNodeSettings.ExtHttpPrefixes); _externalHttpService.SetupController(persistentSubscriptionController); if (vNodeSettings.AdminOnPublic) { _externalHttpService.SetupController(adminController); } _externalHttpService.SetupController(pingController); _externalHttpService.SetupController(infoController); if (vNodeSettings.StatsOnPublic) { _externalHttpService.SetupController(statController); } _externalHttpService.SetupController(atomController); if (vNodeSettings.GossipOnPublic) { _externalHttpService.SetupController(gossipController); } _externalHttpService.SetupController(histogramController); _mainBus.Subscribe <SystemMessage.SystemInit>(_externalHttpService); _mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(_externalHttpService); _mainBus.Subscribe <HttpMessage.PurgeTimedOutRequests>(_externalHttpService); // INTERNAL HTTP if (!isSingleNode) { _internalHttpService = new HttpService(ServiceAccessibility.Private, _mainQueue, new TrieUriRouter(), _workersHandler, vNodeSettings.LogHttpRequests, vNodeSettings.GossipAdvertiseInfo.AdvertiseInternalIPAs, vNodeSettings.GossipAdvertiseInfo.AdvertiseInternalHttpPortAs, vNodeSettings.IntHttpPrefixes); _internalHttpService.SetupController(adminController); _internalHttpService.SetupController(pingController); _internalHttpService.SetupController(infoController); _internalHttpService.SetupController(statController); _internalHttpService.SetupController(atomController); _internalHttpService.SetupController(gossipController); _internalHttpService.SetupController(electController); _internalHttpService.SetupController(histogramController); _internalHttpService.SetupController(persistentSubscriptionController); } // Authentication plugin HTTP vNodeSettings.AuthenticationProviderFactory.RegisterHttpControllers(_externalHttpService, _internalHttpService, httpSendService, _mainQueue, _workersHandler); if (_internalHttpService != null) { _mainBus.Subscribe <SystemMessage.SystemInit>(_internalHttpService); _mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(_internalHttpService); _mainBus.Subscribe <HttpMessage.PurgeTimedOutRequests>(_internalHttpService); } SubscribeWorkers(bus => { HttpService.CreateAndSubscribePipeline(bus, httpAuthenticationProviders.ToArray()); }); // REQUEST FORWARDING var forwardingService = new RequestForwardingService(_mainQueue, forwardingProxy, TimeSpan.FromSeconds(1)); _mainBus.Subscribe <SystemMessage.SystemStart>(forwardingService); _mainBus.Subscribe <SystemMessage.RequestForwardingTimerTick>(forwardingService); _mainBus.Subscribe <ClientMessage.NotHandled>(forwardingService); _mainBus.Subscribe <ClientMessage.WriteEventsCompleted>(forwardingService); _mainBus.Subscribe <ClientMessage.TransactionStartCompleted>(forwardingService); _mainBus.Subscribe <ClientMessage.TransactionWriteCompleted>(forwardingService); _mainBus.Subscribe <ClientMessage.TransactionCommitCompleted>(forwardingService); _mainBus.Subscribe <ClientMessage.DeleteStreamCompleted>(forwardingService); // REQUEST MANAGEMENT var requestManagement = new RequestManagementService(_mainQueue, vNodeSettings.PrepareAckCount, vNodeSettings.PrepareTimeout, vNodeSettings.CommitTimeout, vNodeSettings.BetterOrdering); _mainBus.Subscribe <SystemMessage.SystemInit>(requestManagement); _mainBus.Subscribe <ClientMessage.WriteEvents>(requestManagement); _mainBus.Subscribe <ClientMessage.TransactionStart>(requestManagement); _mainBus.Subscribe <ClientMessage.TransactionWrite>(requestManagement); _mainBus.Subscribe <ClientMessage.TransactionCommit>(requestManagement); _mainBus.Subscribe <ClientMessage.DeleteStream>(requestManagement); _mainBus.Subscribe <StorageMessage.RequestCompleted>(requestManagement); _mainBus.Subscribe <StorageMessage.CheckStreamAccessCompleted>(requestManagement); _mainBus.Subscribe <StorageMessage.AlreadyCommitted>(requestManagement); _mainBus.Subscribe <StorageMessage.CommitReplicated>(requestManagement); _mainBus.Subscribe <StorageMessage.PrepareAck>(requestManagement); _mainBus.Subscribe <StorageMessage.WrongExpectedVersion>(requestManagement); _mainBus.Subscribe <StorageMessage.InvalidTransaction>(requestManagement); _mainBus.Subscribe <StorageMessage.StreamDeleted>(requestManagement); _mainBus.Subscribe <StorageMessage.RequestManagerTimerTick>(requestManagement); // SUBSCRIPTIONS var subscrBus = new InMemoryBus("SubscriptionsBus", true, TimeSpan.FromMilliseconds(50)); var subscrQueue = new QueuedHandlerThreadPool(subscrBus, "Subscriptions", false); _mainBus.Subscribe(subscrQueue.WidenFrom <SystemMessage.SystemStart, Message>()); _mainBus.Subscribe(subscrQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>()); _mainBus.Subscribe(subscrQueue.WidenFrom <TcpMessage.ConnectionClosed, Message>()); _mainBus.Subscribe(subscrQueue.WidenFrom <ClientMessage.SubscribeToStream, Message>()); _mainBus.Subscribe(subscrQueue.WidenFrom <ClientMessage.UnsubscribeFromStream, Message>()); _mainBus.Subscribe(subscrQueue.WidenFrom <SubscriptionMessage.PollStream, Message>()); _mainBus.Subscribe(subscrQueue.WidenFrom <SubscriptionMessage.CheckPollTimeout, Message>()); _mainBus.Subscribe(subscrQueue.WidenFrom <StorageMessage.EventCommitted, Message>()); var subscription = new SubscriptionsService(_mainQueue, subscrQueue, readIndex); subscrBus.Subscribe <SystemMessage.SystemStart>(subscription); subscrBus.Subscribe <SystemMessage.BecomeShuttingDown>(subscription); subscrBus.Subscribe <TcpMessage.ConnectionClosed>(subscription); subscrBus.Subscribe <ClientMessage.SubscribeToStream>(subscription); subscrBus.Subscribe <ClientMessage.UnsubscribeFromStream>(subscription); subscrBus.Subscribe <SubscriptionMessage.PollStream>(subscription); subscrBus.Subscribe <SubscriptionMessage.CheckPollTimeout>(subscription); subscrBus.Subscribe <StorageMessage.EventCommitted>(subscription); // PERSISTENT SUBSCRIPTIONS // IO DISPATCHER var ioDispatcher = new IODispatcher(_mainQueue, new PublishEnvelope(_mainQueue)); _mainBus.Subscribe <ClientMessage.ReadStreamEventsBackwardCompleted>(ioDispatcher.BackwardReader); _mainBus.Subscribe <ClientMessage.WriteEventsCompleted>(ioDispatcher.Writer); _mainBus.Subscribe <ClientMessage.ReadStreamEventsForwardCompleted>(ioDispatcher.ForwardReader); _mainBus.Subscribe <ClientMessage.DeleteStreamCompleted>(ioDispatcher.StreamDeleter); _mainBus.Subscribe(ioDispatcher); var perSubscrBus = new InMemoryBus("PersistentSubscriptionsBus", true, TimeSpan.FromMilliseconds(50)); var perSubscrQueue = new QueuedHandlerThreadPool(perSubscrBus, "PersistentSubscriptions", false); _mainBus.Subscribe(perSubscrQueue.WidenFrom <SystemMessage.StateChangeMessage, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <TcpMessage.ConnectionClosed, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.CreatePersistentSubscription, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.UpdatePersistentSubscription, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.DeletePersistentSubscription, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ConnectToPersistentSubscription, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.UnsubscribeFromStream, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.PersistentSubscriptionAckEvents, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.PersistentSubscriptionNackEvents, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReplayAllParkedMessages, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReplayParkedMessage, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReadNextNPersistentMessages, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <StorageMessage.EventCommitted, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetAllPersistentSubscriptionStats, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetStreamPersistentSubscriptionStats, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetPersistentSubscriptionStats, Message>()); _mainBus.Subscribe(perSubscrQueue.WidenFrom <SubscriptionMessage.PersistentSubscriptionTimerTick, Message>()); //TODO CC can have multiple threads working on subscription if partition var consumerStrategyRegistry = new PersistentSubscriptionConsumerStrategyRegistry(_mainQueue, _mainBus, vNodeSettings.AdditionalConsumerStrategies); var persistentSubscription = new PersistentSubscriptionService(subscrQueue, readIndex, ioDispatcher, _mainQueue, consumerStrategyRegistry); perSubscrBus.Subscribe <SystemMessage.BecomeShuttingDown>(persistentSubscription); perSubscrBus.Subscribe <SystemMessage.BecomeMaster>(persistentSubscription); perSubscrBus.Subscribe <SystemMessage.StateChangeMessage>(persistentSubscription); perSubscrBus.Subscribe <TcpMessage.ConnectionClosed>(persistentSubscription); perSubscrBus.Subscribe <ClientMessage.ConnectToPersistentSubscription>(persistentSubscription); perSubscrBus.Subscribe <ClientMessage.UnsubscribeFromStream>(persistentSubscription); perSubscrBus.Subscribe <ClientMessage.PersistentSubscriptionAckEvents>(persistentSubscription); perSubscrBus.Subscribe <ClientMessage.PersistentSubscriptionNackEvents>(persistentSubscription); perSubscrBus.Subscribe <StorageMessage.EventCommitted>(persistentSubscription); perSubscrBus.Subscribe <ClientMessage.DeletePersistentSubscription>(persistentSubscription); perSubscrBus.Subscribe <ClientMessage.CreatePersistentSubscription>(persistentSubscription); perSubscrBus.Subscribe <ClientMessage.UpdatePersistentSubscription>(persistentSubscription); perSubscrBus.Subscribe <ClientMessage.ReplayAllParkedMessages>(persistentSubscription); perSubscrBus.Subscribe <ClientMessage.ReplayParkedMessage>(persistentSubscription); perSubscrBus.Subscribe <ClientMessage.ReadNextNPersistentMessages>(persistentSubscription); perSubscrBus.Subscribe <MonitoringMessage.GetAllPersistentSubscriptionStats>(persistentSubscription); perSubscrBus.Subscribe <MonitoringMessage.GetStreamPersistentSubscriptionStats>(persistentSubscription); perSubscrBus.Subscribe <MonitoringMessage.GetPersistentSubscriptionStats>(persistentSubscription); perSubscrBus.Subscribe <SubscriptionMessage.PersistentSubscriptionTimerTick>(persistentSubscription); // STORAGE SCAVENGER var storageScavenger = new StorageScavenger(db, ioDispatcher, tableIndex, readIndex, vNodeSettings.AlwaysKeepScavenged, _nodeInfo.ExternalHttp.ToString(), !vNodeSettings.DisableScavengeMerging, vNodeSettings.ScavengeHistoryMaxAge, unsafeIgnoreHardDeletes: vNodeSettings.UnsafeIgnoreHardDeletes); // ReSharper disable RedundantTypeArgumentsOfMethod _mainBus.Subscribe <ClientMessage.ScavengeDatabase>(storageScavenger); _mainBus.Subscribe <UserManagementMessage.UserManagementServiceInitialized>(storageScavenger); // ReSharper restore RedundantTypeArgumentsOfMethod // TIMER _timeProvider = new RealTimeProvider(); _timerService = new TimerService(new ThreadBasedScheduler(_timeProvider)); _mainBus.Subscribe <SystemMessage.BecomeShutdown>(_timerService); _mainBus.Subscribe <TimerMessage.Schedule>(_timerService); var gossipInfo = new VNodeInfo(_nodeInfo.InstanceId, _nodeInfo.DebugIndex, vNodeSettings.GossipAdvertiseInfo.InternalTcp, vNodeSettings.GossipAdvertiseInfo.InternalSecureTcp, vNodeSettings.GossipAdvertiseInfo.ExternalTcp, vNodeSettings.GossipAdvertiseInfo.ExternalSecureTcp, vNodeSettings.GossipAdvertiseInfo.InternalHttp, vNodeSettings.GossipAdvertiseInfo.ExternalHttp); if (!isSingleNode) { // MASTER REPLICATION var masterReplicationService = new MasterReplicationService(_mainQueue, gossipInfo.InstanceId, db, _workersHandler, epochManager, vNodeSettings.ClusterNodeCount); _mainBus.Subscribe <SystemMessage.SystemStart>(masterReplicationService); _mainBus.Subscribe <SystemMessage.StateChangeMessage>(masterReplicationService); _mainBus.Subscribe <ReplicationMessage.ReplicaSubscriptionRequest>(masterReplicationService); _mainBus.Subscribe <ReplicationMessage.ReplicaLogPositionAck>(masterReplicationService); monitoringInnerBus.Subscribe <ReplicationMessage.GetReplicationStats>(masterReplicationService); // REPLICA REPLICATION var replicaService = new ReplicaService(_mainQueue, db, epochManager, _workersHandler, _internalAuthenticationProvider, gossipInfo, vNodeSettings.UseSsl, vNodeSettings.SslTargetHost, vNodeSettings.SslValidateServer, vNodeSettings.IntTcpHeartbeatTimeout, vNodeSettings.ExtTcpHeartbeatInterval); _mainBus.Subscribe <SystemMessage.StateChangeMessage>(replicaService); _mainBus.Subscribe <ReplicationMessage.ReconnectToMaster>(replicaService); _mainBus.Subscribe <ReplicationMessage.SubscribeToMaster>(replicaService); _mainBus.Subscribe <ReplicationMessage.AckLogPosition>(replicaService); _mainBus.Subscribe <StorageMessage.PrepareAck>(replicaService); _mainBus.Subscribe <StorageMessage.CommitAck>(replicaService); _mainBus.Subscribe <ClientMessage.TcpForwardMessage>(replicaService); } // ELECTIONS var electionsService = new ElectionsService(_mainQueue, gossipInfo, vNodeSettings.ClusterNodeCount, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint, epochManager, () => readIndex.LastCommitPosition, vNodeSettings.NodePriority); electionsService.SubscribeMessages(_mainBus); if (!isSingleNode || vNodeSettings.GossipOnSingleNode) { // GOSSIP var gossip = new NodeGossipService(_mainQueue, gossipSeedSource, gossipInfo, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint, epochManager, () => readIndex.LastCommitPosition, vNodeSettings.NodePriority, vNodeSettings.GossipInterval, vNodeSettings.GossipAllowedTimeDifference); _mainBus.Subscribe <SystemMessage.SystemInit>(gossip); _mainBus.Subscribe <GossipMessage.RetrieveGossipSeedSources>(gossip); _mainBus.Subscribe <GossipMessage.GotGossipSeedSources>(gossip); _mainBus.Subscribe <GossipMessage.Gossip>(gossip); _mainBus.Subscribe <GossipMessage.GossipReceived>(gossip); _mainBus.Subscribe <SystemMessage.StateChangeMessage>(gossip); _mainBus.Subscribe <GossipMessage.GossipSendFailed>(gossip); _mainBus.Subscribe <SystemMessage.VNodeConnectionEstablished>(gossip); _mainBus.Subscribe <SystemMessage.VNodeConnectionLost>(gossip); } _workersHandler.Start(); _mainQueue.Start(); monitoringQueue.Start(); subscrQueue.Start(); if (subsystems != null) { foreach (var subsystem in subsystems) { var http = isSingleNode ? new [] { _externalHttpService } : new [] { _internalHttpService, _externalHttpService }; subsystem.Register(new StandardComponents(db, _mainQueue, _mainBus, _timerService, _timeProvider, httpSendService, http, _workersHandler)); } } }
public OnBackpressureBufferSubscriber(ISubscriber <T> actual, int capacityHint) : base(capacityHint) { this.actual = actual; }
public PublisherScan(ISubscriber <R> actual, R value, Func <R, T, R> accumulator) { this.actual = actual; this.value = value; this.accumulator = accumulator; }
public RedisMessageBus(ISubscriber subscriber, string topic = null, ISerializer serializer = null, ILoggerFactory loggerFactory = null) : base(loggerFactory) { _subscriber = subscriber; _topic = topic ?? "messages"; _serializer = serializer ?? new JsonNetSerializer(); }
public LeadDispatcherSubscriber(ISubscriber <ILeadEntity> notificationSubscriber, ILoggerClient loggerClient) { _notificationSubscriber = notificationSubscriber ?? throw new ArgumentNullException(nameof(notificationSubscriber)); _loggerClient = loggerClient ?? throw new ArgumentNullException(nameof(loggerClient)); }
public UntypedSubscriberImpl(ISubscriber <T> subscriber) { _subscriber = subscriber; }
public RedisBus(ISubscriber sub) => _sub = sub;
public void Subscribe(ISubscriber <T> subscriber) { subscriber.OnSubscribe(new StreamTestKit.FailedSubscription <T>(subscriber, Cause)); }
public void Run() { #if DBCallTests DDS.Test.DatabaseTests(); #endif Console.WriteLine("Press enter to enter..."); Console.ReadLine(); Data.DataTest detectionData = new Data.DataTest(); detectionData.TestId = 3214; detectionData.Emergency = true; detectionData.TestStr = "not really"; //detectionData.SeqInt[3] = 23; #if TestMarshaling //Tactical.DetectionTypeSupport support = new Tactical.DetectionTypeSupport(); //Tactical.Detection cachedObj = new Tactical.Detection(); //support.Copy(cachedObj, detectionData); //SampleMarshaler marshaler = SampleMarshalerFactory.CreateMarshaler(detectionData); //using (SampleMarshalHelper helper = new SampleMarshalHelper(marshaler)) //{ // DDS.OpenSplice.Gapi.Test.test_detection(helper.GapiPtr); // Tactical.Detection detectionData2 = new Tactical.Detection(); // SampleMarshaler marshaler2 = SampleMarshalerFactory.CreateMarshaler(detectionData2); // marshaler2.CopyOut(helper.GapiPtr, 0); //} //Duration d = new Duration(234, 2343); //int sec; //uint nanosec; //DDS.OpenSplice.Gapi.Test.test_duration(d, out sec, out nanosec); //LivelinessChangedStatus status; //DDS.OpenSplice.Gapi.Test.get_liveliness_changed_status(out status); //Time t = new Time(1, 2); //int size = Marshal.SizeOf(t); //IntPtr ptr = Marshal.AllocHGlobal(size); //Marshal.StructureToPtr(t, ptr, true); #endif //DDS.Test.TestDataReaderQos(); //DDS.Test.TestTopicQos(); // Create a DomainParticipantFactory DomainParticipantFactory dpf = DomainParticipantFactory.Instance; Console.WriteLine("DomainParticipantFactory: " + dpf); // Tailor the DomainPartipantFactoryQos; DomainParticipantFactoryQos dpfQos = null; ReturnCode result = dpf.GetQos(ref dpfQos); Console.WriteLine("DomainParticipantFactory.get_qos: {0}", result); Console.WriteLine("DomainParticipantFactoryQos.entity_factory.autoenable_created_entities: " + dpfQos.EntityFactory.AutoenableCreatedEntities); dpfQos.EntityFactory.AutoenableCreatedEntities = false; result = dpf.SetQos(dpfQos); Console.WriteLine("DomainParticipantFactory.set_qos: {0}", result); // Get the QOS settings for the Factory... Check values without additional changes DomainParticipantFactoryQos dpf2Qos = null; result = dpf.GetQos(ref dpf2Qos); Console.WriteLine("DomainParticipantFactory.get_qos: {0}", result); Console.WriteLine("DomainParticipantFactoryQos.entity_factory.autoenable_created_entities: " + dpf2Qos.EntityFactory.AutoenableCreatedEntities); // Create the domainParticipant itself. DomainParticipantQos dpQos = new DomainParticipantQos(); dpQos.UserData.Value = new byte[] { (byte)1, (byte)2, (byte)3 }; dpQos.EntityFactory.AutoenableCreatedEntities = true; dpQos.ListenerScheduling.SchedulingClass.Kind = SchedulingClassQosPolicyKind.ScheduleDefault; dpQos.ListenerScheduling.SchedulingPriorityKind.Kind = SchedulingPriorityQosPolicyKind.PriorityRelative; dpQos.ListenerScheduling.SchedulingPriority = 0; dpQos.WatchdogScheduling.SchedulingClass.Kind = SchedulingClassQosPolicyKind.ScheduleDefault; dpQos.WatchdogScheduling.SchedulingPriorityKind.Kind = SchedulingPriorityQosPolicyKind.PriorityRelative; dpQos.WatchdogScheduling.SchedulingPriority = 4; IDomainParticipant dp = dpf.CreateParticipant(DDS.DomainId.Default, dpQos); Console.Write("DomainParticipant: "); Console.WriteLine(dp != null ? "yes" : "no"); if (dp.ContainsEntity(0)) { Console.WriteLine("contains_entity with nil handle incorrect"); } if (dp.ContainsEntity(100)) { Console.WriteLine("contains_entity with incorrect handle incorrect"); } Time currentTime; dp.GetCurrentTime(out currentTime); Console.WriteLine("Current Local Time: {0}", currentTime.ToDatetime().ToLocalTime()); // And look up this DomainParticipant. IDomainParticipant dp2 = dpf.LookupParticipant(null); DomainParticipantQos dp2Qos = null; Console.Write("lookup DomainParticipant: "); Console.WriteLine(dp2 != null ? "Success" : "Fail"); result = dp2.GetQos(ref dp2Qos); Console.WriteLine("DomainParticipant.get_qos: {0}", result); Console.WriteLine("DomainParticipantQos.entity_factory.autoenable_created_entities: " + dp2Qos.EntityFactory.AutoenableCreatedEntities); // Create a new PublisherQos and set some values... PublisherQos publisherQos = new PublisherQos(); publisherQos.EntityFactory.AutoenableCreatedEntities = true; publisherQos.Partition.Name = new string[] { "howdy" }; //, "neighbor", "partition" }; // true not supported in 4.1 ?? publisherQos.Presentation.OrderedAccess = false; // Create the Publisher dp.Enable(); IPublisher publisher = dp.CreatePublisher(publisherQos); Console.WriteLine("Create Publisher: {0}", publisher); //DataWriterQos dwQos; //publisher.GetDefaultDataWriterQos(out dwQos); // Create a Detection Type Support and register it's type Data.DataTestTypeSupport support = new Data.DataTestTypeSupport(); string test2 = support.TypeName; Console.WriteLine("Register Typesupport"); result = support.RegisterType(dp, support.TypeName); Console.WriteLine("Register Typesupport Result: {0}", result); // Create a topic for the Detection type TopicQos topicQos = null; result = dp.GetDefaultTopicQos(ref topicQos); //topicQos.Ownership.Kind = OwnershipQosPolicyKind.ExclusiveOwnershipQos; //DDS.Test.TestTopicQos2(ref topicQos); // Add a listener to the topic ITopic topic = dp.CreateTopic("Data_DataTest", support.TypeName, topicQos, this, StatusKind.InconsistentTopic); topicQos.History.Depth = 5; ITopic topic2 = dp.CreateTopic("Data_DataTest", support.TypeName, topicQos); // ErrorCode errorCode; // string msg; // result = ErrorInfo.Update(); // result = ErrorInfo.GetCode(out errorCode); // result = ErrorInfo.GetMessage(out msg); // Create a DataWriter for the topic Data.IDataTestDataWriter dataWriter = publisher.CreateDataWriter(topic) as Data.IDataTestDataWriter; // Create a SubscriberQos object and set the partition name SubscriberQos subscriberQos = null; result = dp.GetDefaultSubscriberQos(ref subscriberQos); subscriberQos.Partition.Name = new string[] { "howdy" }; // Create the subscriber ISubscriber sub = dp.CreateSubscriber(subscriberQos); // Verify that the subsciber was created... if (sub == null) { Console.WriteLine("Subscriber not created"); return; } DDS.DataReaderQos readerQos = null; sub.GetDefaultDataReaderQos(ref readerQos); //readerQos.SubscriptionKeys.KeyList = new string[] { "test" }; //readerQos.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos; //readerQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; // Create a DataReader for the Detection topic Data.IDataTestDataReader dataReader = sub.CreateDataReader(topic, readerQos, this, StatusKind.DataAvailable) as Data.IDataTestDataReader; // Create a filtered detection topic (only read detections that have an id != 4) IContentFilteredTopic filteredTopic = dp.CreateContentFilteredTopic("Another", topic, "TestId <> %0", "4"); string[] testParams = null; result = filteredTopic.GetExpressionParameters(ref testParams); result = filteredTopic.SetExpressionParameters("hello", "test"); result = filteredTopic.GetExpressionParameters(ref testParams); // Create a DataReader to read the filtered topic IDataReader reader2 = sub.CreateDataReader(filteredTopic); IQueryCondition queryCondition = dataReader.CreateQueryCondition( "TestId = %0", "234"); // just for testing... //GC.Collect(); // WaitSet WaitSet waitSet = new WaitSet(); // either use status conditions...or IStatusCondition sc = reader2.StatusCondition; sc.SetEnabledStatuses(StatusKind.DataAvailable); waitSet.AttachCondition(sc); IStatusCondition sc2 = reader2.StatusCondition; // read conditions... // IReadCondition readCond = reader2.CreateReadCondition(); // waitSet.AttachCondition(readCond); ICondition[] cond = null; //waitSet.Wait(ref cond, Duration.Infinite); Console.WriteLine("Press enter to write data"); Console.ReadLine(); detectionData.SequenceTest = new int[1];// new System.Collections.Generic.List<int>(); //detectionData.SequenceTest.Add(4); detectionData.SequenceTest[0] = 4; // Write detection data result = dataWriter.Write(detectionData); detectionData = new Data.DataTest(); detectionData.TestId = 234; dataWriter.Write(detectionData, InstanceHandle.Nil); detectionData = new Data.DataTest(); detectionData.TestId = 235; dataWriter.Write(detectionData); detectionData = new Data.DataTest(); detectionData.TestId = 236; dataWriter.Write(detectionData); detectionData = new Data.DataTest(); detectionData.TestId = 237; dataWriter.Write(detectionData); Console.WriteLine("Press enter to read data"); Console.ReadLine(); // Read the data SampleInfo[] infos = null; Data.DataTest[] dataValues = null; // result = dataReader.ReadWithCondition(ref dataValues, ref infos, DDS.Length.Unlimited, queryCondition); result = dataReader.Read(ref dataValues, ref infos); Console.WriteLine("dataReader: {0}", dataReader); if (dataValues != null) { Console.WriteLine("Number of samples received: {0}", dataValues.Length); for (int index = 0; index < dataValues.Length; index++) { Console.WriteLine("TestId: {0}, ProviderId: {1}, Emergency: {2}, TestStr: {3}", dataValues[index].TestId, dataValues[index].ProviderId, dataValues[index].Emergency, dataValues[index].TestStr); Console.WriteLine("info: ValidData: {0}, InstHandle: {1}, PubHandle:{2}, SourceTS: {3}, ArrivalTS: {4}, sample: {5}, view: {6}, instance: {7}", infos[index].ValidData, infos[index].InstanceHandle, infos[index].PublicationHandle, infos[index].SourceTimestamp, infos[index].ArrivalTimestamp, infos[index].SampleState, infos[index].ViewState, infos[index].InstanceState); } } Console.WriteLine("Press enter to cleanup"); Console.ReadLine(); Console.WriteLine("DeleteContainedEntities"); result = dp.DeleteContainedEntities(); // If you don't use DeleteContainedEntities then you must delete everything that was created //result = sub.DeleteDataReader(dataReader); //result = publisher.DeleteDataWriter(dataWriter); //result = dp.DeleteTopic(topic); //result = dp.DeletePublisher(publisher); //result = dp.DeleteSubscriber(sub); Console.WriteLine("DeleteParticipant"); result = dpf.DeleteParticipant(dp); Console.WriteLine("Press enter to exit"); Console.ReadLine(); }
public RedisEventBus(IEventStore eventStore, IConnectionMultiplexer connectionMultiplexer, IServiceProvider serviceProvider) { _eventStore = eventStore; _serviceProvider = serviceProvider; _subscriber = connectionMultiplexer.GetSubscriber(); }
/// <summary> /// Redis发布订阅 发布 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="channel"></param> /// <param name="msg"></param> /// <returns></returns> public long Publish <T>(string channel, T msg) { ISubscriber sub = GetConnect().GetSubscriber(); return(sub.Publish(channel, ConvertJson(msg))); }
public static UntypedSubscriber FromTyped <T>(ISubscriber <T> subscriber) { return(new UntypedSubscriberImpl <T>(subscriber)); }
public IAuthenticationProvider BuildAuthenticationProvider(IPublisher mainQueue, ISubscriber mainBus, IPublisher workersQueue, InMemoryBus[] workerBuses, bool logFailedAuthenticationAttempts) { var passwordHashAlgorithm = new Rfc2898PasswordHashAlgorithm(); var dispatcher = new IODispatcher(mainQueue, new PublishEnvelope(workersQueue, crossThread: true)); foreach (var bus in workerBuses) { bus.Subscribe(dispatcher.ForwardReader); bus.Subscribe(dispatcher.BackwardReader); bus.Subscribe(dispatcher.Writer); bus.Subscribe(dispatcher.StreamDeleter); bus.Subscribe(dispatcher.Awaker); bus.Subscribe(dispatcher); } // USER MANAGEMENT var ioDispatcher = new IODispatcher(mainQueue, new PublishEnvelope(mainQueue)); mainBus.Subscribe(ioDispatcher.BackwardReader); mainBus.Subscribe(ioDispatcher.ForwardReader); mainBus.Subscribe(ioDispatcher.Writer); mainBus.Subscribe(ioDispatcher.StreamDeleter); mainBus.Subscribe(ioDispatcher.Awaker); mainBus.Subscribe(ioDispatcher); var userManagement = new UserManagementService(mainQueue, ioDispatcher, passwordHashAlgorithm, skipInitializeStandardUsersCheck: false); mainBus.Subscribe <UserManagementMessage.Create>(userManagement); mainBus.Subscribe <UserManagementMessage.Update>(userManagement); mainBus.Subscribe <UserManagementMessage.Enable>(userManagement); mainBus.Subscribe <UserManagementMessage.Disable>(userManagement); mainBus.Subscribe <UserManagementMessage.Delete>(userManagement); mainBus.Subscribe <UserManagementMessage.ResetPassword>(userManagement); mainBus.Subscribe <UserManagementMessage.ChangePassword>(userManagement); mainBus.Subscribe <UserManagementMessage.Get>(userManagement); mainBus.Subscribe <UserManagementMessage.GetAll>(userManagement); mainBus.Subscribe <SystemMessage.BecomeLeader>(userManagement); mainBus.Subscribe <SystemMessage.BecomeFollower>(userManagement); var provider = new InternalAuthenticationProvider(dispatcher, passwordHashAlgorithm, ESConsts.CachedPrincipalCount, logFailedAuthenticationAttempts); var passwordChangeNotificationReader = new PasswordChangeNotificationReader(mainQueue, dispatcher); mainBus.Subscribe <SystemMessage.SystemStart>(passwordChangeNotificationReader); mainBus.Subscribe <SystemMessage.BecomeShutdown>(passwordChangeNotificationReader); mainBus.Subscribe(provider); return(provider); }
protected void AddConsumer(AbstractConsumerSettings consumerSettings, ISubscriber subscriber, IMessageProcessor <byte[]> messageProcessor) { var consumer = new RedisChannelConsumer(consumerSettings, subscriber, messageProcessor); _consumers.Add(consumer); }
/// <summary> /// 当作消息代理中间件使用 /// 消息组建中,重要的概念便是生产者,消费者,消息中间件。 /// </summary> /// <param name="channel"></param> /// <param name="message"></param> /// <returns></returns> public static long Publish(string channel, string message) { ISubscriber sub = RedisConn.GetInstance().GetSubscriber(); return(sub.Publish(channel, message)); }
protected virtual bool SubscribeInternal(ISubscriber subscriber) { return(!ReferenceEquals(subscriber.Target, this) && InitializeEventAggregator(true) && _localEventAggregator.Subscribe(subscriber)); }
public Subscribe(ISubscriber <T> subscriber) { Subscriber = subscriber; }
public bool Unsubscribe(ISubscriber subscriber) { return(UnsubscribeInternal(subscriber)); }
public TwitterSubscriberTests() { this.mockedConsole = new Mock <IConsole>(); this.mockedSubscriber = new TwitterSubscriber(this.mockedConsole.Object); }
/// <summary> /// Redis发布订阅 取消全部订阅 /// </summary> public void UnsubscribeAll() { ISubscriber sub = GetConnect().GetSubscriber(); sub.UnsubscribeAll(); }
/// <summary> /// Redis发布订阅 取消订阅 /// </summary> /// <param name="channel"></param> public void Unsubscribe(string channel) { ISubscriber sub = GetConnect().GetSubscriber(); sub.Unsubscribe(channel); }
/// <summary> /// 取消订阅 /// </summary> /// <param name="channelFrom"></param> /// <returns></returns> public static void Unsubscribe(string channelFrom) { ISubscriber sub = RedisConn.GetInstance().GetSubscriber(); sub.Unsubscribe(channelFrom); }
protected override bool AroundReceive(Receive receive, object message) { if (message is Request) { var req = (Request)message; if (req.IsProcessed) { // it's an unstashed Request, demand is already handled base.AroundReceive(receive, req); } else { if (req.Count < 1) { if (_lifecycleState == LifecycleState.Active) { OnError(new ArgumentException("Number of requested elements must be positive. Rule 3.9")); } } else { _demand += req.Count; if (_demand < 0) { _demand = long.MaxValue; // long overflow: effectively unbounded } req.MarkProcessed(); base.AroundReceive(receive, message); } } } else if (message is Subscribe <T> ) { var sub = (Subscribe <T>)message; var subscriber = sub.Subscriber; switch (_lifecycleState) { case LifecycleState.PreSubscriber: _scheduledSubscriptionTimeout.Cancel(); _subscriber = subscriber; _lifecycleState = LifecycleState.Active; ReactiveStreamsCompliance.TryOnSubscribe(subscriber, new ActorPublisherSubscription(Self)); break; case LifecycleState.ErrorEmitted: if (_onError.Stop) { Context.Stop(Self); } ReactiveStreamsCompliance.TryOnSubscribe(subscriber, CancelledSubscription.Instance); ReactiveStreamsCompliance.TryOnError(subscriber, _onError.Cause); break; case LifecycleState.Completed: ReactiveStreamsCompliance.TryOnSubscribe(subscriber, CancelledSubscription.Instance); ReactiveStreamsCompliance.TryOnComplete(subscriber); break; case LifecycleState.CompleteThenStop: Context.Stop(Self); ReactiveStreamsCompliance.TryOnSubscribe(subscriber, CancelledSubscription.Instance); ReactiveStreamsCompliance.TryOnComplete(subscriber); break; case LifecycleState.Active: case LifecycleState.Canceled: ReactiveStreamsCompliance.TryOnSubscribe(subscriber, CancelledSubscription.Instance); ReactiveStreamsCompliance.TryOnError(subscriber, _subscriber == subscriber ? new IllegalStateException("Cannot subscribe the same subscriber multiple times") : new IllegalStateException("Only supports one subscriber")); break; } } else if (message is Cancel) { if (_lifecycleState != LifecycleState.Canceled) { // possible to receive again in case of stash CancelSelf(); base.AroundReceive(receive, message); } } else if (message is SubscriptionTimeoutExceeded) { if (!_scheduledSubscriptionTimeout.IsCancellationRequested) { CancelSelf(); base.AroundReceive(receive, message); } } else { return(base.AroundReceive(receive, message)); } return(true); }