StartAnalyze.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Xsl;
using Waher.Content;
using Waher.Content.Text;
using Waher.Content.Xml;
using Waher.Content.Xsl;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Runtime.IO;
 
namespace Waher.IoTGateway.WebResources
{
    public class StartAnalyze : HttpSynchronousResource, IHttpPostMethod
    {
        public StartAnalyze()
            : base("/StartAnalyze")
        {
        }
 
        public override bool HandlesSubPaths
        {
            get
            {
                return false;
            }
        }
 
        public override bool UserSessions
        {
            get
            {
                return true;
            }
        }
 
        public bool AllowsPOST => true;
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            Gateway.AssertUserAuthenticated(Request, "Admin.Data.Backup");
 
            if (!Request.HasData)
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            ContentResponse Content = await Request.DecodeDataAsync();
            if (Content.HasError || !(Content.Decoded is Dictionary<string, object> Parameters))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Parameters.TryGetValue("repair", out object Obj) || !(Obj is bool Repair))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!CanStartAnalyzeDB())
            {
                Response.StatusCode = 409;
                Response.StatusMessage = "Conflict";
                Response.ContentType = PlainTextCodec.DefaultContentType;
                await Response.Write("Analysis is underway.");
            }
 
            string BasePath = await Export.GetFullExportFolderAsync();
            if (!Directory.Exists(BasePath))
                Directory.CreateDirectory(BasePath);
 
            BasePath += Path.DirectorySeparatorChar;
 
            string FullFileName = Path.Combine(BasePath, "DBReport " + DateTime.Now.ToString("yyyy-MM-dd HH_mm_ss"));
            FullFileName = await StartExport.GetUniqueFileName(FullFileName, ".xml");
            FileStream fs = null;
 
            try
            {
                fs = new FileStream(FullFileName, FileMode.Create, FileAccess.Write);
                DateTime Created = File.GetCreationTime(FullFileName);
                XmlWriter XmlOutput = XmlWriter.Create(fs, XML.WriterSettings(true, false));
                string FileName = FullFileName[BasePath.Length..];
 
                Task _ = Task.Run(() => DoAnalyze(FullFileName, FileName, Created, XmlOutput, fs, Repair));
 
                Response.StatusCode = 200;
                Response.StatusMessage = "OK";
                Response.ContentType = PlainTextCodec.DefaultContentType;
                await Response.Write(FileName);
                await Response.SendResponse();
            }
            catch (Exception ex)
            {
                if (!(fs is null))
                {
                    fs.Dispose();
                    File.Delete(FullFileName);
                }
 
                await Response.SendResponse(ex);
            }
        }
 
        public static bool CanStartAnalyzeDB()
        {
            lock (synchObject)
            {
                if (analyzing)
                    return false;
 
                analyzing = true;
            }
 
            return true;
        }
 
        private static bool analyzing = false;
        private static readonly object synchObject = new object();
        private static XslCompiledTransform xslt = null;
 
        public static async Task<string[]> DoAnalyze(string FullPath, string FileName, DateTime Created, XmlWriter XmlOutput, FileStream fs, bool Repair)
        {
            string[] Collections = null;
 
            try
            {
                Log.Informational("Starting analyzing database.", FileName);
 
                ExportFormats.ExportFormat.UpdateClientsFileUpdated(FileName, 0, Created);
 
                Collections = await Database.Analyze(XmlOutput, Path.Combine(Gateway.AppDataFolder, "Transforms", "DbStatXmlToHtml.xslt"), 
                    Gateway.AppDataFolder, false, Repair);
 
                XmlOutput.Flush();
                fs.Flush();
 
                ExportFormats.ExportFormat.UpdateClientsFileUpdated(FileName, fs.Length, Created);
 
                XmlOutput.Dispose();
                XmlOutput = null;
 
                fs.Dispose();
                fs = null;
 
                xslt ??= XSL.LoadTransform(typeof(Gateway).Namespace + ".Transforms.DbStatXmlToHtml.xslt");
 
                string s = await Files.ReadAllTextAsync(FullPath);
                s = XSL.Transform(s, xslt);
                byte[] Bin = Strings.Utf8WithBom.GetBytes(s);
 
                string FullPath2 = FullPath[..^4] + ".html";
                await Files.WriteAllBytesAsync(FullPath2, Bin);
 
                ExportFormats.ExportFormat.UpdateClientsFileUpdated(FileName[..^4] + ".html", Bin.Length, Created);
 
                Log.Informational("Database analysis successfully completed.", FileName);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
 
                string[] Tabs = ClientEvents.GetTabIDsForLocation("/Settings/Backup.md");
                await ClientEvents.PushEvent(Tabs, "BackupFailed", "{\"fileName\":\"" + CommonTypes.JsonStringEncode(FileName) +
                    "\", \"message\": \"" + CommonTypes.JsonStringEncode(ex.Message) + "\"}", true, "User");
            }
            finally
            {
                try
                {
                    XmlOutput?.Dispose();
                    fs?.Dispose();
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
 
                lock (synchObject)
                {
                    analyzing = false;
                }
            }
 
            return Collections;
        }
 
    }
}