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