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))); }