public static object SpannerRestoreDatabase(
string projectId, string instanceId, string databaseId, string backupId)
{
// Create the DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
InstanceName parentAsInstanceName =
InstanceName.FromProjectInstance(projectId, instanceId);
BackupName backupAsBackupName =
BackupName.FromProjectInstanceBackup(projectId, instanceId, backupId);
// Make the RestoreDatabase request.
Operation <Database, RestoreDatabaseMetadata> response =
databaseAdminClient.RestoreDatabase(
parentAsInstanceName, databaseId, backupAsBackupName);
Console.WriteLine("Waiting for the operation to finish");
// Poll until the returned long-running operation is complete.
var completedResponse = response.PollUntilCompleted();
if (completedResponse.IsFaulted)
{
Console.WriteLine($"Database Restore Failed: {completedResponse.Exception}");
return(1);
}
RestoreInfo restoreInfo = completedResponse.Result.RestoreInfo;
Console.WriteLine(
$"Database {restoreInfo.BackupInfo.SourceDatabase} was restored " +
$"to {databaseId} from backup {restoreInfo.BackupInfo.Backup}");
return(0);
}
public void SendMessage(string message, bool isRestoreFile = true)
{
var currentStep = new RestoreInfo();
currentStep.Message = message;
currentStep.IsRestoreFile = isRestoreFile;
this.restoreAciton(currentStep);
}
private void RestoreCallBackExcute(RestoreInfo restoreInfo)
{
new Thread(() =>
{
System.Windows.Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(() =>
{
this.CurrentRestoreInfo.IsRestoreFile = restoreInfo.IsRestoreFile;
this.CurrentRestoreInfo.IsDecompress = restoreInfo.IsDecompress;
this.CurrentRestoreInfo.Message = restoreInfo.Message;
if (restoreInfo.IsDecompress && restoreInfo.TotalSize != 0)
{
this.completeSize += restoreInfo.Size;
this.CurrentRestoreInfo.Percent = (decimal)this.completeSize / restoreInfo.TotalSize;
}
if (restoreInfo.IsRestoreFile)
{
this.CurrentRestoreInfo.RestoreTextList.Add(restoreInfo.Message);
}
}));
}).Start();
}
public void SendMessage(RestoreInfo restoreInfo)
{
this.restoreAciton(restoreInfo);
}
public override void Execute()
{
McsfRestoreLogger.WriteLog("[RestoreMainWorkflow]: restore begin.");
string bkpFilePath = Arguments[0];
List <string> packageList = Arguments[1];
restoreAciton = Arguments[2];
SendMessage("Restore start");
var tempFolderPath = Require <GetTempFolderPath>();//D:\MysqlResotre\Restore\时间戳
McsfRestoreLogger.WriteLog("[RestoreMainWorkflow]: tempFolderPath is " + tempFolderPath);
var compressedFilePath = Require <GetCompressedFilePathFromFolderPath>(tempFolderPath);
McsfRestoreLogger.WriteLog("[RestoreMainWorkflow]: compressedFilePath is " + compressedFilePath);
var rootFolderPath = Require <GetRootFolderPath>();
Require <CreateFolder>(rootFolderPath);
var message = Require <GetRestoreInfoMainWorkflow>(Require <GetMessageFromFile>(bkpFilePath));
McsfRestoreLogger.WriteLog("[RestoreMainWorkflow]: message is " + message);
Require <GenerateCompressedFile>(bkpFilePath, compressedFilePath);//去除bkp头部字符串
var serviceCompress = new Compress();
//计算bkp包大小
SendMessage("Calculate bkp size start");
SendMessage("Calculate bkp size....");
var totalsize = serviceCompress.getTotalSize(compressedFilePath);
McsfRestoreLogger.WriteLog("[RestoreMainWorkflow]: totalsize is " + totalsize);
//解压压缩包
SendMessage("Decompress start", true);
long addSize = (long)(totalsize * 0.1);
bool isOkToDecompress = serviceCompress.unzipFiles(compressedFilePath, rootFolderPath + @"Backup", restoreAciton, totalsize + addSize, addSize);
if (!isOkToDecompress)
{
Export = ResultType.Fail;
SendMessage("Decompress failed.");
}
var depressRult = new RestoreInfo
{
TotalSize = totalsize + addSize,
Size = totalsize + addSize,
Message = "Decompress complete."
};
SendMessage(depressRult);
McsfRestoreLogger.WriteLog(string.Format("[RestoreMainWorkflow]: decompress target is {0} and unzipFiles result is {1}", rootFolderPath + @"Backup", isOkToDecompress));
SendMessage("Decompress success", true);
//restore 文件
SendMessage("Restore files start.", false, true);
var restoreResult = Require <RestoreFiles>(packageList, message, restoreAciton);
McsfRestoreLogger.WriteLog("[RestoreMainWorkflow]: restoreFiles result is " + restoreResult);
if (!restoreResult)
{
Export = ResultType.Fail;
SendMessage("Restore files failed", false, true);
}
else
{
SendMessage("Restore files end.", false, true);
SendMessage("Restore success.", false, true);
}
SendMessage("Exprot start...", false, true);
var batPath = Path.GetFullPath(@"../ExportTool/StartExport.bat");
var isBatSuccess = Require <ExcuteBat>(batPath);
if (!isBatSuccess)
{
Export = ResultType.Fail;
SendMessage("Exprot failed", false, true);
}
else
{
SendMessage("Exprot end", false, true);
SendMessage("Exprot success", false, true);
}
Export = ResultType.Successful;
}
/// <summary>
/// Decompress zip file.
/// </summary>
/// <param name="strZipFile">Zip file path</param>
/// <param name="strDir">The path of the directory after decompress</param>
/// <returns>true:Decompress successfully.
/// failed:Decompress failed.
public bool unzipFiles(string strZipFile, string strDir, Action <RestoreInfo> restoreAciton, long totalSize, long addSize)
{
McsfRestoreLogger.WriteLog("[unzipFiles]: strZipFile is " + strZipFile);
string rootPath = "";
ZipInputStream zipStream = null;
try
{
if (File.Exists(strZipFile))
{
bool bUnzipDir = false;
if (!Directory.Exists(strDir))
{
bUnzipDir = (Directory.CreateDirectory(strDir) != null);
}
else
{
bUnzipDir = true;
}
if (bUnzipDir)
{
zipStream = new ZipInputStream(File.OpenRead(strZipFile));
if (zipStream != null)
{
RestoreInfo restoreInfo = new RestoreInfo();
restoreInfo.IsDecompress = true;
restoreInfo.Size = 0;
restoreInfo.TotalSize = totalSize;
restoreInfo.Message = "Decompressing .....";
ZipEntry zipEntry = null;
while ((zipEntry = zipStream.GetNextEntry()) != null)
{
if (zipEntry.ToString().Contains("\\"))
{
rootPath = strDir + @"\" + zipEntry.ToString().Substring(0, zipEntry.ToString().IndexOf("\\"));
}
else
{
rootPath = strDir + @"\";
}
zipEntry.IsUnicodeText = true;
//McsfRestoreLogger.WriteLog("[unzipFiles]: zipEntry.Name is " + zipEntry.Name);
string strUnzipFile = strDir + "//" + zipEntry.Name;
string strFileName = Path.GetFileName(strUnzipFile);
string strDirName = Path.GetDirectoryName(strUnzipFile);
if (!string.IsNullOrEmpty(strDirName))
{
Directory.CreateDirectory(strDirName);
}
if (!string.IsNullOrEmpty(strFileName))
{
using (FileStream unzipFileStream = new FileStream(strUnzipFile, FileMode.Create))
{
//McsfRestoreLogger.WriteLog(string.Format("[unzipFiles]: zip file name:{0},zip stream file name :{1}", strZipFile, strUnzipFile));
if (unzipFileStream != null)
{
byte[] buf = new byte[bufferSize];
int size = 0;
long remainSize = zipStream.Length;
while (true)
{
if (remainSize > bufferSize)
{
size = zipStream.Read(buf, 0, bufferSize);
unzipFileStream.Write(buf, 0, size - 0);
remainSize = remainSize - bufferSize;
}
else
{
size = zipStream.Read(buf, 0, Convert.ToInt32(remainSize));
unzipFileStream.Write(buf, 0, size - 0);
break;
}
restoreInfo.Size = size;
restoreAciton(restoreInfo);
}
unzipFileStream.Flush();
unzipFileStream.Close();
}
}
}
}
zipStream.Close();
McsfRestoreLogger.WriteLog("[unzipFiles]: Decompress zip file successfully.");
return(true);
}
else
{
McsfRestoreLogger.WriteLog("[unzipFiles]: Zip folder is not exist.");
return(false);
}
}
else
{
McsfRestoreLogger.WriteLog("[unzipFiles]: Decompress zip file is not exist.");
return(false);
}
}
else
{
McsfRestoreLogger.WriteLog("[unzipFiles]: Zip file is not exist.");
return(false);
}
}
catch (Exception Ex)
{
zipStream.Close();
McsfRestoreLogger.WriteLog("[unzipFiles] exception: " + Ex.Message);
return(false);
}
finally
{
var piece = (long)(addSize * 0.1);
RestoreInfo restoreInfo = new RestoreInfo();
restoreInfo.IsDecompress = true;
restoreInfo.TotalSize = totalSize;
restoreInfo.Message = "Decompressing .....";
restoreAciton(restoreInfo);
//0.1
DeleteSpecialFile(strDir);
restoreInfo.Size = piece;
restoreAciton(restoreInfo);
//0.1
if (File.Exists(rootPath + @"\\" + tempFileForFolderTime))
{
RestoreFolderTime(rootPath, rootPath, rootPath + @"\\" + tempFileForFolderTime);
File.Delete(rootPath + @"\\" + tempFileForFolderTime);
}
restoreInfo.Size = piece;
restoreAciton(restoreInfo);
//0.1
if (File.Exists(rootPath + @"\\" + tempFileForFileTime))
{
DirectoryInfo dire = new DirectoryInfo(rootPath);
FileInfo[] files = dire.GetFiles("*", SearchOption.AllDirectories);
foreach (FileInfo file in files)
{
RestoreFileTime(rootPath, file.FullName, rootPath + @"\\" + tempFileForFileTime);
}
File.Delete(rootPath + @"\\" + tempFileForFileTime);
}
restoreInfo.Size = piece;
restoreAciton(restoreInfo);
//0.1
if (File.Exists(strDir + @"\\" + tempFileForFolderTime))
{
RestoreFolderTime(strDir, strDir, strDir + @"\\" + tempFileForFolderTime);
File.Delete(strDir + @"\\" + tempFileForFolderTime);
}
restoreInfo.Size = piece;
restoreAciton(restoreInfo);
//0.6
if (File.Exists(strDir + @"\\" + tempFileForFileTime))
{
var remain = 6 * piece;
long slice = 0;
DirectoryInfo dire = new DirectoryInfo(strDir);
FileInfo[] files = dire.GetFiles("*", SearchOption.AllDirectories);
if (remain > remain / files.Length && files.Length > 0)
{
slice = remain / files.Length;
}
foreach (FileInfo file in files)
{
RestoreFileTime(strDir, file.FullName, strDir + @"\\" + tempFileForFileTime);
restoreInfo.Size = slice;
restoreAciton(restoreInfo);
}
File.Delete(strDir + @"\\" + tempFileForFileTime);
}
}
}
