public RestoreOperation(RestoreOperationOptions options)
{
Options = options;
}
protected async void DoRestore(CustomRestoreAgent agent, Models.Restore restore, RestoreOperationOptions options)
{
try
{
CurrentState = RestoreOperationState.STARTING;
OnStart(agent, restore);
// Mount all network mappings and abort if there is any network mapping failure.
CurrentState = RestoreOperationState.MAPPING_NETWORK_DRIVES;
Helper.MountAllNetworkDrives();
// Execute pre-actions
CurrentState = RestoreOperationState.EXECUTING_PRE_ACTIONS;
Helper.ExecutePreActions();
//
// Scanning
//
CurrentState = RestoreOperationState.SCANNING_FILES;
LinkedList <CustomVersionedFile> filesToProcess = null;
{
Task <PathScanResults <CustomVersionedFile> > filesToProcessTask = GetFilesToProcess(restore);
{
var message = string.Format("Scanning files started.");
Info(message);
//StatusInfo.Update(BackupStatusLevel.INFO, message);
OnUpdate(new RestoreOperationEvent {
Status = RestoreOperationStatus.ScanningFilesStarted, Message = message
});
}
try
{
await filesToProcessTask;
}
catch (Exception ex)
{
if (ex.IsCancellation())
{
string message = string.Format("Scanning files was canceled.");
Report.AddErrorMessage(message);
logger.Warn(message);
}
else
{
string message = string.Format("Caught exception during scanning files: {0}", ex.Message);
Report.AddErrorMessage(message);
logger.Log(LogLevel.Error, ex, message);
}
if (filesToProcessTask.IsFaulted || filesToProcessTask.IsCanceled)
{
if (filesToProcessTask.IsCanceled)
{
OnCancelation(agent, restore, ex); // filesToProcessTask.Exception
}
else
{
OnFailure(agent, restore, ex); // filesToProcessTask.Exception
}
return;
}
}
filesToProcess = filesToProcessTask.Result.Files;
{
foreach (var entry in filesToProcessTask.Result.FailedFiles)
{
Report.AddErrorMessage(entry.Value);
}
if (filesToProcessTask.Result.FailedFiles.Count > 0)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Scanning failed for the following drives/files/directories:");
foreach (var entry in filesToProcessTask.Result.FailedFiles)
{
sb.AppendLine(string.Format(" Path: {0} - Reason: {1}", entry.Key, entry.Value));
}
Warn(sb.ToString());
}
var message = string.Format("Scanning files finished.");
Info(message);
//StatusInfo.Update(BackupStatusLevel.INFO, message);
OnUpdate(new RestoreOperationEvent {
Status = RestoreOperationStatus.ScanningFilesFinished, Message = message
});
}
}
//
// Versioning
//
CurrentState = RestoreOperationState.VERSIONING_FILES;
{
Task versionerTask = DoVersionFiles(restore, filesToProcess);
{
var message = string.Format("Processing files started.");
Info(message);
//StatusInfo.Update(RestoreStatusLevel.INFO, message);
OnUpdate(new RestoreOperationEvent {
Status = RestoreOperationStatus.ProcessingFilesStarted, Message = message
});
}
try
{
await versionerTask;
}
catch (Exception ex)
{
if (ex.IsCancellation())
{
string message = string.Format("Processing files was canceled.");
Report.AddErrorMessage(message);
logger.Warn(message);
}
else
{
string message = string.Format("Caught exception during processing files: {0}", ex.Message);
Report.AddErrorMessage(message);
logger.Log(LogLevel.Error, ex, message);
}
if (versionerTask.IsFaulted || versionerTask.IsCanceled)
{
Versioner.Undo();
if (versionerTask.IsCanceled)
{
OnCancelation(agent, restore, ex); // versionerTask.Exception
}
else
{
OnFailure(agent, restore, ex); // versionerTask.Exception
}
return;
}
}
agent.Files = Versioner.FilesToTransfer;
{
var message = string.Format("Processing files finished.");
Info(message);
//StatusInfo.Update(BackupStatusLevel.INFO, message);
OnUpdate(new RestoreOperationEvent {
Status = RestoreOperationStatus.ProcessingFilesFinished, Message = message
});
}
{
agent.Results.Stats.BytesTotal = agent.EstimatedTransferSize;
var message = string.Format("Estimated restore size: {0} files, {1}",
agent.Files.Count(), FileSizeUtils.FileSizeToString(agent.EstimatedTransferSize));
Info(message);
}
}
//
// Transfer files
//
CurrentState = RestoreOperationState.TRANSFERRING_FILES;
{
Task <TransferResults> transferTask = agent.Start();
Report.TransferResults = transferTask.Result;
{
var message = string.Format("Transfer files started.");
Info(message);
}
try
{
await transferTask;
}
catch (Exception ex)
{
if (ex.IsCancellation())
{
string message = string.Format("Transfer files was canceled.");
Report.AddErrorMessage(message);
logger.Warn(message);
}
else
{
string message = string.Format("Caught exception during transfer files: {0}", ex.Message);
Report.AddErrorMessage(message);
logger.Log(LogLevel.Error, ex, message);
}
if (transferTask.IsFaulted || transferTask.IsCanceled)
{
if (transferTask.IsCanceled)
{
OnCancelation(agent, restore, ex); // transferTask.Exception
}
else
{
OnFailure(agent, restore, ex); // transferTask.Exception
}
return;
}
}
{
var message = string.Format("Transfer files finished.");
Info(message);
}
}
CurrentState = RestoreOperationState.EXECUTING_POST_ACTIONS;
Helper.ExecutePostActions(Report.TransferResults);
CurrentState = RestoreOperationState.FINISHING;
OnFinish(agent, restore);
}
catch (Exception ex)
{
OnFinish(agent, restore, ex);
}
}
public NewRestoreOperation(Models.RestorePlan plan, RestoreOperationOptions options)
: base(options)
{
Restore = new Models.Restore(plan);
}
