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