Joseph Doherty
86 lines
3.8 KiB
C#
86 lines
3.8 KiB
C#
using Microsoft.Extensions.Configuration;
|
|
using ZB.MOM.WW.Secrets.MasterKey;
|
|
using ZB.MOM.WW.Secrets.Replicator.SqlServer;
|
|
|
|
namespace ZB.MOM.WW.Secrets.Cli.Interactive;
|
|
|
|
/// <summary>
|
|
/// Composes a deployment target's Secrets configuration the same way the target app would at
|
|
/// startup — base <c>appsettings.json</c>, optional per-environment overlay, and environment
|
|
/// variables — so the interactive console operates on exactly the store the app reads.
|
|
/// </summary>
|
|
public sealed class TargetConfigReader
|
|
{
|
|
/// <summary>
|
|
/// Loads the target app's config exactly the way the app would (base json + optional environment
|
|
/// overlay + environment variables) and binds the Secrets options out of it.
|
|
/// </summary>
|
|
/// <param name="appSettingsPath">Absolute or relative path to the target app's base <c>appsettings.json</c>.</param>
|
|
/// <param name="environment">
|
|
/// Optional ASP.NET environment name; when non-empty an <c>appsettings.{environment}.json</c>
|
|
/// overlay is layered on top of the base file (optional — absent overlays are ignored).
|
|
/// </param>
|
|
/// <param name="sectionPath">The configuration section the Secrets options bind from. Defaults to <c>Secrets</c>.</param>
|
|
/// <returns>The resolved <see cref="StoreTarget"/>, with the SQLite path made absolute against the app directory.</returns>
|
|
/// <exception cref="FileNotFoundException">The base <paramref name="appSettingsPath"/> does not exist.</exception>
|
|
public StoreTarget Read(string appSettingsPath, string? environment = null, string sectionPath = "Secrets")
|
|
{
|
|
string fullPath = Path.GetFullPath(appSettingsPath);
|
|
if (!File.Exists(fullPath))
|
|
{
|
|
throw new FileNotFoundException(
|
|
$"Target appsettings file not found: {fullPath}", fullPath);
|
|
}
|
|
|
|
string dir = Path.GetDirectoryName(fullPath)!;
|
|
string fileName = Path.GetFileName(fullPath);
|
|
|
|
ConfigurationBuilder builder = new();
|
|
builder.SetBasePath(dir)
|
|
.AddJsonFile(fileName, optional: false);
|
|
|
|
if (!string.IsNullOrEmpty(environment))
|
|
{
|
|
builder.AddJsonFile($"appsettings.{environment}.json", optional: true);
|
|
}
|
|
|
|
builder.AddEnvironmentVariables();
|
|
|
|
IConfigurationRoot config = builder.Build();
|
|
|
|
SecretsOptions secrets = config.GetSection(sectionPath).Get<SecretsOptions>() ?? new SecretsOptions();
|
|
secrets.SqlitePath = Path.GetFullPath(secrets.SqlitePath, dir);
|
|
|
|
SqlServerSecretsOptions? sqlServer = null;
|
|
IConfigurationSection sqlSection = config.GetSection(sectionPath + ":SqlServer");
|
|
if (sqlSection.GetChildren().Any())
|
|
{
|
|
sqlServer = sqlSection.Get<SqlServerSecretsOptions>();
|
|
}
|
|
|
|
string name = new DirectoryInfo(dir).Name;
|
|
|
|
return new StoreTarget(name, fullPath, secrets, sqlServer, config);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Builds a manual target from an explicit db path + master-key options, with no backing
|
|
/// appsettings file (for ad-hoc stores the console operates on directly).
|
|
/// </summary>
|
|
/// <param name="sqlitePath">Path to the SQLite store; made absolute against the current directory.</param>
|
|
/// <param name="masterKey">The master-key resolution options for this manual store.</param>
|
|
/// <returns>A <see cref="StoreTarget"/> named <c>manual</c> with an empty composed configuration and no SQL-Server hub.</returns>
|
|
public StoreTarget Manual(string sqlitePath, MasterKeyOptions masterKey)
|
|
{
|
|
SecretsOptions secrets = new()
|
|
{
|
|
SqlitePath = Path.GetFullPath(sqlitePath),
|
|
MasterKey = masterKey,
|
|
};
|
|
|
|
IConfigurationRoot config = new ConfigurationBuilder().Build();
|
|
|
|
return new StoreTarget("manual", AppSettingsPath: null, secrets, SqlServer: null, config);
|
|
}
|
|
}
|