public override void OnStart(CustomBackupAgent agent, Models.Backup backup)
{
base.OnStart(agent, backup);
_daoBackup.Update(backup);
var message = string.Format("Backup resumed at {0}", StartedAt);
Info(message);
//StatusInfo.Update(BackupStatusLevel.OK, message);
OnUpdate(new BackupOperationEvent {
Status = BackupOperationStatus.Resumed, Message = message
});
}
public void OnCancelation(CustomBackupAgent agent, Models.Backup backup, Exception exception)
{
IsRunning = false;
var message = string.Format("Backup canceled: {0}", exception != null ? exception.Message : "Exception not informed");
Report.AddErrorMessage(message);
Error(message);
//StatusInfo.Update(BackupStatusLevel.ERROR, message);
backup.WasCanceled();
_daoBackup.Update(backup);
OnUpdate(new BackupOperationEvent {
Status = BackupOperationStatus.Canceled, Message = message
});
}
public void OnFailure(CustomBackupAgent agent, Models.Backup backup, Exception exception)
{
IsRunning = false;
logger.Log(LogLevel.Error, exception, "Caught exception: {0}", exception.Message);
var message = string.Format("Backup failed: {0}", exception != null ? exception.Message : "Exception not informed");
Report.AddErrorMessage(message);
Error(message);
//StatusInfo.Update(BackupStatusLevel.ERROR, message);
backup.DidFail();
_daoBackup.Update(backup);
OnUpdate(new BackupOperationEvent {
Status = BackupOperationStatus.Failed, Message = message
});
}
/// <summary>
/// Implements the Dispose pattern
/// </summary>
/// <param name="disposing">Whether this object is being disposed via a call to Dispose
/// or garbage collected.</param>
protected override void Dispose(bool disposing)
{
if (!this._isDisposed)
{
if (disposing && _shouldDispose)
{
if (BackupAgent != null)
{
BackupAgent.Dispose();
BackupAgent = null;
}
if (Versioner != null)
{
Versioner.Dispose();
Versioner = null;
}
}
this._isDisposed = true;
}
base.Dispose(disposing);
}
public void OnFinish(CustomBackupAgent agent, Models.Backup backup, Exception ex = null)
{
IsRunning = false;
switch (CurrentState)
{
default:
{
var message = string.Format("Backup failed: {0}", ex.Message);
Warn(message);
//StatusInfo.Update(BackupStatusLevel.WARN, message);
Report.AddErrorMessage(ex.Message);
Report.OperationStatus = OperationStatus.FAILED;
backup.DidFail();
_daoBackup.Update(backup);
OnUpdate(new BackupOperationEvent {
Status = BackupOperationStatus.Failed, Message = message
});
break;
}
case BackupOperationState.FINISHING:
{
TransferResults.Statistics stats = agent.Results.Stats;
var message = string.Format(
"Backup finished! Stats: {0} completed, {1} failed, {2} canceled, {3} pending, {4} running",
stats.Completed, stats.Failed, stats.Canceled, stats.Pending, stats.Running);
Info(message);
//StatusInfo.Update(BackupStatusLevel.OK, message);
switch (agent.Results.OverallStatus)
//switch (backup.Status)
{
default: throw new InvalidOperationException("Unexpected TransferStatus");
case TransferStatus.CANCELED:
Report.OperationStatus = OperationStatus.CANCELED;
backup.WasCanceled();
_daoBackup.Update(backup);
OnUpdate(new BackupOperationEvent {
Status = BackupOperationStatus.Canceled, Message = message
});
break;
case TransferStatus.FAILED:
Report.OperationStatus = OperationStatus.FAILED;
backup.DidFail();
_daoBackup.Update(backup);
OnUpdate(new BackupOperationEvent {
Status = BackupOperationStatus.Failed, Message = message
});
break;
case TransferStatus.COMPLETED:
Report.OperationStatus = OperationStatus.COMPLETED;
backup.DidComplete();
_daoBackup.Update(backup);
OnUpdate(new BackupOperationEvent {
Status = BackupOperationStatus.Finished, Message = message
});
break;
}
break;
}
}
Report.StartedAt = Backup.StartedAt;
Report.FinishedAt = Backup.FinishedAt.Value;
}
public virtual void OnStart(CustomBackupAgent agent, Models.Backup backup)
{
IsRunning = true;
backup.DidStart();
}
protected void DoCancel(CustomBackupAgent agent)
{
agent.Cancel();
CancellationTokenSource.Cancel();
}
protected async void DoBackup(CustomBackupAgent agent, Models.Backup backup, BackupOperationOptions options)
{
try
{
CurrentState = BackupOperationState.STARTING;
OnStart(agent, backup);
// Mount all network mappings and abort if there is any network mapping failure.
CurrentState = BackupOperationState.MAPPING_NETWORK_DRIVES;
Helper.MountAllNetworkDrives();
// Execute pre-actions
CurrentState = BackupOperationState.EXECUTING_PRE_ACTIONS;
Helper.ExecutePreActions();
//
// Scanning
//
CurrentState = BackupOperationState.SCANNING_FILES;
LinkedList <string> filesToProcess = null;
{
Task <PathScanResults <string> > filesToProcessTask = GetFilesToProcess(backup);
{
var message = string.Format("Scanning files started.");
Info(message);
//StatusInfo.Update(BackupStatusLevel.INFO, message);
OnUpdate(new BackupOperationEvent {
Status = BackupOperationStatus.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, backup, ex); // filesToProcessTask.Exception
}
else
{
OnFailure(agent, backup, 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 BackupOperationEvent {
Status = BackupOperationStatus.ScanningFilesFinished, Message = message
});
}
}
//
// Update synced files
//
CurrentState = BackupOperationState.UPDATING_SYNCED_FILES;
{
Task updateSyncedFilesTask = ExecuteOnBackround(() =>
{
DoUpdateSyncedFiles(backup, filesToProcess);
}, CancellationTokenSource.Token);
{
var message = string.Format("Update of synced files started.");
Info(message);
}
try
{
await updateSyncedFilesTask;
}
catch (Exception ex)
{
if (ex.IsCancellation())
{
string message = string.Format("Update of synced files was canceled.");
Report.AddErrorMessage(message);
logger.Warn(message);
}
else
{
string message = string.Format("Caught exception during update of synced files: {0}", ex.Message);
Report.AddErrorMessage(message);
logger.Log(LogLevel.Error, ex, message);
}
if (updateSyncedFilesTask.IsFaulted || updateSyncedFilesTask.IsCanceled)
{
Versioner.Undo();
if (updateSyncedFilesTask.IsCanceled)
{
OnCancelation(agent, backup, ex); // updateSyncedFilesTask.Exception
}
else
{
OnFailure(agent, backup, ex); // updateSyncedFilesTask.Exception
}
return;
}
}
{
var message = string.Format("Update of synced files finished.");
Info(message);
}
}
//
// Versioning
//
CurrentState = BackupOperationState.VERSIONING_FILES;
{
Task <FileVersionerResults> versionerTask = DoVersionFiles(backup, filesToProcess);
Report.VersionerResults = versionerTask.Result;
{
var message = string.Format("Processing files started.");
Info(message);
//StatusInfo.Update(BackupStatusLevel.INFO, message);
OnUpdate(new BackupOperationEvent {
Status = BackupOperationStatus.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, backup, ex); // versionerTask.Exception
}
else
{
OnFailure(agent, backup, ex); // versionerTask.Exception
}
return;
}
}
agent.Files = Versioner.FilesToTransfer;
{
var message = string.Format("Processing files finished.");
Info(message);
//StatusInfo.Update(BackupStatusLevel.INFO, message);
OnUpdate(new BackupOperationEvent {
Status = BackupOperationStatus.ProcessingFilesFinished, Message = message
});
}
{
agent.Results.Stats.BytesTotal = agent.EstimatedTransferSize;
var message = string.Format("Estimated backup size: {0} files, {1}",
agent.Files.Count(), FileSizeUtils.FileSizeToString(agent.EstimatedTransferSize));
Info(message);
}
}
//
// Transfer files
//
CurrentState = BackupOperationState.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.TransferResults.ErrorMessages.Add(message);
logger.Warn(message);
}
else
{
string message = string.Format("Caught exception during transfer files: {0}", ex.Message);
Report.TransferResults.ErrorMessages.Add(message);
logger.Log(LogLevel.Error, ex, message);
}
if (transferTask.IsFaulted || transferTask.IsCanceled)
{
if (transferTask.IsCanceled)
{
OnCancelation(agent, backup, ex); // transferTask.Exception
}
else
{
OnFailure(agent, backup, ex); // transferTask.Exception
}
return;
}
}
{
var message = string.Format("Transfer files finished.");
Info(message);
}
}
CurrentState = BackupOperationState.EXECUTING_POST_ACTIONS;
Helper.ExecutePostActions(Report.TransferResults);
CurrentState = BackupOperationState.FINISHING;
OnFinish(agent, backup);
}
catch (Exception ex)
{
OnFinish(agent, backup, ex);
}
}
protected CustomBackupAgent BackupAgent; // IDisposable
public override void Start()
{
Assert.IsFalse(IsRunning);
Assert.IsNotNull(Backup);
Assert.IsNotNull(Backup.BackupPlan);
Assert.IsNotNull(Backup.BackupPlan.StorageAccount);
Assert.AreEqual(Models.EStorageAccountType.AmazonS3, Backup.BackupPlan.StorageAccountType);
Assert.AreEqual(CurrentState, BackupOperationState.UNKNOWN);
AmazonS3AccountRepository dao = new AmazonS3AccountRepository();
Models.AmazonS3Account s3account = dao.GetForReadOnly(Backup.BackupPlan.StorageAccount.Id);
//
// Dispose and recycle previous objects, if needed.
//
if (TransferAgent != null)
{
TransferAgent.Dispose();
}
if (TransferListControl != null)
{
TransferListControl.ClearTransfers();
}
if (BackupAgent != null)
{
BackupAgent.Dispose();
}
if (Versioner != null)
{
Versioner.Dispose();
}
//
// Setup agents.
//
AWSCredentials awsCredentials = new BasicAWSCredentials(s3account.AccessKey, s3account.SecretKey);
TransferAgentOptions options = new TransferAgentOptions
{
UploadChunkSizeInBytes = Teltec.Everest.Settings.Properties.Current.UploadChunkSize * 1024 * 1024,
};
TransferAgent = new S3TransferAgent(options, awsCredentials, s3account.BucketName, CancellationTokenSource.Token);
TransferAgent.RemoteRootDir = TransferAgent.PathBuilder.CombineRemotePath("TELTEC_BKP",
Backup.BackupPlan.StorageAccount.Hostname);
BackupAgent = new CustomBackupAgent(TransferAgent);
BackupAgent.Results.Monitor = TransferListControl;
Versioner = new IncrementalFileVersioner(CancellationTokenSource.Token);
RegisterResultsEventHandlers(Backup, BackupAgent.Results);
Report.PlanType = "backup";
Report.PlanName = Backup.BackupPlan.Name;
Report.BucketName = s3account.BucketName;
Report.HostName = Backup.BackupPlan.StorageAccount.Hostname;
Report.TransferResults = BackupAgent.Results;
Helper = new BaseOperationHelper(Backup.BackupPlan);
//
// Start the backup.
//
DoBackup(BackupAgent, Backup, Options);
}
