2022-02-09 18:49:52 +00:00
|
|
|
namespace ASC.Data.Backup.Tasks;
|
|
|
|
|
|
|
|
[Scope]
|
|
|
|
public class TransferPortalTask : PortalTaskBase
|
2021-08-31 09:40:28 +00:00
|
|
|
{
|
2022-02-09 18:49:52 +00:00
|
|
|
public const string DefaultDirectoryName = "backup";
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
public string BackupDirectory { get; set; }
|
|
|
|
public bool DeleteBackupFileAfterCompletion { get; set; }
|
|
|
|
public bool BlockOldPortalAfterStart { get; set; }
|
|
|
|
public bool DeleteOldPortalAfterCompletion { get; set; }
|
|
|
|
public string ToConfigPath { get; private set; }
|
|
|
|
public int ToTenantId { get; private set; }
|
|
|
|
public int Limit { get; private set; }
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
private readonly IOptionsMonitor<ILog> _options;
|
|
|
|
private readonly TempStream _tempStream;
|
|
|
|
private readonly TempPath _tempPath;
|
|
|
|
private readonly IServiceProvider _serviceProvider;
|
2022-02-09 16:29:19 +00:00
|
|
|
|
2020-06-15 08:19:40 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
public TransferPortalTask(
|
|
|
|
DbFactory dbFactory,
|
|
|
|
IServiceProvider serviceProvider,
|
|
|
|
IOptionsMonitor<ILog> options,
|
|
|
|
StorageFactory storageFactory,
|
|
|
|
StorageFactoryConfig storageFactoryConfig,
|
|
|
|
ModuleProvider moduleProvider,
|
|
|
|
TempStream tempStream,
|
|
|
|
TempPath tempPath)
|
|
|
|
: base(dbFactory, options, storageFactory, storageFactoryConfig, moduleProvider)
|
|
|
|
{
|
|
|
|
DeleteBackupFileAfterCompletion = true;
|
|
|
|
BlockOldPortalAfterStart = true;
|
|
|
|
DeleteOldPortalAfterCompletion = true;
|
|
|
|
_options = options;
|
|
|
|
_tempStream = tempStream;
|
|
|
|
_tempPath = tempPath;
|
|
|
|
_serviceProvider = serviceProvider;
|
|
|
|
}
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
public void Init(int tenantId, string fromConfigPath, string toConfigPath, int limit, string backupDirectory)
|
|
|
|
{
|
|
|
|
Limit = limit;
|
2022-01-24 10:49:00 +00:00
|
|
|
ToConfigPath = toConfigPath ?? throw new ArgumentNullException(nameof(toConfigPath));
|
2022-02-09 18:49:52 +00:00
|
|
|
Init(tenantId, fromConfigPath);
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
BackupDirectory = backupDirectory;
|
|
|
|
}
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
public override void RunJob()
|
|
|
|
{
|
|
|
|
Logger.DebugFormat("begin transfer {0}", TenantId);
|
|
|
|
var fromDbFactory = new DbFactory(null, null);
|
|
|
|
var toDbFactory = new DbFactory(null, null);
|
|
|
|
var tenantAlias = GetTenantAlias(fromDbFactory);
|
|
|
|
var backupFilePath = GetBackupFilePath(tenantAlias);
|
|
|
|
var columnMapper = new ColumnMapper();
|
|
|
|
try
|
|
|
|
{
|
|
|
|
//target db can have error tenant from the previous attempts
|
|
|
|
SaveTenant(toDbFactory, tenantAlias, TenantStatus.RemovePending, tenantAlias + "_error", "status = " + TenantStatus.Restoring.ToString("d"));
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
if (BlockOldPortalAfterStart)
|
|
|
|
{
|
|
|
|
SaveTenant(fromDbFactory, tenantAlias, TenantStatus.Transfering);
|
|
|
|
}
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
SetStepsCount(ProcessStorage ? 3 : 2);
|
2020-06-08 10:40:26 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
//save db data to temporary file
|
|
|
|
var backupTask = _serviceProvider.GetService<BackupPortalTask>();
|
|
|
|
backupTask.Init(TenantId, ConfigPath, backupFilePath, Limit);
|
|
|
|
backupTask.ProcessStorage = false;
|
|
|
|
backupTask.ProgressChanged += (sender, args) => SetCurrentStepProgress(args.Progress);
|
|
|
|
foreach (var moduleName in IgnoredModules)
|
|
|
|
{
|
|
|
|
backupTask.IgnoreModule(moduleName);
|
|
|
|
}
|
|
|
|
backupTask.RunJob();
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
//restore db data from temporary file
|
|
|
|
var restoreTask = _serviceProvider.GetService<RestorePortalTask>();
|
|
|
|
restoreTask.Init(ToConfigPath, backupFilePath, columnMapper: columnMapper);
|
|
|
|
restoreTask.ProcessStorage = false;
|
|
|
|
restoreTask.ProgressChanged += (sender, args) => SetCurrentStepProgress(args.Progress);
|
|
|
|
foreach (var moduleName in IgnoredModules)
|
|
|
|
{
|
|
|
|
restoreTask.IgnoreModule(moduleName);
|
|
|
|
}
|
|
|
|
restoreTask.RunJob();
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
//transfer files
|
|
|
|
if (ProcessStorage)
|
|
|
|
{
|
|
|
|
DoTransferStorage(columnMapper);
|
|
|
|
}
|
2021-08-31 09:40:28 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
SaveTenant(toDbFactory, tenantAlias, TenantStatus.Active);
|
|
|
|
if (DeleteOldPortalAfterCompletion)
|
|
|
|
{
|
|
|
|
SaveTenant(fromDbFactory, tenantAlias, TenantStatus.RemovePending, tenantAlias + "_deleted");
|
2020-05-20 15:14:44 +00:00
|
|
|
}
|
2022-02-09 18:49:52 +00:00
|
|
|
else if (BlockOldPortalAfterStart)
|
2020-05-20 15:14:44 +00:00
|
|
|
{
|
|
|
|
SaveTenant(fromDbFactory, tenantAlias, TenantStatus.Active);
|
|
|
|
}
|
2022-02-09 18:49:52 +00:00
|
|
|
|
|
|
|
ToTenantId = columnMapper.GetTenantMapping();
|
|
|
|
}
|
|
|
|
catch
|
|
|
|
{
|
|
|
|
SaveTenant(fromDbFactory, tenantAlias, TenantStatus.Active);
|
|
|
|
if (columnMapper.GetTenantMapping() > 0)
|
2020-05-20 15:14:44 +00:00
|
|
|
{
|
2022-02-09 18:49:52 +00:00
|
|
|
SaveTenant(toDbFactory, tenantAlias, TenantStatus.RemovePending, tenantAlias + "_error");
|
|
|
|
}
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
finally
|
|
|
|
{
|
|
|
|
if (DeleteBackupFileAfterCompletion)
|
|
|
|
{
|
|
|
|
File.Delete(backupFilePath);
|
2020-05-20 15:14:44 +00:00
|
|
|
}
|
2022-02-09 18:49:52 +00:00
|
|
|
Logger.DebugFormat("end transfer {0}", TenantId);
|
2020-05-20 15:14:44 +00:00
|
|
|
}
|
2022-02-09 18:49:52 +00:00
|
|
|
}
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
private void DoTransferStorage(ColumnMapper columnMapper)
|
|
|
|
{
|
|
|
|
Logger.Debug("begin transfer storage");
|
|
|
|
var fileGroups = GetFilesToProcess(TenantId).GroupBy(file => file.Module).ToList();
|
|
|
|
var groupsProcessed = 0;
|
|
|
|
foreach (var group in fileGroups)
|
2020-05-20 15:14:44 +00:00
|
|
|
{
|
2022-02-09 18:49:52 +00:00
|
|
|
var baseStorage = StorageFactory.GetStorage(ConfigPath, TenantId.ToString(), group.Key);
|
|
|
|
var destStorage = StorageFactory.GetStorage(ToConfigPath, columnMapper.GetTenantMapping().ToString(), group.Key);
|
|
|
|
var utility = new CrossModuleTransferUtility(_options, _tempStream, _tempPath, baseStorage, destStorage);
|
|
|
|
|
|
|
|
foreach (var file in group)
|
2020-05-20 15:14:44 +00:00
|
|
|
{
|
2022-02-09 18:49:52 +00:00
|
|
|
var adjustedPath = file.Path;
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
var module = ModuleProvider.GetByStorageModule(file.Module, file.Domain);
|
|
|
|
if (module == null || module.TryAdjustFilePath(false, columnMapper, ref adjustedPath))
|
2020-05-20 15:14:44 +00:00
|
|
|
{
|
2022-02-09 18:49:52 +00:00
|
|
|
try
|
2020-05-20 15:14:44 +00:00
|
|
|
{
|
2022-01-25 09:29:11 +00:00
|
|
|
utility.CopyFileAsync(file.Domain, file.Path, file.Domain, adjustedPath).Wait();
|
2020-05-20 15:14:44 +00:00
|
|
|
}
|
2022-02-09 18:49:52 +00:00
|
|
|
catch (Exception error)
|
2020-05-20 15:14:44 +00:00
|
|
|
{
|
2022-02-09 18:49:52 +00:00
|
|
|
Logger.WarnFormat("Can't copy file ({0}:{1}): {2}", file.Module, file.Path, error);
|
2020-05-20 15:14:44 +00:00
|
|
|
}
|
|
|
|
}
|
2022-02-09 18:49:52 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
Logger.WarnFormat("Can't adjust file path \"{0}\".", file.Path);
|
|
|
|
}
|
2022-02-09 16:46:09 +00:00
|
|
|
}
|
2022-02-09 18:49:52 +00:00
|
|
|
SetCurrentStepProgress((int)(++groupsProcessed * 100 / (double)fileGroups.Count));
|
2020-05-20 15:14:44 +00:00
|
|
|
}
|
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
if (fileGroups.Count == 0)
|
2020-05-20 15:14:44 +00:00
|
|
|
{
|
2022-02-09 18:49:52 +00:00
|
|
|
SetStepCompleted();
|
|
|
|
}
|
2020-09-29 10:28:03 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
Logger.Debug("end transfer storage");
|
|
|
|
}
|
2022-02-09 16:46:09 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
private void SaveTenant(DbFactory dbFactory, string alias, TenantStatus status, string newAlias = null, string whereCondition = null)
|
|
|
|
{
|
|
|
|
using var connection = dbFactory.OpenConnection();
|
|
|
|
if (newAlias == null)
|
|
|
|
{
|
|
|
|
newAlias = alias;
|
2020-05-20 15:14:44 +00:00
|
|
|
}
|
2022-02-09 18:49:52 +00:00
|
|
|
else if (newAlias != alias)
|
2020-05-20 15:14:44 +00:00
|
|
|
{
|
2022-02-09 18:49:52 +00:00
|
|
|
newAlias = GetUniqAlias(connection, newAlias);
|
2020-05-20 15:14:44 +00:00
|
|
|
}
|
|
|
|
|
2022-01-14 13:12:37 +00:00
|
|
|
var commandText = "update tenants_tenants " +
|
2022-02-09 18:49:52 +00:00
|
|
|
"set " +
|
2022-01-14 13:12:37 +00:00
|
|
|
$" status={status.ToString("d")}, " +
|
|
|
|
$" alias = '{newAlias}', " +
|
|
|
|
$" last_modified='{DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss")}', " +
|
|
|
|
$" statuschanged='{DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss")}' " +
|
|
|
|
$"where alias = '{alias}'";
|
2022-02-09 18:49:52 +00:00
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(whereCondition))
|
2020-05-20 15:14:44 +00:00
|
|
|
{
|
2022-02-15 16:56:43 +00:00
|
|
|
commandText += " and " + whereCondition;
|
2020-05-20 15:14:44 +00:00
|
|
|
}
|
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
var command = connection.CreateCommand();
|
|
|
|
command.CommandText = commandText;
|
|
|
|
command.WithTimeout(120).ExecuteNonQuery();
|
|
|
|
}
|
|
|
|
|
|
|
|
private string GetTenantAlias(DbFactory dbFactory)
|
|
|
|
{
|
|
|
|
using var connection = dbFactory.OpenConnection();
|
|
|
|
var command = connection.CreateCommand();
|
|
|
|
command.CommandText = "select alias from tenants_tenants where id = " + TenantId;
|
|
|
|
return (string)command.WithTimeout(120).ExecuteScalar();
|
|
|
|
}
|
|
|
|
|
|
|
|
private static string GetUniqAlias(DbConnection connection, string alias)
|
|
|
|
{
|
|
|
|
var command = connection.CreateCommand();
|
|
|
|
command.CommandText = "select count(*) from tenants_tenants where alias like '" + alias + "%'";
|
|
|
|
return alias + command.WithTimeout(120).ExecuteScalar();
|
|
|
|
}
|
2020-05-20 15:14:44 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
private string GetBackupFilePath(string tenantAlias)
|
|
|
|
{
|
|
|
|
if (!Directory.Exists(BackupDirectory ?? DefaultDirectoryName))
|
|
|
|
{
|
|
|
|
Directory.CreateDirectory(BackupDirectory ?? DefaultDirectoryName);
|
2020-05-20 15:14:44 +00:00
|
|
|
}
|
2020-08-24 18:41:06 +00:00
|
|
|
|
2022-02-09 18:49:52 +00:00
|
|
|
return CrossPlatform.PathCombine(BackupDirectory ?? DefaultDirectoryName, tenantAlias + DateTime.UtcNow.ToString("(yyyy-MM-dd HH-mm-ss)") + ".backup");
|
2020-08-24 18:41:06 +00:00
|
|
|
}
|
2022-02-09 18:49:52 +00:00
|
|
|
|
2020-05-20 15:14:44 +00:00
|
|
|
}
|