AcDebug.cs

Go to the documentation of this file.

using System;
using System.Diagnostics;
using System.IO;
using System.Xml.XPath;
using Microsoft.VisualBasic.Logging;

namespace AcUtils
{

    public enum ParamFileCopy
    {
        NoParamFileCopy,
        CopyParmFileTrigTarget,
        CopyParmFileExitSuccess,
        CopyParmFileExitFailure,
        CopyParmFileContinue
    };

    [Serializable]
    public static class AcDebug
    {
        private static readonly string _trigTargetEnvVar = "AccuRevTriggers";

        public static string TrigTargetEnv
        {
            get { return _trigTargetEnvVar; }
        }

        private static readonly string _trigTargetFile = "TriggersTarget.xml";
        // global logging support
        private static FileLogTraceListener _log;
        [NonSerialized] private static readonly object _locker = new object();


        public static bool paramFileCopy(string xmlFile, ParamFileCopy pfcopy, string trigger, string prncpl, string command)
        {
            bool ret = true; // assume success
            try
            {
                if (pfcopy != ParamFileCopy.NoParamFileCopy)
                {
                    if (
                        (pfcopy == ParamFileCopy.CopyParmFileTrigTarget &&
                            entryInTrigTargetsFile(trigger, prncpl)) ||
                        (pfcopy == ParamFileCopy.CopyParmFileContinue) ||
                        (pfcopy == ParamFileCopy.CopyParmFileExitSuccess) ||
                        (pfcopy == ParamFileCopy.CopyParmFileExitFailure)
                        )
                    {
                        string localappdata = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
                        string paramFolder = Path.Combine(localappdata, "AcTools\\Param");
                        if (!Directory.Exists(paramFolder))
                            Directory.CreateDirectory(paramFolder);
                        FileInfo fileInfoXml = new FileInfo(xmlFile);
                        string pFile;
                        if (String.IsNullOrEmpty(command))
                        {
                            // command is null in the case of server_post_promote
                            pFile = String.Format(@"{0}\{1}-{2}-{3}.xml",
                                paramFolder, trigger, prncpl, getStamp());
                        }
                        else
                        {
                            pFile = String.Format(@"{0}\{1}-{2}-{3}-{4}.xml",
                                paramFolder, trigger, command, prncpl, getStamp());
                        }

                        fileInfoXml.CopyTo(pFile, true);
                        if (pfcopy == ParamFileCopy.CopyParmFileExitSuccess)
                            Environment.Exit(0);
                        else if (pfcopy == ParamFileCopy.CopyParmFileExitFailure)
                            Environment.Exit(1);
                    }
                }
            }

            catch (Exception ecx)
            {
                Log($"Exception caught and logged in AcDebug.paramFileCopy(string, ParamFileCopy, string, string, string){Environment.NewLine}{ecx.Message}");
                ret = false;
            }

            return ret;
        }


        public static bool paramFileCopy(ParamFileCopy pfcopy, string xml, string trigger, string prncpl)
        {
            bool ret = true; // assume success
            try
            {
                if (pfcopy != ParamFileCopy.NoParamFileCopy)
                {
                    if (
                        (pfcopy == ParamFileCopy.CopyParmFileTrigTarget &&
                            entryInTrigTargetsFile(trigger, prncpl)) ||
                        (pfcopy == ParamFileCopy.CopyParmFileContinue) ||
                        (pfcopy == ParamFileCopy.CopyParmFileExitSuccess) ||
                        (pfcopy == ParamFileCopy.CopyParmFileExitFailure)
                        )
                    {
                        string localappdata = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
                        string paramFolder = Path.Combine(localappdata, "AcTools\\Param");
                        if (!Directory.Exists(paramFolder))
                            Directory.CreateDirectory(paramFolder);
                        string pFile = String.Format(@"{0}\{1}-{2}-{3}.xml",
                            paramFolder, trigger, prncpl, getStamp());
                        createParamFile(pFile, xml);
                        if (pfcopy == ParamFileCopy.CopyParmFileExitSuccess)
                            Environment.Exit(0);
                        else if (pfcopy == ParamFileCopy.CopyParmFileExitFailure)
                            Environment.Exit(1);
                    }
                }
            }

            catch (Exception ecx)
            {
                Log($"Exception caught and logged in AcDebug.paramFileCopy(ParamFileCopy, string, string, string){Environment.NewLine}{ecx.Message}");
                ret = false;
            }

            return ret;
        }

        private static void createParamFile(string fileName, string content)
        {
            FileStream fs = null;
            try
            {
                if (File.Exists(fileName)) // highly unlikely it would exist but check anyway
                    File.Delete(fileName);

                fs = new FileStream(fileName, FileMode.Create);
                using (StreamWriter sw = new StreamWriter(fs))
                {
                    sw.Write(content);
                }
            }

            catch (Exception exc)
            {
                String msg = String.Format("Exception in AcDebug.createParamFile caught and logged.{0}{1}{0}Filename: {2}{0}{3}",
                    Environment.NewLine, exc.Message, fileName, content);
                Log(msg);
            }

            finally // avoids CA2202: Do not dispose objects multiple times
            {
                if (fs != null) fs.Dispose();
            }
        }

