/// <summary>
/// Create a backup task for execution and cancellation
/// </summary>
/// <param name="sqlTask"></param>
/// <returns></returns>
internal async Task <TaskResult> BackupTaskAsync(SqlTask sqlTask)
{
sqlTask.AddMessage(SR.Task_InProgress, SqlTaskStatus.InProgress, true);
IBackupOperation backupOperation = sqlTask.TaskMetadata.Data as IBackupOperation;
TaskResult taskResult = null;
if (backupOperation != null)
{
AutoResetEvent backupCompletedEvent = new AutoResetEvent(initialState: false);
Task <TaskResult> performTask = PerformTaskAsync(backupOperation);
Task <TaskResult> cancelTask = CancelTaskAsync(backupOperation, sqlTask.TokenSource.Token, backupCompletedEvent);
Task <TaskResult> completedTask = await Task.WhenAny(performTask, cancelTask);
// Release the cancelTask
if (completedTask == performTask)
{
backupCompletedEvent.Set();
}
sqlTask.AddMessage(completedTask.Result.TaskStatus == SqlTaskStatus.Failed ? completedTask.Result.ErrorMessage : SR.Task_Completed,
completedTask.Result.TaskStatus);
taskResult = completedTask.Result;
}
else
{
taskResult = new TaskResult();
taskResult.TaskStatus = SqlTaskStatus.Failed;
}
return(taskResult);
}
public async Task <TaskResult> FunctionToScript(SqlTask sqlTask)
{
return(await Task.Factory.StartNew(() =>
{
sqlTask.AddMessage("start scripting", SqlTaskStatus.InProgress, true);
TaskScript = sqlTask.AddScript(SqlTaskStatus.Succeeded, "script generated!");
sqlTask.AddMessage("done", SqlTaskStatus.Succeeded);
return new TaskResult
{
TaskStatus = SqlTaskStatus.Succeeded,
};
}));
}
/// <summary>
/// Create a backup task for execution and cancellation
/// </summary>
/// <param name="sqlTask"></param>
/// <returns></returns>
internal async Task <TaskResult> RestoreTaskAsync(SqlTask sqlTask)
{
sqlTask.AddMessage(SR.Task_InProgress, SqlTaskStatus.InProgress, true);
RestoreDatabaseTaskDataObject restoreDataObject = sqlTask.TaskMetadata.Data as RestoreDatabaseTaskDataObject;
TaskResult taskResult = null;
if (restoreDataObject != null)
{
// Create a task to perform backup
return(await Task.Factory.StartNew(() =>
{
TaskResult result = new TaskResult();
try
{
if (restoreDataObject.IsValid)
{
ExecuteRestore(restoreDataObject);
result.TaskStatus = SqlTaskStatus.Succeeded;
}
else
{
result.TaskStatus = SqlTaskStatus.Failed;
if (restoreDataObject.ActiveException != null)
{
result.ErrorMessage = restoreDataObject.ActiveException.Message;
}
else
{
result.ErrorMessage = SR.RestoreNotSupported;
}
}
}
catch (Exception ex)
{
result.TaskStatus = SqlTaskStatus.Failed;
result.ErrorMessage = ex.Message;
if (ex.InnerException != null)
{
result.ErrorMessage += Environment.NewLine + ex.InnerException.Message;
}
if (restoreDataObject != null && restoreDataObject.ActiveException != null)
{
result.ErrorMessage += Environment.NewLine + restoreDataObject.ActiveException.Message;
}
}
return result;
}));
}
else
{
taskResult = new TaskResult();
taskResult.TaskStatus = SqlTaskStatus.Failed;
}
return(taskResult);
}
public async Task <TaskResult> FunctionToRun(SqlTask sqlTask)
{
return(await Task.Factory.StartNew(() =>
{
while (!IsStopped)
{
//Just keep running
if (sqlTask.TaskStatus == SqlTaskStatus.Canceled)
{
break;
}
if (Failed)
{
throw new InvalidOperationException();
}
sqlTask.AddMessage("still running", SqlTaskStatus.InProgress, true);
}
sqlTask.AddMessage("done!", SqlTaskStatus.Succeeded);
return TaskResult;
}));
}
/// <summary>
/// Executes the restore operations
/// </summary>
public void Execute()
{
RestorePlan restorePlan = GetRestorePlanForExecutionAndScript();
// ssms creates a new restore plan by calling GetRestorePlanForExecutionAndScript and
// Doens't use the plan already created here. not sure why, using the existing restore plan doesn't make
// any issue so far so keeping in it for now but we might want to double check later
if (restorePlan != null && restorePlan.RestoreOperations.Count > 0)
{
restorePlan.PercentComplete += (object sender, PercentCompleteEventArgs e) =>
{
if (SqlTask != null)
{
SqlTask.AddMessage($"{e.Percent}%", SqlTaskStatus.InProgress);
}
};
restorePlan.Execute();
}
}