822 lines
39 KiB
C#
822 lines
39 KiB
C#
// Copyright (C) 2025, 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 Duplicati.Library.Backend;
|
|
using Duplicati.Library.Common.IO;
|
|
using Duplicati.Library.Interface;
|
|
using Duplicati.Library.Localization.Short;
|
|
using Duplicati.Library.Main.Backend;
|
|
using Duplicati.Library.Logging;
|
|
using Duplicati.Library.Utility;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.CommandLine;
|
|
using System.CommandLine.NamingConventionBinder;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
|
|
|
|
namespace RemoteSynchronization
|
|
{
|
|
/// <summary>
|
|
/// Global configuration for the tool. Should be set after parsing the commandline arguments.
|
|
/// </summary>
|
|
public sealed record Config
|
|
(
|
|
// Arguments
|
|
string Src,
|
|
string Dst,
|
|
|
|
// Options
|
|
bool AutoCreateFolders,
|
|
int BackendRetries,
|
|
int BackendRetryDelay,
|
|
bool BackendRetryWithExponentialBackoff,
|
|
bool Confirm,
|
|
bool DryRun,
|
|
List<string> DstOptions,
|
|
bool Force,
|
|
List<string> GlobalOptions,
|
|
string LogFile,
|
|
string LogLevel,
|
|
bool ParseArgumentsOnly,
|
|
bool Progress,
|
|
bool Retention,
|
|
int Retry,
|
|
List<string> SrcOptions,
|
|
bool VerifyContents,
|
|
bool VerifyGetAfterPut
|
|
);
|
|
|
|
/// <summary>
|
|
/// Remote synchronization tool.
|
|
/// </summary>
|
|
public static class RemoteSynchronizationRunner
|
|
{
|
|
|
|
/// <summary>
|
|
/// The log tag for this tool.
|
|
/// </summary>
|
|
private static readonly string LOGTAG = Duplicati.Library.Logging.Log.LogTagFromType(typeof(RemoteSynchronizationRunner));
|
|
|
|
/// <summary>
|
|
/// Entry point for running the tool logic with parsed arguments.
|
|
/// </summary>
|
|
/// <param name="args">The commandline arguments</param>
|
|
/// <returns>0 on success, -1 on abort, and the number of errors encountered otherwise.</returns>
|
|
public static async Task<int> RunAsync(string[] args)
|
|
{
|
|
var arg_src = new Argument<string>(name: "backend_src", description: Strings.SourceBackendDescription);
|
|
var arg_dst = new Argument<string>(name: "backend_dst", description: Strings.DestinationBackendDescription);
|
|
|
|
var root_cmd = new RootCommand(Strings.RootCommandDescription)
|
|
{
|
|
arg_src,
|
|
arg_dst,
|
|
|
|
new Option<bool>(aliases: ["--auto-create-folders"], description: Strings.AutoCreateFoldersDescription, getDefaultValue: () => true),
|
|
new Option<int>(aliases: ["--backend-retries"], description: Strings.BackendRetriesDescription, getDefaultValue: () => 3) { Arity = ArgumentArity.ExactlyOne },
|
|
new Option<int>(aliases: ["--backend-retry-delay"], description: Strings.BackendRetryDelayDescription, getDefaultValue: () => 1000) { Arity = ArgumentArity.ExactlyOne },
|
|
new Option<bool>(aliases: ["--backend-retry-with-exponential-backoff"], description: Strings.BackendRetryWithExponentialBackoffDescription, getDefaultValue: () => true),
|
|
new Option<bool>(aliases: ["--confirm", "--yes", "-y"], description: Strings.ConfirmDescription, getDefaultValue: () => false),
|
|
new Option<bool>(aliases: ["--dry-run", "-d"], description: Strings.DryRunDescription, getDefaultValue: () => false),
|
|
OptionWithMultipleTokens(aliases: ["--dst-options"], description: Strings.DstOptionsDescription, getDefaultValue: () => []),
|
|
new Option<bool>(aliases: ["--force", "-f"], description: Strings.ForceDescription, getDefaultValue: () => false),
|
|
OptionWithMultipleTokens(aliases: ["--global-options"], description: Strings.GlobalOptionsDescription, getDefaultValue: () => []),
|
|
new Option<string>(aliases: ["--log-file"], description: Strings.LogFileDescription, getDefaultValue: () => "") { Arity = ArgumentArity.ExactlyOne },
|
|
new Option<string>(aliases: ["--log-level"], description: Strings.LogLevelDescription, getDefaultValue: () => "Information") { Arity = ArgumentArity.ExactlyOne },
|
|
new Option<bool>(aliases: ["--parse-arguments-only"], description: Strings.ParseArgumentsOnlyDescription, getDefaultValue: () => false),
|
|
new Option<bool>(aliases: ["--progress"], description: Strings.ProgressDescription, getDefaultValue: () => false),
|
|
new Option<bool>(aliases: ["--retention"], description: Strings.RetentionDescription, getDefaultValue: () => false),
|
|
new Option<int>(aliases: ["--retry"], description: Strings.RetryDescription, getDefaultValue: () => 3) { Arity = ArgumentArity.ExactlyOne },
|
|
OptionWithMultipleTokens(aliases: ["--src-options"], description: Strings.SrcOptionsDescription, getDefaultValue: () => []),
|
|
new Option<bool>(aliases: ["--verify-contents"], description: Strings.VerifyContentsDescription, getDefaultValue: () => false),
|
|
new Option<bool>(aliases: ["--verify-get-after-put"], description: Strings.VerifyGetAfterPutDescription, getDefaultValue: () => false),
|
|
};
|
|
|
|
root_cmd.Handler = CommandHandler.Create((string backend_src, string backend_dst, Config config, CancellationToken token) =>
|
|
{
|
|
var config_with_args = config with { Dst = backend_dst, Src = backend_src };
|
|
|
|
return Run(config_with_args, token);
|
|
});
|
|
|
|
return await root_cmd.InvokeAsync(args).ConfigureAwait(false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The main logic of the tool.
|
|
/// </summary>
|
|
/// <param name="config">The parsed configuration for the tool.</param>
|
|
/// <param name="token">The cancellation token to use for the asynchronous operations.</param>
|
|
/// <returns>The return code for the main entry; 0 on success.</returns>
|
|
public static async Task<int> Run(Config config, CancellationToken token)
|
|
{
|
|
// Parse the log level
|
|
var log_level_parsed = Enum.TryParse<Duplicati.Library.Logging.LogMessageType>(config.LogLevel, true, out var log_level_enum);
|
|
log_level_enum = log_level_parsed ? log_level_enum : Duplicati.Library.Logging.LogMessageType.Information;
|
|
|
|
if (!string.IsNullOrEmpty(config.LogFile))
|
|
{
|
|
using var console_sink = new StreamLogDestination(Console.OpenStandardOutput());
|
|
|
|
// Parse the log file
|
|
StreamLogDestination? log_file_sink = null;
|
|
if (!string.IsNullOrEmpty(config.LogFile))
|
|
{
|
|
string log_file_dir = SystemIO.IO_OS.PathGetDirectoryName(config.LogFile);
|
|
if (!string.IsNullOrEmpty(log_file_dir) && !SystemIO.IO_OS.DirectoryExists(log_file_dir))
|
|
SystemIO.IO_OS.DirectoryCreate(log_file_dir);
|
|
log_file_sink = new StreamLogDestination(config.LogFile);
|
|
}
|
|
using var multi_sink = new MultiLogDestination([console_sink, log_file_sink]);
|
|
|
|
// Start the logging scope
|
|
using var _ = Duplicati.Library.Logging.Log.StartScope(multi_sink, log_level_enum);
|
|
|
|
return await RunCore(config, token).ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
return await RunCore(config, token).ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The core logic of the tool, without logging setup.
|
|
/// </summary>
|
|
/// <param name="config">The parsed configuration for the tool.</param>
|
|
/// <param name="token">The cancellation token to use for the asynchronous operations.</param>
|
|
/// <returns>The return code for the main entry; 0 on success.</returns>
|
|
private static async Task<int> RunCore(Config config, CancellationToken token)
|
|
{
|
|
// Unpack and parse the multi token options
|
|
var global_options = ParseOptions(config.GlobalOptions);
|
|
|
|
var src_opts = ParseOptions(config.SrcOptions);
|
|
var dst_opts = ParseOptions(config.DstOptions);
|
|
|
|
// Merge the global options into the source and destination options. The global options will be overridden by the source and destination options.
|
|
foreach (var x in global_options)
|
|
{
|
|
if (!src_opts.ContainsKey(x.Key))
|
|
src_opts[x.Key] = x.Value;
|
|
if (!dst_opts.ContainsKey(x.Key))
|
|
dst_opts[x.Key] = x.Value;
|
|
}
|
|
|
|
// Check if we only had to parse the arguments
|
|
if (config.ParseArgumentsOnly)
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync", "Arguments parsed successfully; {0}; exiting.", config);
|
|
return 0;
|
|
}
|
|
|
|
using var b1m = new LightWeightBackendManager(config.Src, src_opts, config.BackendRetries, config.BackendRetryDelay, config.BackendRetryWithExponentialBackoff);
|
|
using var b2m = new LightWeightBackendManager(config.Dst, dst_opts, config.BackendRetries, config.BackendRetryDelay, config.BackendRetryWithExponentialBackoff);
|
|
|
|
// Prepare the operations
|
|
var (to_copy, to_delete, to_verify) = await PrepareFileLists(b1m, b2m, config, token).ConfigureAwait(false);
|
|
|
|
// Verify the files if requested. If the files are not verified, they will be deleted and copied again.
|
|
long verified = 0, failed_verify = 0;
|
|
if (config.VerifyContents)
|
|
{
|
|
// As this is a potentially slow operation, ask for confirmation of the verification)
|
|
if (!config.Confirm)
|
|
{
|
|
Console.WriteLine($"This will verify {to_verify.Count()} files before copying them. Do you want to continue? [y/N]");
|
|
var response = Console.ReadLine();
|
|
if (!response?.Equals("y", StringComparison.CurrentCultureIgnoreCase) ?? true)
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync", "Aborted");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
var not_verified = await VerifyAsync(b1m, b2m, to_verify, config, token).ConfigureAwait(false);
|
|
failed_verify = not_verified.Count();
|
|
verified = to_verify.Count() - failed_verify;
|
|
|
|
if (not_verified.Any())
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteWarningMessage(LOGTAG, "rsync", null,
|
|
"{0} files failed verification. They will be deleted and copied again.",
|
|
not_verified.Count());
|
|
to_delete = to_delete.Concat(not_verified);
|
|
to_copy = to_copy.Concat(not_verified);
|
|
}
|
|
}
|
|
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"The remote synchronization plan is to {0} {1} files from {2}, then copy {3} files from {4} to {2}.",
|
|
config.Retention ? "rename" : "delete",
|
|
to_delete.Count(), b2m.DisplayName, to_copy.Count(), b1m.DisplayName);
|
|
|
|
// As this is a potentially destructive operation, ask for confirmation
|
|
if (!config.Confirm)
|
|
{
|
|
var delete_rename = config.Retention ? "Rename" : "Delete";
|
|
Console.WriteLine($"This will perform the following actions (in order):");
|
|
Console.WriteLine($" - {delete_rename} {to_delete.Count()} files from {config.Dst}");
|
|
Console.WriteLine($" - Copy {to_copy.Count()} files from {config.Src} to {config.Dst}");
|
|
Console.WriteLine();
|
|
Console.WriteLine("Do you want to continue? [y/N]");
|
|
|
|
var response = Console.ReadLine();
|
|
if (!response?.Equals("y", StringComparison.CurrentCultureIgnoreCase) ?? true)
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync", "Aborted");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// Delete or rename the files that are not needed
|
|
long renamed = 0, deleted = 0;
|
|
if (config.Retention)
|
|
{
|
|
renamed = await RenameAsync(b2m, to_delete, config, token).ConfigureAwait(false);
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"Renamed {0} files in {1}", renamed, b2m.DisplayName);
|
|
}
|
|
else
|
|
{
|
|
deleted = await DeleteAsync(b2m, to_delete, config, token).ConfigureAwait(false);
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"Deleted {0} files from {1}", deleted, b2m.DisplayName);
|
|
}
|
|
|
|
// Copy the files
|
|
var (copied, copy_errors) = await CopyAsync(b1m, b2m, to_copy, config, token).ConfigureAwait(false);
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"Copied {0} files from {1} to {2}", copied, b1m.DisplayName, b2m.DisplayName);
|
|
|
|
// If there are still errors, retry a few times
|
|
if (copy_errors.Any())
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteWarningMessage(LOGTAG, "rsync", null,
|
|
"Could not copy {0} files.", copy_errors.Count());
|
|
if (config.Retry > 0)
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"Retrying {0} more times to copy the {1} files that failed",
|
|
config.Retry, copy_errors.Count());
|
|
for (int i = 0; i < config.Retry; i++)
|
|
{
|
|
await Task.Delay(5000).ConfigureAwait(false); // Wait 5 seconds before retrying
|
|
(copied, copy_errors) = await CopyAsync(b1m, b2m, copy_errors, config, token).ConfigureAwait(false);
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"Copied {0} files from {1} to {2}", copied, b1m.DisplayName, b2m.DisplayName);
|
|
if (!copy_errors.Any())
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (copy_errors.Any())
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteErrorMessage(LOGTAG, "rsync", null,
|
|
"Could not copy {0} files. Not retrying any more.", copy_errors.Count());
|
|
return copy_errors.Count();
|
|
}
|
|
}
|
|
|
|
// Results reporting
|
|
if (verified > 0)
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"Verified {0} files in {1} that didn't need to be copied",
|
|
verified, b2m.DisplayName);
|
|
if (failed_verify > 0)
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"Failed to verify {0} files in {1}, which were then attempted to be copied",
|
|
failed_verify, b2m.DisplayName);
|
|
if (copied > 0)
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"Copied {0} files from {1} to {2}", copied, b1m.DisplayName, b2m.DisplayName);
|
|
if (deleted > 0)
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"Deleted {0} files from {1}", deleted, b2m.DisplayName);
|
|
if (renamed > 0)
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"Renamed {0} files in {1}", renamed, b2m.DisplayName);
|
|
|
|
Duplicati.Library.Logging.Log.WriteInformationMessage(LOGTAG, "rsync",
|
|
"Remote synchronization completed successfully");
|
|
|
|
return 0;
|
|
}
|
|
|
|
// TODO have concurrency parameters: uploaders, downloaders
|
|
// TODO low memory mode, where things aren't kept in memory. Maybe utilize SQLite?
|
|
// TODO For convenience, have the option to launch a "duplicati test" on the destination backend after the synchronization
|
|
// TODO Save hash to minimize redownload
|
|
// TODO Duplicati Results
|
|
|
|
/// <summary>
|
|
/// Copies the files from one backend to another.
|
|
/// The files are copied one by one, and each file is verified after uploading if the verify flag is set.
|
|
/// </summary>
|
|
/// <param name="b_src">The source backend.</param>
|
|
/// <param name="b_dst">The destination backend.</param>
|
|
/// <param name="files">The files that will be copied.</param>
|
|
/// <param name="config">The parsed configuration for the tool.</param>
|
|
/// <param name="token">The cancellation token to use for the asynchronous operations.</param>
|
|
/// <returns>A tuple holding the number of succesful copies and a List of the files that failed.</returns>
|
|
private static async Task<(long, IEnumerable<IFileEntry>)> CopyAsync(LightWeightBackendManager b_src, LightWeightBackendManager b_dst, IEnumerable<IFileEntry> files, Config config, CancellationToken token)
|
|
{
|
|
long successful_copies = 0;
|
|
List<IFileEntry> errors = [];
|
|
long i = 0, n = files.Count();
|
|
var sw_get_src = new System.Diagnostics.Stopwatch();
|
|
var sw_put_dst = new System.Diagnostics.Stopwatch();
|
|
var sw_get_dst = new System.Diagnostics.Stopwatch();
|
|
var sw_get_cmp = new System.Diagnostics.Stopwatch();
|
|
|
|
foreach (var f in files)
|
|
{
|
|
if (config.Progress)
|
|
Console.Write($"\rCopying: {i}/{n}");
|
|
|
|
Duplicati.Library.Logging.Log.WriteVerboseMessage(LOGTAG, "rsync",
|
|
"Copying {0} from {1} to {2}", f.Name, b_src.DisplayName, b_dst.DisplayName);
|
|
|
|
using var s_src = Duplicati.Library.Utility.TempFileStream.Create();
|
|
|
|
try
|
|
{
|
|
sw_get_src.Start();
|
|
await b_src.GetAsync(f.Name, s_src, token).ConfigureAwait(false);
|
|
s_src.Position = 0;
|
|
sw_get_src.Stop();
|
|
if (config.DryRun)
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteDryrunMessage(LOGTAG, "rsync",
|
|
"Would write {0} bytes of {1} to {2}",
|
|
Duplicati.Library.Utility.Utility.FormatSizeString(s_src.Length),
|
|
f.Name, b_dst.DisplayName);
|
|
}
|
|
else
|
|
{
|
|
sw_put_dst.Start();
|
|
await b_dst.PutAsync(f.Name, s_src, token).ConfigureAwait(false);
|
|
s_src.Position = 0;
|
|
sw_put_dst.Stop();
|
|
if (config.VerifyGetAfterPut)
|
|
{
|
|
// Start calculating the hash of the source file while we are downloading
|
|
var srchashtask = Task.Run(() =>
|
|
{
|
|
using var hasher = HashFactory.CreateHasher("SHA256");
|
|
return Convert.ToBase64String(hasher.ComputeHash(s_src));
|
|
});
|
|
|
|
using var s_dst = Duplicati.Library.Utility.TempFileStream.Create();
|
|
|
|
sw_get_dst.Start();
|
|
await b_dst.GetAsync(f.Name, s_dst, token).ConfigureAwait(false);
|
|
s_dst.Position = 0;
|
|
sw_get_dst.Stop();
|
|
|
|
sw_get_cmp.Start();
|
|
string? err_string = null;
|
|
if (s_src.Length != s_dst.Length)
|
|
{
|
|
err_string = $"The sizes of the files do not match: {s_src.Length} != {s_dst.Length}.";
|
|
}
|
|
|
|
using var hasher = HashFactory.CreateHasher("SHA256");
|
|
var dsthash = Convert.ToBase64String(hasher.ComputeHash(s_dst));
|
|
|
|
if (await srchashtask.ConfigureAwait(false) != dsthash)
|
|
{
|
|
err_string = (err_string is null ? "" : err_string + " ") + "The contents of the files do not match.";
|
|
}
|
|
sw_get_cmp.Stop();
|
|
|
|
if (err_string is not null)
|
|
{
|
|
throw new Exception(err_string);
|
|
}
|
|
}
|
|
}
|
|
|
|
successful_copies++;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteErrorMessage(LOGTAG, "rsync", e,
|
|
"Error copying {0}: {1}", f.Name, e.Message);
|
|
errors.Add(f);
|
|
}
|
|
finally
|
|
{
|
|
i++;
|
|
|
|
// Stop any running timers
|
|
sw_get_src.Stop();
|
|
sw_put_dst.Stop();
|
|
sw_get_dst.Stop();
|
|
sw_get_cmp.Stop();
|
|
}
|
|
}
|
|
|
|
if (config.Progress)
|
|
Console.WriteLine($"\rCopying: {n}/{n}");
|
|
|
|
Duplicati.Library.Logging.Log.WriteProfilingMessage(LOGTAG, "rsync",
|
|
"Copy | Get source: {0} ms, Put destination: {1} ms, Get destination: {2} ms, Get compare: {3} ms",
|
|
TimeSpan.FromMilliseconds(sw_get_src.ElapsedMilliseconds),
|
|
TimeSpan.FromMilliseconds(sw_put_dst.ElapsedMilliseconds),
|
|
TimeSpan.FromMilliseconds(sw_get_dst.ElapsedMilliseconds),
|
|
TimeSpan.FromMilliseconds(sw_get_cmp.ElapsedMilliseconds));
|
|
|
|
return (successful_copies, errors);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes the files from a backend.
|
|
/// </summary>
|
|
/// <param name="b">The backend to delete the files from.</param>
|
|
/// <param name="files">The files to delete.</param>
|
|
/// <param name="config">The parsed configuration for the tool.</param>
|
|
/// <param name="token">The cancellation token to use for the asynchronous operations.</param>
|
|
/// <returns>The number of successful deletions.</returns>
|
|
private static async Task<long> DeleteAsync(LightWeightBackendManager b, IEnumerable<IFileEntry> files, Config config, CancellationToken token)
|
|
{
|
|
long successful_deletes = 0;
|
|
long i = 0, n = files.Count();
|
|
using var timer = new Duplicati.Library.Logging.Timer(LOGTAG, "rsync", "Delete operation");
|
|
|
|
foreach (var f in files)
|
|
{
|
|
if (n > 1 && config.Progress)
|
|
{
|
|
Console.Write($"\rDeleting: {i}/{n}");
|
|
}
|
|
|
|
Duplicati.Library.Logging.Log.WriteVerboseMessage(LOGTAG, "rsync",
|
|
"Deleting {0} from {1}", f.Name, b.DisplayName);
|
|
|
|
try
|
|
{
|
|
if (config.DryRun)
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteDryrunMessage(LOGTAG, "rsync",
|
|
"Would delete {0} from {1}", f.Name, b.DisplayName);
|
|
}
|
|
else
|
|
{
|
|
await b.DeleteAsync(f.Name, token).ConfigureAwait(false);
|
|
}
|
|
successful_deletes++;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteErrorMessage(LOGTAG, "rsync", e,
|
|
"Error deleting {0}: {1}", f.Name, e.Message);
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
if (config.Progress)
|
|
Console.WriteLine($"\rDeleting: {n}/{n}");
|
|
return successful_deletes;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates an option that allows multiple tokens and multiple arguments per token.
|
|
/// </summary>
|
|
/// <param name="aliases">The aliases for the option.</param>
|
|
/// <param name="description">The description for the option.</param>
|
|
/// <returns>The created option.</returns>
|
|
private static Option<List<string>> OptionWithMultipleTokens(string[] aliases, string description, Func<List<string>> getDefaultValue)
|
|
{
|
|
return new Option<List<string>>(aliases: aliases, description: description, getDefaultValue: getDefaultValue)
|
|
{
|
|
Arity = ArgumentArity.OneOrMore,
|
|
AllowMultipleArgumentsPerToken = true
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// A log destination that writes to multiple destinations.
|
|
/// </summary>
|
|
private sealed class MultiLogDestination : ILogDestination, IDisposable
|
|
{
|
|
private readonly List<ILogDestination> m_destinations;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the MultiLogDestination class.
|
|
/// </summary>
|
|
/// <param name="destinations">The log destinations to write to.</param>
|
|
public MultiLogDestination(IEnumerable<ILogDestination?> destinations)
|
|
{
|
|
m_destinations = destinations.Where(x => x != null).Cast<ILogDestination>().ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes a log entry to all destinations.
|
|
/// </summary>
|
|
/// <param name="entry">The log entry to write.</param>
|
|
public void WriteMessage(LogEntry entry)
|
|
{
|
|
foreach (var destination in m_destinations)
|
|
destination.WriteMessage(entry);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Disposes of the resources used by this instance.
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
foreach (var destination in m_destinations)
|
|
if (destination is IDisposable disposable)
|
|
disposable.Dispose();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses the options from a list of strings.
|
|
/// Each option should be in the format "key=value". If the value contains spaces,
|
|
/// it should be enclosed in quotes, e.g. "key=\"value with spaces\"".
|
|
/// </summary>
|
|
/// <param name="options">The list of string options to parse</param>
|
|
/// <returns>A dictionary with the parsed options, where the key is the option name and the value is the option value.</returns>
|
|
/// <exception cref="ArgumentException">If an option was not parsed correctly.</exception>
|
|
private static Dictionary<string, string> ParseOptions(IEnumerable<string> options)
|
|
{
|
|
var result = options
|
|
.Select(x => x.Split('='))
|
|
.ToDictionary(x => x[0], x => string.Join("=", x.Skip(1)));
|
|
|
|
// Double check that the options are valid by reconstructing them from the dictionary
|
|
foreach (var opt in result.Select(x => $"{x.Key}={x.Value}"))
|
|
{
|
|
if (!options.Contains(opt))
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteErrorMessage(LOGTAG, "rsync", null,
|
|
"The source option '{0}' is not valid. Please check the syntax.", opt);
|
|
throw new ArgumentException($"The source option '{opt}' has not been parsed correctly.");
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prepares the lists of files to copy, delete and verify.
|
|
/// The files to copy are the files that are not in the destination, have a different size or have a more recent modification date.
|
|
/// The files to delete are the files that are found in the destination but not found in the source.
|
|
/// The files to verify are the files that are found in both the source and the destination, and that have the same size and modification date.
|
|
/// </summary>
|
|
/// <param name="b_src">The source lightweight backend manager.</param>
|
|
/// <param name="b_dst">The destination lightweight backend manager.</param>
|
|
/// <param name="config">The parsed configuration for the tool.</param>
|
|
/// <param name="token">The cancellation token to use for the asynchronous operations.</param>
|
|
/// <returns>A tuple of Lists each holding the files to copy, delete and verify.</returns>
|
|
private static async Task<(IEnumerable<IFileEntry>, IEnumerable<IFileEntry>, IEnumerable<IFileEntry>)> PrepareFileLists(LightWeightBackendManager b_src, LightWeightBackendManager b_dst, Config config, CancellationToken token)
|
|
{
|
|
IEnumerable<IFileEntry> files_src, files_dst;
|
|
|
|
using (new Duplicati.Library.Logging.Timer(LOGTAG, "rsync", "Prepare | List source"))
|
|
files_src = await b_src.ListAsync(token).ConfigureAwait(false);
|
|
|
|
using (new Duplicati.Library.Logging.Timer(LOGTAG, "rsync", "Prepare | List destination"))
|
|
files_dst = await b_dst.ListAsync(token).ConfigureAwait(false);
|
|
|
|
// Shortcut for force
|
|
if (config.Force)
|
|
{
|
|
return (files_src, files_dst, []);
|
|
}
|
|
|
|
// Shortcut for empty destination
|
|
if (!files_dst.Any())
|
|
{
|
|
return (files_src, [], []);
|
|
}
|
|
|
|
Dictionary<string, IFileEntry> lookup_src, lookup_dst;
|
|
using (new Duplicati.Library.Logging.Timer(LOGTAG, "rsync", "Prepare | Build lookup for source and destination"))
|
|
{
|
|
lookup_src = files_src.ToDictionary(x => x.Name);
|
|
lookup_dst = files_dst.ToDictionary(x => x.Name);
|
|
}
|
|
|
|
var to_copy = new List<IFileEntry>();
|
|
var to_delete = new HashSet<string>();
|
|
var to_verify = new List<IFileEntry>();
|
|
|
|
// Find all of the files in src that are not in dst, where the dst has a different size than src or src a more recent modification date than dst
|
|
using (new Duplicati.Library.Logging.Timer(LOGTAG, "rsync", "Prepare | Check the files that are present in source against destination"))
|
|
foreach (var f_src in files_src)
|
|
{
|
|
if (lookup_dst.TryGetValue(f_src.Name, out var f_dst))
|
|
{
|
|
if (f_src.Size != f_dst.Size || f_src.LastModification > f_dst.LastModification)
|
|
{
|
|
// The file is different, so we need to copy it
|
|
to_copy.Add(f_src);
|
|
to_delete.Add(f_dst.Name);
|
|
}
|
|
else
|
|
{
|
|
// The file seems to be the same, so we need to verify it if the user wants to
|
|
to_verify.Add(f_src);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The file is not in the destination, so we need to copy it
|
|
to_copy.Add(f_src);
|
|
}
|
|
}
|
|
|
|
// Find all of the files in dst that are not in src
|
|
using (new Duplicati.Library.Logging.Timer(LOGTAG, "rsync", "Prepare | Check the files that are present in destination against source"))
|
|
foreach (var f_dst in files_dst)
|
|
{
|
|
if (to_delete.Contains(f_dst.Name))
|
|
continue;
|
|
|
|
if (!lookup_src.ContainsKey(f_dst.Name))
|
|
{
|
|
to_delete.Add(f_dst.Name);
|
|
}
|
|
}
|
|
|
|
List<IFileEntry> to_delete_lookedup;
|
|
using (new Duplicati.Library.Logging.Timer(LOGTAG, "rsync", "Prepare | Lookup the files to delete"))
|
|
to_delete_lookedup = [.. to_delete.Select(x => lookup_dst[x])];
|
|
|
|
return (to_copy, to_delete_lookedup, to_verify);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Renames the files in a backend.
|
|
/// The renaming is done by deleting the file and re-uploading it with a new name.
|
|
/// </summary>
|
|
/// <param name="bm">The lightweight backend manager to issue rename operations to.</param>
|
|
/// <param name="files">The files to rename.</param>
|
|
/// <param name="config">The parsed configuration for the tool.</param>
|
|
/// <param name="token">The cancellation token to use for the asynchronous operations.</param>
|
|
/// <returns>The number of successful renames.</returns>
|
|
private static async Task<long> RenameAsync(LightWeightBackendManager bm, IEnumerable<IFileEntry> files, Config config, CancellationToken token)
|
|
{
|
|
long successful_renames = 0;
|
|
string prefix = $"{System.DateTime.UtcNow:yyyyMMddHHmmss}.old";
|
|
using var downloaded = new MemoryStream();
|
|
long i = 0, n = files.Count();
|
|
|
|
var sw = new System.Diagnostics.Stopwatch();
|
|
|
|
foreach (var f in files)
|
|
{
|
|
if (config.Progress)
|
|
Console.Write($"\rRenaming: {i}/{n}");
|
|
|
|
Duplicati.Library.Logging.Log.WriteVerboseMessage(LOGTAG, "rsync",
|
|
"Renaming {0} to {1}.{0} by calling Rename on {2}",
|
|
f.Name, prefix, bm.DisplayName);
|
|
|
|
try
|
|
{
|
|
if (config.DryRun)
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteDryrunMessage(LOGTAG, "rsync",
|
|
"Would rename {0} to {1}.{0} by calling Rename on {2}",
|
|
f.Name, prefix, bm.DisplayName);
|
|
}
|
|
else
|
|
{
|
|
sw.Start();
|
|
await bm.RenameAsync(f.Name, $"{prefix}.{f.Name}", token).ConfigureAwait(false);
|
|
sw.Stop();
|
|
}
|
|
successful_renames++;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Duplicati.Library.Logging.Log.WriteErrorMessage(LOGTAG, "rsync", e,
|
|
"Error renaming {0}: {1}", f.Name, e.Message);
|
|
}
|
|
finally
|
|
{
|
|
// Ensure the timer is stopped
|
|
sw.Stop();
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
Duplicati.Library.Logging.Log.WriteProfilingMessage(LOGTAG, "rsync",
|
|
"Rename: {0} ms",
|
|
TimeSpan.FromMilliseconds(sw.ElapsedMilliseconds));
|
|
|
|
if (config.Progress)
|
|
Console.WriteLine($"\rRenaming: {n}/{n}");
|
|
|
|
return successful_renames;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifies the files in the destination backend.
|
|
/// The verification is done by downloading the files from the destination backend and comparing them to the source files.
|
|
/// </summary>
|
|
/// <param name="b_src">The source lightweight backend manager.</param>
|
|
/// <param name="b_dst">The destination lightweight backend manager.</param>
|
|
/// <param name="files">The files to verify.</param>
|
|
/// <param name="config">The parsed configuration for the tool.</param>
|
|
/// <param name="token">The cancellation token to use for the asynchronous operations.</param>
|
|
/// <returns>A list of the files that failed verification.</returns>
|
|
private static async Task<IEnumerable<IFileEntry>> VerifyAsync(LightWeightBackendManager b_src, LightWeightBackendManager b_dst, IEnumerable<IFileEntry> files, Config config, CancellationToken token)
|
|
{
|
|
var errors = new List<IFileEntry>();
|
|
using var s_src = new MemoryStream();
|
|
using var s_dst = new MemoryStream();
|
|
long i = 0, n = files.Count();
|
|
var sw_get = new System.Diagnostics.Stopwatch();
|
|
var sw_cmp = new System.Diagnostics.Stopwatch();
|
|
|
|
foreach (var f in files)
|
|
{
|
|
if (config.Progress)
|
|
Console.Write($"\rVerifying: {i}/{n}");
|
|
|
|
Duplicati.Library.Logging.Log.WriteVerboseMessage(LOGTAG, "rsync",
|
|
"Verifying {0} by downloading and comparing {1} bytes from {2} and {3}",
|
|
f.Name,
|
|
Duplicati.Library.Utility.Utility.FormatSizeString(s_src.Length),
|
|
b_dst.DisplayName, b_src.DisplayName);
|
|
|
|
try
|
|
{
|
|
// Get both files
|
|
sw_get.Start();
|
|
var fs = b_src.GetAsync(f.Name, s_src, token);
|
|
var ds = b_dst.GetAsync(f.Name, s_dst, token);
|
|
await Task.WhenAll(fs, ds).ConfigureAwait(false);
|
|
sw_get.Stop();
|
|
|
|
// Compare the contents
|
|
sw_cmp.Start();
|
|
if (s_src.Length != s_dst.Length || !s_src.ToArray().SequenceEqual(s_dst.ToArray()))
|
|
{
|
|
errors.Add(f);
|
|
}
|
|
sw_cmp.Stop();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
errors.Add(f);
|
|
Duplicati.Library.Logging.Log.WriteErrorMessage(LOGTAG, "rsync", e,
|
|
"Error during verification of {0}: {1}", f.Name, e.Message);
|
|
}
|
|
finally
|
|
{
|
|
// Reset the streams
|
|
s_src.SetLength(0);
|
|
s_dst.SetLength(0);
|
|
|
|
// Stop any running timers
|
|
sw_get.Stop();
|
|
sw_cmp.Stop();
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
Duplicati.Library.Logging.Log.WriteProfilingMessage(LOGTAG, "rsync",
|
|
"Verify | Get: {0} ms, Compare: {1} ms",
|
|
TimeSpan.FromMilliseconds(sw_get.ElapsedMilliseconds),
|
|
TimeSpan.FromMilliseconds(sw_cmp.ElapsedMilliseconds));
|
|
|
|
if (config.Progress)
|
|
Console.WriteLine($"\rVerifying: {n}/{n}");
|
|
|
|
return errors;
|
|
}
|
|
|
|
}
|
|
}
|