protected bool IsStorageModuleAllowed(string storageModuleName)
{
var allowedStorageModules = new List<string>
{
"forum",
"photo",
"bookmarking",
"wiki",
"files",
"crm",
"projects",
"logo",
"fckuploaders",
"talk",
"mailaggregator",
"whitelabel",
"customnavigation",
"userPhotos"
};
if (!allowedStorageModules.Contains(storageModuleName))
return false;
IModuleSpecifics moduleSpecifics = ModuleProvider.GetByStorageModule(storageModuleName);
return moduleSpecifics == null || !IgnoredModules.Contains(moduleSpecifics.ModuleName);
}
public RestoreDbModuleTask(ILog logger, IModuleSpecifics module, IDataReadOperator reader, ColumnMapper columnMapper, DbFactory factory, bool replaceDate, bool dump)
: base(logger, -1, null)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (columnMapper == null)
{
throw new ArgumentNullException("columnMapper");
}
if (factory == null)
{
throw new ArgumentNullException("factory");
}
_module = module;
_reader = reader;
_columnMapper = columnMapper;
_factory = factory;
_replaceDate = replaceDate;
this.dump = dump;
}
protected virtual bool IsStorageModuleAllowed(string storageModuleName)
{
var allowedStorageModules = new List <string>
{
"forum",
"photo",
"bookmarking",
"wiki",
"files",
"crm",
"projects",
"logo",
"fckuploaders",
"talk",
"mailaggregator"
};
if (!allowedStorageModules.Contains(storageModuleName))
{
return(false);
}
IModuleSpecifics moduleSpecifics = ModuleProvider.GetByStorageModule(storageModuleName);
return(moduleSpecifics == null || !IgnoredModules.Contains(moduleSpecifics.ModuleName));
}
private void DoBackupModule(IDataWriteOperator writer, DbFactory dbFactory, IModuleSpecifics module)
{
Logger.Debug("begin saving data for module {0}", module.ModuleName);
var tablesToProcess = module.Tables.Where(t => !IgnoredTables.Contains(t.Name) && t.InsertMethod != InsertMethod.None).ToList();
int tablesCount = tablesToProcess.Count;
int tablesProcessed = 0;
using (var connection = dbFactory.OpenConnection())
{
foreach (var table in tablesToProcess)
{
Logger.Debug("begin load table {0}", table.Name);
using (var data = new DataTable(table.Name))
{
ActionInvoker.Try(
state =>
{
data.Clear();
var t = (TableInfo)state;
var dataAdapter = dbFactory.CreateDataAdapter();
dataAdapter.SelectCommand = module.CreateSelectCommand(connection.Fix(), TenantId, t).WithTimeout(600);
((DbDataAdapter)dataAdapter).Fill(data);
},
table,
maxAttempts: 5,
onFailure: error => { throw ThrowHelper.CantBackupTable(table.Name, error); },
onAttemptFailure: error => Logger.Warn("backup attempt failure: {0}", error));
foreach (var col in data.Columns.Cast <DataColumn>().Where(col => col.DataType == typeof(DateTime)))
{
col.DateTimeMode = DataSetDateTime.Unspecified;
}
module.PrepareData(data);
Logger.Debug("end load table {0}", table.Name);
Logger.Debug("begin saving table {0}", table.Name);
var tmp = Path.GetTempFileName();
using (var file = File.OpenWrite(tmp))
{
data.WriteXml(file, XmlWriteMode.WriteSchema);
data.Clear();
}
writer.WriteEntry(KeyHelper.GetTableZipKey(module, data.TableName), tmp);
File.Delete(tmp);
Logger.Debug("end saving table {0}", table.Name);
}
SetCurrentStepProgress((int)((++tablesProcessed * 100) / (double)tablesCount));
}
}
Logger.Debug("end saving data for module {0}", module.ModuleName);
}
public RestoreDbModuleTask(IOptionsMonitor <ILog> options, IModuleSpecifics module, IDataReadOperator reader, ColumnMapper columnMapper, DbFactory factory, bool replaceDate, bool dump, StorageFactory storageFactory, StorageFactoryConfig storageFactoryConfig, ModuleProvider moduleProvider)
: base(factory, options, storageFactory, storageFactoryConfig, moduleProvider)
{
Reader = reader ?? throw new ArgumentNullException("reader");
ColumnMapper = columnMapper ?? throw new ArgumentNullException("columnMapper");
DbFactory = factory ?? throw new ArgumentNullException("factory");
Module = module;
ReplaceDate = replaceDate;
Dump = dump;
Init(-1, null);
}
public RestoreDbModuleTask(IModuleSpecifics module, IDataReadOperator reader, ColumnMapper columnMapper, DbFactory factory)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (columnMapper == null)
throw new ArgumentNullException("columnMapper");
if (factory == null)
throw new ArgumentNullException("factory");
_module = module;
_reader = reader;
_columnMapper = columnMapper;
_factory = factory;
}
private void DoTransferStorage(ColumnMapper columnMapper)
{
Logger.Debug("begin transfer storage");
var fileGroups = GetFilesToProcess().GroupBy(file => file.Module).ToList();
int groupsProcessed = 0;
foreach (var group in fileGroups)
{
ICrossModuleTransferUtility transferUtility =
StorageFactory.GetCrossModuleTransferUtility(
ConfigPath, TenantId, group.Key,
ToConfigPath, columnMapper.GetTenantMapping(), group.Key);
foreach (BackupFileInfo file in group)
{
string adjustedPath = file.Path;
IModuleSpecifics module = ModuleProvider.GetByStorageModule(file.Module, file.Domain);
if (module == null || module.TryAdjustFilePath(columnMapper, ref adjustedPath))
{
try
{
transferUtility.CopyFile(file.Domain, file.Path, file.Domain, adjustedPath);
}
catch (Exception error)
{
Logger.Warn("Can't copy file ({0}:{1}): {2}", file.Module, file.Path, error);
}
}
else
{
Logger.Warn("Can't adjust file path \"{0}\".", file.Path);
}
}
SetCurrentStepProgress((int)(++groupsProcessed * 100 / (double)fileGroups.Count));
}
if (fileGroups.Count == 0)
{
SetStepCompleted();
}
Logger.Debug("end transfer storage");
}
private void DoBackupModule(IDataWriteOperator writer, DbFactory dbFactory, IModuleSpecifics module)
{
InvokeInfo("begin saving data for module {0}", module.ModuleName);
int tablesCount = module.Tables.Count();
int tablesProcessed = 0;
using (var connection = dbFactory.OpenConnection(module.ConnectionStringName))
{
foreach (var table in module.Tables)
{
InvokeInfo("begin saving table {0}", table.Name);
using (var data = new DataTable(table.Name))
{
ActionInvoker.Try(
state =>
{
data.Clear();
var t = (TableInfo)state;
var dataAdapter = dbFactory.CreateDataAdapter(module.ConnectionStringName);
dataAdapter.SelectCommand = module.CreateSelectCommand(connection.Fix(), Tenant.TenantId, t).WithTimeout(600);
((DbDataAdapter)dataAdapter).Fill(data);
},
table,
maxAttempts: 5,
onFailure: error => { throw ThrowHelper.CantBackupTable(table.Name, error); },
onAttemptFailure: error => InvokeWarning("backup attempt failure: {0}", error));
foreach (var col in data.Columns.Cast<DataColumn>().Where(col => col.DataType == typeof(DateTime)))
{
col.DateTimeMode = DataSetDateTime.Unspecified;
}
var stream = writer.BeginWriteEntry(KeyHelper.GetTableZipKey(module, data.TableName));
data.WriteXml(stream, XmlWriteMode.WriteSchema);
writer.EndWriteEntry();
data.Clear();
}
SetStepProgress((int)((++tablesProcessed*100)/(double)tablesCount));
}
}
InvokeInfo("end saving data for module {0}", module.ModuleName);
}
private void DoDeleteModule(DbFactory dbFactory, IModuleSpecifics module)
{
InvokeInfo("begin delete data for module ({0})", module.ModuleName);
int tablesCount = module.Tables.Count();
int tablesProcessed = 0;
using (var connection = dbFactory.OpenConnection(module.ConnectionStringName))
{
foreach (var table in module.GetTablesOrdered().Reverse().Where(t => !IgnoredTables.Contains(t.Name)))
{
ActionInvoker.Try(state =>
{
var t = (TableInfo)state;
module.CreateDeleteCommand(connection.Fix(), Tenant.TenantId, t).WithTimeout(120).ExecuteNonQuery();
}, table, 5, onFailure: error => { throw ThrowHelper.CantDeleteTable(table.Name, error); });
SetStepProgress((int)((++tablesProcessed*100)/(double)tablesCount));
}
}
InvokeInfo("end delete data for module ({0})", module.ModuleName);
}
private void DoBackupModule(IDataWriteOperator writer, DbFactory dbFactory, IModuleSpecifics module)
{
InvokeInfo("begin saving data for module {0}", module.ModuleName);
int tablesCount = module.Tables.Count();
int tablesProcessed = 0;
using (var connection = dbFactory.OpenConnection(module.ConnectionStringName))
{
foreach (var table in module.Tables)
{
InvokeInfo("begin saving table {0}", table.Name);
using (var data = new DataTable(table.Name))
{
ActionInvoker.Try(
state =>
{
data.Clear();
var t = (TableInfo)state;
var dataAdapter = dbFactory.CreateDataAdapter(module.ConnectionStringName);
dataAdapter.SelectCommand = module.CreateSelectCommand(connection.Fix(), Tenant.TenantId, t).WithTimeout(600);
((DbDataAdapter)dataAdapter).Fill(data);
},
table,
maxAttempts: 5,
onFailure: error => { throw ThrowHelper.CantBackupTable(table.Name, error); },
onAttemptFailure: error => InvokeWarning("backup attempt failure: {0}", error));
foreach (var col in data.Columns.Cast <DataColumn>().Where(col => col.DataType == typeof(DateTime)))
{
col.DateTimeMode = DataSetDateTime.Unspecified;
}
var stream = writer.BeginWriteEntry(KeyHelper.GetTableZipKey(module, data.TableName));
data.WriteXml(stream, XmlWriteMode.WriteSchema);
writer.EndWriteEntry();
data.Clear();
}
SetStepProgress((int)((++tablesProcessed * 100) / (double)tablesCount));
}
}
InvokeInfo("end saving data for module {0}", module.ModuleName);
}
private void DoDeleteModule(DbFactory dbFactory, IModuleSpecifics module)
{
InvokeInfo("begin delete data for module ({0})", module.ModuleName);
int tablesCount = module.Tables.Count();
int tablesProcessed = 0;
using (var connection = dbFactory.OpenConnection(module.ConnectionStringName))
{
foreach (var table in module.GetTablesOrdered().Reverse().Where(t => !IgnoredTables.Contains(t.Name)))
{
ActionInvoker.Try(state =>
{
var t = (TableInfo)state;
module.CreateDeleteCommand(connection.Fix(), Tenant.TenantId, t).WithTimeout(120).ExecuteNonQuery();
}, table, 5, onFailure: error => { throw ThrowHelper.CantDeleteTable(table.Name, error); });
SetStepProgress((int)((++tablesProcessed * 100) / (double)tablesCount));
}
}
InvokeInfo("end delete data for module ({0})", module.ModuleName);
}
public RestoreDbModuleTask(IModuleSpecifics module, IDataReadOperator reader, ColumnMapper columnMapper, DbFactory factory)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (columnMapper == null)
{
throw new ArgumentNullException("columnMapper");
}
if (factory == null)
{
throw new ArgumentNullException("factory");
}
_module = module;
_reader = reader;
_columnMapper = columnMapper;
_factory = factory;
}
private void DoRestoreStorage(IDataReadOperator dataReader)
{
InvokeInfo("begin restore storage");
var fileGroups = GetFilesToProcess(dataReader).GroupBy(file => file.Module).ToList();
int groupsProcessed = 0;
foreach (var group in fileGroups)
{
IDataStore storage = StorageFactory.GetStorage(ConfigPath, _columnMapper.GetTenantMapping().ToString(), group.Key, null, null);
foreach (BackupFileInfo file in group)
{
string adjustedPath = file.Path;
IModuleSpecifics module = ModuleProvider.GetByStorageModule(file.Module);
if (module == null || module.TryAdjustFilePath(_columnMapper, ref adjustedPath))
{
Stream stream = dataReader.GetEntry(KeyHelper.GetFileZipKey(file));
try
{
storage.Save(file.Domain, adjustedPath, stream);
}
catch (Exception error)
{
InvokeWarning("can't restore file ({0}:{1}): {2}", file.Module, file.Path, error);
}
}
}
SetStepProgress((int)(++groupsProcessed * 100 / (double)fileGroups.Count));
}
if (fileGroups.Count == 0)
{
SetStepCompleted();
}
InvokeInfo("end restore storage");
}
public static string GetTableZipKey(IModuleSpecifics module, string tableName)
{
return(string.Format("{0}/{1}/{2}", Databases, module.ConnectionStringName, tableName));
}
public static string GetTableZipKey(IModuleSpecifics module, string tableName)
{
return string.Format("databases/{0}/{1}", module.ConnectionStringName, tableName);
}
