public void ConcurrentAccessTest()
{
var key1 = RFGenericCatalogKey.Create(_fixture.KeyDomain, "ConcurrentAccessTest", TestEngine.TestKeys.Key1, null);
var key2 = RFGenericCatalogKey.Create(_fixture.KeyDomain, "ConcurrentAccessTest", TestEngine.TestKeys.Key2, null);
RFStatic.Log.Info(this, "Starting ConcurrentTest");
var factory = new TaskFactory();
var tasks = new List <Task>();
for (int i = 0; i < 5; i++)
{
tasks.Add(factory.StartNew((j) => _fixture.Context.SaveDocument(key1, j.ToString(), false), i));
tasks.Add(factory.StartNew(() => _fixture.Context.LoadDocumentContent <string>(key1)));
tasks.Add(factory.StartNew((j) => _fixture.Context.SaveDocument(key2, j.ToString(), false), i));
tasks.Add(factory.StartNew(() => _fixture.Context.LoadDocumentContent <string>(key2)));
}
Task.WaitAll(tasks.ToArray());
RFStatic.Log.Info(this, "Finished ConcurrentTest, checking result");
var entry1 = _fixture.Context.LoadEntry(key1);
var entry2 = _fixture.Context.LoadEntry(key2);
Assert.Equal(5, entry1.Version);
Assert.Equal(5, entry2.Version);
}
public void ComplexWriteTest()
{
var testDoc = CreateTestDocument();
var key = RFGenericCatalogKey.Create(_fixture.KeyDomain, "TestDoc1", TestEngine.TestKeys.Key1, null);
_fixture.Context.SaveDocument(key, testDoc);
var reloaded = _fixture.Context.LoadDocumentContent <TestDocument>(key);
CompareTestDoc(reloaded);
}
public void SimpleWriteTest()
{
var key = RFGenericCatalogKey.Create(_fixture.KeyDomain, "WriteTest", TestEngine.TestKeys.Key1, null);
_fixture.Context.SaveDocument(key, "test1");
Assert.Equal(_fixture.Context.LoadDocumentContent <string>(key), "test1");
_fixture.Context.SaveDocument(key, "test2");
Assert.Equal(_fixture.Context.LoadDocumentContent <string>(key), "test2");
}
public void IntervalTest()
{
var key = RFGenericCatalogKey.Create(_fixture.KeyDomain, "IntervalTest", TestEngine.TestKeys.Key2, null);
Thread.Sleep(2000);
var content = _fixture.Context.LoadDocumentContent <string>(key);
Assert.NotNull(content);
Assert.Equal("Complete", content);
}
public void TasksTest()
{
Thread.Sleep(3000);
var task1Result = _fixture.Context.LoadDocumentContent <string>(RFGenericCatalogKey.Create(_fixture.KeyDomain, "Task 1 Result", TestEngine.TestKeys.Key1, null));
var task2Result = _fixture.Context.LoadDocumentContent <string>(RFGenericCatalogKey.Create(_fixture.KeyDomain, "Task 2 Result", TestEngine.TestKeys.Key1, null));
var task3Result = _fixture.Context.LoadDocumentContent <string>(RFGenericCatalogKey.Create(_fixture.KeyDomain, "Task 3 Result", TestEngine.TestKeys.Key1, null));
Assert.Equal("Complete", task1Result);
Assert.Equal("Complete", task2Result);
Assert.Equal("Complete", task3Result);
}
public void QueuedTriggerTest()
{
var triggerKey = RFGenericCatalogKey.Create(_fixture.KeyDomain, "Trigger Key", TestEngine.TestKeys.Key1, null);
_fixture.Context.SaveEntry(RFDocument.Create(triggerKey, new RFScheduleTrigger {
LastTriggerTime = DateTime.Now
}), true);
Thread.Sleep(TimeSpan.FromSeconds(1));
_fixture.Context.SaveEntry(RFDocument.Create(triggerKey, new RFScheduleTrigger {
LastTriggerTime = DateTime.Now
}), true);
Thread.Sleep(TimeSpan.FromSeconds(1));
_fixture.Context.SaveEntry(RFDocument.Create(triggerKey, new RFScheduleTrigger {
LastTriggerTime = DateTime.Now
}), true);
Thread.Sleep(TimeSpan.FromSeconds(20));
var result = _fixture.Context.LoadDocumentContent <string>(RFGenericCatalogKey.Create(_fixture.KeyDomain, "Queued Trigger", TestEngine.TestKeys.Key1, null));
Assert.Equal("StartStopStartStop", result); // we expect 2x, not 1x or 3x
}
public void GraphDependencyTest()
{
var instance = new RFGraphInstance {
Name = "default", ValueDate = RFDate.Today()
};
var s1Key = RFGenericCatalogKey.Create(_fixture.KeyDomain, "S", TestEngine.TestKeys.Key1, instance);
var s2Key = RFGenericCatalogKey.Create(_fixture.KeyDomain, "S", TestEngine.TestKeys.Key2, instance);
_fixture.Context.SaveDocument(s1Key, "S", true);
_fixture.Context.SaveDocument(s2Key, "S", true);
Thread.Sleep(2000);
// results
var e1Key = RFGenericCatalogKey.Create(_fixture.KeyDomain, "E", TestEngine.TestKeys.Key1, instance);
var e2Key = RFGenericCatalogKey.Create(_fixture.KeyDomain, "E", TestEngine.TestKeys.Key2, instance);
// execution counts
var a1Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "A_Counter", TestEngine.TestKeys.Key1, instance);
var b1Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "B_Counter", TestEngine.TestKeys.Key1, instance);
var c1Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "C_Counter", TestEngine.TestKeys.Key1, instance);
var a2Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "A_Counter", TestEngine.TestKeys.Key2, instance);
var b2Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "B_Counter", TestEngine.TestKeys.Key2, instance);
var c2Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "C_Counter", TestEngine.TestKeys.Key2, instance);
Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(a1Count));
Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(b1Count));
Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(c1Count));
Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(a2Count));
Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(b2Count));
Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(c2Count));
Assert.Equal("SASABC", _fixture.Context.LoadDocumentContent <string>(e1Key));
Assert.Equal("SASABC", _fixture.Context.LoadDocumentContent <string>(e2Key));
}
public RFEngineDefinition BuildEngine(string database, string environment)
{
var keyDomain = new RFSimpleKeyDomain("TEST");
var engineConfig = RFEngineDefinition.Create(
"TestEngine",
keyDomain,
intervalSeconds: 1,
maxRuntime: TimeSpan.FromMinutes(20));
// interval and direct dependency
engineConfig.AddIntervalTrigger(
engineConfig.AddProcess("Interval test", "Checks for internal", () => new ActionProcessor((c) =>
c.SaveDocument(RFGenericCatalogKey.Create(keyDomain, "IntervalTest", TestKeys.Key1, null), "Complete")
)));
engineConfig.AddProcessWithCatalogTrigger <RFEngineProcessorKeyParam>("Interval sink", "Step 2", () => new ActionProcessor((c) =>
c.SaveDocument(RFGenericCatalogKey.Create(keyDomain, "IntervalTest", TestKeys.Key2, null), "Complete")),
RFGenericCatalogKey.Create(keyDomain, "IntervalTest", TestKeys.Key1, null));
// direct and indirect dependency test (A -> B -> C) with reverse
var graph = engineConfig.CreateGraph("TestGraph");
graph.AddProcess("A1", "A1", () => new AppendProcessor(new AppendProcessor.Config {
Append = "A"
}))
.Map(d => d.Input1, RFGenericCatalogKey.Create(keyDomain, "S", TestKeys.Key1, null), RFDateBehaviour.Exact)
.Map(d => d.Output, RFGenericCatalogKey.Create(keyDomain, "Y", TestKeys.Key1, null), RFDateBehaviour.Exact)
.Map(d => d.Counter, RFGenericCatalogKey.Create(keyDomain, "A_Counter", TestKeys.Key1, null), RFDateBehaviour.Exact);
graph.AddProcess("B1", "B1", () => new AppendProcessor(new AppendProcessor.Config {
Append = "B"
}))
.Map(d => d.Input1, RFGenericCatalogKey.Create(keyDomain, "Y", TestKeys.Key1, null), RFDateBehaviour.Exact)
.Map(d => d.Output, RFGenericCatalogKey.Create(keyDomain, "Z", TestKeys.Key1, null), RFDateBehaviour.Exact)
.Map(d => d.Counter, RFGenericCatalogKey.Create(keyDomain, "B_Counter", TestKeys.Key1, null), RFDateBehaviour.Exact);
graph.AddProcess("C1", "C1", () => new AppendProcessor(new AppendProcessor.Config {
Append = "C"
}))
.Map(d => d.Input1, RFGenericCatalogKey.Create(keyDomain, "Y", TestKeys.Key1, null), RFDateBehaviour.Exact)
.Map(d => d.Input2, RFGenericCatalogKey.Create(keyDomain, "Z", TestKeys.Key1, null), RFDateBehaviour.Exact)
.Map(d => d.Output, RFGenericCatalogKey.Create(keyDomain, "E", TestKeys.Key1, null), RFDateBehaviour.Exact)
.Map(d => d.Counter, RFGenericCatalogKey.Create(keyDomain, "C_Counter", TestKeys.Key1, null), RFDateBehaviour.Exact);
// reverse
graph.AddProcess("A2", "A2", () => new AppendProcessor(new AppendProcessor.Config {
Append = "C"
}))
.Map(d => d.Input1, RFGenericCatalogKey.Create(keyDomain, "Y", TestKeys.Key2, null), RFDateBehaviour.Exact)
.Map(d => d.Input2, RFGenericCatalogKey.Create(keyDomain, "Z", TestKeys.Key2, null), RFDateBehaviour.Exact)
.Map(d => d.Output, RFGenericCatalogKey.Create(keyDomain, "E", TestKeys.Key2, null), RFDateBehaviour.Exact)
.Map(d => d.Counter, RFGenericCatalogKey.Create(keyDomain, "C_Counter", TestKeys.Key2, null), RFDateBehaviour.Exact);
graph.AddProcess("B2", "B2", () => new AppendProcessor(new AppendProcessor.Config {
Append = "B"
}))
.Map(d => d.Input1, RFGenericCatalogKey.Create(keyDomain, "Y", TestKeys.Key2, null), RFDateBehaviour.Exact)
.Map(d => d.Output, RFGenericCatalogKey.Create(keyDomain, "Z", TestKeys.Key2, null), RFDateBehaviour.Exact)
.Map(d => d.Counter, RFGenericCatalogKey.Create(keyDomain, "B_Counter", TestKeys.Key2, null), RFDateBehaviour.Exact);
graph.AddProcess("C2", "C2", () => new AppendProcessor(new AppendProcessor.Config {
Append = "A"
}))
.Map(d => d.Input1, RFGenericCatalogKey.Create(keyDomain, "S", TestKeys.Key2, null), RFDateBehaviour.Exact)
.Map(d => d.Output, RFGenericCatalogKey.Create(keyDomain, "Y", TestKeys.Key2, null), RFDateBehaviour.Exact)
.Map(d => d.Counter, RFGenericCatalogKey.Create(keyDomain, "A_Counter", TestKeys.Key2, null), RFDateBehaviour.Exact);
// tasks
var task1 = engineConfig.AddProcess("Task 1 Process", "Task 1", () => new ActionProcessor((c) =>
c.SaveDocument(RFGenericCatalogKey.Create(keyDomain, "Task 1 Result", TestKeys.Key1, null), "Complete")));
var task2 = engineConfig.AddProcess("Task 2 Process", "Task 2", () => new ActionProcessor((c) =>
c.SaveDocument(RFGenericCatalogKey.Create(keyDomain, "Task 2 Result", TestKeys.Key1, null), "Complete")));
var task3 = engineConfig.AddProcess("Task 3 Process", "Task 3", () => new ActionProcessor((c) =>
c.SaveDocument(RFGenericCatalogKey.Create(keyDomain, "Task 3 Result", TestKeys.Key1, null), "Complete")));
engineConfig.AddScheduledTask("Task 1", new RFIntervalSchedule(new TimeSpan(0, 0, 1)).Single(), RFWeeklyWindow.AllWeek(), task1, false);
engineConfig.AddChainedTask("Task 2", task1, task2, false);
engineConfig.AddTriggeredTask("Task 3", RFGenericCatalogKey.Create(keyDomain, "Task 2 Result", TestKeys.Key1, null), task3);
// queued trigger test
var queuedTrigger = engineConfig.AddProcess("Queued Trigger Process", "Queued Trigger Process", () => new ActionProcessor((c) =>
{
var _in = c.LoadDocumentContent <string>(RFGenericCatalogKey.Create(keyDomain, "Queued Trigger", TestKeys.Key1, null)) ?? String.Empty;
_in += "Start";
Thread.Sleep(TimeSpan.FromSeconds(3));
_in += "Stop";
c.SaveDocument(RFGenericCatalogKey.Create(keyDomain, "Queued Trigger", TestKeys.Key1, null), _in);
}));
engineConfig.AddTriggeredTask("Queued Scheduler", RFGenericCatalogKey.Create(keyDomain, "Trigger Key", TestEngine.TestKeys.Key1, null), queuedTrigger);
// transaction
engineConfig.AddProcess("Transaction Tester", "Tests SQL+MSMQ Transaction", () => new TransactionProcessor(
RFGenericCatalogKey.Create(keyDomain, "Transaction", "Test1", null),
RFGenericCatalogKey.Create(keyDomain, "Transaction", "Test2", null)));
return(engineConfig);
}
public void KeyInstancesTest()
{
var key1 = RFGenericCatalogKey.Create(_fixture.KeyDomain, "KeyInstancesTest", TestEngine.TestKeys.Key1, new RFGraphInstance {
Name = "dummy", ValueDate = RFDate.Today()
});
var key2 = RFGenericCatalogKey.Create(_fixture.KeyDomain, "KeyInstancesTest", TestEngine.TestKeys.Key2, new RFGraphInstance {
Name = "dummy", ValueDate = RFDate.Today()
});
foreach (var date in RFDate.Range(new RFDate(2016, 7, 1), new RFDate(2016, 7, 12), d => true))
{
// 12 of these
var key11 = key1.CreateForInstance(new RFGraphInstance
{
Name = "default1",
ValueDate = date
});
_fixture.Context.SaveDocument(key11, "Test", false);
// 6 of these
if (date.Day % 2 == 0)
{
var key12 = key1.CreateForInstance(new RFGraphInstance
{
Name = "default2",
ValueDate = date
});
_fixture.Context.SaveDocument(key12, "Test", false);
}
// 4 of these
if (date.Day % 3 == 0)
{
var key21 = key2.CreateForInstance(new RFGraphInstance
{
Name = "default1",
ValueDate = date
});
_fixture.Context.SaveDocument(key21, "Test", false);
}
// 3 of these
if (date.Day % 4 == 0)
{
var key22 = key2.CreateForInstance(new RFGraphInstance
{
Name = "default2",
ValueDate = date
});
_fixture.Context.SaveDocument(key22, "Test", false);
}
}
_fixture.Context.SaveDocument(key2.CreateForInstance(null), "Test", false); // this should be ignored
var keys1 = _fixture.Context.GetKeyInstances(key1);
Assert.Equal(18, keys1.Count);
Assert.Equal(12, keys1.Where(k => k.Value.GraphInstance.Name == "default1").Count());
Assert.Equal(6, keys1.Where(k => k.Value.GraphInstance.Name == "default2").Count());
var keys2 = _fixture.Context.GetKeyInstances(key2);
Assert.Equal(7, keys2.Count);
Assert.Equal(4, keys2.Where(k => k.Value.GraphInstance != null && k.Value.GraphInstance.Name == "default1").Count());
Assert.Equal(3, keys2.Where(k => k.Value.GraphInstance != null && k.Value.GraphInstance.Name == "default2").Count());
// invalidate
_fixture.Context.Invalidate(key1.CreateForInstance(new RFGraphInstance
{
Name = "default1",
ValueDate = new RFDate(2016, 7, 12)
}));
// get latest
var latest1 = _fixture.Context.LoadEntry(key1.CreateForInstance(new RFGraphInstance
{
Name = "default1",
ValueDate = RFDate.Today()
}), new RFCatalogOptions
{
DateBehaviour = RFDateBehaviour.Latest
});
Assert.Equal(11, latest1.Key.GraphInstance.ValueDate.Value.Day);
var latest2 = _fixture.Context.LoadEntry(key1.CreateForInstance(new RFGraphInstance
{
Name = "default2",
ValueDate = RFDate.Today()
}), new RFCatalogOptions
{
DateBehaviour = RFDateBehaviour.Latest
});
Assert.Equal(12, latest2.Key.GraphInstance.ValueDate.Value.Day);
}
public void ExecuteCommand(string input)
{
if (!string.IsNullOrWhiteSpace(input))
{
var tokens = new RIFF.Interfaces.Formats.CSV.CSVParser(input, ' ').Where(t => !string.IsNullOrWhiteSpace(t)).ToArray();
switch (tokens[0])
{
case "importupdates":
{
if (tokens.Length < 2)
{
Console.WriteLine("Usage: importupdates,<path>");
break;
}
var c = RFCatalogMaintainer.ImportCatalogUpdates(_context, tokens[1]);
Console.WriteLine("Imported {0} documents", c);
break;
}
case "exportupdates":
{
if (tokens.Length < 3)
{
Console.WriteLine("Usage: exportupdates,<startDate>,<path>");
break;
}
var startDate = RFDate.Parse(tokens[1], "yyyy-MM-dd");
var c = RFCatalogMaintainer.ExportCatalogUpdates(_context, tokens[2], startDate, null, null);
Console.WriteLine("Exported {0} documents", c);
break;
}
case "run":
case "runsequential":
{
if (tokens.Length == 1)
{
Console.WriteLine("Usage: run,<fullProcessName>,<graphInstance>,<startDate>,[endDate]");
break;
}
var processName = tokens[1];
if (tokens.Length > 2)
{
var graphInstanceName = tokens[2];
var startDate = RFDate.Parse(tokens[3], "yyyy-MM-dd");
var endDate = startDate;
if (tokens.Length > 4)
{
endDate = RFDate.Parse(tokens[4], "yyyy-MM-dd");
}
var instructions = new List <RFInstruction>();
while (startDate <= endDate)
{
var graphInstance = new RFGraphInstance
{
Name = graphInstanceName,
ValueDate = startDate
};
instructions.Add(new RFGraphProcessInstruction(graphInstance, processName));
startDate = startDate.OffsetDays(1);
}
var ra = new RFRequestActivity(_context, _config);
var tracker = ra.Submit(null, instructions, null);
while (!tracker.IsComplete)
{
Thread.Sleep(100);
}
Console.WriteLine("Finished: #{0} cycles, #{1} keys, last run {2}.", tracker.FinishedCycles, tracker.KeyCount, tracker.CurrentProcess);
foreach (var message in tracker.Messages)
{
Console.WriteLine("Message: {0}: {1}", message.Key, message.Value);
}
}
else
{
// non-graph
var instruction = new RFParamProcessInstruction(
processName, new RFEngineProcessorKeyParam(RFGenericCatalogKey.Create(_config.KeyDomain, "dummy", "dummy", null)));
var ra = new RFRequestActivity(_context, _config);
var tracker = ra.Submit(null, new List <RFInstruction> {
instruction
}, null);
while (!tracker.IsComplete)
{
Thread.Sleep(100);
}
Console.WriteLine("Finished: #{0} cycles, #{1} keys, last run {2}.", tracker.FinishedCycles, tracker.KeyCount, tracker.CurrentProcess);
foreach (var message in tracker.Messages)
{
Console.WriteLine("Message: {0}: {1}", message.Key, message.Value);
}
}
break;
}
case "error":
{
_context.SystemLog.Error(this, "System Log error message");
//_context.SystemLog.Exception(this, "System Log exception message", new Exception("Test exception"));
break;
}
case "version":
{
var runLicense = RFPublicRSA.GetHost(_config.LicenseTokens.Key, _config.LicenseTokens.Value);
Console.WriteLine("RIFF Framework {0} | (c) rohatsu software studios limited | www.rohatsu.com", RFCore.sVersion);
Console.WriteLine("Licensed to '{0}' ({1})", runLicense.Key, runLicense.Value.ToString(RFCore.sDateFormat));
Console.WriteLine("Loaded engine {0} from {1} in environment {2}", _engine?.EngineName, _engine?.Assembly, _engine.Environment);
break;
}
case "email":
{
if (tokens.Length > 1)
{
var e = new RFGenericEmail(new RFEmailConfig
{
Enabled = true,
To = tokens[1]
}, string.Format("<html><body>Test email from RIFF System.<p/>Sent on {0} from {1}.</body></html>", DateTime.Now.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss \"GMT\"zzz"), Environment.MachineName));
e.Send("RIFF Test e-mail");
}
else
{
Console.WriteLine("provide email address as parameter");
}
}
break;
case "list":
{
Console.WriteLine("== PROCESSES");
foreach (var p in _config.Processes.OrderBy(p => p.Key))
{
Console.WriteLine($"\"{p.Key}\" -> {p.Value.Processor().GetType().Name}");
}
Console.WriteLine("== GRAPHS");
foreach (var g in _config.Graphs.OrderBy(g => g.Key))
{
foreach (var p in g.Value.Processes.OrderBy(p => p.Key))
{
Console.WriteLine($"\"{RFGraphDefinition.GetFullName(g.Key, p.Key)}\" -> {p.Value.Processor().GetType().Name}");
}
}
}
break;
case "scheduler":
{
if (tokens.Length == 1)
{
Console.WriteLine("Controls task scheduler. Commands: list, reload");
break;
}
_context.RaiseEvent(this, new RFServiceEvent {
ServiceName = RFSchedulerService.SERVICE_NAME, ServiceCommand = tokens[1], ServiceParams = tokens.Length > 2 ? tokens[2] : null
});
break;
}
case "rebuildgraph":
{
if (tokens.Length < 4)
{
Console.WriteLine("Usage: rebuild,<graphNameOrBlank>,<graphInstance>,<startDate>,[endDate]");
break;
}
var graphName = tokens[1];
var graphInstanceName = tokens[2];
if (tokens.Length > 3)
{
var startDate = RFDate.Parse(tokens[3], "yyyy-MM-dd");
var endDate = startDate;
if (tokens.Length > 4)
{
endDate = RFDate.Parse(tokens[4], "yyyy-MM-dd");
}
var instructions = new List <RFInstruction>();
// queue all graph processes
foreach (var vd in RFDate.Range(startDate, endDate, d => true))
{
var instance = new RFGraphInstance
{
Name = graphInstanceName,
ValueDate = vd
};
foreach (var g in this._config.Graphs.Values.Where(g => graphName.IsBlank() || g.GraphName.StartsWith(graphName, StringComparison.OrdinalIgnoreCase)))
{
foreach (var gp in g.Processes.Values)
{
var processName = RFGraphDefinition.GetFullName(gp.GraphName, gp.Name);
instructions.Add(new RFGraphProcessInstruction(instance, processName));
}
}
}
if (instructions.Any())
{
var tracker = new RFRequestActivity(_context, _config).Submit(null, instructions, null);
while (!tracker.IsComplete)
{
Thread.Sleep(100);
}
Console.WriteLine("Finished: #{0} cycles, #{1} keys, last run {2}.", tracker.FinishedCycles, tracker.KeyCount, tracker.CurrentProcess);
foreach (var message in tracker.Messages)
{
Console.WriteLine("Message: {0}: {1}", message.Key, message.Value);
}
}
}
}
break;
case "exit":
case "quit":
_isExiting = true;
break;
default:
{
if (_engineConsole != null)
{
var queueCommands = new List <string>();
if (!_engineConsole.RunCommand(tokens, queueCommands))
{
Console.WriteLine(String.Format("Unrecognized command '{0}'", tokens[0]));
}
foreach (var c in queueCommands)
{
ExecuteCommand(c);
}
}
}
break;
}
}
}
public static RFCatalogKey GetKey(RFKeyDomain domain)
{
return(RFGenericCatalogKey.Create(domain, "RFDataSources", "Global", null));
}
