Пример #1
0
        void Runner_XervBackupProgress(XervBackup.Library.Main.XervBackupOperation operation, XervBackupRunner.RunnerState state, string message, string submessage, int progress, int subprogress)
        {
            if (this.InvokeRequired)
                this.Invoke(new XervBackupRunner.ProgressEventDelegate(Runner_XervBackupProgress), operation, state, message, submessage, progress, subprogress);
            else
            {
                WorkProgressbar.Visible = ProgressMessage.Visible = state != XervBackupRunner.RunnerState.Stopped;
                WorkProgressbar.Style = progress < 0 ? ProgressBarStyle.Marquee : ProgressBarStyle.Blocks;
                WorkProgressbar.Value = Math.Max(Math.Min(WorkProgressbar.Maximum, progress), WorkProgressbar.Minimum);
                ProgressMessage.Text = message;
                toolTip1.SetToolTip(SubProgressBar, submessage);

                SubProgressBar.Value = Math.Max(Math.Min(SubProgressBar.Maximum, subprogress), SubProgressBar.Minimum);
                if (!SubProgressBar.Visible && subprogress >= 0)
                    ProgressMessage_TextChanged(null, null);
                SubProgressBar.Visible = subprogress >= 0;

                toolTip1.SetToolTip(ProgressMessage, ProgressMessage.Text);
                toolTip1.SetToolTip(WorkProgressbar, ProgressMessage.Text);
            }
        }
