public void ConfigurationUpdatedWithFileReferences()
{
var healthReporterMock = new Mock <IHealthReporter>();
var configurationSource = new Dictionary <string, string>()
{
["alpha"] = "Alpha",
["bravo:charlie"] = "BravoCharlie",
["delta"] = "servicefabricfile:/ApplicationInsights.config"
};
IConfigurationRoot configuration = (new ConfigurationBuilder()).AddInMemoryCollection(configurationSource).Build();
ServiceFabricDiagnosticPipelineFactory.ApplyFabricConfigurationOverrides(configuration, @"C:\FabricCluster\work\Config\AppInstance00", healthReporterMock.Object);
healthReporterMock.Verify(o => o.ReportProblem(It.IsAny <string>(), It.IsAny <string>()), Times.Never());
healthReporterMock.Verify(o => o.ReportWarning(It.IsAny <string>(), It.IsAny <string>()), Times.Never());
string verificationError;
bool isOK = VerifyConfguration(configuration.AsEnumerable(), configurationSource, out verificationError);
Assert.False(isOK, verificationError);
configurationSource["delta"] = @"C:\FabricCluster\work\Config\AppInstance00\ApplicationInsights.config";
isOK = VerifyConfguration(configuration.AsEnumerable(), configurationSource, out verificationError);
Assert.True(isOK, verificationError);
}
public void ReferencedKeyCanContainComplexKey(string complexKey)
{
var healthReporterMock = new Mock <IHealthReporter>();
var configurationSource = new Dictionary <string, string>()
{
["alpha"] = "Alpha",
[$"bravo:{complexKey}"] = "Delta",
["delta"] = $"servicefabric:/bravo/{complexKey}"
};
IConfigurationRoot configuration = (new ConfigurationBuilder()).AddInMemoryCollection(configurationSource).Build();
ServiceFabricDiagnosticPipelineFactory.ApplyFabricConfigurationOverrides(configuration, "unused-configuration-package-path", healthReporterMock.Object);
healthReporterMock.Verify(o => o.ReportProblem(It.IsAny <string>(), It.IsAny <string>()), Times.Never());
healthReporterMock.Verify(o => o.ReportWarning(It.IsAny <string>(), It.IsAny <string>()), Times.Never());
string verificationError;
bool isOK = VerifyConfguration(configuration.AsEnumerable(), configurationSource, out verificationError);
Assert.False(isOK, verificationError);
configurationSource["delta"] = "Delta";
isOK = VerifyConfguration(configuration.AsEnumerable(), configurationSource, out verificationError);
Assert.True(isOK, verificationError);
}
private static string GetArg(IConfigurationRoot config, string key, string defaultValue = null)
{
if (!config.AsEnumerable().Any(a => a.Key == key))
{
return(defaultValue);
}
return(config.AsEnumerable().First(a => a.Key == key).Value);
}
static void Main(string[] args)
{
var builder = new ConfigurationBuilder();
builder.SetBasePath(Directory.GetCurrentDirectory())
.AddXmlFile("App.config", optional: true, reloadOnChange: true)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
builder.AddEnvironmentVariables();
Configuration = builder.Build();
var simple = new SimpleInjector.Container();
simple.AddOptions(Configuration);
foreach (var v in Configuration.AsEnumerable())
{
Console.WriteLine($"{v.Key} : {v.Value}");
}
var dbOptions = simple.GetInstance <IOptions <DatabaseSettings> >();
Console.WriteLine($"DB Name : {dbOptions.Value.Name}");
Console.ReadKey();
}
public Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appSettings.json", optional: false, reloadOnChange: true)
.AddJsonFile("appSettings." + env.EnvironmentName + ".json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables();
Configuration = builder.Build();
HostingEnvironment = env;
// Serilog
Serilog.Debugging.SelfLog.Enable(x => Debug.WriteLine(x));
var awsOptions = Configuration.GetAWSOptions();
// AWS clients
_s3Client = awsOptions.CreateServiceClient <IAmazonS3>();
_lambdaClient = awsOptions.CreateServiceClient <IAmazonLambda>();
_cloudWatchClient = awsOptions.CreateServiceClient <IAmazonCloudWatchLogs>();
_logger = new LoggerConfiguration()
.ReadFrom.Configuration(Configuration)
.WriteTo.AmazonCloudWatch(new CloudWatchSinkOptions {
LogGroupName = "markdown-webapi", Period = TimeSpan.FromSeconds(5)
}, _cloudWatchClient)
.CreateLogger();
_logger.Information("Server started: HostingEnvironment: {@HostingEvironment}", env);
_logger.Information("Server started: Environment: {@Environment}", Environment.GetEnvironmentVariables());
_logger.Information("Server started: Configuration: {@Configuration}", Configuration.AsEnumerable());
_settings = new WebApiSettings(Configuration);
_fileUploadSettings = new FileUploadSettings(Configuration);
}
public bool InitializeContext(IConfigurationRoot configuration)
{
string connectionString = configuration.GetConnectionString("LabManDbContext");
var configs = configuration.AsEnumerable();
bool useMySql = false;
foreach (KeyValuePair <string, string> config in configs)
{
if (config.Key.Equals("UseMySql") && config.Value.Equals("Yes"))
{
useMySql = true;
}
}
var optionsBuilder = new DbContextOptionsBuilder();
if (useMySql)
{
connectionString = configuration.GetConnectionString("LabManDbContextMysql");
optionsBuilder.UseMySQL(connectionString);
}
else
{
optionsBuilder.UseSqlServer(connectionString);
}
dbContext = new LabManDBContext(optionsBuilder.Options);
if (dbContext.Database.EnsureCreated())
{
InitTablesWithData();
dbContext.SaveChanges();
}
return(true);
}
private async Task OnExecuteAsync(CommandLineApplication app)
{
IConfigurationRoot configuration = DemoToRun switch
{
Demo.BuilderOnly => ConfigurationSamples.BuilderOnly(),
Demo.InMemory => ConfigurationSamples.InMemory(),
Demo.EnvironmentVariables => ConfigurationSamples.EnvironmentVariables(),
Demo.FileXml => ConfigurationSamples.FileXml(),
Demo.FileJson => ConfigurationSamples.FileJson(),
Demo.FileIni => ConfigurationSamples.FileIni(),
Demo.UserSecrets => ConfigurationSamples.UserSecrets(),
_ => throw new NotSupportedException()
};
await app.Out.WriteLineAsync($"Printing all configuration received from {DemoToRun}");
foreach (var item in configuration.AsEnumerable())
{
await app.Out.WriteLineAsync($"{item.Key}='{item.Value}'");
}
}
}
private static Dictionary <string, string> GetDatabases()
{
var prefix = "ConnectionStrings:Database-";
var connectionStrings = _config.AsEnumerable()
.Where(o => o.Key.StartsWith(prefix))
.ToDictionary(o => o.Key, o => o.Value);
var databases = new Dictionary <string, string>();
foreach (var item in connectionStrings)
{
var regex = new Regex($"{prefix}(.*)");
var match = regex.Match(item.Key);
if (match.Success)
{
var planName = match.Groups[1].Value;
var connectionString = item.Value;
databases.Add(planName, connectionString);
}
}
return(databases);
}
// check that important parts of configuration are existing
private static Dictionary <string, string> CheckConfig(IConfigurationRoot config)
{
var result = new Dictionary <string, string>();
List <string> requiredConfigValues = new List <string>()
{
"EventHub:ConnectionString",
"EventHub:Name",
"EventHub:ConsumerGroup",
"Storage:ConnectionString",
"Storage:Container",
"InfluxDb:Measurement:Name",
"InfluxDb:Measurement:Timestamp",
"InfluxDb:Measurement:Fields:0"
};
var lookup = config.AsEnumerable().ToDictionary((i) => { return(i.Key); });
foreach (var item in requiredConfigValues)
{
if (!lookup.ContainsKey(item))
{
result.Add(item, "is missing!");
}
else if (lookup[item].Value == null || lookup[item].Value == "")
{
result.Add(item, "has no value defined!");
}
}
return(result);
}
public Dictionary <string, string> ReadConfigurationFile()
{
if (LotterySetting == null || LotterySetting.Count == 0)
{
LotterySetting = new Dictionary <string, string>();
IConfigurationBuilder builder = new ConfigurationBuilder();
//load Json file, the web.config and appSetting are no longer supported in .Net Core
builder.AddJsonFile("AppSettings.json");
IConfigurationRoot configuration = builder.Build();
var version = configuration["Version"];
var parms = configuration.AsEnumerable();
foreach (var v in parms)
{
if (v.Key.StartsWith("AppSettings:LotteryParameters:"))
{
LotterySetting.Add(v.Key.Replace("AppSettings:LotteryParameters:", string.Empty), v.Value);
}
}
}
return(LotterySetting);
}
public override void Load()
{
var dbConfigs = new DbConfigs()
{
Encrypt = defaultValue.GetValue <bool>("DbConfigs:Encrypt"),
Type = defaultValue.GetValue <string>("DbConfigs:Type"),
ConnectionString = defaultValue.GetValue <string>("DbConfigs:ConnectionString")
};
using (var db = new CompanyDbContext(dbConfigs))
{
db.Database.EnsureCreated();
//检查默认配置
var enumerable = defaultValue.AsEnumerable();
foreach (var value in enumerable)
{
if (value.Value != null)
{
var config = db.Config.FirstOrDefault(a => a.Name == value.Key);
if (config == null)
{
config = new Config {
Name = value.Key, Value = value.Value
};
db.Config.Add(config);
}
db.SaveChanges();
}
}
Data = db.Config.ToDictionary(c => c.Name, c => c.Value);
}
}
public Config GetAkkaHocon()
{
var cfg = _config.AsEnumerable();
var dict = cfg.ToDictionary(x => x.Key.Replace(":", "."), x => x.Value?.Trim());
return(ConfigurationFactory.FromObject(dict));
}
/// <summary>
/// Copies all of the values from the supplied <see cref="IConfigurationRoot"/> to function configuration
/// environment variables.
/// </summary>
/// <param name="testContext">The context to add the configuration to.</param>
/// <param name="configuration">The configuration to copy.</param>
public static void CopyToFunctionConfigurationEnvironmentVariables(this SpecFlowContext testContext, IConfigurationRoot configuration)
{
FunctionConfiguration config = testContext.GetFunctionConfiguration();
foreach (KeyValuePair <string, string> item in configuration.AsEnumerable())
{
config.EnvironmentVariables.Add(item.Key, item.Value);
}
}
static void Main(string[] args)
{
var env = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var confbuilder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env}.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables("EH2TI_")
.AddCommandLine(args);
config = confbuilder.Build();
var configCheck = CheckConfig(config);
if (configCheck.Count > 0)
{
Console.WriteLine("Errors while loading configuration:");
foreach (var item in configCheck)
{
Console.WriteLine($"'{item.Key}' - {item.Value}");
}
Console.WriteLine("Exiting.");
Console.ReadLine();
return;
}
if (args.ToList().Contains("--dumpconfig"))
{
// dump config:
Console.WriteLine("Configuration:");
foreach (var item in config.AsEnumerable())
{
Console.WriteLine($"{item.Key} = {item.Value}");
}
}
AssemblyLoadContext.Default.Unloading += ctx =>
{
startwait.Set();
System.Console.WriteLine("Waiting for main thread shutdown");
ended.Wait(9000);
};
Console.CancelKeyPress += (object sender, ConsoleCancelEventArgs e) =>
{
// start waiting app end
startwait.Set();
e.Cancel = true;
};
var program = new Program();
Task.Run(async() => await program.RunServerAsync(args));
//RunServerAsync(args).Wait();
ended.Wait();
}
/// <summary>
/// This Method is use to read the data from appsetting.json file.
/// We are using that file to store messages and configuration setting.
/// </summary>
/// <param name="tagName">tag name are the root value of the json which contains the keys,Like ResponseCode,StatusCode,Messages,AppSettings</param>
/// <param name="key">Provide the key name to read the value from appsetting.json</param>
/// <returns>Method will return the value according to the key</returns>
public string GetMessageFromConfiguration(string tagName, string key)
{
var builder = new ConfigurationBuilder().SetBasePath(System.IO.Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json"); Configuration = builder.Build();
var SettingsEnumerable = Configuration.AsEnumerable();
List <KeyValuePair <string, string> > listOfSettings = SettingsEnumerable.ToList();
string value = (from c in listOfSettings.Where(x => x.Key == tagName + ":" + key) select c.Value).FirstOrDefault();
return(value);
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
{
app.Run(async context =>
{
foreach (var e in _config.AsEnumerable())
{
await context.Response.WriteAsync($"{e.Key} = {e.Value}\n");
}
});
}
public static void IncludeEnvironmentVariables(this IConfigurationRoot config)
{
config.AsEnumerable().ToList().ForEach(item =>
{
if (!string.IsNullOrEmpty(item.Key) && !string.IsNullOrEmpty(item.Value))
{
Environment.SetEnvironmentVariable(item.Key, item.Value);
}
});
}
public void Configure(IApplicationBuilder app)
{
app.Run(async context =>
{
foreach (var e in _config.AsEnumerable())
{
await context.Response.WriteAsync($"{e.Key} = {e.Value}\n");
}
});
}
public void Configure(IApplicationBuilder app)
{
app.Run(async(context) =>
{
foreach (var c in _config.AsEnumerable())
{
await context.Response.WriteAsync($"{c.Key} = {_config[c.Key]}\n");
}
});
}
public void CopyExternalTokens()
{
_webConfigWriter.InitializeWebConfigForTokenReplacements();
foreach (var configEntry in _config.AsEnumerable())
{
_webConfigWriter.ReplaceToken(configEntry.Key, configEntry.Value);
}
_webConfigWriter.FinalizeWebConfigTokenReplacements();
}
public void FlushEnvironmentVariables()
{
if (IsTraceConfigEnabled())
{
_logger.WriteLog($"-----> TRACE: Flushing out configurations...");
foreach (var config in _configuration.AsEnumerable())
{
_logger.WriteLog($"-----> TRACE: KEY=> {config.Key}, VALUE=> {config.Value}");
}
}
}
private void InjectSecrets()
{
var configValues = _configuration.AsEnumerable();
foreach (KeyValuePair <string, string> configPair in configValues)
{
if (configPair.Value != null)
{
_configuration[configPair.Key] = _secretInjector.Value.InjectAsync(configPair.Value).Result;
}
}
}
public async Task InjectSecrets()
{
var configValues = _configuration.AsEnumerable();
foreach (KeyValuePair <string, string> configPair in configValues)
{
if (configPair.Value != null)
{
_configuration[configPair.Key] = await _secretInjector.Value.InjectAsync(configPair.Value);
}
}
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
{
app.Run(async context =>
{
foreach (var c in _config.AsEnumerable())
{
await context.Response.WriteAsync($"{c.Key} = {c.Value}\n");
}
await context.Response.WriteAsync($"\nDatabase Port = {_config["database:port"]}");
});
}
public static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddLegacyXmlConfiguration("web.config");
Configuration = builder.Build();
foreach (var item in Configuration.AsEnumerable())
{
Console.WriteLine($"Key: {item.Key}, Value: {item.Value}");
}
Console.ReadKey();
}
public override IEnumerable <KeyValuePair <string, string> > GetSettings()
{
try
{
return(_configurationRoot.AsEnumerable()
.Where(pair => !string.IsNullOrEmpty(pair.Value))
.ToList());
}
catch (Exception ex)
{
_logger.LogError(ex, $"Failed to get configuration settings. {ex.Message}");
return(Enumerable.Empty <KeyValuePair <string, string> >());
}
}
public AppSettings(IConfigurationRoot config)
{
foreach (var kvp in config.AsEnumerable())
{
switch (kvp.Key)
{
case "cluster": ClusterUrl = kvp.Value; break;
case "version": Version = kvp.Value; break;
}
}
Current = this;
}
public static ShellSettings ParseSettings(IConfigurationRoot configuration)
{
var shellSettings = new ShellSettings();
foreach (var setting in configuration.AsEnumerable().ToDictionary(k => k.Key, v => v.Value))
{
shellSettings[setting.Key] = setting.Value;
}
TenantState state;
shellSettings.State = Enum.TryParse(configuration["State"], true, out state) ? state : TenantState.Uninitialized;
return(shellSettings);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.Run(async(context) =>
{
foreach (var c in _config.AsEnumerable())
{
await context.Response.WriteAsync($"{c.Key} {c.Value}\n");
}
});
}
public virtual PropertySourceDescriptor GetPropertySourceDescriptor(IConfigurationProvider provider, IConfigurationRoot root)
{
Dictionary <string, PropertyValueDescriptor> properties = new Dictionary <string, PropertyValueDescriptor>();
var sourceName = GetPropertySourceName(provider);
foreach (var kvp in root.AsEnumerable())
{
if (provider.TryGet(kvp.Key, out string provValue))
{
properties.Add(kvp.Key, new PropertyValueDescriptor(kvp.Value));
}
}
return(new PropertySourceDescriptor(sourceName, properties));
}