/// <summary> /// Creates and configures the application configuration, where key value pair settings are stored. See /// http://docs.asp.net/en/latest/fundamentals/configuration.html /// http://weblog.west-wind.com/posts/2015/Jun/03/Strongly-typed-AppSettings-Configuration-in-ASPNET-5 /// </summary> /// <param name="hostingEnvironment">The environment the application is running under. This can be Development, /// Staging or Production by default.</param> /// <returns>A collection of key value pair settings.</returns> private static IConfiguration ConfigureConfiguration(IHostingEnvironment hostingEnvironment) { IConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); // Add configuration from the config.json file. configurationBuilder.AddJsonFile("config.json"); // Add configuration from an optional config.development.json, config.staging.json or // config.production.json file, depending on the environment. These settings override the ones in the // config.json file. configurationBuilder.AddJsonFile($"config.{hostingEnvironment.EnvironmentName}.json", optional: true); // This reads the configuration keys from the secret store. This allows you to store connection strings // and other sensitive settings, so you don't have to check them into your source control provider. See // http://go.microsoft.com/fwlink/?LinkID=532709 and // http://docs.asp.net/en/latest/security/app-secrets.html configurationBuilder.AddUserSecrets(); // Add configuration specific to the Development, Staging or Production environments. This config can // be stored on the machine being deployed to or if you are using Azure, in the cloud. These settings // override the ones in all of the above config files. // Note: To set environment variables for debugging navigate to: // Project Properties -> Debug Tab -> Environment Variables // Note: To get environment variables for the machine use the following command in PowerShell: // $env:[VARIABLE_NAME] // Note: To set environment variables for the machine use the following command in PowerShell: // $env:[VARIABLE_NAME]="[VARIABLE_VALUE]" // Note: Environment variables use a colon separator e.g. You can override the site title by creating a // variable named AppSettings:SiteTitle. See // http://docs.asp.net/en/latest/security/app-secrets.html configurationBuilder.AddEnvironmentVariables(); return configurationBuilder.Build(); }
public void ConfigureConfigServerClientSettingsOptions_WithDefaults() { // Arrange var services = new ServiceCollection().AddOptions(); var environment = new HostingEnvironment(); // Act and Assert var builder = new ConfigurationBuilder().AddConfigServer(environment); var config = builder.Build(); services.Configure<ConfigServerClientSettingsOptions>(config); var service = services.BuildServiceProvider().GetService<IOptions<ConfigServerClientSettingsOptions>>(); Assert.NotNull(service); var options = service.Value; Assert.NotNull(options); ConfigServerTestHelpers.VerifyDefaults(options.Settings); Assert.Equal(ConfigServerClientSettings.DEFAULT_PROVIDER_ENABLED, options.Enabled); Assert.Equal(ConfigServerClientSettings.DEFAULT_FAILFAST, options.FailFast); Assert.Equal(ConfigServerClientSettings.DEFAULT_URI, options.Uri); Assert.Equal(ConfigServerClientSettings.DEFAULT_ENVIRONMENT, options.Environment); Assert.Equal(ConfigServerClientSettings.DEFAULT_CERTIFICATE_VALIDATION, options.ValidateCertificates); Assert.Null(options.Name); Assert.Null(options.Label); Assert.Null(options.Username); Assert.Null(options.Password); }
//<inheritdoc/> public IEnumerable<Tenant> GetEnabledTenants() { var fileProvider = _hostingEnvironment.ContentRootFileProvider; var tenantFolders = fileProvider .GetDirectoryContents("tenants") .Where(info => info.IsDirectory); foreach (var tenantFolder in tenantFolders) { var tenantFileName = "tenant.json"; var tenantDirectoryPath = Path.Combine("tenants", tenantFolder.Name); var tenantFilePath = Path.Combine(tenantDirectoryPath, tenantFileName); var tenantFileInfo = fileProvider.GetFileInfo(tenantFilePath); if (tenantFileInfo.Exists) { var builder = new ConfigurationBuilder(); builder.SetFileProvider(fileProvider); builder.AddJsonFile(tenantFilePath); var config = builder.Build(); var tenant = new Tenant { TenantId = tenantFolder.Name, Configuration = config, Identities = config.GetSection("Identities").GetChildren().Select(t => t.Value), Extensions = config.GetSection("Extensions").GetChildren().Select(t => t.Value), Path = tenantFolder.PhysicalPath }; yield return tenant; } } }
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv) { // Setup configuration sources. var builder = new ConfigurationBuilder() .AddJsonFile("appsettings.json") .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true); if (env.IsEnvironment("Development")) { // This reads the configuration keys from the secret store. // For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709 builder.AddUserSecrets(); } // this file name is ignored by gitignore // so you can create it and use on your local dev machine // remember last config source added wins if it has the same settings builder.AddJsonFile("appsettings.local.overrides.json", optional: true); // most common use of environment variables would be in azure hosting // since it is added last anything in env vars would trump the same setting in previous config sources // so no risk of messing up settings if deploying a new version to azure builder.AddEnvironmentVariables(); Configuration = builder.Build(); //env.MapPath appBasePath = appEnv.ApplicationBasePath; }
protected override void OnStart(string[] args) { try { var configProvider = new MemoryConfigurationProvider(); configProvider.Add("server.urls", "http://localhost:5000"); var config = new ConfigurationBuilder() .Add(configProvider) .Build(); var builder = new WebHostBuilder(config); builder.UseServer("Microsoft.AspNet.Server.Kestrel"); builder.UseServices(services => services.AddMvc()); builder.UseStartup(appBuilder => { appBuilder.UseDefaultFiles(); appBuilder.UseStaticFiles(); appBuilder.UseMvc(); }); var hostingEngine = builder.Build(); _application = hostingEngine.Start(); } catch (Exception ex) { Debug.WriteLine("error in OnStart: " + ex); throw; } }
public int Main(string[] args) { var builder = new ConfigurationBuilder(); //builder.Add(new JsonConfigurationSource("config.json")); builder.AddJsonFile("config.json"); var config = builder.Build(); var webjobsConnectionString = config["Data:AzureWebJobsStorage:ConnectionString"]; var dbConnectionString = config["Data:DefaultConnection:ConnectionString"]; if (string.IsNullOrWhiteSpace(webjobsConnectionString)) { Console.WriteLine("The configuration value for Azure Web Jobs Connection String is missing."); return 10; } if (string.IsNullOrWhiteSpace(dbConnectionString)) { Console.WriteLine("The configuration value for Database Connection String is missing."); return 10; } var jobHostConfig = new JobHostConfiguration(webjobsConnectionString); var host = new JobHost(jobHostConfig); host.RunAndBlock(); return 0; }
private static DungeonParameters GatherParameters() { var builder = new ConfigurationBuilder() .AddJsonFile("AppSettings.json") .AddEnvironmentVariables(); var configuration = builder.Build(); return new DungeonParameters { Width = configuration.GetValue<int>("Map:Width"), Height = configuration.GetValue<int>("Map:Height"), CellSparseFactor = configuration.GetValue<int>("Map:CellSparseFactor"), DeadEndSparseFactor = configuration.GetValue<int>("Map:DeadEndSparseFactor"), TwistFactor = configuration.GetValue<int>("Map:TwistFactor"), RoomParameters = new RoomParameters { Count = configuration.GetValue<int>("Map:Room:Count"), MinWidth = configuration.GetValue<int>("Map:Room:MinWidth"), MaxWidth = configuration.GetValue<int>("Map:Room:MaxWidth"), MinHeight = configuration.GetValue<int>("Map:Room:MinHeight"), MaxHeight = configuration.GetValue<int>("Map:Room:MaxHeight") } }; }
public Startup() { var builder = new ConfigurationBuilder() .AddJsonFile("Config.json") .AddEnvironmentVariables(); Configuration = builder.Build(); }
public void Run() { try { Console.WriteLine("Reading Configuration"); var builder = new ConfigurationBuilder() .SetBasePath(PlatformServices.Default.Application.ApplicationBasePath) .AddJsonFile("config.json") .AddEnvironmentVariables(); _config = builder.Build(); _ctx = new OldWilderContext(_config); _newCtx = new WilderContext(_config); _repo = new WilderRepository(_config, _newCtx); Console.WriteLine("Migrating Stories"); MigrateStories(); //TODO More migration } catch (Exception ex) { Console.WriteLine(ex.ToString()); Console.ReadKey(); } }
IEnumerable<ShellSettings> IShellSettingsManager.LoadSettings() { var shellSettings = new List<ShellSettings>(); foreach (var tenant in _appDataFolder.ListDirectories(_optionsAccessor.Value.Location)) { if (_logger.IsEnabled(LogLevel.Information)) { _logger.LogInformation("ShellSettings found in '{0}', attempting to load.", tenant.Name); } var configurationContainer = new ConfigurationBuilder() .SetBasePath(_appDataFolder.RootPath) .AddJsonFile(_appDataFolder.Combine(tenant.FullName, string.Format(SettingsFileNameFormat, "json")), true) .AddXmlFile(_appDataFolder.Combine(tenant.FullName, string.Format(SettingsFileNameFormat, "xml")), true) .AddYamlFile(_appDataFolder.Combine(tenant.FullName, string.Format(SettingsFileNameFormat, "txt")), false); var config = configurationContainer.Build(); var shellSetting = ShellSettingsSerializer.ParseSettings(config); shellSettings.Add(shellSetting); if (_logger.IsEnabled(LogLevel.Information)) { _logger.LogInformation("Loaded ShellSettings for tenant '{0}'", shellSetting.Name); } } return shellSettings; }
public void Configure(IApplicationBuilder app) { var builder = new ConfigurationBuilder(); builder.Add(new MemoryConfigurationProvider { {"MySettings:RetryCount", "42"}, {"MySettings:DefaultAdBlock", "House"}, {"MySettings:AdBlock:House:ProductCode", "123"}, {"MySettings:AdBlock:House:Origin", "blob-456"}, {"MySettings:AdBlock:Contoso:ProductCode", "contoso2014"}, {"MySettings:AdBlock:Contoso:Origin", "sql-789"}, }); var config = builder.Build(); var mySettings = new MySettings(); mySettings.Read(config.GetSection("MySettings")); app.Run(async ctx => { ctx.Response.ContentType = "text/plain"; await ctx.Response.WriteAsync(string.Format("Retry Count {0}\r\n", mySettings.RetryCount)); await ctx.Response.WriteAsync(string.Format("Default Ad Block {0}\r\n", mySettings.DefaultAdBlock)); foreach (var adBlock in mySettings.AdBlocks.Values) { await ctx.Response.WriteAsync(string.Format( "Ad Block {0} Origin {1} Product Code {2}\r\n", adBlock.Name, adBlock.Origin, adBlock.ProductCode)); } }); }
public static void Main(string[] args) { var configBuilder = new ConfigurationBuilder().AddCommandLine(args); Configuration = configBuilder.Build(); string configFile = Configuration["config"]; if (configFile != null) { configBuilder.AddJsonFile(configFile, optional: false); Configuration = configBuilder.Build(); } ConfigurationBinder.Bind(Configuration.GetSection("startup"), _startupOptions); ConfigurationBinder.Bind(Configuration.GetSection("security"), _securityOptions); _loggerFactory .AddDebug() .AddConsole(LogLevel.Trace) .AddProvider(new FileLoggerProvider(_startupOptions.Name)); _logger = _loggerFactory.CreateLogger<Program>(); if (_startupOptions.Name != null) { _logger.LogInformation(Resources.Info_BrokerName, _startupOptions.Name); } var tlsConfig = new TlsConfiguration(_logger, _securityOptions); var httpsOptions = tlsConfig.GetHttpsOptions(Configuration); Uri uri = GetServerUri(Configuration); try { CreateWebHost(httpsOptions).Run(); } catch(AggregateException ex) when (ex.IsPortInUseException()) { _logger.LogError(0, ex.InnerException, Resources.Error_ConfiguredPortNotAvailable, uri?.Port); } }
// ReSharper disable once UnusedParameter.Local public Startup(IHostingEnvironment env) { var builder = new ConfigurationBuilder() .AddJsonFile("config.json") .AddEnvironmentVariables("Dorothy:"); Configuration = builder.Build(); }
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv) { //Setting up configuration builder var builder = new ConfigurationBuilder() .SetBasePath(appEnv.ApplicationBasePath) .AddEnvironmentVariables(); if (!env.IsProduction()) { builder.AddUserSecrets(); } else { } Configuration = builder.Build(); //Setting up configuration if (!env.IsProduction()) { var confConnectString = Configuration.GetSection("Data:DefaultConnection:ConnectionString"); confConnectString.Value = @"Server=(localdb)\mssqllocaldb;Database=GetHabitsAspNet5;Trusted_Connection=True;"; var identityConnection = Configuration.GetSection("Data:IdentityConnection:ConnectionString"); identityConnection.Value = @"Server=(localdb)\mssqllocaldb;Database=GetHabitsIdentity;Trusted_Connection=True;"; } else { } }
protected override void OnStart(string[] args) { try { var temp = new ConfigurationBuilder() .AddJsonFile("config.json") .AddJsonFile("hosting.json", true) .Build(); var configProvider = new MemoryConfigurationProvider(); configProvider.Add("server.urls", temp["WebServerAddress"]); configProvider.Add("webroot", temp.Get<string>("webroot", "wwwroot")); var config = new ConfigurationBuilder() .Add(configProvider) .Build(); var builder = new WebHostBuilder(config); builder.UseServer("Microsoft.AspNet.Server.Kestrel"); builder.UseStartup<Startup>(); var hostingEngine = builder.Build(); _application = hostingEngine.Start(); } catch (Exception ex) { Debug.WriteLine("error in OnStart: " + ex); throw; } }
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv) { // Setup configuration sources. var builder = new ConfigurationBuilder().AddEnvironmentVariables(); Configuration = builder.Build(); }
public Startup(IHostingEnvironment env) { var builder = new ConfigurationBuilder() .AddJsonFile("appsettings.json"); Configuration = builder.Build(); }
public Startup( IHostingEnvironment env, IApplicationEnvironment appEnv) { _env = env; // Setup configuration sources. var builder = new ConfigurationBuilder() .SetBasePath(appEnv.ApplicationBasePath) // standard config file .AddJsonFile("config.json") // environment specific config.<environment>.json file .AddJsonFile($"config.{env.EnvironmentName}.json", true /* override if exists */) // standard Windows environment variables .AddEnvironmentVariables(); if (env.IsDevelopment()) { // this one adds not using directive to keep it secret, only a dnx reference // the focus is not on Secrets but on User, so these are User specific settings // we can also make it available only for developers builder.AddUserSecrets(); } Configuration = builder.Build(); }
public Startup(IHostingEnvironment env) { // Set up configuration sources. Configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json") .AddEnvironmentVariables() .Build(); }
public static void Main(string[] args) { if (Debugger.IsAttached) { Environment.SetEnvironmentVariable( "ASPNETCORE_ENVIRONMENT", EnvironmentName.Development); } var config = new ConfigurationBuilder() .AddJsonFile("hosting.json", optional: true) .AddEnvironmentVariables("ASPNETCORE_") .AddCommandLine(args) .Build(); var host = new WebHostBuilder() .UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseConfiguration(config) .UseIISIntegration() .UseStartup<Startup>() .Build(); host.Run(); }
public Startup(IHostingEnvironment env) { // Setup configuration sources. Configuration = new ConfigurationBuilder() .AddJsonFile("config.json") .Build(); }
public Startup(IHostingEnvironment hostingEnvironment, IApplicationEnvironment applicationEnvironment) { Configuration = new ConfigurationBuilder() .SetBasePath(applicationEnvironment.ApplicationBasePath) .AddJsonFile("config.json") .Build(); }
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv) { Configuration = new ConfigurationBuilder() .AddJsonFile(ConfigFilename) .AddEnvironmentVariables() .Build(); }
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnvironment) { _appEnvironment = appEnvironment; _hostingEnvironment = env; var RollingPath = Path.Combine(appEnvironment.ApplicationBasePath, "logs/myapp-{Date}.txt"); Log.Logger = new LoggerConfiguration() .WriteTo.RollingFile(RollingPath) .CreateLogger(); Log.Information("Ah, there you are!"); // Set up configuration sources. var builder = new ConfigurationBuilder() .AddJsonFile("appsettings.json") .AddJsonFile("appsettings-filters.json") .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true); if (env.IsDevelopment()) { // For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709 builder.AddUserSecrets(); } builder.AddEnvironmentVariables(); Configuration = builder.Build(); // Initialize the global configuration static GlobalConfigurationRoot.Configuration = Configuration; }
public static void Main(string[] args) { var config = new ConfigurationBuilder() .AddCommandLine(args) .AddEnvironmentVariables(prefix: "ASPNETCORE_") .AddJsonFile("hosting.json", optional: true) .Build(); var host = new WebHostBuilder() .UseConfiguration(config) // Default set of configurations to use, may be subsequently overridden //.UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) // Override the content root with the current directory .UseUrls("http://*:1000", "https://*:902") .UseEnvironment("Development") .UseWebRoot("public") .ConfigureServices(services => { // Configure services that the application can see services.AddSingleton<IMyCustomService, MyCustomService>(); }) .Configure(app => { // Write the application inline, this won't call any startup class in the assembly app.Use(next => context => { return next(context); }); }) .Build(); host.Run(); }
public Startup(IHostingEnvironment env) { // Set up configuration sources. var builder = new ConfigurationBuilder() .AddJsonFile("appsettings.json"); #if DEBUG URLS.Api_url = "http://localhost:58517/"; URLS.Html_url = "http://localhost:7079/oauth.html"; URLS.Idt_url = "http://localhost:58058/"; URLS.Mvc_url = "http://localhost:7079/signin-oidc"; #endif #if RELEASE URLS.Api_url = "http://it4govwebapi.azurewebsites.net/"; URLS.Html_url = "http://it4govwebapp.azurewebsites.net/oauth.html"; URLS.Idt_url = "http://it4govidentityserver.azurewebsites.net"; URLS.Mvc_url = "http://it4govwebapp.azurewebsites.net/signin-oidc"; #endif // This will push telemetry data through Application Insights pipeline faster, allowing you to view results immediately. builder.AddApplicationInsightsSettings(developerMode: true); builder.AddEnvironmentVariables(); Configuration = builder.Build().ReloadOnChanged("appsettings.json"); }
public ProviderServices(IApplicationEnvironment env) { var configuration = new ConfigurationBuilder() .BuildConfiguration(env); _serviceProvider = new ServiceCollection() .AddLogging() .AddOptions() .Configure<MailConfiguration>(configuration) .Configure<TestOptions>(configuration) .AddSingleton<TestConfiguration>() .AddInstance(configuration) .AddProceesProviderServices() .AddTransient<IModifiedCodeTestsFinder, ModifiedCodeTestsFinder>() .AddTransient<IDnxTestRunner, DnxTestRunner>() .AddTransient<ITestRunner, TestRunner>() .AddTransient<IMailServiceFactory, MailServiceFactory>() .AddInstance(env) .BuildServiceProvider(); _serviceProvider.GetService<ILoggerFactory>().AddConsole(LogLevel.Information); }
public static void Main(string[] args) { var configBuilder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("hosting.json"); var configuration = configBuilder.Build(); var hostBuilder = new WebHostBuilder(); // set urls and environment hostBuilder .UseUrls(configuration["urls"]) .UseEnvironment(configuration["environment"]); // set other common things hostBuilder .UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseIISIntegration() .UseStartup<Startup>(); var host = hostBuilder.Build(); host.Run(); }
IEnumerable<ShellSettings> IShellSettingsManager.LoadSettings() { var shellSettings = new List<ShellSettings>(); foreach (var tenant in _appDataFolder.ListDirectories("Sites")) { _logger.LogInformation("ShellSettings found in '{0}', attempting to load.", tenant.Name); var configurationContainer = new ConfigurationBuilder() .AddJsonFile(_appDataFolder.Combine(tenant.PhysicalPath, string.Format(SettingsFileNameFormat, "json")), true) .AddXmlFile(_appDataFolder.Combine(tenant.PhysicalPath, string.Format(SettingsFileNameFormat, "xml")), true) .AddYamlFile(_appDataFolder.Combine(tenant.PhysicalPath, string.Format(SettingsFileNameFormat, "txt")), false); var config = configurationContainer.Build(); var shellSetting = new ShellSettings(config); shellSettings.Add(shellSetting); _logger.LogInformation("Loaded ShellSettings for tenant '{0}'", shellSetting.Name); } return shellSettings; }
public async Task RegisterAddresses_Success(string addressInput, string[] testUrls) { var config = new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary<string, string> { { "server.urls", addressInput } }) .Build(); var applicationBuilder = new WebApplicationBuilder() .UseConfiguration(config) .UseServerFactory("Microsoft.AspNet.Server.Kestrel") .Configure(ConfigureEchoAddress); using (var app = applicationBuilder.Build().Start()) { using (var client = new HttpClient()) { foreach (var testUrl in testUrls) { var responseText = await client.GetStringAsync(testUrl); Assert.Equal(testUrl, responseText); } } } }
public void Given_The_system_has_version_P0(String P0) { var config = new Dictionary <string, string>() { ["version"] = P0 }; var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder(); configurationBuilder.AddInMemoryCollection(config); _config = configurationBuilder.Build(); }
public LiteSmallEventPublisher(IHostingEnvironment env /*, AMQPEventSubscriber aMQPEventSubscriber*/) { connectionFactory = new ConnectionFactory(); var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json", optional: false, reloadOnChange: false) .AddEnvironmentVariables(); builder.Build().GetSection("RabbitMqSetting").Bind(connectionFactory); }
public IntegrationTestsStartup(IHostingEnvironment env) { var builder = new ConfigurationBuilder() .SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true) .AddJsonFile("configuration.json") .AddEnvironmentVariables(); Configuration = builder.Build(); }
private static void Configure(string profile, bool ignoreCertificateErrors, bool noProtection) { // read configuration values var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(AppDomain.CurrentDomain.BaseDirectory) .AddJsonFile("appsettings.json", false) .AddJsonFile($"{profile}.json", false); var configurationRoot = builder.Build(); // configure logging _loggerFactory = new LoggerFactory(); _loggerFactory.AddConsole(configurationRoot.GetSection("Logging")); _logger = _loggerFactory.CreateLogger("TestClient"); // configure caching var distributedCache = DistributedCacheFactory.Create(); // set up address registry var addressRegistrySettings = new AddressRegistrySettings(); configurationRoot.GetSection("AddressRegistrySettings").Bind(addressRegistrySettings); addressRegistrySettings.WcfConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); var addressRegistry = new AddressRegistry(addressRegistrySettings, distributedCache); // set up collaboration registry var collaborationProtocolRegistrySettings = new CollaborationProtocolRegistrySettings(); configurationRoot.GetSection("CollaborationProtocolRegistrySettings").Bind(collaborationProtocolRegistrySettings); collaborationProtocolRegistrySettings.WcfConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); var collaborationProtocolRegistry = new CollaborationProtocolRegistry(collaborationProtocolRegistrySettings, distributedCache, addressRegistry); _clientSettings = new ClientSettings(); configurationRoot.GetSection("ClientSettings").Bind(_clientSettings); // set up messaging var messagingSettings = new MessagingSettings(); configurationRoot.GetSection("MessagingSettings").Bind(messagingSettings); messagingSettings.IgnoreCertificateErrorOnSend = ignoreCertificateErrors; messagingSettings.LogPayload = true; if (noProtection) { _messagingClient = new MessagingClient(messagingSettings, collaborationProtocolRegistry, addressRegistry, null, null, new NoMessageProtection()); } else { _messagingClient = new MessagingClient(messagingSettings, collaborationProtocolRegistry, addressRegistry); } }
public Startup(IHostingEnvironment env) { var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder(); builder.SetBasePath(env.ContentRootPath) .AddJsonFile("configuration.json", optional: false, reloadOnChange: true) .AddEnvironmentVariables(); Configuration = builder.Build(); }
public Startup(IHostingEnvironment env) { var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true) .AddEnvironmentVariables(); this.Configuration = builder.Build(); Configuration = builder.Build(); }
public static void Main(string[] args) { Microsoft.Extensions.Configuration.ConfigurationBuilder bconfig = (Microsoft.Extensions.Configuration.ConfigurationBuilder)(new Microsoft.Extensions.Configuration.ConfigurationBuilder()); //if (args != null)bconfig.AddCommandLine(args).Build(); bconfig.SetBasePath(BasePath); bconfig.AddJsonFile(AppName + ".json", optional: true, reloadOnChange: true); _Config = bconfig.Build(); Start(args); Config_OnChanged = Config.GetReloadToken().RegisterChangeCallback(Call_Config_OnChanged, new object[] { Config }); }
private static void LoadConfiguration(string[] args) { System.Console.WriteLine("Loading Configuration..."); var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddCommandLine(args) .AddEnvironmentVariables(); Configuration = builder.Build(); System.Console.WriteLine("Finished Loading Configuration."); }
/// <summary> /// Start code for ASP.NET Core >= 2.0, see https://docs.microsoft.com/en-us/aspnet/core/migration/1x-to-2x/ /// </summary> /// <param name="args"></param> public static void Main(string[] args) { //BL.DataGenerator.Run(); CUI.MainHeadline("MiracleList Backend v" + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString()); Console.WriteLine(); CUI.Headline("Main"); CUI.Print("OS: " + System.Environment.OSVersion); CUI.Print("Runtime: " + ITVisions.CLRInfo.GetClrVersion()); CUI.Print("Webframework: ASP.NET Core v" + typeof(WebHost).Assembly.GetName().Version.ToString()); var configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .AddCommandLine(args) .Build(); var hostUrl = configuration["hosturl"]; if (string.IsNullOrEmpty(hostUrl)) { hostUrl = "http://localhost:6000"; } CUI.Print("HostURL: " + hostUrl); var builder = WebHost.CreateDefaultBuilder(args) .UseUrls(hostUrl) .UseSetting("detailedErrors", "true") .UseStartup <Startup>() .CaptureStartupErrors(true) .ConfigureLogging((hostingContext, logging) => { logging.AddConsole(); }) .Build(); CUI.H2("Server Features:"); foreach (var sf in builder.ServerFeatures) { Console.WriteLine(sf.Key + "=" + sf.Value); if (sf.Value is IServerAddressesFeature) { var saf = sf.Value as IServerAddressesFeature; foreach (var a in saf.Addresses) { Console.WriteLine(a); } } } builder.Run(); }
public Startup(Microsoft.AspNetCore.Hosting.IWebHostEnvironment env) { var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder(); builder.SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json") //add configuration.json .AddJsonFile("configuration.json", optional: false, reloadOnChange: true) .AddEnvironmentVariables(); Configuration = builder.Build(); }
private void _getConnectionString() { // Create Builder var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder() //.SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json") .AddEnvironmentVariables(); var config = builder.Build(); // Get Connection string from the build var connectionString = config.GetConnectionString("(default)"); }
public void Start() { var config = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .AddCommandLine(new[] { "--server.urls", $"http://{_serverInterface}:{_serverPort}" }); var builder = new WebHostBuilder() .UseKestrel() .ConfigureServices(serviceCollection => { serviceCollection.AddSingleton(_environment); serviceCollection.AddSingleton(_sharedTextWriter); serviceCollection.AddSingleton(NullEventEmitter.Instance); serviceCollection.AddSingleton(_pluginAssemblies); serviceCollection.AddSingleton(new HttpEnvironment { Port = _serverPort }); }) .UseUrls($"http://{_serverInterface}:{_serverPort}") .UseConfiguration(config.Build()) .UseEnvironment("OmniSharp") .UseStartup(typeof(Startup)); using (var app = builder.Build()) { app.Start(); var appLifeTime = app.Services.GetRequiredService <IApplicationLifetime>(); Console.CancelKeyPress += (sender, e) => { appLifeTime.StopApplication(); e.Cancel = true; }; if (_environment.HostProcessId != -1) { try { var hostProcess = Process.GetProcessById(_environment.HostProcessId); hostProcess.EnableRaisingEvents = true; hostProcess.OnExit(() => appLifeTime.StopApplication()); } catch { // If the process dies before we get here then request shutdown // immediately appLifeTime.StopApplication(); } } appLifeTime.ApplicationStopping.WaitHandle.WaitOne(); } }
public virtual void LoadConfiguration() { if (String.IsNullOrEmpty(FullLoadedFileName)) { throw new Exception("The file hasn't been defined, yet, so we can't load an empty definition"); } IConfigurationBuilder configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder().SetBasePath(@Directory.GetCurrentDirectory()); LoadedConfiguration = configurationBuilder .AddJsonFile(FullLoadedFileName, optional: true, reloadOnChange: true).Build(); }
public Startup(IHostingEnvironment env) { var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true) // adding cache.json which contains cachemanager configuration(s) .AddJsonFile("cache.json", optional: false) .AddEnvironmentVariables(); Configuration = builder.Build(); }
public Startup(IHostingEnvironment env) { var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder(); builder.SetBasePath(env.ContentRootPath) .AddJsonFile($"appsettings.{env.EnvironmentName}.json") //add configuration.json .AddJsonFile($"configuration.{env.EnvironmentName}.json") .AddEnvironmentVariables(); Configuration = builder.Build(); }
static BaseTest() { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.AddInMemoryCollection(DefaultConfigurationStrings); Configuration = builder.Build(); //LogManager.Adapter = new ConsoleOutLoggerFA(new NameValueCollection()); ScriptDirectory = Path.Combine(Path.Combine(Path.Combine(Path.Combine(Path.Combine(TestContext.CurrentContext.TestDirectory, ".."), ".."), ".."), "Scripts"), Configuration["database"]) + Path.DirectorySeparatorChar; }
/// <summary> /// Build the configuration and populate the service collection based on the input environment. /// </summary> private (IConfigurationRoot Configuration, ServicesBuilder ServicesBuilder) Init() { var configurationOptions = this.GetOrAdd(() => new ConfigurationOptions()); var configurationBuilder = new ConfigurationBuilder() .SetFileProvider(_environment.ContentRootFileProvider) .Apply(configurationOptions.ApplicationConfiguration) .Apply(configurationOptions.EnvironmentConfiguration, _environment.EnvironmentName) .Apply(configurationOptions.EnvironmentConfiguration, "local"); #pragma warning disable CA2000 var cb = new Extensions.Configuration.ConfigurationBuilder( Scanner, _environment, new ConfigurationRoot(new List <IConfigurationProvider>()), configurationBuilder, _logger, ServiceProperties ); #pragma warning restore CA2000 var configuration = configurationBuilder .AddConfiguration(cb.Build()) .Build(); var serviceCollection = new ServiceCollection(); var servicesBuilder = new ServicesBuilder( Scanner, AssemblyProvider, AssemblyCandidateFinder, serviceCollection, configuration, _environment, _logger, ServiceProperties ); servicesBuilder.Services.AddLogging( builder => { builder.ClearProviders(); builder.Services.AddSingleton(_loggerFactory); } ); Composer.Register( servicesBuilder.Scanner, servicesBuilder, typeof(IServiceConvention), typeof(ServiceConventionDelegate) ); return(configuration, servicesBuilder); }
public static OmniSharpTestHost Create(string path = null, ITestOutputHelper testOutput = null, IEnumerable <KeyValuePair <string, string> > configurationData = null, DotNetCliVersion dotNetCliVersion = DotNetCliVersion.Current) { var environment = new OmniSharpEnvironment(path, logLevel: LogLevel.Trace); var loggerFactory = new LoggerFactory().AddXunit(testOutput); var logger = loggerFactory.CreateLogger <OmniSharpTestHost>(); var sharedTextWriter = new TestSharedTextWriter(testOutput); var dotNetCliService = CreateTestDotNetCliService(dotNetCliVersion, loggerFactory); var info = dotNetCliService.GetInfo(); logger.LogInformation($"Using .NET CLI: {info.Version}"); var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder(); builder.AddInMemoryCollection(configurationData); // We need to set the "UseLegacySdkResolver" for tests because // MSBuild's SDK resolver will not be able to locate the .NET Core SDKs // that we install locally in the ".dotnet" and ".dotnet-legacy" directories. // This property will cause the MSBuild project loader to set the // MSBuildSDKsPath environment variable to the correct path "Sdks" folder // within the appropriate .NET Core SDK. var msbuildProperties = new Dictionary <string, string>() { [$"MSBuild:{nameof(MSBuildOptions.UseLegacySdkResolver)}"] = "true", [$"MSBuild:{nameof(MSBuildOptions.MSBuildSDKsPath)}"] = Path.Combine(info.BasePath, "Sdks") }; builder.AddInMemoryCollection(msbuildProperties); var configuration = builder.Build(); var serviceProvider = new TestServiceProvider(environment, loggerFactory, sharedTextWriter, configuration, NullEventEmitter.Instance, dotNetCliService); var compositionHost = new CompositionHostBuilder(serviceProvider) .WithAssemblies(s_lazyAssemblies.Value) .Build(); var workspace = compositionHost.GetExport <OmniSharpWorkspace>(); WorkspaceInitializer.Initialize(serviceProvider, compositionHost, configuration, logger); var host = new OmniSharpTestHost(serviceProvider, loggerFactory, workspace, compositionHost); // Force workspace to be updated var service = host.GetWorkspaceInformationService(); service.Handle(new WorkspaceInformationRequest()).Wait(); return(host); }
/// <inheritdoc /> public ApplicationDbContext CreateDbContext(string[] args) { var configuration = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json") .Build(); var builder = new DbContextOptionsBuilder <ApplicationDbContext>(); var connectionString = configuration.GetConnectionString(ConfigurationVariables.DefaultConnection); builder.UseSqlServer(connectionString, sqlServerOptions => sqlServerOptions.MigrationsAssembly(ConfigurationVariables.MigrationAssembly)); return(new ApplicationDbContext(builder.Options)); }
static void Main(string[] args) { Console.WriteLine("Hello World!"); var config = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(Environment.CurrentDirectory) .AddJsonFile("appsettings.json", optional: true) .Build(); InitConfigValues(config); //int result = GetNumberOfCalendars().Result; //int result = Calendar.API.CalendarApi.GetEvents(CalendarId).Result; //Event result = Calendar.API.CalendarApi.CreateEvent(CalendarId).Result; }
public Startup(IHostingEnvironment env) { var builder = new ConfigurationBuilder() .SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json", true, true) .AddEnvironmentVariables(); Configuration = builder.Build(); Log.Logger = new LoggerConfiguration() .ReadFrom.Configuration(Configuration) .CreateLogger(); }
public void CreateDefault_UseBundledOnly_True_LocatesOnlyStandAloneInstance() { var configBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder().AddInMemoryCollection(new Dictionary <string, string>() { ["useBundledOnly"] = "true" }); var loggerFactory = new LoggerFactory(); var locator = MSBuildLocator.CreateDefault(loggerFactory, new AssemblyLoader(loggerFactory), configBuilder.Build()); var instances = locator.GetInstances(); Assert.Single(instances); Assert.Equal(DiscoveryType.StandAlone, instances[0].DiscoveryType); }
public static void Main(string[] args) { var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddJsonFile("ocelot.json", true, false) .AddEnvironmentVariables() .AddCommandLine(args); if (args != null) { configurationBuilder.AddCommandLine(args); } var hostingconfig = configurationBuilder.Build(); var url = hostingconfig[addressKey] ?? defaultAddress; IWebHostBuilder builder = new WebHostBuilder(); builder.ConfigureServices(s => { s.AddSingleton(builder); }); builder.UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseConfiguration(hostingconfig) //.ConfigureAppConfiguration((hostingContext, config) => //{ // config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath); // var env = hostingContext.HostingEnvironment; // //config.AddOcelot(); // config.AddEnvironmentVariables(); //}) .ConfigureLogging((hostingContext, logging) => { logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging")); logging.AddConsole(); logging.AddDebug(); //add NLog to ASP.NET Core logging.AddNLog($"{hostingContext.HostingEnvironment.ContentRootPath}{ Path.DirectorySeparatorChar}nlog.config"); }) .UseIISIntegration() //.UseIIS() .UseMetricsWebTracking() .UseMetricsEndpoints() .UseNLog() .UseUrls(url) .UseStartup <Startup>(); var host = builder.Build(); host.Run(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Add framework services. services.AddMvc(); services.AddSingleton <HttpClient>(); var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder(); configurationBuilder.SetBasePath(_env.ContentRootPath); configurationBuilder.AddJsonFile("urls.json"); configurationBuilder.AddJsonFile("appsettings.json"); var config = configurationBuilder.Build(); var gameStateUrl = config.GetSection("urls")["GameStateApi"]; services.AddOptions(); services.Configure <DemoOptions>(config); services.Configure <GameDuration>(config); services.AddSingleton <IGameStateClient, NullGameClient>(); services.AddTransient <INewGameFactory, HardCodedGameFactory>(); services.AddTransient <INewRegionsFactory, HardCodedRegionsFactory>(); services.AddSignalR( o => { o.Hubs.EnableDetailedErrors = true; }); services.AddSingleton <ActorSystem>( x => { var system = ActorSystem.Create("BlockWars"); system.AddDependencyResolver(new ActorContainer(x, system)); return(system); }); services.AddSingleton <IServerManager, AkkaAdapter>(); services.AddTransient <AccomplishmentManager, AccomplishmentManager>(); services.AddTransient <GameActor, GameActor>(); services.AddSingleton <ServerSupervisor, ServerSupervisor>(); services.AddSingleton <Broadcaster, Broadcaster>(); services.AddTransient <DemoActor, DemoActor>(); services.AddTransient <GamePersistenceActor, GamePersistenceActor>(); services.AddTransient <PlayerStatsActor, PlayerStatsActor>(); services.AddSingleton <PlayerSupervisor, PlayerSupervisor>(); services.AddTransient <PlayerActor, PlayerActor>(); services.AddSingleton <LeaderboardActor, LeaderboardActor>(); services.AddSingleton <LeaderboardBuffer, LeaderboardBuffer>(); }
public static IServiceProvider GetConfiguredContextServiceProvider( TestCacheProvider cacheProvider, LogLevel logLevel, bool cacheAllQueries) { var services = new ServiceCollection(); services.AddOptions(); var basePath = Directory.GetCurrentDirectory(); Console.WriteLine($"Using `{basePath}` as the ContentRootPath"); var configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(basePath) .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) .Build(); services.AddSingleton(_ => configuration); var loggerProvider = new DebugLoggerProvider(); services.AddLogging(cfg => cfg.AddConsole().AddDebug().AddProvider(loggerProvider).SetMinimumLevel(logLevel)); services.AddEFSecondLevelCache(options => { switch (cacheProvider) { case TestCacheProvider.BuiltInInMemory: options.UseMemoryCacheProvider(); break; case TestCacheProvider.CacheManagerCoreInMemory: options.UseCacheManagerCoreProvider(); addCacheManagerCoreInMemory(services); break; case TestCacheProvider.CacheManagerCoreRedis: options.UseCacheManagerCoreProvider(); addCacheManagerCoreRedis(services); break; } if (cacheAllQueries) { options.CacheAllQueries(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(30)); } }); services.AddConfiguredMsSqlDbContext(GetConnectionString(basePath, configuration)); return(services.BuildServiceProvider()); }
/// <summary> /// Read configuration files and build application configuration /// </summary> /// <param name="envName"></param> /// <returns></returns> protected virtual IConfiguration BuildConfiguration(string envName) { IConfigurationBuilder builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(AppDomain.CurrentDomain.BaseDirectory) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); if (!String.IsNullOrEmpty(envName)) { string cfgName = $"appsettings.{envName}.json"; builder.AddJsonFile(cfgName, optional: true, reloadOnChange: true); } return(builder.Build()); }
public static string GetConnectionString() { string environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"); IConfigurationRoot configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json") .AddJsonFile($"appsettings.{environmentName}.json", true) .AddEnvironmentVariables().Build(); string connectionString = configuration.GetConnectionString("DefaultConnection"); return(connectionString); }
public Appsettings(string contentPath) { string Path = "appsettings.json"; //如果你把配置文件 是 根据环境变量来分开了,可以这样写 //Path = $"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json"; Configuration = new ConfigurationBuilder() .SetBasePath(contentPath) .Add(new JsonConfigurationSource { Path = Path, Optional = false, ReloadOnChange = true }) //这样的话,可以直接读目录里的json文件,而不是 bin 文件夹下的,所以不用修改复制属性 .Build(); }
public WebAppContext CreateDbContext(string[] args) { Microsoft.Extensions.Configuration.IConfigurationRoot configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json") .Build(); var builder = new DbContextOptionsBuilder <WebAppContext>(); var connectionString = configuration.GetConnectionString("DefaultConnection"); builder.UseSqlServer(connectionString); return(new WebAppContext(builder.Options)); }
public static IConfigurationRoot GetConfiguration() { var environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"); //Set configurations var di = Directory.GetCurrentDirectory(); var configBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(di) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: false) .AddJsonFile($"appsettings.{environmentName}.json", optional: true, reloadOnChange: false) .AddEnvironmentVariables(); var configuration = configBuilder.Build(); return(configuration); }