public void TestCoreCaching()
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router))
{
server.Start();
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
using (ICoreCache cacheA = client.CreateCache())
using (ICoreCache cacheB = client.CreateCache())
{
using (cacheA.SubscribeNoWait <TestData>(Expr.ALL, null, null))
{
using (cacheB.SubscribeNoWait <TestData>(Expr.ALL, null, null))
{
// publish an item and check all caches are consistent
Guid id0 = cacheA.SaveObject <TestData>(new TestData("Zero", 0), "Item0", null, TimeSpan.MaxValue);
// cacheA is publisher - should be immediately consistent
Assert.AreEqual <int>(1, cacheA.ItemCount);
ICoreItem item0a = cacheA.Items[0];
Assert.IsNotNull(item0a);
TestData data0a = (TestData)item0a.Data;
Assert.IsNotNull(data0a);
Assert.AreEqual <string>("Zero", (data0a.field1));
// cacheB is not publisher - allow for propagation delay
Thread.Sleep(500);
// both caches should now be consistent
Assert.AreEqual <int>(1, cacheA.ItemCount);
Assert.AreEqual <int>(1, cacheB.ItemCount);
ICoreItem item0b = cacheA.Items[0];
Assert.IsNotNull(item0b);
TestData data0b = (TestData)item0b.Data;
Assert.IsNotNull(data0b);
Assert.AreEqual <string>("Zero", (data0b.field1));
Assert.AreEqual <Guid>(item0a.Id, item0b.Id);
}
// cacheB unsubscribed - should not receive updates from cacheA
Guid id1 = cacheA.SaveObject <TestData>(new TestData("One", 1), "Item1", null);
ICoreItem data1a = cacheA.LoadItem <TestData>("Item1");
Guid id2 = cacheB.SaveObject <TestData>(new TestData("Two", 2), "Item2", null);
ICoreItem data2b = cacheB.LoadItem <TestData>("Item2");
// object is immediately available in local cache but not others
Assert.IsNotNull(data1a);
Assert.AreEqual <Guid>(id1, data1a.Id);
Assert.IsNotNull(data2b);
Assert.AreEqual <Guid>(id2, data2b.Id);
// wait a bit for propagation
Thread.Sleep(500);
// both caches should now be 'up-to-date'
// - A should receive from B, but not vice versa
Assert.AreEqual <int>(3, cacheA.ItemCount);
ICoreItem data2a = cacheA.LoadItem <TestData>("Item2");
Assert.IsNotNull(data2a);
Assert.AreEqual <Guid>(id2, data2a.Id);
// - B should be inconsistent with A
Assert.AreEqual <int>(2, cacheB.ItemCount);
// - but becomes consistent as soon as we load the missing item
ICoreItem data1b = cacheB.LoadItem <TestData>("Item1");
Assert.AreEqual <int>(3, cacheB.ItemCount);
Assert.IsNotNull(data1b);
Assert.AreEqual <Guid>(id1, data1b.Id);
}
}
}
}
public void TestDispatcherParallelism()
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
Int32 counter = 10000;
// dispatches a series of serial and parallel tasks
Dispatcher seq = new Dispatcher(loggerRef.Target, "UnitTest");
try
{
DispatcherHandle key0_root = seq.GetDispatcherHandle("");
DispatcherHandle key1_slow = seq.GetDispatcherHandle("slow");
DispatcherHandle key1_norm = seq.GetDispatcherHandle("norm");
DispatcherHandle key1_fast = seq.GetDispatcherHandle("fast");
// start first global task
key0_root.DispatchObject(delegate(object state)
{
int count1 = Interlocked.Increment(ref counter);
loggerRef.Target.LogDebug("[{0}]key0_root: (a) running", count1);
Thread.Sleep(1000);
int count2 = Interlocked.Increment(ref counter);
loggerRef.Target.LogDebug("[{0}]key0_root: (a) stopped", count2);
}, null);
Assert.AreEqual <long>(1, seq.Wait(TimeSpan.Zero));
// start 1 slow (3 second) task
for (int i = 0; i < 1; i++)
{
key1_slow.DispatchObject(delegate(object state)
{
string name = (string)state;
int count1 = Interlocked.Increment(ref counter);
loggerRef.Target.LogDebug("[{1}]key1_slow: ({0}) running", name, count1);
Thread.Sleep(3000); // 3 secs
int count2 = Interlocked.Increment(ref counter);
loggerRef.Target.LogDebug("[{1}]key1_slow: ({0}) stopped", name, count2);
}, i.ToString());
Assert.AreEqual <long>(i + 2, seq.Wait(TimeSpan.Zero));
}
// start 3 normal (1 second) tasks
for (int i = 0; i < 3; i++)
{
key1_norm.DispatchObject(delegate(object state)
{
string name = (string)state;
int count1 = Interlocked.Increment(ref counter);
loggerRef.Target.LogDebug("[{1}]key1_norm: ({0}) running", name, count1);
Thread.Sleep(1000); // 1 sec
int count2 = Interlocked.Increment(ref counter);
loggerRef.Target.LogDebug("[{1}]key1_norm: ({0}) stopped", name, count2);
}, i.ToString());
Assert.AreEqual <long>(i + 3, seq.Wait(TimeSpan.Zero));
}
// start 10 fast (0.1 second) tasks
for (int i = 0; i < 10; i++)
{
key1_fast.DispatchObject(delegate(object state)
{
string name = (string)state;
int count1 = Interlocked.Increment(ref counter);
loggerRef.Target.LogDebug("[{1}]key1_fast: ({0}) running", name, count1);
Thread.Sleep(100); // 0.1 sec
int count2 = Interlocked.Increment(ref counter);
loggerRef.Target.LogDebug("[{1}]key1_fast: ({0}) stopped", name, count2);
}, i.ToString());
Assert.AreEqual <long>(i + 6, seq.Wait(TimeSpan.Zero));
}
// start last global task
key0_root.DispatchObject(delegate(object state)
{
//int count = Interlocked.Increment(ref counter);
//loggerRef.Target.LogDebug("[{0}]key0_root: (b) running", count);
Thread.Sleep(1000);
int count2 = Interlocked.Increment(ref counter);
loggerRef.Target.LogDebug("[{0}]key0_root: (b) stopped", count2);
}, null);
Assert.AreEqual <long>(16, seq.Wait(TimeSpan.Zero));
}
finally
{
loggerRef.Target.LogDebug("all tasks dispatched");
long n = seq.Wait(TimeSpan.FromSeconds(0));
while (n > 0)
{
loggerRef.Target.LogDebug("waiting for {0} tasks", n);
n = seq.Wait(TimeSpan.FromSeconds(5));
}
seq = null;
loggerRef.Target.LogDebug("all tasks completed");
}
}
}
/// <summary>
/// Render the Like button block frontend view.
/// </summary>
/// <param name="currentBlock">The current block instance.</param>
/// <returns>Result of the redirect to the current page.</returns>
public override ActionResult Index(LikeButtonBlock currentBlock)
{
var pageLink = _pageRouteHelper.PageLink;
var targetPageRef = Reference.Create(PermanentLinkUtility.FindGuid(pageLink).ToString());
var anonymousUser = User.Identity.GetUserId() == null ? true : false;
// Create a rating block view model to fill the frontend block view
var blockModel = new LikeButtonBlockViewModel(currentBlock)
{
Link = pageLink
};
try
{
// Using the Episerver Social Rating service, get the existing rating for the current
// user (rater) and page (target). This is done only if there's a user identity. Anonymous
// users will never match a previously submitted anonymous Like rating as they are always
// uniquely generated.
if (!anonymousUser)
{
var raterUserRef = GetRaterRef();
var ratingPage = _ratingService.Get(
new Criteria <RatingFilter>
{
Filter = new RatingFilter
{
Rater = raterUserRef,
Targets = new List <Reference>
{
targetPageRef
}
},
PageInfo = new PageInfo
{
PageSize = 1
}
}
);
// Add the current Like rating, if any, to the block view model. If the user is logged
// into the site and had previously liked the current page then the CurrentRating value
// should be 1 (LIKED_RATING). Anonymous user Likes are generated with unique random users
// and thus the current anonymous user will never see a current rating value as he/she
// can Like the page indefinitely.
if (ratingPage.Results.Count() > 0)
{
blockModel.CurrentRating = ratingPage.Results.ToList().FirstOrDefault().Value.Value;
}
}
// Using the Episerver Social Rating service, get the existing Like statistics for the page (target)
var ratingStatisticsPage = _ratingStatisticsService.Get(
new Criteria <RatingStatisticsFilter>
{
Filter = new RatingStatisticsFilter
{
Targets = new List <Reference>
{
targetPageRef
}
},
PageInfo = new PageInfo
{
PageSize = 1
}
}
);
// Add the page Like statistics to the block view model
if (ratingStatisticsPage.Results.Count() > 0)
{
var statistics = ratingStatisticsPage.Results.ToList().FirstOrDefault();
if (statistics.TotalCount > 0)
{
blockModel.TotalCount = statistics.TotalCount;
}
}
}
catch (Exception)
{
// The rating service may throw a number of possible exceptions
// should handle each one accordingly -- see rating service documentation
}
return(PartialView("~/Features/Blocks/Views/LikeButtonBlock.cshtml", blockModel));
}
public void TestServerBridge()
{
// required environment:
// - local env (eg. DEV) server
// - lower env (eg. UTT) server
// creates the bridge, and check all messages published
// in local env are re-published correctly in lower env
EnvId localEnvId = EnvId.Dev_Development;
string localEnvName = EnvHelper.EnvName(localEnvId);
EnvId lowerEnvId = (localEnvId - 1);
string lowerEnvName = EnvHelper.EnvName(lowerEnvId);
int localPort = 9214;
int lowerPort = 9114;
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
CoreClientFactory clientfactory = new CoreClientFactory(loggerRef);
using (CoreServer localServer =
new CoreServer(loggerRef, localEnvName, NodeType.Router, localPort))
using (CoreServer lowerServer =
new CoreServer(loggerRef, lowerEnvName, NodeType.Router, lowerPort))
{
// start servers
localServer.Start();
lowerServer.Start();
// create clients
using (Reference <ICoreClient> localClientRef = Reference <ICoreClient> .Create(clientfactory.SetEnv(localEnvName).SetServers("localhost:" + localPort).Create()))
using (ICoreClient lowerClient = clientfactory.SetEnv(lowerEnvName).SetServers("localhost:" + lowerPort).Create())
{
using (ServerBridge bridge = new ServerBridge())
{
bridge.LoggerRef = loggerRef;
bridge.Client = localClientRef;
bridge.TargetClient = lowerClient;
// test begins here
// - start the bridge
bridge.Start();
const int sendCount = 500;
const int maxWaitSeconds = 5;
long excpCount = 0;
long recdCount = 0;
// subscribe to objects on downstream server
ISubscription subs = lowerClient.Subscribe <TestData>(Expr.ALL,
delegate(ISubscription subscription, ICoreItem item)
{
// receiver
long count = Interlocked.Increment(ref recdCount);
try
{
TestData data = (TestData)item.Data;
//loggerRef.Target.LogDebug("Recd[{0}]", data.field2);
Assert.AreEqual <long>(count, data.field2);
}
catch (Exception)
{
Interlocked.Increment(ref excpCount);
}
}, null);
long sentCount = 0;
// publish n Server events
for (int i = 1; i <= sendCount; i++)
{
Interlocked.Increment(ref sentCount);
localClientRef.Target.SaveObject <TestData>(new TestData("Test", i), "Test", null, TimeSpan.MaxValue);
}
// wait for a short period
DateTimeOffset waitStart = DateTimeOffset.Now;
DateTimeOffset waitExpiry = waitStart.AddSeconds(maxWaitSeconds);
while ((Interlocked.Add(ref recdCount, 0) < Interlocked.Add(ref sentCount, 0)) &&
(DateTimeOffset.Now < waitExpiry) &&
(Interlocked.Add(ref excpCount, 0) == 0))
{
Thread.Sleep(TimeSpan.FromSeconds(1.0));
loggerRef.Target.LogDebug("Recd/Sent: {0}/{1} items...", Interlocked.Add(ref recdCount, 0), Interlocked.Add(ref sentCount, 0));
}
loggerRef.Target.LogDebug("Duration: {0}", (DateTimeOffset.Now - waitStart));
Assert.AreEqual <long>(0, excpCount);
Assert.AreEqual <long>(sendCount, recdCount);
// done
Assert.IsTrue(true);
}
}
}
}
}
public void TestDispatcherSequencing()
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
const int InitSeqNum = 1000000;
const int scaleFactor = 50;
long seqErrors = 0;
int dispatchCount = 0;
int callbackCount = 0;
Dispatcher seq = new Dispatcher(loggerRef.Target, "TestCount");
try
{
// setup Dispatcher handles
DispatcherHandle handle0 = seq.GetDispatcherHandle("");
DispatcherHandle[] handle1 = new DispatcherHandle[scaleFactor];
DispatcherHandle[,] handle2 = new DispatcherHandle[scaleFactor, scaleFactor];
DispatcherHandle[, ,] handle3 = new DispatcherHandle[scaleFactor, scaleFactor, scaleFactor];
TestMsg prev_msg0 = null;
TestMsg[] prev_msg1 = new TestMsg[scaleFactor];
TestMsg[,] prev_msg2 = new TestMsg[scaleFactor, scaleFactor];
TestMsg[, ,] prev_msg3 = new TestMsg[scaleFactor, scaleFactor, scaleFactor];
loggerRef.Target.LogDebug("building handles...");
for (int a = 0; a < scaleFactor; a++)
{
string aKey = "a" + a.ToString();
handle1[a] = seq.GetDispatcherHandle(aKey);
for (int b = 0; b < scaleFactor; b++)
{
string bKey = aKey + "/" + "b" + b.ToString();
handle2[a, b] = seq.GetDispatcherHandle(bKey);
for (int c = 0; c < scaleFactor; c++)
{
string cKey = bKey + "/" + "c" + c.ToString();
handle3[a, b, c] = seq.GetDispatcherHandle(cKey);
}
}
}
// dispatch some events and check sequence
TestMsgDelegate testSeqNum = delegate(TestMsg thisMsg, TestMsg prevMsg)
{
if (prevMsg == null)
{
return;
}
if (thisMsg.N > prevMsg.N)
{
return;
}
// failed
Interlocked.Increment(ref seqErrors);
loggerRef.Target.LogError("{0} SeqNum ({1}) is <= PrevMsg {2} SeqNum ({3})",
thisMsg.Title, thisMsg.N, prevMsg.Title, prevMsg.N);
};
SendOrPostCallback callback = delegate(object state)
{
Interlocked.Increment(ref callbackCount);
TestMsg msg = (TestMsg)state;
//loggerRef.Target.LogDebug("{0} SeqNum ({1}) callback commenced.", msg.Title, msg.N);
Thread.Sleep(3 - (msg.L * 1));
// test sequence
// - seqnum must be greater than parents and all children
if (msg.L == 0)
{
testSeqNum(msg, prev_msg0);
for (int a = 0; a < scaleFactor; a++)
{
testSeqNum(msg, prev_msg1[a]);
for (int b = 0; b < scaleFactor; b++)
{
testSeqNum(msg, prev_msg2[a, b]);
for (int c = 0; c < scaleFactor; c++)
{
testSeqNum(msg, prev_msg3[a, b, c]);
}
}
}
prev_msg0 = msg;
}
if (msg.L == 1)
{
testSeqNum(msg, prev_msg0);
testSeqNum(msg, prev_msg1[msg.A]);
for (int b = 0; b < scaleFactor; b++)
{
testSeqNum(msg, prev_msg2[msg.A, b]);
for (int c = 0; c < scaleFactor; c++)
{
testSeqNum(msg, prev_msg3[msg.A, b, c]);
}
}
prev_msg1[msg.A] = msg;
}
if (msg.L == 2)
{
testSeqNum(msg, prev_msg0);
testSeqNum(msg, prev_msg1[msg.A]);
testSeqNum(msg, prev_msg2[msg.A, msg.B]);
for (int c = 0; c < scaleFactor; c++)
{
testSeqNum(msg, prev_msg3[msg.A, msg.B, c]);
}
prev_msg2[msg.A, msg.B] = msg;
}
if (msg.L == 3)
{
testSeqNum(msg, prev_msg0);
testSeqNum(msg, prev_msg1[msg.A]);
testSeqNum(msg, prev_msg2[msg.A, msg.B]);
testSeqNum(msg, prev_msg3[msg.A, msg.B, msg.C]);
prev_msg3[msg.A, msg.B, msg.C] = msg;
}
//loggerRef.Target.LogDebug("{0} SeqNum ({1}) callback completed.", msg.Title, msg.N);
};
loggerRef.Target.LogDebug("dispatching tasks...");
int seqnum = InitSeqNum;
handle0.DispatchObject(callback, new TestMsg(seqnum++));
for (int a = 0; a < scaleFactor; a++)
{
handle1[a].DispatchObject(callback, new TestMsg(seqnum++, a));
for (int b = 0; b < scaleFactor; b++)
{
handle2[a, b].DispatchObject(callback, new TestMsg(seqnum++, a, b));
for (int c = 0; c < scaleFactor; c++)
{
handle3[a, b, c].DispatchObject(callback, new TestMsg(seqnum++, a, b, c));
}
handle2[a, b].DispatchObject(callback, new TestMsg(seqnum++, a, b));
}
handle1[a].DispatchObject(callback, new TestMsg(seqnum++, a));
}
handle0.DispatchObject(callback, new TestMsg(seqnum++));
dispatchCount = (seqnum - InitSeqNum);
loggerRef.Target.LogDebug("dispatched {0} tasks.", dispatchCount);
}
finally
{
long n = seq.Wait(TimeSpan.FromSeconds(0));
while (n > 0)
{
loggerRef.Target.LogDebug("waiting for {0} tasks", n);
n = seq.Wait(TimeSpan.FromSeconds(5));
Assert.AreEqual <long>(0, Interlocked.Add(ref seqErrors, 0));
}
seq = null;
loggerRef.Target.LogDebug("{0} tasks completed.", callbackCount);
// test
Assert.AreEqual <int>(dispatchCount, callbackCount);
Assert.AreEqual <long>(0, Interlocked.Add(ref seqErrors, 0));
}
}
}
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 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);
}
}
}
}
private void Form1Load(object sender, EventArgs e)
{
_loggerRef = Reference <ILogger> .Create(new TextBoxLogger(txtLog));
ResetSettings();
}
public void TestFileImportServer()
{
// start the server, connect a client1, and shutdown
using (ILogger logger = new TraceLogger(true))
{
const EnvId env = EnvId.Utt_UnitTest;
var logRef = Reference <ILogger> .Create(logger);
var random = new Random(Environment.TickCount);
int port = random.Next(8000, 8099);
using (var server = new CoreServer(logRef, env.ToString(), NodeType.Router, port, WcfConst.NetTcp))
{
// start server
server.Start();
// connect client
using (ICoreClient client = new CoreClientFactory(logRef).SetEnv(env.ToString()).Create())
{
// create test import rule
var rule = new FileImportRule
{
RuleName = "UnitTest",
SourceLocation = @"C:\windows\system32",
TargetLocation = @"c:\temp",
CopyFilePatterns = "notep*.exe"
};
var name = rule.RuleName;
// start the file import server
//DateTimeOffset waitCompleted;
var target = new FileImportServer {
Client = Reference <ICoreClient> .Create(client)
};
client.SaveObject(rule, "UnitTest", null, true, TimeSpan.MaxValue);
using (target)//logger, env
{
target.Start();
Thread.Sleep(TimeSpan.FromSeconds(5));
//waitCompleted = DateTimeOffset.Now;
target.Stop();
}
{
var results1 = client.LoadItem <FileImportRule>(name);
Assert.IsNotNull(results1);
//List<ImportRuleResult> results = client.LoadObjects<ImportRuleResult>(Expr.ALL);//IRuleObject ImportRuleResult
//Assert.AreEqual(1, results.Count);
//ImportRuleResult result = results[0];
//Assert.AreEqual("UnitTest", result.RuleName);
//Assert.AreEqual("Completed", result.ImportResult);
//Assert.AreEqual(1, result.FileNames.Length);
//Assert.AreEqual("notepad.exe", result.FileNames[0].ToLower());
}
//{
// List<ImportFileResult> results = client.LoadObjects<ImportFileResult>(Expr.ALL);
// Assert.AreEqual(1, results.Count);
// ImportFileResult result = results[0];
// Assert.AreEqual("UnitTest", result.RuleName);
// Assert.AreEqual("Completed", result.ImportResult);
// Assert.AreEqual("notepad.exe", result.FileName.ToLower());
//}
}
// explicit shutdown
// - not necessary in a "using" block but run it anyway
server.Stop();
}
}
}
public void TestSerialisingDerivedTypes()
{
// tests control of the serialisation type
// - type b (derived from a) is saved as b, loaded as b;
// - type b (derived from a) is saved as a, loaded as a (but is type b).
// (in this example a = PricingStructure, b = YieldCurve)
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router))
{
// start server
server.Start();
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
{
YieldCurve dataA = new YieldCurve
{
currency = new Currency {
Value = "USD"
},
algorithm = "FastCubicSpline"
};
// - save as derived type
client.SaveObject(dataA, "TestA", null, TimeSpan.MaxValue);
ICoreItem test1 = client.LoadItem <YieldCurve>("TestA");
Assert.IsNotNull(test1);
Assert.IsNotNull(test1.Text);
Assert.AreEqual(
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<yieldCurve xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"http://www.fpml.org/FpML-5/reporting\">\r\n <currency>USD</currency>\r\n <algorithm>FastCubicSpline</algorithm>\r\n</yieldCurve>",
test1.Text);
Assert.AreEqual(typeof(YieldCurve).FullName, test1.DataTypeName);
Assert.AreEqual(typeof(YieldCurve), test1.DataType);
Assert.IsNotNull(test1.Data);
Assert.AreEqual(typeof(YieldCurve), test1.Data.GetType());
// - save as base type
client.SaveObject <PricingStructure>(dataA, "TestA", null, TimeSpan.MaxValue);
ICoreItem test2 = client.LoadItem <PricingStructure>("TestA");
Assert.IsNotNull(test2);
Assert.IsNotNull(test2.Text);
Assert.AreEqual(
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<PricingStructure xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:q1=\"http://www.fpml.org/FpML-5/reporting\" xsi:type=\"q1:YieldCurve\">\r\n <q1:currency>USD</q1:currency>\r\n <q1:algorithm>FastCubicSpline</q1:algorithm>\r\n</PricingStructure>",
test2.Text);
Assert.AreEqual(typeof(PricingStructure).FullName, test2.DataTypeName);
Assert.AreEqual(typeof(PricingStructure), test2.DataType);
Assert.IsNotNull(test2.Data);
Assert.AreEqual(typeof(YieldCurve), test2.Data.GetType());
}
{
FxCurve dataB = new FxCurve()
{
quotedCurrencyPair = new QuotedCurrencyPair()
{
currency1 = new Currency()
{
Value = "USD"
},
currency2 = new Currency()
{
Value = "JPY"
},
quoteBasis = QuoteBasisEnum.Currency2PerCurrency1
}
};
// - save as derived type
client.SaveObject(dataB, "TestB", null, TimeSpan.MaxValue);
ICoreItem test1 = client.LoadItem <FxCurve>("TestB");
Assert.IsNotNull(test1);
Assert.IsNotNull(test1.Text);
Assert.AreEqual(
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<fxCurve xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"http://www.fpml.org/FpML-5/reporting\">\r\n <quotedCurrencyPair>\r\n <currency1>USD</currency1>\r\n <currency2>JPY</currency2>\r\n </quotedCurrencyPair>\r\n</fxCurve>",
test1.Text);
Assert.AreEqual(typeof(FxCurve).FullName, test1.DataTypeName);
Assert.AreEqual(typeof(FxCurve), test1.DataType);
Assert.IsNotNull(test1.Data);
Assert.AreEqual(typeof(FxCurve), test1.Data.GetType());
// - save as base type
client.SaveObject <PricingStructure>(dataB, "TestB", null, TimeSpan.MaxValue);
ICoreItem test2 = client.LoadItem <PricingStructure>("TestB");
Assert.IsNotNull(test2);
Assert.IsNotNull(test2.Text);
Assert.AreEqual(
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<PricingStructure xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:q1=\"http://www.fpml.org/FpML-5/reporting\" xsi:type=\"q1:FxCurve\">\r\n <q1:quotedCurrencyPair>\r\n <q1:currency1>USD</q1:currency1>\r\n <q1:currency2>JPY</q1:currency2>\r\n </q1:quotedCurrencyPair>\r\n</PricingStructure>",
test2.Text);
Assert.AreEqual(typeof(PricingStructure).FullName, test2.DataTypeName);
Assert.AreEqual(typeof(PricingStructure), test2.DataType);
Assert.IsNotNull(test2.Data);
Assert.AreEqual(typeof(FxCurve), test2.Data.GetType());
}
{
// load a collection of the base type and verify specific types
List <ICoreItem> items = client.LoadItems <PricingStructure>(Expr.ALL);
Assert.AreEqual(2, items.Count);
Dictionary <string, PricingStructure> index = new Dictionary <string, PricingStructure>();
foreach (ICoreItem item in items)
{
index[item.Name] = (PricingStructure)item.Data;
}
Assert.AreEqual(typeof(YieldCurve), index["TestA"].GetType());
Assert.AreEqual(typeof(FxCurve), index["TestB"].GetType());
}
}
// shutdown
server.Stop();
}
}
}
public static void Main(string[] args)
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new ConsoleLogger("CoreDump: ")))
{
loggerRef.Target.LogInfo("Running...");
const int exitCode = 0;
try
{
// set defaults
string coreAddr = null;
// process arguments
var filterProps = new NamedValueSet();
foreach (string arg in args)
{
bool argProcessed = true;
// switches - begin with /
if (arg.StartsWith("/"))
{
// arg is a switch
string[] argParts = arg.Split(':');
string argName = argParts[0].Substring(1);
string argValue = "";
for (int j = 1; j < argParts.Length; j++)
{
if (j > 1)
{
argValue += ':';
}
argValue += argParts[j];
}
switch (argName.ToLower())
{
case "p":
string[] propParts = argValue.Split('=');
filterProps.Set(new NamedValue(propParts[0], propParts[1]));
loggerRef.Target.LogInfo(" Property: {0}={1}", propParts[0], propParts[1]);
break;
case "s":
coreAddr = argValue;
loggerRef.Target.LogInfo(" Server : {0}", coreAddr);
break;
default:
argProcessed = false;
break;
}
}
if (!argProcessed)
{
loggerRef.Target.LogInfo(" Dumps trade metadata and FpML content");
loggerRef.Target.LogInfo(" usage:");
loggerRef.Target.LogInfo(" CoreDump [options]");
loggerRef.Target.LogInfo(" /s:address the server address to connect to eg. /s:sydwadqds01:8213");
loggerRef.Target.LogInfo(" /p:name=value adds a filter property value e.g. /p:CounterpartyId=13142");
loggerRef.Target.LogInfo(" Examples: /p:CounterpartyId=13142 /p:OriginatingPartyId=1636 /p:ProductType=CrossCurrencySwap");
loggerRef.Target.LogInfo(" returns:");
loggerRef.Target.LogInfo(" 0: success");
loggerRef.Target.LogInfo(" 2: failed - see output for details");
throw new ArgumentException("Unknown argument '" + arg + "'");
}
}
// connect and query
using (ICoreClient client = new CoreClientFactory(loggerRef)
.SetEnv(BuildConst.BuildEnv)
.SetServers(coreAddr)
.SetApplication(Assembly.GetExecutingAssembly())
.Create())
{
IExpression filterExpr = Expr.BoolAND(filterProps);
loggerRef.Target.LogInfo("Selecting trades where: {0}", filterExpr.DisplayString());
ICoreItem[] tradeItems = client.LoadItems <Trade>(filterExpr).ToArray();
// dump results
loggerRef.Target.LogInfo("Saving {0} trades...", tradeItems.Length);
for (int i = 0; i < tradeItems.Length; i++)
{
ICoreItem tradeItem = tradeItems[i];
// save item
string baseFilename = Path.GetFullPath($@".\{tradeItem.Name}.xxx");
string xmlFilename = Path.ChangeExtension(baseFilename, ".xml");
string nvsFilename = Path.ChangeExtension(xmlFilename, ".nvs");
using (var sr = new StreamWriter(xmlFilename))
{
sr.Write(tradeItem.Text);
}
using (var sr = new StreamWriter(nvsFilename))
{
sr.Write(tradeItem.AppProps.Serialise());
}
// done
tradeItems[i] = null; // allows early GC of decompressed/deserialised xml content
if (i % 1000 == 0)
{
loggerRef.Target.LogInfo("Saved {0} trades...", i);
GC.Collect();
}
}
loggerRef.Target.LogInfo("Saved {0} trades.", tradeItems.Length);
}
loggerRef.Target.LogInfo("Success");
Environment.ExitCode = exitCode;
}
catch (Exception e)
{
loggerRef.Target.Log(e);
for (int i = 0; i < args.Length; i++)
{
loggerRef.Target.LogDebug(" args[{0}]='{1}'", i, args[i]);
}
loggerRef.Target.LogInfo("FAILED");
Environment.ExitCode = 2;
}
}
}
private void Form1_Load(object sender, EventArgs e)
{
_MainLog = new TextBoxLogger(txtLog);
_WorkerALog = new TextBoxLogger(txtWorkerALog);
_WorkerBLog = new TextBoxLogger(txtWorkerBLog);
_ManagerLog = new TextBoxLogger(txtManagerLog);
_ClientRef = Reference <ICoreClient> .Create(new CoreClientFactory(_MainLog).Create());
// init controls
txtWorkerComputer.Text = Environment.MachineName;
txtWorkerInstance.Text = "A";
// - form title
WinFormHelper.SetAppFormTitle(this, BuildConst.BuildEnv);
cbMarketName.Items.Add(CurveConst.QR_EOD);
cbMarketName.Items.Add(CurveConst.NAB_EOD);
cbMarketName.SelectedIndex = 0;
cbCounterParty.Items.Add("14859,Woolworths");
cbCounterParty.Items.Add("13142,Barclays");
cbCounterParty.SelectedIndex = 0;
// setup the request progress view
_ProgressViewHelper = new ProgressViewHelper();
_ProgressDataHelper = new ProgressDataHelper();
_ProgressFilters = new ComboxBoxFilterGroup(
panelProgress, _ProgressViewHelper, new EventHandler(ProgressSelectionChanged));
_ProgressSelecter = new ProgressSelecter(
_ProgressFilters, _ProgressViewHelper, _ProgressDataHelper);
_ProgressView = new ListViewManager <ProgressObj>(
_MainLog, lvProgress, _ProgressViewHelper,
_ProgressSelecter, _ProgressFilters, new ProgressSorter(), _ProgressDataHelper);
_ClientRef.Target.SubscribeNoWait <PortfolioValuationRequest>(Expr.ALL, ProgressCallback, null);
_ClientRef.Target.SubscribeNoWait <TradeValuationRequest>(Expr.ALL, ProgressCallback, null);
_ClientRef.Target.SubscribeNoWait <OrdinaryCurveGenRequest>(Expr.ALL, ProgressCallback, null);
_ClientRef.Target.SubscribeNoWait <StressedCurveGenRequest>(Expr.ALL, ProgressCallback, null);
_ClientRef.Target.SubscribeNoWait <UnassignedWorkflowRequest>(Expr.ALL, ProgressCallback, null);
_ClientRef.Target.SubscribeNoWait <AssignedWorkflowRequest>(Expr.ALL, ProgressCallback, null);
_ClientRef.Target.SubscribeNoWait <HandlerResponse>(Expr.ALL, ProgressCallback, null);
_ClientRef.Target.SubscribeNoWait <WorkerResponse>(Expr.ALL, ProgressCallback, null);
_ClientRef.Target.SubscribeNoWait <ManagerResponse>(Expr.ALL, ProgressCallback, null);
// setup the worker availability view
_AvailabilityViewHelper = new AvailabilityViewHelper();
_AvailabilityDataHelper = new AvailabilityDataHelper();
_AvailabilityFilters = new ComboxBoxFilterGroup(
panelAvailability, _AvailabilityViewHelper, new EventHandler(AvailabilitySelectionChanged));
_AvailabilitySelecter = new AvailabilitySelecter(
_AvailabilityFilters, _AvailabilityViewHelper, _AvailabilityDataHelper);
_AvailabilityView = new ListViewManager <WorkerAvailability>(
_MainLog, lvAvailability, _AvailabilityViewHelper,
_AvailabilitySelecter, _AvailabilityFilters, new AvailabilitySorter(), _AvailabilityDataHelper);
ICoreCache _AvailabilityCache = _ClientRef.Target.CreateCache(
delegate(CacheChangeData update)
{
_AvailabilityView.UpdateData(new ViewChangeNotification <WorkerAvailability>()
{
Change = update.Change,
OldData = (update.OldItem != null) ? (WorkerAvailability)update.OldItem.Data : null,
NewData = (update.NewItem != null) ? (WorkerAvailability)update.NewItem.Data : null
});
}, WindowsFormsSynchronizationContext.Current);
_AvailabilityCache.SubscribeNoWait <WorkerAvailability>(Expr.ALL, null, null);
}
static void Main(string[] args)
{
using (ConsoleLogger logger = new ConsoleLogger("SetAppCfg: "))
{
logger.LogInfo("Running...");
int exitCode = 0;
try
{
// set defaults
string coreAddr = null;
string applName = null;
string userName = null;
string hostName = null;
bool replace = false;
//bool debugOn = false;
// process arguments
NamedValueSet appCfg = new NamedValueSet();
foreach (var arg in args)
{
bool argProcessed = true;
// switches - begin with /
if (arg.StartsWith("/"))
{
// arg is a switch
string[] argParts = arg.Split(':');
string argName = argParts[0].Substring(1);
string argValue = "";
for (int j = 1; j < argParts.Length; j++)
{
if (j > 1)
{
argValue += ':';
}
argValue += argParts[j];
}
switch (argName.ToLower())
{
case "a":
applName = argValue;
logger.LogInfo(" ApplName: {0}", applName);
break;
case "u":
userName = argValue;
logger.LogInfo(" UserName: {0}", userName);
break;
case "h":
hostName = argValue;
logger.LogInfo(" HostName: {0}", hostName);
break;
case "p": // simple string property
string[] propParts = argValue.Split('=');
appCfg.Set(new NamedValue(propParts[0], propParts[1]));
logger.LogInfo(" Property: {0}={1}", propParts[0], propParts[1]);
break;
case "nv": // typed serialised named value
appCfg.Set(new NamedValue(argValue));
logger.LogInfo(" Property: {0}", argValue);
break;
case "replace":
replace = true;
logger.LogInfo(" Replace Old");
break;
case "debug":
//debugOn = true;
logger.LogInfo(" Debug On");
break;
case "s":
coreAddr = argValue;
logger.LogInfo(" Server : {0}", coreAddr);
break;
default:
argProcessed = false;
break;
}
}
if (!argProcessed)
{
logger.LogInfo(" Sets configuration values for applications, users and machines");
logger.LogInfo(" usage:");
logger.LogInfo(" SetAppCfg [options]");
logger.LogInfo(" /a:applname the application name (default: all applications)");
logger.LogInfo(" /u:username the user name (default: all users)");
logger.LogInfo(" /h:hostname the host (machine) name (default: all machines)");
logger.LogInfo(" /p:name=value sets a string property value");
logger.LogInfo(" /nv:name/type=value sets a typed property value with a serialised named value");
logger.LogInfo(" /s:address the address of the core server to connect to eg. localhost:8114");
logger.LogInfo(" /replace old values for the same application/user/host are deleted");
logger.LogInfo(" /debug logs the internal query and results to the debug port");
logger.LogInfo(" returns:");
logger.LogInfo(" 0: success - settings updated");
logger.LogInfo(" 2: error - see error output for details");
throw new ArgumentException("Unknown argument '" + arg + "'");
}
}
// save the app config
var refLogger = Reference <ILogger> .Create(logger);
using (ICoreClient client = new CoreClientFactory(refLogger).SetServers(coreAddr).Create())
{
logger.LogInfo("Old/new settings comparison for:");
logger.LogInfo(" Application: {0}", applName ?? "(all)");
logger.LogInfo(" User name : {0}", userName ?? "(all)");
logger.LogInfo(" Host name : {0}", hostName ?? "(all)");
// get old settings
NamedValueSet oldAppCfg = client.LoadAppSettings(applName, userName, hostName);
logger.LogInfo("Old settings:");
oldAppCfg.LogValues(delegate(string text) { logger.LogInfo(" " + text); });
// set new settings
client.SaveAppSettings(appCfg, applName, userName, hostName, replace);
// get new settings
NamedValueSet newAppCfg = client.LoadAppSettings(applName, userName, hostName);
logger.LogInfo("New settings:");
newAppCfg.LogValues(delegate(string text) { logger.LogInfo(" " + text); });
}
logger.LogInfo("Success");
Environment.ExitCode = exitCode;
}
catch (Exception e)
{
logger.Log(e);
for (int i = 0; i < args.Length; i++)
{
logger.LogDebug(" args[{0}]='{1}'", i, args[i]);
}
logger.LogInfo("FAILED");
Environment.ExitCode = 2;
}
}
}
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();
}
}
}
private void Form1Load(object sender, EventArgs e)
{
// create loggers
_loggerRef = Reference <ILogger> .Create(new TextBoxLogger(txtMainLog));
// create client factory and client
_clientFactory = new CoreClientFactory(_loggerRef);
_clientFactory.SetEnv(BuildConst.BuildEnv);
_clientFactory.SetApplication(Assembly.GetExecutingAssembly());
_client = _clientFactory.Create();
// - form title
WinFormHelper.SetAppFormTitle(this, EnvHelper.EnvName(BuildEnv));
// setup the AlertRule view
_alertRuleViewHelper = new AlertRuleViewHelper();
_alertRuleDataHelper = new AlertRuleDataHelper();
_alertRuleFilters = new ComboxBoxFilterGroup(
panelAlertRule, _alertRuleViewHelper, AlertRuleSelectionChanged);
_alertRuleSelecter = new AlertRuleSelecter(
_alertRuleFilters, _alertRuleViewHelper, _alertRuleDataHelper);
_alertRuleView = new ListViewManager <AlertRule>(
_loggerRef.Target, lvAlertRule, _alertRuleViewHelper,
_alertRuleSelecter, _alertRuleFilters, new AlertRuleSorter(), _alertRuleDataHelper);
ICoreCache alertRuleCache = _client.CreateCache(
update => _alertRuleView.UpdateData(new ViewChangeNotification <AlertRule>
{
Change = update.Change,
OldData =
(AlertRule)update.OldItem?.Data,
NewData =
(AlertRule)update.NewItem?.Data
}), SynchronizationContext.Current);
alertRuleCache.SubscribeNoWait <AlertRule>(Expr.ALL, null, null);
// setup the AlertSignal view
_alertSignalViewHelper = new AlertSignalViewHelper();
_alertSignalDataHelper = new AlertSignalDataHelper();
_alertSignalFilters = new ComboxBoxFilterGroup(
panelAlertSignal, _alertSignalViewHelper, AlertSignalSelectionChanged);
_alertSignalSelecter = new AlertSignalSelecter(
_alertSignalFilters, _alertSignalViewHelper, _alertSignalDataHelper);
_alertSignalView = new ListViewManager <AlertSignal>(
_loggerRef.Target, lvAlertSignal, _alertSignalViewHelper,
_alertSignalSelecter, _alertSignalFilters, new AlertSignalSorter(), _alertSignalDataHelper);
ICoreCache alertSignalCache = _client.CreateCache(
update => _alertSignalView.UpdateData(new ViewChangeNotification <AlertSignal>
{
Change = update.Change,
OldData =
(AlertSignal)update.OldItem?.Data,
NewData =
(AlertSignal)update.NewItem?.Data
}), SynchronizationContext.Current);
alertSignalCache.SubscribeNoWait <AlertSignal>(Expr.ALL, null, null);
// setup the LogEvent view
_logEventViewHelper = new LogEventViewHelper();
_logEventDataHelper = new LogEventDataHelper();
_logEventFilters = new ComboxBoxFilterGroup(
panelLogEvent, _logEventViewHelper, LogEventSelectionChanged);
_logEventSelecter = new LogEventSelecter(
_logEventFilters, _logEventViewHelper, _logEventDataHelper);
_logEventView = new ListViewManager <DebugLogEvent>(
_loggerRef.Target, lvLogEvent, _logEventViewHelper,
_logEventSelecter, _logEventFilters, new LogEventSorter(), _logEventDataHelper);
ICoreCache logEventCache = _client.CreateCache(
update => _logEventView.UpdateData(new ViewChangeNotification <DebugLogEvent>
{
Change = update.Change,
OldData =
(DebugLogEvent)update.OldItem?.Data,
NewData =
(DebugLogEvent)update.NewItem?.Data
}), SynchronizationContext.Current);
logEventCache.SubscribeNoWait <DebugLogEvent>(Expr.ALL, null, null);
// init controls
// server 0
_serverAddress[0] = txtServer0Address;
_ping[0] = chkServer0Ping;
_lastChecked[0] = txtServer0LastChecked;
_lastReplied[0] = txtServer0LastReplied;
_serverStatus[0] = txtServer0Status;
_serverReason[0] = txtServer0OtherInfo;
// server 1
_serverAddress[1] = txtServer1Address;
_ping[1] = chkServer1Ping;
_lastChecked[1] = txtServer1LastChecked;
_lastReplied[1] = txtServer1LastReplied;
_serverStatus[1] = txtServer1Status;
_serverReason[1] = txtServer1OtherInfo;
// server 2
_serverAddress[2] = txtServer2Address;
_ping[2] = chkServer2Ping;
_lastChecked[2] = txtServer2LastChecked;
_lastReplied[2] = txtServer2LastReplied;
_serverStatus[2] = txtServer2Status;
_serverReason[2] = txtServer2OtherInfo;
// server 3
_serverAddress[3] = txtServer3Address;
_ping[3] = chkServer3Ping;
_lastChecked[3] = txtServer3LastChecked;
_lastReplied[3] = txtServer3LastReplied;
_serverStatus[3] = txtServer3Status;
_serverReason[3] = txtServer3OtherInfo;
// server 4
_serverAddress[4] = txtServer4Address;
_ping[4] = chkServer4Ping;
_lastChecked[4] = txtServer4LastChecked;
_lastReplied[4] = txtServer4LastReplied;
_serverStatus[4] = txtServer4Status;
_serverReason[4] = txtServer4OtherInfo;
// server 5
_serverAddress[5] = txtServer5Address;
_ping[5] = chkServer5Ping;
_lastChecked[5] = txtServer5LastChecked;
_lastReplied[5] = txtServer5LastReplied;
_serverStatus[5] = txtServer5Status;
_serverReason[5] = txtServer5OtherInfo;
for (int i = 0; i < NServers; i++)
{
_lastChecked[i].BackColor = Color.FromKnownColor(KnownColor.Window);
_lastReplied[i].BackColor = Color.FromKnownColor(KnownColor.Window);
_serverStatus[i].BackColor = Color.FromKnownColor(KnownColor.Window);
_serverReason[i].BackColor = Color.FromKnownColor(KnownColor.Window);
}
}
public void TestUsingDerivedTypes()
{
// tests control of the serialisation type
// - type b (derived from a) is saved as b, loaded as b;
// - type b (derived from a) is saved as a, loaded as a (but is type b).
// (in this example a = PricingStructure, b = YieldCurve)
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
using (ICoreClient client = new PrivateCore(loggerRef.Target))
{
{
YieldCurve dataA = new YieldCurve()
{
currency = new Currency()
{
Value = "USD"
},
algorithm = "FastCubicSpline"
};
// - save as derived type
client.SaveObject(dataA, "TestA", null, TimeSpan.MaxValue);
ICoreItem test1 = client.LoadItem <YieldCurve>("TestA");
Assert.IsNotNull(test1);
Assert.AreEqual(typeof(YieldCurve).FullName, test1.DataTypeName);
Assert.AreEqual(typeof(YieldCurve), test1.DataType);
Assert.IsNotNull(test1.Data);
Assert.AreEqual(typeof(YieldCurve), test1.Data.GetType());
// - save as base type
client.SaveObject <PricingStructure>(dataA, "TestA", null, TimeSpan.MaxValue);
ICoreItem test2 = client.LoadItem <PricingStructure>("TestA");
Assert.IsNotNull(test2);
Assert.AreEqual(typeof(PricingStructure).FullName, test2.DataTypeName);
Assert.AreEqual(typeof(PricingStructure), test2.DataType);
Assert.IsNotNull(test2.Data);
Assert.AreEqual(typeof(YieldCurve), test2.Data.GetType());
}
{
FxCurve dataB = new FxCurve()
{
quotedCurrencyPair = new QuotedCurrencyPair()
{
currency1 = new Currency {
Value = "USD"
},
currency2 = new Currency {
Value = "JPY"
},
quoteBasis = QuoteBasisEnum.Currency2PerCurrency1
}
};
// - save as derived type
client.SaveObject(dataB, "TestB", null, TimeSpan.MaxValue);
ICoreItem test1 = client.LoadItem <FxCurve>("TestB");
Assert.IsNotNull(test1);
Assert.AreEqual(typeof(FxCurve).FullName, test1.DataTypeName);
Assert.AreEqual(typeof(FxCurve), test1.DataType);
Assert.IsNotNull(test1.Data);
Assert.AreEqual(typeof(FxCurve), test1.Data.GetType());
// - save as base type
client.SaveObject <PricingStructure>(dataB, "TestB", null, TimeSpan.MaxValue);
ICoreItem test2 = client.LoadItem <PricingStructure>("TestB");
Assert.IsNotNull(test2);
Assert.AreEqual(typeof(PricingStructure).FullName, test2.DataTypeName);
Assert.AreEqual(typeof(PricingStructure), test2.DataType);
Assert.IsNotNull(test2.Data);
Assert.AreEqual(typeof(FxCurve), test2.Data.GetType());
}
{
// load a collection of the base type and verify specific types
List <ICoreItem> items = client.LoadItems <PricingStructure>(Expr.ALL);
Assert.AreEqual(2, items.Count);
Dictionary <string, PricingStructure> index = new Dictionary <string, PricingStructure>();
foreach (ICoreItem item in items)
{
index[item.Name] = (PricingStructure)item.Data;
}
Assert.AreEqual(typeof(YieldCurve), index["TestA"].GetType());
Assert.AreEqual(typeof(FxCurve), index["TestB"].GetType());
}
}
}
}
public void TestFailingExpressions()
{
// tests expressions that fail to evaluate on the server
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())
{
client1.SaveObject(new TestData(), "AllValuesNotNull", new NamedValueSet("StrValue/String=A|NumValue/Int32=0"), TimeSpan.MaxValue);
client1.SaveObject(new TestData(), "NumValueIsNull", new NamedValueSet("StrValue/String=A"), TimeSpan.MaxValue);
client1.SaveObject(new TestData(), "StrValueIsNull", new NamedValueSet("NumValue/Int32=0"), TimeSpan.MaxValue);
client1.SaveObject(new TestData(), "AllValuesAreNull", null, TimeSpan.MaxValue);
}
// load using expression
using (ICoreClient client2 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
client2.DebugRequests = true;
{
var items = client2.LoadObjects <TestData>(Expr.BoolAND(Expr.IsEQU("StrValue", "A"), Expr.IsEQU("NumValue", 0)));
Assert.AreEqual(1, items.Count);
}
{
var items = client2.LoadObjects <TestData>(Expr.BoolOR(Expr.IsEQU("StrValue", "A"), Expr.IsEQU("NumValue", 0)));
Assert.AreEqual(3, items.Count);
}
{
// unknown/missing string property
var items = client2.LoadObjects <TestData>(Expr.BoolOR(Expr.IsEQU("StrValue", "A"), Expr.IsEQU("XValue", "X")));
Assert.AreEqual(2, items.Count);
}
{
// unknown/missing non-string property
var items = client2.LoadObjects <TestData>(Expr.BoolOR(Expr.IsEQU("StrValue", "A"), Expr.IsEQU("YValue", 1)));
Assert.AreEqual(2, items.Count);
}
{
// property missing
var items = client2.LoadObjects <TestData>(Expr.IsNull("StrValue"));
Assert.AreEqual(2, items.Count);
}
{
// property has value
var items = client2.LoadObjects <TestData>(Expr.IsNotNull("StrValue"));
Assert.AreEqual(2, items.Count);
}
{
var items = client2.LoadObjects <TestData>(Expr.StartsWith("StrValue", "A"));
Assert.AreEqual(2, items.Count);
}
{
var items = client2.LoadObjects <TestData>(Expr.BoolOR(Expr.StartsWith("StrValue", "A"), Expr.IsEQU("NumValue", 0)));
Assert.AreEqual(3, items.Count);
}
}
}
}
}
/// <summary>
/// Constructor which sets the cache
/// </summary>
/// <param name="cache"></param>
public PricingStructures(ICoreCache cache)
: this(Reference <ILogger> .Create(new TraceLogger(true)), cache, EnvironmentProp.DefaultNameSpace)
{
}
[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
}
}
}
}
/// <summary>
/// Takes action on the specified workflow item, representing a
/// membership request.
/// </summary>
/// <param name="workflowId">The id of the workflow </param>
/// <param name="action">The moderation action to be taken</param>
/// <param name="userId">The unique id of the user under moderation.</param>
/// <param name="communityId">The unique id of the community to which membership has been requested.</param>
public void Moderate(string workflowId, string action, string userId, string communityId)
{
var membershipRequest = GetMembershipRequest(userId, communityId);
var populatedWorkflowId = WorkflowId.Create(workflowId);
var requestReference = Reference.Create(CreateUri(membershipRequest.Group, membershipRequest.User));
try
{
var transitionToken = _workflowService.BeginTransitionSession(populatedWorkflowId, requestReference);
try
{
// Retrieve the moderation workflow associated with
// the item to be acted upon.
var workflow = _workflowService.Get(populatedWorkflowId);
// Leverage the workflow to determine what the
// resulting state of the item will be upon taking
// the specified action.
//retrieve the current state of the workflow item once the begintransitionsession begins.
var filter = new WorkflowItemFilter {
Target = requestReference
};
var criteria = new Criteria <WorkflowItemFilter> {
Filter = filter
};
var workflowItem = _workflowItemService.Get(criteria).Results.Last();
// Example: Current State: "Pending", Action: "Approve" => Transitioned State: "Approved"
var transitionedState = workflow.Transition(workflowItem.State, new WorkflowAction(action));
var subsequentWorkflowItem = new WorkflowItem(
workflow.Id,
transitionedState,
requestReference
);
_workflowItemService.Add(subsequentWorkflowItem, membershipRequest, transitionToken);
// Perform any application logic given the item's
// new state.
if (IsApproved(subsequentWorkflowItem.State))
{
_memberRepository.Add(_memberAdapter.Adapt(membershipRequest));
}
}
finally
{
_workflowService.EndTransitionSession(transitionToken);
}
}
catch (SocialAuthenticationException ex)
{
throw new SocialRepositoryException("The application failed to authenticate with Episerver Social.",
ex);
}
catch (MaximumDataSizeExceededException ex)
{
throw new SocialRepositoryException(
"The application request was deemed too large for Episerver Social.", ex);
}
catch (SocialCommunicationException ex)
{
throw new SocialRepositoryException("The application failed to communicate with Episerver Social.", ex);
}
catch (SocialException ex)
{
throw new SocialRepositoryException("Episerver Social failed to process the application request.", ex);
}
}
public void TestThatServiceIsMultithreaded()
{
const int nClients = 100;
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
using (TestServer server = new TestServer(loggerRef.Target, 9001))
{
const int msThreadDelay = 250;
bool multiThreaded = false;
// multiple concurrent clients
long excpCount = 0;
long startedCount = 0;
SpinLock spinlock = new SpinLock();
int maxServerThreadCount = 0;
//int maxSpinlockAttempts = 0;
//long runningCount = 0;
for (int i = 0; i < nClients; i++)
{
Interlocked.Increment(ref startedCount);
ThreadPool.QueueUserWorkItem((state) =>
{
try
{
using (TestClient client = new TestClient("localhost", 9001))
{
// wait until all client threads are running
//Interlocked.Increment(ref runningCount);
//while ((Interlocked.Add(ref runningCount, 0) < nClients) && (Interlocked.Add(ref excpCount, 0) == 0))
//{
// Thread.Sleep(100);
//}
// now call the service
int serverThreadCount = client.GetThreadCount(msThreadDelay);
if (serverThreadCount > 1)
{
multiThreaded = true;
bool spinlocked = false;
//int attempts = 0;
//int failures = 0;
while (!spinlocked)
{
//attempts++;
spinlock.Enter(ref spinlocked);
try
{
if (spinlocked)
{
if (serverThreadCount > maxServerThreadCount)
{
maxServerThreadCount = serverThreadCount;
}
//if (attempts > maxSpinlockAttempts)
// maxSpinlockAttempts = attempts;
//Thread.Sleep(100);
}
//else
// failures++;
}
finally
{
if (spinlocked)
{
spinlock.Exit();
}
}
}
}
}
}
catch (Exception)
{
Interlocked.Increment(ref excpCount);
}
finally
{
Interlocked.Decrement(ref startedCount);
}
});
}
while ((Interlocked.Add(ref startedCount, 0) > 0) && (Interlocked.Add(ref excpCount, 0) == 0))
{
Thread.Sleep(1000);
}
Assert.AreEqual <long>(0, Interlocked.Add(ref excpCount, 0));
Assert.IsTrue(maxServerThreadCount > 1);
//Assert.IsTrue(maxSpinlockAttempts > 0);
Assert.IsTrue(multiThreaded);
}
}
}
public void ConvertQuotedAssetSetsToFxCurveDefinition()
{
const string curveType = "FxCurve";
using (var logger = Reference <ILogger> .Create(new TraceLogger(true)))
{
using (ICoreClient client = (new CoreClientFactory(logger)).SetEnv(BuildConst.BuildEnv).Create())
{
IterateCurveProperties((ccy, index, marketName, tenor) =>
{
string indexName = $"{ccy}-{index}";
string curveName = $"{indexName}-{tenor}";
string qasItemName = String.Format("Orion.V5r3.MarketData.{0}.{4}.{1}-{2}-{3}",
marketName, ccy, index, tenor, curveType);
// outputs
string curveItemName = String.Format("Orion.V5r3.Configuration.PricingStructures.{0}.{4}.{1}-{2}-{3}",
marketName, ccy, index, tenor, curveType);
var marketData = client.LoadObject <QuotedAssetSet>(qasItemName);
if (marketData != null)
{
RemoveMarketQuoteValues(marketData);
var curveDef = new Market
{
id = curveName,
Items = new PricingStructure[] { new FxCurve {
id = curveName
} },
Items1 = new PricingStructureValuation[] {
new FxCurveValuation
{
id = curveName,
spotRate = new FxRateSet
{
instrumentSet = marketData.instrumentSet,
assetQuote = marketData.assetQuote
}
}
}
};
var curveProps = new NamedValueSet();
curveProps.Set(CurveProp.Market, marketName);
curveProps.Set(CurveProp.PricingStructureType, curveType);
curveProps.Set(CurveProp.IndexName, indexName);
curveProps.Set(CurveProp.IndexTenor, tenor);
curveProps.Set(CurveProp.CurveName, curveName);
curveProps.Set("Algorithm", "FastLinearZero");
curveProps.Set(CurveProp.Currency1, ccy);
curveProps.Set(CurveProp.DataGroup, "Orion.V5r3.Configuration.PricingStructureType");
curveProps.Set("SourceSystem", "Orion");
curveProps.Set("Function", "Configuration");//TODO add the namespace
curveProps.Set("Type", CurveProp.PricingStructureType);
curveProps.Set(CurveProp.UniqueIdentifier, curveItemName);
client.SaveObject(curveDef, curveItemName, curveProps, TimeSpan.MaxValue);
}
});
}
}
}
public void TestManualRecovery()
{
// demonstrates how an application should use the client in its simplest (transient) mode:
// - exceptions should be handled by the application;
// - client must be disposed and recreated after an exception has occurred;
// - subscriptions are not supported.
//TimeSpan outageDuration = TimeSpan.FromMinutes(1);
//TimeSpan requestTimeout = TimeSpan.FromSeconds(30);
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
loggerRef.Target.LogDebug("----------> test commenced");
// create unit test storage
IStoreEngine unitTestStore = new UnitTestStoreEngine(loggerRef.Target);
CoreServer server = null;
try
{
var serverSettings = new NamedValueSet();
serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Server);
serverSettings.Set(CfgPropName.EnvName, "UTT");
server = new CoreServer(loggerRef, serverSettings)
{
StoreEngine = unitTestStore
};
loggerRef.Target.LogDebug("----------> starting server");
server.Start();
// create 1st client and save object - should succeed
Guid id1;
using (ICoreClient client1 = new CoreClientFactory(loggerRef)
.SetEnv("UTT")
.Create())
{
id1 = client1.SaveObject(new TestData("Test1", 1), "Test1", null, TimeSpan.MaxValue);
// stop server and begin save - should fail with timeout
loggerRef.Target.LogDebug("----------> stopping server");
server.Stop();
DisposeHelper.SafeDispose(ref server);
client1.RequestTimeout = TimeSpan.FromSeconds(10);
UnitTestHelper.AssertThrows <TimeoutException>(() =>
{
client1.SaveObject(new TestData("Test2a", 2), "Test2", null, TimeSpan.MaxValue);
});
// further use of client throws more timeout errors
UnitTestHelper.AssertThrows <TimeoutException>(() => { client1.LoadObject <TestData>("Test2a"); });
}
// create 2nd client - should fail to connect
UnitTestHelper.AssertThrows <EndpointNotFoundException>("No server in list 'localhost:8113' found!", () =>
{
using (ICoreClient client2 = new CoreClientFactory(loggerRef)
.SetEnv("UTT")
.Create())
{
client2.SaveObject <TestData>(new TestData("Test2b", 2), "Test2", null, TimeSpan.MaxValue);
}
});
// restart server
server = new CoreServer(loggerRef, serverSettings)
{
StoreEngine = unitTestStore
};
loggerRef.Target.LogDebug("----------> restarting server");
server.Start();
// load 1st object - should succeed
ICoreItem item1;
ICoreItem item2;
using (ICoreClient client3 = new CoreClientFactory(loggerRef)
.SetEnv("UTT")
.Create())
{
item1 = client3.LoadItem <TestData>("Test1");
item2 = client3.LoadItem <TestData>("Test2");
}
Assert.IsNotNull(item1);
Assert.AreEqual(id1, item1.Id);
Assert.IsNull(item2);
// done
loggerRef.Target.LogDebug("----------> test completed");
server.Stop();
DisposeHelper.SafeDispose(ref server);
}
finally
{
DisposeHelper.SafeDispose(ref server);
}
}
}
public void ConvertQuotedAssetSetsToDiscountCurveDefinition()
{
using (var logger = Reference <ILogger> .Create(new TraceLogger(true)))
{
using (ICoreClient client = (new CoreClientFactory(logger)).SetEnv(BuildConst.BuildEnv).Create())
{
const string instrument = "LIBOR";
const string seniority = "SENIOR";
foreach (string ccy in "AUD;USD;EUR;NZD;GBP".Split(';'))
{
foreach (string marketName in CurveConst.QR_LIVE.Split(';'))
{
//foreach (string tenor in "3M".Split(';'))
{
//string indexName = String.Format("{0}-{1}", ccy, index);
string curveName = $"{ccy}-{instrument}-{seniority}";
string qasItemName = $"Orion.V5r3.MarketData.{marketName}.DiscountCurve.{curveName}";
// outputs
string curveItemName =
$"Orion.V5r3.Configuration.PricingStructures.{marketName}.DiscountCurve.{curveName}";
var marketData = client.LoadObject <QuotedAssetSet>(qasItemName);
if (marketData != null)
{
// strip out market quote values
foreach (var tradeItem in marketData.assetQuote)
{
foreach (var quote in tradeItem.quote)
{
if (quote.measureType.Value == "MarketQuote")
{
quote.valueSpecified = false;
quote.value = 0.0m;
}
}
}
var curveDef = new Market
{
id = curveName,
Items = new PricingStructure[] { new YieldCurve {
id = curveName
} },
Items1 = new PricingStructureValuation[] {
new YieldCurveValuation {
id = curveName, inputs = marketData
}
}
};
var curveProps = new NamedValueSet();
curveProps.Set(CurveProp.Market, marketName);
curveProps.Set(CurveProp.PricingStructureType, "DiscountCurve");
//curveProps.Set(CurveProp.IndexName, indexName);
//curveProps.Set(CurveProp.IndexTenor, tenor);
curveProps.Set("CreditInstrumentId", instrument);
curveProps.Set("CreditSeniority", seniority);
curveProps.Set(CurveProp.CurveName, curveName);
curveProps.Set("Algorithm", "FastLinearZero");
curveProps.Set(CurveProp.Currency1, ccy);
curveProps.Set(CurveProp.DataGroup, "Orion.V5r3.Configuration.PricingStructureType");
curveProps.Set("SourceSystem", "Orion");
curveProps.Set("Function", "Configuration");
curveProps.Set("Type", CurveProp.PricingStructureType);
curveProps.Set(CurveProp.UniqueIdentifier, curveItemName);
client.SaveObject(curveDef, curveItemName, curveProps, TimeSpan.MaxValue);
}
}
}
}
}
}
}
public void TestDispatcherScalability()
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
const int InitSeqNum = 1000000;
const int scaleFactor = 20; // => 20^4 (or 160,000) tasks
int dispatchCount = 0;
int callbackCount = 0;
Dispatcher seq = new Dispatcher(loggerRef.Target, "TestCount");
try
{
// setup Dispatcher handles
DispatcherHandle handle0 = seq.GetDispatcherHandle("");
DispatcherHandle[] handle1 = new DispatcherHandle[scaleFactor];
DispatcherHandle[,] handle2 = new DispatcherHandle[scaleFactor, scaleFactor];
DispatcherHandle[, ,] handle3 = new DispatcherHandle[scaleFactor, scaleFactor, scaleFactor];
DispatcherHandle[, , ,] handle4 = new DispatcherHandle[scaleFactor, scaleFactor, scaleFactor, scaleFactor];
//TestMsg prev_msg0 = null;
//TestMsg[] prev_msg1 = new TestMsg[scaleFactor];
//TestMsg[,] prev_msg2 = new TestMsg[scaleFactor, scaleFactor];
//TestMsg[, ,] prev_msg3 = new TestMsg[scaleFactor, scaleFactor, scaleFactor];
for (int a = 0; a < scaleFactor; a++)
{
string aKey = "a" + a.ToString();
handle1[a] = seq.GetDispatcherHandle(aKey);
for (int b = 0; b < scaleFactor; b++)
{
string bKey = aKey + "/" + "b" + a.ToString();
handle2[a, b] = seq.GetDispatcherHandle(bKey);
for (int c = 0; c < scaleFactor; c++)
{
string cKey = bKey + "/" + "c" + a.ToString();
handle3[a, b, c] = seq.GetDispatcherHandle(cKey);
for (int d = 0; d < scaleFactor; d++)
{
string dKey = cKey + "/" + "d" + a.ToString();
handle4[a, b, c, d] = seq.GetDispatcherHandle(dKey);
}
}
}
}
// dispatch some events and check sequence
SendOrPostCallback callback = delegate(object state)
{
Interlocked.Increment(ref callbackCount);
TestMsg msg = (TestMsg)state;
//loggerRef.Target.LogDebug("{0} SeqNum ({1}) callback commenced.", msg.Title, msg.N);
//Thread.Sleep(30 - (msg.L * 10));
//loggerRef.Target.LogDebug("{0} SeqNum ({1}) callback completed.", msg.Title, msg.N);
};
loggerRef.Target.LogDebug("dispatching tasks...");
int seqnum = InitSeqNum;
handle0.DispatchObject(callback, new TestMsg(seqnum++));
for (int a = 0; a < scaleFactor; a++)
{
handle1[a].DispatchObject(callback, new TestMsg(seqnum++, a));
for (int b = 0; b < scaleFactor; b++)
{
handle2[a, b].DispatchObject(callback, new TestMsg(seqnum++, a, b));
for (int c = 0; c < scaleFactor; c++)
{
handle3[a, b, c].DispatchObject(callback, new TestMsg(seqnum++, a, b, c));
for (int d = 0; d < scaleFactor; d++)
{
handle4[a, b, c, d].DispatchObject(callback, new TestMsg(seqnum++, a, b, c, d));
}
handle3[a, b, c].DispatchObject(callback, new TestMsg(seqnum++, a, b, c));
}
handle2[a, b].DispatchObject(callback, new TestMsg(seqnum++, a, b));
}
handle1[a].DispatchObject(callback, new TestMsg(seqnum++, a));
}
handle0.DispatchObject(callback, new TestMsg(seqnum++));
dispatchCount = (seqnum - InitSeqNum);
loggerRef.Target.LogDebug("dispatched {0} tasks.", dispatchCount);
}
finally
{
long n = seq.Wait(TimeSpan.FromSeconds(0));
while (n > 0)
{
loggerRef.Target.LogDebug("waiting for {0} tasks", n);
n = seq.Wait(TimeSpan.FromSeconds(5));
}
seq = null;
loggerRef.Target.LogDebug("{0} tasks completed.", callbackCount);
// test
Assert.AreEqual <int>(dispatchCount, callbackCount);
}
}
}
public void ProcessRequest(RequestBase baseRequest, HandlerResponse response)
{
if (baseRequest == null)
{
throw new ArgumentNullException(nameof(baseRequest));
}
var request = baseRequest as OrdinaryCurveGenRequest;
if (request == null)
{
throw new InvalidCastException(
$"{typeof(RequestBase).Name} is not a {typeof(OrdinaryCurveGenRequest).Name}");
}
CurveSelection[] curveSelectors = request.CurveSelector ?? new List <CurveSelection>().ToArray();
response.ItemCount = curveSelectors.Length;
DateTime lastStatusPublishedAt = DateTime.Now;
// check for workflow cancellation
if (Cancelled)
{
throw new OperationCanceledException(CancelReason);
}
// iterate selected curves
foreach (CurveSelection curveSelector in curveSelectors)
{
// publish 'intermediate' in-progress result (throttled)
if ((DateTime.Now - lastStatusPublishedAt) > TimeSpan.FromSeconds(5))
{
lastStatusPublishedAt = DateTime.Now;
response.Status = RequestStatusEnum.InProgress;
Context.Cache.SaveObject(response);
}
string nameSpace = curveSelector.NameSpace;
string inputMarketName = curveSelector.MarketName;
string inputCurveName = curveSelector.CurveName;
string inputCurveType = curveSelector.CurveType;
// given a curve definition, this workflow generates:
// - a live base curve using current market data
// load curve definition
Context.Logger.LogDebug("Building ordinary curve: {0}.{1}.{2}", inputMarketName, inputCurveType, inputCurveName);
string curveUniqueId =
$"Configuration.PricingStructures.{inputMarketName}.{inputCurveType}.{inputCurveName}";
//TODO This does not work for MArket=Test_EOD because the market date propeerty
//is not included in the identifier and unique identifier!
ICoreItem marketItem = LoadAndCheckMarketItem(Context.Cache, nameSpace, curveUniqueId);
// check data is not mutated
//AssertNotModified<Market>(marketItem);
// note: we must clone the definition to avoid updating it in the cache!
var market = marketItem.GetData <Market>(true);
//AssertSomeQuotesMissing(((YieldCurveValuation)(cachedMarket.Items1[0])).inputs);
//Market clonedMarket = BinarySerializerHelper.Clone<Market>(cachedMarket);
PricingStructure ps = market.Items[0];
PricingStructureValuation psv = market.Items1[0];
// supply base data and build datetime
psv.baseDate = new IdentifiedDate {
Value = request.BaseDate
};
QuotedAssetSet curveDefinition;
if (psv is YieldCurveValuation curveValuation)
{
curveDefinition = curveValuation.inputs;
}
else
{
if (psv is FxCurveValuation valuation)
{
curveDefinition = valuation.spotRate;
}
else
{
throw new NotSupportedException("Unsupported PricingStructureValuation type: " + psv.GetType().Name);
}
}
//AssertSomeQuotesMissing(curveDefinition);
// default outputs
var curveDefProps = new NamedValueSet(marketItem.AppProps);
var curveType = PropertyHelper.ExtractPricingStructureType(curveDefProps);//.GetValue<string>(CurveProp.PricingStructureType, true));
var curveName = curveDefProps.GetValue <string>(CurveProp.CurveName, true);
string marketDataItemName = String.Format(FunctionProp.QuotedAssetSet.ToString() + ".{0}.{1}.{2}", inputMarketName, curveType, curveName);
curveDefProps.Set("BootStrap", true);
curveDefProps.Set(CurveProp.BaseDate, request.BaseDate);
IPricingStructureIdentifier liveCurveId = PricingStructureIdentifier.CreateMarketCurveIdentifier(curveDefProps, inputMarketName, null, null, null, null);
NamedValueSet liveCurveProps = liveCurveId.Properties;
var liveCurveItemName = liveCurveProps.GetValue <string>(CurveProp.UniqueIdentifier, true);
var liveCurve = new Market(); // empty
try
{
// build a request/response map (indexed by instrument id)
var instrumentMap = new Dictionary <string, Asset>();
foreach (Asset asset in curveDefinition.instrumentSet.Items)
{
instrumentMap[asset.id.ToLower()] = asset;
}
int bavNum = 0;
foreach (BasicAssetValuation quoteInstr in curveDefinition.assetQuote)
{
if (quoteInstr.objectReference?.href == null)
{
throw new ApplicationException($"Missing objectReference in BasicAssetValuation[{bavNum}]");
}
string instrId = quoteInstr.objectReference.href;
if (!instrumentMap.TryGetValue(instrId.ToLower(), out _))
{
throw new ApplicationException($"Cannot find instrument '{instrId}' for assetQuote");
}
bavNum++;
}
// request market data from MDS
QuotedAssetSet marketData;
if (request.UseSavedMarketData)
{
// get saved market data
marketData = Context.Cache.LoadObject <QuotedAssetSet>(nameSpace + "." + marketDataItemName);
if (marketData == null)
{
throw new ApplicationException(
$"Could not load saved market data with name: '{marketDataItemName}'");
}
}
else
{
//throw new NotImplementedException();
using (var mdc = MarketDataFactory.Create(Reference <ILogger> .Create(Context.Logger), Assembly.GetExecutingAssembly(), null))
{
// call MDS
//AssertSomeQuotesMissing(curveDefinition);
Guid mdsRequestId = Guid.NewGuid();
MDSResult <QuotedAssetSet> mdsResponse = mdc.GetMarketQuotes(
MDSProviderId.Bloomberg, null, mdsRequestId, true, null,
curveDefinition);
if (mdsResponse.Error != null)
{
throw mdsResponse.Error;
}
marketData = mdsResponse.Result;
if ((marketData.assetQuote == null) || marketData.assetQuote.Length < 1)
{
throw new ApplicationException($"MDS response contains no quotes! ({mdsRequestId})");
}
// save transient market data for later offline use
if (request.SaveMarketData)
{
var marketDataProps = new NamedValueSet();
marketDataProps.Set(liveCurveProps.Get(EnvironmentProp.NameSpace));//TODO Added to filter on client namespace!
marketDataProps.Set(liveCurveProps.Get(CurveProp.Market));
marketDataProps.Set(liveCurveProps.Get(CurveProp.PricingStructureType));
marketDataProps.Set(liveCurveProps.Get(CurveProp.CurveName));
marketDataProps.Set(liveCurveProps.Get(CurveProp.Currency1));
Context.Cache.SaveObject(marketData, marketDataItemName, marketDataProps, true, TimeSpan.FromDays(7));
}
}
}
// check market data for undefined/invalid quotes
foreach (BasicAssetValuation asset in marketData.assetQuote)
{
if (asset.quote.Any(quote => quote.measureType.Value.Equals("undefined", StringComparison.OrdinalIgnoreCase)))
{
throw new ApplicationException(
$"Market quote undefined/missing for asset '{asset.objectReference.href}'");
}
}
// merge MDS results with stored quotes in the curve definition
curveDefinition.Replace(marketData);//Merge(marketData, true, false, true);
// generate ordinary base curve
if (psv is YieldCurveValuation valuation)
{
valuation.inputs = curveDefinition;
}
else
{
((FxCurveValuation)psv).spotRate = new FxRateSet
{
instrumentSet = curveDefinition.instrumentSet,
assetQuote = curveDefinition.assetQuote
};
}
// hack - if rate basis curve then call new triplet fn, else call old pair fn.
IPricingStructure ips;
switch (curveType)
{
case PricingStructureTypeEnum.RateBasisCurve:
{
// rate basis curves require a reference curve
string refCurveUniqueId =
$"Market.{inputMarketName}.{curveDefProps.GetValue<string>(CurveProp.ReferenceCurveName, true)}";
// load the reference curve
ICoreItem refCurveItem = LoadAndCheckMarketItem(Context.Cache, nameSpace, refCurveUniqueId);
var refCurve = (Market)refCurveItem.Data;
//Format the ref curve data and call the pricing structure helper.
var refCurveFpMLTriplet = new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(refCurve.Items[0],
refCurve.Items1[0], refCurveItem.AppProps);
liveCurveProps.Set(CurveProp.ReferenceCurveUniqueId, refCurveUniqueId);
var spreadCurveFpMLTriplet = new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(ps, psv, liveCurveProps);
//create and set the pricingstructure
ips = CurveLoader.LoadInterestRateCurve(Context.Logger, Context.Cache, nameSpace, refCurveFpMLTriplet, spreadCurveFpMLTriplet);
//Creator.Create(refCurveFpMLTriplet, spreadCurveFpMLTriplet);
}
break;
case PricingStructureTypeEnum.RateXccyCurve:
{
// rate basis curves require a base curve
string baseCurveUniqueId = String.Format(nameSpace + ".Market.{0}.{1}",
inputMarketName, curveDefProps.GetValue <string>(CurveProp.ReferenceCurveName, true));
// load the reference curve
ICoreItem baseCurveItem = LoadAndCheckMarketItem(Context.Cache, nameSpace, baseCurveUniqueId);
var baseCurve = (Market)baseCurveItem.Data;
// rate basis curves require an fx curve
string fxCurveUniqueId = String.Format(nameSpace + ".Market.{0}.{1}",
inputMarketName, curveDefProps.GetValue <string>(CurveProp.ReferenceFxCurveName, true));
// load the reference curve
ICoreItem fxCurveItem = LoadAndCheckMarketItem(Context.Cache, nameSpace, fxCurveUniqueId);
var fxCurve = (Market)fxCurveItem.Data;
// rate basis curves require a reference curve
string refCurveUniqueId = String.Format(nameSpace + ".Market.{0}.{1}",
inputMarketName, curveDefProps.GetValue <string>(CurveProp.ReferenceCurrency2CurveName, true));
// load the reference curve
ICoreItem refCurveItem = LoadAndCheckMarketItem(Context.Cache, nameSpace, refCurveUniqueId);
var refCurve = (Market)refCurveItem.Data;
//Format the ref curve data and call the pricing structure helper.
var baseCurveFpMLTriplet = new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(baseCurve.Items[0],
baseCurve.Items1[0], baseCurveItem.AppProps);
var fxCurveFpMLTriplet = new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(fxCurve.Items[0],
fxCurve.Items1[0], fxCurveItem.AppProps);
var refCurveFpMLTriplet = new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(refCurve.Items[0],
refCurve.Items1[0], refCurveItem.AppProps);
liveCurveProps.Set(CurveProp.ReferenceCurveUniqueId, baseCurveUniqueId);
liveCurveProps.Set(CurveProp.ReferenceFxCurveUniqueId, fxCurveUniqueId);
liveCurveProps.Set(CurveProp.ReferenceCurrency2CurveId, refCurveUniqueId);
var spreadCurveFpMLTriplet = new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(ps, psv, liveCurveProps);
//create and set the pricingstructure
ips = CurveLoader.LoadInterestRateCurve(Context.Logger, Context.Cache, nameSpace, baseCurveFpMLTriplet,
fxCurveFpMLTriplet, refCurveFpMLTriplet, spreadCurveFpMLTriplet);
//Creator.Create(baseCurveFpMLTriplet, fxCurveFpMLTriplet, refCurveFpMLTriplet, spreadCurveFpMLTriplet);
}
break; //TODO Add Volatility types as well
default:
{
ips = CurveLoader.LoadCurve(Context.Logger, Context.Cache,
nameSpace, new Pair <PricingStructure, PricingStructureValuation>(ps, psv),
liveCurveProps);
//Creator.Create(new Pair<PricingStructure, PricingStructureValuation>(ps, psv), liveCurveProps);
}
break;
}
// retrieve curve
liveCurve = PricingStructureHelper.CreateMarketFromFpML(
ips.GetPricingStructureId().UniqueIdentifier,
ips.GetFpMLData());
// curve done
response.IncrementItemsPassed();
}
catch (Exception innerExcp)
{
response.IncrementItemsFailed();
Context.Logger.Log(innerExcp);
liveCurveProps.Set(WFPropName.ExcpName, WFHelper.GetExcpName(innerExcp));
liveCurveProps.Set(WFPropName.ExcpText, WFHelper.GetExcpText(innerExcp));
}
// ================================================================================
// calculate curve lifetimes
// SOD = 8am, EOD = 4:30pm
// live curves
// - publish anytime
// - expires SOD next day
// EOD (today) curves
// - publish for 15 minutes prior to EOD today
// - expires in 7 days
// EOD (dated) - 7 days
// - publish for 15 minutes prior to EOD today
// - expires in 7 days
DateTime dtNow = DateTime.Now;
DateTime dtToday = dtNow.Date;
DateTime dtEODPublishBegin = dtToday.AddHours(16.25); // 4:15pm today
DateTime dtEODPublishUntil = dtToday.AddHours(16.5); // 4:30pm today
DateTime dtSODTomorrow = dtToday.AddHours(24 + 8); // 8am tomorrow
//DateTime dtEODTomorrow = dtToday.AddHours(24 + 16); // 4pm tomorrow
// publish live curve
Context.Cache.SaveObject(liveCurve, nameSpace + "." + liveCurveItemName, liveCurveProps, true, dtSODTomorrow);
// republish as latest EOD curve
if (request.ForceGenerateEODCurves || ((dtNow >= dtEODPublishBegin) && (dtNow <= dtEODPublishUntil)))
{
NamedValueSet itemProps = PricingStructureIdentifier.CreateMarketCurveIdentifier(liveCurveProps, CurveConst.QR_EOD, null, null, null, null).Properties;
var itemName = itemProps.GetValue <string>(CurveProp.UniqueIdentifier, true);
// persistent
Context.Cache.SaveObject(liveCurve, nameSpace + "." + itemName, itemProps, false, TimeSpan.FromDays(7));
}
// republish as dated EOD curve
if (request.ForceGenerateEODCurves || ((dtNow >= dtEODPublishBegin) && (dtNow <= dtEODPublishUntil)))
{
NamedValueSet itemProps = PricingStructureIdentifier.CreateMarketCurveIdentifier(liveCurveProps, CurveConst.QR_EOD, dtToday, null, null, null).Properties;
var itemName = itemProps.GetValue <string>(CurveProp.UniqueIdentifier, true);
// persistent
Context.Cache.SaveObject(liveCurve, nameSpace + "." + itemName, itemProps, false, TimeSpan.FromDays(7));
}
} // foreach curve
// success
response.Status = RequestStatusEnum.Completed;
}
static void Main(string[] args)
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new ConsoleLogger("TestMds: ")))
{
loggerRef.Target.LogInfo("{0} Started.", DateTime.Now);
try
{
const MDSProviderId provider = MDSProviderId.Bloomberg;
var settings = new NamedValueSet();
const int port = 9123;
settings.Set(MdsPropName.Port, port);
settings.Set(MdsPropName.EnabledProviders, new[] { MDSProviderId.GlobalIB.ToString(), provider.ToString() });
using (Reference <ICoreClient> clientRef = Reference <ICoreClient> .Create(new CoreClientFactory(loggerRef).SetEnv(BuildConst.BuildEnv).Create()))
using (var mds = new MarketDataServer())
{
mds.LoggerRef = loggerRef;
mds.Client = clientRef;
mds.OtherSettings = settings;
mds.Start();
loggerRef.Target.LogDebug("Waiting...");
Thread.Sleep(15000);
loggerRef.Target.LogDebug("Continuing...");
List <ICoreItem> marketItems;
{
marketItems = clientRef.Target.LoadItems <Market>(Expr.StartsWith(Expr.SysPropItemName, "Orion.V5r3.Configuration."));
}
if (marketItems.Count == 0)
{
throw new ApplicationException("No curve definitions found!");
}
using (IMarketDataClient mdc = MarketDataFactory.Create(loggerRef, null, "localhost:" + port.ToString(CultureInfo.InvariantCulture)))
{
foreach (ICoreItem marketItem in marketItems)
{
loggerRef.Target.LogDebug("Curve: {0}", marketItem.Name);
var market = (Market)marketItem.Data;
//PricingStructure ps = market.Items[0];
PricingStructureValuation psv = market.Items1[0];
QuotedAssetSet curveDefinition;
if (psv is YieldCurveValuation valuation)
{
curveDefinition = valuation.inputs;
}
else
{
if (psv is FxCurveValuation curveValuation)
{
curveDefinition = new QuotedAssetSet
{
instrumentSet = curveValuation.spotRate.instrumentSet,
assetQuote = curveValuation.spotRate.assetQuote
}
}
;
else
{
throw new NotSupportedException("Unsupported PricingStructureValuation type: " + psv.GetType().Name);
}
}
// call MDS
MDSResult <QuotedAssetSet> mdsResponse = mdc.GetMarketQuotes(
provider, null, Guid.NewGuid(), false,
null, // caspar-specific parameters
curveDefinition);
if (mdsResponse.Error != null)
{
throw mdsResponse.Error;
}
foreach (BasicAssetValuation result in mdsResponse.Result.assetQuote)
{
string instrId = result.objectReference.href;
foreach (BasicQuotation quote in result.quote)
{
string fieldId = quote.GetStandardFieldName();
loggerRef.Target.LogDebug("{0}/{1} ({2}/{3}) = [{4}]",
instrId, fieldId, quote.measureType.Value, quote.quoteUnits.Value, quote.value);
}
}
}
} // using MDC
mds.Stop();
}// using MDS
}
catch (Exception e)
{
loggerRef.Target.Log(e);
}
loggerRef.Target.LogInfo("{0} Completed.", DateTime.Now);
loggerRef.Target.LogInfo("Press ENTER to exit.");
Console.ReadLine();
}
}
static void Main(string[] args)
{
Reference <ILogger> loggerRef = Reference <ILogger> .Create(new ConsoleLogger("TestWebMdc: "));
loggerRef.Target.LogInfo("Running...");
try
{
// get some market quotes from for a Highlander FX curve
// and get a Highlander volatility matrix
const string curveName = "Orion.V5r3.Configuration.PricingStructures.QR_LIVE.FxCurve.AUD-USD";
QuotedAssetSet quotedAssetSet;
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv(BuildConst.BuildEnv).Create())
{
ICoreItem marketItem = client.LoadItem <Market>(curveName);
if (marketItem == null)
{
throw new ApplicationException("Market '" + curveName + "' not found!");
}
var market = (Market)marketItem.Data;
//PricingStructure ps = market.Items[0];
PricingStructureValuation psv = market.Items1[0];
var valuation = psv as YieldCurveValuation;
if (valuation != null)
{
quotedAssetSet = valuation.inputs;
}
else
{
var curveValuation = psv as FxCurveValuation;
if (curveValuation != null)
{
quotedAssetSet = new QuotedAssetSet
{
instrumentSet = curveValuation.spotRate.instrumentSet,
assetQuote = curveValuation.spotRate.assetQuote
}
}
;
else
{
throw new NotSupportedException("Unsupported PricingStructureValuation type: " + psv.GetType().Name);
}
}
}
//Copied from the working version
const int port = 9123;
// create MDS client
using (IMarketDataClient mdc = MarketDataFactory.Create(loggerRef, null, "localhost:" + port.ToString(CultureInfo.InvariantCulture)))//This was null in the 3rd parameter.
{
{
const MDSProviderId providerId = MDSProviderId.Bloomberg;
loggerRef.Target.LogInfo("----- {0} Market Quotes -----", providerId);
QuotedAssetSet quotes = mdc.GetMarketQuotes(
providerId, null, Guid.NewGuid(), true, null,
quotedAssetSet).Result;
LogResults(loggerRef.Target, quotes);
}
{
const MDSProviderId providerId = MDSProviderId.GlobalIB;
loggerRef.Target.LogInfo("----- {0} Volatility Matrix -----", providerId);
var matrixProps = new NamedValueSet();
matrixProps.Set("Function", "MarketData");
matrixProps.Set("Market", "EOD");
matrixProps.Set("CurveName", "AUD-Swap");
matrixProps.Set("PricingStructureType", "RateATMVolatilityMatrix");
QuotedAssetSet matrix = mdc.GetPricingStructure(
providerId, null, Guid.NewGuid(), true, null,
matrixProps).Result;
LogResults(loggerRef.Target, matrix);
}
}
}
catch (Exception e)
{
loggerRef.Target.Log(e);
}
loggerRef.Target.LogInfo("Completed.");
loggerRef.Target.LogInfo("Press ENTER to exit.");
Console.ReadLine();
}
/// <summary>
/// Adapt the application PageComment to the Episerver Social Comment
/// </summary>
/// <param name="comment">The application's PageComment.</param>
/// <returns>The Episerver Social Comment.</returns>
private Comment AdaptPageComment(PageComment comment)
{
return(new Comment(Reference.Create(comment.Target), Reference.Create(comment.AuthorId), comment.Body,
true));
}
/// <summary>
/// Adapt the application PageSubscription to the Episerver Social Subscription
/// </summary>
/// <param name="subscription">The application's PageSubscription.</param>
/// <returns>The Episerver Social Subscription.</returns>
private Subscription AdaptSubscription(PageSubscription subscription)
{
return(new Subscription(Reference.Create(subscription.Subscriber),
Reference.Create(subscription.Target)));
}