static async Task Main(string[] args) { //TrinityConfig.LoadConfig(); //TrinityConfig.CurrentRunningMode = RunningMode.Client; //TrinityConfig.LogEchoOnConsole = false; TrinityConfig.LoggingLevel = LogLevel.Debug; //TrinityConfig.SaveConfig(); //Log.LogsWritten += Log_LogsWritten; //TrinityTripleModuleClient = new TrinityClient("testcluster100.southcentralus.cloudapp.azure.com:8800"); TrinityTripleModuleClient = new TrinityClient("GenNexusPrime.inknowworksdev.net:12333"); //TrinityTripleModuleClient = new TrinityClient("truesparksf01.inknowworksdev.net:8808"); // truesparksf03.inknowworksdev.net:8808 TrinityTripleModuleClient.UnhandledException += TrinityTripleModuleClient_UnhandledException; TrinityTripleModuleClient.Started += TrinityTripleModuleClientOnStarted; TrinityTripleModuleClient.RegisterCommunicationModule <TripleModule>(); TrinityTripleModuleClient.Start(); Log.WriteLine("Setup Reactive Event Stream Processing!"); TripleClientSideModule = TrinityTripleModuleClient.GetCommunicationModule <TripleModule>(); TripleClientSideModule.TripleBySubjectReceivedAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TripleBySubjectReceivedAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async tripleStore => { using var reactiveGetTripleBySubjectTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine( "Reactive Async - Parallel-Tasking return from Server-Side Get Request on behalf of the Client."); Log.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Object CellID: {tripleStore.CellId}."); Log.WriteLine($"Triple Subject Node: {tripleStore.TripleCell.Subject}"); Log.WriteLine( $"Triple Predicate Node: {tripleStore.TripleCell.Predicate}"); Log.WriteLine($"Triple Object Node: {tripleStore.TripleCell.Object}."); var getTripleByCellRequestWriter = new TripleGetRequestWriter() { TripleCellId = tripleStore.CellId, Subject = tripleStore.TripleCell.Subject, Predicate = tripleStore.TripleCell.Predicate, Object = tripleStore.TripleCell.Object, Namespace = tripleStore.TripleCell.Namespace }; await TrinityTripleModuleClient.GetTripleSubject(getTripleByCellRequestWriter); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task TripleObjectStreamedFromServerReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = reactiveGetTripleBySubjectTask; await writeToConsoleTask; }); // TripleObjectStreamedFromServerReceivedAction TripleClientSideModule.TripleObjectStreamedFromServerReceivedAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TripleObjectStreamedFromServerReceivedAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async tripleObjectFromServer => { using var reactiveGraphEngineResponseTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Incoming Triple Object Received from GE Server."); Log.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Subject Node: {tripleObjectFromServer.Subject}"); Log.WriteLine($"Triple Predicate Node: {tripleObjectFromServer.Predicate}"); Log.WriteLine($"Triple Object Node: {tripleObjectFromServer.Object}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task TripleObjectStreamedFromServerReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = reactiveGraphEngineResponseTask; await writeToConsoleTask; }); // ServerStreamedTripleSavedToMemoryCloudAction TripleClientSideModule.ServerStreamedTripleSavedToMemoryCloudAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ServerStreamedTripleSavedToMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async tripleObjectFromMC => { using var reactiveGraphEngineResponseTask = Task.Factory.StartNew(async() => { await Task.Delay(0).ConfigureAwait(false); var myTripleStore = tripleObjectFromMC.NewTripleStore; Log.WriteLine("Incoming TripleStore Object retrieved from MemoryCloud."); Log.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Object CellID: {myTripleStore.CellId}"); Log.WriteLine($"Triple Subject Node: {myTripleStore.TripleCell.Subject}"); Log.WriteLine($"Triple Predicate Node: {myTripleStore.TripleCell.Predicate}"); Log.WriteLine($"Triple Object Node: {myTripleStore.TripleCell.Object}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task ServerStreamedTripleSavedToMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = reactiveGraphEngineResponseTask; await writeToConsoleTask; }); // ClientPostedTripleStoreReadyInMemoryCloudAction TripleClientSideModule.ClientPostedTripleStoreReadyInMemoryCloudAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleStoreReadyInMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleObject => { using var getTripleByCellIdTask = Task.Factory.StartNew(async() => { // await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); using var getRequest = new TripleGetRequestWriter() { TripleCellId = tripleObject.CellId, Subject = tripleObject.TripleCell.Subject, Predicate = tripleObject.TripleCell.Predicate, Namespace = tripleObject.TripleCell.Namespace, Object = tripleObject.TripleCell.Object }; await TrinityTripleModuleClient.GetTripleByCellId(getRequest); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task ClientPostedTripleStoreReadyInMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleByCellIdTask; await writeToConsoleTask; }); // Reactive: ClientPostedTripleStoreReadyInMemoryCloudHotAction TripleClientSideModule.ClientPostedTripleStoreReadyInMemoryCloudHotAction .ObserveOn(TripleClientSideModule.HotObservableSchedulerContext) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleStoreReadyInMemoryCloudHotAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.HotObservableSchedulerContext) .Synchronize() .Subscribe(onNext: async tripleObject => { using var getTripleByCellIdTask = Task.Factory.StartNew(async() => { // await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Reactive Event Stream Processing from Hot Observable"); using var getRequest = new TripleGetRequestWriter() { TripleCellId = tripleObject.CellId, Subject = tripleObject.TripleCell.Subject, Predicate = tripleObject.TripleCell.Predicate, Namespace = tripleObject.TripleCell.Namespace, Object = tripleObject.TripleCell.Object }; await TrinityTripleModuleClient.GetTripleByCellId(getRequest); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task ClientPostedTripleStoreReadyInMemoryCloudHotAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleByCellIdTask; await writeToConsoleTask; }); TripleClientSideModule.ClientPostedTripleStoreReadyInMemoryCloudHotAction.Connect(); TripleClientSideModule.TripleByCellIdReceivedAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TripleByCellIdReceivedAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleObjectFromGetRequest => { using var getTripleBySubjectTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine( "Reactive Async - Server-Side Get Request on behalf of the Client."); Log.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Object CellID: {tripleObjectFromGetRequest.CellId}."); Log.WriteLine( $"Triple Subject Node: {tripleObjectFromGetRequest.TripleCell.Subject}"); Log.WriteLine( $"Triple Predicate Node: {tripleObjectFromGetRequest.TripleCell.Predicate}"); Log.WriteLine( $"Triple Object Node: {tripleObjectFromGetRequest.TripleCell.Object}."); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task TripleByCellIdReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleBySubjectTask; await writeToConsoleTask; }); TripleClientSideModule.ClientPostedTripleSavedToMemoryCloudAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleSavedToMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleStoreMemoryContext => { using var reactToTriplePostedSavedToMemoryCloudTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Success! Found the Triple in the TripleStore MemoryCloud"); var tripleStore = tripleStoreMemoryContext.NewTripleStore; var subjectNode = tripleStore.TripleCell.Subject; var predicateNode = tripleStore.TripleCell.Predicate; var objectNode = tripleStore.TripleCell.Object; Log.WriteLine($"Triple CellId in MemoryCloud: {tripleStoreMemoryContext.NewTripleStore.CellId}"); Log.WriteLine($"Subject Node: {subjectNode}"); Log.WriteLine($"Predicate Node: {predicateNode}"); Log.WriteLine($"Object Node: {objectNode}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task ClientPostedTripleSavedToMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var storeFromMemoryCloudTask = reactToTriplePostedSavedToMemoryCloudTask; await storeFromMemoryCloudTask; }); //Log.WriteLine($"Please press the enter to continue!"); //Log.ReadLine(); // Prevents this host process from terminating so services keep running. //Thread.Sleep(Timeout.Infinite); // Main Processing Loop! using var trinityClientProcessingLoopTask = Task.Factory.StartNew(async() => { while (true) { try { //await Task.Yield(); var sampleTriple = new List <Triple> { new Triple { Subject = "Test-GraphEngineClient", Predicate = "is", Object = "Running" } }; using var tripleStreamWriter = new TripleStreamWriter(sampleTriple); await TrinityTripleModuleClient.PostTriplesToServer(tripleStreamWriter).ConfigureAwait(false); } catch (Exception ex) { Log.WriteLine(ex.ToString()); } await Task.Delay(0).ConfigureAwait(false); } /* * return; */ }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap(); var mainLoopTask = trinityClientProcessingLoopTask; await mainLoopTask; }
void TrinityTripleModuleClientStarted() { Log.WriteLine("Setup Reactive Event Stream Processing!"); TripleClientSideModule = TrinityTripleModuleClient.GetCommunicationModule <TripleModule>(); TripleClientSideModule.TripleBySubjectReceivedAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TripleBySubjectReceivedAction-1"; Console.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async tripleStore => { using var reactiveGetTripleBySubjectTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Console.WriteLine( "Reactive Async - Parallel-Tasking return from Server-Side Get Request on behalf of the Client."); Console.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Console.WriteLine($"Triple Object CellID: {tripleStore.CellId}."); Console.WriteLine($"Triple Subject Node: {tripleStore.TripleCell.Subject}"); Console.WriteLine( $"Triple Predicate Node: {tripleStore.TripleCell.Predicate}"); Console.WriteLine($"Triple Object Node: {tripleStore.TripleCell.Object}."); var getTripleByCellRequestWriter = new TripleGetRequestWriter() { TripleCellId = tripleStore.CellId, Subject = tripleStore.TripleCell.Subject, Predicate = tripleStore.TripleCell.Predicate, Object = tripleStore.TripleCell.Object, Namespace = tripleStore.TripleCell.Namespace }; await TrinityTripleModuleClient.GetTripleSubject(getTripleByCellRequestWriter); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Console.WriteLine("Task TripleObjectStreamedFromServerReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = reactiveGetTripleBySubjectTask; await writeToConsoleTask; }); // TripleObjectStreamedFromServerReceivedAction TripleClientSideModule.TripleObjectStreamedFromServerReceivedAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TripleObjectStreamedFromServerReceivedAction-1"; Console.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async tripleObjectFromServer => { using var reactiveGraphEngineResponseTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Console.WriteLine("Incoming Triple Object Received from GE Server."); Console.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Console.WriteLine($"Triple Subject Node: {tripleObjectFromServer.Subject}"); Console.WriteLine($"Triple Predicate Node: {tripleObjectFromServer.Predicate}"); Console.WriteLine($"Triple Object Node: {tripleObjectFromServer.Object}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Console.WriteLine("Task TripleObjectStreamedFromServerReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = reactiveGraphEngineResponseTask; await writeToConsoleTask; }); // ServerStreamedTripleSavedToMemoryCloudAction TripleClientSideModule.ServerStreamedTripleSavedToMemoryCloudAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ServerStreamedTripleSavedToMemoryCloudAction-1"; Console.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async tripleObjectFromMC => { using var reactiveGraphEngineResponseTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); var myTripleStore = tripleObjectFromMC.NewTripleStore; Console.WriteLine("Incoming TripleStore Object retrieved from MemoryCloud."); Console.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Console.WriteLine($"Triple Object CellID: {myTripleStore.CellId}"); Console.WriteLine($"Triple Subject Node: {myTripleStore.TripleCell.Subject}"); Console.WriteLine($"Triple Predicate Node: {myTripleStore.TripleCell.Predicate}"); Console.WriteLine($"Triple Object Node: {myTripleStore.TripleCell.Object}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Console.WriteLine("Task ServerStreamedTripleSavedToMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = reactiveGraphEngineResponseTask; await writeToConsoleTask; }); // ClientPostedTripleStoreReadyInMemoryCloudAction TripleClientSideModule.ClientPostedTripleStoreReadyInMemoryCloudAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleStoreReadyInMemoryCloudAction-1"; Console.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleObject => { using var getTripleByCellIdTask = Task.Factory.StartNew(async() => { // await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); using var getRequest = new TripleGetRequestWriter() { TripleCellId = tripleObject.CellId, Subject = tripleObject.TripleCell.Subject, Predicate = tripleObject.TripleCell.Predicate, Namespace = tripleObject.TripleCell.Namespace, Object = tripleObject.TripleCell.Object }; await TrinityTripleModuleClient.GetTripleByCellId(getRequest); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Console.WriteLine("Task ClientPostedTripleStoreReadyInMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleByCellIdTask; await writeToConsoleTask; }); // Reactive: ClientPostedTripleStoreReadyInMemoryCloudHotAction TripleClientSideModule.ClientPostedTripleStoreReadyInMemoryCloudHotAction .ObserveOn(TripleClientSideModule.HotObservableSchedulerContext) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleStoreReadyInMemoryCloudHotAction-1"; Console.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.HotObservableSchedulerContext) .Synchronize() .Subscribe(onNext: async tripleObject => { using var getTripleByCellIdTask = Task.Factory.StartNew(async() => { // await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Console.WriteLine("Reactive Event Stream Processing from Hot Observable"); using var getRequest = new TripleGetRequestWriter() { TripleCellId = tripleObject.CellId, Subject = tripleObject.TripleCell.Subject, Predicate = tripleObject.TripleCell.Predicate, Namespace = tripleObject.TripleCell.Namespace, Object = tripleObject.TripleCell.Object }; await TrinityTripleModuleClient.GetTripleByCellId(getRequest); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Console.WriteLine("Task ClientPostedTripleStoreReadyInMemoryCloudHotAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleByCellIdTask; await writeToConsoleTask; }); TripleClientSideModule.ClientPostedTripleStoreReadyInMemoryCloudHotAction.Connect(); TripleClientSideModule.TripleByCellIdReceivedAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TripleByCellIdReceivedAction-1"; Console.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleObjectFromGetRequest => { using var getTripleBySubjectTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Console.WriteLine( "Reactive Async - Server-Side Get Request on behalf of the Client."); Console.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Console.WriteLine($"Triple Object CellID: {tripleObjectFromGetRequest.CellId}."); Console.WriteLine( $"Triple Subject Node: {tripleObjectFromGetRequest.TripleCell.Subject}"); Console.WriteLine( $"Triple Predicate Node: {tripleObjectFromGetRequest.TripleCell.Predicate}"); Console.WriteLine( $"Triple Object Node: {tripleObjectFromGetRequest.TripleCell.Object}."); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Console.WriteLine("Task TripleByCellIdReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleBySubjectTask; await writeToConsoleTask; }); TripleClientSideModule.ClientPostedTripleSavedToMemoryCloudAction .ObserveOn(TripleClientSideModule.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleSavedToMemoryCloudAction-1"; Console.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(TripleClientSideModule.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleStoreMemoryContext => { using var reactToTriplePostedSavedToMemoryCloudTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Console.WriteLine("Success! Found the Triple in the TripleStore MemoryCloud"); var tripleStore = tripleStoreMemoryContext.NewTripleStore; var subjectNode = tripleStore.TripleCell.Subject; var predicateNode = tripleStore.TripleCell.Predicate; var objectNode = tripleStore.TripleCell.Object; Console.WriteLine($"Triple CellId in MemoryCloud: {tripleStoreMemoryContext.NewTripleStore.CellId}"); Console.WriteLine($"Subject Node: {subjectNode}"); Console.WriteLine($"Predicate Node: {predicateNode}"); Console.WriteLine($"Object Node: {objectNode}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Console.WriteLine("Task ClientPostedTripleSavedToMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var storeFromMemoryCloudTask = reactToTriplePostedSavedToMemoryCloudTask; await storeFromMemoryCloudTask; }); }
/// <summary> /// /// </summary> private static void TripleStoreServer_Started() { if (TripleStoreServer != null) { //Global.LocalStorage.LoadStorage(); TripleStoreServer.RegisterCommunicationModule <TrinityClientModule>(); TripleStoreServer.RegisterCommunicationModule <TripleModule>(); GraphEngineTripleClientAPI = TripleStoreServer.GetCommunicationModule <TrinityClientModule>(); // We inject an instance of the TripleModule class object so that we hook-up to our custom sever-side code GraphEngineTripleServerAPI = TripleStoreServer.GetCommunicationModule <TripleModule>(); } if (GraphEngineTripleServerAPI != null) { Log.WriteLine("Setup Reactive Event Stream Processing!"); GraphEngineTripleServerAPI.TriplePostedToServerReceivedAction .ObserveOn(GraphEngineTripleServerAPI.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TriplePostedToServerReceivedAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async tripleFromClient => { using var graphEngineResponseTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Received from Client has been saved Received."); Log.WriteLine($"Triple Subject Node: {tripleFromClient.Subject}"); Log.WriteLine($"Triple Predicate Node: {tripleFromClient.Predicate}"); Log.WriteLine($"Triple Object Node: {tripleFromClient.Object}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); var msg = "TriplePostedToServerReceivedAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); Log.WriteLine("Task TriplePostedToServerReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = graphEngineResponseTask; await writeToConsoleTask; }); GraphEngineTripleServerAPI.ServerStreamedTripleSavedToMemoryCloudAction .ObserveOn(GraphEngineTripleServerAPI.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ServerStreamedTripleSavedToMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async savedTriple => { using var graphEngineResponseTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Streamed to Pushed Client has been saved to MemoryCloud."); Log.WriteLine($"TripleStore CellID: {savedTriple.NewTripleStore.CellId}"); Log.WriteLine($"Triple Subject Node: {savedTriple.NewTripleStore.TripleCell.Subject}"); Log.WriteLine( $"Triple Predicate Node: {savedTriple.NewTripleStore.TripleCell.Predicate}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task ServerStreamedTripleSavedToMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = graphEngineResponseTask; await writeToConsoleTask; }); // ClientPostedTripleStoreReadyInMemoryCloudAction GraphEngineTripleServerAPI.ClientPostedTripleStoreReadyInMemoryCloudAction .ObserveOn(GraphEngineTripleServerAPI.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleStoreReadyInMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleObject => { using var getTripleByCellIdTask = Task.Factory.StartNew(async() => { //var t = Global.CloudStorage.IsLocalCell(tripleObject.CellId); // await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); using var getRequest = new TripleGetRequestWriter() { TripleCellId = tripleObject.CellId, Subject = tripleObject.TripleCell.Subject, Predicate = tripleObject.TripleCell.Predicate, Namespace = tripleObject.TripleCell.Namespace, Object = tripleObject.TripleCell.Object }; await GraphEngineTripleServerAPI.GetTripleByCellId(0, getRequest).ConfigureAwait(false); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task ClientPostedTripleStoreReadyInMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleByCellIdTask; await writeToConsoleTask; }); // Reactive: ClientPostedTripleStoreReadyInMemoryCloudHotAction GraphEngineTripleServerAPI.ClientPostedTripleStoreReadyInMemoryCloudHotAction .ObserveOn(GraphEngineTripleServerAPI.HotObservableSchedulerContext) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleStoreReadyInMemoryCloudHotAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.HotObservableSchedulerContext) .Synchronize() .Subscribe(onNext: async tripleObject => { using var getTripleByCellIdTask = Task.Factory.StartNew(async() => { // await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); using var getRequest = new TripleGetRequestWriter() { TripleCellId = tripleObject.CellId, Subject = tripleObject.TripleCell.Subject, Predicate = tripleObject.TripleCell.Predicate, Namespace = tripleObject.TripleCell.Namespace, Object = tripleObject.TripleCell.Object }; await GraphEngineTripleServerAPI.GetTripleByCellId(0, getRequest).ConfigureAwait(false); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task ClientPostedTripleStoreReadyInMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleByCellIdTask; await writeToConsoleTask; }); // Let's get hooked-up to the host observable GraphEngineTripleServerAPI.ClientPostedTripleStoreReadyInMemoryCloudHotAction.Connect(); GraphEngineTripleServerAPI.TripleByCellIdReceivedAction .ObserveOn(GraphEngineTripleServerAPI.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TripleByCellIdReceivedAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleObjectFromGetRequest => { using var getTripleBySubjectTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine( "Reactive Async - Parallel-Tasking return from Server-Side Get Request on behalf of the Client."); Log.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Object CellID: {tripleObjectFromGetRequest.CellId}."); Log.WriteLine( $"Triple Subject Node: {tripleObjectFromGetRequest.TripleCell.Subject}"); Log.WriteLine( $"Triple Predicate Node: {tripleObjectFromGetRequest.TripleCell.Predicate}"); Log.WriteLine( $"Triple Object Node: {tripleObjectFromGetRequest.TripleCell.Object}."); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Console.WriteLine("Task TripleByCellIdReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleBySubjectTask; await writeToConsoleTask; }); GraphEngineTripleServerAPI.ClientPostedTripleSavedToMemoryCloudAction .ObserveOn(GraphEngineTripleServerAPI.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleSavedToMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleStoreMemoryContext => { using var reactToTriplePostedSavedToMemoryCloudTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Success! Found the Triple in the TripleStore MemoryCloud"); var tripleStore = tripleStoreMemoryContext.NewTripleStore; var subjectNode = tripleStore.TripleCell.Subject; var predicateNode = tripleStore.TripleCell.Predicate; var objectNode = tripleStore.TripleCell.Object; Log.WriteLine( $"Triple CellId in MemoryCloud: {tripleStoreMemoryContext.NewTripleStore.CellId}"); Log.WriteLine($"Subject Node: {subjectNode}"); Log.WriteLine($"Predicate Node: {predicateNode}"); Log.WriteLine($"Object Node: {objectNode}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Console.WriteLine("Task ClientPostedTripleSavedToMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var storeFromMemoryCloudTask = reactToTriplePostedSavedToMemoryCloudTask; await storeFromMemoryCloudTask; }); } }
private static async Task Main(string[] args) { TrinityConfig.LoadConfig(@"D:\Trinity TripleStore Server Deployment\trinity.xml"); //graphEngineCluster = new AvailabilityGroup() //{ // Id = "rub-truespark-ge-cluster", // Instances = new List<ServerInfo>() // { // new ServerInfo("GenNexusPrime.inknowworks.dev.net", 9888, string.Empty, LogLevel.Verbose), // new ServerInfo("metagengraph-a.inknowworks.dev.net", 9888, string.Empty, LogLevel.Verbose), // new ServerInfo("metagengraph-b.inknowworks.dev.net", 9888, string.Empty, LogLevel.Verbose) // //new ServerInfo("truesparksf03.inknowworks.dev.net", 7808, string.Empty, LogLevel.Verbose), // //new ServerInfo("truesparksf04.inknowworks.dev.net", 7808, string.Empty, LogLevel.Verbose), // //new ServerInfo("truesparksf05.inknowworks.dev.net", 7808, string.Empty, LogLevel.Verbose) // } //}; TrinityConfig.LoggingLevel = LogLevel.Debug; //TrinityConfig.Servers.Add(graphEngineCluster); //TrinityConfig.CurrentRunningMode = RunningMode.Server; //TrinityConfig.AddServer(TripleStoreServerInfo); //TrinityConfig.LogEchoOnConsole = true; //TrinityConfig.StorageRoot = TripleStoreStorageRoot; //Log.LogsWritten += Log_LogsWritten; TripleStoreServer = new TrinityServer(); var registeredModuleTypes = TripleStoreServer.GetRegisteredCommunicationModuleTypes(); var moduleTypes = registeredModuleTypes as Type[] ?? registeredModuleTypes.ToArray(); if (!moduleTypes.Contains(typeof(TrinityClientModule))) { TripleStoreServer.RegisterCommunicationModule <TrinityClientModule>(); } if (!moduleTypes.Contains(typeof(TripleModule))) { TripleStoreServer.RegisterCommunicationModule <TripleModule>(); } //TripleStoreServer.Started += TripleStoreServer_Started; //TripleStoreServer.RegisterCommunicationModule<TripleStoreDemoServerModule>(); TripleStoreServer.Start(); //Global.CloudStorage.ResetStorage(); //Global.LocalStorage.ResetStorage(); //Global.LocalStorage.LoadStorage(); GraphEngineTripleClientAPI = TripleStoreServer.GetCommunicationModule <TrinityClientModule>(); // We inject an instance of the TripleModule class object so that we hook-up to our custom sever-side code GraphEngineTripleServerAPI = TripleStoreServer.GetCommunicationModule <TripleModule>(); if (GraphEngineTripleServerAPI != null) { Log.WriteLine("Setup Reactive Event Stream Processing!"); GraphEngineTripleServerAPI.TriplePostedToServerReceivedAction .ObserveOn(GraphEngineTripleServerAPI.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TriplePostedToServerReceivedAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async tripleFromClient => { using var graphEngineResponseTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine($"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Received from Client has been saved Received."); Log.WriteLine($"Triple Subject Node : {tripleFromClient.Subject}"); Log.WriteLine($"Triple Predicate Node: {tripleFromClient.Predicate}"); Log.WriteLine($"Triple Object Node : {tripleFromClient.Object}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task TriplePostedToServerReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = graphEngineResponseTask; await writeToConsoleTask; }); // Reactive Event: ServerStreamedTripleSavedToMemoryCloudAction // Description: Setup Reactive Subscription on Cold Observable. Logic is trigger/executed whenever // a client call RPC Method "PostTripleToServer." GraphEngineTripleServerAPI.ServerStreamedTripleSavedToMemoryCloudAction .ObserveOn(GraphEngineTripleServerAPI.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ServerStreamedTripleSavedToMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async savedTriple => { using var graphEngineResponseTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine($"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Streamed to Pushed Client has been saved to MemoryCloud."); Log.WriteLine($"TripleStore CellID : {savedTriple.NewTripleStore.CellId}"); Log.WriteLine($"Triple Subject Node : {savedTriple.NewTripleStore.TripleCell.Subject}"); Log.WriteLine($"Triple Predicate Node: {savedTriple.NewTripleStore.TripleCell.Predicate}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Task ServerStreamedTripleSavedToMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = graphEngineResponseTask; await writeToConsoleTask; }); // ClientPostedTripleStoreReadyInMemoryCloudAction GraphEngineTripleServerAPI.ClientPostedTripleStoreReadyInMemoryCloudAction .ObserveOn(GraphEngineTripleServerAPI.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleStoreReadyInMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleObject => { using var getTripleByCellIdTask = Task.Factory.StartNew(async() => { // await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); var isLocalCell = Global.CloudStorage.IsLocalCell(tripleObject.CellId); if (isLocalCell) { Log.WriteLine($"Found TripleStore Object: {tripleObject.CellId} in Local MemoryCloud!"); using var getRequest = new TripleGetRequestWriter() { TripleCellId = tripleObject.CellId, Subject = tripleObject.TripleCell.Subject, Predicate = tripleObject.TripleCell.Predicate, Namespace = tripleObject.TripleCell.Namespace, Object = tripleObject.TripleCell.Object }; Log.WriteLine($"Make Client-Side call from Server-side: GetTripleByCellId."); await GraphEngineTripleServerAPI.GetTripleByCellId(0, getRequest).ConfigureAwait(false); } }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Task ClientPostedTripleStoreReadyInMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleByCellIdTask; await writeToConsoleTask; }); // Reactive: ClientPostedTripleStoreReadyInMemoryCloudHotAction GraphEngineTripleServerAPI.ClientPostedTripleStoreReadyInMemoryCloudHotAction .ObserveOn(GraphEngineTripleServerAPI.HotObservableSchedulerContext) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleStoreReadyInMemoryCloudHotAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.HotObservableSchedulerContext) .Synchronize() .Subscribe(onNext: async tripleObject => { using var getTripleByCellIdTask = Task.Factory.StartNew(async() => { // await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); //using var getRequest = new TripleGetRequestWriter() //{ // TripleCellId = tripleObject.CellId, // Subject = tripleObject.TripleCell.Subject, // Predicate = tripleObject.TripleCell.Predicate, // Namespace = tripleObject.TripleCell.Namespace, // Object = tripleObject.TripleCell.Object //}; //await GraphEngineTripleServerAPI.GetTripleByCellId(0, getRequest).ConfigureAwait(false); var isLocalCell = Global.CloudStorage.IsLocalCell(tripleObject.CellId); if (isLocalCell) { Log.WriteLine($"Found TripleStore Object: {tripleObject.CellId} in Local MemoryCloud!"); using var getRequest = new TripleGetRequestWriter() { TripleCellId = tripleObject.CellId, Subject = tripleObject.TripleCell.Subject, Predicate = tripleObject.TripleCell.Predicate, Namespace = tripleObject.TripleCell.Namespace, Object = tripleObject.TripleCell.Object }; Log.WriteLine($"Make Client-Side call from Server-side: GetTripleByCellId."); await GraphEngineTripleServerAPI .GetTripleByCellId(0, getRequest).ConfigureAwait(false); } }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Task ClientPostedTripleStoreReadyInMemoryCloudHotAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleByCellIdTask; await writeToConsoleTask; }); GraphEngineTripleServerAPI.ClientPostedTripleStoreReadyInMemoryCloudHotAction.Connect(); GraphEngineTripleServerAPI.TripleByCellIdReceivedAction .ObserveOn(GraphEngineTripleServerAPI.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TripleByCellIdReceivedAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleObjectFromGetRequest => { using var getTripleBySubjectTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Reactive Async - Server-Side Get Request on behalf of the Client."); Log.WriteLine($"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Object CellID : {tripleObjectFromGetRequest.CellId}."); Log.WriteLine($"Triple Subject Node : {tripleObjectFromGetRequest.TripleCell.Subject}"); Log.WriteLine($"Triple Predicate Node: {tripleObjectFromGetRequest.TripleCell.Predicate}"); Log.WriteLine($"Triple Object Node : {tripleObjectFromGetRequest.TripleCell.Object}."); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Task TripleByCellIdReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleBySubjectTask; await writeToConsoleTask; }); GraphEngineTripleServerAPI.ClientPostedTripleSavedToMemoryCloudAction .ObserveOn(GraphEngineTripleServerAPI.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleSavedToMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleServerAPI.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleStoreMemoryContext => { using var reactToTriplePostedSavedToMemoryCloudTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Success! Found the Triple in the TripleStore MemoryCloud"); var tripleStore = tripleStoreMemoryContext.NewTripleStore; var subjectNode = tripleStore.TripleCell.Subject; var predicateNode = tripleStore.TripleCell.Predicate; var objectNode = tripleStore.TripleCell.Object; Log.WriteLine($"Triple CellId in MemoryCloud: {tripleStoreMemoryContext.NewTripleStore.CellId}"); Log.WriteLine($"Subject Node: {subjectNode}"); Log.WriteLine($"Predicate Node: {predicateNode}"); Log.WriteLine($"Object Node: {objectNode}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Task ClientPostedTripleSavedToMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var storeFromMemoryCloudTask = reactToTriplePostedSavedToMemoryCloudTask; await storeFromMemoryCloudTask; }); } //Console.ReadLine(); Log.WriteLine("Graph Engine Server is up, running and waiting to client connections"); //Thread.Sleep(Timeout.Infinite); //GraphEngineTripleStoreDemoServerImpl = // TripleStoreServer.GetCommunicationModule<TripleStoreDemoServerModule>(); while (true) { // Each time we pass through the look check to see how many active clients are connected using var processingLoopTask = Task.Factory.StartNew(async() => { if (GraphEngineTripleClientAPI.Clients.Any()) { var tripleStoreClients = GraphEngineTripleClientAPI.Clients.ToList(); Log.WriteLine($"The number of real-time Connected TripleStore Client: {tripleStoreClients.Count}."); foreach (var connectedTripleStoreClient in tripleStoreClients.Where(connectedTripleStoreClient => connectedTripleStoreClient != null)) { try { List <Triple> triples = new List <Triple> { new Triple { Subject = "GraphEngineServer", Predicate = "is", Object = "Running" } }; // New-up the Request Message! using var message = new TripleStreamWriter(triples); // Push a triple to the Client await connectedTripleStoreClient.StreamTriplesAsync(message).ConfigureAwait(false); } catch (Exception ex) { Log.WriteLine(ex.ToString()); } } } await Task.Delay(1000).ConfigureAwait(false); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap(); var mainLoopTask = processingLoopTask; await mainLoopTask; } }
/// <summary> /// This is the entry point of the service host process. /// </summary> private static async Task Main() { try { //TrinityConfig.LogEchoOnConsole = false; TrinityConfig.LoggingLevel = LogLevel.Debug; //TrinityConfig.StorageRoot = @"C:\GE-TripleStore-Storage"; // The ServiceManifest.XML file defines one or more service type names. // Registering a service maps a service type name to a .NET type. // When Service Fabric creates an instance of this service type, // an instance of the class is created in this host process. GraphEngineService.StartServiceAsync("Stateful.TripleStore.GraphDataServiceType").GetAwaiter() .GetResult(); Log.WriteLine(nameof(TripleModule) + " is Up, Ready and Active"); // Global.Communications runtime is ready if (Global.CommunicationInstance != null) { TripleStoreServer = Global.CommunicationInstance as TrinityServer; } if (TripleStoreServer != null) { //Global.LocalStorage.LoadStorage(); TripleStoreServer.RegisterCommunicationModule <TrinityClientModule>(); TripleStoreServer.RegisterCommunicationModule <TripleModule>(); TrinityClientModuleRuntime = TripleStoreServer.GetCommunicationModule <TrinityClientModule>(); // We inject an instance of the TripleModule class object so that we hook-up to our custom sever-side code GraphEngineTripleModuleImpl = TripleStoreServer.GetCommunicationModule <TripleModule>(); } if (GraphEngineTripleModuleImpl != null) { Log.WriteLine("Setup Reactive Event Stream Processing!"); GraphEngineTripleModuleImpl.TriplePostedToServerReceivedAction .ObserveOn(GraphEngineTripleModuleImpl.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TriplePostedToServerReceivedAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleModuleImpl.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async tripleFromClient => { using var graphEngineResponseTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Received from Client has been saved Received."); Log.WriteLine($"Triple Subject Node: {tripleFromClient.Subject}"); Log.WriteLine($"Triple Predicate Node: {tripleFromClient.Predicate}"); Log.WriteLine($"Triple Object Node: {tripleFromClient.Object}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); var msg = "TriplePostedToServerReceivedAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); Log.WriteLine("Task TriplePostedToServerReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = graphEngineResponseTask; await writeToConsoleTask; }); GraphEngineTripleModuleImpl.ServerStreamedTripleSavedToMemoryCloudAction .ObserveOn(GraphEngineTripleModuleImpl.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ServerStreamedTripleSavedToMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleModuleImpl.SubscribeOnEventLoopScheduler) .Subscribe(onNext: async savedTriple => { using var graphEngineResponseTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Streamed to Pushed Client has been saved to MemoryCloud."); Log.WriteLine($"TripleStore CellID: {savedTriple.NewTripleStore.CellId}"); Log.WriteLine($"Triple Subject Node: {savedTriple.NewTripleStore.TripleCell.Subject}"); Log.WriteLine( $"Triple Predicate Node: {savedTriple.NewTripleStore.TripleCell.Predicate}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task ServerStreamedTripleSavedToMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = graphEngineResponseTask; await writeToConsoleTask; }); // ClientPostedTripleStoreReadyInMemoryCloudAction GraphEngineTripleModuleImpl.ClientPostedTripleStoreReadyInMemoryCloudAction .ObserveOn(GraphEngineTripleModuleImpl.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleStoreReadyInMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleModuleImpl.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleObject => { using var getTripleByCellIdTask = Task.Factory.StartNew(async() => { //var t = Global.CloudStorage.IsLocalCell(tripleObject.CellId); // await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); using var getRequest = new TripleGetRequestWriter() { TripleCellId = tripleObject.CellId, Subject = tripleObject.TripleCell.Subject, Predicate = tripleObject.TripleCell.Predicate, Namespace = tripleObject.TripleCell.Namespace, Object = tripleObject.TripleCell.Object }; await GraphEngineTripleModuleImpl.GetTripleByCellId(0, getRequest).ConfigureAwait(false); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task ClientPostedTripleStoreReadyInMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleByCellIdTask; await writeToConsoleTask; }); // Reactive: ClientPostedTripleStoreReadyInMemoryCloudHotAction GraphEngineTripleModuleImpl.ClientPostedTripleStoreReadyInMemoryCloudHotAction .ObserveOn(GraphEngineTripleModuleImpl.HotObservableSchedulerContext) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleStoreReadyInMemoryCloudHotAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleModuleImpl.HotObservableSchedulerContext) .Synchronize() .Subscribe(onNext: async tripleObject => { using var getTripleByCellIdTask = Task.Factory.StartNew(async() => { // await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); using var getRequest = new TripleGetRequestWriter() { TripleCellId = tripleObject.CellId, Subject = tripleObject.TripleCell.Subject, Predicate = tripleObject.TripleCell.Predicate, Namespace = tripleObject.TripleCell.Namespace, Object = tripleObject.TripleCell.Object }; await GraphEngineTripleModuleImpl.GetTripleByCellId(0, getRequest).ConfigureAwait(false); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task ClientPostedTripleStoreReadyInMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleByCellIdTask; await writeToConsoleTask; }); GraphEngineTripleModuleImpl.ClientPostedTripleStoreReadyInMemoryCloudHotAction.Connect(); GraphEngineTripleModuleImpl.TripleByCellIdReceivedAction .ObserveOn(GraphEngineTripleModuleImpl.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "TripleByCellIdReceivedAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleModuleImpl.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleObjectFromGetRequest => { using var getTripleBySubjectTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine( "Reactive Async - Parallel-Tasking return from Server-Side Get Request on behalf of the Client."); Log.WriteLine( $"Processing Timestamp: {DateTime.Now.ToString(CultureInfo.InvariantCulture)}"); Log.WriteLine($"Triple Object CellID: {tripleObjectFromGetRequest.CellId}."); Log.WriteLine( $"Triple Subject Node: {tripleObjectFromGetRequest.TripleCell.Subject}"); Log.WriteLine( $"Triple Predicate Node: {tripleObjectFromGetRequest.TripleCell.Predicate}"); Log.WriteLine( $"Triple Object Node: {tripleObjectFromGetRequest.TripleCell.Object}."); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task TripleByCellIdReceivedAction Complete..."); }, cancellationToken: CancellationToken.None); var writeToConsoleTask = getTripleBySubjectTask; await writeToConsoleTask; }); GraphEngineTripleModuleImpl.ClientPostedTripleSavedToMemoryCloudAction .ObserveOn(GraphEngineTripleModuleImpl.ObserverOnNewThreadScheduler) .Do(onNext: subscriberSource => { var msg = "ClientPostedTripleSavedToMemoryCloudAction-1"; Log.WriteLine("{0} Subscription happened on this Thread: {1}", msg, Thread.CurrentThread.ManagedThreadId); }) .SubscribeOn(GraphEngineTripleModuleImpl.SubscribeOnEventLoopScheduler) .Synchronize() .Subscribe(onNext: async tripleStoreMemoryContext => { using var reactToTriplePostedSavedToMemoryCloudTask = Task.Factory.StartNew(async() => { //await Task.Yield(); await Task.Delay(0).ConfigureAwait(false); Log.WriteLine("Success! Found the Triple in the TripleStore MemoryCloud"); var tripleStore = tripleStoreMemoryContext.NewTripleStore; var subjectNode = tripleStore.TripleCell.Subject; var predicateNode = tripleStore.TripleCell.Predicate; var objectNode = tripleStore.TripleCell.Object; Log.WriteLine( $"Triple CellId in MemoryCloud: {tripleStoreMemoryContext.NewTripleStore.CellId}"); Log.WriteLine($"Subject Node: {subjectNode}"); Log.WriteLine($"Predicate Node: {predicateNode}"); Log.WriteLine($"Object Node: {objectNode}"); }, cancellationToken: CancellationToken.None, creationOptions: TaskCreationOptions.HideScheduler, scheduler: TaskScheduler.Current).Unwrap().ContinueWith(async _ => { await Task.Delay(0); Log.WriteLine("Task ClientPostedTripleSavedToMemoryCloudAction Complete..."); }, cancellationToken: CancellationToken.None); var storeFromMemoryCloudTask = reactToTriplePostedSavedToMemoryCloudTask; await storeFromMemoryCloudTask; }); } //Console.ReadLine(); await Task.Delay(0).ConfigureAwait(false); Thread.Sleep(Timeout.Infinite); //GraphEngineTripleStoreDemoServerImpl = // TripleStoreServer.GetCommunicationModule<TripleStoreDemoServerModule>(); //while (true) //{ // // Each time we pass through the look check to see how many active clients are connected // using var processingLoopTask = Task.Factory.StartNew(async () => // { // if (TrinityClientModuleRuntime.Clients != null) // { // var tripleStoreClients = TrinityClientModuleRuntime.Clients.ToList(); // Log.WriteLine($"The number of real-time Connected TripleStore Client: {tripleStoreClients.Count}."); // foreach (var connectedTripleStoreClient in tripleStoreClients.Where(connectedTripleStoreClient => connectedTripleStoreClient != null)) // { // try // { // List<Triple> triples = new List<Triple> { new Triple { Subject = "GraphEngineServer", Predicate = "is", Object = "Running" } }; // // New-up the Request Message! // using var message = new TripleStreamWriter(triples); // // Push a triple to the Client // await connectedTripleStoreClient.StreamTriplesAsync(message).ConfigureAwait(false); // } // catch (Exception ex) // { // Log.WriteLine(ex.ToString()); // } // } // } // await Task.Delay(2000).ConfigureAwait(false); // }, cancellationToken: CancellationToken.None, // creationOptions: TaskCreationOptions.HideScheduler, // scheduler: TaskScheduler.Current).Unwrap(); // var mainLoopTask = processingLoopTask; // await mainLoopTask; //} } catch (Exception ex) { Log.WriteLine(ex.Message); } }