/Duplicati/Scheduler/RunBackup/RunBackup.cs

#region Disclaimer / License

// Copyright (C) 2011, Kenneth Bergeron, IAP Worldwide Services, Inc

// NOAA :: National Marine Fisheries Service

// 

// This library is free software; you can redistribute it and/or

// modify it under the terms of the GNU Lesser General Public

// License as published by the Free Software Foundation; either

// version 2.1 of the License, or (at your option) any later version.

// 

// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

// Lesser General Public License for more details.

// 

// You should have received a copy of the GNU Lesser General Public

// License along with this library; if not, write to the Free Software

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

// 

#endregion

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

// This is a x86 exe - If you are using Express, see this:

// http://social.msdn.microsoft.com/Forums/en-US/Vsexpressvcs/thread/4650481d-b385-43f3-89c7-c07546a7f7cd

//

//[assembly: System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.RequestMinimum, Name = "FullTrust")]

namespace Duplicati.Scheduler.RunBackup

{

    class Program

    {

        /// <summary>

        /// The name of the mother package

        /// </summary>

        public const string Package = "Duplicati";

        /// <summary>

        /// Name of application

        /// </summary>

        public const string Name = "Duplicati.RunBackup";

        /// <summary>

        /// Root name of named pipe

        /// </summary>

        public const string PipeBaseName = "Duplicati.Pipe";

        /// <summary>

        /// Name of the Pipe client listener thread

        /// </summary>

        public const string ClientThreadName = "Duplicati.PipeClient";

        /// <summary>

        /// Where Monitor plugins live

        /// </summary>

        public static string StartupPath = 

            System.IO.Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName);



        /// <summary>

        /// Name of this job

        /// </summary>

        public static string Job = "<none>";

        /// <summary>

        /// If set via command line argument "DryRun", no backup is actually made; used for debug

        /// </summary>

        private static bool itsDryRun = false;

        /// <summary>

        /// This is basically a very small Duplicati command line that only supports backup.

        /// This is a console app; but compiled with 'forms' to get rid of the dreaded console window in xp.

        /// </summary>

        /// <param name="aArgs">Arguments are job name and XML file name</param>

        static void Main(string[] aArgs)

        {

            // Args as a handy list

            List<string> ArgList = new List<string>(aArgs);

#if DEBUGUSER

            if (!Environment.UserInteractive) 

                System.Threading.Thread.Sleep(20000); // Give time to attach debugger

            if (!Environment.UserName.EndsWith("\\User"))

            {

                // TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST 

                Utility.Su.Impersonate("User", Environment.UserDomainName, "asd");  // TEST

                Environment.SetEnvironmentVariable("TMP", "C:\\temp"); // TEST

            }

#endif

            if (ArgList.Count == 0)

            {

                System.Windows.Forms.MessageBox.Show("This program must be executed with a job name and should not be executed manually");

                return;

            }



            itsDryRun = ArgList.Contains("DryRun"); // Good for debugging

            if(itsDryRun) ArgList.Remove("DryRun");

            // The job name

            Job = ArgList[0];



            // Be nice

            System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.BelowNormal;

            // Get a log file

            string LogFile = Duplicati.Scheduler.Utility.Tools.LogFileName(Package);

            using (new Notifier())  // Attempt to put that little thingy in the tray

            // Create the log

            using (Duplicati.Library.Logging.AppendLog Log = new Duplicati.Library.Logging.AppendLog(LogFile, Job))

            {

                Duplicati.Library.Logging.Log.CurrentLog = Log;

                // Hard code level to info, deal with filters in the forms level

                Duplicati.Library.Logging.Log.LogLevel = Duplicati.Library.Logging.LogMessageType.Information;

#if !DEBUG

                try

#endif

                {

                    // Load the history XML dataset

                    using (Duplicati.Scheduler.Data.HistoryDataSet hds = new Duplicati.Scheduler.Data.HistoryDataSet())

                    {

                        hds.Load();

                        // Create a new history record for this run

                        Duplicati.Scheduler.Data.HistoryDataSet.HistoryRow HistoryRow = hds.History.AddHistoryRow(Job, DateTime.Now, "Backup", true, false, LogFile, new byte[0], string.Empty);

                        // Actually run the job

                        RunBackup(ArgList.ToArray(), HistoryRow);

                        // Just clean out history

                        foreach (Duplicati.Scheduler.Data.HistoryDataSet.HistoryRow Row in 

                            from Duplicati.Scheduler.Data.HistoryDataSet.HistoryRow qR in hds.History 

                            where !System.IO.File.Exists(qR.LogFileName) select qR)

                                Row.Delete();

                        hds.Save();     // Save the XML (later: make so the whole db need not be loaded (XMLReader)

                    }

                }

#if !DEBUG

                catch (Exception Ex)        // Log error

                {

                    Library.Logging.Log.WriteMessage(Ex.Message, Duplicati.Library.Logging.LogMessageType.Error);

                }

#endif

                UpdateMonitors(LogFile);

                // All done, set the log file (filewathers are looking for AttributeChange)

                System.IO.File.SetAttributes(LogFile, System.IO.FileAttributes.ReadOnly);

            }

        }

