215 lines
11 KiB
C#
215 lines
11 KiB
C#
using System;
|
|
using System.Dynamic;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using Newtonsoft.Json;
|
|
|
|
[assembly: InternalsVisibleTo("deployment.tests")]
|
|
namespace greyn.Deployment
|
|
{
|
|
public static class ConfigurationBootstrapper
|
|
{
|
|
private const string confpath = "appsettings.json";
|
|
|
|
public static T Load<T>() where T : new()
|
|
{
|
|
if (File.Exists("appsettings.json"))
|
|
{
|
|
/* "aaaahhh this is the most abstract and reflective thing in the goddamn world aaaahhhhh next you'll make an ECS on a dynamic aaaahhh"
|
|
* Ok, yes. I share these fears. but.
|
|
* this way we can read a *very* arbitrary configuration file.
|
|
* some random external file's configuration values is a good reason to aim for very high flexibility, imo
|
|
* if the configuration expects new values we write them in,
|
|
* if you left other junk for whatever reason, we don't delete them.
|
|
*/
|
|
var actualConfig = JsonConvert.DeserializeObject<ExpandoObject>(File.ReadAllText(confpath)) ?? new ExpandoObject();
|
|
var toReturn = new T();
|
|
populateExpando(toReturn, ref actualConfig);
|
|
File.WriteAllText(confpath, JsonConvert.SerializeObject(actualConfig, Formatting.Indented));
|
|
|
|
readFromExpando(ref toReturn, actualConfig);
|
|
|
|
return toReturn;
|
|
}
|
|
else
|
|
{
|
|
var toReturn = new T();
|
|
File.WriteAllText(confpath, JsonConvert.SerializeObject(toReturn));
|
|
return toReturn;
|
|
}
|
|
}
|
|
|
|
//TODO: make private but get tests to cooperate... I think that's a c# limitation
|
|
internal static void populateExpando<T>(T config, ref ExpandoObject fromFile)
|
|
{
|
|
if (config == null) return;
|
|
Console.WriteLine("config is not null");
|
|
|
|
Console.WriteLine($"fromfile null: {fromFile == null}");
|
|
if (fromFile == null)
|
|
{
|
|
fromFile = new ExpandoObject();
|
|
// var expandoPopulated = new ExpandoObject();
|
|
// var dictionaryFromExpandoPopulated = (IDictionary<string, object?>)expandoPopulated;
|
|
// foreach (var memberInfo in config.GetType().GetMembers())
|
|
// {
|
|
// switch (memberInfo.MemberType)
|
|
// {
|
|
// case MemberTypes.Field:
|
|
// dictionaryFromExpandoPopulated.Add(memberInfo.Name, ((FieldInfo)memberInfo).GetValue(config));
|
|
// break;
|
|
// case MemberTypes.Property:
|
|
// dictionaryFromExpandoPopulated.Add(memberInfo.Name, ((PropertyInfo)memberInfo).GetValue(config));
|
|
// break;
|
|
// default:
|
|
// break;
|
|
// }
|
|
// }
|
|
// expandoPopulated = (ExpandoObject)dictionaryFromExpandoPopulated;
|
|
// fromFile = expandoPopulated;
|
|
// return;
|
|
}
|
|
var dictionaryFromExpandoFromFile = (IDictionary<string, object?>)fromFile;
|
|
Console.WriteLine($"{config.GetType().GetMembers().Count()} members on {config.GetType()}");
|
|
foreach (var memberInfo in config.GetType().GetMembers())
|
|
{
|
|
Console.WriteLine($"checking property: {memberInfo.Name}");
|
|
|
|
if(memberInfo.DeclaringType == typeof(System.Object))
|
|
{
|
|
Console.WriteLine($"junk from system.object, don't care");
|
|
continue;
|
|
}
|
|
if(memberInfo.MemberType != MemberTypes.Field && memberInfo.MemberType != MemberTypes.Property)
|
|
{
|
|
Console.WriteLine($"type I don't know how to handle ({memberInfo.MemberType})");
|
|
continue;
|
|
}
|
|
|
|
if (dictionaryFromExpandoFromFile.TryGetValue(memberInfo.Name, out object? valueFromDict))
|
|
{
|
|
Console.WriteLine($"dictionary has it - {valueFromDict}");
|
|
if (valueFromDict != null)
|
|
{
|
|
Console.WriteLine($"value from configuration file is not null");
|
|
|
|
switch (memberInfo.MemberType)
|
|
{
|
|
case MemberTypes.Field:
|
|
var asField = (FieldInfo)memberInfo;
|
|
|
|
//if ((asField.FieldType.GetMembers(BindingFlags.DeclaredOnly)?.Count() ?? 0) > 0)
|
|
{
|
|
Console.WriteLine($"{asField.Name} (as field) has {asField.FieldType.GetMembers() .Count()} members.");
|
|
Console.WriteLine($"{dictionaryFromExpandoFromFile[asField.Name]}");
|
|
|
|
var childMember = dictionaryFromExpandoFromFile[asField.Name] as ExpandoObject;
|
|
if(childMember != null)
|
|
{
|
|
populateExpando(asField.GetValue(config), ref childMember);
|
|
//asField.SetValue(fromFile, childMember); //you don't have to set it back. the expandoobject *implements* IDictionary
|
|
// so when you cast it, it's not a copy; you just access it as a dictionary. So you can change it dynamically.
|
|
// and we ref'd it so it got the underlying one.
|
|
//https://stackoverflow.com/questions/4938397/dynamically-adding-properties-to-an-expandoobject
|
|
}
|
|
}
|
|
break;
|
|
case MemberTypes.Property:
|
|
var asProperty = (PropertyInfo)memberInfo;
|
|
//if ((asProperty.PropertyType.GetMembers(BindingFlags.DeclaredOnly)?.Count() ?? 0) > 0)
|
|
{
|
|
Console.WriteLine($"{asProperty.Name} (as property) has {asProperty.PropertyType.GetMembers() .Count()} members.");
|
|
Console.WriteLine($"{dictionaryFromExpandoFromFile[asProperty.Name]}");
|
|
var childMember = dictionaryFromExpandoFromFile[asProperty.Name] as ExpandoObject; // (ExpandoObject)asProperty.GetValue(fromFile);
|
|
if(childMember != null)
|
|
{
|
|
populateExpando(asProperty.GetValue(config), ref childMember);
|
|
//asProperty.SetValue(fromFile, childMember);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
Console.WriteLine($"membertype unhanlded. {memberInfo.MemberType}");
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine($"dictionary didn't have it. so let's add to fromFile");
|
|
switch (memberInfo.MemberType)
|
|
{
|
|
case MemberTypes.Field:
|
|
var addTry = fromFile.TryAdd(memberInfo.Name, ((FieldInfo)memberInfo).GetValue(config));
|
|
Console.WriteLine($"ostensibly, succeeded? {addTry}");
|
|
break;
|
|
case MemberTypes.Property:
|
|
var addTry2 = fromFile.TryAdd(memberInfo.Name, ((PropertyInfo)memberInfo).GetValue(config));
|
|
Console.WriteLine($"ostensibly, succeeded? {addTry2}");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
Console.WriteLine($"{memberInfo.Name} handled");
|
|
}
|
|
}
|
|
internal static void readFromExpando<T>(ref T config, ExpandoObject readFromFile)
|
|
{
|
|
//TODO: read from Expando
|
|
}
|
|
|
|
// private static T sync<T>(ref T config, ref ExpandoObject readFromFile)
|
|
// {
|
|
// var fieldsFoundThisLevel = new List<string>();
|
|
|
|
// if(config == null)
|
|
// {
|
|
// //TODO: it's entirely possible this is null.
|
|
// throw new ArgumentNullException();
|
|
// }
|
|
// if(readFromFile == null)
|
|
// {
|
|
// //TODO: it's entirely possible this is null.
|
|
// throw new ArgumentNullException();
|
|
// }
|
|
// var readUnExpandoed = (IDictionary<string, object?>)readFromFile;
|
|
// //if it's present on what was read
|
|
// //set it on Config
|
|
// //if it's not found on what was read, or type is different
|
|
|
|
// foreach (var prop in config.GetType().GetProperties())
|
|
// {
|
|
// fieldsFoundThisLevel.Add(prop.Name);
|
|
// if(readUnExpandoed.TryGetValue(prop.Name, out object? valueFromFile)) //so a configuration file can *set* a value *to null*
|
|
// {
|
|
// if(valueFromFile != null)
|
|
// {
|
|
// var defaultConfigValue = prop.GetValue(config);
|
|
// if (defaultConfigValue != null)
|
|
// {
|
|
// //expandofy, since we objectified it.
|
|
// var expandoFromFile = new ExpandoObject();
|
|
// var dictionaryFromExpandoFromFile = (IDictionary<string, object?>)expandoFromFile;
|
|
// foreach (var property in valueFromFile.GetType().GetProperties())
|
|
// dictionaryFromExpandoFromFile.Add(property.Name, property.GetValue(valueFromFile));
|
|
// expandoFromFile = (ExpandoObject)dictionaryFromExpandoFromFile;
|
|
// //dive in, repeat
|
|
// sync(ref defaultConfigValue, ref expandoFromFile);
|
|
// //we've now Sync'd expandoFromFile and defaultConfigValue
|
|
// prop.SetValue(readFromFile, expandoFromFile);
|
|
// prop.SetValue(config, expandoFromFile);
|
|
// }
|
|
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// readFromFile.TryAdd(prop.Name, prop.GetValue(config));
|
|
// }
|
|
// }
|
|
// }
|
|
}
|
|
} |