ConfigManager.cs

Go to the documentation of this file.

using System;
 
namespace Hermod.Config {
 
    using Core;
    using Detail;
 
    using Newtonsoft.Json;
    using Newtonsoft.Json.Linq;
 
    using Serilog;
 
    using System.IO;
    using System.Text;
    using System.Text.RegularExpressions;
 
    public partial class ConfigManager: IConfigLoaded, IConfigChanged {
 
        private readonly object m_lock;
        private volatile string m_lockedBy;
 
        public ILogger? AppLogger { get; set; }
 
        #region IConfigLoaded
        public event ConfigLoadedEventHandler? ConfigLoaded;
 
        protected void OnConfigLoaded() => ConfigLoaded?.Invoke(this, new ConfigLoadedEventArgs());
        #endregion
 
        #region ConfigChanged
        public event ConfigChangedEventHandler? ConfigChanged;
 
        protected void OnConfigChanged(string configName, object? prevValue, object? newValue, Type cfgType) {
            ConfigChanged?.Invoke(this, new ConfigChangedEventArgs(configName, prevValue, newValue, cfgType));
        }
        #endregion
 
        #region Defaults
        const string DefaultConfigFileName  = ".hermod.json";
 
        private static FileInfo? _defaultConfigPathCache = null;
 
        FileInfo GetDefaultConfigPath() {
            return
                _defaultConfigPathCache ??
                (
                    _defaultConfigPathCache = AppInfo.GetBaseHermodDirectory()
                                                     .GetSubFile(
                                                        AppInfo.HermodAppCfgDirName,
                                                        DefaultConfigFileName
                                                      )
                );
        }
        #endregion
 
        #region Singleton
        private static ConfigManager? _instance;
 
        public static ConfigManager Instance => _instance ?? (_instance = new ConfigManager());
 
        protected ConfigManager() {
            m_lock = new object();
            m_lockedBy = string.Empty;
            m_configDictionary = new JObject();
            m_configFile = GetDefaultConfigPath();
            m_defaultConfig = LoadDefaultConfig();
        }
        #endregion
 
        [GeneratedRegex(@"^([A-z_][A-z0-9_]+)(\.[A-z_][A-z0-9_]+)+?[^\.]$", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase)]
        public static partial Regex ConfigDotNotation();
 
        protected JObject m_configDictionary;
        protected JObject m_defaultConfig;
 
        protected JObject LoadDefaultConfig() {
            using var rStream = typeof(ConfigManager).Assembly.GetManifestResourceStream("Hermod.Config.Resources.DefaultConfig.json");
            if (rStream is null) {
                throw new Exception("Failed to load default configuration! Hermod will abort!");
            }
 
            using (var sReader = new StreamReader(rStream)) {
                var text = sReader.ReadToEnd();
                return JObject.Parse(text);
            }
        }
 
        private FileInfo? m_configFile = null;
        public FileInfo ConfigFile {
            get => m_configFile ?? GetDefaultConfigPath();
            set {
                if (value == m_configFile) { return; }
 
                m_configFile = value;
                LoadConfig();
            }
        }
 
        public async Task LoadConfigAsync() {
            if (!ConfigFile.Exists || ConfigFile.Length < 10) {
                // this will happen for files that don't exist
                // and files that are less than 10B
                lock (m_lock) {
                    m_lockedBy = nameof(LoadConfigAsync);
                    m_configDictionary = m_defaultConfig;
                    m_lockedBy = string.Empty;
                }
                await SaveConfigAsync();
                return;
            }
 
            using (var cfgFile = ConfigFile.Open(FileMode.Open))
            using (var sReader = new StreamReader(cfgFile)) {
                var sBuilder = new StringBuilder();
 
                while (sReader.Peek() != -1) {
                    sBuilder.AppendLine(await sReader.ReadLineAsync());
                }
 
                try {
                    lock (m_lock) {
                        m_lockedBy = nameof(LoadConfigAsync);
                        m_configDictionary = JObject.Parse(sBuilder.ToString());
                        m_lockedBy = string.Empty;
                    }
                } catch (Exception ex) {
                    Console.Error.WriteLine("An error occurred while loading configs! Loading defaults!");
                    Console.Error.WriteLine($"Error message: { ex.Message }");
 
                    #if DEBUG
                    Console.Error.WriteLine(ex.StackTrace);
                    #endif
                }
            }
        }
 
