public SendResult RouteRequest(IRequestMessage message, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0)
{
return(NetworkSendService.TryRouteMessage(message, deliveryMethod, encrypt, channel));
}
public SendResult SendRequest(PacketPayload payload, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0)
{
return(NetworkSendService.TrySendMessage(OperationType.Request, payload, deliveryMethod, encrypt, channel));
}
/// <summary>
/// Sends a networked request.
/// Additionally this message/payloadtype is known to have static send parameters and those will be used in transit.
/// </summary>
/// <typeparam name="TPacketType">Type of the packet payload.</typeparam>
/// <param name="payload">Payload instance to be sent in the message that contains static message parameters.</param>
/// <returns>Indication of the message send state.</returns>
public SendResult SendRequest <TPacketType>(TPacketType payload)
where TPacketType : PacketPayload, IStaticPayloadParameters
{
return(NetworkSendService.TrySendMessage(OperationType.Request, payload));
}
public SingleVNode(TFChunkDb db,
SingleVNodeSettings vNodeSettings,
bool dbVerifyHashes,
int memTableEntryCount = ESConsts.MemTableEntryCount)
{
Ensure.NotNull(db, "db");
Ensure.NotNull(vNodeSettings, "vNodeSettings");
db.OpenVerifyAndClean(dbVerifyHashes);
_tcpEndPoint = vNodeSettings.ExternalTcpEndPoint;
_httpEndPoint = vNodeSettings.ExternalHttpEndPoint;
_mainBus = new InMemoryBus("MainBus");
_controller = new SingleVNodeController(Bus, _httpEndPoint);
_mainQueue = new QueuedHandler(_controller, "MainQueue");
_controller.SetMainQueue(MainQueue);
//MONITORING
var monitoringInnerBus = new InMemoryBus("MonitoringInnerBus", watchSlowMsg: false);
var monitoringRequestBus = new InMemoryBus("MonitoringRequestBus", watchSlowMsg: false);
var monitoringQueue = new QueuedHandler(monitoringInnerBus, "MonitoringQueue", true, TimeSpan.FromMilliseconds(100));
var monitoring = new MonitoringService(monitoringQueue,
monitoringRequestBus,
MainQueue,
db.Config.WriterCheckpoint,
db.Config.Path,
vNodeSettings.StatsPeriod,
_httpEndPoint,
vNodeSettings.StatsStorage);
Bus.Subscribe(monitoringQueue.WidenFrom<SystemMessage.SystemInit, Message>());
Bus.Subscribe(monitoringQueue.WidenFrom<SystemMessage.StateChangeMessage, Message>());
Bus.Subscribe(monitoringQueue.WidenFrom<SystemMessage.BecomeShuttingDown, Message>());
Bus.Subscribe(monitoringQueue.WidenFrom<ClientMessage.CreateStreamCompleted, Message>());
monitoringInnerBus.Subscribe<SystemMessage.SystemInit>(monitoring);
monitoringInnerBus.Subscribe<SystemMessage.StateChangeMessage>(monitoring);
monitoringInnerBus.Subscribe<SystemMessage.BecomeShuttingDown>(monitoring);
monitoringInnerBus.Subscribe<ClientMessage.CreateStreamCompleted>(monitoring);
monitoringInnerBus.Subscribe<MonitoringMessage.GetFreshStats>(monitoring);
//STORAGE SUBSYSTEM
var indexPath = Path.Combine(db.Config.Path, "index");
var tableIndex = new TableIndex(indexPath,
() => new HashListMemTable(maxSize: memTableEntryCount * 2),
maxSizeForMemory: memTableEntryCount,
maxTablesPerLevel: 2);
var readIndex = new ReadIndex(_mainQueue,
ESConsts.ReadIndexReaderCount,
() => new TFChunkSequentialReader(db, db.Config.WriterCheckpoint, 0),
() => new TFChunkReader(db, db.Config.WriterCheckpoint),
tableIndex,
new XXHashUnsafe(),
new LRUCache<string, StreamCacheInfo>(ESConsts.MetadataCacheCapacity));
var writer = new TFChunkWriter(db);
new StorageWriterService(_mainQueue, _mainBus, writer, readIndex); // subscribes internally
var storageReader = new StorageReaderService(_mainQueue, _mainBus, readIndex, ESConsts.StorageReaderHandlerCount, db.Config.WriterCheckpoint);
_mainBus.Subscribe<SystemMessage.SystemInit>(storageReader);
_mainBus.Subscribe<SystemMessage.BecomeShuttingDown>(storageReader);
_mainBus.Subscribe<SystemMessage.BecomeShutdown>(storageReader);
monitoringRequestBus.Subscribe<MonitoringMessage.InternalStatsRequest>(storageReader);
var chaser = new TFChunkChaser(db, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint);
var storageChaser = new StorageChaser(_mainQueue, db.Config.WriterCheckpoint, chaser, readIndex, _tcpEndPoint);
_mainBus.Subscribe<SystemMessage.SystemInit>(storageChaser);
_mainBus.Subscribe<SystemMessage.SystemStart>(storageChaser);
_mainBus.Subscribe<SystemMessage.BecomeShuttingDown>(storageChaser);
var storageScavenger = new StorageScavenger(db, readIndex);
_mainBus.Subscribe<SystemMessage.ScavengeDatabase>(storageScavenger);
// NETWORK SEND
_networkSendService = new NetworkSendService(tcpQueueCount: vNodeSettings.TcpSendingThreads, httpQueueCount: vNodeSettings.HttpSendingThreads);
//TCP
var tcpService = new TcpService(MainQueue, _tcpEndPoint, _networkSendService);
Bus.Subscribe<SystemMessage.SystemInit>(tcpService);
Bus.Subscribe<SystemMessage.SystemStart>(tcpService);
Bus.Subscribe<SystemMessage.BecomeShuttingDown>(tcpService);
//HTTP
_httpService = new HttpService(ServiceAccessibility.Private, MainQueue, vNodeSettings.HttpReceivingThreads, vNodeSettings.HttpPrefixes);
Bus.Subscribe<SystemMessage.SystemInit>(HttpService);
Bus.Subscribe<SystemMessage.BecomeShuttingDown>(HttpService);
Bus.Subscribe<HttpMessage.SendOverHttp>(HttpService);
Bus.Subscribe<HttpMessage.PurgeTimedOutRequests>(HttpService);
HttpService.SetupController(new AdminController(MainQueue));
HttpService.SetupController(new PingController());
HttpService.SetupController(new StatController(monitoringQueue, _networkSendService));
HttpService.SetupController(new ReadEventDataController(MainQueue, _networkSendService));
HttpService.SetupController(new AtomController(MainQueue, _networkSendService));
HttpService.SetupController(new WebSiteController(MainQueue));
//REQUEST MANAGEMENT
var requestManagement = new RequestManagementService(MainQueue, 1, 1);
Bus.Subscribe<StorageMessage.CreateStreamRequestCreated>(requestManagement);
Bus.Subscribe<StorageMessage.WriteRequestCreated>(requestManagement);
Bus.Subscribe<StorageMessage.TransactionStartRequestCreated>(requestManagement);
Bus.Subscribe<StorageMessage.TransactionWriteRequestCreated>(requestManagement);
Bus.Subscribe<StorageMessage.TransactionCommitRequestCreated>(requestManagement);
Bus.Subscribe<StorageMessage.DeleteStreamRequestCreated>(requestManagement);
Bus.Subscribe<StorageMessage.RequestCompleted>(requestManagement);
Bus.Subscribe<StorageMessage.AlreadyCommitted>(requestManagement);
Bus.Subscribe<StorageMessage.CommitAck>(requestManagement);
Bus.Subscribe<StorageMessage.PrepareAck>(requestManagement);
Bus.Subscribe<StorageMessage.WrongExpectedVersion>(requestManagement);
Bus.Subscribe<StorageMessage.InvalidTransaction>(requestManagement);
Bus.Subscribe<StorageMessage.StreamDeleted>(requestManagement);
Bus.Subscribe<StorageMessage.PreparePhaseTimeout>(requestManagement);
Bus.Subscribe<StorageMessage.CommitPhaseTimeout>(requestManagement);
new SubscriptionsService(_mainBus, readIndex); // subcribes internally
//TIMER
_timerService = new TimerService(new ThreadBasedScheduler(new RealTimeProvider()));
Bus.Subscribe<TimerMessage.Schedule>(TimerService);
monitoringQueue.Start();
MainQueue.Start();
}
