BackupConfiguration.cs

using System;
using System.Reflection;
using System.Threading.Tasks;
using Waher.Networking.HTTP;
using Waher.Runtime.Language;
using Waher.IoTGateway.WebResources;
using Waher.Content;
using System.IO;
 
namespace Waher.IoTGateway.Setup
{
    public class BackupConfiguration : SystemConfiguration
    {
        private static BackupConfiguration instance = null;
 
        private HttpFolderResource exportFolder = null;
        private HttpFolderResource keyFolder = null;
        private StartExport startExport = null;
        private StartAnalyze startAnalyze = null;
        private DeleteExport deleteExport = null;
        private UpdateBackupSettings updateBackupSettings = null;
        private UpdateBackupFolderSettings updateBackupFolderSettings = null;
 
        public static BackupConfiguration Instance => instance;
 
        public override string Resource => "/Settings/Backup.md";
 
        public override int Priority => 175;
 
        public override Task<string> Title(Language Language)
        {
            return Language.GetStringAsync(typeof(Gateway), 7, "Backup");
        }
 
        public override async Task ConfigureSystem()
        {
            await this.UpdateExportFolder(await Export.GetFullExportFolderAsync());
            this.UpdateExportKeyFolder(await Export.GetFullKeyExportFolderAsync());
        }
 
        public override void SetStaticInstance(ISystemConfiguration Configuration)
        {
            instance = Configuration as BackupConfiguration;
        }
 
        public override async Task InitSetup(HttpServer WebServer)
        {
            HttpAuthenticationScheme Auth = Gateway.LoggedIn(new string[] { this.ConfigPrivilege });
 
            WebServer.Register(this.exportFolder = new HttpFolderResource("/Export", await Export.GetFullExportFolderAsync(), false, false, false, true, HostDomainOptions.SameForAllDomains, Auth));
            WebServer.Register(this.keyFolder = new HttpFolderResource("/Key", await Export.GetFullKeyExportFolderAsync(), false, false, false, true, HostDomainOptions.SameForAllDomains, Auth));
            WebServer.Register(this.startExport = new StartExport());
            WebServer.Register(this.startAnalyze = new StartAnalyze());
            WebServer.Register(this.deleteExport = new DeleteExport());
            WebServer.Register(this.updateBackupSettings = new UpdateBackupSettings());
            WebServer.Register(this.updateBackupFolderSettings = new UpdateBackupFolderSettings());
 
            await base.InitSetup(WebServer);
        }
 
        protected override string ConfigPrivilege => "Admin.Data.Backup";
 
        public override Task UnregisterSetup(HttpServer WebServer)
        {
            WebServer.Unregister(this.exportFolder);
            WebServer.Unregister(this.keyFolder);
            WebServer.Unregister(this.startExport);
            WebServer.Unregister(this.startAnalyze);
            WebServer.Unregister(this.deleteExport);
            WebServer.Unregister(this.updateBackupSettings);
            WebServer.Unregister(this.updateBackupFolderSettings);
 
            return base.UnregisterSetup(WebServer);
        }
 
        internal async Task UpdateExportFolder(string Folder)
        {
            if (!(this.exportFolder is null))
                this.exportFolder.FolderPath = Folder;
 
            if (!(Gateway.InternalDatabase is null))
            {
                Type T = Gateway.InternalDatabase.GetType();
                PropertyInfo PI = T.GetProperty("AutoRepairReportFolder");
 
                if (!(PI is null) && PI.PropertyType == typeof(string))
                    PI.SetValue(Gateway.InternalDatabase, await Export.GetFullExportFolderAsync(), null);
            }
        }
 
        internal void UpdateExportKeyFolder(string Folder)
        {
            if (!(this.keyFolder is null))
                this.keyFolder.FolderPath = Folder;
        }
 
        public override Task<bool> SimplifiedConfiguration()
        {
            return Task.FromResult(true);
        }
 
        public const string GATEWAY_BACKUP = nameof(GATEWAY_BACKUP);
 
        public const string GATEWAY_BACKUP_TIME = nameof(GATEWAY_BACKUP_TIME);
 
        public const string GATEWAY_BACKUP_DAYS = nameof(GATEWAY_BACKUP_DAYS);
 