        private static string getStamp()
        {
            string stamp = DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + DateTime.Now.Day.ToString() +
                DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString() +
                DateTime.Now.Millisecond.ToString();
            return stamp;
        }


        private static bool entryInTrigTargetsFile(string trigger, string prncpl)
        {
            try
            {
                string triggersFolder = Environment.GetEnvironmentVariable(_trigTargetEnvVar);
                if (triggersFolder != null) // if the AccuRevTriggers environment variable is set
                {
                    string xmlTriggersFile = Path.Combine(triggersFolder, _trigTargetFile);
                    XPathDocument doc = new XPathDocument(xmlTriggersFile);
                    XPathNavigator nav = doc.CreateNavigator();
                    XPathNodeIterator iterDebug = nav.Select($"Triggers/Trigger[@Name='{trigger}']/Principal");
                    foreach (XPathNavigator iterCmd in iterDebug) // iterate thru all principals in TriggersTarget.xml
                    {
                        string name = iterCmd.GetAttribute("Name", String.Empty);
                        if (String.Equals(prncpl, name))
                        {
                            return true;
                        }
                    }
                }
            }

            catch (XPathException ecx)
            {
                Log($"XPathException in AcDebug.entryInTrigTargetsFile caught and logged.{Environment.NewLine}{ecx.Message}");
            }

            catch (Exception exc)
            {
                String msg = String.Format("Exception in AcDebug.entryInTrigTargetsFile caught and logged.{0}Trigger: {1}{0}Principal: {2}{0}{3}",
                    Environment.NewLine, trigger, prncpl, exc.Message);
                Log(msg);
            }

            return false;
        }


        public static void Log(string message, bool formatting = true)
        {
            lock (_locker)
            {
                Console.WriteLine(message); // to STDOUT and trigger.log
                if (_log != null)
                {
                    if (formatting)
                        // include date/time in our log file and separate each log entry with an empty line
                        _log.WriteLine($"{DateTime.Now.ToString()}{Environment.NewLine}{message}{Environment.NewLine}");
                    else
                        _log.WriteLine(message);
                }
            }
        }


        public static void Log(string message, string xmlParamFile, bool formatting = true)
        {
            Log(message, formatting);
            try
            {
                // Overwrite the XML param file to display our custom message text in the error dialog given
                // to the user. Otherwise, the contents of the XML param file will display (yuck).
                using (StreamWriter writer = new StreamWriter(xmlParamFile, false)) // false to overwrite file
                {
                    writer.WriteLine(message);
                }
            }

            catch (Exception e) // IOException, DirectoryNotFoundException, PathTooLongException, SecurityException... others
            {
                Log($"Unable to overwrite XML param file {xmlParamFile}{Environment.NewLine}{e.Message}");
            }
        }



        public static bool initAcLogging()
        {
            bool ret = false; // assume failure
            try
            {
                // Get root name of our executable for initializing our TraceSource object below.
                // This name must be specified in the application's .config file for logging to work.
                string exeRootName = String.Empty;
                using (Process currentProcess = Process.GetCurrentProcess())
                {
                    ProcessModule pm = currentProcess.MainModule;
                    string module = pm.ModuleName;
                    exeRootName = Path.GetFileNameWithoutExtension(module);
                }

                string localappdata = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
                string logsFolder = Path.Combine(localappdata, "AcTools\\Logs");
                if (!Directory.Exists(logsFolder))
                    Directory.CreateDirectory(logsFolder);

                TraceSource ts = new TraceSource(exeRootName);
                _log = (FileLogTraceListener)ts.Listeners["AcLog"];
                _log.Location = LogFileLocation.Custom;
                _log.CustomLocation = logsFolder;
                // our log file name begins with this name
                _log.BaseFileName = exeRootName;
                // allow log files to grow up to 40 megabytes in size
                //_log.MaxFileSize = 41943040;
                // allow log files to grow up to 80 megabytes in size
                _log.MaxFileSize = 83886080;
                // at least 2.3GB free disk space must exist for logging to continue
                _log.ReserveDiskSpace = 2500000000;
                // use the first day of the current week in the log file name
                _log.LogFileCreationSchedule = LogFileCreationScheduleOption.Weekly;
                // true to make sure we capture data in the event of an exception
                _log.AutoFlush = true;
                ret = true;
            }

            catch (Exception exc)
            {
                Console.WriteLine($"Exception caught in AcDebug.initAcLogging{Environment.NewLine}{exc.Message}");
            }

            return ret;
        }

        public static string getLogFile()
        {
            string logfile = null;
            if (_log != null) // if logging support was initialized
                // referencing FullLogFileName property will create a zero-byte log file if it doesn't exist
                logfile = _log.FullLogFileName;
            return logfile;
        }


        public static void unhandledException(object sender, UnhandledExceptionEventArgs args)
        {
            Exception e = (Exception)args.ExceptionObject;
            AcDebug.Log(e.ToString(), false);
        }

        public static void errorDataHandler(object sendingProcess, DataReceivedEventArgs errLine)
        {
            if (!String.IsNullOrEmpty(errLine.Data))
            {
                string errline = errLine.Data.Trim();
                // Report error if something other than "not in a directory associated with a workspace"
                if (errline.Length > 0 &&
                    !String.Equals("You are not in a directory associated with a workspace", errline))
                {
                    AcDebug.Log(errline);
                }
            }
        }
    }
}