private static int SvcPortBase(EnvId env)
{
switch (env)
{
case EnvId.Utt_UnitTest: return(8100);
case EnvId.Dev_Development: return(8200);
case EnvId.Sit_SystemTest: return(8300);
case EnvId.Stg_StagingLive: return(8400);
case EnvId.Prd_Production: return(8500);
default:
throw new NotSupportedException("EnvId: " + env);
}
}
public WorkflowClient(IWorkContext context, NamedValueSet settings)
{
// default configuration
const SvcId svc = SvcId.GridSwitch;
EnvId env = EnvHelper.ParseEnvName(BuildConst.BuildEnv);
Guid nodeId = Guid.NewGuid();
// custom configuration
if (settings != null)
{
// environment
env = (EnvId)settings.GetValue(WFPropName.EnvId, (int)env);
}
env = EnvHelper.CheckEnv(env);
// derived configuration
string hosts = null;
int port = EnvHelper.SvcPort(env, svc);
if (settings != null)
{
port = settings.GetValue(WFPropName.Port, port);
hosts = settings.GetValue(WFPropName.Hosts, hosts);
nodeId = settings.GetValue(WFPropName.NodeId, nodeId);
}
string svcName = EnvHelper.SvcPrefix(svc);
string[] serviceAddrs = EnvHelper.GetServiceAddrs(env, svc, false);
if (hosts != null)
{
serviceAddrs = hosts.Split(";".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
}
ServiceAddress resolvedServer = V111Helpers.ResolveServer(context.Logger, svcName, new ServiceAddresses(WcfConst.AllProtocols, serviceAddrs, port),
new[] { typeof(IDiscoverV111).FullName });
// initialise worksteps
List <IWorkstep> worksteps = GridWorksteps.Create();
foreach (IWorkstep workstep in worksteps)
{
workstep.Initialise(context);
workstep.EnableGrid(GridLevel.Client, nodeId, resolvedServer.Port, resolvedServer.Host);
}
Clients = worksteps.ToArray();
}
// V1.3
public static V131EnvId ToV131EnvId(EnvId env)
{
switch (env)
{
case EnvId.Undefined: return(V131EnvId.Undefined);
case EnvId.Utt_UnitTest: return(V131EnvId.UTT_UnitTest);
case EnvId.Dev_Development: return(V131EnvId.DEV_Development);
case EnvId.Sit_SystemTest: return(V131EnvId.SIT_SystemTest);
case EnvId.Stg_StagingLive: return(V131EnvId.STG_StagingLive);
case EnvId.Prd_Production: return(V131EnvId.PRD_Production);
default: throw new ArgumentException($"Unknown EnvId: {env}");
}
}
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);
}
}
private static void AddRuleSet(EnvId env, string hostComputer, string buildConfig, List <HostConfigRule> rules)
{
// note: The market data server (MDS) must run in the default host instance (null) as only this instance
// has the necessary configuration, Bloomberg meta data files, and references to Bloomberg assemblies.
rules.Add(SetRuleEnv(env, hostComputer, null, buildConfig, true, MakeRuleGenericServer(buildConfig, "MarketData", "MarketDataServer")));
// the following services have no known configuration constraints - run them in the default host instance
rules.Add(SetRuleEnv(env, hostComputer, null, buildConfig, true, MakeRuleGenericServer(buildConfig, "FileImporter", "FileImportServer")));
rules.Add(SetRuleEnv(env, hostComputer, null, buildConfig, true, MakeRuleGenericServer(buildConfig, "TradeImporter", "TradeImportServer")));
rules.Add(SetRuleEnv(env, hostComputer, null, buildConfig, true, MakeRuleGenericServer(buildConfig, "Alerting", "AlertServer")));
rules.Add(SetRuleEnv(env, hostComputer, null, buildConfig, true, MakeRulePortfolioValuerServer(buildConfig)));
rules.Add(SetRuleEnv(env, hostComputer, null, buildConfig, true, MakeRuleGenericServer(buildConfig, "DataExporter", "DataExportServer")));
// note: Services that use the QRSC analytics engine must run in separate processes (different host instances)
// because the engine contains a static singleton runtime client which cannot easily be shared. These services are:
// - CurveGenServer
// - StressGenServer
// - TradeValuationServer
// - PortfolioValuationServer
rules.Add(SetRuleEnv(env, hostComputer, "A", buildConfig, true, MakeRuleGenericServer(buildConfig, "CurveGenerator", "CurveGenServer")));
rules.Add(SetRuleEnv(env, hostComputer, "B", buildConfig, true, MakeRuleGenericServer(buildConfig, "StressGenerator", "StressGenServer")));
rules.Add(SetRuleEnv(env, hostComputer, "C", buildConfig, true, MakeRuleGenericServer(buildConfig, "TradeRevaluer", "TradeValuationServer")));
rules.Add(SetRuleEnv(env, hostComputer, "D", buildConfig, false, MakeRuleGenericServer(buildConfig, "TradeRevaluer", "PortfolioValuationServer")));
}
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();
}
}
}
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 SaveAppSettings(NamedValueSet settings, string applName, string userName, string hostName, bool replaceOldSettings, EnvId envId)
{
throw new NotImplementedException();
}
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();
}
}
}
private static string SiteKey(EnvId env, string siteName)
{
return(EnvHelper.EnvName(env) + siteName);
}
//public NetSubnet FallbackSite;
public NetSubnet(EnvId env, string name)
{
Env = env; Name = name;
}
public static Dictionary <string, object> GetAppSettings(EnvId env, string applName, bool reload)
{
var result = new Dictionary <string, object>();
// load settings if required
if (reload || (_ruleSets == null))
{
var ruleSets = new List <EnvConfigRuleSet>();
// get default settings
const string resourceName = "Default.cfg.xml";
Assembly assembly = Assembly.GetExecutingAssembly();
string xmlText = GetResourceWithPartialName(assembly, resourceName);
if (xmlText == null)
{
throw new FileNotFoundException(
$"Embedded resource '{resourceName}' not found in {assembly.FullName}");
}
ruleSets.Add(DeserializeFromString <EnvConfigRuleSet>(typeof(EnvConfigRuleSet), xmlText));
// load all custom xml files
string assemblyPath = Path.GetDirectoryName(assembly.CodeBase.Replace("file:///", ""));
if (assemblyPath != null)
{
string[] xmlFileNames = Directory.GetFiles(assemblyPath, "QDS.Core.*.cfg.xml", SearchOption.TopDirectoryOnly);
ruleSets.AddRange(xmlFileNames.Select(xmlFileName => DeserializeFromFile <EnvConfigRuleSet>(typeof(EnvConfigRuleSet), xmlFileName)));
}
_ruleSets = ruleSets;
}
// filter
string hostName = Dns.GetHostName();
WindowsIdentity winIdent = WindowsIdentity.GetCurrent();
{
string userName = winIdent.Name.Split('\\')[1];
string envName = EnvName(env);
var selectedRules = new List <EnvConfigRule>();
foreach (EnvConfigRuleSet ruleSet in _ruleSets)
{
if (ruleSet.v2Rules != null)
{
foreach (EnvConfigRule rule in ruleSet.v2Rules)
{
if (!rule.Disabled &&
CandidateMatchesArgument(rule.Env, envName) &&
CandidateMatchesArgument(rule.HostName, hostName) &&
CandidateMatchesArgument(rule.ApplName, applName) &&
CandidateMatchesArgument(rule.UserName, userName))
{
selectedRules.Add(rule);
}
}
}
}
// sort and accumulate
selectedRules.Sort();
foreach (EnvConfigRule rule in selectedRules)
{
// config values are cumulative
if (!rule.Disabled)
{
var ruleNamedValues = DeserialiseNamedValueSet(rule.Settings);
foreach (var item in ruleNamedValues)
{
result[item.Key.ToLower()] = item.Value;
}
}
}
}
return(result);
}
public static string FormatDbCfgStr(EnvId env, string dbServer, string dbPrefix)
{
return(String.Format("Data Source={1};Initial Catalog={2}_{0};Integrated Security=True", EnvName(env), dbServer, dbPrefix));
}
public static int SvcPort(EnvId env, SvcId svc)
{
return(SvcPortBase(env) + SvcPortOffset(svc));
}
protected override void OnServerStarted()
{
// default configuration
_activeProviders = new[] { MDSProviderId.Bloomberg };
// custom configuration
string[] enabledProviders = OtherSettings.GetArray <string>(MdsPropName.EnabledProviders);
if (enabledProviders != null && enabledProviders.Length > 0)
{
_activeProviders = enabledProviders.Select(providerName => EnumHelper.Parse <MDSProviderId>(providerName, true)).ToArray();
}
// derived configuration
EnvId envId = IntClient.Target.ClientInfo.ConfigEnv;
string envName = EnvHelper.EnvName(envId);
var port = OtherSettings.GetValue(MdsPropName.Port, EnvHelper.SvcPort(envId, SvcId.MarketData));
// service endpoints
string transEndpoints = ServiceHelper.FormatEndpoint(WcfConst.NetTcp, port);
string discoEndpoints = ServiceHelper.FormatEndpoint(WcfConst.NetTcp, port);
transEndpoints = OtherSettings.GetValue(MdsPropName.Endpoints, transEndpoints);
// add default port to endpoints if required
var tempEndpoints = new List <string>();
foreach (string ep in transEndpoints.Split(';'))
{
var epParts = ep.Split(':');
var scheme = epParts[0];
var tport = port;
if (epParts.Length > 1)
{
tport = Int32.Parse(epParts[1]);
}
tempEndpoints.Add($"{scheme}:{tport}");
}
transEndpoints = String.Join(";", tempEndpoints.ToArray());
// get user identity and full name
WindowsIdentity winIdent = WindowsIdentity.GetCurrent();
UserPrincipal principal = null;
try
{
var principalContext = new PrincipalContext(ContextType.Domain);
principal = UserPrincipal.FindByIdentity(principalContext, IdentityType.SamAccountName, winIdent.Name);
}
catch (PrincipalException principalException)
{
// swallow - can occur on machines not connected to domain controller
Logger.LogWarning("UserPrincipal.FindByIdentity failed: {0}: {1}", principalException.GetType().Name, principalException.Message);
}
string userFullName = null;
if (principal != null)
{
userFullName = principal.GivenName + " " + principal.Surname;
}
_serverCfg = new ServerCfg(
new ModuleInfo(envName, Guid.NewGuid(), winIdent.Name, userFullName, null, null),
transEndpoints, discoEndpoints);
foreach (MDSProviderId providerId in _activeProviders)
{
_providers[(int)providerId] = new MarketDataRealtimeClient(LoggerRef, MainThreadQueue, IntClient.Target, providerId);
}
string svcName = EnvHelper.SvcPrefix(SvcId.MarketData);
// V2.2
_mrktDataV221ServerHost = new CustomServiceHost <IMrktDataV221, MrktDataRecverV221>(
Logger, new MrktDataRecverV221(this), _serverCfg.TransEndpoints,
svcName, typeof(IMrktDataV221).Name, true);
_sessCtrlV131ServerHost = new CustomServiceHost <ISessCtrlV131, SessCtrlRecverV131>(
Logger, new SessCtrlRecverV131(this), _serverCfg.DiscoEndpoints,
svcName, typeof(ISessCtrlV131).Name, true);
_discoServerHostV111 = new CustomServiceHost <IDiscoverV111, DiscoverRecverV111>(
Logger, new DiscoverRecverV111(this), _serverCfg.DiscoEndpoints,
svcName, typeof(IDiscoverV111).Name, true);
}
