/// <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 Main(string[] args)
{
Log("started with args: "+String.Join(" ", args));
var configBuilder = new ConfigurationBuilder();
configBuilder.AddJsonFile("appsettings.json");
Configuration = configBuilder.Build();
if (args.Contains("--windows-service"))
{
try
{
Log("WWWService Main()");
Run(this);
return;
}
catch(Exception x)
{
Log("WWWService Main() Exception: "+ x.Message);
}
}
OnStart(null);
Console.ReadLine();
OnStop();
}
static HalibutLimits()
{
#if NET40
var settings = System.Configuration.ConfigurationManager.AppSettings;
var fields = typeof (HalibutLimits).GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
foreach (var field in fields)
{
var value = settings.Get("Halibut." + field.Name);
if (string.IsNullOrWhiteSpace(value)) continue;
var time = TimeSpan.Parse(value);
field.SetValue(null, time);
}
#else
// should be able to use Directory.GetCurrentDirectory()
// to get the working path, but the nunit test runner
// runs from another directory. Go with dll location for now.
var directory = Path.GetDirectoryName(new Uri(typeof(HalibutLimits).GetTypeInfo().Assembly.CodeBase).LocalPath);
var builder = new ConfigurationBuilder();
builder.SetBasePath(directory);
builder.AddJsonFile("appsettings.json", optional: true);
var halibutConfig = builder.Build();
var fields = typeof(HalibutLimits).GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
foreach (var field in fields)
{
var value = halibutConfig["Halibut:" + field.Name];
if (string.IsNullOrWhiteSpace(value)) continue;
var time = TimeSpan.Parse(value);
field.SetValue(null, time);
}
#endif
}
//<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;
}
}
}
/// <summary>
/// 1. Loads configurations
/// </summary>
public Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder();
// general config file
builder.AddJsonFile("config.json");
// environment-specific config
builder.AddJsonFile($"config.{env.EnvironmentName}.json", optional: true);
// sensitive information config
if (env.IsDevelopment()) builder.AddUserSecrets();
Configuration = builder.Build();
}
public Functional()
{
var builder = new ConfigurationBuilder();
builder.AddJsonFile("config.json");
builder.AddJsonFile("config.private.json", true);
var configuration = builder.Build();
var uri = new Uri(configuration["ServerCredentialUri"]);
var username = configuration["ServerCredentialUsername"];
var password = configuration["ServerCredentialPassword"];
_serverCredential = new ServerCredential(uri, username, password);
}
// 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 Startup(IHostingEnvironment env)
{
// Setup configuration sources.
var builder = new ConfigurationBuilder().SetBasePath(env.ContentRootPath);
if (env.IsDevelopment())
{
builder.AddJsonFile("config.json",true,true);
}
else
{
builder.AddJsonFile("/etc/bahamut/website.json",true,true);
}
builder.AddEnvironmentVariables();
Configuration = builder.Build();
}
public static IConfiguration BuildLightcoreConfiguration(this IApplicationEnvironment appEnv, IHostingEnvironment env)
{
var builder = new ConfigurationBuilder().SetBasePath(appEnv.ApplicationBasePath);
// Add main config file
builder.AddJsonFile("lightcore.json");
// Add optional environment specific config file, will be merged and duplicates takes precedence
builder.AddJsonFile($"lightcore.{env.EnvironmentName}.json", true);
// Add environment variables, will be merged and duplicates takes precedence - Set LightcoreConfig:ServerUrl in Azure for example...
builder.AddEnvironmentVariables();
return builder.Build();
}
public ConfigurationResult Build(Action <IConfigurationBuilder> additionalSetup = null)
{
try
{
var configBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
.SetBasePath(AppContext.BaseDirectory)
.AddEnvironmentVariables("OMNISHARP_");
if (_environment.AdditionalArguments?.Length > 0)
{
configBuilder.AddCommandLine(_environment.AdditionalArguments);
}
// Use the global omnisharp config if there's any in the shared path
configBuilder.CreateAndAddGlobalOptionsFile(_environment);
// Use the local omnisharp config if there's any in the root path
configBuilder.AddJsonFile(
new PhysicalFileProvider(_environment.TargetDirectory).WrapForPolling(),
Constants.OptionsFile,
optional: true,
reloadOnChange: true);
// bootstrap additional host configuration at the end
additionalSetup?.Invoke(configBuilder);
var config = configBuilder.Build();
return(new ConfigurationResult(config));
}
catch (Exception ex)
{
return(new ConfigurationResult(ex));
}
}
public void SpringCloudConfigServer_ReturnsExpectedDefaultData()
{
// Arrange
var appsettings = @"
{
'spring': {
'application': {
'name' : 'foo'
},
'cloud': {
'config': {
'uri': 'http://localhost:8888',
'env': 'development'
}
}
}
}";
var path = ConfigServerTestHelpers.CreateTempFile(appsettings);
var configurationBuilder = new ConfigurationBuilder();
var hostingEnv = new HostingEnvironment();
configurationBuilder.AddJsonFile(path);
// Act and Assert (expects Spring Cloud Config server to be running)
configurationBuilder.AddConfigServer(hostingEnv);
IConfigurationRoot root = configurationBuilder.Build();
Assert.Equal("spam", root["bar"]);
Assert.Equal("bar", root["foo"]);
Assert.Equal("Spring Cloud Samples", root["info:description"]);
Assert.Equal("https://github.com/spring-cloud-samples", root["info:url"]);
Assert.Equal("http://localhost:8761/eureka/", root["eureka:client:serviceUrl:defaultZone"]);
}
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);
}
}
public Startup()
{
var cb = new ConfigurationBuilder();
cb.AddJsonFile("appSettings.json");
_configuration = cb.Build();
}
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;
}
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;
}
public IConfiguration Build()
{
Validate();
IConfigurationBuilder builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder();
builder.AddJsonFile(Path.Combine(_filePath, _fileName));
return(builder.Build());
}
public static void CreateOrderProcessTask([Queue("orders")] CloudQueue orderQueue)
{
Console.WriteLine("Starting Create Order Process Task");
try
{
var builder = new ConfigurationBuilder();
//builder.Add(new JsonConfigurationSource("config.json"));
builder.AddJsonFile("config.json");
var config = builder.Build();
var connectionString = config["Data:DefaultConnection:ConnectionString"];
using (var context = new PartsUnlimitedContext(connectionString))
{
var orders = context.Orders.Where(x => !x.Processed).ToList();
Console.WriteLine("Found {0} orders to process", orders.Count);
foreach (var order in orders)
{
var productIds = context.OrderDetails.Where(x => x.OrderId == order.OrderId).Select(x => x.ProductId).ToList();
var items = context.Products
.Where(x => productIds.Contains(x.ProductId))
.ToList();
var orderItems = items.Select(
x => new LegacyOrderItem
{
SkuNumber = x.SkuNumber,
Price = x.Price
}).ToList();
var queueOrder = new LegacyOrder
{
Address = order.Address,
Country = order.Country,
City = order.City,
Phone = order.Phone,
CustomerName = order.Name,
OrderDate = order.OrderDate,
PostalCode = order.PostalCode,
State = order.State,
TotalCost = order.Total,
Discount = order.Total,
Items = orderItems
};
var settings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() };
var message = JsonConvert.SerializeObject(queueOrder, settings);
orderQueue.AddMessage(new CloudQueueMessage(message));
order.Processed = true;
}
context.SaveChanges();
Console.WriteLine("Orders successfully processed.");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private static IConfiguration ConfigureConfiguration(IHostingEnvironment hostingEnvironment)
{
IConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.SetBasePath(hostingEnvironment.ContentRootPath);
configurationBuilder.AddJsonFile("config.json", optional: true);
configurationBuilder.AddEnvironmentVariables();
return configurationBuilder.Build();
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=398940
public Startup()
{
var builder = new ConfigurationBuilder();
builder
.AddJsonFile("config.json")
.AddEnvironmentVariables();
Configuration = builder.Build();
}
public RecaptchaTagHelper() : base()
{
var builder = new ConfigurationBuilder();
builder.AddJsonFile("appsettings.json");
builder.AddEnvironmentVariables();
var config = builder.Build();
secret = config["RecaptchaOptions:Secret"];
siteKey = config["RecaptchaOptions:SiteKey"];
}
public Startup(IApplicationEnvironment appEnv, IHostingEnvironment env)
{
var Builder = new ConfigurationBuilder()
.SetBasePath(appEnv.ApplicationBasePath);
if (env.IsDevelopment())
{
Builder.AddJsonFile("config.json")
.AddEnvironmentVariables();
}
else
{
Builder.AddJsonFile("config-prod.json")
.AddEnvironmentVariables();
}
Configuration = Builder.Build();
}
public Startup(IHostingEnvironment env, IApplicationEnvironment app)
{
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.SetBasePath(app.ApplicationBasePath);
builder.AddJsonFile("appsettings.json");
IConfigurationRoot config = builder.Build();
AppSettings.ConnectionString = config.Get<string>
("Data:DefaultConnection:ConnectionString");
}
private IConfiguration GetConfiguration()
{
var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder();
string directoryName = Path.GetDirectoryName(typeof(ConfigurationDriver).Assembly.Location);
configurationBuilder.AddJsonFile(Path.Combine(directoryName, @"test-appsettings.json"));
return(configurationBuilder.Build());
}
private static IConfigurationRoot GetConfigurationRoot()
{
var builder = new ConfigurationBuilder();
var testFolder = new DirectoryInfo(Directory.GetCurrentDirectory()).FullName;
builder.SetBasePath(testFolder);
//use json file to configure settings. See http://docs.asp.net/en/latest/fundamentals/configuration.html for more detail on CongifurationBuilder
builder.AddJsonFile("appsettings.json");
var config = builder.Build();
return config;
}
private static void BuildByJson()
{
var config = new ConfigurationBuilder();
config.AddJsonFile("autofac.json");//need Microsoft.Extensions.Configuration.Json
var module = new ConfigurationModule(config.Build());
var builder = new ContainerBuilder();
builder.RegisterModule(module);
container = 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 });
}
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, IApplicationEnvironment appEnv)
{
var builder = new ConfigurationBuilder()
.AddJsonFile("appsettings.json");
// 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);
Configuration = builder.Build();
}
/// <summary>
/// get IConfigurationRoot from rpclite.config.json
/// </summary>
/// <param name="basePath"></param>
/// <returns></returns>
public static IConfigurationRoot GetConfiguration(string basePath)
{
var configBuilder = new ConfigurationBuilder();
if (!string.IsNullOrWhiteSpace(basePath))
configBuilder.SetBasePath(basePath);
configBuilder
.AddJsonFile("rpclite.config.json", true);
var config = configBuilder.Build();
return config;
}
public void NonDefaultSectionTest()
{
var builder = new ConfigurationBuilder();
builder.AddJsonFile("./TestFiles/NonDefaultSectionTest.json");
IConfiguration config = builder.Build();
var options = config.GetAWSOptions("AWSNonStandard");
Assert.Equal(RegionEndpoint.EUCentral1, options.Region);
IAmazonS3 client = options.CreateServiceClient<IAmazonS3>();
Assert.NotNull(client);
Assert.Equal(RegionEndpoint.EUCentral1, client.Config.RegionEndpoint);
}
public BotCredentials()
{
_log = LogManager.GetCurrentClassLogger();
try { File.WriteAllText("./credentials_example.json", JsonConvert.SerializeObject(new CredentialsModel(), Formatting.Indented)); } catch { }
if(!File.Exists(credsFileName))
_log.Warn($"credentials.json is missing. Attempting to load creds from environment variables prefixed with 'NadekoBot_'. Example is in {Path.GetFullPath("./credentials_example.json")}");
try
{
var configBuilder = new ConfigurationBuilder();
configBuilder.AddJsonFile(credsFileName, true)
.AddEnvironmentVariables("NadekoBot_");
var data = configBuilder.Build();
Token = data[nameof(Token)];
if (string.IsNullOrWhiteSpace(Token))
throw new ArgumentNullException(nameof(Token), "Token is missing from credentials.json or Environment varibles.");
OwnerIds = data.GetSection("OwnerIds").GetChildren().Select(c => ulong.Parse(c.Value)).ToArray();
LoLApiKey = data[nameof(LoLApiKey)];
GoogleApiKey = data[nameof(GoogleApiKey)];
MashapeKey = data[nameof(MashapeKey)];
OsuApiKey = data[nameof(OsuApiKey)];
int ts = 1;
int.TryParse(data[nameof(TotalShards)], out ts);
TotalShards = ts < 1 ? 1 : ts;
ulong clId = 0;
ulong.TryParse(data[nameof(ClientId)], out clId);
ClientId = clId;
SoundCloudClientId = data[nameof(SoundCloudClientId)];
CarbonKey = data[nameof(CarbonKey)];
var dbSection = data.GetSection("db");
Db = new DBConfig(string.IsNullOrWhiteSpace(dbSection["Type"])
? "sqlite"
: dbSection["Type"],
string.IsNullOrWhiteSpace(dbSection["ConnectionString"])
? "Filename=./data/NadekoBot.db"
: dbSection["ConnectionString"]);
}
catch (Exception ex)
{
_log.Fatal(ex.Message);
_log.Fatal(ex);
throw;
}
}
/// <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 Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
builder.AddJsonFile("appsettings.windows.json");
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
builder.AddJsonFile("appsettings.linux.json");
}
else
{
throw new NotSupportedException("MapGuide doesn't work on this platform");
}
// Set up configuration sources.
builder.AddEnvironmentVariables();
Configuration = builder.Build();
string mgWebConfigPath = Configuration["MapGuide.WebConfigPath"];
MapGuideApi.MgInitializeWebTier(mgWebConfigPath);
}
public void ConfigureServices(IServiceCollection services)
{
var configBuilder = new ConfigurationBuilder();
configBuilder.AddJsonFile("config.json");
configBuilder.AddEnvironmentVariables();
this.Configuration = configBuilder.Build();
services.AddOptions();
services.Configure<DotkubeOptions>(this.Configuration);
services.AddTransient<IDatabase>((IServiceCollection) => configureRedis());
services.AddDbContext<DataContext>(options => configureDatabase(options));
services.AddMvcCore().AddJsonFormatters();
services.AddCors();
}
public static void Main(string[] args)
{
var builder = new ConfigurationBuilder();
builder.AddJsonFile("appsettings.json");
builder.AddEnvironmentVariables();
var config = builder.Build();
builder.AddEntityFramework(options => options.UseSqlServer(config["Data:DefaultConnection:ConnectionString"]));
config = builder.Build();
Console.WriteLine("key1={0}", config["key1"]);
Console.WriteLine("key2={0}", config["key2"]);
Console.WriteLine("key3={0}", config["key3"]);
}
private void RegisterPublisher(IServiceCollection services)
{
var configurationBuilder = new ConfigurationBuilder();
var path = Path.Combine(configurationBuilder.GetBasePath(), "glimpse.json");
if (File.Exists(path))
{
var configuration = configurationBuilder.AddJsonFile("glimpse.json").Build();
services.Configure<ResourceOptions>(configuration.GetSection("resources"));
services.Replace(new ServiceDescriptor(typeof(IMessagePublisher), typeof(HttpMessagePublisher), ServiceLifetime.Transient));
}
// TODO: If I reach this line, than Glimpse has no way to send data from point A to B. Should we blow up?
}
private IConfiguration SetupConfiguration()
{
var existingConfiguration = Builder.Services.First(z => z.ServiceType == typeof(IConfiguration))
.ImplementationInstance as IConfiguration;
var configurationBuilder = new MsftConfigurationBinder();
configurationBuilder.AddConfiguration(existingConfiguration);
configurationBuilder
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddYamlFile("appsettings.yml", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{_environment.EnvironmentName}.json", optional: true, reloadOnChange: true)
.AddYamlFile($"appsettings.{_environment.EnvironmentName}.yml", optional: true, reloadOnChange: true);
var cb = new ConfigurationBuilder(
Scanner,
_environment,
existingConfiguration,
configurationBuilder,
_logger,
Properties);
cb.Build();
if (_environment.IsDevelopment() && !string.IsNullOrEmpty(_environment.ApplicationName))
{
var appAssembly = Assembly.Load(new AssemblyName(_environment.ApplicationName));
if (appAssembly != null)
{
configurationBuilder.AddUserSecrets(appAssembly, optional: true);
}
}
configurationBuilder.AddEnvironmentVariables();
var newConfig = configurationBuilder.Build();
Builder.Services.Replace(ServiceDescriptor.Singleton <IConfiguration>(newConfig));
return(newConfig);
}
public Startup(IConfiguration configuration)
{
// Configuration = configuration;
var builder = new ConfigurationBuilder().AddConfiguration(configuration);
/* Add Default configurations */
builder.AddConfiguration(configuration);
/* Add Custom configurations */
// adding cache.json which contains cachemanager configuration(s)
var appOptions = configuration.GetSection(nameof(AppOptions)).Get <AppOptions>();
if (true || appOptions.Cache)
{
builder.AddJsonFile("cache.json");
}
Configuration = builder.Build();
/*
* // For manual for like console app.
* var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder().AddJsonFile("cache.json");
* Configuration = builder.Build();
*
* // var cacheConfiguration = Configuration.GetCacheConfiguration();
* var cacheConfiguration =
* Configuration.GetCacheConfiguration("retaileasy_cache")
* .Builder
* .WithMicrosoftLogging(f =>
* {
* f.AddSerilog();
* // f.AddDebug(LogLevel.Information);
* })
* .Build();
*/
SetupLogging(Configuration);
}
public IConfigurationRoot Build()
{
var configBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
.SetBasePath(AppContext.BaseDirectory)
.AddEnvironmentVariables("OMNISHARP_");
if (_environment.AdditionalArguments?.Length > 0)
{
configBuilder.AddCommandLine(_environment.AdditionalArguments);
}
// Use the global omnisharp config if there's any in the shared path
configBuilder.CreateAndAddGlobalOptionsFile(_environment);
// Use the local omnisharp config if there's any in the root path
configBuilder.AddJsonFile(
new PhysicalFileProvider(_environment.TargetDirectory).WrapForPolling(),
Constants.OptionsFile,
optional: true,
reloadOnChange: true);
return(configBuilder.Build());
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
var builder = new ConfigurationBuilder()
.SetBasePath(appEnv.ApplicationBasePath);
if (env.IsDevelopment())
{
builder.AddJsonFile("appsettings.json").AddJsonFile("privatesettings.json");
}
builder.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);
builder.AddUserSecrets();
builder.AddEnvironmentVariables();
this.Configuration = builder.Build();
}
