static void Main(string[] args)
{
FanoutSearchModule.EnableExternalQuery(true);
FanoutSearchModule.SetQueryTimeout(30000);
FanoutSearchModule.RegisterIndexService(Indexer);
FanoutSearchModule.RegisterExpressionSerializerFactory(() => new ExpressionSerializer());
LambdaDSL.SetDialect("MyGraph", "StartFrom", "VisitNode", "FollowEdge", "Action");
TrinityConfig.HttpPort = 80;
var server = new TrinityServer();
server.RegisterCommunicationModule <FanoutSearchModule>();
server.Start();
if (!Trinity.Global.LocalStorage.LoadStorage() || !Trinity.Global.LocalStorage.Movie_Accessor_Selector().Any())
{
Trinity.Global.LocalStorage.LoadStorage();
ImportMovieData(@"D:\MovieDomain\GraphEngineServer\bin\Debug\");
Trinity.Global.LocalStorage.SaveStorage();
}
else
{
Console.WriteLine("=============================Movie had been imported once. Skipping this turn.");
}
//TestMovieData(@"D:\MovieDomain\GraphEngineServer\bin\Debug\");
//ImportToyData();
//PrepareSeedEntity();
}
public void T1()
{
TrinityServer server = new TrinityServer();
server.Start();
Global.Uninitialize();
}
static void Main(string[] args)
{
TrinityConfig.LoggingLevel = Trinity.Diagnostics.LogLevel.Debug;
TrinityConfig.StorageRoot = Environment.CurrentDirectory;
Global.LocalStorage.ResetStorage();
TrinityServer server = new TrinityServer();
server.Start();
server.Stop();
Parallel.For(0, 1000, i =>
{
Global.LocalStorage.SaveCell(i, new byte[i]);
});
Global.LocalStorage.SaveStorage();
Global.LocalStorage.LoadStorage();
for (int i = 0; i < 1000; ++i)
{
byte[] cell_content;
Assert(TrinityErrorCode.E_SUCCESS == Global.LocalStorage.LoadCell(i, out cell_content));
Assert(i == cell_content.Length);
}
// let's also assert that there are no other cells in the storage...
for (int i = 1001; i < 10000; ++i)
{
Assert(!Global.LocalStorage.Contains(i));
}
Global.Uninitialize();
Environment.Exit(0);
}
static void Main(string[] args)
{
TrinityConfig.LoggingLevel = Trinity.Diagnostics.LogLevel.Debug;
Global.LocalStorage.ResetStorage();
TrinityServer server = new TrinityServer();
server.Start();
server.Stop();
Parallel.For(0, 1000, i =>
{
Global.LocalStorage.SaveCell(i, new byte[i]);
});
Global.LocalStorage.SaveStorage();
Global.LocalStorage.LoadStorage();
for (int i = 0; i < 1000; ++i)
{
byte[] cell_content;
Debug.Assert(TrinityErrorCode.E_SUCCESS == Global.LocalStorage.LoadCell(i, out cell_content));
Debug.Assert(i == cell_content.Length);
}
Global.Uninitialize();
Environment.Exit(0);
}
static void Main(string[] args)
{
if (args.Length == 0)
{
Usage();
return;
}
if (args.Length >= 2)
{
TrinityConfig.StorageRoot = args[1];
}
Global.LoadTSLStorageExtension(args[0]);
Global.LocalStorage.LoadStorage();
TrinityConfig.HttpPort = 80;
FanoutSearchModule.EnableExternalQuery(true);
FanoutSearchModule.SetQueryTimeout(3000);
FanoutSearchModule.RegisterIndexService(Indexer);
FanoutSearch.LambdaDSL.SetDialect("g", "v", "outV", "outE", "Action");
TrinityServer server = new TrinityServer();
server.RegisterCommunicationModule <FanoutSearchModule>();
server.Start();
}
static void Main(string[] args)
{
Console.WriteLine(typeof(PythonRuntimeProvider).Name);
FFIConfig.Instance.ProgramDirectory = Environment.CurrentDirectory;
Console.WriteLine(Environment.CurrentDirectory);
TrinityServer server = new TrinityServer();
server.Start();
}
public void ModuleAutoload()
{
TrinityServer server = new TrinityServer();
server.Start();
Assert.NotNull(server.GetCommunicationModule <TrinityFFIModule>());
server.Stop();
}
public TrinityServerFixture()
{
Global.Initialize();
LambdaDSL.SetDialect("MAG", "StartFrom", "VisitNode", "FollowEdge", "Action");
FanoutSearchModule.SetQueryTimeout(-1);
FanoutSearchModule.RegisterIndexService(FakeIndexService);
server = new TrinityServer();
server.RegisterCommunicationModule <FanoutSearchModule>();
server.Start();
}
private static async Task Main(string[] args)
{
TrinityConfig.CurrentRunningMode = RunningMode.Server;
TrinityConfig.LogEchoOnConsole = true;
TrinityConfig.LoggingLevel = LogLevel.Info;
Log.LogsWritten += Log_LogsWritten;
TripleStoreServer = new TrinityServer();
TripleStoreServer.RegisterCommunicationModule <TrinityClientModule>();
TripleStoreServer.RegisterCommunicationModule <TripleModule>();
TripleStoreServer.Start();
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>();
while (true)
{
// Each time we pass through the look check to see how many active clients are connected
var tripleStoreClients = TrinityClientModuleRuntime.Clients.ToList();
Console.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 = "foo", Predicate = "is", Object = "bar"
}
};
// New-up the Request Message!
using var message = new TripleStreamWriter(triples);
// Push a triple to the Client
using var rsp = await connectedTripleStoreClient.StreamTriplesAsync(message).ConfigureAwait(false);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
await Task.Delay(1000).ConfigureAwait(false);
}
}
public void issue_267()
{
Global.Initialize("trinity.xml");
var server = new TrinityServer();
server.Start();
var contains = Global.CloudStorage.Contains(0);
Assert.False(contains);
}
internal static void Initialize()
{
Global.Initialize();
LambdaDSL.SetDialect("MAG", "StartFrom", "VisitNode", "FollowEdge", "Action");
FanoutSearchModule.SetQueryTimeout(-1);
FanoutSearchModule.RegisterIndexService(FakeIndexService);
FanoutSearchModule.RegisterExpressionSerializerFactory(() => new ExpressionSerializer());
TrinityServer server = new TrinityServer();
server.RegisterCommunicationModule <FanoutSearchModule>();
server.Start();
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
//TrinityConfig.ServerPort = 8081;
TrinityConfig.HttpPort = 8080;
TrinityServer server = new TrinityServer();
// server.RegisterCommunicationModule<FanoutSearchModule>();
server.Start();
}
public void StartServerTwice()
{
TrinityServer server = new TrinityServer();
server.Start();
Global.Uninitialize();
Global.Initialize();
server.Start();
Global.Uninitialize();
}
static void Main(string[] args)
{
Initialize();
// Spawn a 'stock' Trinity server
TrinityServer server = new TrinityServer();
// Plug-in the LIKQ communication module.
server.RegisterCommunicationModule <FanoutSearchModule>();
// Start the server
server.Start();
}
public static void Initialize(TestContext context)
{
TrinityServer server = new TrinityServer();
TrinityConfig.HttpPort = 8080;
TrinityConfig.ServerPort = 7304;
TrinityConfig.LoggingLevel = Trinity.Diagnostics.LogLevel.Debug;
server.RegisterCommunicationModule <FanoutSearchModule>();
server.Start();
Console.WriteLine("Local Server started");
Global.CloudStorage.BarrierSync();
Console.WriteLine("All Server started");
}
static void Main(string[] args)
{
LoadPlugins(PluginConfig.Instance);
Global.Initialize();
TrinityServer server = new TrinityServer();
server.Start();
while (true)
{
System.Threading.Thread.Sleep(10000);
}
}
public static void Initialize(TestContext context)
{
TrinityServer server = new TrinityServer();
TrinityConfig.HttpPort = 8080;
TrinityConfig.ServerPort = 7304;
TrinityConfig.LoggingLevel = Trinity.Diagnostics.LogLevel.Debug;
FanoutSearchModule.RegisterExpressionSerializerFactory(() => new ExpressionSerializer());
server.RegisterCommunicationModule <FanoutSearchModule>();
server.Start();
Console.WriteLine("Local Server started");
BSP.BarrierSync((FixedMemoryCloud)Global.CloudStorage);
Console.WriteLine("All Server started");
}
static void Main(string[] args)
{
TrinityConfig.LoggingLevel = Diagnostics.LogLevel.Debug;
TrinityServer server = new TrinityServer();
server.RegisterCommunicationModule <TrinityClientModule.TrinityClientModule>();
server.RegisterCommunicationModule <TrinityClientTestModule>();
server.Start();
Global.LocalStorage.SaveC1(0, "foo", 123);
var cmod = server.GetCommunicationModule <TrinityClientModule.TrinityClientModule>();
var tmod = server.GetCommunicationModule <TrinityClientTestModule>();
int i = 0;
while (true)
{
var client = cmod.Clients.FirstOrDefault();
Console.WriteLine($"{cmod.Clients.Count()} clients");
if (client != null)
{
try
{
using (var msg = new S1Writer("foo", i++))
client.P1(msg).ContinueWith(t =>
{
using (var rsp = t.Result)
{
Console.WriteLine($"Client responded: {rsp.foo}, {rsp.bar}");
}
}, TaskContinuationOptions.RunContinuationsAsynchronously);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
--i;
}
}
Thread.Sleep(1000);
}
}
public void LoadsRuntime()
{
Global.Initialize();
FileUtility.CompletePath(FFIConfig.Instance.ProgramDirectory, create_nonexistent: true);
var fp = Path.Combine(FFIConfig.Instance.ProgramDirectory, "test.txt");
File.WriteAllText(fp, " ");
TrinityServer server = new TrinityServer();
server.Start();
Assert.Equal(fp, MockRuntime.s_loadprogram_called);
Assert.Equal(1, MockRuntimeProvider_SS.s_runtime_cnt);
server.Stop();
Global.Uninitialize();
Assert.Equal(true, MockRuntime.s_dispose_called);
}
public void Initialize(string LogDirectory, string StorageRoot, bool LogEchoOnConsole, Trinity.Diagnostics.LogLevel LogLevel)
{
if (!_isInitialized)
{
TrinityConfig.LogEchoOnConsole = LogEchoOnConsole;
LoggingConfig.Instance.LogDirectory = LogDirectory;
LoggingConfig.Instance.LoggingLevel = LogLevel;
StorageConfig.Instance.StorageRoot = StorageRoot;
Global.Initialize();
LambdaDSL.SetDialect("MAG", "StartFrom", "VisitNode", "FollowEdge", "Action");
FanoutSearchModule.SetQueryTimeout(-1);
TrinityServer server = new TrinityServer();
server.RegisterCommunicationModule <FanoutSearchModule>();
server.Start();
_isInitialized = true;
}
}
public void LoadPythonFFI_Success()
{
// The test engine may trigger the initialization
Global.Initialize();
FileUtility.CompletePath(FFIConfig.Instance.ProgramDirectory, create_nonexistent: true);
// try to invoke trinity-specific python code here
var fp = Path.Combine(FFIConfig.Instance.ProgramDirectory, "test.py");
File.WriteAllText(fp, @"
with open('MyCell.txt', 'w') as f:
a = ge.NewCell('MyCell')
print(a)
f.write(a)
");
TrinityServer server = new TrinityServer();
server.Start();
Global.Uninitialize();
Assert.True(File.Exists("MyCell.txt"));
Debug.WriteLine(File.ReadAllText("MyCell.txt"));
}
/// <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("Trinity.SF.GraphEngineDataServiceType").GetAwaiter()
.GetResult();
// Global.Communications runtime is ready
TripleStoreServer = Global.CommunicationInstance as TrinityServer;
if (TripleStoreServer != null)
{
Log.WriteLine(nameof(TripleModule) + " is Up, Ready and Active");
TripleStoreServer.Started += TripleStoreServer_Started;
TripleStoreServer_Started();
}
//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 (GraphEngineTripleClientAPI.Clients != null)
// {
// var tripleStoreClients = GraphEngineTripleClientAPI.Clients.ToList();
// Console.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);
}
}
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;
}
}
static void Main(string[] args)
{
TrinityConfig.LoggingLevel = Trinity.Diagnostics.LogLevel.Debug;
TrinityConfig.LogEchoOnConsole = true;
TrinityConfig.LogToFile = true;
TrinityConfig.CurrentRunningMode = RunningMode.Server;
TrinityConfig.ClientMaxConn = 1;
TrinityServer server = new TrinityServer();
server.RegisterCommunicationModule <TrinityClientModule>();
server.RegisterCommunicationModule <TripleStoreServiceModule>();
server.Start();
var myTriple =
new Triple()
{
GraphInstance = 0,
Url = "http://www.inknowworks.semanticweb.ontology/persongraph",
HashCode = Trinity.Core.Lib.HashHelper.HashString2Int64(Guid.NewGuid().ToString()),
Nodes = new List <INode>()
{
new INode()
{
GraphParent = Trinity.Core.Lib.CellIdFactory.NewCellId(),
GraphUri = "http://www.inknowworks.semanticweb.ontology/persongraph",
HashCode = Trinity.Core.Lib.HashHelper.HashString2Int64("http://www.inknowworks.semanticweb.ontology/persongraph"),
TypeOfNode = NodeType.GraphLiteral
}
},
ObjectNode = new INode()
{
GraphParent = 0,
GraphUri = "http://www.inknowworks.semanticweb.ontology/persongraph",
HashCode = Trinity.Core.Lib.HashHelper.HashString2Int64(Guid.NewGuid().ToString()),
TripleType = TripleSegmentPart.Object,
TypeOfNode = NodeType.Literal,
},
SubjectNode = new INode()
{
GraphParent = 0,
GraphUri = "http://www.inknowworks.semanticweb.ontology/persongraph",
HashCode = Trinity.Core.Lib.HashHelper.HashString2Int64(Guid.NewGuid().ToString()),
TripleType = TripleSegmentPart.Subject,
TypeOfNode = NodeType.GraphLiteral
},
PredicateNode = new INode()
{
GraphParent = 0,
GraphUri = "http://www.inknowworks.semanticweb.ontology/persongraph",
HashCode = Trinity.Core.Lib.HashHelper.HashString2Int64(Guid.NewGuid().ToString()),
TripleType = TripleSegmentPart.Predicate,
TypeOfNode = NodeType.Literal,
}
};
var tripleCollection = new List <Triple> {
myTriple
};
// New up a Graph Entity
Graph myGraph = new Graph()
{
BaseUri = "http://www.inknowworks.semanticweb.ontology/",
CellId = Trinity.Core.Lib.CellIdFactory.NewCellId(),
TripleCollection = tripleCollection
};
myTriple.GraphInstance = myGraph.CellId;
Global.CloudStorage.SaveGraph(myGraph);
//int i = 0;
//while (true)
//{
// var client = clientModule.Clients.FirstOrDefault();
// Console.WriteLine($"{clientModule.Clients.Count()} clients");
// // Test to see if Client has connected
// if (client != null)
// {
// try
// {
// using (var msg = new S1Writer("foo", i++))
// client.P1(msg).ContinueWith(t =>
// {
// using (var rsp = t.Result)
// {
// Console.WriteLine($"Client responded: {rsp.foo}, {rsp.bar}");
// }
// }, TaskContinuationOptions.RunContinuationsAsynchronously);
// }
// catch (Exception ex)
// {
// Console.WriteLine(ex.ToString());
// --i;
// }
// }
// Thread.Sleep(1000);
//}
//var clientModule = server.GetCommunicationModule<TrinityClientModule>();
//var tripleStoreServiceModule = server.GetCommunicationModule<TripleStoreServiceModule>();
while (true)
{
Thread.Sleep(1000000);
}
}
/// <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);
}
}
