private void ExecuteOperation(DacFxOperation operation, DacFxParams parameters, string taskName, RequestContext <DacFxResult> requestContext) { Task.Run(async() => { try { TaskMetadata metadata = TaskMetadata.Create(parameters, taskName, operation, ConnectionServiceInstance); // put appropriate database name since connection passed was to master metadata.DatabaseName = parameters.DatabaseName; SqlTask sqlTask = SqlTaskManagerInstance.CreateTask <SqlTask>(metadata); await sqlTask.RunAsync(); await requestContext.SendResult(new DacFxResult() { OperationId = operation.OperationId, Success = sqlTask.TaskStatus == SqlTaskStatus.Succeeded, ErrorMessage = string.Empty }); } catch (Exception e) { await requestContext.SendResult(new DacFxResult() { OperationId = operation.OperationId, Success = false, ErrorMessage = e.Message }); } }); }
public async Task VerifyRunningMultipleBackupTasks() { using (SqlTaskManager manager = new SqlTaskManager()) { var mockBackupOperation = new Mock <IBackupOperation>(); TaskMetadata taskMetaData = this.CreateTaskMetaData(mockBackupOperation.Object); SqlTask sqlTask = manager.CreateTask <SqlTask>(taskMetaData); SqlTask sqlTask2 = manager.CreateTask <SqlTask>(taskMetaData); Assert.NotNull(sqlTask); Assert.NotNull(sqlTask2); Task taskToVerify = sqlTask.RunAsync().ContinueWith(Task => { Assert.Equal(SqlTaskStatus.Succeeded, sqlTask.TaskStatus); }); Task taskToVerify2 = sqlTask2.RunAsync().ContinueWith(Task => { Assert.Equal(SqlTaskStatus.Succeeded, sqlTask2.TaskStatus); }); await Task.WhenAll(taskToVerify, taskToVerify2); } }
public async Task VerifyCombinationRunAndCancelBackupTasks() { using (SqlTaskManager manager = new SqlTaskManager()) { IBackupOperation backupOperation = new BackupOperationStub(); TaskMetadata taskMetaData = this.CreateTaskMetaData(backupOperation); SqlTask sqlTask = manager.CreateTask <SqlTask>(taskMetaData); var mockBackupOperation = new Mock <IBackupOperation>(); TaskMetadata taskMetaData2 = this.CreateTaskMetaData(mockBackupOperation.Object); SqlTask sqlTask2 = manager.CreateTask <SqlTask>(taskMetaData); Assert.NotNull(sqlTask); Assert.NotNull(sqlTask2); Task taskToVerify = sqlTask.RunAsync().ContinueWith(Task => { Assert.Equal(SqlTaskStatus.Canceled, sqlTask.TaskStatus); Assert.Equal(sqlTask.IsCancelRequested, true); ((BackupOperationStub)backupOperation).BackupSemaphore.Release(); manager.Reset(); }); Task taskToVerify2 = sqlTask2.RunAsync().ContinueWith(Task => { Assert.Equal(SqlTaskStatus.Succeeded, sqlTask2.TaskStatus); }); manager.CancelTask(sqlTask.TaskId); await Task.WhenAll(taskToVerify, taskToVerify2); } }
public async Task ToTaskInfoShouldReturnTaskInfo() { SqlTaskStatus expectedStatus = SqlTaskStatus.Succeeded; DatabaseOperationStub operation = new DatabaseOperationStub(); operation.TaskResult = new TaskResult { TaskStatus = expectedStatus }; SqlTask sqlTask = new SqlTask(new TaskMetadata { ServerName = "server name", DatabaseName = "database name" }, operation.FunctionToRun, operation.FunctionToCancel); Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => { var taskInfo = sqlTask.ToTaskInfo(); Assert.Equal(taskInfo.TaskId, sqlTask.TaskId.ToString()); Assert.Equal(taskInfo.ServerName, "server name"); Assert.Equal(taskInfo.DatabaseName, "database name"); }); operation.Stop(); await taskToVerify; }
public async Task VerifyTaskWithExecutionMode(TaskExecutionMode executionMode, bool makeTaskFail = false) { serviceHostMock.AddEventHandling(TaskStatusChangedNotification.Type, null); using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile()) { //To make the task fail don't create the schema so create table fails string query = string.Empty; if (!makeTaskFail) { query = $"CREATE SCHEMA [test]"; } SqlTestDb testDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, query, "TaskService"); try { TestConnectionResult connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync(testDb.DatabaseName, queryTempFile.FilePath); string taskName = "task name"; Server server = CreateServerObject(connectionResult.ConnectionInfo); RequstParamStub requstParam = new RequstParamStub { TaskExecutionMode = executionMode, OwnerUri = queryTempFile.FilePath }; SmoScriptableTaskOperationStub taskOperation = new SmoScriptableTaskOperationStub(server); taskOperation.DatabaseName = testDb.DatabaseName; taskOperation.TableName = "newTable"; TaskMetadata taskMetadata = TaskMetadata.Create(requstParam, taskName, taskOperation, ConnectionService.Instance); SqlTask sqlTask = service.TaskManager.CreateTask <SqlTask>(taskMetadata); Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => { if (!makeTaskFail) { if (executionMode == TaskExecutionMode.Script || executionMode == TaskExecutionMode.ExecuteAndScript) { serviceHostMock.Verify(x => x.SendEvent(TaskStatusChangedNotification.Type, It.Is <TaskProgressInfo>(t => !string.IsNullOrEmpty(t.Script))), Times.AtLeastOnce()); } //Verify if the table created if execution mode includes execute bool expected = executionMode == TaskExecutionMode.Execute || executionMode == TaskExecutionMode.ExecuteAndScript; Server serverToverfiy = CreateServerObject(connectionResult.ConnectionInfo); bool actual = serverToverfiy.Databases[testDb.DatabaseName].Tables.Contains(taskOperation.TableName, "test"); Assert.Equal(expected, actual); } else { serviceHostMock.Verify(x => x.SendEvent(TaskStatusChangedNotification.Type, It.Is <TaskProgressInfo>(t => t.Status == SqlTaskStatus.Failed)), Times.AtLeastOnce()); } }); await taskToVerify; } finally { testDb.Cleanup(); } } }
public async Task CancelTaskShouldCancelTheOperationAndSendNotification() { serviceHostMock.AddEventHandling(TaskCreatedNotification.Type, null); serviceHostMock.AddEventHandling(TaskStatusChangedNotification.Type, null); DatabaseOperationStub operation = new DatabaseOperationStub(); SqlTask sqlTask = service.TaskManager.CreateTask(taskMetaData, operation.FunctionToRun, operation.FunctionToCancel); Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => { serviceHostMock.Verify(x => x.SendEvent(TaskStatusChangedNotification.Type, It.Is <TaskProgressInfo>(t => t.Status == SqlTaskStatus.Canceled)), Times.AtLeastOnce()); }); CancelTaskParams cancelParams = new CancelTaskParams { TaskId = sqlTask.TaskId.ToString() }; await RunAndVerify <bool>( test : (requestContext) => service.HandleCancelTaskRequest(cancelParams, requestContext), verify : ((result) => { })); serviceHostMock.Verify(x => x.SendEvent(TaskCreatedNotification.Type, It.Is <TaskInfo>(t => t.TaskId == sqlTask.TaskId.ToString())), Times.Once()); await taskToVerify; }
public async Task VerifyScriptTask() { using (SqlTaskManager manager = new SqlTaskManager()) { DatabaseOperationStub operation = new DatabaseOperationStub(); operation.TaskResult = new TaskResult { TaskStatus = SqlTaskStatus.Succeeded }; SqlTask sqlTask = manager.CreateTask(taskMetaData, operation.FunctionToScript); bool scriptAddedEventRaised = false; string script = null; sqlTask.ScriptAdded += (object sender, TaskEventArgs <TaskScript> e) => { scriptAddedEventRaised = true; script = e.TaskData.Script; }; Assert.NotNull(sqlTask); Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => { Assert.True(scriptAddedEventRaised); Assert.True(!string.IsNullOrEmpty(script)); Assert.True(manager.HasCompletedTasks()); manager.RemoveCompletedTask(sqlTask); }); operation.Stop(); await taskToVerify; } }
public async Task VerifyCreateAndRunningTask() { using (SqlTaskManager manager = new SqlTaskManager()) { bool taskAddedEventRaised = false; manager.TaskAdded += (object sender, TaskEventArgs <SqlTask> e) => { taskAddedEventRaised = true; }; DatabaseOperationStub operation = new DatabaseOperationStub(); operation.TaskResult = new TaskResult { TaskStatus = SqlTaskStatus.Succeeded }; SqlTask sqlTask = manager.CreateTask(taskMetaData, operation.FunctionToRun); Assert.NotNull(sqlTask); Assert.True(taskAddedEventRaised); Assert.False(manager.HasCompletedTasks()); Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => { Assert.True(manager.HasCompletedTasks()); manager.RemoveCompletedTask(sqlTask); }); operation.Stop(); await taskToVerify; } }
public async Task VerifyRunningBackupTask() { using (SqlTaskManager manager = new SqlTaskManager()) { DisasterRecoveryService service = new DisasterRecoveryService(); var mockBackupOperation = new Mock <IBackupOperation>(); TaskMetadata taskMetaData = this.CreateTaskMetaData(mockBackupOperation.Object); SqlTask sqlTask = manager.CreateTask <SqlTask>(taskMetaData); Assert.NotNull(sqlTask); Task taskToVerify = sqlTask.RunAsync().ContinueWith(Task => { Assert.Equal(SqlTaskStatus.Succeeded, sqlTask.TaskStatus); }); await taskToVerify; } }
public async Task VerifyScriptBackupTask() { using (SqlTaskManager manager = new SqlTaskManager()) { var mockBackupOperation = new Mock <IBackupOperation>(); TaskMetadata taskMetaData = this.CreateTaskMetaData(mockBackupOperation.Object); taskMetaData.TaskExecutionMode = TaskExecutionMode.Script; SqlTask sqlTask = manager.CreateTask <SqlTask>(taskMetaData); Assert.NotNull(sqlTask); Task taskToVerify = sqlTask.RunAsync().ContinueWith(Task => { Assert.Equal(SqlTaskStatus.Succeeded, sqlTask.TaskStatus); }); await taskToVerify; } }
public async Task VerifyCancelBackupTask() { using (SqlTaskManager manager = new SqlTaskManager()) { IBackupOperation backupOperation = new BackupOperationStub(); TaskMetadata taskMetaData = this.CreateTaskMetaData(backupOperation); SqlTask sqlTask = manager.CreateTask <SqlTask>(taskMetaData); Assert.NotNull(sqlTask); Task taskToVerify = sqlTask.RunAsync().ContinueWith(Task => { Assert.Equal(SqlTaskStatus.Canceled, sqlTask.TaskStatus); Assert.Equal(sqlTask.IsCancelRequested, true); ((BackupOperationStub)backupOperation).BackupSemaphore.Release(); manager.Reset(); }); manager.CancelTask(sqlTask.TaskId); await taskToVerify; } }
public async Task RunScriptShouldReturnScriptContent() { SqlTaskStatus expectedStatus = SqlTaskStatus.Succeeded; DatabaseOperationStub operation = new DatabaseOperationStub(); operation.TaskResult = new TaskResult { TaskStatus = expectedStatus }; SqlTask sqlTask = new SqlTask(new TaskMetadata(), operation.FunctionToScript, null); Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.NotStarted); Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => { Assert.Equal(sqlTask.TaskStatus, expectedStatus); Assert.Equal(sqlTask.IsCompleted, true); Assert.NotNull(operation.TaskScript); Assert.True(!string.IsNullOrEmpty(operation.TaskScript.Script)); }); await taskToVerify; }
public async Task FailedOperationShouldFailTheTask() { SqlTaskStatus expectedStatus = SqlTaskStatus.Failed; DatabaseOperationStub operation = new DatabaseOperationStub(); operation.TaskResult = new TaskResult { }; SqlTask sqlTask = new SqlTask(new TaskMetadata(), operation.FunctionToRun, operation.FunctionToCancel); Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.NotStarted); Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => { Assert.Equal(sqlTask.TaskStatus, expectedStatus); Assert.True(sqlTask.Duration > 0); }); Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.InProgress); Thread.Sleep(1000); operation.FailTheOperation(); await taskToVerify; }
public async Task CancelTaskShouldCancelTheOperation() { using (SqlTaskManager manager = new SqlTaskManager()) { SqlTaskStatus expectedStatus = SqlTaskStatus.Canceled; DatabaseOperationStub operation = new DatabaseOperationStub(); operation.TaskResult = new TaskResult { }; SqlTask sqlTask = manager.CreateTask(taskMetaData, operation.FunctionToRun, operation.FunctionToCancel); Assert.NotNull(sqlTask); Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => { Assert.Equal(expectedStatus, sqlTask.TaskStatus); Assert.Equal(sqlTask.IsCancelRequested, true); manager.Reset(); }); manager.CancelTask(sqlTask.TaskId); await taskToVerify; } }
public async Task RunShouldRunTheFunctionAndGetTheResult() { SqlTaskStatus expectedStatus = SqlTaskStatus.Succeeded; DatabaseOperationStub operation = new DatabaseOperationStub(); operation.TaskResult = new TaskResult { TaskStatus = expectedStatus }; SqlTask sqlTask = new SqlTask(new TaskMetadata(), operation.FunctionToRun, null); Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.NotStarted); Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => { Assert.Equal(sqlTask.TaskStatus, expectedStatus); Assert.Equal(sqlTask.IsCompleted, true); Assert.True(sqlTask.Duration > 0); }); Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.InProgress); Thread.Sleep(1000); operation.Stop(); await taskToVerify; }
public async Task VerifyCancelMultipleBackupTasks() { using (SqlTaskManager manager = new SqlTaskManager()) { DisasterRecoveryService service = new DisasterRecoveryService(); IBackupOperation backupOperation = new BackupOperationStub(); IBackupOperation backupOperation2 = new BackupOperationStub(); TaskMetadata taskMetaData = this.CreateTaskMetaData(backupOperation); TaskMetadata taskMetaData2 = this.CreateTaskMetaData(backupOperation2); SqlTask sqlTask = manager.CreateTask <SqlTask>(taskMetaData); SqlTask sqlTask2 = manager.CreateTask <SqlTask>(taskMetaData2); Assert.NotNull(sqlTask); Assert.NotNull(sqlTask2); Task taskToVerify = sqlTask.RunAsync().ContinueWith(Task => { Assert.Equal(SqlTaskStatus.Canceled, sqlTask.TaskStatus); Assert.Equal(sqlTask.IsCancelRequested, true); ((BackupOperationStub)backupOperation).BackupSemaphore.Release(); manager.Reset(); }); Task taskToVerify2 = sqlTask2.RunAsync().ContinueWith(Task => { Assert.Equal(SqlTaskStatus.Canceled, sqlTask2.TaskStatus); Assert.Equal(sqlTask2.IsCancelRequested, true); ((BackupOperationStub)backupOperation2).BackupSemaphore.Release(); manager.Reset(); }); manager.CancelTask(sqlTask.TaskId); manager.CancelTask(sqlTask2.TaskId); await Task.WhenAll(taskToVerify, taskToVerify2); } }