        public const string GATEWAY_BACKUP_MONTHS = nameof(GATEWAY_BACKUP_MONTHS);
 
        public const string GATEWAY_BACKUP_YEARS = nameof(GATEWAY_BACKUP_YEARS);
 
        public const string GATEWAY_BACKUP_FOLDER = nameof(GATEWAY_BACKUP_FOLDER);
 
        public const string GATEWAY_KEY_FOLDER = nameof(GATEWAY_KEY_FOLDER);
 
        public const string GATEWAY_BACKUP_HOSTS = nameof(GATEWAY_BACKUP_HOSTS);
 
        public const string GATEWAY_KEY_HOSTS = nameof(GATEWAY_KEY_HOSTS);
 
        public override async Task<bool> EnvironmentConfiguration()
        {
            if (!this.TryGetEnvironmentVariable(GATEWAY_BACKUP, false, out bool Backup))
                return false;
 
            if (!Backup)
                return true;
 
            await Export.SetAutomaticBackupsAsync(true);
 
            string s = Environment.GetEnvironmentVariable(GATEWAY_BACKUP_TIME);
            if (!string.IsNullOrEmpty(s))
            {
                if (!TimeSpan.TryParse(s, out TimeSpan BackupTime) || BackupTime < TimeSpan.Zero || BackupTime.TotalHours >= 24)
                {
                    this.LogEnvironmentVariableInvalidTimeError(GATEWAY_BACKUP_TIME, s);
                    return false;
                }
 
                await Export.SetBackupTimeAsync(BackupTime);
            }
 
            s = Environment.GetEnvironmentVariable(GATEWAY_BACKUP_DAYS);
            if (!string.IsNullOrEmpty(s))
            {
                if (!int.TryParse(s, out int i) || i < 0)
                {
                    this.LogEnvironmentVariableInvalidIntegerError(GATEWAY_BACKUP_DAYS, s);
                    return false;
                }
 
                await Export.SetKeepDaysAsync(i);
            }
 
            s = Environment.GetEnvironmentVariable(GATEWAY_BACKUP_MONTHS);
            if (!string.IsNullOrEmpty(s))
            {
                if (!int.TryParse(s, out int i) || i < 0)
                {
                    this.LogEnvironmentVariableInvalidIntegerError(GATEWAY_BACKUP_MONTHS, s);
                    return false;
                }
 
                await Export.SetKeepMonthsAsync(i);
            }
 
            s = Environment.GetEnvironmentVariable(GATEWAY_BACKUP_YEARS);
            if (!string.IsNullOrEmpty(s))
            {
                if (!int.TryParse(s, out int i) || i < 0)
                {
                    this.LogEnvironmentVariableInvalidIntegerError(GATEWAY_BACKUP_YEARS, s);
                    return false;
                }
 
                await Export.SetKeepYearsAsync(i);
            }
 
            if (this.TryGetEnvironmentVariable(GATEWAY_BACKUP_FOLDER, false, out s))
            {
                try
                {
                    if (!Directory.Exists(s))
                        Directory.CreateDirectory(s);
            
                    await Export.SetExportFolderAsync(s);
                }
                catch (Exception ex)
                {
                    this.LogEnvironmentError(ex.Message, GATEWAY_BACKUP_FOLDER, s);
                }
            }
 
            s = Environment.GetEnvironmentVariable(GATEWAY_KEY_FOLDER);
            if (!string.IsNullOrEmpty(s))
            {
                try
                {
                    if (!Directory.Exists(s))
                        Directory.CreateDirectory(s);
 
                    await Export.SetExportKeyFolderAsync(s);
                }
                catch (Exception ex)
                {
                    this.LogEnvironmentError(ex.Message, GATEWAY_KEY_FOLDER, s);
                }
            }
 
            s = Environment.GetEnvironmentVariable(GATEWAY_BACKUP_HOSTS);
            if (!string.IsNullOrEmpty(s))
                await Export.SetBackupHostsAsync(s.Split(','));
 
            s = Environment.GetEnvironmentVariable(GATEWAY_KEY_HOSTS);
            if (!string.IsNullOrEmpty(s))
                await Export.SetKeyHostsAsync(s.Split(','));
 
            return true;
        }
 
    }
}