        public void LoadConfig() {
            if (!ConfigFile.Exists || ConfigFile.Length < 10) {
                // this will happen for files that don't exist
                // and files that are less than 10B
                lock (m_lock) {
                    m_lockedBy = nameof(LoadConfig);
                    m_configDictionary = m_defaultConfig;
                    m_lockedBy = string.Empty;
                }
                SaveConfig();
                return;
            }
 
            using (var cfgFile = ConfigFile.Open(FileMode.Open))
            using (var sReader = new StreamReader(cfgFile)) {
                var sBuilder = new StringBuilder();
 
                while (sReader.Peek() != -1) {
                    sBuilder.AppendLine(sReader.ReadLine());
                }
 
                try {
                    lock (m_lock) {
                        m_lockedBy = nameof(LoadConfig);
                        m_configDictionary = JObject.Parse(sBuilder.ToString());
                        m_lockedBy = string.Empty;
                    }
                } catch (Exception ex) {
                    Console.Error.WriteLine("An error occurred while loading configs! Loading defaults!");
                    Console.Error.WriteLine($"Error message: { ex.Message }");
 
                    #if DEBUG
                    Console.Error.WriteLine(ex.StackTrace);
                    #endif
                }
            }
        }
 
        public async Task SaveConfigAsync() {
            if (!ConfigFile.Exists) {
                try {
                    ConfigFile.Directory?.Create();
                } catch (UnauthorizedAccessException ex) {
                    HandleUnauthorizedAccessWhenSavingConfig(ex);
                    await SaveConfigAsync();
                }
                ConfigFile.Create().Close();
            }
            
            using (var cfgFile = ConfigFile.Open(FileMode.Truncate))
            using (var sWriter = new StreamWriter(cfgFile)) {
                string serialisedData;
                lock (m_lock) {
                    m_lockedBy = nameof(SaveConfigAsync);
                    serialisedData = JsonConvert.SerializeObject(m_configDictionary, Formatting.Indented);
                    m_lockedBy = string.Empty;
                }
                await sWriter.WriteLineAsync(serialisedData);
            }
        }
 
        private void HandleUnauthorizedAccessWhenSavingConfig(UnauthorizedAccessException ex) {
            AppLogger?.Error($"Failed to create config file in { ConfigFile.FullName }!");
            AppLogger?.Error(ex, "Hermod does not have sufficient access rights.");
            AppLogger?.Warning("Switching to user-local config location!");
            ConfigFile = AppInfo.GetLocalHermodDirectory().CreateSubdirectory(AppInfo.HermodAppCfgDirName).GetSubFile(DefaultConfigFileName);
        }
 
        public void SaveConfig() {
            if (!ConfigFile.Exists) {
                try {
                    ConfigFile.Directory?.Create();
                } catch (UnauthorizedAccessException ex) {
                    HandleUnauthorizedAccessWhenSavingConfig(ex);
                    SaveConfig();
                }
                ConfigFile.Create().Close();
            }
 
            using (var cfgFile = ConfigFile.Open(FileMode.Truncate))
            using (var sWriter = new StreamWriter(cfgFile)) {
                string serialisedData;
                lock (m_lock) {
                    m_lockedBy = nameof(SaveConfig);
                    serialisedData = JsonConvert.SerializeObject(m_configDictionary, Formatting.Indented);
                    m_lockedBy = string.Empty;
                }
                sWriter.WriteLine(serialisedData);
            }
        }
 
        public T GetConfig<T>(string configName) {
            try {
                return GetConfig<T>(configName, m_configDictionary);
            } catch (ConfigNotFoundException) {
                return GetConfig<T>(configName, m_defaultConfig); // no point in catching anything here
            } catch {
                throw;
            }
        }
 
        public void SetConfig<T>(string configName, T? configValue) => SetConfig<T>(configName, configValue, ref m_configDictionary);
 
