326 lines
13 KiB
C#
326 lines
13 KiB
C#
using System.Globalization;
|
|
using System.Text;
|
|
using FluentResults;
|
|
using Npgsql;
|
|
|
|
namespace pgLabII.PgUtils.ConnectionStrings;
|
|
|
|
/// <summary>
|
|
/// Parser/formatter for Npgsql-style .NET connection strings. We intentionally do not
|
|
/// rely on NpgsqlConnectionStringBuilder here because:
|
|
/// - We need a lossless, format-agnostic round-trip to our ConnectionDescriptor, including
|
|
/// unknown/extension keys and per-host port lists. NpgsqlConnectionStringBuilder normalizes
|
|
/// names, may drop unknown keys or coerce values, which breaks lossless conversions.
|
|
/// - We support multi-host with per-host ports and want to preserve the original textual
|
|
/// representation across conversions. The builder flattens/rewrites these details.
|
|
/// - We aim to keep pgLabII.PgUtils independent from Npgsql's evolving parsing rules and
|
|
/// version-specific behaviors to ensure stable UX and deterministic tests.
|
|
/// - We need symmetric formatting matching our other codecs (libpq/URL/JDBC) and consistent
|
|
/// quoting rules across formats.
|
|
/// If required, we still reference Npgsql for enums and interop types, but parsing/formatting
|
|
/// is done by this small, well-tested custom codec for full control and stability.
|
|
/// </summary>
|
|
public sealed class NpgsqlCodec : IConnectionStringCodec
|
|
{
|
|
public ConnStringFormat Format => ConnStringFormat.Npgsql;
|
|
public string FormatName => "Npgsql";
|
|
|
|
public Result<ConnectionDescriptor> TryParse(string input)
|
|
{
|
|
try
|
|
{
|
|
var dict = Tokenize(input);
|
|
var descriptor = new ConnectionDescriptorBuilder();
|
|
|
|
// Hosts and Ports
|
|
if (dict.TryGetValue("Host", out var hostVal) || dict.TryGetValue("Server", out hostVal) || dict.TryGetValue("Servers", out hostVal))
|
|
{
|
|
var rawHosts = SplitList(hostVal).ToList();
|
|
var hosts = new List<string>(rawHosts.Count);
|
|
var portsPerHost = new List<ushort?>(rawHosts.Count);
|
|
|
|
// First, extract inline ports from each host entry (e.g., host:5432 or [::1]:5432)
|
|
foreach (var raw in rawHosts)
|
|
{
|
|
ParseHostPort(raw, out var hostOnly, out var inlinePort);
|
|
hosts.Add(hostOnly);
|
|
portsPerHost.Add(inlinePort);
|
|
}
|
|
|
|
// Then, merge values from Port key: single port applies to all hosts missing a port;
|
|
// list of ports applies 1:1 for hosts that still miss a port. Inline ports take precedence.
|
|
if (dict.TryGetValue("Port", out var portVal))
|
|
{
|
|
var ports = SplitList(portVal).ToList();
|
|
if (ports.Count == 1 && ushort.TryParse(ports[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var singlePort))
|
|
{
|
|
for (int i = 0; i < portsPerHost.Count; i++)
|
|
if (!portsPerHost[i].HasValue)
|
|
portsPerHost[i] = singlePort;
|
|
}
|
|
else if (ports.Count == hosts.Count)
|
|
{
|
|
for (int i = 0; i < ports.Count; i++)
|
|
{
|
|
if (!portsPerHost[i].HasValue && ushort.TryParse(ports[i], NumberStyles.Integer, CultureInfo.InvariantCulture, out var up))
|
|
portsPerHost[i] = up;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < hosts.Count; i++)
|
|
{
|
|
descriptor.AddHost(hosts[i], i < portsPerHost.Count ? portsPerHost[i] : null);
|
|
}
|
|
}
|
|
|
|
// Standard fields
|
|
if (TryGetFirst(dict, out var db, "Database", "Db", "Initial Catalog", "dbname"))
|
|
descriptor.Database = db;
|
|
if (TryGetFirst(dict, out var user, "Username", "User ID", "User", "UID"))
|
|
descriptor.Username = user;
|
|
if (TryGetFirst(dict, out var pass, "Password", "PWD"))
|
|
descriptor.Password = pass;
|
|
if (TryGetFirst(dict, out var app, "Application Name", "ApplicationName"))
|
|
descriptor.ApplicationName = app;
|
|
if (TryGetFirst(dict, out var timeout, "Timeout", "Connect Timeout", "Connection Timeout"))
|
|
{
|
|
if (int.TryParse(timeout, NumberStyles.Integer, CultureInfo.InvariantCulture, out var t))
|
|
descriptor.TimeoutSeconds = t;
|
|
}
|
|
if (TryGetFirst(dict, out var ssl, "SSL Mode", "SslMode", "SSLMode"))
|
|
descriptor.SslMode = ParseSslMode(ssl);
|
|
|
|
// Preserve extras (not mapped) into Properties
|
|
var mapped = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
"Host","Server","Servers","Port","Database","Db","Initial Catalog","dbname",
|
|
"Username","User ID","User","UID","Password","PWD","Application Name","ApplicationName",
|
|
"Timeout","Connect Timeout","Connection Timeout","SSL Mode","SslMode","SSLMode"
|
|
};
|
|
foreach (var (k, v) in dict)
|
|
{
|
|
if (!mapped.Contains(k))
|
|
descriptor.Properties[k] = v;
|
|
}
|
|
|
|
return Result.Ok(descriptor.Build());
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return Result.Fail<ConnectionDescriptor>(ex.Message);
|
|
}
|
|
}
|
|
|
|
public Result<string> TryFormat(ConnectionDescriptor descriptor)
|
|
{
|
|
try
|
|
{
|
|
var parts = new List<string>();
|
|
|
|
if (descriptor.Hosts != null && descriptor.Hosts.Count > 0)
|
|
{
|
|
var hostList = string.Join(',', descriptor.Hosts.Select(h => h.Host));
|
|
parts.Add(FormatPair("Host", hostList));
|
|
var ports = descriptor.Hosts.Select(h => h.Port).Where(p => p.HasValue).Select(p => p!.Value).Distinct().ToList();
|
|
if (ports.Count == 1)
|
|
{
|
|
parts.Add(FormatPair("Port", ports[0].ToString(CultureInfo.InvariantCulture)));
|
|
}
|
|
else if (ports.Count == 0)
|
|
{
|
|
// nothing
|
|
}
|
|
else
|
|
{
|
|
// Per-host ports if provided 1:1
|
|
var perHost = descriptor.Hosts.Select(h => h.Port?.ToString(CultureInfo.InvariantCulture) ?? string.Empty).ToList();
|
|
if (perHost.All(s => !string.IsNullOrEmpty(s)))
|
|
parts.Add(FormatPair("Port", string.Join(',', perHost)));
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(descriptor.Database))
|
|
parts.Add(FormatPair("Database", descriptor.Database));
|
|
if (!string.IsNullOrEmpty(descriptor.Username))
|
|
parts.Add(FormatPair("Username", descriptor.Username));
|
|
if (!string.IsNullOrEmpty(descriptor.Password))
|
|
parts.Add(FormatPair("Password", descriptor.Password));
|
|
if (descriptor.SslMode.HasValue)
|
|
parts.Add(FormatPair("SSL Mode", FormatSslMode(descriptor.SslMode.Value)));
|
|
if (!string.IsNullOrEmpty(descriptor.ApplicationName))
|
|
parts.Add(FormatPair("Application Name", descriptor.ApplicationName));
|
|
if (descriptor.TimeoutSeconds.HasValue)
|
|
parts.Add(FormatPair("Timeout", descriptor.TimeoutSeconds.Value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
var emittedKeys = new HashSet<string>(parts.Select(p => p.Split('=')[0].Trim()), StringComparer.OrdinalIgnoreCase);
|
|
foreach (var kv in descriptor.Properties)
|
|
{
|
|
if (!emittedKeys.Contains(kv.Key))
|
|
parts.Add(FormatPair(kv.Key, kv.Value));
|
|
}
|
|
|
|
return Result.Ok(string.Join(";", parts));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return Result.Fail<string>(ex.Message);
|
|
}
|
|
}
|
|
|
|
private static IEnumerable<string> SplitList(string s)
|
|
{
|
|
return s.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
|
|
}
|
|
|
|
private static void ParseHostPort(string hostPart, out string host, out ushort? port)
|
|
{
|
|
host = hostPart;
|
|
port = null;
|
|
if (string.IsNullOrWhiteSpace(hostPart)) return;
|
|
|
|
// IPv6 in brackets: [::1]:5432
|
|
if (hostPart[0] == '[')
|
|
{
|
|
int end = hostPart.IndexOf(']');
|
|
if (end > 0)
|
|
{
|
|
host = hostPart.Substring(1, end - 1);
|
|
if (end + 1 < hostPart.Length && hostPart[end + 1] == ':')
|
|
{
|
|
var ps = hostPart.Substring(end + 2);
|
|
if (ushort.TryParse(ps, NumberStyles.Integer, CultureInfo.InvariantCulture, out var p))
|
|
port = p;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Non-IPv6: split on last ':' and ensure right side is numeric
|
|
int colon = hostPart.LastIndexOf(':');
|
|
if (colon > 0 && colon < hostPart.Length - 1)
|
|
{
|
|
var ps = hostPart.Substring(colon + 1);
|
|
if (ushort.TryParse(ps, NumberStyles.Integer, CultureInfo.InvariantCulture, out var p))
|
|
{
|
|
host = hostPart.Substring(0, colon);
|
|
port = p;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool TryGetFirst(Dictionary<string, string> dict, out string value, params string[] keys)
|
|
{
|
|
foreach (var k in keys)
|
|
{
|
|
if (dict.TryGetValue(k, out value)) return true;
|
|
}
|
|
value = string.Empty;
|
|
return false;
|
|
}
|
|
|
|
private static SslMode ParseSslMode(string s) => CodecCommon.ParseSslModeLoose(s);
|
|
|
|
private static string FormatSslMode(SslMode mode) => mode switch
|
|
{
|
|
SslMode.Disable => "Disable",
|
|
SslMode.Allow => "Allow",
|
|
SslMode.Prefer => "Prefer",
|
|
SslMode.Require => "Require",
|
|
SslMode.VerifyCA => "VerifyCA",
|
|
SslMode.VerifyFull => "VerifyFull",
|
|
_ => "Prefer"
|
|
};
|
|
|
|
// Npgsql/.NET connection string grammar: semicolon-separated key=value; values with special chars are wrapped in quotes, internal quotes doubled
|
|
private static string FormatPair(string key, string? value)
|
|
{
|
|
value ??= string.Empty;
|
|
var needsQuotes = NeedsQuoting(value);
|
|
if (!needsQuotes) return key + "=" + value;
|
|
return key + "=\"" + EscapeQuoted(value) + "\"";
|
|
}
|
|
|
|
private static bool NeedsQuoting(string value)
|
|
{
|
|
if (value.Length == 0) return true;
|
|
foreach (var c in value)
|
|
{
|
|
if (char.IsWhiteSpace(c) || c == ';' || c == '=' || c == '"') return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private static string EscapeQuoted(string value)
|
|
{
|
|
// Double the quotes per standard DbConnectionString rules
|
|
return value.Replace("\"", "\"\"");
|
|
}
|
|
|
|
private static Dictionary<string, string> Tokenize(string input)
|
|
{
|
|
// Simple tokenizer for .NET connection strings: key=value pairs separated by semicolons; values may be quoted with double quotes
|
|
var dict = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
int i = 0;
|
|
void SkipWs() { while (i < input.Length && char.IsWhiteSpace(input[i])) i++; }
|
|
|
|
while (true)
|
|
{
|
|
SkipWs();
|
|
if (i >= input.Length) break;
|
|
|
|
// read key
|
|
int keyStart = i;
|
|
while (i < input.Length && input[i] != '=') i++;
|
|
if (i >= input.Length) { break; }
|
|
var key = input.Substring(keyStart, i - keyStart).Trim();
|
|
i++; // skip '='
|
|
SkipWs();
|
|
|
|
// read value
|
|
string value;
|
|
if (i < input.Length && input[i] == '"')
|
|
{
|
|
i++; // skip opening quote
|
|
var sb = new StringBuilder();
|
|
while (i < input.Length)
|
|
{
|
|
char c = input[i++];
|
|
if (c == '"')
|
|
{
|
|
if (i < input.Length && input[i] == '"')
|
|
{
|
|
// doubled quote -> literal quote
|
|
sb.Append('"');
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
break; // end quoted value
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sb.Append(c);
|
|
}
|
|
}
|
|
value = sb.ToString();
|
|
}
|
|
else
|
|
{
|
|
int valStart = i;
|
|
while (i < input.Length && input[i] != ';') i++;
|
|
value = input.Substring(valStart, i - valStart).Trim();
|
|
}
|
|
|
|
dict[key] = value;
|
|
|
|
// skip to next, if ; present, consume one
|
|
while (i < input.Length && input[i] != ';') i++;
|
|
if (i < input.Length && input[i] == ';') i++;
|
|
}
|
|
|
|
return dict;
|
|
}
|
|
}
|