Пример #2
0
        static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            //If we are on Windows, append the bundled "win-tools" programs to the search path
            //We add it last, to allow the user to override with other versions
            if (!Library.Utility.Utility.IsClientLinux)
            {
                string wintools = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "win-tools");
                Environment.SetEnvironmentVariable("PATH",
                    Environment.GetEnvironmentVariable("PATH") +
                    System.IO.Path.PathSeparator.ToString() +
                    wintools +
                    System.IO.Path.PathSeparator.ToString() +
                    System.IO.Path.Combine(wintools, "gpg") //GPG needs to be in a subfolder for wrapping reasons
                );
            }

            Library.Utility.UrlUtillity.ErrorHandler = new XervBackup.Library.Utility.UrlUtillity.ErrorHandlerDelegate(DisplayURLOpenError);

            //If we are on windows we encrypt the database by default
            //We do not encrypt on Linux as most distros use a SQLite library without encryption support,
            //Linux users can use an encrypted home folder, or install a SQLite library with encryption support
            if (!Library.Utility.Utility.IsClientLinux && string.IsNullOrEmpty(Environment.GetEnvironmentVariable(DB_KEY_ENV_NAME)))
            {
                //Note that the password here is a default password and public knowledge
                //
                //The purpose of this is to prevent casual read of the database, as well
                // as protect from harddisk string scans, not to protect from determined
                // attacks.
                //
                //If you desire better security, start XervBackup once with the commandline option
                // --unencrypted-database to decrypt the database.
                //Then set the environment variable XERVBACKUP_DB_KEY to the desired key,
                // and run XervBackup again without the --unencrypted-database option
                // to re-encrypt it with the new key
                //
                //If you change the key, please note that you need to supply the same
                // key when restoring the setup, as the setup being backed up will
                // be encrypted as well.
                Environment.SetEnvironmentVariable(DB_KEY_ENV_NAME, "XervBackup_Key_42");
            }

            //Find commandline options here for handling special startup cases
            Dictionary<string, string> commandlineOptions = CommandLine.CommandLineParser.ExtractOptions(new List<string>(args));

            foreach (string s in args)
                if (
                    s.Equals("help", StringComparison.InvariantCultureIgnoreCase) ||
                    s.Equals("/help", StringComparison.InvariantCultureIgnoreCase) ||
                    s.Equals("usage", StringComparison.InvariantCultureIgnoreCase) ||
                    s.Equals("/usage", StringComparison.InvariantCultureIgnoreCase))
                    commandlineOptions["help"] = "";

            //If the commandline issues --help, just stop here
            if (commandlineOptions.ContainsKey("help"))
            {
                List<string> lines = new List<string>();
                foreach (Library.Interface.ICommandLineArgument arg in SupportedCommands)
                    lines.Add(string.Format(Strings.Program.HelpDisplayFormat, arg.Name, arg.LongDescription));
                MessageBox.Show(string.Format(Strings.Program.HelpDisplayDialog, string.Join(Environment.NewLine, lines.ToArray())), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if (commandlineOptions.ContainsKey("trayless"))
                Program.TraylessMode = Library.Utility.Utility.ParseBoolOption(commandlineOptions, "trayless");

            #if DEBUG
            //Log various information in the logfile
            if (!commandlineOptions.ContainsKey("log-file"))
            {
                commandlineOptions["log-file"] = System.IO.Path.Combine(Application.StartupPath, "XervBackup.debug.log");
                commandlineOptions["log-level"] = XervBackup.Library.Logging.LogMessageType.Profiling.ToString();
            }
            #endif

            if (commandlineOptions.ContainsKey("log-level"))
                foreach (string s in Enum.GetNames(typeof(XervBackup.Library.Logging.LogMessageType)))
                    if (s.Equals(commandlineOptions["log-level"].Trim(), StringComparison.InvariantCultureIgnoreCase))
                        XervBackup.Library.Logging.Log.LogLevel = (XervBackup.Library.Logging.LogMessageType)Enum.Parse(typeof(XervBackup.Library.Logging.LogMessageType), s);

            if (commandlineOptions.ContainsKey("log-file"))
            {
                if (System.IO.File.Exists(commandlineOptions["log-file"]))
                    System.IO.File.Delete(commandlineOptions["log-file"]);
                XervBackup.Library.Logging.Log.CurrentLog = new XervBackup.Library.Logging.StreamLog(commandlineOptions["log-file"]);
            }

            //Set the %XERVBACKUP_HOME% env variable, if it is not already set
            if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable(DATAFOLDER_ENV_NAME)))
            {
            #if DEBUG
                //debug mode uses a lock file located in the app folder
                Environment.SetEnvironmentVariable(DATAFOLDER_ENV_NAME, System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location));
            #else
                bool portableMode = Library.Utility.Utility.ParseBoolOption(commandlineOptions, "portable-mode");

                if (portableMode)
                {
                    //Portable mode uses a data folder in the application home dir
                    Environment.SetEnvironmentVariable(DATAFOLDER_ENV_NAME, System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "data"));
                }
                else
                {
                    //Normal release mode uses the systems "Application Data" folder
                    Environment.SetEnvironmentVariable(DATAFOLDER_ENV_NAME, System.IO.Path.Combine(System.Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), Application.ProductName));
                }
            #endif
            }

            try
            {
                try
                {
                    //This will also create Program.DATAFOLDER if it does not exist
                    SingleInstance = new SingleInstance(Application.ProductName, Program.DATAFOLDER);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(string.Format(Strings.Program.StartupFailure, ex.ToString()), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                if (!SingleInstance.IsFirstInstance)
                {
                    //Linux shows this output
                    Console.WriteLine(Strings.Program.AnotherInstanceDetected);
                    return;
                }

                Version sqliteVersion = new Version((string)SQLiteLoader.SQLiteConnectionType.GetProperty("SQLiteVersion").GetValue(null, null));
                if (sqliteVersion < new Version(3, 6, 3))
                {
                    //The official Mono SQLite provider is also broken with less than 3.6.3
                    MessageBox.Show(string.Format(Strings.Program.WrongSQLiteVersion, sqliteVersion, "3.6.3"), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                //Create the connection instance
                System.Data.IDbConnection con = (System.Data.IDbConnection)Activator.CreateInstance(SQLiteLoader.SQLiteConnectionType);

                try
                {
            #if DEBUG
                    //Default is to not use encryption for debugging
                    Program.UseDatabaseEncryption = commandlineOptions.ContainsKey("unencrypted-database") ? !Library.Utility.Utility.ParseBoolOption(commandlineOptions, "unencrypted-database") : false;
            #else
                    //Default is to use encryption for release
                    Program.UseDatabaseEncryption = !Library.Utility.Utility.ParseBoolOption(commandlineOptions, "unencrypted-database");
            #endif

                    OpenSettingsDatabase(con, Program.DATAFOLDER);
                }
                catch (Exception ex)
                {
                    //Unwrap the reflection exceptions
                    if (ex is System.Reflection.TargetInvocationException && ex.InnerException != null)
                        ex = ex.InnerException;

                    MessageBox.Show(string.Format(Strings.Program.DatabaseOpenError, ex.Message), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                DataConnection = new DataFetcherWithRelations(new SQLiteDataProvider(con));

                string displayLanguage = new Datamodel.ApplicationSettings(DataConnection).DisplayLanguage;
                if (!string.IsNullOrEmpty(displayLanguage) && displayLanguage != Library.Utility.Utility.DefaultCulture.Name)
                {
                    try
                    {
                        System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.GetCultureInfo(displayLanguage);
                        System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.GetCultureInfo(displayLanguage);
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(string.Format(Strings.Program.LanguageSelectionError, ex.Message), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
                        //This is non-fatal, just keep running with system default language
                    }
                }

                try
                {
                    DataFetcherNested logcon = new DataFetcherNested(DataConnection);
                    Log[] items = logcon.GetObjects<Log>("Subaction LIKE ?", "InProgress");
                    if (items != null && items.Length > 0)
                    {
                        foreach (Log l in items)
                            l.SubAction = "Primary";

                        logcon.CommitAllRecursive();
                    }
                }
                catch
                {
                    //Non-fatal but any interrupted backup will not show
                }

                LiveControl = new LiveControls(new ApplicationSettings(DataConnection));
                LiveControl.StateChanged += new EventHandler(LiveControl_StateChanged);
                LiveControl.ThreadPriorityChanged += new EventHandler(LiveControl_ThreadPriorityChanged);
                LiveControl.ThrottleSpeedChanged += new EventHandler(LiveControl_ThrottleSpeedChanged);

                Runner = new XervBackupRunner();
                WorkThread = new WorkerThread<IDuplicityTask>(new WorkerThread<IDuplicityTask>.ProcessItemDelegate(Runner.ExecuteTask), LiveControl.State == LiveControls.LiveControlState.Paused);
                Scheduler = new Scheduler(DataConnection, WorkThread, MainLock);

                DataConnection.AfterDataConnection += new DataConnectionEventHandler(DataConnection_AfterDataConnection);

                DisplayHelper = new MainForm();
                DisplayHelper.InitialArguments = args;

                Program.IsRunningMainLoop = true;
                Application.Run(DisplayHelper);
                Program.IsRunningMainLoop = false;
            }
            catch (Exception ex)
            {
                //If the helper thread aborts the main thread, it also sets IsRunningMainLoop to false
                // and in that case we accept the abort call
                if (ex is System.Threading.ThreadAbortException && !Program.IsRunningMainLoop)
                    System.Threading.Thread.ResetAbort();
                else
                    MessageBox.Show(string.Format(Strings.Program.SeriousError, ex.ToString()), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            try
            {
                //Find logs that are no longer displayed, and delete them
                DataFetcherNested con = new DataFetcherNested(DataConnection);
                foreach (Log x in con.GetObjects<Log>("EndTime < ?", Library.Utility.Timeparser.ParseTimeInterval(new ApplicationSettings(con).RecentBackupDuration, DateTime.Now, true)))
                {
                    if (x.Blob != null) //Load the blob part if required
                        con.DeleteObject(x.Blob);
                    con.DeleteObject(x);
                }

                con.CommitAllRecursive();
            }
            catch
            { }

            try
            {
                //Compact the database
                using (System.Data.IDbCommand vaccum_cmd = DataConnection.Provider.Connection.CreateCommand())
                {
                    vaccum_cmd.CommandText = "VACUUM;";
                    vaccum_cmd.ExecuteNonQuery();
                }
            }
            catch
            { }

            if (Scheduler != null)
                Scheduler.Terminate(true);
            if (WorkThread != null)
                WorkThread.Terminate(true);
            if (SingleInstance != null)
                SingleInstance.Dispose();

            #if DEBUG
            using(XervBackup.Library.Logging.Log.CurrentLog as XervBackup.Library.Logging.StreamLog)
                XervBackup.Library.Logging.Log.CurrentLog = null;
            #endif
        }
Пример #3
0
        void Runner_XervBackupProgress(XervBackup.Library.Main.XervBackupOperation operation, XervBackupRunner.RunnerState state, string message, string submessage, int progress, int subprogress)
        {
            if (this.InvokeRequired)
            {
                this.BeginInvoke(new XervBackupRunner.ProgressEventDelegate(Runner_XervBackupProgress), operation, state, message, submessage, progress, subprogress);
                return;
            }

            string name = "";

            //Dirty read of the instance variable
            try { name = Program.WorkThread.CurrentTask.Schedule.Name; }
            catch { }

            Datamodel.ApplicationSettings.NotificationLevel level;
            try { level = m_settings.BallonNotificationLevel; }
            catch
            {
                m_settings = new Datamodel.ApplicationSettings(Program.DataConnection);
                try { level = m_settings.BallonNotificationLevel; }
                catch
                {
                    //TODO: Should find the cause for this, but at least we do not crash the process
                    return;
                }
            }

            if (state == XervBackupRunner.RunnerState.Started && (level == XervBackup.Datamodel.ApplicationSettings.NotificationLevel.StartAndStop || level == XervBackup.Datamodel.ApplicationSettings.NotificationLevel.Start || level == XervBackup.Datamodel.ApplicationSettings.NotificationLevel.Continous))
            {
                //Show start balloon
                m_trayIcon.ShowBalloonTip(BALLOON_SHOW_TIME, Application.ProductName, String.Format(Strings.MainForm.BalloonTip_Started, name), ToolTipIcon.Info);
            }
            else if (state == XervBackupRunner.RunnerState.Stopped && (level == XervBackup.Datamodel.ApplicationSettings.NotificationLevel.StartAndStop || level == XervBackup.Datamodel.ApplicationSettings.NotificationLevel.Continous))
            {
                //Show stop balloon
                m_trayIcon.ShowBalloonTip(BALLOON_SHOW_TIME, Application.ProductName, String.Format(Strings.MainForm.BalloonTip_Stopped, name), ToolTipIcon.Info);
            }
            else if (state == XervBackupRunner.RunnerState.Running && level == XervBackup.Datamodel.ApplicationSettings.NotificationLevel.Continous)
            {
                //Show update balloon
                m_trayIcon.ShowBalloonTip(BALLOON_SHOW_TIME, Application.ProductName, String.Format(Strings.MainForm.BalloonTip_Running, message), ToolTipIcon.Info);

            }
        }
Пример #4
0
        void Runner_ResultEvent(XervBackupRunner.RunnerResult result, string parsedMessage, string message)
        {
            if (this.InvokeRequired)
            {
                this.BeginInvoke(new XervBackupRunner.ResultEventDelegate(Runner_ResultEvent), result, parsedMessage, message);
                return;
            }

            string name = "";

            //Dirty read of the instance variable
            try { name = Program.WorkThread.CurrentTask.Schedule.Name; }
            catch { }

            if (result == XervBackupRunner.RunnerResult.Error)
                SetCurrentIcon(result, String.Format(Strings.MainForm.BalloonTip_Error, name, parsedMessage));
            else if (result == XervBackupRunner.RunnerResult.Partial || result == XervBackupRunner.RunnerResult.Warning)
                SetCurrentIcon(result, String.Format(Strings.MainForm.BalloonTip_Warning, name));

            if (result == XervBackupRunner.RunnerResult.OK || m_settings.BallonNotificationLevel == XervBackup.Datamodel.ApplicationSettings.NotificationLevel.Off)
                return;

            if (result == XervBackupRunner.RunnerResult.Error)
                m_trayIcon.ShowBalloonTip(BALLOON_SHOW_TIME, Application.ProductName, String.Format(Strings.MainForm.BalloonTip_Error, name, parsedMessage), ToolTipIcon.Error);

            else if (result == XervBackupRunner.RunnerResult.Warning || result == XervBackupRunner.RunnerResult.Partial)
                m_trayIcon.ShowBalloonTip(BALLOON_SHOW_TIME, Application.ProductName, String.Format(Strings.MainForm.BalloonTip_Warning, name), ToolTipIcon.Warning);
        }
Пример #5
0
        public void SetCurrentIcon(XervBackupRunner.RunnerResult icon, string message)
        {
            if (icon == XervBackupRunner.RunnerResult.Error)
            {
                m_currentIcon = Properties.Resources.TrayNormalError;
                m_currentIconState = icon;
                m_currentTooltip = message;

            }
            else if ((icon == XervBackupRunner.RunnerResult.Warning || icon == XervBackupRunner.RunnerResult.Partial) && m_currentIconState != XervBackupRunner.RunnerResult.Error)
            {
                m_currentIcon = Properties.Resources.TrayNormalWarning;
                m_currentIconState = icon;
                m_currentTooltip = message;
            }

            UpdateTrayIcon();
        }
Пример #6
0
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            lock (m_lock)
                m_thread = System.Threading.Thread.CurrentThread;

            try
            {
                object[] args = (object[])e.Argument;
                XervBackupRunner r = new XervBackupRunner();
                IList<string> sourceFolders = r.ListSourceFolders((Datamodel.Schedule)args[0], (DateTime)args[1]);
                if (r.IsAborted)
                    e.Cancel = true;
                else
                {
                    r = new XervBackupRunner();
                    List<KeyValuePair<Library.Main.RSync.RSyncDir.PatchFileType, string>> files = r.ListActualFiles((Datamodel.Schedule)args[0], (DateTime)args[1]);

                    e.Result = new KeyValuePair<IList<string>, List<KeyValuePair<Library.Main.RSync.RSyncDir.PatchFileType, string>>>(sourceFolders, files);

                    if (r.IsAborted)
                        e.Cancel = true;
                }
            }
            catch (System.Threading.ThreadAbortException)
            {
                System.Threading.Thread.ResetAbort();
                e.Cancel = true;
            }
            finally
            {
                lock (m_lock)
                    m_thread = null;
            }
        }