public void TestMDSBloomberg()
{
// test basic start, request snapshot, and stop functions
// - create a MDS client with direct connection to provider
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
IModuleInfo clientInfo = new V131ModuleInfo(new V131ClientInfo());
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv(BuildConst.BuildEnv).Create())
{
const string curveName = "Orion.V5r3.Configuration.PricingStructures.QR_LIVE.RateCurve.AUD-BBR-BBSW-3M";
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];
QuotedAssetSet quotedAssetSet = ((YieldCurveValuation)psv).inputs;
using (IMarketDataClient mdc = new MarketDataRealtimeClient(
loggerRef, null, client,
MDSProviderId.Bloomberg))//MDSProviderId.GlobalIB
{
QuotedAssetSet data = mdc.GetMarketQuotes(
MDSProviderId.Bloomberg, clientInfo, Guid.NewGuid(), true,
null,
quotedAssetSet).Result;
Assert.IsNotNull(data);
}
}
}
}
public void TestMutationDetection()
{
// tests the object mutation detector
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())
{
// create reference object
TestData data0 = new TestData("Zero", 0);
client.SaveObject(data0, "Item0", null);
ICoreItem item = client.LoadItem <TestData>("Item0");
string text = item.Text;
TestData data = item.GetData <TestData>(false);
// - assert not mutated
Assert.AreEqual(text, XmlSerializerHelper.SerializeToString(item.GetData <TestData>(false)));
// - mutate the object
data.field1 = "One";
data.field2 = 1;
// - assert mutated
Assert.AreNotEqual(text, XmlSerializerHelper.SerializeToString(item.GetData <TestData>(false)));
}
// shutdown
server.Stop();
}
}
}
/// <summary>
/// Application start
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void ApplicationStart(object sender, EventArgs e)
{
const string fullAppName = "FpML.V5r3.PublisherWebService";
LoggerRef.Target.LogInfo("Starting up...");
try
{
//var stopwatch = new Stopwatch();
//stopwatch.Start();
CoreClientFactory factory = new CoreClientFactory(LoggerRef)
.SetEnv("DEV")
.SetApplication(Assembly.GetExecutingAssembly())
.SetProtocols(WcfConst.AllProtocolsStr);
_client = factory.SetServers("localhost").Create();
_cache = _client.CreateCache();
//LoadConfigDataHelper.LoadConfigurationData(LogRef.Target, _Cache);//TODO get rid of this
//stopwatch.Stop();
//Debug.Print("Initialized test environment, in {0} seconds", stopwatch.Elapsed.TotalSeconds);
LoggerRef.Target.LogInfo("Loaded..." + fullAppName);
}
catch (Exception excp)
{
LoggerRef.Target.Log(excp);
}
}
private void StartUp()
{
_loggerRef.Target.Clear();
ClearTree();
try
{
CoreClientFactory factory = new CoreClientFactory(_loggerRef)
.SetEnv(cbEnvId.Text)
.SetApplication(Assembly.GetExecutingAssembly())
.SetProtocols(WcfConst.AllProtocolsStr);
if (rbDefaultServers.Checked)
{
_client = factory.Create();
}
else if (rbLocalhost.Checked)
{
_client = factory.SetServers("localhost").Create();
}
else
{
_client = factory.SetServers(txtSpecificServers.Text).Create();
}
_syncContext.Post(OnClientStateChange, new CoreStateChange(CoreStateEnum.Initial, _client.CoreState));
_client.OnStateChange += _Client_OnStateChange;
}
catch (Exception excp)
{
_loggerRef.Target.Log(excp);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TradeQuery"/> class.
/// </summary>
public TradeQuery(ILogger logger)
{
var logRef = Reference <ILogger> .Create(logger);
try
{
CoreClientFactory factory = new CoreClientFactory(logRef)
.SetEnv(BuildEnv.ToString())
.SetApplication(Assembly.GetExecutingAssembly())
.SetProtocols(WcfConst.AllProtocolsStr);
//if (rbDefaultServers.Checked)
// _Client = factory.Create();
//else if (rbLocalhost.Checked)
var client = factory.SetServers("localhost").Create();
_cache = client.CreateCache();
//else
// _Client = factory.SetServers(txtSpecificServers.Text).Create();
//_SyncContext.Post(OnClientStateChange, new CoreStateChange(CoreStateEnum.Initial, _Client.CoreState));
//_Client.OnStateChange += new CoreStateHandler(_Client_OnStateChange);
}
catch (Exception excp)
{
logRef.Target.Log(excp);
}
}
private void StartUp()
{
try
{
var factory = new CoreClientFactory(_loggerRef)
.SetEnv("Dev")
.SetApplication(Assembly.GetExecutingAssembly())
.SetProtocols(WcfConst.AllProtocolsStr)
.SetServers("localhost");
var client = factory.Create();
_clientRef = Reference <ICoreClient> .Create(client);
_cache = _clientRef.Target.CreateCache();
// init controls
// - form title
var env = _clientRef.Target.ClientInfo.ConfigEnv;
Text += String.Format(" ({0})", EnvHelper.EnvName(env));
// - server port
int defaultPort = EnvHelper.SvcPort(env, SvcId.GridSwitch);
chkChangePort.Text = String.Format("Change server port from default ({0}) to:", defaultPort);
_syncContext.Post(OnClientStateChange, new CoreStateChange(CoreStateEnum.Initial, _clientRef.Target.CoreState));
_clientRef.Target.OnStateChange += _Client_OnStateChange;
}
catch (Exception excp)
{
_loggerRef.Target.Log(excp);
}
}
/// <summary>
/// Generic constructor
/// </summary>
/// <param name="loggerRef"></param>
/// <param name="cache"></param>
/// <param name="nameSpace"></param>
public PricingStructures(Reference <ILogger> loggerRef, ICoreCache cache, string nameSpace)
{
Logger = loggerRef;
NameSpace = nameSpace;
if (cache != null)
{
Cache = cache;
}
else if (Cache == null)
{
try
{
CoreClientFactory factory = new CoreClientFactory(Logger)
.SetEnv(BuildEnv.ToString())
.SetApplication(Assembly.GetExecutingAssembly())
.SetProtocols(WcfConst.AllProtocolsStr)
.SetServers("localhost");
Cache = factory.Create();
}
catch (Exception excp)
{
Logger.Target.Log(excp);
}
}
}
// This method used to connect to Core API with creds from current active seesion
public static ICoreClient GetDefaultCoreClient(CoreConnectionCredentials coreCredentials)
{
var coreClientFactory = new CoreClientFactory();
var coreClient = coreClientFactory.Create(CreateApiUri(coreCredentials.Hostname, coreCredentials.Port));
coreClient.UseDefaultCredentials();
return coreClient;
}
// This method is used to connect to Core API with specific credentials
public static ICoreClient GetFullCoreClient(CoreConnectionCredentials coreCredentials)
{
var networkCreds = new NetworkCredential(coreCredentials.Username, coreCredentials.Password);
var factory = new CoreClientFactory();
var coreClient = factory.Create(CreateApiUri(coreCredentials.Hostname, coreCredentials.Port));
coreClient.UseSpecificCredentials(networkCreds);
return coreClient;
}
// This method used to connect to Core API with creds from current active seesion
public static ICoreClient GetDefaultCoreClient(string host, int port)
{
var coreClientFactory = new CoreClientFactory();
var coreClient = coreClientFactory.Create(CreateApiUri(host, port));
coreClient.UseDefaultCredentials();
return coreClient;
}
// This method is used to connect to Core API with specific credentials
public static ICoreClient GetFullCoreClient(string host, int port, string username, string password)
{
var networkCreds = new NetworkCredential(username, password);
var factory = new CoreClientFactory();
var coreClient = factory.Create(CreateApiUri(host, port));
coreClient.UseSpecificCredentials(networkCreds);
return coreClient;
}
public void TestBasicEncryption()
{
// tests key creation and exchange
// - between 2 clients
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router))
{
server.Start();
using (ICoreClient sender = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
using (ICoreClient recver = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
// check un-encrypted traffic
Guid evtId1 = sender.SaveObject <TestData>(new TestData("1", 1), "test", null, TimeSpan.MaxValue);
List <ICoreItem> recdList1 = recver.LoadItems <TestData>(Expr.ALL);
Assert.AreEqual <int>(1, recdList1.Count);
ICoreItem recdItem1 = recdList1[0];
Assert.AreEqual <Guid>(evtId1, recdItem1.Id);
Assert.IsNull(recdItem1.TranspKeyId);
Assert.IsNull(recdItem1.SenderKeyId);
Assert.IsNull(recdItem1.RecverKeyId);
// generate keys
string senderKeyId = sender.CryptoManager.GenerateNewKeys();
string recverKeyId = recver.CryptoManager.GenerateNewKeys();
// send encrypted message and check receiver fails to decrypt
ICoreItem sentItem2 = sender.MakeObject <TestData>(new TestData("2", 2), "test", null);
sentItem2.TranspKeyId = senderKeyId;
sentItem2.SenderKeyId = senderKeyId;
Guid evtId2 = sender.SaveItem(sentItem2);
List <ICoreItem> recdList2 = recver.LoadItems <TestData>(Expr.ALL);
Assert.AreEqual <int>(1, recdList2.Count);
ICoreItem recdItem2 = recdList2[0];
Assert.AreEqual <Guid>(evtId2, recdItem2.Id);
Assert.AreEqual <Guid>(evtId2, recdItem2.Id);
Assert.AreEqual <string>(senderKeyId, recdItem2.TranspKeyId);
Assert.AreEqual <string>(senderKeyId, recdItem2.SenderKeyId);
Assert.IsNull(recver.CryptoManager.GetTranspKey(senderKeyId));
// set public key at receiver and check authentication
recver.CryptoManager.SetPublicKey(senderKeyId, sender.CryptoManager.GetPublicKey(senderKeyId));
Assert.IsTrue(recdItem2.IsSigned);
Assert.IsFalse(recdItem2.IsSecret);
// set transport key at receiver and recheck decryption
recver.CryptoManager.SetTranspKey(senderKeyId, sender.CryptoManager.GetTranspKey(senderKeyId));
object data2 = recdItem2.Data;
Assert.IsNotNull(data2);
Assert.AreEqual <Type>(typeof(TestData), data2.GetType());
}
server.Stop();
}
}
}
public void TestSerialisingInterfaceTypes()
{
// tests control of the serialisation type
// - interface types
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())
{
AssetMeasureValue codeValueInstance = new AssetMeasureValue()
{
Code = "Test",
Description = "This is a test",
Source = "UnitTest"
};
IFpMLCodeValue codeValueInterface = codeValueInstance;
// save reference item
client.SaveObject(codeValueInstance, "Test0", null, TimeSpan.MaxValue);
ICoreItem itemA = client.LoadItem("Test0");
Assert.AreEqual(typeof(AssetMeasureValue).FullName, itemA.DataTypeName);
// test interface and instance both serialise identically
{
client.SaveUntypedObject(codeValueInterface, "Test1", null);
ICoreItem itemB = client.LoadItem("Test1");
Assert.AreEqual(typeof(AssetMeasureValue).FullName, itemB.DataTypeName);
Assert.AreEqual(itemA.Text, itemB.Text);
}
{
client.SaveObject((AssetMeasureValue)codeValueInterface, "Test2", null, TimeSpan.MaxValue);
ICoreItem itemB = client.LoadItem("Test2");
Assert.AreEqual(typeof(AssetMeasureValue).FullName, itemB.DataTypeName);
Assert.AreEqual(itemA.Text, itemB.Text);
}
{
// this should fail because interfaces cant be serialised
UnitTestHelper.AssertThrows <ArgumentException>("Cannot be an interface type!\r\nParameter name: dataType", () =>
{
client.SaveObject(codeValueInterface, "Test3", null, TimeSpan.MaxValue);
});
}
{
// note: this silently binds to SaveObject<IFpMLCodeValue>(...) which should fail
UnitTestHelper.AssertThrows <ArgumentException>("Cannot be an interface type!\r\nParameter name: dataType", () =>
{
client.SaveObject(codeValueInterface, "Test4", null, TimeSpan.MaxValue);
});
}
}
// shutdown
server.Stop();
}
}
}
private void Form1Load(object sender, EventArgs e)
{
_logRef = Reference <ILogger> .Create(new TextBoxLogger(txtLog));
_factory = new CoreClientFactory(_logRef)
.SetEnv("DEV")
.SetApplication(Assembly.GetExecutingAssembly())
.SetProtocols(WcfConst.AllProtocolsStr)
.SetServers("localhost");
}
// This method is used to connect to Core API with specific credentials
private static ICoreClient GetFullCoreClient(CoreConnectionCredentials coreCredentials)
{
var networkCreds = new NetworkCredential(coreCredentials.Username, coreCredentials.Password);
var factory = new CoreClientFactory();
var coreClient = factory.Create(CreateApiUri(coreCredentials.Hostname, coreCredentials.Port));
coreClient.UseSpecificCredentials(networkCreds);
return(coreClient);
}
// This method used to connect to Core API with creds from current active seesion
public static ICoreClient GetDefaultCoreClient(CoreConnectionCredentials coreCredentials)
{
var coreClientFactory = new CoreClientFactory();
var coreClient = coreClientFactory.Create(CreateApiUri(coreCredentials.Hostname, coreCredentials.Port));
coreClient.UseDefaultCredentials();
return(coreClient);
}
private void button1_Click(object sender, EventArgs e)
{
using (ICoreClient client = new CoreClientFactory(_Logger).Create())
{
ServiceHostRulesLoader.Load(_Logger, client);
FileImportRuleLoader.Load(_Logger, client);
MarketDataConfigHelper.LoadProviderRules(_Logger, client);
AlertRulesLoader.Load(_Logger, client);
TradeImportRuleLoader.Load(_Logger, client);
}
}
/// <summary>
/// Simplest constructor
/// </summary>
public PricingStructures()
{
Logger = Reference <ILogger> .Create(new TraceLogger(true));
NameSpace = EnvironmentProp.DefaultNameSpace;
CoreClientFactory factory = new CoreClientFactory(Logger)
.SetEnv(BuildEnv.ToString())
.SetApplication(Assembly.GetExecutingAssembly())
.SetProtocols(WcfConst.AllProtocolsStr)
.SetServers("localhost");
Cache = factory.Create();
}
private void BtnDebugLoadAlertRulesClick(object sender, EventArgs e)
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TextBoxLogger(txtDebugLog)))
{
loggerRef.Target.LogDebug("Loading alert rules...");
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv(BuildConst.BuildEnv).Create())
{
// load test user details
//client.SaveObject<UserDetail>(MakeUserDetail(User_MLim2, "Mark Lim", "*****@*****.**"));
//client.SaveObject<UserDetail>(MakeUserDetail(User_SDudley, "Simon Dudley", "*****@*****.**"));
client.SaveObject(MakeUserDetail(AlertRule.UserDefaultReplyTo, "Default ReplyTo User", "*****@*****.**"));
client.SaveObject(MakeUserGroup(AlertRule.GroupDefaultMailTo, "Default MailTo Group", new[] { AlertRule.UserDefaultReplyTo }, null));
//client.SaveObject<UserGroup>(MakeUserGroup(Group_QDS_Developers, "QDS Developers Group", new string[] { User_SDudley, User_MLim2 }, null));
//client.SaveObject<UserGroup>(MakeUserGroup(Group_QDS_Developers, "QDS Developers Group", new string[] { User_SDudley }, null));
// defaults
// - check constraint: time of day is between 4:30am and 8:30pm 7 days a week
IExpression defaultCheckConstraint = Expr.BoolAND(
Expr.IsGEQ(Expr.DayOfWeek(Expr.FuncToday()), Expr.Const(DayOfWeek.Monday)),
Expr.IsLEQ(Expr.DayOfWeek(Expr.FuncToday()), Expr.Const(DayOfWeek.Friday)),
Expr.IsGEQ(Expr.FuncTimeOfDay(), Expr.Const(new TimeSpan(4, 30, 0))),
Expr.IsLEQ(Expr.FuncTimeOfDay(), Expr.Const(new TimeSpan(20, 30, 0))));
// - monitor period: every minute
TimeSpan defaultMonitorPeriod = TimeSpan.FromMinutes(1);
// - publish period: hourly
TimeSpan defaultPublishPeriod = TimeSpan.FromHours(1);
// build rules
var alertRules = new List <AlertRule>();
alertRules.AddRange(CreateDevRules(defaultCheckConstraint, defaultMonitorPeriod, defaultPublishPeriod));
//alertRules.AddRange(CreateSitRules(defaultCheckConstraint, defaultMonitorPeriod, defaultPublishPeriod));
//alertRules.AddRange(CreateStgRules(defaultCheckConstraint, defaultMonitorPeriod, defaultPublishPeriod));
//alertRules.AddRange(CreateLegacyRules(defaultCheckConstraint, defaultMonitorPeriod, defaultPublishPeriod));
// save Import rules
foreach (AlertRule rule in alertRules)
{
loggerRef.Target.LogDebug(" Loading AlertRule: {0}.{1}.{2} ({3})...", rule.HostEnvAbbr, rule.HostInstance, rule.RuleUniqueId, rule.Disabled ? "Disabled" : "Enabled");
TimeSpan lifetime = rule.Disabled ? TimeSpan.FromDays(30) : TimeSpan.MaxValue;
client.SaveObject(rule, lifetime);
}
loggerRef.Target.LogDebug("Loaded {0} alert rules.", alertRules.Count);
}
}
}
public void TestSaveLoadPrivateCacheItems()
{
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())
{
Guid id = cacheA.SavePrivateObject("data", "name1", null);
//ICoreItem item = cacheA.LoadPrivateItem<string>("name1");
ICoreItem item = cacheA.LoadItem <string>("name1");
string data = (string)item.Data;
Assert.AreEqual <string>("data", data);
}
}
}
private void StartUp()
{
try
{
var factory = new CoreClientFactory(_loggerRef)
.SetEnv("Dev")
.SetApplication(Assembly.GetExecutingAssembly())
.SetProtocols(WcfConst.AllProtocolsStr)
.SetServers("localhost");
var client = factory.Create();
_clientRef = Reference <ICoreClient> .Create(client);
_cache = _clientRef.Target.CreateCache();
// init controls
// - form title
EnvId env = _clientRef.Target.ClientInfo.ConfigEnv;
Text += String.Format(" ({0})", EnvHelper.EnvName(env));
// - server port
int defaultPort = EnvHelper.SvcPort(env, SvcId.GridSwitch);
_qasDefViewHelper = new QASDefViewHelper();
_qasDefDataHelper = new QASDefDataHelper();
_qasDefFilters = new ComboxBoxFilterGroup(panelQASDef, _qasDefViewHelper, QASDefSelectionChanged);
_qasDefSelecter = new QASDefSelecter(
_qasDefFilters, _qasDefViewHelper, _qasDefDataHelper);
_qasDefView = new ListViewManager <RatesObj>(
_loggerRef.Target, lvQASDef, _qasDefViewHelper,
_qasDefSelecter, _qasDefFilters, new QASDefSorter(), _qasDefDataHelper);
//Get the starting configuration
//
chkChangePort.Text = String.Format("Change server port from default ({0}) to:", defaultPort);
//Set up the timer and the random number generator.
//
_timer = new System.Timers.Timer(10000);
_rand = new Random();
}
catch (Exception excp)
{
_loggerRef.Target.Log(excp);
}
}
static void Main(string[] args)
{
using (Reference <ILogger> logRef = Reference <ILogger> .Create(new ConsoleLogger("FpML.V5r3.ConfigDataLoader: ")))
{
logRef.Target.LogInfo("Running...");
int exitCode = 0;
try
{
using (ICoreClient client = new CoreClientFactory(logRef).SetEnv("DEV").Create())
{
// delete 'old' configuration data in all environments greater than DEV
if (client.ClientInfo.ConfigEnv >= EnvId.SIT_SystemTest)
{
client.DeleteUntypedObjects(null, Expr.StartsWith(Expr.SysPropItemName, "Orion.FpML.V5r3.Configuration."));
}
// load configuration data
//AppSettingsLoader.Load(logRef.Target, client);
LoadConfigDataHelper.LoadConfigurationData(logRef.Target, client);
// done
logRef.Target.LogInfo("Success");
}
}
catch (Exception e)
{
logRef.Target.Log(e);
for (int i = 0; i < args.Length; i++)
{
logRef.Target.LogDebug(" args[{0}]='{1}'", i, args[i]);
}
logRef.Target.LogInfo("FAILED");
exitCode = 2;
}
finally
{
Environment.ExitCode = exitCode;
}
}
}
public void TestRequestThrottling()
{
const int numberOfAsyncRequests = 1000;
const int serverPort = 9001;
string hostAddress = $"localhost:{serverPort}";
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
NamedValueSet serverSettings = new NamedValueSet();
serverSettings.Set(CfgPropName.EnvName, "UTT");
serverSettings.Set(CfgPropName.Port, serverPort);
serverSettings.Set(CfgPropName.Endpoints, WcfConst.NetTcp);
using (CoreServer server = new CoreServer(loggerRef, serverSettings))
{
server.Start();
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").SetServers(hostAddress).Create())
{
List <IAsyncResult> completions = new List <IAsyncResult>();
try
{
for (int i = 0; i < numberOfAsyncRequests; i++)
{
completions.Add(client.SaveObjectBegin(new TestData("Test", i), "Test", null, false, TimeSpan.MaxValue));
//loggerRef.Target.LogDebug("[{0}] save begun...", i.ToString("0000"));
}
}
finally
{
for (int i = 0; i < numberOfAsyncRequests; i++)
{
client.SaveEnd(completions[i]);
//loggerRef.Target.LogDebug("[{0}] save done.", i.ToString("0000"));
}
}
}
}
}
}
public RuntimeEnvironment(string nameSpace)
{
NameSpace = nameSpace;
string fullAppName = $"ExcelAPI-{ApplicationHelper.Diagnostics("FileVersion")}";
try
{
//var stopwatch = new Stopwatch();
LogRef = Reference <ILogger> .Create(new TraceLogger(true));
//stopwatch.Start();
CoreClientFactory factory = new CoreClientFactory(LogRef)
.SetEnv("DEV")
.SetApplication(Assembly.GetExecutingAssembly())
.SetProtocols(WcfConst.AllProtocolsStr);
_client = factory.SetServers("localhost").Create();
Cache = _client.CreateCache();
Log(LogRef.Target, "Starting...", fullAppName, "StartUp");
}
catch (System.Exception excp)
{
LogRef.Target.Log(excp);
}
}
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();
}
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 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 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 TestPagingTechniques()
{
const bool debugRequests = true;
// loads/saves a very large number of objects
const int maxLoopCount = 5;
const int itemsPerLoop = 400;
const int itemsPerPage = 154;
const int totalItems = maxLoopCount * itemsPerLoop;
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
NamedValueSet serverSettings = new NamedValueSet();
serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Router);
serverSettings.Set(CfgPropName.EnvName, "UTT");
using (CoreServer server = new CoreServer(loggerRef, serverSettings))
{
server.Start();
// save
using (ICoreClient client1 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
for (int loop = 0; loop < maxLoopCount; loop++)
{
ICoreItem[] items = new ICoreItem[itemsPerLoop];
for (int i = 0; i < itemsPerLoop; i++)
{
client1.DebugRequests = i == 0;
int n = loop * itemsPerLoop + i;
TestData data = new TestData(n.ToString(), n);
NamedValueSet props = new NamedValueSet(new NamedValue("n", n));
items[i] = client1.MakeObject(data, "Test." + n, props);
}
client1.SaveItems(items);
}
}
// load (using original paging technique)
loggerRef.Target.LogDebug("---------- multi page load");
// - slow because it scans and sort the entire data set for each page
using (ICoreClient client3 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
// count the items
int itemCount1 = client3.CountObjects <TestData>(null);
// now get the items in pages
IExpression orderExpr = Expr.Prop("n");
client3.DebugRequests = debugRequests;
int itemCount2 = 0;
int startRow = 0;
List <ICoreItem> page;
do
{
page = client3.LoadItems <TestData>(null, orderExpr, startRow, itemsPerPage);
itemCount2 += page.Count;
startRow += page.Count;
}while (page.Count == itemsPerPage);
Assert.AreEqual(totalItems, itemCount1);
Assert.AreEqual(totalItems, itemCount2);
}
// paged load (using pre-load of item header info)
loggerRef.Target.LogDebug("---------- header pre-load");
// - faster because it only scans sorts the entire data set once and sorting
// can use local compiled methods instead of server-side expression evaluation.
using (ICoreClient client4 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
// get all the items (without data)
List <ICoreItemInfo> itemInfoList = client4.LoadItemInfos <TestData>(null);
int itemCount1 = itemInfoList.Count;
// optionally sort the list here
//IExpression orderExpr = Expr.Prop("n");
// now get the items in pages
client4.DebugRequests = debugRequests;
int itemCount2 = 0;
int maxPages = ((itemCount1 / itemsPerPage) + 1);
for (int pageNum = 0; pageNum < maxPages; pageNum++)
{
// get the item names/ids for the current page
int startRow = itemsPerPage * pageNum;
List <string> itemNames = new List <string>();
for (int i = 0; i < itemsPerPage; i++)
{
int n = startRow + i;
if (n < itemCount1)
{
itemNames.Add(itemInfoList[n].Name);
}
}
// now get the objects (with data)
var page = client4.LoadItems <TestData>(itemNames);
itemCount2 += page.Count;
}
Assert.AreEqual(totalItems, itemCount1);
Assert.AreEqual(totalItems, itemCount2);
}
}
}
}
[Ignore] // this is an integration test
public void StressUttServerLoadAndSubscribe()
{
// return an increasing number of trades until failure
// on a 4GB workstation, the limit is about 13,000 trades.
Trade trade = XmlSerializerHelper.DeserializeFromString <Trade>(
ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.xml"));
NamedValueSet tradeProps = new NamedValueSet(
ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.nvs"));
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
//NamedValueSet serverSettings = new NamedValueSet();
//serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Router);
//serverSettings.Set(CfgPropName.EnvName, "UTT");
//using (CoreServer server = new CoreServer(logger, serverSettings))
{
//server.Start();
//using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").SetHosts("localhost:8113").Create())
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
{
// delete the test trades
IExpression deleteExpr = Expr.ALL;
client.DeleteObjects <Trade>(deleteExpr);
const int maxLoops = 3;
const int loopRepeat = 3;
const int incrementPerLoop = 1024;
int itemsPerLoop = 1024;
int itemsSaved = 0;
for (int loop = 0; loop < maxLoops; loop++)
{
string loopName = $"Test.{loop}.";
for (int repeat = 0; repeat < loopRepeat; repeat++)
{
// create trades
loggerRef.Target.LogDebug("[{0}-{1}] Creating {2} trades...", loop, repeat, itemsPerLoop);
ICoreItem[] items = new ICoreItem[itemsPerLoop];
for (int i = 0; i < itemsPerLoop; i++)
{
string tradeName = $"Test.{loop}.{i}";
items[i] = client.MakeObject <Trade>(trade, tradeName, tradeProps);
itemsSaved++;
}
client.SaveItems(items);
// start subscription
loggerRef.Target.LogDebug("[{0}-{1}] Receiving {2} trades...", loop, repeat, itemsPerLoop);
long itemsReceived = 0;
DateTime testStartedTime = DateTime.Now;
DateTime lastReceiveTime = testStartedTime;
ISubscription subscription = client.CreateSubscription <Trade>(Expr.StartsWith(Expr.SysPropItemName, loopName));
subscription.UserCallback = delegate
{
Interlocked.Increment(ref itemsReceived);
lastReceiveTime = DateTime.Now;
};
//subscription.ExcludeDataBody = true;
subscription.Start();
// wait a bit to ensure subscription is up to date
while ((Interlocked.Add(ref itemsReceived, 0) < itemsPerLoop) && ((DateTime.Now - testStartedTime) < TimeSpan.FromSeconds(10)))
{
Thread.Sleep(100);
}
Thread.Sleep(100);
subscription.Cancel();
// load all that have been saved
loggerRef.Target.LogDebug("[{0}-{1}] Received {2} trades in {3} seconds.", loop, repeat, itemsReceived, (lastReceiveTime - testStartedTime).TotalSeconds);
Assert.AreEqual(itemsPerLoop, Interlocked.Add(ref itemsReceived, 0));
// delete the test trades
//client.DeleteObjects<Trade>(deleteExpr);
//GC.Collect();
}
// next loop
itemsPerLoop += incrementPerLoop;
} // for loop
}
}
}
}
public void TestStressServerLoadAndRetrieve()
{
// return an increasing number of trades until failure
Trade trade = XmlSerializerHelper.DeserializeFromString <Trade>(
ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.xml"));
NamedValueSet tradeProps = new NamedValueSet(
ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.nvs"));
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
NamedValueSet serverSettings = new NamedValueSet();
serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Router);
serverSettings.Set(CfgPropName.EnvName, "UTT");
using (CoreServer server = new CoreServer(loggerRef, serverSettings))
{
server.Start();
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").SetServers("localhost:8113").Create())
//using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv(EnvId.DEV_Development).Create())
{
// delete the test trades
IExpression deleteExpr = Expr.StartsWith(Expr.SysPropItemName, "Test.");
client.DeleteObjects <Trade>(deleteExpr);
const int maxLoops = 1;
const int loopRepeat = 1;
const int incrementPerLoop = 1024;
int itemsPerLoop = 8192 - 1024;
int itemsSaved = 0;
for (int loop = 0; loop < maxLoops; loop++)
{
for (int repeat = 0; repeat < loopRepeat; repeat++)
{
// create trades
loggerRef.Target.LogDebug("[{0}-{1}] Making {2} trades...", loop, repeat, itemsPerLoop);
List <IAsyncResult> completions = new List <IAsyncResult>();
ICoreItem[] items = new ICoreItem[itemsPerLoop];
for (int i = 0; i < itemsPerLoop; i++)
{
string tradeName = $"Test.{loop}.{i}";
ICoreItem item = client.MakeObject(trade, tradeName, tradeProps);
item.Freeze(); // serialises
items[i] = item;
}
loggerRef.Target.LogDebug("[{0}-{1}] Commencing save of {2} trades...", loop, repeat, itemsPerLoop);
for (int i = 0; i < itemsPerLoop; i++)
{
completions.Add(client.SaveItemBegin(items[i]));
itemsSaved++;
}
loggerRef.Target.LogDebug("[{0}-{1}] Completing save of {2} trades...", loop, repeat, itemsPerLoop);
foreach (IAsyncResult ar in completions)
{
client.SaveEnd(ar);
}
// load all that have been saved
string loopName = $"Test.{loop}.";
loggerRef.Target.LogDebug("[{0}-{1}] Loading {2} trades...", loop, repeat, itemsPerLoop);
List <ICoreItem> tradeItems = client.LoadItems <Trade>(Expr.StartsWith(Expr.SysPropItemName, loopName));
Assert.AreEqual(itemsPerLoop, tradeItems.Count);
loggerRef.Target.LogDebug("[{0}-{1}] Unpacking {2} trades...", loop, repeat, itemsPerLoop);
List <Trade> trades = new List <Trade>();
foreach (ICoreItem item in tradeItems)
{
trades.Add((Trade)item.Data);
}
loggerRef.Target.LogDebug("[{0}-{1}] Retrieved {2} trades.", loop, repeat, itemsPerLoop);
// delete the test trades
client.DeleteObjects <Trade>(deleteExpr);
GC.Collect();
}
// next loop
itemsPerLoop += incrementPerLoop;
} // for loop
}
}
}
}
public void 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);
}
}
}
}
}
static void Main(string[] args)
{
// exit codes:
// 1 success
// 0 failed (exception logged to network)
// -1 catastrophic failure (logged to local file)
// -2 catastrophic failure (logged to console only)
using (ILogger logger = new ConsoleLogger("RequestHandler: "))
{
// argument defaults
bool attended = false;
Guid requestId = Guid.Empty;
EnvId env = EnvId.Undefined;
string hostInstance = null;
// note: project debugging guid is: {6B70756E-16D8-4E9D-B104-3BE5830F229A}
try
{
// process arguments
logger.LogDebug("Arguments:");
for (int i = 0; i < args.Length; i++)
{
logger.LogDebug(" Argument[{0}]='{1}'", i, args[i]);
string[] argParts = args[i].Split(':');
string argName = argParts[0];
switch (argName.ToLower())
{
case "/debug": attended = true; break;
case "/reqid": requestId = Guid.Parse(argParts[1]); break;
case "/hiid":
{
hostInstance = argParts[1];
if (hostInstance.Equals("Default", StringComparison.OrdinalIgnoreCase))
{
hostInstance = null;
}
}
break;
case "/env": env = EnvHelper.ParseEnvName(argParts[1]); break;
default: break;
}
}
using (ICoreClient client = new CoreClientFactory(logger).SetEnv(env).Create())
//using (ILogger netLogger = new NetworkLogger(client, null))
using (ICoreCache cache = client.CreateCache())
{
//Environment.ExitCode = HandleRequest(new MultiLogger(logger, netLogger), cache, requestId);
Environment.ExitCode = RequestHandler.HandleRequest(logger, cache, requestId, hostInstance);
}
}
catch (Exception e1)
{
// catastrophic failure
// - try to log to local file
try
{
Environment.ExitCode = -2;
using (ILogger errorLog = new MultiLogger(logger,
new FileLogger(String.Format(@".\RequestHandler.Error.{0}.log", requestId))))
{
errorLog.LogDebug("Arguments:");
for (int i = 0; i < args.Length; i++)
{
errorLog.LogDebug(" Argument[{0}]='{1}'", i, args[i]);
}
errorLog.LogError(e1);
}
}
catch (Exception e2)
{
// I/O failure creating error log?
Environment.ExitCode = -3;
logger.LogDebug("Arguments ({0}):", args.Length);
for (int i = 0; i < args.Length; i++)
{
logger.LogDebug(" Argument[{0}]='{1}'", i, args[i]);
}
logger.LogError(e2);
}
}
if (attended)
{
Console.WriteLine("Press ENTER to exit.");
Console.ReadLine();
}
}
}
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);
}
}