        /// <summary>

        /// Update any Monitor plugins

        /// </summary>

        /// <param name="aLogFile"></param>

        private static void UpdateMonitors(string aLogFile)

        {

            // Each plugin

            foreach(string Plug in System.IO.Directory.GetFiles(StartupPath, "Duplicati.Scheduler.Monitor.*.dll"))

            {

                // Load the assembly, get the type, create an instance

                System.Reflection.Assembly Ass = System.Reflection.Assembly.LoadFile(Plug);

                Type ClassType = Ass.GetTypes().Where(qR=>qR.Name == "Plugin").First();

                Duplicati.Scheduler.Data.IMonitorPlugin Monitor = Activator.CreateInstance(ClassType, null) as Duplicati.Scheduler.Data.IMonitorPlugin;

                if (Monitor != null && (DisabledMonitors == null || !DisabledMonitors.Contains(Monitor.Name)))

                {

                    // Tell big brother

                    Exception phEx = 

#if !DEBUG

                        Utility.Tools.TryCatch((Action)delegate()

#else

                        null;

#endif

                    {

                        // Update the scheduler

                        Monitor.UpdateScheduler(Duplicati.Scheduler.Data.SchedulerDataSet.DefaultPath());

                        // Update the history

                        Monitor.UpdateHistory(Duplicati.Scheduler.Data.HistoryDataSet.DefaultPath());

                        // Update the log file

                        Monitor.UpdateLog(System.IO.File.GetLastWriteTime(aLogFile), Duplicati.Library.Logging.AppendLog.LogFileToXML(aLogFile));

                    }

#if !DEBUG

                    );

#endif

                    if (phEx != null)

                        Library.Logging.Log.WriteMessage("Monitor Update failed "+Monitor.Name, 

                            Duplicati.Library.Logging.LogMessageType.Warning, phEx);

                }

            }

        }

        private static string[] DisabledMonitors = null;

        private static bool RunBackup(string[] args, Duplicati.Scheduler.Data.HistoryDataSet.HistoryRow aHistoryRow)