        protected void SetConfig<T>(string configName, T? configValue, ref JObject dict) {
            if (string.IsNullOrEmpty(configName) || string.IsNullOrWhiteSpace(configName)) {
                throw new ArgumentNullException(nameof(configName), "The config name must not be null or empty!");
            }
 
            if (ConfigDotNotation().IsMatch(configName)) {
                var periodPos = configName.IndexOf('.');
                var container = configName.Substring(0, periodPos);
                var subConfig = configName.Substring(periodPos + 1);
                var subConfigHasDotNotation = ConfigDotNotation().IsMatch(subConfig);
 
                if (dict.ContainsKey(container) && subConfigHasDotNotation) {
                    var token = dict[container];
                    if (token?.Type != JTokenType.Object) {
                        throw new ConfigException($"Config type mismatch! Expected object; got { token?.Type.ToString() }");
                    }
 
                    var tokenObj = (JObject)token;
                    SetConfig<T>(subConfig, configValue, ref tokenObj);
                    return;
                } else if (subConfigHasDotNotation) {
                    // the desired object doesn't exist, so we'll have to add it
                    lock (m_lock) {
                        m_lockedBy = nameof(SetConfig);
                        dict.Add(container, new JObject()); // add a new object and then recursively call this method so the first condition is true
                        m_lockedBy = string.Empty;
                    }
                    SetConfig<T>(configName, configValue, ref dict);
                    return;
                }
 
                // the object exists, but subConfig does not match config dot notation; call the method again so the value can be set
                SetConfig<T>(subConfig, configValue, ref dict);
            }
 
            if (!dict.ContainsKey(configName)) {
                lock (m_lock) {
                    m_lockedBy = nameof(SetConfig);
                    dict.Add(configName, JToken.FromObject(configValue));
                    m_lockedBy = string.Empty;
                }
                ConfigChanged?.Invoke(this, new ConfigChangedEventArgs(configName, null, configValue, typeof(T)));
                return;
            }
 
            var prevValue = dict[configName];
            lock (m_lock) {
                m_lockedBy = nameof(SetConfig);
                dict[configName] = JToken.FromObject(configValue);
                m_lockedBy = string.Empty;
            }
            ConfigChanged?.Invoke(this, new ConfigChangedEventArgs(configName, prevValue, configValue, typeof(T)));
        }
 
        protected T GetConfig<T>(string configName, JObject dict) {
            if (string.IsNullOrEmpty(configName) || string.IsNullOrWhiteSpace(configName)) {
                throw new ArgumentNullException(nameof(configName), "The config name must not be null or empty!");
            }
 
            if (ConfigDotNotation().IsMatch(configName)) {
                var periodPos = configName.IndexOf('.');
                var container = configName.Substring(0, periodPos);
 
                if (dict.ContainsKey(container)) {
                    var token = dict[container];
                    if (token?.Type != JTokenType.Object) {
                        throw new ConfigException($"Config type mismatch! Expected object; got { token?.Type.ToString() }");
                    }
 
                    return GetConfig<T>(configName.Substring(periodPos + 1), (JObject)token);
                } else {
                    throw new ConfigNotFoundException(container, $"Could not find container for { configName }!");
                }
            }
 
            if (!dict.ContainsKey(configName)) {
                throw new ConfigNotFoundException(configName, "Could not find requested config key!");
            }
 
            JToken config;
            lock (m_lock) {
                m_lockedBy = nameof(GetConfig);
                config = dict[configName];
                m_lockedBy = string.Empty;
            }
 
            return config.ToObject<T>();
        }
 
        #region Special Accessors
        public LoggerConfig GetConsoleLoggerConfig() => GetConfig<LoggerConfig>("Logging.ConsoleLogging");
 
        public LoggerConfig GetFileLoggerConfig() => GetConfig<LoggerConfig>("Logging.FileLogging");
 
        public DirectoryInfo GetPluginInstallDir() {
            var installDir = GetConfig<string?>("Plugins.InstallDir");
 
            if (string.IsNullOrEmpty(installDir)) {
                installDir = AppInfo.GetLocalHermodDirectory().CreateSubdirectory(AppInfo.HermodAppPluginDirName).FullName;
                SetConfig<string>("Plugins.InstallDir", installDir);
            }
 
            return new DirectoryInfo(installDir);
        }
 
        #endregion
 
    }
}