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)")); }
private static string conString; // The default test database connection string /// <summary> /// Static constructor. /// </summary> static SqlTestDatabase() { conString = EnvironmentVars.Get("LT_TEST_DB"); if (conString == null) { conString = "server=.\\SQLEXPRESS;Integrated Security=SSPI"; } }
public void EnvironmentVars_System() { EnvironmentVars.Load(""); Assert.AreEqual(Environment.GetEnvironmentVariable("path"), EnvironmentVars.Get("path")); Assert.AreEqual(Environment.GetEnvironmentVariable("systemdrive"), EnvironmentVars.Get("systemdrive")); Assert.AreEqual(Environment.GetEnvironmentVariable("windir"), EnvironmentVars.Get("windir")); Assert.AreEqual(Environment.GetEnvironmentVariable("comspec"), EnvironmentVars.Get("comspec")); }
/// <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 DigitalOceanWorker( BotCommandResolver botCommandResolver, ITelegramBotClient telegramBotClient, ILogger <DigitalOceanWorker> logger) { _botCommandResolver = botCommandResolver; _logger = logger; _telegramBotClient = telegramBotClient; _userId = EnvironmentVars.GetUserId(); }
/// <summary> /// Handles initialization for processes launched by Azure roles. /// </summary> /// <param name="processName">Identifies the process.</param> private static void ProcessInitialize(string processName) { // Load the known Azure related settings from environment variables set // by the parent Azure role. AzureHelper.RoleName = GetVar("AZURE_ROLENAME") ?? string.Empty; AzureHelper.RoleType = Serialize.Parse <AzureRoleType>(GetVar("AZURE_ROLETYPE"), AzureRoleType.Process); AzureHelper.Datacenter = GetVar("AZURE_DATACENTER") ?? "EMULATOR"; AzureHelper.Deployment = GetVar("AZURE_DEPLOYMENT") ?? "<unknown>"; AzureHelper.Environment = Serialize.Parse <AzureEnvironment>(GetVar("AZURE_ENVIRONMENT"), AzureEnvironment.Dev); AzureHelper.RoleInstanceID = GetVar("AZURE_ROLEINSTANCEID") ?? string.Empty; AzureHelper.RoleIndex = Serialize.Parse(GetVar("AZURE_ROLEINDEX"), -1); AzureHelper.RoleDataPath = GetVar("AZURE_ROLEDATAPATH") ?? string.Empty; if (string.IsNullOrWhiteSpace(AzureHelper.RoleName)) { AzureHelper.RoleName = processName; } // Make sure the role data path points somewhere real in case the // process is running outside the context of an Azure role // (e.g. during development or test). if (string.IsNullOrWhiteSpace(AzureHelper.RoleDataPath) || !Directory.Exists(AzureHelper.RoleDataPath)) { AzureHelper.RoleDataPath = Path.GetTempPath(); } // Make sure that the known Azure settings are persisted to environment variables. // We need to do this to ensure that the configuration settings are loaded properly. System.Environment.SetEnvironmentVariable("AZURE_ROLENAME", AzureHelper.RoleName); System.Environment.SetEnvironmentVariable("AZURE_ROLETYPE", AzureHelper.RoleType.ToString()); System.Environment.SetEnvironmentVariable("AZURE_DATACENTER", AzureHelper.Datacenter); System.Environment.SetEnvironmentVariable("AZURE_DEPLOYMENT", AzureHelper.Deployment); System.Environment.SetEnvironmentVariable("AZURE_ENVIRONMENT", AzureHelper.Environment.ToString().ToUpper()); System.Environment.SetEnvironmentVariable("AZURE_ROLEINSTANCEID", AzureHelper.RoleInstanceID); System.Environment.SetEnvironmentVariable("AZURE_ROLEINDEX", AzureHelper.RoleIndex.ToString()); System.Environment.SetEnvironmentVariable("AZURE_ROLEDATAPATH", AzureHelper.RoleDataPath); // This indicates to the Config class how it can retrieve Windows Azure configuration settings. Config.SetAzureGetSettingMethod(typeof(AzureHelper).GetMethod("GetProcessAzureSetting")); // We need to reload the environment and configuration settings so that they will be processed // in the context of the Azure related settings. if (Helper.EntryAssemblyFile != null) { Config.SetConfigPath(Path.Combine(Helper.AppFolder, Path.GetFileNameWithoutExtension(Helper.EntryAssemblyFile) + ".ini")); EnvironmentVars.Reload(); Config.Load(); } }
public void EnvironmentVars_IsVariable() { // Actual environment vairabl;es Assert.IsTrue(EnvironmentVars.IsVariable("path")); Assert.IsTrue(EnvironmentVars.IsVariable("temp")); Assert.IsTrue(EnvironmentVars.IsVariable("tmp")); // Handle LillTek built-in variables. Assert.IsTrue(EnvironmentVars.IsVariable("os")); Assert.IsTrue(EnvironmentVars.IsVariable("appversion")); }
/// <summary> /// Starts the RADIUS server, intializing the user and client /// databases. /// </summary> /// <param name="users">The user database file contents.</param> /// <param name="clients">The client database file contents.</param> /// <remarks> /// See the <b>users.example</b> and <b>clients.example</b> files /// in the <b>raddb</b> folder for a description of how these /// files must be formatted. /// </remarks> /// <exception cref="NotAvailableException">Thrown if the RADIUS server application is not installed.</exception> public void Start(string users, string clients) { StreamWriter writer = null; string testBinPath; string exePath; testBinPath = EnvironmentVars.Get("LT_TESTBIN"); if (testBinPath == null) { throw new ArgumentException("[LT_TESTBIN] environment variable does not exist."); } testBinPath = Helper.AddTrailingSlash(testBinPath) + @"RadiusServer\"; exePath = testBinPath + "Radl.exe"; usersPath = testBinPath + @"raddb\users"; clientsPath = testBinPath + @"raddb\clients"; if (!File.Exists(exePath)) { throw new NotAvailableException("RADIUS Server not found at: " + exePath); } orgDir = Environment.CurrentDirectory; Environment.CurrentDirectory = testBinPath.Substring(0, testBinPath.Length - 1); try { writer = new StreamWriter(usersPath, false, Helper.AnsiEncoding); writer.Write(users); writer.Close(); writer = null; writer = new StreamWriter(clientsPath, false, Helper.AnsiEncoding); writer.Write(clients); writer.Close(); writer = null; serverProcess = Process.Start(exePath, string.Empty); serverProcess.EnableRaisingEvents = true; Thread.Sleep(5000); // Give the server a chance to initialize } finally { if (writer != null) { writer.Close(); } } }
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 BuildProjectCode(WIXSharpProject project) { Options = project.GetOptions(); GlobalFileAssociations = project.GetGlobalFileAssociations(); Registryvalues = project.GetRegistryValues(); FireExcept = project.GetFirewallExceptions(); Sourcefiles = project.GetSourceFiles(); Certs = project.GetCerts(); EnvironmentVariables = project.GetEnvironmentVars(); application = project.GetApplication(); users = project.GetUsers(); WElements = project.GetElements(); installdir = project.GetInstallDir(); progfiles = project.GetProgFiles(); progmenu = project.GetProgMenu(); }
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 RadiusClient_Interop_AD_IAS() { if (EnvironmentVars.Get("LT_TESTBIN") == null) { Assert.Inconclusive("[LT_TESTBIN] environment variable does not exist."); } if (EnvironmentVars.Get("LT_TEST_AD") == null) { Assert.Inconclusive("[LT_TEST_AD] environment variable does not exist."); } var ad = new ADTestSettings(); if (ad.NasSecret == string.Empty) { Assert.Inconclusive("AD/IAS Testing is disabled"); return; } // Verify that RADIUS client works against AD/IAS. This requires that // the LT_TEST_AD environment variable be set properly as described // in the LillTek DevInstall.doc document. The IAS server must also // be manually configured with the NAS shared secret for this client. RadiusClient client = new RadiusClient(); NetworkBinding serverEP = new NetworkBinding(EnhancedDns.GetHostByName(ad.Servers[0]).AddressList.IPv4Only()[0], NetworkPort.RADIUS); RadiusClientSettings clientSettings = new RadiusClientSettings(serverEP, ad.NasSecret); clientSettings.RealmFormat = RealmFormat.Email; clientSettings.PortCount = 1; try { client.Open(clientSettings); Assert.IsTrue(client.Authenticate(ad.Domain, ad.Account, ad.Password)); Assert.IsFalse(client.Authenticate(ad.Domain + "x", ad.Account, ad.Password)); Assert.IsFalse(client.Authenticate(ad.Domain, ad.Account + "x", ad.Password)); Assert.IsFalse(client.Authenticate(ad.Domain, ad.Account, ad.Password + "x")); } finally { client.Close(); } }
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); } }
public BuildProjectCode(SetupOptions options, FileAssociations fileassoc, RegistryValues registryvalues, FirewallExceptions firewallexceptions, SourceFiles sourcefiles, Certificates certs, EnvironmentVars envirvars, ApplicationInfo app, Users user, Elements elements, string dir, string files, string menu) { Options = options; GlobalFileAssociations = fileassoc; Registryvalues = registryvalues; FireExcept = firewallexceptions; Sourcefiles = sourcefiles; Certs = certs; EnvironmentVariables = envirvars; application = app; users = user; WElements = elements; installdir = dir; progfiles = files; progmenu = menu; addglobalfileassociations(); }
public void RadiusClient_Interop() { if (EnvironmentVars.Get("LT_TESTBIN") == null) { Assert.Inconclusive("[LT_TESTBIN] environment variable does not exist."); } // Verify that my RADIUS client code can work against a server from // another vendor. RadiusTestServer server = new RadiusTestServer(); Dictionary <string, string> users; Dictionary <IPAddress, string> devices; RadiusClient client = new RadiusClient(); RadiusClientSettings clientSettings = new RadiusClientSettings(Local_AAA, "secret"); clientSettings.RealmFormat = RealmFormat.Email; clientSettings.PortCount = 1; users = new Dictionary <string, string>(); users.Add("jeff", "password1"); users.Add("joe", "password2"); devices = new Dictionary <IPAddress, string>(); devices.Add(IPAddress.Loopback, "secret"); devices.Add(NetHelper.GetActiveAdapter(), "secret"); try { server.Start(users, devices); client.Open(clientSettings); Assert.IsTrue(client.Authenticate("", "jeff", "password1")); Assert.IsTrue(client.Authenticate("", "joe", "password2")); Assert.IsFalse(client.Authenticate("", "jeff", "passwordX")); Assert.IsFalse(client.Authenticate("", "billy", "x")); } finally { client.Close(); server.Stop(); } }
/// <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_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"))); }
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 static IHostBuilder ConfigureTelegram(this IHostBuilder hostBuilder) { return(hostBuilder.ConfigureServices((_, collection) => { collection.AddSingleton <ITelegramBotClient>(_ => new TelegramBotClient(EnvironmentVars.GetTelegramToken())); })); }
/// <summary> /// Constructs the default router settings. /// </summary> public RouterSettings() { this.RouterEP = EnvironmentVars.Expand("physical://DETACHED/$(LillTek.DC.DefHubName)/$(Guid)"); }
private static string GetEnvVar(EnvironmentVars var) { return(Environment.GetEnvironmentVariable(var.ToString()) != null? Environment.GetEnvironmentVariable(var.ToString()) : new DefaultEnvVars().GetType().GetProperty(var.ToString())?.GetValue(null)?.ToString()); }
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> /// 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> /// 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 static IHostBuilder ConfigureServices(this IHostBuilder hostBuilder) { return(hostBuilder.ConfigureServices((_, collection) => { collection.Scan(scan => { scan.FromAssemblyOf <IPaginator>() .AddClasses() .AsSelf() .WithSingletonLifetime(); scan.FromAssemblyOf <IBotCommand>() .AddClasses(x => x.AssignableTo <IBotCommand>()) .As <IBotCommand>() .WithSingletonLifetime(); scan.FromAssemblyOf <IBotStateHandler>() .AddClasses(x => x.AssignableTo <IBotStateHandler>()) .As <IBotStateHandler>() .WithSingletonLifetime(); scan.FromAssemblyOf <IBotCallbackQuery>() .AddClasses(x => x.AssignableTo <IBotCallbackQuery>()) .As <IBotCallbackQuery>() .WithSingletonLifetime(); }); collection.AddSingleton <IDigitalOceanClient>(_ => new DigitalOceanClient(EnvironmentVars.GetDigitalOceanToken())); collection.AddSingleton <StorageService>(); collection.AddSingleton <BotCommandResolver>(); })); }
/// <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> /// Constructor. /// </summary> /// <param name="appName">The application name.</param> /// <param name="database">The database name.</param> /// <remarks> /// <note> /// The application name must be no longer than 32 characters /// and can include only letters or digit characters. /// The application name is used to generate a unique database /// user account and password to be used by the application to gain /// gain access to the database. /// </note> /// </remarks> public DBInstallParams(string appName, string database) { SqlConnectionInfo conInfo; string conString; string path; int pos; if (string.IsNullOrWhiteSpace(appName)) { throw new ArgumentException("Invalid application name."); } else if (appName.Length > 32) { throw new ArgumentException("Application name exceeds 32 characters."); } else { foreach (char ch in appName) { if (Char.IsLetterOrDigit(ch)) { continue; } else { throw new ArgumentException("Application name may include only letters or digits characters."); } } } if (string.IsNullOrWhiteSpace(database)) { throw new ArgumentException("Invalid database path."); } conString = EnvironmentVars.Get("LT_TEST_DB"); if (conString != null) { conInfo = new SqlConnectionInfo(conString); } else { conInfo = new SqlConnectionInfo("server=.\\SQLEXPRESS;Integrated Security=SSPI"); } this.appName = appName; this.server = conInfo.Server; this.database = database; this.adminSecurity = string.IsNullOrWhiteSpace(conInfo.Security) ? "" : "Integrated Security=" + conInfo.Security; this.appSecurity = string.Format("uid={0}User;pwd={1}", appName, Crypto.GeneratePassword(8, true)); this.dbPath = null; this.logPath = null; path = Environment.SystemDirectory; pos = path.IndexOf(':'); if (pos == -1) { throw new InvalidOperationException("Unexpected system directory path."); } this.defDBFolder = path.Substring(0, pos + 1) + @"\LillTek\Data"; }
/// <summary> /// Called by Azure roles early in their boot process to intialize global state. Note that /// this method may also be safely called by processes launched by an Azure role. /// </summary> /// <param name="roleName">The role or process name.</param> /// <param name="roleType">The type of Azure role being hosted.</param> /// <exception cref="AzureHelperException">Thrown if initialization failed.</exception> /// <remarks> /// <para> /// This method should be called after <see cref="Helper.InitializeApp"/> or <b>WebHelper.PlatformInitialize()</b> is /// called to perform basic LillTek initalization. /// </para> /// <para> /// This method will set the <b>AZURE_ROLENAME</b>, <b>AZURE_ROLETYPE</b>, <b>AZURE_DATACENTER</b>, /// <b>AZURE_DEPLOYMENT</b>, <b>AZURE_ENVIRONMENT</b>, <b>AZURE_ROLEINDEX</b>, <b>AZURE_ROLEINSTANCEID</b>, /// and <b>AZURE_ROLEDATAPATH</b> environment variables so that child processes can have /// access to this information. /// </para> /// <para> /// Applications can also specify that other Azure configuration settings be persisted /// to the environment by specifying the names of these settings as a comma separated list /// in the <b>EnvironmentSettings</b> Azure configuration setting. /// </para> /// <para> /// This method also requires that the role define the <b>RoleData</b> local folder /// resource in its Azure configuration file. The path to this folder can be obtained /// globally via <see cref="RoleDataPath"/>. /// </para> /// </remarks> public static void RoleInitialize(string roleName, AzureRoleType roleType) { LocalResource resource; // Handle non-Azure role initialization separately. if (roleType == AzureRoleType.Process) { ProcessInitialize(roleName); return; } // Initialize the role type and role data path globals. Note that the data path is required. AzureHelper.RoleName = roleName; AzureHelper.RoleType = roleType; AzureHelper.RoleDataPath = null; try { resource = RoleEnvironment.GetLocalResource("RoleData"); } catch { resource = null; } if (resource != null) { AzureHelper.RoleDataPath = resource.RootPath; } if (AzureHelper.RoleDataPath == null) { throw new AzureHelperException("Could not obtain the [RoleData] local resource. This resource must be specified in the Windows Azure role configuration settings."); } // This indicates to the Config class how it can retrieve Windows Azure configuration settings. Config.SetAzureGetSettingMethod(typeof(Microsoft.WindowsAzure.CloudConfigurationManager).GetMethod("GetSetting")); // $hack: // // I'm going to parse the role deployment index out of the RoleInstance.Id property. // The code below should be robust enough not to crash if the format changes, and // will set RoleInstance=-1 in this case. // // The code below assumes that the ID property looks someything like: // // "deployment17(273).MyService.MyRole_IN_0" // // where the role instance number is the integer at the end. AzureHelper.RoleIndex = -1; try { var fields = RoleEnvironment.CurrentRoleInstance.Id.Split('_'); int v; if (!int.TryParse(fields.Last(), out v) || v < 0) { throw new FormatException("RoleIndex: Last role instance ID field is not a valid instance number."); } AzureHelper.RoleIndex = v; } catch (Exception e) { SysLog.LogException(e, "Unable to extract the role index from the Azure role ID [{0}].", RoleEnvironment.CurrentRoleInstance.Id); } // Load Azure deployment related settings. AzureHelper.Datacenter = Config.Global.Get("Azure.Datacenter", "UNKNOWN"); AzureHelper.Deployment = Config.Global.Get("Azure.Deployment", "UNKNOWN"); AzureHelper.Environment = Config.Global.Get <AzureEnvironment>("Azure.Environment", AzureEnvironment.Unknown); AzureHelper.RoleInstanceID = string.Format("{0}[{1}]", AzureHelper.RoleName, AzureHelper.RoleIndex); if (AzureHelper.Environment == AzureEnvironment.Dev) { var machineName = Helper.MachineName; if (!string.IsNullOrWhiteSpace(machineName)) { AzureHelper.RoleInstanceID = machineName + "." + AzureHelper.RoleInstanceID; } } // Persist Azure deployment related settings to environment variables so // external child processes can pick these up. System.Environment.SetEnvironmentVariable("AZURE_ROLENAME", AzureHelper.RoleName); System.Environment.SetEnvironmentVariable("AZURE_ROLETYPE", AzureHelper.RoleType.ToString()); System.Environment.SetEnvironmentVariable("AZURE_DATACENTER", AzureHelper.Datacenter); System.Environment.SetEnvironmentVariable("AZURE_DEPLOYMENT", AzureHelper.Deployment.ToUpper()); System.Environment.SetEnvironmentVariable("AZURE_ENVIRONMENT", AzureHelper.Environment.ToString().ToUpper()); System.Environment.SetEnvironmentVariable("AZURE_ROLEINSTANCEID", AzureHelper.RoleInstanceID); System.Environment.SetEnvironmentVariable("AZURE_ROLEINDEX", AzureHelper.RoleIndex.ToString()); System.Environment.SetEnvironmentVariable("AZURE_ROLEDATAPATH", AzureHelper.RoleDataPath); // The [Azure.EnvironmentSettings] configuration setting can be used to specify // the names of all the settings to be saved to environment variables to be accessable // by processes launched by the role. Handle this here. var environmentSettings = Config.Global.Get("Azure.EnvironmentSettings", string.Empty).Split(','); foreach (var envSetting in environmentSettings) { var name = envSetting.Trim().ToUpper(); var value = System.Environment.GetEnvironmentVariable(name); if (name == string.Empty || value == null) { continue; } name = "AZURE " + name; if (System.Environment.GetEnvironmentVariable(name) != null) { continue; // Don't overwrite a setting that was saved above. } System.Environment.SetEnvironmentVariable(name, value); } // Load/reload the LillTek environment variables and configuration here. if (roleType == AzureRoleType.Web) { Config.SetConfigPath(Path.Combine(Helper.AppFolder, "Web.ini")); } else { Config.SetConfigPath(Path.Combine(Helper.AppFolder, Path.GetFileNameWithoutExtension(Helper.EntryAssemblyFile) + ".ini")); } EnvironmentVars.Reload(); Config.Load(); }