public void TestBasicEncryption()
{
// tests key creation and exchange
// - between 2 clients
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router))
{
server.Start();
using (ICoreClient sender = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
using (ICoreClient recver = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
// check un-encrypted traffic
Guid evtId1 = sender.SaveObject <TestData>(new TestData("1", 1), "test", null, TimeSpan.MaxValue);
List <ICoreItem> recdList1 = recver.LoadItems <TestData>(Expr.ALL);
Assert.AreEqual <int>(1, recdList1.Count);
ICoreItem recdItem1 = recdList1[0];
Assert.AreEqual <Guid>(evtId1, recdItem1.Id);
Assert.IsNull(recdItem1.TranspKeyId);
Assert.IsNull(recdItem1.SenderKeyId);
Assert.IsNull(recdItem1.RecverKeyId);
// generate keys
string senderKeyId = sender.CryptoManager.GenerateNewKeys();
string recverKeyId = recver.CryptoManager.GenerateNewKeys();
// send encrypted message and check receiver fails to decrypt
ICoreItem sentItem2 = sender.MakeObject <TestData>(new TestData("2", 2), "test", null);
sentItem2.TranspKeyId = senderKeyId;
sentItem2.SenderKeyId = senderKeyId;
Guid evtId2 = sender.SaveItem(sentItem2);
List <ICoreItem> recdList2 = recver.LoadItems <TestData>(Expr.ALL);
Assert.AreEqual <int>(1, recdList2.Count);
ICoreItem recdItem2 = recdList2[0];
Assert.AreEqual <Guid>(evtId2, recdItem2.Id);
Assert.AreEqual <Guid>(evtId2, recdItem2.Id);
Assert.AreEqual <string>(senderKeyId, recdItem2.TranspKeyId);
Assert.AreEqual <string>(senderKeyId, recdItem2.SenderKeyId);
Assert.IsNull(recver.CryptoManager.GetTranspKey(senderKeyId));
// set public key at receiver and check authentication
recver.CryptoManager.SetPublicKey(senderKeyId, sender.CryptoManager.GetPublicKey(senderKeyId));
Assert.IsTrue(recdItem2.IsSigned);
Assert.IsFalse(recdItem2.IsSecret);
// set transport key at receiver and recheck decryption
recver.CryptoManager.SetTranspKey(senderKeyId, sender.CryptoManager.GetTranspKey(senderKeyId));
object data2 = recdItem2.Data;
Assert.IsNotNull(data2);
Assert.AreEqual <Type>(typeof(TestData), data2.GetType());
}
server.Stop();
}
}
}
public void TestPagingTechniques()
{
const bool debugRequests = true;
// loads/saves a very large number of objects
const int maxLoopCount = 5;
const int itemsPerLoop = 400;
const int itemsPerPage = 154;
const int totalItems = maxLoopCount * itemsPerLoop;
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
NamedValueSet serverSettings = new NamedValueSet();
serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Router);
serverSettings.Set(CfgPropName.EnvName, "UTT");
using (CoreServer server = new CoreServer(loggerRef, serverSettings))
{
server.Start();
// save
using (ICoreClient client1 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
for (int loop = 0; loop < maxLoopCount; loop++)
{
ICoreItem[] items = new ICoreItem[itemsPerLoop];
for (int i = 0; i < itemsPerLoop; i++)
{
client1.DebugRequests = i == 0;
int n = loop * itemsPerLoop + i;
TestData data = new TestData(n.ToString(), n);
NamedValueSet props = new NamedValueSet(new NamedValue("n", n));
items[i] = client1.MakeObject(data, "Test." + n, props);
}
client1.SaveItems(items);
}
}
// load (using original paging technique)
loggerRef.Target.LogDebug("---------- multi page load");
// - slow because it scans and sort the entire data set for each page
using (ICoreClient client3 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
// count the items
int itemCount1 = client3.CountObjects <TestData>(null);
// now get the items in pages
IExpression orderExpr = Expr.Prop("n");
client3.DebugRequests = debugRequests;
int itemCount2 = 0;
int startRow = 0;
List <ICoreItem> page;
do
{
page = client3.LoadItems <TestData>(null, orderExpr, startRow, itemsPerPage);
itemCount2 += page.Count;
startRow += page.Count;
}while (page.Count == itemsPerPage);
Assert.AreEqual(totalItems, itemCount1);
Assert.AreEqual(totalItems, itemCount2);
}
// paged load (using pre-load of item header info)
loggerRef.Target.LogDebug("---------- header pre-load");
// - faster because it only scans sorts the entire data set once and sorting
// can use local compiled methods instead of server-side expression evaluation.
using (ICoreClient client4 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
// get all the items (without data)
List <ICoreItemInfo> itemInfoList = client4.LoadItemInfos <TestData>(null);
int itemCount1 = itemInfoList.Count;
// optionally sort the list here
//IExpression orderExpr = Expr.Prop("n");
// now get the items in pages
client4.DebugRequests = debugRequests;
int itemCount2 = 0;
int maxPages = ((itemCount1 / itemsPerPage) + 1);
for (int pageNum = 0; pageNum < maxPages; pageNum++)
{
// get the item names/ids for the current page
int startRow = itemsPerPage * pageNum;
List <string> itemNames = new List <string>();
for (int i = 0; i < itemsPerPage; i++)
{
int n = startRow + i;
if (n < itemCount1)
{
itemNames.Add(itemInfoList[n].Name);
}
}
// now get the objects (with data)
var page = client4.LoadItems <TestData>(itemNames);
itemCount2 += page.Count;
}
Assert.AreEqual(totalItems, itemCount1);
Assert.AreEqual(totalItems, itemCount2);
}
}
}
}
[Ignore] // this is an integration test
public void StressUttServerLoadAndSubscribe()
{
// return an increasing number of trades until failure
// on a 4GB workstation, the limit is about 13,000 trades.
Trade trade = XmlSerializerHelper.DeserializeFromString <Trade>(
ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.xml"));
NamedValueSet tradeProps = new NamedValueSet(
ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.nvs"));
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
//NamedValueSet serverSettings = new NamedValueSet();
//serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Router);
//serverSettings.Set(CfgPropName.EnvName, "UTT");
//using (CoreServer server = new CoreServer(logger, serverSettings))
{
//server.Start();
//using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").SetHosts("localhost:8113").Create())
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
// delete the test trades
IExpression deleteExpr = Expr.ALL;
client.DeleteObjects <Trade>(deleteExpr);
const int maxLoops = 3;
const int loopRepeat = 3;
const int incrementPerLoop = 1024;
int itemsPerLoop = 1024;
int itemsSaved = 0;
for (int loop = 0; loop < maxLoops; loop++)
{
string loopName = $"Test.{loop}.";
for (int repeat = 0; repeat < loopRepeat; repeat++)
{
// create trades
loggerRef.Target.LogDebug("[{0}-{1}] Creating {2} trades...", loop, repeat, itemsPerLoop);
ICoreItem[] items = new ICoreItem[itemsPerLoop];
for (int i = 0; i < itemsPerLoop; i++)
{
string tradeName = $"Test.{loop}.{i}";
items[i] = client.MakeObject <Trade>(trade, tradeName, tradeProps);
itemsSaved++;
}
client.SaveItems(items);
// start subscription
loggerRef.Target.LogDebug("[{0}-{1}] Receiving {2} trades...", loop, repeat, itemsPerLoop);
long itemsReceived = 0;
DateTime testStartedTime = DateTime.Now;
DateTime lastReceiveTime = testStartedTime;
ISubscription subscription = client.CreateSubscription <Trade>(Expr.StartsWith(Expr.SysPropItemName, loopName));
subscription.UserCallback = delegate
{
Interlocked.Increment(ref itemsReceived);
lastReceiveTime = DateTime.Now;
};
//subscription.ExcludeDataBody = true;
subscription.Start();
// wait a bit to ensure subscription is up to date
while ((Interlocked.Add(ref itemsReceived, 0) < itemsPerLoop) && ((DateTime.Now - testStartedTime) < TimeSpan.FromSeconds(10)))
{
Thread.Sleep(100);
}
Thread.Sleep(100);
subscription.Cancel();
// load all that have been saved
loggerRef.Target.LogDebug("[{0}-{1}] Received {2} trades in {3} seconds.", loop, repeat, itemsReceived, (lastReceiveTime - testStartedTime).TotalSeconds);
Assert.AreEqual(itemsPerLoop, Interlocked.Add(ref itemsReceived, 0));
// delete the test trades
//client.DeleteObjects<Trade>(deleteExpr);
//GC.Collect();
}
// next loop
itemsPerLoop += incrementPerLoop;
} // for loop
}
}
}
}
public void TestStressServerLoadAndRetrieve()
{
// return an increasing number of trades until failure
Trade trade = XmlSerializerHelper.DeserializeFromString <Trade>(
ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.xml"));
NamedValueSet tradeProps = new NamedValueSet(
ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.nvs"));
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
NamedValueSet serverSettings = new NamedValueSet();
serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Router);
serverSettings.Set(CfgPropName.EnvName, "UTT");
using (CoreServer server = new CoreServer(loggerRef, serverSettings))
{
server.Start();
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").SetServers("localhost:8113").Create())
//using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv(EnvId.DEV_Development).Create())
{
// delete the test trades
IExpression deleteExpr = Expr.StartsWith(Expr.SysPropItemName, "Test.");
client.DeleteObjects <Trade>(deleteExpr);
const int maxLoops = 1;
const int loopRepeat = 1;
const int incrementPerLoop = 1024;
int itemsPerLoop = 8192 - 1024;
int itemsSaved = 0;
for (int loop = 0; loop < maxLoops; loop++)
{
for (int repeat = 0; repeat < loopRepeat; repeat++)
{
// create trades
loggerRef.Target.LogDebug("[{0}-{1}] Making {2} trades...", loop, repeat, itemsPerLoop);
List <IAsyncResult> completions = new List <IAsyncResult>();
ICoreItem[] items = new ICoreItem[itemsPerLoop];
for (int i = 0; i < itemsPerLoop; i++)
{
string tradeName = $"Test.{loop}.{i}";
ICoreItem item = client.MakeObject(trade, tradeName, tradeProps);
item.Freeze(); // serialises
items[i] = item;
}
loggerRef.Target.LogDebug("[{0}-{1}] Commencing save of {2} trades...", loop, repeat, itemsPerLoop);
for (int i = 0; i < itemsPerLoop; i++)
{
completions.Add(client.SaveItemBegin(items[i]));
itemsSaved++;
}
loggerRef.Target.LogDebug("[{0}-{1}] Completing save of {2} trades...", loop, repeat, itemsPerLoop);
foreach (IAsyncResult ar in completions)
{
client.SaveEnd(ar);
}
// load all that have been saved
string loopName = $"Test.{loop}.";
loggerRef.Target.LogDebug("[{0}-{1}] Loading {2} trades...", loop, repeat, itemsPerLoop);
List <ICoreItem> tradeItems = client.LoadItems <Trade>(Expr.StartsWith(Expr.SysPropItemName, loopName));
Assert.AreEqual(itemsPerLoop, tradeItems.Count);
loggerRef.Target.LogDebug("[{0}-{1}] Unpacking {2} trades...", loop, repeat, itemsPerLoop);
List <Trade> trades = new List <Trade>();
foreach (ICoreItem item in tradeItems)
{
trades.Add((Trade)item.Data);
}
loggerRef.Target.LogDebug("[{0}-{1}] Retrieved {2} trades.", loop, repeat, itemsPerLoop);
// delete the test trades
client.DeleteObjects <Trade>(deleteExpr);
GC.Collect();
}
// next loop
itemsPerLoop += incrementPerLoop;
} // for loop
}
}
}
}
public void TestSecretKeyExchange()
{
// tests key creation and exchange
// - between 2 clients
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router))
{
server.Start();
using (ICoreClient sender = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
using (ICoreClient recver = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
// generate keys
string senderKeyId = sender.CryptoManager.GenerateNewKeys();
string recverKeyId = recver.CryptoManager.GenerateNewKeys();
// hardcode the public key exchange
sender.CryptoManager.SetPublicKey(recverKeyId, recver.CryptoManager.GetPublicKey(recverKeyId));
recver.CryptoManager.SetPublicKey(senderKeyId, sender.CryptoManager.GetPublicKey(senderKeyId));
sender.DefaultLifetime = TimeSpan.FromMinutes(5);
// send secret message containing transport key
ICoreItem item1 = sender.MakeObject <string>("", "key", null);
TestData sendXKey = new TestData();
sendXKey.field1 = senderKeyId;
sendXKey.array1 = new string[1] {
sender.CryptoManager.GetTranspKey(senderKeyId)
};
item1.SetData(sendXKey);
//evt1.ItemName = "key";
item1.SenderKeyId = senderKeyId;
item1.RecverKeyId = recverKeyId;
Guid evtIdXKey = sender.SaveItem(item1);
// send encrypted message
ICoreItem item2 = sender.MakeObject <string>("", "data", null);
string text2 = XmlSerializerHelper.SerializeToString(new TestData("data", 1));
item2.SetText(text2, typeof(TestData));
item2.TranspKeyId = senderKeyId;
item2.SenderKeyId = senderKeyId;
Guid evtIdData = sender.SaveItem(item2);
// check sender
// note:
// - although sender published the key, sender cannot see it
// - however, sender can see the data
ICoreItem sentItemXKey = sender.LoadItem <TestData>("key");
Assert.IsNotNull(sentItemXKey);
Assert.AreEqual <Guid>(evtIdXKey, sentItemXKey.Id);
Assert.AreEqual <string>("key", sentItemXKey.Name);
Assert.IsTrue(sentItemXKey.IsSigned);
Assert.IsTrue(sentItemXKey.IsSecret);
//object sentTempXKey = sentItemXKey.Data; // this will fail
ICoreItem sentItemData = sender.LoadItem <TestData>("data");
Assert.IsNotNull(sentItemData);
Assert.AreEqual <Guid>(evtIdData, sentItemData.Id);
Assert.AreEqual <string>("data", sentItemData.Name);
Assert.IsTrue(sentItemData.IsSigned);
Assert.IsFalse(sentItemData.IsSecret);
object sentTempData = sentItemData.Data;
Assert.IsNotNull(sentTempData);
Assert.AreEqual <Type>(typeof(TestData), sentTempData.GetType());
TestData sentTestData = (TestData)sentTempData;
Assert.AreEqual <string>("data", sentTestData.field1);
Assert.AreEqual <int>(1, sentTestData.field2);
// check that secret transport key is received by recver
ICoreItem recdItemXKey = recver.LoadItem <TestData>("key");
Assert.IsNotNull(recdItemXKey);
Assert.AreEqual <Guid>(evtIdXKey, recdItemXKey.Id);
Assert.AreEqual <string>("key", recdItemXKey.Name);
Assert.IsTrue(recdItemXKey.IsSigned);
Assert.IsTrue(recdItemXKey.IsSecret);
object recdTempXKey = recdItemXKey.Data;
Assert.IsNotNull(recdTempXKey);
Assert.AreEqual <Type>(typeof(TestData), recdTempXKey.GetType());
TestData recdTestXKey = (TestData)recdTempXKey;
Assert.AreEqual <string>(recdTestXKey.field1, senderKeyId);
Assert.IsNotNull(recdTestXKey.array1);
Assert.AreEqual <int>(1, recdTestXKey.array1.Length);
Assert.AreEqual <string>(recdTestXKey.array1[0], sender.CryptoManager.GetTranspKey(senderKeyId));
// set the transport key and receive the 2nd data message
recver.CryptoManager.SetTranspKey(recdTestXKey.field1, recdTestXKey.array1[0]);
ICoreItem recdItemData = recver.LoadItem <TestData>("data");
Assert.IsNotNull(recdItemData);
Assert.AreEqual <Guid>(evtIdData, recdItemData.Id);
Assert.AreEqual <string>("data", recdItemData.Name);
Assert.IsTrue(recdItemData.IsSigned);
Assert.IsFalse(recdItemData.IsSecret);
object recdTempData = recdItemData.Data;
Assert.IsNotNull(recdTempData);
Assert.AreEqual <Type>(typeof(TestData), recdTempData.GetType());
TestData recdTestData = (TestData)recdTempData;
Assert.AreEqual <string>("data", recdTestData.field1);
Assert.AreEqual <int>(1, recdTestData.field2);
}
server.Stop();
}
}
}