        {

            // Log the start

            Library.Logging.Log.WriteMessage(Name + " " + String.Join(" ", args) + (itsDryRun ? " DryRun as" : " as ") + Duplicati.Scheduler.Utility.User.UserName,

                Duplicati.Library.Logging.LogMessageType.Information);



            // See if the XML file name was on the command line

            string XML = (args.Length > 1) ? XML = args[1] : Duplicati.Scheduler.Data.SchedulerDataSet.DefaultPath();

            // Convert our options to Duplicati options

            Options BackupOptions = new Options(Job, XML);

            // Get disabled monitors

            DisabledMonitors = BackupOptions.DisabledMonitors;

            // Complain about any results from the drive mapping

            if (!string.IsNullOrEmpty(BackupOptions.MapResults))

                Library.Logging.Log.WriteMessage(BackupOptions.MapResults, Duplicati.Library.Logging.LogMessageType.Information);



            // Get the signature file temp

            Duplicati.Library.Utility.TempFolder SigTemp = new Duplicati.Library.Utility.TempFolder();

            string SigThingy = System.IO.Path.Combine(SigTemp, Duplicati.Scheduler.Data.SchedulerDataSet.DefaultName);

            if (Duplicati.Scheduler.Utility.Tools.NoException((Action)delegate() { System.IO.File.Copy(Duplicati.Scheduler.Data.SchedulerDataSet.DefaultPath(), SigThingy); }))

                BackupOptions["signature-control-files"] = SigThingy;



            // See if there is a pipe server listening, if so, connect to it for progress messages

            bool HasPipe = Duplicati.Scheduler.Utility.NamedPipeServerStream.ServerIsUp(

                Duplicati.Scheduler.Utility.NamedPipeServerStream.MakePipeName(PipeBaseName, Duplicati.Scheduler.Utility.User.UserName, System.IO.Pipes.PipeDirection.In));

            if (HasPipe) Pipe.Connecter();

            // Run the dern thing already

            string Result = "Not started";

            bool OK = false;

            if (itsDryRun)

            {

                OK = true;

                Result = "DryRun";

                if(HasPipe) TestProgress(5); // Just send fake progress

            }

            else

            {

                try

                {

                    using (Duplicati.Library.Main.Interface i = new Duplicati.Library.Main.Interface(BackupOptions.Target, BackupOptions))

                    {

                        // Set our events if we have a pipe

                        if (HasPipe)

                        {

                            i.OperationProgress += new Duplicati.Library.Main.OperationProgressEvent(Pipe.OperationProgress);

                            i.OperationCompleted += new Duplicati.Library.Main.OperationProgressEvent(Pipe.OperationProgress);

                        }

                        Result = i.Backup(BackupOptions.Source);

                    }

                    OK = true;

                }

                catch (Exception Ex)

                {

                    // Dang

                    Result = "Error: " + Ex.Message;

                }

            }

            // Log the done.

            Library.Logging.Log.WriteMessage("Finished: "+(OK?"OK":Result), OK ? Duplicati.Library.Logging.LogMessageType.Information : Duplicati.Library.Logging.LogMessageType.Error);

            // Put deletions in the log, where they belong.

            // Deleting backup at 07/06/2011 06:05:21

            foreach(string Line in Result.Split('\n'))

                if (Line.StartsWith("Deleting backup at "))

                    Library.Logging.Log.WriteMessage(Line, Duplicati.Library.Logging.LogMessageType.Information);

            // OK, made it, update the history

            aHistoryRow.Update("Backup", BackupOptions.Full, OK, Result, BackupOptions.Checksum, BackupOptions.CheckMod);

            LimitLogFiles(BackupOptions.LogFileMaxAgeDays); // zero has no effect.

            // woot

            return OK;

        }

        /// <summary>

        /// Delete old log files

        /// </summary>

        /// <param name="aMaxDays">Number of days to keep logs (0=always)</param>

        private static void LimitLogFiles(int aMaxDays)

        {

            if (aMaxDays <= 0) return;

            foreach (string Entry in System.IO.Directory.GetFiles(Duplicati.Scheduler.Utility.Tools.LogFileDirectory(Package), Duplicati.Scheduler.Utility.Tools.LogFileFilter))

            {

                if ((DateTime.Now - (new System.IO.FileInfo(Entry).LastWriteTime)).TotalDays > aMaxDays)

                    Duplicati.Scheduler.Utility.Tools.TryCatch((Action)delegate()

                        {

                            System.IO.File.SetAttributes(Entry, System.IO.FileAttributes.Normal);

                            System.IO.File.Delete(Entry);

                        });

            }

        }

        private static void TestProgress(int aSeconds)

        {

            Job = "PipeTest";

            Debug.WriteLine(Job);

            for (int i = 0; i<aSeconds*2 ; i++)

            {

                int P = (i % 100);

                Pipe.OperationProgress(null, Duplicati.Library.Main.DuplicatiOperation.Backup, Duplicati.Library.Main.DuplicatiOperationMode.Backup,

                    P, P, "test:" + P.ToString(), P.ToString());

                System.Threading.Thread.Sleep(500);

            }

        }

    }

}