public void EnvironmentVars_Expand_Recursive() { string cfg1; // Old style cfg1 = @" var1=HELLO var2=%var1% var3=WORLD var4=%var2% %var3% "; EnvironmentVars.Load(cfg1); Assert.AreEqual("HELLO", EnvironmentVars.Expand("%var2%")); Assert.AreEqual("prefix HELLO suffix", EnvironmentVars.Expand("prefix %var2% suffix")); Assert.AreEqual("HELLO WORLD", EnvironmentVars.Expand("%var4%")); // New style cfg1 = @" var1=HELLO var2=$(var1) var3=WORLD var4=$(var2) $(var3) "; EnvironmentVars.Load(cfg1); Assert.AreEqual("HELLO", EnvironmentVars.Expand("$(var2)")); Assert.AreEqual("prefix HELLO suffix", EnvironmentVars.Expand("prefix $(var2) suffix")); Assert.AreEqual("HELLO WORLD", EnvironmentVars.Expand("$(var4)")); }
/// <summary> /// Static constructor. /// </summary> static CoreApp() { // Initialize this to something reasonable so unit tests will work. #if DEBUG CoreApp.InstallPath = EnvironmentVars.Expand(@"$(LT_ROOT)\Main\Platform\Telephony\NeonSwitchCore\bin\x64\Debug"); #else CoreApp.InstallPath = EnvironmentVars.Expand(@"$(LT_ROOT)\Main\Platform\Telephony\NeonSwitchCore\bin\x64\Release"); #endif }
public void EnvironmentVars_Expand_InfiniteRecursion() { string cfg1; // Old style cfg1 = @" var1=%var2% var2=%var1% "; EnvironmentVars.Load(cfg1); try { EnvironmentVars.Expand("%var2%"); Assert.Fail(); // Expected a StackOverflowException } catch (StackOverflowException) { } catch { Assert.Fail(); // Expected a StackOverflowException } // New style cfg1 = @" var1=$(var2) var2=$(var1) "; EnvironmentVars.Load(cfg1); try { EnvironmentVars.Expand("$(var2)"); Assert.Fail(); // Expected a StackOverflowException } catch (StackOverflowException) { } catch { Assert.Fail(); // Expected a StackOverflowException } }
public void EnvironmentVars_IPAddressing() { string output; // This test exercises the IP address macros without actually checking // their values (since they'll differ from machine to machine). This // will test for crashes and also provide a place where these values // can be manually verified. output = EnvironmentVars.Expand(@" ip-address = $(ip-address) ip-mask = $(ip-mask) ip-subnet = $(ip-subnet) "); }
public void EnvironmentVars_BuiltIn() { EnvironmentVars.Load(""); Assert.AreEqual(Environment.GetEnvironmentVariable("temp"), EnvironmentVars.Get("temp")); Assert.AreEqual(Environment.GetEnvironmentVariable("tmp"), EnvironmentVars.Get("tmp")); Assert.AreEqual(Environment.GetEnvironmentVariable("SystemRoot"), EnvironmentVars.Get("SystemRoot")); Assert.AreEqual((Environment.GetEnvironmentVariable("SystemRoot") + @"\system32").ToLowerInvariant(), EnvironmentVars.Get("SystemDirectory").ToLowerInvariant()); Assert.AreEqual(Helper.EntryAssemblyFolder, EnvironmentVars.Get("AppPath")); Assert.IsNotNull(EnvironmentVars.Get("OS")); Assert.IsNotNull(EnvironmentVars.Get("WINFULL")); Assert.IsNull(EnvironmentVars.Get("WINCE")); Assert.AreEqual(Helper.GetVersionString(Assembly.GetExecutingAssembly()), EnvironmentVars.Get("appversion")); Assert.AreEqual(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), EnvironmentVars.ProgramDataPath); Assert.IsTrue(!EnvironmentVars.ProgramDataPath.EndsWith("/")); Assert.IsTrue(!EnvironmentVars.ProgramDataPath.EndsWith("\\")); Assert.AreNotEqual(EnvironmentVars.Get("guid"), EnvironmentVars.Get("Guid")); Assert.AreEqual(Helper.MachineName, EnvironmentVars.Get("MachineName")); Assert.AreEqual(Dns.GetHostName(), EnvironmentVars.Get("HostName")); Assert.AreEqual(EnvironmentVars.ServerID, EnvironmentVars.Get("ServerID")); Assert.AreEqual(Environment.GetEnvironmentVariable("temp"), EnvironmentVars.Expand("$(temp)")); Assert.AreEqual(Environment.GetEnvironmentVariable("tmp"), EnvironmentVars.Expand("$(tmp)")); Assert.AreEqual(Environment.GetEnvironmentVariable("SystemRoot"), EnvironmentVars.Expand("$(SystemRoot)")); Assert.AreEqual((Environment.GetEnvironmentVariable("SystemRoot") + @"\system32").ToLowerInvariant(), EnvironmentVars.Expand("$(SystemDirectory)").ToLowerInvariant()); Assert.AreEqual(Helper.EntryAssemblyFolder, EnvironmentVars.Expand("$(AppPath)")); Assert.IsNotNull(EnvironmentVars.Expand("$(OS)")); Assert.IsNotNull(EnvironmentVars.Expand("$(WINFULL)")); Assert.AreEqual("$(WINCE)", EnvironmentVars.Expand("$(WINCE)")); Assert.AreNotEqual(EnvironmentVars.Expand("$(guid)"), EnvironmentVars.Expand("$(Guid)")); Assert.AreEqual(Helper.MachineName, EnvironmentVars.Expand("$(MachineName)")); Assert.AreEqual(Environment.ProcessorCount.ToString(), EnvironmentVars.Expand("$(ProcessorCount)")); Assert.AreEqual(Const.DCCloudEP.ToString(), EnvironmentVars.Expand("$(LillTek.DC.CloudEP)")); Assert.AreEqual(Const.DCCloudGroup.ToString(), EnvironmentVars.Expand("$(LillTek.DC.CloudGroup)")); Assert.AreEqual(Const.DCCloudPort.ToString(), EnvironmentVars.Expand("$(LillTek.DC.CloudPort)")); Assert.AreEqual(Const.DCRootPort.ToString(), EnvironmentVars.Expand("$(LillTek.DC.RootPort)")); Assert.AreEqual(Const.DCDefHubName, EnvironmentVars.Expand("$(LillTek.DC.DefHubName)")); #if DEBUG Assert.AreEqual("true", EnvironmentVars.Expand("$(IsDebug)")); Assert.AreEqual("false", EnvironmentVars.Expand("$(IsRelease)")); #else Assert.AreEqual("false", EnvironmentVars.Expand("$(IsDebug)")); Assert.AreEqual("true", EnvironmentVars.Expand("$(IsRelease)")); #endif }
/// <summary> /// Queries the realm map provider for the current set of realm mappings. /// </summary> /// <returns>The list of realm mappings.</returns> /// <exception cref="AuthenticationException">Thrown if there's an error getting the map.</exception> public List <RealmMapping> GetMap() { OdbcConnection dbCon = null; OdbcDataReader reader = null; List <RealmMapping> map = new List <RealmMapping>(); OdbcCommand cmd; using (TimedLock.Lock(this)) { if (!IsOpen) { throw new AuthenticationException("Provider is closed."); } dbCon = new OdbcConnection(conString); dbCon.Open(); try { cmd = dbCon.CreateCommand(); cmd.CommandText = query; cmd.CommandType = CommandType.Text; reader = cmd.ExecuteReader(); while (reader.Read()) { map.Add(new RealmMapping(engineSettings, SqlHelper.AsString(reader["Realm"]), Config.Parse(SqlHelper.AsString(reader["ProviderType"]), (System.Type)null), ArgCollection.Parse(EnvironmentVars.Expand(SqlHelper.AsString(reader["Args"]))), SqlHelper.AsString(reader["Query"]))); } } finally { if (reader != null) { reader.Close(); } dbCon.Close(); } return(map); } }
/// <summary> /// Establishes a session with the authentication extension. /// </summary> /// <param name="args">The extension specific arguments (see the remarks).</param> /// <param name="query">Ignored for this extension.</param> /// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param> /// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param> /// <remarks> /// <para> /// This extension recognises the following arguments: /// </para> /// <list type="table"> /// <item> /// <term>Path</term> /// <description> /// The fully qualified path to the credential file. This argument is required. /// </description> /// </item> /// <item> /// <term>Reload</term> /// <description> /// Indicates whether the credentials file should be reloaded before every authentication /// attempt. This can have values such as "yes"/"no" or "true"/"false". This argument /// defaults to "true". /// </description> /// </item> /// <item> /// <term>MaxCacheTime</term> /// <description> /// Specifies the maximum time clients should retain authentication information. /// This is expressed in the same format as timespans parsed by <see cref="Config.Parse(string,TimeSpan)" />. /// This argument defaults to "5m". /// </description> /// </item> /// <item> /// <term>LockoutCount</term> /// <description> /// Specifies the limiting failed authentication count. Accounts /// will be locked when the fail count reaches this number. /// </description> /// </item> /// <item> /// <term>LockoutThreshold</term> /// <description> /// The period of time that can elapse between failed authentication /// attempts where the failed attempts will <b>not</b> be counted against the /// <b>LockoutCount</b>. Set this to <see cref="TimeSpan.Zero" /> /// to disable account lockout for the realm. /// </description> /// </item> /// <item> /// <term>LockoutTime</term> /// <description> /// The period of time an account will remain locked after being locked /// out due to too many failed authentication attempts. /// </description> /// </item> /// </list> /// <note> /// All calls to <see cref="Open" /> must be matched with a call /// to <see cref="Close" /> or <see cref="Dispose" />. /// </note> /// </remarks> public void Open(ArgCollection args, string query, PerfCounterSet perfCounters, string perfPrefix) { using (TimedLock.Lock(this)) { if (IsOpen) { throw new AuthenticationException("Authentication extension is already open."); } perf = new Perf(perfCounters, perfPrefix); path = EnvironmentVars.Expand(args["Path"]); reload = args.Get("Reload", true); maxCacheTime = args.Get("MaxCacheTime", TimeSpan.FromMinutes(5)); if (!reload) { credentials = LoadCredentials(); } } }
public void EnvironmentVars_Expand() { string cfg1 = @" var1=INSERT "; EnvironmentVars.Load(cfg1); // Old style Assert.AreEqual("", EnvironmentVars.Expand("")); Assert.AreEqual("INSERT", EnvironmentVars.Expand("INSERT")); Assert.AreEqual("INSERT", EnvironmentVars.Expand("%var1%")); Assert.AreEqual("prefix INSERT suffix", EnvironmentVars.Expand("prefix %VAR1% suffix")); Assert.AreEqual("%none%", EnvironmentVars.Expand("%none%")); Assert.AreEqual("prefix %none% suffix", EnvironmentVars.Expand("prefix %none% suffix")); Assert.AreEqual("%", EnvironmentVars.Expand("%")); Assert.AreEqual("%hello", EnvironmentVars.Expand("%hello")); Assert.AreEqual("hello%", EnvironmentVars.Expand("hello%")); Assert.AreEqual("hello%world", EnvironmentVars.Expand("hello%world")); // New style Assert.AreEqual("", EnvironmentVars.Expand("")); Assert.AreEqual("INSERT", EnvironmentVars.Expand("INSERT")); Assert.AreEqual("INSERT", EnvironmentVars.Expand("$(var1)")); Assert.AreEqual("prefix INSERT suffix", EnvironmentVars.Expand("prefix $(VAR1) suffix")); Assert.AreEqual("$(none)", EnvironmentVars.Expand("$(none)")); Assert.AreEqual("prefix $(none) suffix", EnvironmentVars.Expand("prefix $(none) suffix")); Assert.AreEqual("$", EnvironmentVars.Expand("$")); Assert.AreEqual("$(", EnvironmentVars.Expand("$(")); Assert.AreEqual("$hello", EnvironmentVars.Expand("$hello")); Assert.AreEqual("$(hello", EnvironmentVars.Expand("$(hello")); Assert.AreEqual("$(hello)", EnvironmentVars.Expand("$(hello)")); Assert.AreEqual("hello)", EnvironmentVars.Expand("hello)")); Assert.AreEqual("hello)world", EnvironmentVars.Expand("hello)world")); }
public void EnvironmentVars_ServerID() { string orgServerID; orgServerID = EnvironmentVars.ServerID; if (String.Compare(orgServerID, Dns.GetHostName(), true) == 0) { orgServerID = null; } try { EnvironmentVars.ServerID = "www.lilltek.com"; Assert.AreEqual("www.lilltek.com", EnvironmentVars.Expand("$(ServerID)")); EnvironmentVars.ServerID = null; Assert.AreEqual(Dns.GetHostName(), EnvironmentVars.Expand("$(ServerID)")); } finally { EnvironmentVars.ServerID = orgServerID; } }
public void EnvironmentVars_Basic() { string cfg1 = @" var1=10 // This is a comment var2 = 20 VAR3=30 path=$(ProgramDataPath)\Foo "; EnvironmentVars.Load(cfg1); Assert.AreEqual("10", EnvironmentVars.Get("var1")); Assert.AreEqual("20", EnvironmentVars.Get("VAR2")); Assert.AreEqual("30", EnvironmentVars.Get("var3")); Assert.IsNull(EnvironmentVars.Get("var4")); Assert.AreEqual(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "Foo"), EnvironmentVars.Expand(EnvironmentVars.Get("path"))); }
/// <summary> /// Starts the router, reading configuration parameters from the /// application's configuration settings. /// </summary> /// <remarks> /// <para> /// This method will gather the instance settings from the application's /// configuration settings, as described below. Multiple router instances /// can be specified in a single configuration file. The router name /// parameter is used to distinguish between the settings for each router /// instance. The method will look for configuration keys prefixed by /// </para> /// <code language="none"> /// "MsgRouter." + name + "." /// </code> /// <para> /// So, when loading the TcpEP setting, Start("Foo") will query for /// "Router.Foo.TcpEP". /// </para> /// <para> /// Here are the configuration settings LeafRouter expects: (note /// that all settings are prefixed by "MsgRouter." as in "MsgRouter.RouterEP". /// </para> /// <div class="tablediv"> /// <table class="dtTABLE" cellspacing="0" ID="Table1"> /// <tr valign="top"> /// <th width="1">Setting</th> /// <th width="1">Default</th> /// <th width="90%">Description</th> /// </tr> /// <tr valign="top"><td>AppName</td><td>EXE file name</td><td>Name of the application hosting the router</td></tr> /// <tr valign="top"><td>AppDescription</td><td>(none)</td><td>Description of the application hosting thr router</td></tr> /// <tr valign="top"> /// <td>RouterEP</td> /// <td>physical://DETACHED/$(LillTek.DC.DefHubName)/$(Guid)</td> /// <td> /// Physical MsgEP for this instance. The endpoint should be three levels deep /// such as physical://root.com:40/hub/leaf and the leaf name should be unique across /// all leaf routers beneath the hub. One way to guarantee uniquness is to use the $(guid) /// environment variable in the endpoint, as in physical://root.com:40/hub/$(MachineName)-$(Guid). /// This will be replaced with a newly generated GUID when the configuration variable /// is processed. /// </td> /// </tr> /// <tr valign="top"> /// <td>DiscoveryMode</td> /// <td>MULTICAST</td> /// <td> /// <para> /// Specifies how the router will go about discovering other routers on the /// network. The possible values are <b>MULTICAST</b> (the default) and /// <b>UDPBROADCAST</b>. /// </para> /// <para> /// If <b>MULTICAST</b> is specified then the router will broadcast and listen /// for presence packets on the specified <see cref="RouterSettings.CloudAdapter"/> for the /// <see cref="RouterSettings.CloudEP" /> multicast endpoint. /// </para> /// <para> /// If <b>UDPBROADCAST</b> is specified then the router will use the LillTek /// Broadcast Server to handle the transmission and reception presence packets /// on networks that don't support multicast. The <see cref="RouterSettings.BroadcastSettings" /> /// property can be used to configure the internal <see cref="UdpBroadcastClient" /> /// used to manage these broadcasts. /// </para> /// </td> /// </tr> /// <tr valign="top"><td>CloudEP</td><td><see cref="Const.DCCloudEP" /></td><td>The discovery UDP multicast network group and port</td></tr> /// <tr valign="top"><td>CloudAdapter</td><td>ANY</td><td>The discovery UDP multicast network adapter address</td></tr> /// <tr valign="top"><td>MulticastSendBufferSize</td><td>64K</td><td>UDP multicast socket send buffer size</td></tr> /// <tr valign="top"><td>MulticastReceiveBufferSize</td><td>64K</td><td>Multicast socket receive buffer size</td></tr> /// <tr valign="top"> /// <td>BroadcastSettings</td> /// <td>(see note)</td> /// <td> /// Settings for the <see cref="UdpBroadcastClient" /> used to manage the precence /// packets used for router discovery when operating in <see cref="DiscoveryMode.UdpBroadcast "/> /// discovery mode. This is initialized with reasonable default values. /// </td> /// </tr> /// <tr valign="top"><td>UdpEP</td><td>ANY:0</td><td>UDP network endpoint</td></tr> /// <tr valign="top"><td>UdpMsgQueueCountMax</td><td>1000</td><td>Max queued outbound UDP normal priority messages.</td></tr> /// <tr valign="top"><td>UdpMsgQueueSizeMax</td><td>10MB</td><td>Max bytes of serialized queued outbound UDP normal priority messages.</td></tr> /// <tr valign="top"><td>UdpSendBufferSize</td><td>64K</td><td>UDP unicast socket send buffer size</td></tr> /// <tr valign="top"><td>UdpReceiveBufferSize</td><td>64K</td><td>UDP unicast socket receive buffer size</td></tr> /// <tr valign="top"><td>TcpEP</td><td>ANY:0</td><td>TCP listening network endpoint</td></tr> /// <tr valign="top"><td>TcpMsgQueueCountMax</td><td>1000</td><td>Max queued outbound TCP normal priority messages.</td></tr> /// <tr valign="top"><td>TcpMsgQueueSizeMax</td><td>10MB</td><td>Max bytes of serialized queued outbound TCP normal priority messages.</td></tr> /// <tr valign="top"><td>TcpBacklog</td><td>100</td><td>Max pending connecting TCP sockets</td></tr> /// <tr valign="top"><td>TcpDelay</td><td>off</td><td>Enables Nagle on TCP channels</td></tr> /// <tr valign="top"><td>TcpSendBufferSize</td><td>64K</td><td>TCP socket send buffer size</td></tr> /// <tr valign="top"><td>TcpReceiveBufferSize</td><td>64K</td><td>TCP socket receive buffer size</td></tr> /// <tr valign="top"><td>BkInterval</td><td>1s</td><td>Background task interval</td></tr> /// <tr valign="top"><td>MaxIdle</td><td>5m</td><td>Maximum time a TCP socket should idle before being closed automatically</td></tr> /// <tr valign="top"><td>EnableP2P</td><td>true</td><td>Enables peer-to-peer routing between routers on the same subnet</td></tr> /// <tr valign="top"><td>AdvertiseTime</td><td>1m</td><td>RouterAdvertiseMsg multicast interval</td></tr> /// <tr valign="top"><td>PhysicalRouteTTL</td><td>3m</td><td>Maximum time a physical route will be maintained without being refreshed with a RouterAdvertiseMsg</td></tr> /// <tr valign="top"><td>DefMsgTTL</td><td>5</td><td>Default message time-to-live (max hops)</td></tr> /// <tr valign="top"><td>SharedKey</td><td>PLAINTEXT</td><td>The shared encryption key used to encrypt all message traffic.</td></tr> /// <tr valign="top"><td>SessionCacheTime</td><td>2m</td><td>Default time the router's session manager will cache idempotent replies.</td></tr> /// <tr valign="top"><td>SessionRetries</td><td>3</td><td>Maximum session initiation retries.</td></tr> /// <tr valign="top"><td>SessionTimeout</td><td>10s</td><td>Default session timeout</td></tr> /// <tr valign="top"><td>MaxLogicalAdvertiseEPs</td><td>256</td><td>Maximum number of logical endpoints to be included in a single LogicalAdvertiseMsg</td></tr> /// <tr valign="top"><td>DeadRouterTTL</td><td>0s</td><td>Maximum time to wait for a <see cref="ReceiptMsg" /> before declaring a dead router. Use 0 to disable dead router detection.</td></tr> /// <tr valign="top"> /// <td>RouteLocal</td> /// <td>(none)</td> /// <td> /// <para> /// An array of zero or more logical routes for which messages should favor /// local destinations. These routes may include wildcards. Here's an example /// configuration fragment: /// </para> /// <code lang="none"> /// #section MsgRouter /// /// RouteLocal[0] = abstract://Test/Local /// RouteLocal[1] = abstract://MyApps/* /// /// #endsection /// </code> /// </td> /// </tr> /// </table> /// </div> /// </remarks> public void Start() { RouterSettings settings; MsgEP routerEP; Config config; string v; // Load the configuration settings config = new Config(MsgHelper.ConfigPrefix); v = config.Get("RouterEP", EnvironmentVars.Expand("physical://DETACHED/$(LillTek.DC.DefHubName)/$(Guid)")); try { routerEP = MsgEP.Parse(v); } catch { throw new MsgException("[MsgRouter.RouterEP] configuration setting is invalid."); } if (routerEP.Segments.Length != 2) { throw new MsgException("[MsgRouter.RouterEP] must specify a valid two segment leaf endpoint (eg: physical://root/hub/leaf)."); } settings = new RouterSettings(routerEP); settings.AppName = config.Get("AppName", settings.AppName); settings.AppDescription = config.Get("AppDescription", settings.AppDescription); settings.DiscoveryMode = config.Get <DiscoveryMode>("DiscoveryMode", settings.DiscoveryMode); settings.CloudAdapter = config.Get("CloudAdapter", settings.CloudAdapter); settings.CloudEP = config.Get("CloudEP", settings.CloudEP); settings.BroadcastSettings = new UdpBroadcastClientSettings(Config.CombineKeys(MsgHelper.ConfigPrefix, "BroadcastSettings")); settings.UdpEP = config.Get("UdpEP", settings.UdpEP); settings.UdpMsgQueueCountMax = config.Get("UdpMsgQueueCountMax", settings.UdpMsgQueueCountMax); settings.UdpMsgQueueSizeMax = config.Get("UdpMsgQueueSizeMax", settings.UdpMsgQueueSizeMax); settings.TcpEP = config.Get("TcpEP", settings.TcpEP); settings.TcpMsgQueueCountMax = config.Get("TcpMsgQueueCountMax", settings.TcpMsgQueueCountMax); settings.TcpMsgQueueSizeMax = config.Get("TcpMsgQueueSizeMax", settings.TcpMsgQueueSizeMax); settings.TcpBacklog = config.Get("TcpBacklog", settings.TcpBacklog); settings.MaxIdle = config.Get("MaxIdle", settings.MaxIdle); settings.EnableP2P = config.Get("EnableP2P", settings.EnableP2P); settings.SessionCacheTime = config.Get("SessionCacheTime", settings.SessionCacheTime); settings.SessionRetries = config.Get("SessionRetries", settings.SessionRetries); settings.SessionTimeout = config.Get("SessionTimeout", settings.SessionTimeout); settings.TcpDelay = config.Get("TcpDelay", settings.TcpDelay); settings.BkInterval = config.Get("BkInterval", settings.BkInterval); settings.DefMsgTTL = config.Get("DefMsgTTL", settings.DefMsgTTL); settings.PhysicalRouteTTL = config.Get("PhysicalRouteTTL", settings.PhysicalRouteTTL); settings.MaxLogicalAdvertiseEPs = config.Get("MaxLogicalAdvertiseEPs", settings.MaxLogicalAdvertiseEPs); settings.DeadRouterTTL = config.Get("DeadRouterTTL", settings.DeadRouterTTL); settings.MulticastSendBufferSize = config.Get("MulticastSendBufferSize", settings.MulticastSendBufferSize); settings.MulticastReceiveBufferSize = config.Get("MulticastReceiveBufferSize", settings.MulticastReceiveBufferSize); settings.UdpSendBufferSize = config.Get("UdpSendBufferSize", settings.UdpSendBufferSize); settings.UdpReceiveBufferSize = config.Get("UdpReceiveBufferSize", settings.UdpReceiveBufferSize); settings.TcpSendBufferSize = config.Get("TcpSendBufferSize", settings.TcpSendBufferSize); settings.TcpReceiveBufferSize = config.Get("TcpReceiveBufferSize", settings.TcpReceiveBufferSize); settings.AdvertiseTime = config.Get("AdvertiseTime", settings.AdvertiseTime); v = config.Get("SharedKey"); if (!string.IsNullOrWhiteSpace(v)) { try { settings.SharedKey = new SymmetricKey(v); } catch { // Ignoring } } // Get the local route endpoints foreach (string ep in config.GetArray("RouteLocal")) { settings.LocalityMap.Add(ep); } Start(settings); }
/// <summary> /// Attempts to load the realm map from the text file. /// </summary> /// <returns>The new realm map.</returns> private List <RealmMapping> LoadMap() { StreamReader reader; List <RealmMapping> realmMap; int lineNum; reader = new StreamReader(path, Helper.AnsiEncoding); try { lineNum = 0; realmMap = new List <RealmMapping>(); while (true) { string map; string[] fields; string realm; System.Type providerType; string args; string query; map = reader.ReadLine(); if (map == null) { break; } lineNum++; map = map.Trim(); if (map.Length == 0 || map.StartsWith("//")) { continue; } map = EnvironmentVars.Expand(map); fields = map.Split(new string[] { "$$" }, StringSplitOptions.None); if (fields.Length != 4) { throw new AuthenticationException("{0}({1}): Four realm map fields expected: [{2}]", Path.GetFileName(path), lineNum, map); } realm = fields[0].Trim(); args = fields[2].Trim(); query = fields[3].Trim(); providerType = Config.Parse(fields[1], (System.Type)null); if (providerType == null) { throw new AuthenticationException("{0}({1}): Unable to instantiate provider class: [{2}]", Path.GetFileName(path), lineNum, fields[1]); } for (int i = 0; i < realmMap.Count; i++) { if (String.Compare(realmMap[i].Realm, realm, true) == 0) { throw new AuthenticationException("{0}({1}): Duplicate realm: {2}", Path.GetFileName(path), realm); } } realmMap.Add(new RealmMapping(engineSettings, realm, providerType, new ArgCollection(args), query)); } } finally { reader.Close(); } return(realmMap); }
/// <summary> /// Establishes a session with the realm map provider. /// </summary> /// <param name="engineSettings">The associated authentication engine's settings.</param> /// <param name="key"> /// This is simply the name of the configuration array that holds the /// static realm mappings. /// </param> /// <remarks> /// <para> /// This provider simply loads a static list of provider mappings from the /// application's configuration settings. The mappings are loaded from /// the configuration key array specified by the <b>key</b> parameter. /// Each element in the array specifies a single realm mapping. The format /// of each is mapping is: /// </para> /// <code language="none"> /// <realm>$$<extension typeref>$$<args>$$<query> /// </code> /// <para> /// where <b>realm</b> identifies the authentication realm, <b>extension typeref</b> /// specifies the type implementing <see cref="IAuthenticationExtension" /> formatted as /// specified for <see cref="Config.Parse(string,System.Type)" />, <b>key</b> /// are the provider arguments and <b>query</b> is the optional provider query /// string. Note the use of <b>$$</b> as field separators. Here's an example /// configuration: /// </para> /// <code language="none"> /// realm-map[0] = lilltek.com$$LillTek.Datacenter.Server.FileAuthenticationExtension:LillTek.Datacenter.Server.dll$$path=c:\lilltek.txt$$ /// realm-map[1] = test.com$$LillTek.Datacenter..Server.FileAuthenticationExtension:LillTek.Datacenter.Server.dll$$path=c:\test.txt$$ /// </code> /// <note> /// Every call to <see cref="Open" /> should be matched by a call to /// <see cref="Close" /> or <see cref="Dispose" />. /// </note> /// </remarks> /// <exception cref="AuthenticationException">Thrown if there's an error loading the map.</exception> public void Open(AuthenticationEngineSettings engineSettings, string key) { string[] configMap; using (TimedLock.Lock(this)) { if (IsOpen) { throw new AuthenticationException("Provider is already open."); } this.engineSettings = engineSettings; configMap = Config.Global.GetArray(key); if (configMap == null) { throw new AuthenticationException("Configuration key [{0}] not found.", key); } realmMap = new List <RealmMapping>(); foreach (string map in configMap) { string[] fields; string realm; System.Type providerType; string args; string query; fields = map.Split(new string[] { "$$" }, StringSplitOptions.None); if (fields.Length != 4) { throw new AuthenticationException("Four realm map fields expected: [{0}]", map); } realm = fields[0].Trim(); args = fields[2].Trim(); query = fields[3].Trim(); if (realm.Length == 0) { throw new AuthenticationException("<realm> field cannot be empty."); } providerType = Config.Parse(fields[1], (System.Type)null); if (providerType == null) { throw new AuthenticationException("Unable to instantiate provider class: [{0}]", fields[1]); } for (int i = 0; i < realmMap.Count; i++) { if (String.Compare(realmMap[i].Realm, realm, true) == 0) { throw new AuthenticationException("Duplicate realm: {0}", realm); } } realmMap.Add(new RealmMapping(engineSettings, realm, providerType, new ArgCollection(EnvironmentVars.Expand(args)), query)); } } }
public void SentinelServiceDB_DeployDB() { SqlTestDatabase dbTest; Package dbPackage = null; DBPackageInstaller dbInstaller; DBInstallParams dbParams; DBInstallResult result; using (dbTest = SqlTestDatabase.Create()) { SqlConnectionInfo conInfo; SqlContext ctx = null; SqlCommand cmd; DataTable dt; try { // Deploy to a non-existent database dbPackage = new Package(EnvironmentVars.Expand("$(LT_BUILD)\\LillTek.SentinelService.dbpack")); dbParams = new DBInstallParams("SentinelService", dbTest.ConnectionInfo.Database); dbInstaller = new DBPackageInstaller(dbPackage); result = dbInstaller.Install(dbParams); Assert.AreEqual(DBInstallResult.Installed, result); conInfo = SqlConnectionInfo.Parse(dbInstaller.ConnectionString); ctx = new SqlContext(conInfo); ctx.Open(); cmd = ctx.CreateSPCall("GetProductInfo"); dt = ctx.ExecuteTable(cmd); Assert.AreEqual(1, dt.Rows.Count); cmd = ctx.CreateSPCall("Ping"); dt = ctx.ExecuteTable(cmd); Assert.AreEqual(1, dt.Rows.Count); Assert.AreEqual("OK", SqlHelper.AsString(dt.Rows[0]["STATUS"])); ctx.Close(); ctx = null; // Deploy again and we should see that the database is up-to-date. SqlConnection.ClearAllPools(); result = dbInstaller.Install(dbParams); Assert.AreEqual(DBInstallResult.UpToDate, result); } finally { if (dbPackage != null) { dbPackage.Close(); } if (ctx != null) { ctx.Close(); } } } }
/// <summary> /// Constructs the default router settings. /// </summary> public RouterSettings() { this.RouterEP = EnvironmentVars.Expand("physical://DETACHED/$(LillTek.DC.DefHubName)/$(Guid)"); }