private static async Task SetVaultConfig(
this IConfigurationBuilder builder,
VaultOptions options,
string kvp)
{
VerifyOptions(options);
var kvPath = string.IsNullOrWhiteSpace(kvp) ? options.KeyValue?.Path : kvp;
if (!(options.KeyValue?.Enabled ?? false) && string.IsNullOrWhiteSpace(kvPath))
{
return;
}
var(client, _) = GetClientAndSettings(options);
var keyValueService = new KeyValueService(client, options);
var secret = await keyValueService.GetAsync(kvPath);
var parser = new JsonConfigurationParser();
var data = parser.Parse(JObject.FromObject(secret));
var source = new MemoryConfigurationSource {
InitialData = data
};
builder.Add(source);
}
public void Should_skip_comments()
{
var json = @"
// root
{
// my
""A"": ""1"",
""B"": [
// world
""2""
]
}
";
var parsed = JsonConfigurationParser.Parse(json);
parsed.Should()
.BeEquivalentTo(
new ObjectNode(
null,
new ISettingsNode[]
{
new ValueNode("A", "1"),
new ArrayNode("B", new[] { new ValueNode(null, "2") })
}));
}
public override IDictionary <string, string> ProcessParameters(IEnumerable <Parameter> parameters, string path)
{
return(parameters
.Where(parameter => IncludeParameter(parameter, path))
.SelectMany(parameter => JsonConfigurationParser.Parse(parameter.Value))
.ToDictionary(parameter => parameter.Key, parameter => parameter.Value, StringComparer.OrdinalIgnoreCase));
}
public void LoadConfig(string module, object config)
{
if (!_moduleDict.TryGetValue(module, out var dict))
{
dict = new Dictionary <string, string>();
_moduleDict.Add(module, dict);
}
dict.Clear();
if (config != null)
{
var parser = new JsonConfigurationParser();
var json = config is string?config.ToString() : JsonConvert.SerializeObject(config);
var t = parser.Parse(json);
foreach (var key in t.Keys)
{
var dKey = ConvertKey(key);
if (string.IsNullOrWhiteSpace(dKey))
{
continue;
}
dict[dKey] = t[key];
}
}
//重新加载整体数据
Data.Clear();
foreach (var moduleData in _moduleDict)
{
foreach (var data in moduleData.Value)
{
Data[data.Key] = data.Value;
}
}
}
public void Should_parse_value_with_empty_root_object()
{
const string value = "{ }";
var result = JsonConfigurationParser.Parse(value);
result.Should().Be(new ObjectNode(new ISettingsNode[] {}));
}
public void Should_parse_ArrayOfNulls_value()
{
const string value = "{ 'Array': [null, null] }";
var result = JsonConfigurationParser.Parse(value);
result["Array"].Children.Select(c => c.Value).Should().Equal(null, null);
}
public void Should_parse_Null_value()
{
const string value = "{ 'NullValue': null }";
var result = JsonConfigurationParser.Parse(value);
result["NullValue"].Value.Should().Be(null);
}
public void Should_parse_Boolean_value()
{
const string value = "{ 'BooleanValue': true }";
var result = JsonConfigurationParser.Parse(value);
result["BooleanValue"].Value.Should().Be("True");
}
public void Should_parse_integer_value()
{
const string value = "{ 'IntValue': 123 }";
var result = JsonConfigurationParser.Parse(value);
result["IntValue"].Value.Should().Be("123");
}
public void Should_parse_Double_value()
{
const string value = "{ 'DoubleValue': 123.321 }";
var result = JsonConfigurationParser.Parse(value);
result["DoubleValue"].Value.Should().Be(123.321d.ToString(CultureInfo.CurrentCulture));
}
public void Should_parse_Object_value()
{
const string value = "{ 'Object': { 'StringValue': 'str' } }";
var result = JsonConfigurationParser.Parse(value);
result["Object"]["StringValue"].Value.Should().Be("str");
}
public void Should_parse_empty_Object_value()
{
const string value = "{ 'Object': { } }";
var result = JsonConfigurationParser.Parse(value);
result["Object"].Should().Be(new ObjectNode("Object"));
}
public void Should_parse_Array_value()
{
const string value = "{ 'IntArray': [1, 2, 3] }";
var result = JsonConfigurationParser.Parse(value);
result["IntArray"].Children.Select(c => c.Value).Should().Equal("1", "2", "3");
}
public SettingsProvider(string serviceName, string configurationPathPrefix = SingularClientConstants.ServicesConfigurationNamePrefix)
{
servicePath = $"{configurationPathPrefix}{serviceName}.json";
source = new ClusterConfigSource(
new ClusterConfigSourceSettings(ClusterConfigClient.Default, servicePath)
{
ValuesParser = (value, path) => JsonConfigurationParser.Parse(value)
});
}
public async Task ConvertAsync_InvalidJson()
{
var json = "{";
using var jsonStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
var configurationConverter = new JsonConfigurationParser();
await Assert.ThrowsAsync <JsonException>(() => configurationConverter.ParseAsync(jsonStream));
}
public ConsulConfigurationSource(string key)
{
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentNullException(nameof(key));
}
Key = key;
Parser = new JsonConfigurationParser();
}
public void Should_parse_ArrayOfArrays_value()
{
const string value = "{ 'Array': [['s', 't'], ['r']] }";
var result = JsonConfigurationParser.Parse(value);
result["Array"].Children.Count().Should().Be(2);
result["Array"].Children.First().Children.Select(c => c.Value).Should().Equal("s", "t");
result["Array"].Children.Last().Children.Select(c => c.Value).Should().Equal("r");
}
public void Should_parse_ArrayOfObjects_value()
{
const string value = "{ 'Array': [{ 'StringValue': 'str' }, { 'IntValue': 123 }] }";
var result = JsonConfigurationParser.Parse(value);
result["Array"].Children.Count().Should().Be(2);
result["Array"].Children.First()["StringValue"].Value.Should().Be("str");
result["Array"].Children.Last()["IntValue"].Value.Should().Be("123");
}
public async Task ConvertAsync_OneExcelEntry_MissingSheet()
{
var json = "{ \"summary\": [{ \"resource\": \"homer.xlsx\", \"row\": 1 }]}";
using var jsonStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
var configurationConverter = new JsonConfigurationParser();
await Assert.ThrowsAsync <InvalidDataException>(() => configurationConverter.ParseAsync(jsonStream));
}
public async Task ConvertAsync_OneSensorEntry_InvalidFormatValue()
{
var json = "{ \"energy\": [{ \"format\": \"swiss\", \"resource\": \"heaven.json\" }]}";
using var jsonStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
var configurationConverter = new JsonConfigurationParser();
await Assert.ThrowsAsync <InvalidDataException>(() => configurationConverter.ParseAsync(jsonStream));
}
public async Task ConvertAsync_OneSensorEntry()
{
var json = "{ \"energy\": [{ \"id\": \"heaven\", \"format\": \"Sel\", \"resource\": \"heaven.json\" }]}";
using var jsonStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
var configurationConverter = new JsonConfigurationParser();
var configuration = await configurationConverter.ParseAsync(jsonStream);
Assert.Contains(new EnergyConfig("heaven", "heaven.json", EnergySourceFormat.Sel), configuration.EnergyConfigs);
}
public async Task ConvertAsync_OneExcelEntry()
{
var json = "{ \"summary\": [{ \"resource\": \"homer.xlsx\", \"sheet\": \"atlantis\", \"row\": 1 }]}";
using var jsonStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
var configurationConverter = new JsonConfigurationParser();
var configuration = await configurationConverter.ParseAsync(jsonStream);
Assert.Contains(new SummaryConfig("homer.xlsx", "atlantis", 1), configuration.SummaryConfigs);
}
public ConsulConfigurationSource(string key)
{
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentNullException(nameof(key));
}
Key = key;
Parser = new JsonConfigurationParser();
ConvertConsulKVPairToConfig = DefaultConvertConsulKVPairToConfigStrategy;
}
public void JsonTest()
{
var json = @"{""a"":3, ""b"":{""c"":[4]}}";
var data = JsonConfigurationParser.Parse(json);
Assert.NotNull(data);
Assert.Equal(2, data.Count);
Assert.Equal("3", data["a"]);
Assert.Equal("4", data["b:c:0"]);
}
public async Task ConvertAsync_TwoMeteoEntries()
{
var json = "{ \"meteo\": [{ \"resource\": \"any.json\" }, { \"resource\": \"second.json\" }]}";
using var jsonStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
var configurationConverter = new JsonConfigurationParser();
var configuration = await configurationConverter.ParseAsync(jsonStream);
Assert.Contains(new MeteoConfig("any.json"), configuration.MeteoConfigs);
Assert.Contains(new MeteoConfig("second.json"), configuration.MeteoConfigs);
}
public void Should_parse_root_array()
{
const string value = "[1, 2]";
JsonConfigurationParser.Parse(value)
.Should()
.Be(new ArrayNode(new ISettingsNode[]
{
new ValueNode("0", "1"),
new ValueNode("1", "2")
}));
}
public async Task ConvertAsync_Empty()
{
var json = "{}";
using var jsonStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
var configurationConverter = new JsonConfigurationParser();
var configuration = await configurationConverter.ParseAsync(jsonStream);
Assert.NotNull(configuration);
Assert.Empty(configuration.MeteoConfigs);
Assert.Empty(configuration.EnergyConfigs);
Assert.Empty(configuration.SummaryConfigs);
}
public static IConfigurationBuilder AddAwsS3(this IConfigurationBuilder builder,
Func <IAmazonS3> clientCreator,
GetObjectRequest objectRequest,
bool optional = false,
TimeSpan?period = default,
string prefix = default,
Func <AsyncLoaderExceptionContext, Task> onException = default)
{
builder.AddLoadAsync(async() =>
{
using var client = clientCreator();
var response = await client.GetObjectAsync(objectRequest).ConfigureAwait(false);
return(JsonConfigurationParser.Parse(response.ResponseStream));
}, optional, period, prefix, onException);
return(builder);
}
public void Should_not_corrupt_date()
{
var json = @"{
""A"": ""2020-11-16T00:00:00.000+06:00"",
""B"": [ ""2020-11-16T00:00:00.000+06:00"" ]
}
";
var parsed = JsonConfigurationParser.Parse(json);
var printed = JsonConfigurationPrinter.Print(parsed);
printed.Should().Contain("2020-11-16T00:00:00.000+06:00");
var parsed2 = JsonConfigurationParser.Parse(printed);
parsed2.Should().BeEquivalentTo(parsed);
}
private void ParseFrom(KVPair kv)
{
if (kv.Value == null || kv.Value.Length == 0)
{
return;
}
var parser = new JsonConfigurationParser();
using (var stream = new MemoryStream(kv.Value))
{
Data = parser.Parse(stream);
}
if (this._LastIndex > 0)
{
Logger.Debug("raise base onreload");
base.OnReload();
}
//Console.WriteLine(JsonConvert.SerializeObject(Data));
}
