public static async Task RunExecuteAsync(string commandName, string[] commandArgs, IJobExecutionContext jobContext)
{
try
{
Func <IJobContext, Task> job;
if (Jobs.TryGetValue(commandName, out job))
{
if (job != null)
{
var context = new JobContextImpl(commandName, commandArgs, jobContext);
await job(context);
}
}
}
catch (Exception ex)
{
await CliUtils.PrintErrorAsync(ex.Message);
var errorLogFilePath = CliUtils.CreateErrorLogFile("siteserver");
await CliUtils.AppendErrorLogsAsync(errorLogFilePath, new List <TextLogInfo>
{
new TextLogInfo
{
DateTime = DateTime.Now,
Detail = "Console Error",
Exception = ex
}
});
}
}
public async Task Execute(IJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
await CliUtils.PrintErrorAsync("需要指定恢复数据的文件夹名称：directory");
return;
}
var treeInfo = new TreeInfo(_directory);
if (!DirectoryUtils.IsDirectoryExists(treeInfo.DirectoryPath))
{
await CliUtils.PrintErrorAsync($"恢复数据的文件夹 {treeInfo.DirectoryPath} 不存在");
return;
}
var tablesFilePath = treeInfo.TablesFilePath;
if (!FileUtils.IsFileExists(tablesFilePath))
{
await CliUtils.PrintErrorAsync($"恢复文件 {treeInfo.TablesFilePath} 不存在");
return;
}
var webConfigPath = CliUtils.GetWebConfigPath(_configFile);
if (!FileUtils.IsFileExists(webConfigPath))
{
await CliUtils.PrintErrorAsync($"系统配置文件不存在：{webConfigPath}！");
return;
}
WebConfigUtils.Load(CliUtils.PhysicalApplicationPath, webConfigPath);
if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync($"{webConfigPath} 中数据库连接字符串 connectionString 未设置");
return;
}
await Console.Out.WriteLineAsync($"数据库类型: {WebConfigUtils.DatabaseType.Value}");
await Console.Out.WriteLineAsync($"连接字符串: {WebConfigUtils.ConnectionString}");
await Console.Out.WriteLineAsync($"恢复文件夹: {treeInfo.DirectoryPath}");
if (!DataProvider.DatabaseDao.IsConnectionStringWork(WebConfigUtils.DatabaseType, WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync($"系统无法连接到 {webConfigPath} 中设置的数据库");
return;
}
if (!_dataOnly)
{
if (!SystemManager.IsNeedInstall())
{
await CliUtils.PrintErrorAsync("数据无法在已安装系统的数据库中恢复，命令执行失败");
return;
}
// 恢复前先创建表，确保系统在恢复的数据库中能够使用
SystemManager.CreateSiteServerTables();
}
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("恢复表名称", "总条数");
await CliUtils.PrintRowLineAsync();
var errorLogFilePath = CliUtils.CreateErrorLogFile(CommandName);
await Restore(_includes, _excludes, _dataOnly, tablesFilePath, treeInfo, errorLogFilePath);
await Console.Out.WriteLineAsync($"恭喜，成功从文件夹：{treeInfo.DirectoryPath} 恢复数据！");
}
public static async Task Execute(IJobContext context)
{
if (!CliUtils.ParseArgs(Options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
await CliUtils.PrintErrorAsync("Error, the restore {directory} name is empty");
return;
}
var treeInfo = new TreeInfo(_directory);
if (!DirectoryUtils.IsDirectoryExists(treeInfo.DirectoryPath))
{
await CliUtils.PrintErrorAsync($"Error, directory {treeInfo.DirectoryPath} not exists");
return;
}
var tablesFilePath = treeInfo.TablesFilePath;
if (!FileUtils.IsFileExists(tablesFilePath))
{
await CliUtils.PrintErrorAsync($"Error, file {treeInfo.TablesFilePath} not exists");
return;
}
ConfigInfo configInfo;
if (!string.IsNullOrEmpty(_databaseType) && !string.IsNullOrEmpty(_connectionString))
{
configInfo = CliUtils.LoadConfigByArgs(_databaseType, _connectionString);
}
else
{
configInfo = await CliUtils.LoadConfigByFileAsync(_configFileName);
}
if (configInfo == null)
{
await CliUtils.PrintErrorAsync("Error, config not exists");
return;
}
if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync("Error, connection string is empty");
return;
}
if (!DataProvider.DatabaseDao.IsConnectionStringWork(WebConfigUtils.DatabaseType, WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync("Error, can not connect to the database");
return;
}
await Console.Out.WriteLineAsync($"Database Type: {WebConfigUtils.DatabaseType.Value}");
await Console.Out.WriteLineAsync($"Connection String: {WebConfigUtils.ConnectionString}");
await Console.Out.WriteLineAsync($"Restore Directory: {treeInfo.DirectoryPath}");
var tableNames = TranslateUtils.JsonDeserialize <List <string> >(await FileUtils.ReadTextAsync(tablesFilePath, Encoding.UTF8));
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("Import Table Name", "Total Count");
await CliUtils.PrintRowLineAsync();
var errorLogFilePath = CliUtils.CreateErrorLogFile(CommandName);
foreach (var tableName in tableNames)
{
var logs = new List <TextLogInfo>();
if (configInfo.RestoreConfig.Includes != null)
{
if (!StringUtils.ContainsIgnoreCase(configInfo.RestoreConfig.Includes, tableName))
{
continue;
}
}
if (configInfo.RestoreConfig.Excludes != null)
{
if (StringUtils.ContainsIgnoreCase(configInfo.RestoreConfig.Excludes, tableName))
{
continue;
}
}
var metadataFilePath = treeInfo.GetTableMetadataFilePath(tableName);
if (!FileUtils.IsFileExists(metadataFilePath))
{
continue;
}
var tableInfo = TranslateUtils.JsonDeserialize <TableInfo>(await FileUtils.ReadTextAsync(metadataFilePath, Encoding.UTF8));
await CliUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
if (!DataProvider.DatabaseDao.IsTableExists(tableName))
{
if (!DataProvider.DatabaseDao.CreateSystemTable(tableName, tableInfo.Columns, out var ex, out var sqlString))
{
logs.Add(new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"create table {tableName}: {sqlString}",
Exception = ex
});
continue;
}
}
else
{
DataProvider.DatabaseDao.AlterSystemTable(tableName, tableInfo.Columns);
}
using (var progress = new ProgressBar())
{
for (var i = 0; i < tableInfo.RowFiles.Count; i++)
{
progress.Report((double)i / tableInfo.RowFiles.Count);
var fileName = tableInfo.RowFiles[i];
var objects = TranslateUtils.JsonDeserialize <List <JObject> >(
await FileUtils.ReadTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName),
Encoding.UTF8));
try
{
DataProvider.DatabaseDao.InsertMultiple(tableName, objects, tableInfo.Columns);
}
catch (Exception ex)
{
logs.Add(new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"insert table {tableName}, fileName {fileName}",
Exception = ex
});
}
}
}
await CliUtils.AppendErrorLogsAsync(errorLogFilePath, logs);
}
await CliUtils.PrintRowLineAsync();
if (configInfo.RestoreConfig.SyncDatabase)
{
SystemManager.SyncDatabase();
}
await Console.Out.WriteLineAsync("Well done! Thanks for Using SiteServer Cli Tool");
}
public static async Task Execute(IJobContext context)
{
if (!CliUtils.ParseArgs(Options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
await CliUtils.PrintErrorAsync("需要指定恢复数据的文件夹名称：directory");
return;
}
var treeInfo = new TreeInfo(_directory);
if (!DirectoryUtils.IsDirectoryExists(treeInfo.DirectoryPath))
{
await CliUtils.PrintErrorAsync($"恢复数据的文件夹 {treeInfo.DirectoryPath} 不存在");
return;
}
var tablesFilePath = treeInfo.TablesFilePath;
if (!FileUtils.IsFileExists(tablesFilePath))
{
await CliUtils.PrintErrorAsync($"恢复文件 {treeInfo.TablesFilePath} 不存在");
return;
}
var webConfigPath = PathUtils.Combine(CliUtils.PhysicalApplicationPath, "web.config");
if (!FileUtils.IsFileExists(webConfigPath))
{
await CliUtils.PrintErrorAsync($"系统配置文件不存在：{webConfigPath}！");
return;
}
if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync("web.config 中数据库连接字符串 connectionString 未设置");
return;
}
WebConfigUtils.Load(CliUtils.PhysicalApplicationPath, "web.config");
await Console.Out.WriteLineAsync($"数据库类型: {WebConfigUtils.DatabaseType.Value}");
await Console.Out.WriteLineAsync($"连接字符串: {WebConfigUtils.ConnectionString}");
await Console.Out.WriteLineAsync($"恢复文件夹: {treeInfo.DirectoryPath}");
if (!DataProvider.DatabaseDao.IsConnectionStringWork(WebConfigUtils.DatabaseType, WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync("系统无法连接到 web.config 中设置的数据库");
return;
}
if (!SystemManager.IsNeedInstall())
{
await CliUtils.PrintErrorAsync("数据无法在已安装系统的数据库中恢复，命令执行失败");
return;
}
// 恢复前先创建表，确保系统在恢复的数据库中能够使用
SystemManager.CreateSiteServerTables();
var tableNames = TranslateUtils.JsonDeserialize <List <string> >(await FileUtils.ReadTextAsync(tablesFilePath, Encoding.UTF8));
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("恢复表名称", "总条数");
await CliUtils.PrintRowLineAsync();
var errorLogFilePath = CliUtils.CreateErrorLogFile(CommandName);
foreach (var tableName in tableNames)
{
var logs = new List <TextLogInfo>();
if (_includes != null)
{
if (!StringUtils.ContainsIgnoreCase(_includes, tableName))
{
continue;
}
}
if (_excludes != null)
{
if (StringUtils.ContainsIgnoreCase(_excludes, tableName))
{
continue;
}
}
var metadataFilePath = treeInfo.GetTableMetadataFilePath(tableName);
if (!FileUtils.IsFileExists(metadataFilePath))
{
continue;
}
var tableInfo = TranslateUtils.JsonDeserialize <TableInfo>(await FileUtils.ReadTextAsync(metadataFilePath, Encoding.UTF8));
await CliUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
if (!DataProvider.DatabaseDao.IsTableExists(tableName))
{
if (!DataProvider.DatabaseDao.CreateSystemTable(tableName, tableInfo.Columns, out var ex, out var sqlString))
{
logs.Add(new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"创建表 {tableName}: {sqlString}",
Exception = ex
});
continue;
}
}
else
{
DataProvider.DatabaseDao.AlterSystemTable(tableName, tableInfo.Columns);
}
using (var progress = new ProgressBar())
{
for (var i = 0; i < tableInfo.RowFiles.Count; i++)
{
progress.Report((double)i / tableInfo.RowFiles.Count);
var fileName = tableInfo.RowFiles[i];
var objects = TranslateUtils.JsonDeserialize <List <JObject> >(
await FileUtils.ReadTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName),
Encoding.UTF8));
try
{
DataProvider.DatabaseDao.InsertMultiple(tableName, objects, tableInfo.Columns);
}
catch (Exception ex)
{
logs.Add(new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"插入表 {tableName}, 文件名 {fileName}",
Exception = ex
});
}
}
}
await CliUtils.AppendErrorLogsAsync(errorLogFilePath, logs);
}
await CliUtils.PrintRowLineAsync();
// 恢复后同步表，确保内容辅助表字段与系统一致
SystemManager.SyncContentTables();
SystemManager.UpdateConfigVersion();
await Console.Out.WriteLineAsync($"恭喜，成功从文件夹：{treeInfo.DirectoryPath} 恢复数据！");
}
private async Task RunAsync(IJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
await CliUtils.PrintErrorAsync("需要指定恢复数据的文件夹名称：directory");
return;
}
var treeInfo = new TreeInfo(_settings.ContentRootPath, _directory);
if (!Directory.Exists(treeInfo.DirectoryPath))
{
await CliUtils.PrintErrorAsync($"恢复数据的文件夹 {treeInfo.DirectoryPath} 不存在");
return;
}
var tablesFilePath = treeInfo.TablesFilePath;
if (!CliUtils.FileExists(tablesFilePath))
{
await CliUtils.PrintErrorAsync($"恢复文件 {treeInfo.TablesFilePath} 不存在");
return;
}
var(isConnectionWorks, errorMessage) = await CliUtils.CheckSettingsAsync(_settings);
if (!isConnectionWorks)
{
await CliUtils.PrintErrorAsync(errorMessage);
return;
}
await Console.Out.WriteLineAsync($"数据库类型: {_settings.Database.DatabaseType.GetDisplayName()}");
await Console.Out.WriteLineAsync($"连接字符串: {_settings.Database.ConnectionString}");
await Console.Out.WriteLineAsync($"恢复文件夹: {treeInfo.DirectoryPath}");
var tableNames = Utilities.JsonDeserialize <List <string> >(await CliUtils.ReadAllTextAsync(tablesFilePath));
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("恢复表名称", "总条数");
await CliUtils.PrintRowLineAsync();
var includes = new List <string>(_settings.Includes);
var excludes = new List <string>(_settings.Excludes);
var errorLogFilePath = CliUtils.CreateErrorLogFile(_settings.ContentRootPath, CommandName);
foreach (var tableName in tableNames)
{
try
{
if (includes.Count > 0 && !Utilities.ContainsIgnoreCase(includes, tableName))
{
continue;
}
if (excludes.Count > 0 && Utilities.ContainsIgnoreCase(excludes, tableName))
{
continue;
}
var metadataFilePath = treeInfo.GetTableMetadataFilePath(tableName);
if (!CliUtils.FileExists(metadataFilePath))
{
continue;
}
var tableInfo = Utilities.JsonDeserialize <TableInfo>(await CliUtils.ReadAllTextAsync(metadataFilePath));
var repository = new Repository(_settings.Database, tableName, tableInfo.Columns);
await CliUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
if (!await _settings.Database.IsTableExistsAsync(tableName))
{
try
{
await _settings.Database.CreateTableAsync(tableName, tableInfo.Columns);
}
catch (Exception ex)
{
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"创建表 {tableName}",
Exception = ex
});
continue;
}
}
else
{
await _settings.Database.AlterTableAsync(tableName, tableInfo.Columns);
}
if (tableInfo.RowFiles.Count > 0)
{
using (var progress = new ProgressBar())
{
for (var i = 0; i < tableInfo.RowFiles.Count; i++)
{
progress.Report((double)i / tableInfo.RowFiles.Count);
var fileName = tableInfo.RowFiles[i];
var objects = Utilities.JsonDeserialize <List <JObject> >(
await CliUtils.ReadAllTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName)));
try
{
await repository.BulkInsertAsync(objects);
}
catch (Exception ex)
{
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"插入表 {tableName}, 文件名 {fileName}",
Exception = ex
});
}
}
}
}
}
catch (Exception ex)
{
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"插入表 {tableName}",
Exception = ex
});
}
}
await CliUtils.PrintRowLineAsync();
await Console.Out.WriteLineAsync($"恭喜，成功从文件夹：{treeInfo.DirectoryPath} 恢复数据！");
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var directory = _directory;
if (string.IsNullOrEmpty(directory))
{
directory = $"backup/{DateTime.Now:yyyy-MM-dd}";
}
var treeInfo = new TreeInfo(_settingsManager, directory);
DirectoryUtils.CreateDirectoryIfNotExists(treeInfo.DirectoryPath);
var backupConfigPath = PathUtils.Combine(_settingsManager.ContentRootPath, _from);
if (!FileUtils.IsFileExists(backupConfigPath))
{
await WriteUtils.PrintErrorAsync($"The sscms configuration file does not exist: {backupConfigPath}");
return;
}
//WebConfigUtils.Load(_settingsManager.ContentRootPath, backupWebConfigPath);
//if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
//{
// await CliUtils.PrintErrorAsync($"{backupWebConfigPath} 中数据库连接字符串 connectionString 未设置");
// return;
//}
//await Console.Out.WriteLineAsync($"备份数据库类型: {_settingsManager.Database.DatabaseType.GetValue()}");
//await Console.Out.WriteLineAsync($"备份连接字符串: {WebConfigUtils.ConnectionString}");
//await Console.Out.WriteLineAsync($"备份文件夹: {treeInfo.DirectoryPath}");
var(isConnectionWorks, errorMessage) = await _settingsManager.Database.IsConnectionWorksAsync();
if (!isConnectionWorks)
{
await WriteUtils.PrintErrorAsync($"Unable to connect to database, error message:{errorMessage}");
return;
}
if (_excludes == null)
{
_excludes = new List <string>();
}
_excludes.Add("bairong_Log");
_excludes.Add("bairong_ErrorLog");
_excludes.Add("siteserver_ErrorLog");
_excludes.Add("siteserver_Log");
_excludes.Add("siteserver_Tracking");
var errorLogFilePath = CliUtils.CreateErrorLogFile(CommandName, _settingsManager);
await DataBackupJob.Backup(_settingsManager.Database, _databaseManager, _includes, _excludes, _maxRows, treeInfo);
var restoreConfigPath = PathUtils.Combine(_settingsManager.ContentRootPath, _to);
if (!FileUtils.IsFileExists(restoreConfigPath))
{
await WriteUtils.PrintErrorAsync($"The sscms configuration file does not exist: {restoreConfigPath}");
return;
}
//WebConfigUtils.Load(_settingsManager.ContentRootPath, restoreWebConfigPath);
//if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
//{
// await CliUtils.PrintErrorAsync($"{restoreWebConfigPath} 中数据库连接字符串 connectionString 未设置");
// return;
//}
//await Console.Out.WriteLineAsync($"恢复数据库类型: {_settingsManager.Database.DatabaseType.GetValue()}");
//await Console.Out.WriteLineAsync($"恢复连接字符串: {WebConfigUtils.ConnectionString}");
(isConnectionWorks, errorMessage) = await _settingsManager.Database.IsConnectionWorksAsync();
if (!isConnectionWorks)
{
await WriteUtils.PrintErrorAsync($"Unable to connect to database, error message:{errorMessage}");
return;
}
await _restoreService.RestoreAsync(_includes, _excludes, true, treeInfo.DirectoryPath, treeInfo, errorLogFilePath);
await WriteUtils.PrintRowLineAsync();
await WriteUtils.PrintSuccessAsync("恭喜，成功同步数据!");
}
public async Task Execute(IJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var directory = _directory;
if (string.IsNullOrEmpty(directory))
{
directory = $"backup/{DateTime.Now:yyyy-MM-dd}";
}
var treeInfo = new TreeInfo(directory);
DirectoryUtils.CreateDirectoryIfNotExists(treeInfo.DirectoryPath);
var backupWebConfigPath = CliUtils.GetWebConfigPath(_from);
if (!FileUtils.IsFileExists(backupWebConfigPath))
{
await CliUtils.PrintErrorAsync($"系统配置文件不存在：{backupWebConfigPath}！");
return;
}
WebConfigUtils.Load(CliUtils.PhysicalApplicationPath, backupWebConfigPath);
if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync($"{backupWebConfigPath} 中数据库连接字符串 connectionString 未设置");
return;
}
await Console.Out.WriteLineAsync($"备份数据库类型: {WebConfigUtils.DatabaseType.Value}");
await Console.Out.WriteLineAsync($"备份连接字符串: {WebConfigUtils.ConnectionString}");
await Console.Out.WriteLineAsync($"备份文件夹: {treeInfo.DirectoryPath}");
if (!DataProvider.DatabaseDao.IsConnectionStringWork(WebConfigUtils.DatabaseType, WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync($"系统无法连接到 {backupWebConfigPath} 中设置的数据库");
return;
}
if (_excludes == null)
{
_excludes = new List <string>();
}
_excludes.Add("bairong_Log");
_excludes.Add("bairong_ErrorLog");
_excludes.Add("siteserver_ErrorLog");
_excludes.Add("siteserver_Log");
_excludes.Add("siteserver_Tracking");
var errorLogFilePath = CliUtils.CreateErrorLogFile(CommandName);
await BackupJob.Backup(_includes, _excludes, _maxRows, treeInfo);
var restoreWebConfigPath = CliUtils.GetWebConfigPath(_to);
if (!FileUtils.IsFileExists(restoreWebConfigPath))
{
await CliUtils.PrintErrorAsync($"系统配置文件不存在：{restoreWebConfigPath}！");
return;
}
WebConfigUtils.Load(CliUtils.PhysicalApplicationPath, restoreWebConfigPath);
if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync($"{restoreWebConfigPath} 中数据库连接字符串 connectionString 未设置");
return;
}
await Console.Out.WriteLineAsync($"恢复数据库类型: {WebConfigUtils.DatabaseType.Value}");
await Console.Out.WriteLineAsync($"恢复连接字符串: {WebConfigUtils.ConnectionString}");
if (!DataProvider.DatabaseDao.IsConnectionStringWork(WebConfigUtils.DatabaseType, WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync($"系统无法连接到 {restoreWebConfigPath} 中设置的数据库");
return;
}
await RestoreJob.Restore(_includes, _excludes, true, treeInfo.DirectoryPath, treeInfo, errorLogFilePath);
await CliUtils.PrintRowLineAsync();
await Console.Out.WriteLineAsync("恭喜，成功同步数据！");
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
await WriteUtils.PrintErrorAsync("Restore folder name not specified: --directory");
return;
}
var treeInfo = new TreeInfo(_settingsManager, _directory);
if (!DirectoryUtils.IsDirectoryExists(treeInfo.DirectoryPath))
{
await WriteUtils.PrintErrorAsync($"恢复数据的文件夹 {treeInfo.DirectoryPath} 不存在");
return;
}
var tablesFilePath = treeInfo.TablesFilePath;
if (!FileUtils.IsFileExists(tablesFilePath))
{
await WriteUtils.PrintErrorAsync($"恢复文件 {treeInfo.TablesFilePath} 不存在");
return;
}
var configPath = CliUtils.GetConfigPath(_settingsManager);
if (!FileUtils.IsFileExists(configPath))
{
await WriteUtils.PrintErrorAsync($"The sscms.json file does not exist: {configPath}");
return;
}
//WebConfigUtils.Load(_settingsManager.ContentRootPath, webConfigPath);
//if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
//{
// await CliUtils.PrintErrorAsync($"{webConfigPath} 中数据库连接字符串 connectionString 未设置");
// return;
//}
//await Console.Out.WriteLineAsync($"数据库类型: {_settingsManager.Database.DatabaseType.GetValue()}");
//await Console.Out.WriteLineAsync($"连接字符串: {WebConfigUtils.ConnectionString}");
//await Console.Out.WriteLineAsync($"恢复文件夹: {treeInfo.DirectoryPath}");
await Console.Out.WriteLineAsync($"Database type: {_settingsManager.Database.DatabaseType.GetDisplayName()}");
await Console.Out.WriteLineAsync($"Database connection string: {_settingsManager.Database.ConnectionString}");
await Console.Out.WriteLineAsync($"Restore folder: {treeInfo.DirectoryPath}");
var(isConnectionWorks, errorMessage) = await _settingsManager.Database.IsConnectionWorksAsync();
if (!isConnectionWorks)
{
await WriteUtils.PrintErrorAsync($"Unable to connect to database, error message:{errorMessage}");
return;
}
//if (!_dataOnly)
//{
// if (!await _configRepository.IsNeedInstallAsync())
// {
// await WriteUtils.PrintErrorAsync("The data could not be restored on the installed sscms database");
// return;
// }
// // 恢复前先创建表，确保系统在恢复的数据库中能够使用
// //await _databaseManager.CreateSiteServerTablesAsync();
// if (_settingsManager.DatabaseType == DatabaseType.SQLite)
// {
// var filePath = PathUtils.Combine(_settingsManager.ContentRootPath, Constants.DefaultLocalDbFileName);
// if (!FileUtils.IsFileExists(filePath))
// {
// await FileUtils.WriteTextAsync(filePath, string.Empty);
// }
// }
// await _databaseManager.SyncDatabaseAsync();
//}
await WriteUtils.PrintRowLineAsync();
await WriteUtils.PrintRowAsync("Restore table name", "Count");
await WriteUtils.PrintRowLineAsync();
var errorLogFilePath = CliUtils.CreateErrorLogFile(CommandName, _settingsManager);
await _restoreService.RestoreAsync(_includes, _excludes, _dataOnly, tablesFilePath, treeInfo, errorLogFilePath);
await Console.Out.WriteLineAsync($"恭喜，成功从文件夹：{treeInfo.DirectoryPath} 恢复数据!");
}
private static void Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
var commandName = string.Empty;
var commandArgs = new List <string>();
if (args.Length >= 1)
{
for (var i = 0; i < args.Length; i++)
{
if (i == 0)
{
commandName = args[i];
}
else
{
commandArgs.Add(args[i]);
}
}
}
Console.WriteLine("Welcome to SiteServer Cli Tool");
Console.WriteLine();
try
{
if (StringUtils.EqualsIgnoreCase(commandName, BackupManager.CommandName))
{
BackupManager.Execute(commandArgs.ToArray());
}
else if (StringUtils.EqualsIgnoreCase(commandName, RestoreManager.CommandName))
{
RestoreManager.Execute(commandArgs.ToArray());
}
else if (StringUtils.EqualsIgnoreCase(commandName, UpdateManager.CommandName))
{
UpdateManager.Execute(commandArgs.ToArray());
}
else if (StringUtils.EqualsIgnoreCase(commandName, VersionManager.CommandName))
{
VersionManager.Execute(commandArgs.ToArray());
}
else if (StringUtils.EqualsIgnoreCase(commandName, TestManager.CommandName))
{
TestManager.Execute(commandArgs.ToArray());
}
else
{
CliUtils.PrintLine();
CliUtils.PrintRow("Usage");
CliUtils.PrintLine();
BackupManager.PrintUsage();
RestoreManager.PrintUsage();
UpdateManager.PrintUsage();
VersionManager.PrintUsage();
CliUtils.PrintLine();
CliUtils.PrintRow("http://www.siteserver.cn/docs/cli");
CliUtils.PrintLine();
Console.ReadLine();
}
}
catch (Exception ex)
{
CliUtils.PrintError(ex.Message);
var errorLogFilePath = CliUtils.CreateErrorLogFile("siteserver");
CliUtils.AppendErrorLogs(errorLogFilePath, new List <TextLogInfo> {
new TextLogInfo
{
DateTime = DateTime.Now,
Detail = "Console Error",
Exception = ex
}
});
}
}