/// <summary>
/// Builds the configuration probing; will probe in the following order: 1) Command-line arguments, 2) Azure Key Vault (see https://docs.microsoft.com/en-us/aspnet/core/security/key-vault-configuration),
/// 3) User Secrets where hosting environment is development (see https://docs.microsoft.com/en-us/aspnet/core/security/app-secrets), 4) environment variable (see <paramref name="environmentVariablePrefix"/>),
/// 5) appsettings.{environment}.json, 6) appsettings.json, 7) webapisettings.{environment}.json (embedded resource), and 8) webapisettings.json (embedded resource).
/// </summary>
/// <typeparam name="TStartup">The API startup <see cref="Type"/>.</typeparam>
/// <param name="configurationBuilder">The <see cref="IConfigurationBuilder"/>.</param>
/// <param name="args">The command line args.</param>
/// <param name="hostingEnvironment">The <see cref="IWebHostEnvironment"/>.</param>
/// <param name="environmentVariablePrefix">The prefix that the environment variables must start with (will automatically add a trailing underscore where not supplied).</param>
public static void ConfigurationBuilder <TStartup>(IConfigurationBuilder configurationBuilder, string[] args, IWebHostEnvironment hostingEnvironment, string?environmentVariablePrefix = null) where TStartup : class
{
if (configurationBuilder == null)
{
throw new ArgumentNullException(nameof(configurationBuilder));
}
if (hostingEnvironment == null)
{
throw new ArgumentNullException(nameof(hostingEnvironment));
}
configurationBuilder.AddJsonFile(new EmbeddedFileProvider(typeof(TStartup).Assembly), $"webapisettings.json", true, false)
.AddJsonFile(new EmbeddedFileProvider(typeof(TStartup).Assembly), $"webapisettings.{hostingEnvironment.EnvironmentName}.json", true, false)
.AddJsonFile("appsettings.json", true, true)
.AddJsonFile($"appsettings.{hostingEnvironment.EnvironmentName}.json", true, true);
if (string.IsNullOrEmpty(environmentVariablePrefix))
{
configurationBuilder.AddEnvironmentVariables();
}
else
{
configurationBuilder.AddEnvironmentVariables(environmentVariablePrefix.EndsWith("_", StringComparison.InvariantCulture) ? environmentVariablePrefix : environmentVariablePrefix + "_");
}
configurationBuilder.AddCommandLine(args);
var config = configurationBuilder.Build();
if (hostingEnvironment.IsDevelopment() && config.GetValue <bool>("UseUserSecrets"))
{
configurationBuilder.AddUserSecrets <TStartup>();
}
var kvn = config["KeyVaultName"];
if (!string.IsNullOrEmpty(kvn))
{
var astp = new AzureServiceTokenProvider();
#pragma warning disable CA2000 // Dispose objects before losing scope; this object MUST NOT be disposed or will result in further error - only a single instance so is OK.
var kvc = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(astp.KeyVaultTokenCallback));
configurationBuilder.AddAzureKeyVault($"https://{kvn}.vault.azure.net/", kvc, new DefaultKeyVaultSecretManager());
#pragma warning restore CA2000
}
configurationBuilder.AddCommandLine(args);
}
private static void AddCommandArguments(this IConfigurationBuilder configuration, string[] args)
{
if (args != null)
{
configuration.AddCommandLine(args);
}
}
private static void ConfigureHost(IConfigurationBuilder builder, string[] args)
{
builder.SetBasePath(Directory.GetCurrentDirectory());
builder.AddJsonFile("hostsettings.json", optional: true);
builder.AddEnvironmentVariables(prefix: "");
builder.AddCommandLine(args);
}
public static void BuildConfiguration(IConfigurationBuilder config, IHostEnvironment env, string[] args)
{
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
if (env.IsDevelopment())
{
var appAssembly = Assembly.Load(new AssemblyName(env.ApplicationName));
if (appAssembly != null)
{
config.AddUserSecrets(appAssembly, optional: true);
}
}
else
{
var secretSettingsPath = $@"/run/secrets/identifier-generator/webapi";
config.AddJsonFile(secretSettingsPath, optional: true, reloadOnChange: true);
}
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
}
/// <summary>
/// Load the configuration settings for the program.
/// </summary>
/// <param name="config">the config</param>
/// <param name="basePath">the base path to look for application settings files</param>
/// <param name="args">programs arguments</param>
public static void LoadConfigurationSettings(IConfigurationBuilder config, string basePath, string[] args)
{
_logger.Information($"Program // Loading Configuration from basePath={basePath}");
config.SetBasePath(basePath);
string configJsonFile1 = $"{basePath}/altinn-appsettings/altinn-dbsettings-secret.json";
string configJsonFile2 = $"{basePath}/Receipt/appsettings.json";
if (basePath == "/")
{
configJsonFile2 = "/app/appsettings.json";
}
_logger.Information($"Loading configuration file: '{configJsonFile1}'");
config.AddJsonFile(configJsonFile1, optional: true, reloadOnChange: true);
_logger.Information($"Loading configuration file2: '{configJsonFile2}'");
config.AddJsonFile(configJsonFile2, optional: false, reloadOnChange: true);
config.AddEnvironmentVariables();
ConnectToKeyVaultAndSetApplicationInsights(config);
config.AddCommandLine(args);
}
/// <summary>
/// Configures the host itself
/// </summary>
/// <param name="configurationBuilder">The configuration builder</param>
private static void ConfigureHost(IConfigurationBuilder configurationBuilder)
{
configurationBuilder.SetBasePath(Directory.GetCurrentDirectory());
configurationBuilder.AddJsonFile("appsettings.json", optional: true);
configurationBuilder.AddEnvironmentVariables(prefix: "PREFIX_");
configurationBuilder.AddCommandLine(Array.Empty <string>());
}
public static IConfigurationBuilder InitialiseBellightConfigurations(
this IConfigurationBuilder configurationBuilder,
bool isDevelopment,
string environmentName = null,
string[] args = null)
{
configurationBuilder.AddJsonFile("appsettings.json", true, true);
if (!string.IsNullOrEmpty(environmentName))
{
configurationBuilder.AddJsonFile($"appsettings.{environmentName}.json", true, true);
}
if (isDevelopment)
{
var assembly = Assembly.GetEntryAssembly();
if (assembly != null)
{
configurationBuilder.AddUserSecrets(assembly, true);
}
}
configurationBuilder.AddEnvironmentVariables();
if (args == null)
{
return(configurationBuilder);
}
configurationBuilder.AddCommandLine(args);
return(configurationBuilder);
}
public static IConfigurationBuilder AddHostDefaults(
this IConfigurationBuilder configurationBuilder, string[] args = null)
{
_ = configurationBuilder ?? throw new ArgumentNullException(nameof(configurationBuilder));
var aspnetCoreEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")
?? Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT")
?? "Production";
configurationBuilder
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{aspnetCoreEnvironment}.json", optional: true, reloadOnChange: true);
if (aspnetCoreEnvironment == "Development")
{
var entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null)
{
configurationBuilder.AddUserSecrets(entryAssembly, optional: true);
}
}
configurationBuilder.AddEnvironmentVariables();
if (args != null)
{
configurationBuilder.AddCommandLine(args);
}
return(configurationBuilder);
}
/// <summary> Gets the configuration. </summary>
/// <param name="args">The arguments.</param>
/// <returns>Configuration object</returns>
private static IConfigurationRoot GetConfig(string[] args)
{
// The configurationbuilder is a fluid api that cascades it data like CSS. The last data wins.
IConfigurationBuilder configurationBuilder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
IConfigurationBuilder configurationBuilderWithEnviroment = configurationBuilder;
var environment = Environment.GetEnvironmentVariable("CONSOLEAPPCORE_ENVIRONMENT");
if (environment != null)
{
// The environment may be null in a unit test
configurationBuilderWithEnviroment.AddJsonFile($"appsettings.{environment}.json", optional: true);
}
// The AddEnvironmentVariables can't fail on it's argument
configurationBuilderWithEnviroment.AddEnvironmentVariables();
IConfigurationBuilder configurationBuilderWithCommandLine = configurationBuilderWithEnviroment;
if (args != null)
{
// The args may be null in a unit test
configurationBuilderWithCommandLine.AddCommandLine(args);
}
IConfigurationRoot config = configurationBuilderWithCommandLine.Build();
return(config);
}
public static IConfigurationBuilder BuildConfiguration(this IConfigurationBuilder builder, string[] args)
{
var environmentName = Environment.GetEnvironmentVariable("Hosting:Environment");
var pathToExe = Process.GetCurrentProcess().MainModule.FileName;
var pathToContentRoot = Path.GetDirectoryName(pathToExe);
builder
.SetBasePath(pathToContentRoot)
.AddJsonFile("appsettings.json", true)
.AddJsonFile("/settings/appsettings.json", true)
.AddJsonFile("/secrets/appsettings.json", true);
if (!string.IsNullOrWhiteSpace(environmentName))
{
builder.AddJsonFile($"appsettings.{environmentName}.json", true);
}
builder.AddEnvironmentVariables();
if (args != null && args.Any())
{
builder.AddCommandLine(args);
}
return(builder);
}
public static IConfigurationBuilder AddSystemCommandLineOptions(this IConfigurationBuilder builder, ParseResult results)
{
var args = results.OptionsCommandLineArgs();
builder.AddCommandLine(args);
return(builder);
}
public static void LoadConfigurationSettings(IConfigurationBuilder config, string basePath, string[] args)
{
config.SetBasePath(basePath);
config.AddJsonFile(basePath + "altinn-appsettings/altinn-dbsettings-secret.json", optional: true, reloadOnChange: true);
if (basePath == "/")
{
config.AddJsonFile(basePath + "app/appsettings.json", optional: false, reloadOnChange: true);
}
else
{
config.AddJsonFile(basePath + "/appsettings.json", optional: false, reloadOnChange: true);
}
config.AddEnvironmentVariables();
config.AddCommandLine(args);
IConfiguration stageOneConfig = config.Build();
string appId = stageOneConfig.GetValue <string>("kvSetting:ClientId:0");
string tenantId = stageOneConfig.GetValue <string>("kvSetting:TenantId:0");
string appKey = stageOneConfig.GetValue <string>("kvSetting:ClientSecret:0");
string keyVaultEndpoint = stageOneConfig.GetValue <string>("kvSetting:SecretUri:0");
if (!string.IsNullOrEmpty(appId) && !string.IsNullOrEmpty(tenantId) &&
!string.IsNullOrEmpty(appKey) && !string.IsNullOrEmpty(keyVaultEndpoint))
{
AzureServiceTokenProvider azureServiceTokenProvider = new AzureServiceTokenProvider($"RunAs=App;AppId={appId};TenantId={tenantId};AppKey={appKey}");
KeyVaultClient keyVaultClient = new KeyVaultClient(
new KeyVaultClient.AuthenticationCallback(
azureServiceTokenProvider.KeyVaultTokenCallback));
config.AddAzureKeyVault(
keyVaultEndpoint, keyVaultClient, new DefaultKeyVaultSecretManager());
}
}
public static IConfigurationBuilder AddArguments([NotNull] this IConfigurationBuilder thisValue, string[] args)
{
if (!args.IsNullOrEmpty())
{
thisValue.AddCommandLine(args);
}
return(thisValue);
}
private static void ConfigureApp(HostBuilderContext context, IConfigurationBuilder builder, string[] args)
{
var environmentName = context.HostingEnvironment.EnvironmentName;
builder.AddJsonFile("appsettings.json", optional: true);
builder.AddJsonFile($"appsettings.{environmentName}.json", optional: true);
builder.AddCommandLine(args);
}
/// <summary>
/// Builds the configuration probing; will probe in the following order: 1) Command-line arguments, 2) Azure Key Vault (see https://docs.microsoft.com/en-us/aspnet/core/security/key-vault-configuration),
/// 3) User Secrets where hosting environment is development (see https://docs.microsoft.com/en-us/aspnet/core/security/app-secrets), 4) environment variable (see <paramref name="environmentVariablePrefix"/>),
/// 5) appsettings.{environment}.json, 6) appsettings.json, 7) webapisettings.{environment}.json (embedded resource), and 8) webapisettings.json (embedded resource).
/// </summary>
/// <typeparam name="TStartup">The API startup <see cref="Type"/>.</typeparam>
/// <param name="configurationBuilder">The <see cref="IConfigurationBuilder"/>.</param>
/// <param name="args">The command line args.</param>
/// <param name="hostingEnvironment">The <see cref="IWebHostEnvironment"/>.</param>
/// <param name="environmentVariablePrefix">The prefix that the environment variables must start with (will automatically add a trailing underscore where not supplied).</param>
public static void ConfigurationBuilder <TStartup>(IConfigurationBuilder configurationBuilder, string[] args, IWebHostEnvironment hostingEnvironment, string?environmentVariablePrefix = null) where TStartup : class
{
if (configurationBuilder == null)
{
throw new ArgumentNullException(nameof(configurationBuilder));
}
if (hostingEnvironment == null)
{
throw new ArgumentNullException(nameof(hostingEnvironment));
}
configurationBuilder.AddJsonFile(new EmbeddedFileProvider(typeof(TStartup).Assembly), $"webapisettings.json", true, false)
.AddJsonFile(new EmbeddedFileProvider(typeof(TStartup).Assembly), $"webapisettings.{hostingEnvironment.EnvironmentName}.json", true, false)
.AddJsonFile("appsettings.json", true, true)
.AddJsonFile($"appsettings.{hostingEnvironment.EnvironmentName}.json", true, true);
if (string.IsNullOrEmpty(environmentVariablePrefix))
{
configurationBuilder.AddEnvironmentVariables();
}
else
{
configurationBuilder.AddEnvironmentVariables(environmentVariablePrefix.EndsWith("_", StringComparison.InvariantCulture) ? environmentVariablePrefix : environmentVariablePrefix + "_");
}
configurationBuilder.AddCommandLine(args);
var config = configurationBuilder.Build();
if (hostingEnvironment.IsDevelopment() && config.GetValue <bool>("UseUserSecrets"))
{
configurationBuilder.AddUserSecrets <TStartup>();
}
var kvn = config["KeyVaultName"];
if (!string.IsNullOrEmpty(kvn))
{
var secretClient = new SecretClient(new Uri($"https://{kvn}.vault.azure.net/"), new DefaultAzureCredential());
configurationBuilder.AddAzureKeyVault(secretClient, new KeyVaultSecretManager());
}
configurationBuilder.AddCommandLine(args);
}
private static void Configure(HostBuilderContext builderContext, IConfigurationBuilder configHost,
string[] args)
{
configHost.SetBasePath(Directory.GetCurrentDirectory());
configHost.AddEnvironmentVariables("ASPNETCORE_");
configHost.AddJsonFile("appsettings.json", true);
configHost.AddJsonFile($"appsettings.{builderContext.HostingEnvironment.EnvironmentName}.json", true);
configHost.AddCommandLine(args);
}
private static void ConfigureHostConfiguration(string[] args, IConfigurationBuilder hostConfigBuilder)
{
hostConfigBuilder.SetBasePath(Directory.GetCurrentDirectory());
hostConfigBuilder.AddJsonFile("hostsettings.json", false);
if (args != null && args.Length > 0)
{
hostConfigBuilder.AddCommandLine(args);
}
}
private static void AppConfig(HostBuilderContext ctx, IConfigurationBuilder builder, string[] args)
{
builder.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
var env = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
builder.AddJsonFile($"appsettings.{env}.json", optional: true);
builder.AddEnvironmentVariables();
builder.AddCommandLine(args);
}
private static void SetupConfiguration(IConfigurationBuilder builder, IHostingEnvironment hostingEnv)
{
builder.Sources.Clear();
builder.AddAppSettings(hostingEnv);
if (hostingEnv.IsDevelopment())
{
builder.AddCommandLine(Environment.GetCommandLineArgs());
}
}
private static void ConfigureApp(HostBuilderContext context, IConfigurationBuilder builder, string[] args)
{
builder.SetBasePath(Directory.GetCurrentDirectory());
builder.AddJsonFile("appsettings.json", optional: true);
builder.AddJsonFile(
$"appsettings.{context.HostingEnvironment.EnvironmentName}.json",
optional: true);
builder.AddEnvironmentVariables(prefix: "");
builder.AddCommandLine(args);
}
internal static void RegisterCommandLine(IConfigurationBuilder builder, string[] cmdLine)
{
if (cmdLine.Length > 0 &&
!cmdLine[0].StartsWith("--"))
{
cmdLine[0] = $"\"{cmdLine[0]}\"";
}
builder.AddCommandLine(cmdLine);
}
public static IConfigurationBuilder AddAppSettings(this IConfigurationBuilder configurationBuilder, HostBuilderContext hostBuilderContext, string[] args)
{
configurationBuilder.SetBasePath(Directory.GetCurrentDirectory());
configurationBuilder.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
configurationBuilder.AddJsonFile($"appsettings.{hostBuilderContext.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true);
configurationBuilder.AddEnvironmentVariables();
configurationBuilder.AddCommandLine(args);
return(configurationBuilder);
}
protected virtual void ConfigureHostConfiguration(IConfigurationBuilder config)
{
config.SetBasePath(Directory.GetCurrentDirectory());
config.AddJsonFile("hostsettings.json", true);
config.AddEnvironmentVariables(EnvironmentVariablePrefix);
if (this.args != null)
{
config.AddCommandLine(this.args);
}
}
public static void AddAppConfiguration(this IConfigurationBuilder builder, string environmentName, string[] args)
{
builder.Sources.Clear();
builder.AddJsonFile("appsettings.json", true, true);
builder.AddJsonFile($"appsettings.{environmentName}.json", true);
builder.AddEnvironmentVariables();
builder.AddCommandLine(args);
}
internal static IConfigurationBuilder AddVariables(this IConfigurationBuilder envBuilder)
{
try
{
envBuilder.AddEnvironmentVariables();
envBuilder.AddCommandLine();
}
catch (NotSupportedException)
{ }
return(envBuilder);
}
public static void AddCommandLine(this IConfigurationBuilder envBuilder)
{
var args = Environment.GetCommandLineArgs();
if (args != null && args.Length > 1)
{
String[] dest = new String[args.Length - 1];
Array.Copy(args, 1, dest, 0, dest.Length);
envBuilder.AddCommandLine(dest);
}
}
protected virtual void ConfigureAppConfiguration(string[] args, IConfigurationBuilder config)
{
config.AddEnvironmentVariables();
string configFile = GetConfigurationFileOrDefault(args);
config.AddJsonFile(configFile, optional: false, reloadOnChange: true);
if (args != null)
{
config.AddCommandLine(args);
}
}
private static void ConfigureApp(
HostBuilderContext hostContext,
IConfigurationBuilder configurationBuilder,
string[] args)
{
configurationBuilder.AddJsonFile("configuration/appsettings.json", optional: true);
configurationBuilder.AddJsonFile(
$"configuration/appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json",
optional: true);
configurationBuilder.AddCommandLine(args);
}
public void ConfigureConfiguration(HostBuilderContext hostContext, IConfigurationBuilder config, string[] args)
{
config.AddJsonFile("appsettings.json", true);
config.AddJsonFile("appsettings.private.json", true);
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
}
private static void ConfigureAppConfiguration(HostBuilderContext hostContext, IConfigurationBuilder config, string[] args)
{
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
config.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true);
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
}
