// Copyright (C) 2024, The Duplicati Team // https://duplicati.com, hello@duplicati.com // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the "Software"), // to deal in the Software without restriction, including without limitation // the rights to use, copy, modify, merge, publish, distribute, sublicense, // and/or sell copies of the Software, and to permit persons to whom the // Software is furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. using System; using System.Linq; using System.Collections.Generic; using Duplicati.Library.Interface; using Duplicati.Library.Utility; using System.Globalization; namespace Duplicati.Library.Main { /// /// A class for keeping all Duplicati options in one place, /// and provide typesafe access to the options /// public class Options { private const string DEFAULT_BLOCK_HASH_ALGORITHM = "SHA256"; private const string DEFAULT_FILE_HASH_ALGORITHM = "SHA256"; /// /// The default block size, chose to minimize hash numbers but allow smaller upload sizes. /// private const string DEFAULT_BLOCKSIZE = "1mb"; /// /// The default threshold value /// private const long DEFAULT_THRESHOLD = 25; /// /// The default value for maximum number of small files /// private const long DEFAULT_SMALL_FILE_MAX_COUNT = 20; /// /// Default size of volumes /// private const string DEFAULT_VOLUME_SIZE = "50mb"; /// /// Default value for keep-versions /// private const int DEFAULT_KEEP_VERSIONS = 0; /// /// The default threshold for purging log data /// private const string DEFAULT_LOG_RETENTION = "30D"; /// /// The default number of compressor instances /// private readonly int DEFAULT_COMPRESSORS = Math.Max(1, Environment.ProcessorCount / 2); /// /// The default number of hasher instances /// private readonly int DEFAULT_BLOCK_HASHERS = Math.Max(1, Environment.ProcessorCount / 2); /// /// The default threshold for warning about coming close to quota /// private const int DEFAULT_QUOTA_WARNING_THRESHOLD = 10; /// /// An enumeration that describes the supported strategies for an optimization /// public enum OptimizationStrategy { /// /// The optimization feature is created if possible, but silently ignored if it fails /// Auto, /// /// The optimization feature is created if possible, but an error is logged if it fails /// On, /// /// The optimization feature is deactivated /// Off, /// /// The optimization feature is created, and the backup is aborted if it fails /// Required } /// /// The possible settings for the symlink strategy /// public enum SymlinkStrategy { /// /// Store information about the symlink /// Store, /// /// Treat symlinks as normal files or folders /// Follow, /// /// Ignore all symlinks /// Ignore } /// /// The possible settings for the remote test strategy /// public enum RemoteTestStrategy { /// /// test the remote volumes /// True, /// /// do not test the remote volumes /// False, /// /// test only the list and index volumes /// ListAndIndexes } /// /// The possible settings for the hardlink strategy /// public enum HardlinkStrategy { /// /// Process only the first hardlink /// First, /// /// Process all hardlinks /// All, /// /// Ignore all hardlinks /// None } /// /// The possible settings for index file usage /// public enum IndexFileStrategy { /// /// Disables usage of index files /// None, /// /// Stores only block lookup information in the index files /// Lookup, /// /// Stores both block lookup and block lists in the index files /// Full } private static readonly string DEFAULT_COMPRESSED_EXTENSION_FILE = System.IO.Path.Combine(Duplicati.Library.AutoUpdater.UpdaterManager.INSTALLATIONDIR, "default_compressed_extensions.txt"); /// /// Lock that protects the options collection /// protected readonly object m_lock = new object(); protected readonly Dictionary m_options; protected readonly List> m_loadedModules = new List>(); /// /// Lookup table for compression hints /// private Dictionary m_compressionHints; public Options(Dictionary options) { m_options = options; } public Dictionary RawOptions { get { return m_options; } } /// /// Returns a list of strings that are not supported on the commandline as options, but used internally /// public static string[] InternalOptions { get { return new string[] { "main-action" }; } } /// /// Returns a list of options that are intentionally duplicate /// public static string[] KnownDuplicates { get { return new string[] { "auth-password", "auth-username" }; } } /// /// A default backup name /// public static string DefaultBackupName { get { return System.IO.Path.GetFileNameWithoutExtension(Library.Utility.Utility.getEntryAssembly().Location); } } /// /// Gets all supported commands /// public IList SupportedCommands { get { var lst = new List(new ICommandLineArgument[] { new CommandLineArgument("dblock-size", CommandLineArgument.ArgumentType.Size, Strings.Options.DblocksizeShort, Strings.Options.DblocksizeLong, DEFAULT_VOLUME_SIZE), new CommandLineArgument("auto-cleanup", CommandLineArgument.ArgumentType.Boolean, Strings.Options.AutocleanupShort, Strings.Options.AutocleanupLong, "false"), new CommandLineArgument("unittest-mode", CommandLineArgument.ArgumentType.Boolean, Strings.Options.UnittestmodeShort, Strings.Options.UnittestmodeLong, "false"), new CommandLineArgument("control-files", CommandLineArgument.ArgumentType.Path, Strings.Options.ControlfilesShort, Strings.Options.ControlfilesLong), new CommandLineArgument("skip-file-hash-checks", CommandLineArgument.ArgumentType.Boolean, Strings.Options.SkipfilehashchecksShort, Strings.Options.SkipfilehashchecksLong, "false"), new CommandLineArgument("dont-read-manifests", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DontreadmanifestsShort, Strings.Options.DontreadmanifestsLong, "false"), new CommandLineArgument("restore-path", CommandLineArgument.ArgumentType.String, Strings.Options.RestorepathShort, Strings.Options.RestorepathLong), new CommandLineArgument("time", CommandLineArgument.ArgumentType.Timespan, Strings.Options.TimeShort, Strings.Options.TimeLong, "now"), new CommandLineArgument("version", CommandLineArgument.ArgumentType.String, Strings.Options.VersionShort, Strings.Options.VersionLong, ""), new CommandLineArgument("all-versions", CommandLineArgument.ArgumentType.Boolean, Strings.Options.AllversionsShort, Strings.Options.AllversionsLong, "false"), new CommandLineArgument("list-prefix-only", CommandLineArgument.ArgumentType.Boolean, Strings.Options.ListprefixonlyShort, Strings.Options.ListprefixonlyLong, "false"), new CommandLineArgument("list-folder-contents", CommandLineArgument.ArgumentType.Boolean, Strings.Options.ListfoldercontentsShort, Strings.Options.ListfoldercontentsLong, "false"), new CommandLineArgument("list-sets-only", CommandLineArgument.ArgumentType.Boolean, Strings.Options.ListsetsonlyShort, Strings.Options.ListsetsonlyLong, "false"), new CommandLineArgument("disable-autocreate-folder", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DisableautocreatefolderShort, Strings.Options.DisableautocreatefolderLong, "false"), new CommandLineArgument("allow-missing-source", CommandLineArgument.ArgumentType.Boolean, Strings.Options.AllowmissingsourceShort, Strings.Options.AllowmissingsourceLong, "false"), new CommandLineArgument("disable-filetime-check", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DisablefiletimecheckShort, Strings.Options.DisablefiletimecheckLong, "false"), new CommandLineArgument("check-filetime-only", CommandLineArgument.ArgumentType.Boolean, Strings.Options.CheckfiletimeonlyShort, Strings.Options.CheckfiletimeonlyLong, "false"), new CommandLineArgument("disable-time-tolerance", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DisabletimetoleranceShort, Strings.Options.DisabletimetoleranceLong, "false"), new CommandLineArgument("tempdir", CommandLineArgument.ArgumentType.Path, Strings.Options.TempdirShort, Strings.Options.TempdirLong, System.IO.Path.GetTempPath()), new CommandLineArgument("thread-priority", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.ThreadpriorityShort, Strings.Options.ThreadpriorityLong, "normal", null, new string[] {"highest", "high", "abovenormal", "normal", "belownormal", "low", "lowest", "idle" }), new CommandLineArgument("prefix", CommandLineArgument.ArgumentType.String, Strings.Options.PrefixShort, Strings.Options.PrefixLong, "duplicati"), new CommandLineArgument("passphrase", CommandLineArgument.ArgumentType.Password, Strings.Options.PassphraseShort, Strings.Options.PassphraseLong), new CommandLineArgument("no-encryption", CommandLineArgument.ArgumentType.Boolean, Strings.Options.NoencryptionShort, Strings.Options.NoencryptionLong, "false"), new CommandLineArgument("number-of-retries", CommandLineArgument.ArgumentType.Integer, Strings.Options.NumberofretriesShort, Strings.Options.NumberofretriesLong, "5"), new CommandLineArgument("retry-delay", CommandLineArgument.ArgumentType.Timespan, Strings.Options.RetrydelayShort, Strings.Options.RetrydelayLong, "10s"), new CommandLineArgument("retry-with-exponential-backoff", CommandLineArgument.ArgumentType.Boolean, Strings.Options.RetrywithexponentialbackoffShort, Strings.Options.RetrywithexponentialbackoffLong, "false"), new CommandLineArgument("synchronous-upload", CommandLineArgument.ArgumentType.Boolean, Strings.Options.SynchronousuploadShort, Strings.Options.SynchronousuploadLong, "false"), new CommandLineArgument("asynchronous-upload-limit", CommandLineArgument.ArgumentType.Integer, Strings.Options.AsynchronousuploadlimitShort, Strings.Options.AsynchronousuploadlimitLong, "4"), new CommandLineArgument("asynchronous-concurrent-upload-limit", CommandLineArgument.ArgumentType.Integer, Strings.Options.AsynchronousconcurrentuploadlimitShort, Strings.Options.AsynchronousconcurrentuploadlimitLong, "4"), new CommandLineArgument("asynchronous-upload-folder", CommandLineArgument.ArgumentType.Path, Strings.Options.AsynchronousuploadfolderShort, Strings.Options.AsynchronousuploadfolderLong, System.IO.Path.GetTempPath()), new CommandLineArgument("disable-streaming-transfers", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DisableStreamingShort, Strings.Options.DisableStreamingLong, "false"), new CommandLineArgument("throttle-upload", CommandLineArgument.ArgumentType.Size, Strings.Options.ThrottleuploadShort, Strings.Options.ThrottleuploadLong, "0kb"), new CommandLineArgument("throttle-download", CommandLineArgument.ArgumentType.Size, Strings.Options.ThrottledownloadShort, Strings.Options.ThrottledownloadLong, "0kb"), new CommandLineArgument("skip-files-larger-than", CommandLineArgument.ArgumentType.Size, Strings.Options.SkipfileslargerthanShort, Strings.Options.SkipfileslargerthanLong), new CommandLineArgument("upload-unchanged-backups", CommandLineArgument.ArgumentType.Boolean, Strings.Options.UploadUnchangedBackupsShort, Strings.Options.UploadUnchangedBackupsLong, "false"), new CommandLineArgument("snapshot-policy", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.SnapshotpolicyShort, Strings.Options.SnapshotpolicyLong, "off", null, Enum.GetNames(typeof(OptimizationStrategy))), new CommandLineArgument("vss-exclude-writers", CommandLineArgument.ArgumentType.String, Strings.Options.VssexcludewritersShort, Strings.Options.VssexcludewritersLong, "{e8132975-6f93-4464-a53e-1050253ae220}"), new CommandLineArgument("vss-use-mapping", CommandLineArgument.ArgumentType.Boolean, Strings.Options.VssusemappingShort, Strings.Options.VssusemappingLong, "false"), new CommandLineArgument("usn-policy", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.UsnpolicyShort, Strings.Options.UsnpolicyLong, "off", null, Enum.GetNames(typeof(OptimizationStrategy))), new CommandLineArgument("encryption-module", CommandLineArgument.ArgumentType.String, Strings.Options.EncryptionmoduleShort, Strings.Options.EncryptionmoduleLong, "aes"), new CommandLineArgument("compression-module", CommandLineArgument.ArgumentType.String, Strings.Options.CompressionmoduleShort, Strings.Options.CompressionmoduleLong, "zip"), new CommandLineArgument("enable-module", CommandLineArgument.ArgumentType.String, Strings.Options.EnablemoduleShort, Strings.Options.EnablemoduleLong), new CommandLineArgument("disable-module", CommandLineArgument.ArgumentType.String, Strings.Options.DisablemoduleShort, Strings.Options.DisablemoduleLong), new CommandLineArgument("debug-output", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DebugoutputShort, Strings.Options.DebugoutputLong, "false"), new CommandLineArgument("debug-retry-errors", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DebugretryerrorsShort, Strings.Options.DebugretryerrorsLong, "false"), new CommandLineArgument("log-file", CommandLineArgument.ArgumentType.Path, Strings.Options.LogfileShort, Strings.Options.LogfileLong), new CommandLineArgument("log-file-log-level", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.LogfileloglevelShort, Strings.Options.LogfileloglevelShort, "Warning", null, Enum.GetNames(typeof(Duplicati.Library.Logging.LogMessageType))), new CommandLineArgument("log-file-log-filter", CommandLineArgument.ArgumentType.String, Strings.Options.LogfilelogfiltersShort, Strings.Options.LogfilelogfiltersLong(System.IO.Path.PathSeparator.ToString()), null), new CommandLineArgument("console-log-level", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.ConsoleloglevelShort, Strings.Options.ConsoleloglevelShort, "Warning", null, Enum.GetNames(typeof(Duplicati.Library.Logging.LogMessageType))), new CommandLineArgument("console-log-filter", CommandLineArgument.ArgumentType.String, Strings.Options.ConsolelogfiltersShort, Strings.Options.ConsolelogfiltersLong(System.IO.Path.PathSeparator.ToString()), null), new CommandLineArgument("log-level", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.LoglevelShort, Strings.Options.LoglevelLong, "Warning", null, Enum.GetNames(typeof(Duplicati.Library.Logging.LogMessageType)), Strings.Options.LogLevelDeprecated("log-file-log-level", "console-log-level")), new CommandLineArgument("profile-all-database-queries", CommandLineArgument.ArgumentType.Boolean, Strings.Options.ProfilealldatabasequeriesShort, Strings.Options.ProfilealldatabasequeriesLong, "false"), new CommandLineArgument("list-verify-uploads", CommandLineArgument.ArgumentType.Boolean, Strings.Options.ListverifyuploadsShort, Strings.Options.ListverifyuploadsShort, "false"), new CommandLineArgument("allow-sleep", CommandLineArgument.ArgumentType.Boolean, Strings.Options.AllowsleepShort, Strings.Options.AllowsleepLong, "false"), new CommandLineArgument("use-background-io-priority", CommandLineArgument.ArgumentType.Boolean, Strings.Options.UsebackgroundiopriorityShort, Strings.Options.UsebackgroundiopriorityLong, "false"), new CommandLineArgument("no-connection-reuse", CommandLineArgument.ArgumentType.Boolean, Strings.Options.NoconnectionreuseShort, Strings.Options.NoconnectionreuseLong, "false"), new CommandLineArgument("quota-size", CommandLineArgument.ArgumentType.Size, Strings.Options.QuotasizeShort, Strings.Options.QuotasizeLong), new CommandLineArgument("quota-warning-threshold", CommandLineArgument.ArgumentType.Integer, Strings.Options.QuotaWarningThresholdShort, Strings.Options.QuotaWarningThresholdLong, DEFAULT_QUOTA_WARNING_THRESHOLD.ToString()), new CommandLineArgument("quota-disable", CommandLineArgument.ArgumentType.Boolean, Strings.Options.QuotaDisableShort, Strings.Options.QuotaDisableLong("quota-size"), "false"), new CommandLineArgument("symlink-policy", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.SymlinkpolicyShort, Strings.Options.SymlinkpolicyLong("store", "ignore", "follow"), Enum.GetName(typeof(SymlinkStrategy), SymlinkStrategy.Store), null, Enum.GetNames(typeof(SymlinkStrategy))), new CommandLineArgument("hardlink-policy", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.HardlinkpolicyShort, Strings.Options.HardlinkpolicyLong("first", "all", "none"), Enum.GetName(typeof(HardlinkStrategy), HardlinkStrategy.All), null, Enum.GetNames(typeof(HardlinkStrategy))), new CommandLineArgument("exclude-files-attributes", CommandLineArgument.ArgumentType.String, Strings.Options.ExcludefilesattributesShort, Strings.Options.ExcludefilesattributesLong(Enum.GetNames(typeof(System.IO.FileAttributes)))), new CommandLineArgument("backup-name", CommandLineArgument.ArgumentType.String, Strings.Options.BackupnameShort, Strings.Options.BackupnameLong, DefaultBackupName), new CommandLineArgument("compression-extension-file", CommandLineArgument.ArgumentType.Path, Strings.Options.CompressionextensionfileShort, Strings.Options.CompressionextensionfileLong(DEFAULT_COMPRESSED_EXTENSION_FILE), DEFAULT_COMPRESSED_EXTENSION_FILE), new CommandLineArgument("backup-id", CommandLineArgument.ArgumentType.String, Strings.Options.BackupidShort, Strings.Options.BackupidLong, ""), new CommandLineArgument("machine-id", CommandLineArgument.ArgumentType.String, Strings.Options.MachineidShort, Strings.Options.MachineidLong, Library.AutoUpdater.UpdaterManager.InstallID), new CommandLineArgument("verbose", CommandLineArgument.ArgumentType.Boolean, Strings.Options.VerboseShort, Strings.Options.VerboseLong, "false", null, null, Strings.Options.VerboseDeprecated), new CommandLineArgument("full-result", CommandLineArgument.ArgumentType.Boolean, Strings.Options.FullresultShort, Strings.Options.FullresultLong, "false"), new CommandLineArgument("overwrite", CommandLineArgument.ArgumentType.Boolean, Strings.Options.OverwriteShort, Strings.Options.OverwriteLong, "false"), new CommandLineArgument("dbpath", CommandLineArgument.ArgumentType.Path, Strings.Options.DbpathShort, Strings.Options.DbpathLong), new CommandLineArgument("blocksize", CommandLineArgument.ArgumentType.Size, Strings.Options.BlocksizeShort, Strings.Options.BlocksizeLong, DEFAULT_BLOCKSIZE), new CommandLineArgument("file-read-buffer-size", CommandLineArgument.ArgumentType.Size, Strings.Options.FilereadbuffersizeShort, Strings.Options.FilereadbuffersizeLong, "0kb", null, null, @"The ""file-read-buffer-size"" option is no longer used and has been deprecated."), new CommandLineArgument("skip-metadata", CommandLineArgument.ArgumentType.Boolean, Strings.Options.SkipmetadataShort, Strings.Options.SkipmetadataLong, "false"), new CommandLineArgument("restore-permissions", CommandLineArgument.ArgumentType.Boolean, Strings.Options.RestorepermissionsShort, Strings.Options.RestorepermissionsLong, "false"), new CommandLineArgument("skip-restore-verification", CommandLineArgument.ArgumentType.Boolean, Strings.Options.SkiprestoreverificationShort, Strings.Options.SkiprestoreverificationLong, "false"), new CommandLineArgument("disable-filepath-cache", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DisablefilepathcacheShort, Strings.Options.DisablefilepathcacheLong, "true", null, null, @"The ""disable-filepath-cache"" option is no longer used and has been deprecated."), new CommandLineArgument("use-block-cache", CommandLineArgument.ArgumentType.Boolean, Strings.Options.UseblockcacheShort, Strings.Options.UseblockcacheLong, "false"), new CommandLineArgument("changed-files", CommandLineArgument.ArgumentType.Path, Strings.Options.ChangedfilesShort, Strings.Options.ChangedfilesLong), new CommandLineArgument("deleted-files", CommandLineArgument.ArgumentType.Path, Strings.Options.DeletedfilesShort, Strings.Options.DeletedfilesLong("changed-files")), new CommandLineArgument("disable-synthetic-filelist", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DisablesyntheticfilelistShort, Strings.Options.DisablesyntehticfilelistLong, "false"), new CommandLineArgument("threshold", CommandLineArgument.ArgumentType.Integer, Strings.Options.ThresholdShort, Strings.Options.ThresholdLong, DEFAULT_THRESHOLD.ToString()), new CommandLineArgument("index-file-policy", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.IndexfilepolicyShort, Strings.Options.IndexfilepolicyLong, IndexFileStrategy.Full.ToString(), null, Enum.GetNames(typeof(IndexFileStrategy))), new CommandLineArgument("no-backend-verification", CommandLineArgument.ArgumentType.Boolean, Strings.Options.NobackendverificationShort, Strings.Options.NobackendverificationLong, "false"), new CommandLineArgument("backup-test-samples", CommandLineArgument.ArgumentType.Integer, Strings.Options.BackendtestsamplesShort, Strings.Options.BackendtestsamplesLong("no-backend-verification"), "1"), new CommandLineArgument("backup-test-percentage", CommandLineArgument.ArgumentType.Decimal, Strings.Options.BackendtestpercentageShort, Strings.Options.BackendtestpercentageLong, "0.1"), new CommandLineArgument("full-remote-verification", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.FullremoteverificationShort, Strings.Options.FullremoteverificationLong("no-backend-verification"), Enum.GetName(typeof(RemoteTestStrategy), RemoteTestStrategy.False), null, Enum.GetNames(typeof(RemoteTestStrategy))), new CommandLineArgument("dry-run", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DryrunShort, Strings.Options.DryrunLong, "false", new string[] { "dryrun" }), new CommandLineArgument("block-hash-algorithm", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.BlockhashalgorithmShort, Strings.Options.BlockhashalgorithmLong, DEFAULT_BLOCK_HASH_ALGORITHM, null, HashFactory.GetSupportedHashes()), new CommandLineArgument("file-hash-algorithm", CommandLineArgument.ArgumentType.Enumeration, Strings.Options.FilehashalgorithmShort, Strings.Options.FilehashalgorithmLong, DEFAULT_FILE_HASH_ALGORITHM, null, HashFactory.GetSupportedHashes()), new CommandLineArgument("no-auto-compact", CommandLineArgument.ArgumentType.Boolean, Strings.Options.NoautocompactShort, Strings.Options.NoautocompactLong, "false"), new CommandLineArgument("small-file-size", CommandLineArgument.ArgumentType.Size, Strings.Options.SmallfilesizeShort, Strings.Options.SmallfilesizeLong), new CommandLineArgument("small-file-max-count", CommandLineArgument.ArgumentType.Integer, Strings.Options.SmallfilemaxcountShort, Strings.Options.SmallfilemaxcountLong, DEFAULT_SMALL_FILE_MAX_COUNT.ToString()), new CommandLineArgument("patch-with-local-blocks", CommandLineArgument.ArgumentType.Boolean, Strings.Options.PatchwithlocalblocksShort, Strings.Options.PatchwithlocalblocksLong, "false", null, null, Strings.Options.PatchwithlocalblocksDeprecated("restore-with-local-blocks")), new CommandLineArgument("no-local-db", CommandLineArgument.ArgumentType.Boolean, Strings.Options.NolocaldbShort, Strings.Options.NolocaldbLong, "false"), new CommandLineArgument("dont-compress-restore-paths", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DontcompressrestorepathsShort, Strings.Options.DontcompressrestorepathsLong, "false"), new CommandLineArgument("keep-versions", CommandLineArgument.ArgumentType.Integer, Strings.Options.KeepversionsShort, Strings.Options.KeepversionsLong, DEFAULT_KEEP_VERSIONS.ToString()), new CommandLineArgument("keep-time", CommandLineArgument.ArgumentType.Timespan, Strings.Options.KeeptimeShort, Strings.Options.KeeptimeLong), new CommandLineArgument("retention-policy", CommandLineArgument.ArgumentType.String, Strings.Options.RetentionPolicyShort, Strings.Options.RetentionPolicyLong), new CommandLineArgument("upload-verification-file", CommandLineArgument.ArgumentType.Boolean, Strings.Options.UploadverificationfileShort, Strings.Options.UploadverificationfileLong, "false"), new CommandLineArgument("allow-passphrase-change", CommandLineArgument.ArgumentType.Boolean, Strings.Options.AllowpassphrasechangeShort, Strings.Options.AllowpassphrasechangeLong, "false"), new CommandLineArgument("no-local-blocks", CommandLineArgument.ArgumentType.Boolean, Strings.Options.NolocalblocksShort, Strings.Options.NolocalblocksLong, "false", null, null, Strings.Options.NolocalblocksDeprecated("restore-with-local-blocks")), new CommandLineArgument("restore-with-local-blocks", CommandLineArgument.ArgumentType.Boolean, Strings.Options.RestorewithlocalblocksShort, Strings.Options.RestorewithlocalblocksLong, "false"), new CommandLineArgument("full-block-verification", CommandLineArgument.ArgumentType.Boolean, Strings.Options.FullblockverificationShort, Strings.Options.FullblockverificationLong, "false"), new CommandLineArgument("allow-full-removal", CommandLineArgument.ArgumentType.Boolean, Strings.Options.AllowfullremovalShort, Strings.Options.AllowfullremovalLong, "false"), new CommandLineArgument("log-retention", CommandLineArgument.ArgumentType.Timespan, Strings.Options.LogretentionShort, Strings.Options.LogretentionLong, DEFAULT_LOG_RETENTION), new CommandLineArgument("repair-only-paths", CommandLineArgument.ArgumentType.Boolean, Strings.Options.RepaironlypathsShort, Strings.Options.RepaironlypathsLong, "false"), new CommandLineArgument("repair-force-block-use", CommandLineArgument.ArgumentType.Boolean, Strings.Options.RepaironlypathsShort, Strings.Options.RepaironlypathsLong, "false"), new CommandLineArgument("force-locale", CommandLineArgument.ArgumentType.String, Strings.Options.ForcelocaleShort, Strings.Options.ForcelocaleLong), new CommandLineArgument("force-actual-date", CommandLineArgument.ArgumentType.Boolean, Strings.Options.ForceActualDateShort, Strings.Options.ForceActualDateLong, "false"), new CommandLineArgument("disable-piped-streaming", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DisablepipingShort, Strings.Options.DisablepipingLong, "false"), new CommandLineArgument("concurrency-max-threads", CommandLineArgument.ArgumentType.Integer, Strings.Options.ConcurrencymaxthreadsShort, Strings.Options.ConcurrencymaxthreadsLong, "0"), new CommandLineArgument("concurrency-block-hashers", CommandLineArgument.ArgumentType.Integer, Strings.Options.ConcurrencyblockhashersShort, Strings.Options.ConcurrencyblockhashersLong, DEFAULT_BLOCK_HASHERS.ToString()), new CommandLineArgument("concurrency-compressors", CommandLineArgument.ArgumentType.Integer, Strings.Options.ConcurrencycompressorsShort, Strings.Options.ConcurrencycompressorsLong, DEFAULT_COMPRESSORS.ToString()), new CommandLineArgument("auto-vacuum", CommandLineArgument.ArgumentType.Boolean, Strings.Options.AutoVacuumShort, Strings.Options.AutoVacuumLong, "false"), new CommandLineArgument("disable-file-scanner", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DisablefilescannerShort, Strings.Options.DisablefilescannerLong, "false"), new CommandLineArgument("disable-filelist-consistency-checks", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DisablefilelistconsistencychecksShort, Strings.Options.DisablefilelistconsistencychecksLong, "false"), new CommandLineArgument("disable-on-battery", CommandLineArgument.ArgumentType.Boolean, Strings.Options.DisableOnBatteryShort, Strings.Options.DisableOnBatteryLong, "false"), new CommandLineArgument("exclude-empty-folders", CommandLineArgument.ArgumentType.Boolean, Strings.Options.ExcludeemptyfoldersShort, Strings.Options.ExcludeemptyfoldersLong, "false"), new CommandLineArgument("ignore-filenames", CommandLineArgument.ArgumentType.Path, Strings.Options.IgnorefilenamesShort, Strings.Options.IgnorefilenamesLong), new CommandLineArgument("restore-symlink-metadata", CommandLineArgument.ArgumentType.Boolean, Strings.Options.RestoresymlinkmetadataShort, Strings.Options.RestoresymlinkmetadataLong, "false"), new CommandLineArgument("rebuild-missing-dblock-files", CommandLineArgument.ArgumentType.Boolean, Strings.Options.RebuildmissingdblockfilesShort, Strings.Options.RebuildmissingdblockfilesLong, "false"), new CommandLineArgument("auto-compact-interval", CommandLineArgument.ArgumentType.Timespan, Strings.Options.AutoCompactIntervalShort, Strings.Options.AutoCompactIntervalLong, "0m"), new CommandLineArgument("auto-vacuum-interval", CommandLineArgument.ArgumentType.Timespan, Strings.Options.AutoVacuumIntervalShort, Strings.Options.AutoVacuumIntervalLong, "0m"), }); return lst; } } /// /// Gets or sets the current main action of the instance /// public OperationMode MainAction { get { return (OperationMode)Enum.Parse(typeof(OperationMode), m_options["main-action"]); } set { m_options["main-action"] = value.ToString(); } } /// /// Gets the size of each volume in bytes /// public long VolumeSize { get { string volsize; m_options.TryGetValue("dblock-size", out volsize); if (string.IsNullOrEmpty(volsize)) volsize = DEFAULT_VOLUME_SIZE; #if DEBUG return Math.Max(1024 * 10, Library.Utility.Sizeparser.ParseSize(volsize, "mb")); #else return Math.Max(1024 * 1024, Library.Utility.Sizeparser.ParseSize(volsize, "mb")); #endif } } /// /// Gets the maximum size of a single file /// public long SkipFilesLargerThan { get { if (!m_options.ContainsKey("skip-files-larger-than") || string.IsNullOrEmpty(m_options["skip-files-larger-than"])) return long.MaxValue; else return Library.Utility.Sizeparser.ParseSize(m_options["skip-files-larger-than"], "mb"); } } /// /// A value indicating if orphan files are deleted automatically /// public bool AutoCleanup { get { return GetBool("auto-cleanup"); } } /// /// A value indicating if we are running in unittest mode /// public bool UnittestMode { get { return GetBool("unittest-mode"); } } /// /// Gets a list of files to add to the signature volumes /// public string ControlFiles { get { string v; m_options.TryGetValue("control-files", out v); return v; } } /// /// A value indicating if file hash checks are skipped /// public bool SkipFileHashChecks { get { return GetBool("skip-file-hash-checks"); } } /// /// A value indicating if the manifest files are not read /// public bool DontReadManifests { get { return GetBool("dont-read-manifests"); } } /// /// Gets the backup that should be restored /// public DateTime Time { get { if (!m_options.ContainsKey("time") || string.IsNullOrEmpty(m_options["time"])) return new DateTime(0, DateTimeKind.Utc); else return Library.Utility.Timeparser.ParseTimeInterval(m_options["time"], DateTime.Now); } } /// /// Gets the versions the restore or list operation is limited to /// public long[] Version { get { string v; m_options.TryGetValue("version", out v); if (string.IsNullOrEmpty(v)) return null; var versions = v.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); if (v.Length == 0) return null; var res = new List(); foreach (var n in versions) if (n.Contains('-')) { //TODO: Throw errors if too many entries? var parts = n.Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries).Select(x => Convert.ToInt64(x.Trim())).ToArray(); for (var i = Math.Min(parts[0], parts[1]); i <= Math.Max(parts[0], parts[1]); i++) res.Add(i); } else res.Add(Convert.ToInt64(n)); return res.ToArray(); } } /// /// A value indicating if all versions are listed /// public bool AllVersions { get { return GetBool("all-versions"); } } /// /// A value indicating if only the largest common prefix is returned /// public bool ListPrefixOnly { get { return GetBool("list-prefix-only"); } } /// /// A value indicating if only folder contents are returned /// public bool ListFolderContents { get { return GetBool("list-folder-contents"); } } /// /// A value indicating that only filesets are returned /// public bool ListSetsOnly { get { return GetBool("list-sets-only"); } } /// /// A value indicating if file time checks are skipped /// public bool DisableFiletimeCheck { get { return GetBool("disable-filetime-check"); } } /// /// A value indicating if file time checks are skipped /// public bool CheckFiletimeOnly { get { return GetBool("check-filetime-only"); } } /// /// A value indicating if USN numbers are used to get list of changed files /// //public bool DisableUSNDiffCheck { get { return GetBool("disable-usn-diff-check"); } } /// /// A value indicating if time tolerance is disabled /// public bool DisableTimeTolerance { get { return GetBool("disable-time-tolerance"); } } /// /// Gets a value indicating whether a temporary folder has been specified /// public bool HasTempDir { get { return m_options.ContainsKey("tempdir") && !string.IsNullOrEmpty(m_options["tempdir"]); } } /// /// Gets the folder where temporary files are stored /// public string TempDir { get { if (!m_options.ContainsKey("tempdir") || string.IsNullOrEmpty(m_options["tempdir"])) { return Duplicati.Library.Utility.TempFolder.SystemTempPath; } return m_options["tempdir"]; } } /// /// Gets a value indicating whether the user has forced the locale /// public bool HasForcedLocale { get { return m_options.ContainsKey("force-locale"); } } /// /// Gets the forced locale for the current user /// public System.Globalization.CultureInfo ForcedLocale { get { if (!m_options.ContainsKey("force-locale")) return System.Threading.Thread.CurrentThread.CurrentCulture; else { var localestring = m_options["force-locale"]; if (string.IsNullOrWhiteSpace(localestring)) return System.Globalization.CultureInfo.InvariantCulture; else return new System.Globalization.CultureInfo(localestring); } } } /// /// Gets the process priority /// public string ThreadPriority { get { if (!m_options.ContainsKey("thread-priority") || string.IsNullOrEmpty(m_options["thread-priority"])) return null; else return m_options["thread-priority"]; } } /// /// A value indicating if missing folders should be created automatically /// public bool AutocreateFolders { get { return !GetBool("disable-autocreate-folder"); } } /// /// Gets the backup prefix /// public string Prefix { get { string v; m_options.TryGetValue("prefix", out v); if (!string.IsNullOrEmpty(v)) return v; return "duplicati"; } } /// /// Gets the number of old backups to keep /// public int KeepVersions { get { string v; m_options.TryGetValue("keep-versions", out v); if (string.IsNullOrEmpty(v)) return DEFAULT_KEEP_VERSIONS; return Math.Max(0, int.Parse(v)); } } /// /// Gets the timelimit for removal /// public DateTime KeepTime { get { string v; m_options.TryGetValue("keep-time", out v); if (string.IsNullOrEmpty(v)) return new DateTime(0); TimeSpan tolerance = this.DisableTimeTolerance ? TimeSpan.FromSeconds(0) : TimeSpan.FromSeconds(Math.Min(Library.Utility.Timeparser.ParseTimeSpan(v).TotalSeconds / 100, 60.0 * 60.0)); return Library.Utility.Timeparser.ParseTimeInterval(v, DateTime.Now, true) - tolerance; } } /// /// Gets the time frames and intervals for the retention policy /// public List RetentionPolicy { get { var retentionPolicyConfig = new List(); string v; m_options.TryGetValue("retention-policy", out v); if (string.IsNullOrEmpty(v)) { return retentionPolicyConfig; } var periodIntervalStrings = v.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); foreach (var periodIntervalString in periodIntervalStrings) { retentionPolicyConfig.Add(RetentionPolicyValue.CreateFromString(periodIntervalString)); } return retentionPolicyConfig; } } /// /// Gets the encryption passphrase /// public string Passphrase { get { if (!m_options.ContainsKey("passphrase") || string.IsNullOrEmpty(m_options["passphrase"])) return null; else return m_options["passphrase"]; } } /// /// A value indicating if backups are not encrypted /// public bool NoEncryption { get { return GetBool("no-encryption"); } } /// /// Gets the module used for encryption /// public string EncryptionModule { get { //Disabled? if (NoEncryption) return null; //Specified? if (m_options.ContainsKey("encryption-module")) return m_options["encryption-module"]; return "aes"; } } /// /// Gets the module used for compression /// public string CompressionModule { get { if (m_options.ContainsKey("compression-module")) return m_options["compression-module"]; else return "zip"; } } /// /// Gets the number of time to retry transmission if it fails /// public int NumberOfRetries { get { if (!m_options.ContainsKey("number-of-retries") || string.IsNullOrEmpty(m_options["number-of-retries"])) return 5; else { int x = int.Parse(m_options["number-of-retries"]); if (x < 0) throw new UserInformationException("Invalid count for number-of-retries", "NumberOfRetriesInvalid"); return x; } } } /// /// A value indicating if backups are transmitted on a separate thread /// public bool SynchronousUpload { get { return Library.Utility.Utility.ParseBoolOption(m_options, "synchronous-upload"); } } /// /// A value indicating if system is allowed to enter sleep power states during backup/restore /// public bool AllowSleep { get { return GetBool("allow-sleep"); } } /// /// A value indicating if system should use the low-priority IO during backup/restore /// public bool UseBackgroundIOPriority { get { return GetBool("use-background-io-priority"); } } /// /// A value indicating if use of the streaming interface is disallowed /// public bool DisableStreamingTransfers { get { return GetBool("disable-streaming-transfers"); } } /// /// A value indicating if multithreaded pipes may be used for hashing and crypting on up-/downloads /// public bool DisablePipedStreaming { get { return GetBool("disable-piped-streaming"); } } /// /// Gets the delay period to retry uploads /// public TimeSpan RetryDelay { get { if (!m_options.ContainsKey("retry-delay") || string.IsNullOrEmpty(m_options["retry-delay"])) return new TimeSpan(TimeSpan.TicksPerSecond * 10); else return Library.Utility.Timeparser.ParseTimeSpan(m_options["retry-delay"]); } } /// /// Gets whether exponential backoff is enabled /// public Boolean RetryWithExponentialBackoff { get { return Library.Utility.Utility.ParseBoolOption(m_options, "retry-with-exponential-backoff"); } } /// /// Gets the max upload speed in bytes pr. second /// public long MaxUploadPrSecond { get { lock (m_lock) { string v; m_options.TryGetValue("throttle-upload", out v); if (string.IsNullOrEmpty(v)) return 0; else return Library.Utility.Sizeparser.ParseSize(v, "kb"); } } set { lock (m_lock) if (value <= 0) m_options["throttle-upload"] = ""; else m_options["throttle-upload"] = value.ToString() + "b"; } } /// /// Gets or sets the max download speed in bytes pr. second /// public long MaxDownloadPrSecond { get { lock (m_lock) { string v; m_options.TryGetValue("throttle-download", out v); if (string.IsNullOrEmpty(v)) return 0; else return Library.Utility.Sizeparser.ParseSize(v, "kb"); } } set { lock (m_lock) if (value <= 0) m_options["throttle-download"] = ""; else m_options["throttle-download"] = value.ToString() + "b"; } } /// /// A value indicating if the backup is a full backup /// public bool AllowFullRemoval { get { return GetBool("allow-full-removal"); } } /// /// A value indicating if debug output is enabled /// public bool DebugOutput { get { return GetBool("debug-output"); } } /// /// A value indicating if unchanged backups are uploaded /// public bool UploadUnchangedBackups { get { return GetBool("upload-unchanged-backups"); } } /// /// Gets a list of modules that should be loaded /// public string[] EnableModules { get { if (m_options.ContainsKey("enable-module")) return m_options["enable-module"].Trim().ToLower(CultureInfo.InvariantCulture).Split(','); else return new string[0]; } } /// /// Gets a list of modules that should not be loaded /// public string[] DisableModules { get { if (m_options.ContainsKey("disable-module")) return m_options["disable-module"].Trim().ToLower(CultureInfo.InvariantCulture).Split(','); else return new string[0]; } } /// /// Gets the snapshot strategy to use /// public OptimizationStrategy SnapShotStrategy { get { string strategy; if (!m_options.TryGetValue("snapshot-policy", out strategy)) strategy = ""; OptimizationStrategy r; if (!Enum.TryParse(strategy, true, out r)) r = OptimizationStrategy.Off; return r; } } /// /// Gets the symlink strategy to use /// public SymlinkStrategy SymlinkPolicy { get { string policy; if (!m_options.TryGetValue("symlink-policy", out policy)) policy = ""; SymlinkStrategy r; if (!Enum.TryParse(policy, true, out r)) r = SymlinkStrategy.Store; return r; } } /// /// Gets the hardlink strategy to use /// public HardlinkStrategy HardlinkPolicy { get { string policy; if (!m_options.TryGetValue("hardlink-policy", out policy)) policy = ""; HardlinkStrategy r; if (!Enum.TryParse(policy, true, out r)) r = HardlinkStrategy.All; return r; } } /// /// Gets the update sequence number (USN) strategy to use /// public OptimizationStrategy UsnStrategy { get { string strategy; if (!m_options.TryGetValue("usn-policy", out strategy)) strategy = ""; OptimizationStrategy r; if (!Enum.TryParse(strategy, true, out r)) r = OptimizationStrategy.Off; return r; } } /// /// Gets the number of concurrent volume uploads allowed. Zero for unlimited. /// public int AsynchronousConcurrentUploadLimit { get { if (!m_options.TryGetValue("asynchronous-concurrent-upload-limit", out var value)) value = null; if (string.IsNullOrEmpty(value)) return 4; else return int.Parse(value); } } /// /// Gets the number of volumes to create ahead of time when using async transfers, /// a value of zero indicates no limit /// public long AsynchronousUploadLimit { get { string value; if (!m_options.TryGetValue("asynchronous-upload-limit", out value)) value = null; if (string.IsNullOrEmpty(value)) return 4; else return long.Parse(value); } } /// /// Gets the temporary folder to use for asynchronous transfers /// public string AsynchronousUploadFolder { get { string value; if (!m_options.TryGetValue("asynchronous-upload-folder", out value)) value = null; if (string.IsNullOrEmpty(value)) return this.TempDir; else return value; } } /// /// Gets the logfile filename /// public string Logfile { get { string value; if (!m_options.TryGetValue("log-file", out value)) value = null; return value; } } /// /// Gets the log-file detail level /// public Duplicati.Library.Logging.LogMessageType LogFileLoglevel { get { string value; if (!m_options.TryGetValue("log-file-log-level", out value)) value = null; if (string.IsNullOrWhiteSpace(value)) if (!m_options.TryGetValue("log-level", out value)) value = null; foreach (string s in Enum.GetNames(typeof(Duplicati.Library.Logging.LogMessageType))) if (s.Equals(value, StringComparison.OrdinalIgnoreCase)) return (Duplicati.Library.Logging.LogMessageType)Enum.Parse(typeof(Duplicati.Library.Logging.LogMessageType), s); if (Dryrun) return Duplicati.Library.Logging.LogMessageType.DryRun; else return Duplicati.Library.Logging.LogMessageType.Warning; } } /// /// Gets the filter used for log-file messages. /// /// The log file filter. public IFilter LogFileLogFilter { get { m_options.TryGetValue("log-file-log-filter", out var value); return Library.Utility.FilterExpression.ParseLogFilter(value); } } /// /// Gets the filter used for console messages. /// /// The log file filter. public IFilter ConsoleLogFilter { get { m_options.TryGetValue("console-log-filter", out var value); return Library.Utility.FilterExpression.ParseLogFilter(value); } } /// /// Gets the console log detail level /// public Duplicati.Library.Logging.LogMessageType ConsoleLoglevel { get { string value; if (!m_options.TryGetValue("console-log-level", out value)) value = null; if (string.IsNullOrWhiteSpace(value)) if (!m_options.TryGetValue("log-level", out value)) value = null; foreach (string s in Enum.GetNames(typeof(Duplicati.Library.Logging.LogMessageType))) if (s.Equals(value, StringComparison.OrdinalIgnoreCase)) return (Duplicati.Library.Logging.LogMessageType)Enum.Parse(typeof(Duplicati.Library.Logging.LogMessageType), s); if (Dryrun) return Duplicati.Library.Logging.LogMessageType.DryRun; else return Duplicati.Library.Logging.LogMessageType.Warning; } } /// /// A value indicating if all database queries should be logged /// public bool ProfileAllDatabaseQueries { get { return GetBool("profile-all-database-queries"); } } /// /// Gets the attribute filter used to exclude files and folders. /// public System.IO.FileAttributes FileAttributeFilter { get { System.IO.FileAttributes res = default(System.IO.FileAttributes); string v; if (!m_options.TryGetValue("exclude-files-attributes", out v)) return res; foreach (string s in v.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries)) { System.IO.FileAttributes f; if (Enum.TryParse(s.Trim(), true, out f)) res |= f; } return res; } } /// /// A value indicating if server uploads are verified by listing the folder contents /// public bool ListVerifyUploads { get { return GetBool("list-verify-uploads"); } } /// /// A value indicating if connections cannot be re-used /// public bool NoConnectionReuse { get { return GetBool("no-connection-reuse"); } } /// /// A value indicating if the returned value should not be truncated /// public bool FullResult { get { return GetBool("full-result"); } } /// /// A value indicating restored files overwrite existing ones /// public bool Overwrite { get { return GetBool("overwrite"); } } /// /// Gets the total size in bytes that the backup should use, returns -1 if there is no upper limit /// public long QuotaSize { get { if (!m_options.ContainsKey("quota-size") || string.IsNullOrEmpty(m_options["quota-size"])) return -1; else return Library.Utility.Sizeparser.ParseSize(m_options["quota-size"], "mb"); } } /// /// Gets the threshold at which a quota warning should be generated. /// /// /// This is treated as a percentage, where a warning is given when the amount of free space is less than this percentage of the backup size. /// public int QuotaWarningThreshold { get { string tmp; m_options.TryGetValue("quota-warning-threshold", out tmp); if (string.IsNullOrEmpty(tmp)) { return DEFAULT_QUOTA_WARNING_THRESHOLD; } else { return int.Parse(tmp); } } } /// /// Gets a flag indicating that backup quota reported by the backend should be ignored /// /// This is necessary because in some cases the backend might report a wrong quota (especially with some Linux mounts). public bool QuotaDisable { get { return Library.Utility.Utility.ParseBoolOption(m_options, "quota-disable"); } } /// /// Gets the display name of the backup /// public string BackupName { get { string tmp; m_options.TryGetValue("backup-name", out tmp); if (string.IsNullOrEmpty(tmp)) return DefaultBackupName; else return tmp; } set { m_options["backup-name"] = value; } } /// /// Gets the ID of the backup /// public string BackupId { get { m_options.TryGetValue("backup-id", out var tmp); return tmp; } } /// /// Gets the ID of the machine /// public string MachineId { get { if (m_options.TryGetValue("machine-id", out var tmp)) return tmp; return Library.AutoUpdater.UpdaterManager.InstallID; } } /// /// Gets the path to the database /// public string Dbpath { get { string tmp; m_options.TryGetValue("dbpath", out tmp); return tmp; } set { m_options["dbpath"] = value; } } /// /// Gets a value indicating whether a blocksize has been specified /// public bool HasBlocksize { get { return m_options.ContainsKey("blocksize") && !string.IsNullOrEmpty(m_options["blocksize"]); } } /// /// Gets the size of file-blocks /// public int Blocksize { get { string tmp; if (!m_options.TryGetValue("blocksize", out tmp)) tmp = DEFAULT_BLOCKSIZE; long blocksize = Library.Utility.Sizeparser.ParseSize(tmp, "kb"); if (blocksize > int.MaxValue || blocksize < 1024) throw new ArgumentOutOfRangeException(nameof(blocksize), string.Format("The blocksize cannot be less than {0}, nor larger than {1}", 1024, int.MaxValue)); return (int)blocksize; } } /// /// Cache for the block hash size value, to avoid creating new hash instances just to get the size /// private KeyValuePair m_cachedBlockHashSize; /// /// Gets the size of the blockhash in bytes. /// /// The size of the blockhash. public int BlockhashSize { get { if (m_cachedBlockHashSize.Key != BlockHashAlgorithm) m_cachedBlockHashSize = new KeyValuePair(BlockHashAlgorithm, HashFactory.HashSizeBytes(BlockHashAlgorithm)); return m_cachedBlockHashSize.Value; } } /// /// Gets a flag indicating if metadata for files and folders should be ignored /// public bool SkipMetadata { get { return Library.Utility.Utility.ParseBoolOption(m_options, "skip-metadata"); } } /// /// Gets a flag indicating if empty folders should be ignored /// public bool ExcludeEmptyFolders { get { return Library.Utility.Utility.ParseBoolOption(m_options, "exclude-empty-folders"); } } /// /// Gets a flag indicating if during restores metadata should be applied to the symlink target. /// Setting this to true can result in errors if the target no longer exists. /// public bool RestoreSymlinkMetadata { get { return Library.Utility.Utility.ParseBoolOption(m_options, "restore-symlink-metadata"); } } /// /// Gets a flag indicating if permissions should be restored /// public bool RestorePermissions { get { return Library.Utility.Utility.ParseBoolOption(m_options, "restore-permissions"); } } /// /// Gets a flag indicating if file hashes are checked after a restore /// public bool PerformRestoredFileVerification { get { return !Library.Utility.Utility.ParseBoolOption(m_options, "skip-restore-verification"); } } /// /// Gets a flag indicating if synthetic filelist generation is disabled /// public bool DisableSyntheticFilelist { get { return Library.Utility.Utility.ParseBoolOption(m_options, "disable-synthetic-filelist"); } } /// /// Flag indicating if the in-memory block cache is used /// public bool UseBlockCache { get { return Library.Utility.Utility.ParseBoolOption(m_options, "use-block-cache"); } } /// /// Gets the compact threshold /// public long Threshold { get { string v; m_options.TryGetValue("threshold", out v); if (string.IsNullOrEmpty(v)) return DEFAULT_THRESHOLD; return Convert.ToInt64(v); } } /// /// Gets the size of small volumes /// public long SmallFileSize { get { string v; m_options.TryGetValue("small-file-size", out v); if (string.IsNullOrEmpty(v)) return this.VolumeSize / 5; return Library.Utility.Sizeparser.ParseSize(v, "mb"); } } /// /// Gets the maximum number of small volumes /// public long SmallFileMaxCount { get { string v; m_options.TryGetValue("small-file-max-count", out v); if (string.IsNullOrEmpty(v)) return DEFAULT_SMALL_FILE_MAX_COUNT; return Convert.ToInt64(v); } } /// /// List of files to check for changes /// public string[] ChangedFilelist { get { string v; m_options.TryGetValue("changed-files", out v); if (string.IsNullOrEmpty(v)) return null; return v.Split(new char[] { System.IO.Path.PathSeparator }, StringSplitOptions.RemoveEmptyEntries); } } /// /// List of files to mark as deleted /// public string[] DeletedFilelist { get { string v; m_options.TryGetValue("deleted-files", out v); if (string.IsNullOrEmpty(v)) return null; return v.Split(new char[] { System.IO.Path.PathSeparator }, StringSplitOptions.RemoveEmptyEntries); } } /// /// List of filenames that are used to exclude a folder /// public string[] IgnoreFilenames { get { string v; m_options.TryGetValue("ignore-filenames", out v); if (string.IsNullOrEmpty(v)) return null; return v.Split(new char[] { System.IO.Path.PathSeparator }, StringSplitOptions.RemoveEmptyEntries); } } /// /// Alternate restore path /// public string Restorepath { get { string v; m_options.TryGetValue("restore-path", out v); return v; } } /// /// Gets the index file usage method /// public IndexFileStrategy IndexfilePolicy { get { string strategy; if (!m_options.TryGetValue("index-file-policy", out strategy)) strategy = ""; IndexFileStrategy res; if (!Enum.TryParse(strategy, true, out res)) res = IndexFileStrategy.Full; return res; } } /// /// Gets a flag indicating if the check for files on the remote storage should be omitted /// public bool NoBackendverification { get { return Library.Utility.Utility.ParseBoolOption(m_options, "no-backend-verification"); } } /// /// Gets the percentage of samples to test during a backup operation /// public decimal BackupTestPercentage { get { m_options.TryGetValue("backup-test-percentage", out string s); if (string.IsNullOrEmpty(s)) { return 0.1m; } decimal percentage; try { percentage = decimal.Parse(s, CultureInfo.InvariantCulture); } catch (Exception ex) { throw new ArgumentException("The value provided for the backup-test-percentage option must lie between 0 and 100.", ex); } if ((percentage < 0) || (percentage > 100)) { throw new ArgumentOutOfRangeException(nameof(percentage), "The value provided for the backup-test-percentage option must lie between 0 and 100."); } return percentage; } } /// /// Gets the number of samples to test during a backup operation /// public long BackupTestSampleCount { get { string s; m_options.TryGetValue("backup-test-samples", out s); if (string.IsNullOrEmpty(s)) return 1; return long.Parse(s); } } /// /// Gets a flag indicating if compacting should not be done automatically /// public bool NoAutoCompact { get { return Library.Utility.Utility.ParseBoolOption(m_options, "no-auto-compact"); } } /// /// Gets the minimum time that must elapse after last compaction before running next automatic compaction /// public TimeSpan AutoCompactInterval { get { if (!m_options.ContainsKey("auto-compact-interval") || string.IsNullOrEmpty(m_options["auto-compact-interval"])) return TimeSpan.Zero; else return Library.Utility.Timeparser.ParseTimeSpan(m_options["auto-compact-interval"]); } } /// /// Gets a flag indicating if compacting should not be done automatically /// public bool AllowMissingSource { get { return Library.Utility.Utility.ParseBoolOption(m_options, "allow-missing-source"); } } /// /// Gets a value indicating if a verification file should be uploaded after changing the remote store /// public bool UploadVerificationFile { get { return Library.Utility.Utility.ParseBoolOption(m_options, "upload-verification-file"); } } /// /// Gets a value indicating if a passphrase change is allowed /// public bool AllowPassphraseChange { get { return Library.Utility.Utility.ParseBoolOption(m_options, "allow-passphrase-change"); } } /// /// Gets a flag indicating if the current operation should merely output the changes /// public bool Dryrun { get { if (m_options.ContainsKey("dry-run")) return Library.Utility.Utility.ParseBoolOption(m_options, "dry-run"); else return Library.Utility.Utility.ParseBoolOption(m_options, "dryrun"); } } /// /// Gets a value indicating if the remote verification is deep /// public RemoteTestStrategy FullRemoteVerification { get { string policy; if (!m_options.TryGetValue("full-remote-verification", out policy)) policy = "False"; RemoteTestStrategy r; if (!Enum.TryParse(policy, true, out r)) r = RemoteTestStrategy.True; return r; } } /// /// The block hash algorithm to use /// public string BlockHashAlgorithm { get { string v; m_options.TryGetValue("block-hash-algorithm", out v); if (string.IsNullOrEmpty(v)) return DEFAULT_BLOCK_HASH_ALGORITHM; return v; } } /// /// The file hash algorithm to use /// public string FileHashAlgorithm { get { string v; m_options.TryGetValue("file-hash-algorithm", out v); if (string.IsNullOrEmpty(v)) return DEFAULT_FILE_HASH_ALGORITHM; return v; } } /// /// Gets a value indicating whether local blocks usage should be used for restore. /// /// true if no local blocks; otherwise, false. public bool UseLocalBlocks { get { return Library.Utility.Utility.ParseBoolOption(m_options, "restore-with-local-blocks"); } } /// /// Gets a flag indicating if the local database should not be used /// /// true if no local db is used; otherwise, false. public bool NoLocalDb { get { return Library.Utility.Utility.ParseBoolOption(m_options, "no-local-db"); } } /// /// Gets a flag indicating if the local database should not be used /// /// true if no local db is used; otherwise, false. public bool DontCompressRestorePaths { get { return Library.Utility.Utility.ParseBoolOption(m_options, "dont-compress-restore-paths"); } } /// /// Gets a flag indicating if block hashes are checked before being applied /// /// true if block hashes are checked; otherwise, false. public bool FullBlockVerification { get { return Library.Utility.Utility.ParseBoolOption(m_options, "full-block-verification"); } } /// /// Gets a flag indicating if the repair process will only restore paths /// /// true if only paths are restored; otherwise, false. public bool RepairOnlyPaths { get { return Library.Utility.Utility.ParseBoolOption(m_options, "repair-only-paths"); } } /// /// Gets a flag indicating if the repair process will always use blocks /// /// true if repair process always use blocks; otherwise, false. public bool RepairForceBlockUse { get { return Library.Utility.Utility.ParseBoolOption(m_options, "repair-force-block-use"); } } /// /// Gets a flag indicating whether the VACUUM operation should ever be run automatically. /// public bool AutoVacuum { get { return GetBool("auto-vacuum"); } } /// /// Gets the minimum time that must elapse after last vacuum before running next automatic vacuum /// public TimeSpan AutoVacuumInterval { get { if (!m_options.ContainsKey("auto-vacuum-interval") || string.IsNullOrEmpty(m_options["auto-vacuum-interval"])) return TimeSpan.Zero; else return Library.Utility.Timeparser.ParseTimeSpan(m_options["auto-vacuum-interval"]); } } /// /// Gets a flag indicating if the local filescanner should be disabled /// /// true if the filescanner should be disabled; otherwise, false. public bool DisableFileScanner { get { return Library.Utility.Utility.ParseBoolOption(m_options, "disable-file-scanner"); } } /// /// Gets a flag indicating if the filelist consistency checks should be disabled /// /// true if the filelist consistency checks should be disabled; otherwise, false. public bool DisableFilelistConsistencyChecks { get { return Library.Utility.Utility.ParseBoolOption(m_options, "disable-filelist-consistency-checks"); } } /// /// Gets a flag indicating whether the backup should be disabled when on battery power. /// /// true if the backup should be disabled when on battery power; otherwise, false. public bool DisableOnBattery { get { return Library.Utility.Utility.ParseBoolOption(m_options, "disable-on-battery"); } } /// /// Gets a value indicating if missing dblock files are attempted created /// public bool RebuildMissingDblockFiles { get { return GetBool("rebuild-missing-dblock-files"); } } /// /// Gets the threshold for when log data should be cleaned /// public DateTime LogRetention { get { string pts; if (!m_options.TryGetValue("log-retention", out pts)) pts = DEFAULT_LOG_RETENTION; return Library.Utility.Timeparser.ParseTimeInterval(pts, DateTime.Now, true); } } /// /// Gets the number of concurrent threads /// public int ConcurrencyMaxThreads { get { string value; if (!m_options.TryGetValue("concurrency-max-threads", out value)) value = null; if (string.IsNullOrEmpty(value)) return 0; else return int.Parse(value); } } /// /// Gets the number of concurrent block hashers /// public int ConcurrencyBlockHashers { get { string value; if (!m_options.TryGetValue("concurrency-block-hashers", out value)) value = null; if (string.IsNullOrEmpty(value)) return DEFAULT_BLOCK_HASHERS; else return Math.Max(1, int.Parse(value)); } } /// /// Gets the number of concurrent block hashers /// public int ConcurrencyCompressors { get { string value; if (!m_options.TryGetValue("concurrency-compressors", out value)) value = null; if (string.IsNullOrEmpty(value)) return DEFAULT_COMPRESSORS; else return Math.Max(1, int.Parse(value)); } } /// /// Gets a lookup table with compression hints, the key is the file extension with the leading period /// public IDictionary CompressionHints { get { if (m_compressionHints == null) { var hints = new Dictionary(StringComparer.OrdinalIgnoreCase); // Ignore file system case sensitivity, since file extensions case rarely indicates type string file; if (!m_options.TryGetValue("compression-extension-file", out file)) file = DEFAULT_COMPRESSED_EXTENSION_FILE; if (!string.IsNullOrEmpty(file) && System.IO.File.Exists(file)) foreach (var _line in Library.Utility.Utility.ReadFileWithDefaultEncoding(file).Split('\n')) { var line = _line.Trim(); var lix = line.IndexOf(' '); if (lix > 0) line = line.Substring(0, lix); if (line.Length >= 2 && line[0] == '.') hints[line] = CompressionHint.Noncompressible; } //Don't try again, if the file does not exist m_compressionHints = hints; } return m_compressionHints; } } /// /// Gets a compression hint from a filename /// /// The filename to get the hint for /// The compression hint public CompressionHint GetCompressionHintFromFilename(string filename) { CompressionHint h; if (!CompressionHints.TryGetValue(System.IO.Path.GetExtension(filename), out h)) return CompressionHint.Default; return h; } /// /// Gets a list of modules, the key indicates if they are loaded /// public List> LoadedModules { get { return m_loadedModules; } } /// /// Helper method to extract boolean values. /// If the option is not present, it it's value is false. /// If the option is present it's value is true, unless the option's value is false, off or 0 /// /// The name of the option to read /// The interpreted value of the option private bool GetBool(string name) { return Library.Utility.Utility.ParseBoolOption(m_options, name); } /// /// Class for handling a single RetentionPolicy timeframe-interval-pair /// public class RetentionPolicyValue { public readonly TimeSpan Timeframe; public readonly TimeSpan Interval; public RetentionPolicyValue(TimeSpan timeframe, TimeSpan interval) { if (timeframe < TimeSpan.Zero) { throw new ArgumentOutOfRangeException(nameof(timeframe), string.Format("The timeframe cannot be negative: '{0}'", timeframe)); } if (interval < TimeSpan.Zero) { throw new ArgumentOutOfRangeException(nameof(interval), string.Format("The interval cannot be negative: '{0}'", interval)); } this.Timeframe = timeframe; this.Interval = interval; } /// /// Returns whether this is an unlimited timeframe or not /// /// public Boolean IsUnlimtedTimeframe() { // Timeframes equal or bigger than the maximum TimeSpan effectively represent an unlimited timeframe return Timeframe >= TimeSpan.MaxValue; } /// /// Returns whether all versions in this timeframe should be kept or not /// /// public Boolean IsKeepAllVersions() { /// Intervals between two versions that are equal or smaller than zero effectivly result in /// all versions in that timeframe being kept. return Interval <= TimeSpan.Zero; } public override string ToString() { return (IsUnlimtedTimeframe() ? "Unlimited" : Timeframe.ToString()) + " / " + (IsKeepAllVersions() ? "Keep all" : Interval.ToString()); } /// /// Parses a string representation of a timeframe-interval-pair and returns a RetentionPolicyValue object /// /// public static RetentionPolicyValue CreateFromString(string rententionPolicyValueString) { var periodInterval = rententionPolicyValueString.Split(':'); TimeSpan timeframe; // Timeframe "U" (= Unlimited) means: For unlimited time keep one version every X interval. // So the timeframe has to span the maximum time possible. if (String.Equals(periodInterval[0], "U", StringComparison.OrdinalIgnoreCase)) { timeframe = TimeSpan.MaxValue; } else { timeframe = Library.Utility.Timeparser.ParseTimeSpan(periodInterval[0]); } TimeSpan interval; // Interval "U" (= Unlimited) means: For period X keep all versions. // So the interval between two versions has to be zero. if (String.Equals(periodInterval[1], "U", StringComparison.OrdinalIgnoreCase)) { interval = TimeSpan.Zero; } else { interval = Library.Utility.Timeparser.ParseTimeSpan(periodInterval[1]); } return new RetentionPolicyValue(timeframe, interval); } } } }