/// <summary> /// Handle request to get backup configuration info /// </summary> /// <param name="optionsParams"></param> /// <param name="requestContext"></param> /// <returns></returns> public static async Task HandleBackupConfigInfoRequest( DefaultDatabaseInfoParams optionsParams, RequestContext <BackupConfigInfoResponse> requestContext) { try { var response = new BackupConfigInfoResponse(); ConnectionInfo connInfo; DisasterRecoveryService.ConnectionServiceInstance.TryFindConnection( optionsParams.OwnerUri, out connInfo); if (connInfo != null) { DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true); SqlConnection sqlConn = GetSqlConnection(connInfo); if ((sqlConn != null) && !connInfo.IsSqlDW && !connInfo.IsAzure) { BackupConfigInfo backupConfigInfo = DisasterRecoveryService.Instance.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database); backupConfigInfo.DatabaseInfo = AdminService.GetDatabaseInfo(connInfo); response.BackupConfigInfo = backupConfigInfo; } } await requestContext.SendResult(response); } catch (Exception ex) { await requestContext.SendError(ex.ToString()); } }
public void CreateBackupTest() { DisasterRecoveryService service = new DisasterRecoveryService(); string databaseName = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999); var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName); using (SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName)) using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true)) using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo)) { string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn); BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName, BackupType.Full, new List <string>() { backupPath }, new Dictionary <string, int>() { { backupPath, (int)DeviceType.File } }); BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn); // Backup the database service.PerformBackup(backupOperation); VerifyAndCleanBackup(sqlConn, backupPath); } }
/// <summary> /// Handle request to get backup configuration info /// </summary> /// <param name="optionsParams"></param> /// <param name="requestContext"></param> /// <returns></returns> internal async Task HandleBackupConfigInfoRequest( DefaultDatabaseInfoParams optionsParams, RequestContext <BackupConfigInfoResponse> requestContext) { try { var response = new BackupConfigInfoResponse(); ConnectionInfo connInfo; DisasterRecoveryService.ConnectionServiceInstance.TryFindConnection( optionsParams.OwnerUri, out connInfo); if (connInfo != null) { using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true)) { using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Backup")) { if (sqlConn != null && !connInfo.IsCloud) { BackupConfigInfo backupConfigInfo = this.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database); response.BackupConfigInfo = backupConfigInfo; } } } } await requestContext.SendResult(response); } catch (Exception ex) { await requestContext.SendError(ex.ToString()); } }
//[Fact] public void ScriptBackupTest() { DisasterRecoveryService service = new DisasterRecoveryService(); string databaseName = "testbackup_" + new Random().Next(10000000, 99999999); SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName); var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName); DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true); SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo); string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn); BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName, BackupType.Full, new List <string>() { backupPath }, new Dictionary <string, int>() { { backupPath, (int)DeviceType.File } }); BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn); // Generate script for backup service.ScriptBackup(backupOperation); string script = backupOperation.ScriptContent; Assert.True(!string.IsNullOrEmpty(script)); // Execute the script testDb.RunQuery(script); VerifyAndCleanBackup(backupPath); testDb.Cleanup(); }
/// <summary> /// Test creating backup with advanced options set. /// </summary> //[Fact] public void ScriptBackupWithAdvancedOptionsTest() { DisasterRecoveryService service = new DisasterRecoveryService(); string databaseName = "testbackup_" + new Random().Next(10000000, 99999999); SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName); var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName); DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true); SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo); string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn); string certificateName = CreateCertificate(testDb); string cleanupCertificateQuery = string.Format(CleanupCertificateQueryFormat, certificateName); BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName, BackupType.Full, new List <string>() { backupPath }, new Dictionary <string, int>() { { backupPath, (int)DeviceType.File } }); backupInfo.FormatMedia = true; backupInfo.SkipTapeHeader = true; backupInfo.Initialize = true; backupInfo.MediaName = "backup test media"; backupInfo.MediaDescription = "backup test"; backupInfo.EncryptionAlgorithm = (int)BackupEncryptionAlgorithm.Aes128; backupInfo.EncryptorType = (int)BackupEncryptorType.ServerCertificate; backupInfo.EncryptorName = certificateName; BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn); // Backup the database Console.WriteLine("Generate script for backup operation.."); service.ScriptBackup(backupOperation); string script = backupOperation.ScriptContent; // Run the script Console.WriteLine("Execute the script.."); testDb.RunQuery(script); // Remove the backup file Console.WriteLine("Verify the backup file exists and remove.."); VerifyAndCleanBackup(backupPath); // Delete certificate and master key Console.WriteLine("Remove certificate and master key.."); testDb.RunQuery(cleanupCertificateQuery); // Clean up the database Console.WriteLine("Clean up database.."); testDb.Cleanup(); }
public void ValidateDefaultBackupFolderPath() { var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo("master"); DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true); SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo); string backupPath = GetDefaultBackupFolderPath(helper.DataContainer, sqlConn); bool isFolder; bool result = DisasterRecoveryFileValidator.IsPathExisting(sqlConn, backupPath, out isFolder); Assert.True(isFolder); Assert.True(result); }
//[Fact] public void ValidatorShouldReturnFalseForInvalidPath() { var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo("master"); DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true); string message; bool result = DisasterRecoveryFileValidator.ValidatePaths(new FileBrowserValidateEventArgs { ServiceType = FileValidationServiceConstants.Backup, OwnerUri = liveConnection.ConnectionInfo.OwnerUri, FilePaths = new string[] { Guid.NewGuid().ToString() } }, out message); Assert.False(result); Assert.True(!string.IsNullOrEmpty(message)); }
/// Test is failing in code coverage runs. Reenable when stable. ///[Fact] public void CreateBackupTest() { string databaseName = "testbackup_" + new Random().Next(10000000, 99999999); SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName); var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName); // Initialize backup service DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true); SqlConnection sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo); // Get default backup path BackupConfigInfo backupConfigInfo = DisasterRecoveryService.Instance.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database); string backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + ".bak"); BackupInfo backupInfo = CreateBackupInfo(databaseName, BackupType.Full, new List <string>() { backupPath }, new Dictionary <string, int>() { { backupPath, (int)DeviceType.File } }); var backupParams = new BackupParams { OwnerUri = liveConnection.ConnectionInfo.OwnerUri, BackupInfo = backupInfo }; // Backup the database BackupOperation backupOperation = DisasterRecoveryService.Instance.SetBackupInput(helper.DataContainer, sqlConn, backupParams.BackupInfo); DisasterRecoveryService.Instance.PerformBackup(backupOperation); // Remove the backup file if (File.Exists(backupPath)) { File.Delete(backupPath); } // Clean up the database testDb.Cleanup(); }
public void ValidateDefaultBackupFullFilePath() { var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo("master"); DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true); SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo); string backupPath = Path.Combine(GetDefaultBackupFolderPath(helper.DataContainer, sqlConn), "master.bak"); string message; bool result = DisasterRecoveryFileValidator.ValidatePaths(new FileBrowserValidateEventArgs { ServiceType = FileValidationServiceConstants.Backup, OwnerUri = liveConnection.ConnectionInfo.OwnerUri, FilePaths = new string[] { backupPath } }, out message); Assert.True(result); Assert.Empty(message); }
public async Task <string> CreateBackupFile() { using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile()) { SqlTestDb testDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "RestoreTest"); var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(testDb.DatabaseName, queryTempFile.FilePath); // Initialize backup service DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true); SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo); // Get default backup pathS BackupConfigInfo backupConfigInfo = DisasterRecoveryService.Instance.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database); string backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, testDb.DatabaseName + ".bak"); BackupInfo backupInfo = CreateBackupInfo(testDb.DatabaseName, BackupType.Full, new List <string>() { backupPath }, new Dictionary <string, int>() { { backupPath, (int)DeviceType.File } }); var backupParams = new BackupParams { OwnerUri = liveConnection.ConnectionInfo.OwnerUri, BackupInfo = backupInfo, TaskExecutionMode = TaskExecutionMode.Execute }; // Backup the database BackupOperation backupOperation = DisasterRecoveryService.Instance.CreateBackupOperation(helper.DataContainer, sqlConn, backupParams.BackupInfo); DisasterRecoveryService.Instance.PerformBackup(backupOperation); // Clean up the database testDb.Cleanup(); return(backupPath); } }
/// <summary> /// Handles a backup request /// </summary> internal static async Task HandleBackupRequest( BackupParams backupParams, RequestContext <BackupResponse> requestContext) { try { ConnectionInfo connInfo; DisasterRecoveryService.ConnectionServiceInstance.TryFindConnection( backupParams.OwnerUri, out connInfo); if (connInfo != null) { DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true); SqlConnection sqlConn = GetSqlConnection(connInfo); if ((sqlConn != null) && !connInfo.IsSqlDW && !connInfo.IsAzure) { BackupOperation backupOperation = DisasterRecoveryService.Instance.SetBackupInput(helper.DataContainer, sqlConn, backupParams.BackupInfo); // create task metadata TaskMetadata metadata = new TaskMetadata(); metadata.ServerName = connInfo.ConnectionDetails.ServerName; metadata.DatabaseName = connInfo.ConnectionDetails.DatabaseName; metadata.Name = SR.Backup_TaskName; metadata.IsCancelable = true; metadata.Data = backupOperation; // create backup task and perform SqlTask sqlTask = SqlTaskManager.Instance.CreateTask(metadata, Instance.BackupTaskAsync); sqlTask.Run(); } } await requestContext.SendResult(new BackupResponse()); } catch (Exception ex) { await requestContext.SendError(ex.ToString()); } }
/// <summary> /// Handles a backup request /// </summary> internal async Task HandleBackupRequest( BackupParams backupParams, RequestContext <BackupResponse> requestContext) { try { BackupResponse response = new BackupResponse(); ConnectionInfo connInfo; bool supported = IsBackupRestoreOperationSupported(backupParams.OwnerUri, out connInfo); if (supported && connInfo != null) { DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true); SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Backup"); // Connection gets discounnected when backup is done BackupOperation backupOperation = CreateBackupOperation(helper.DataContainer, sqlConn, backupParams.BackupInfo); SqlTask sqlTask = null; // create task metadata TaskMetadata metadata = TaskMetadata.Create(backupParams, SR.BackupTaskName, backupOperation, ConnectionServiceInstance); sqlTask = SqlTaskManagerInstance.CreateAndRun <SqlTask>(metadata); sqlTask.StatusChanged += CloseConnection; } else { response.Result = false; } await requestContext.SendResult(response); } catch (Exception ex) { await requestContext.SendError(ex.ToString()); } }
private string GenerateScriptForBackupType(BackupType backupType, string databaseName) { DisasterRecoveryService service = new DisasterRecoveryService(); var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName); DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true); SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo); string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn); BackupInfo backupInfoLog = CreateDefaultBackupInfo(databaseName, backupType, new List <string>() { backupPath }, new Dictionary <string, int>() { { backupPath, (int)DeviceType.File } }); backupInfoLog.FormatMedia = true; backupInfoLog.SkipTapeHeader = true; backupInfoLog.Initialize = true; backupInfoLog.MediaName = "backup test media"; backupInfoLog.MediaDescription = "backup test"; BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfoLog, helper.DataContainer, sqlConn); // Generate Script Console.WriteLine("Generate script for backup operation.."); service.ScriptBackup(backupOperation); string script = backupOperation.ScriptContent; // There shouldnt be any backup file created Assert.True(!File.Exists(backupPath), "Backup file is not expected to be created"); sqlConn.Close(); return(script); }
public async Task <string[]> CreateBackupSetsToRecoverDatabase() { List <string> backupFiles = new List <string>(); using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile()) { string query = $"CREATE SCHEMA [test]"; SqlTestDb testDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, query, "RestoreTest"); string databaseName = testDb.DatabaseName; // Initialize backup service var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName, queryTempFile.FilePath); DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true); using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo)) { BackupConfigInfo backupConfigInfo = DisasterRecoveryService.Instance.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database); query = $"create table [test].[{tableNames[0]}] (c1 int)"; await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, databaseName, query); string backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + "_full.bak"); query = $"BACKUP DATABASE [{databaseName}] TO DISK = N'{backupPath}' WITH NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD, STATS = 10"; await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query); backupFiles.Add(backupPath); query = $"create table [test].[{tableNames[1]}] (c1 int)"; await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, databaseName, query); backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + "_diff.bak"); query = $"BACKUP DATABASE [{databaseName}] TO DISK = N'{backupPath}' WITH DIFFERENTIAL, NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD, STATS = 10"; await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query); backupFiles.Add(backupPath); query = $"create table [test].[{tableNames[2]}] (c1 int)"; await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, databaseName, query); backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + "_log1.bak"); query = $"BACKUP Log [{databaseName}] TO DISK = N'{backupPath}' WITH NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD, STATS = 10"; await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query); backupFiles.Add(backupPath); query = $"create table [test].[{tableNames[3]}] (c1 int)"; await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, databaseName, query); backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + "_log2.bak"); query = $"BACKUP Log [{databaseName}] TO DISK = N'{backupPath}' WITH NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD, STATS = 10"; await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query); backupFiles.Add(backupPath); query = $"create table [test].[{tableNames[4]}] (c1 int)"; await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, databaseName, query); backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + "_log3.bak"); query = $"BACKUP Log [{databaseName}] TO DISK = N'{backupPath}' WITH NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD, STATS = 10"; await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query); backupFiles.Add(backupPath); databaseNameToRestoreFrom = testDb.DatabaseName; // Clean up the database testDb.Cleanup(); } } return(backupFiles.ToArray()); }
//[Fact] public async void BackupFileBrowserTest() { string databaseName = "testfilebrowser_" + new Random().Next(10000000, 99999999); SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName); // Initialize backup service var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName); DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true); SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo); DisasterRecoveryService disasterRecoveryService = new DisasterRecoveryService(); BackupConfigInfo backupConfigInfo = disasterRecoveryService.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database); // Create backup file string backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + ".bak"); string query = $"BACKUP DATABASE [{databaseName}] TO DISK = N'{backupPath}' WITH NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD, STATS = 10"; await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query); FileBrowserService service = new FileBrowserService(); string[] backupFilters = new string[2] { "*.bak", "*.trn" }; var openParams = new FileBrowserOpenParams { OwnerUri = liveConnection.ConnectionInfo.OwnerUri, ExpandPath = backupConfigInfo.DefaultBackupFolder, FileFilters = backupFilters }; var openBrowserEventFlowValidator = new EventFlowValidator <bool>() .AddEventValidation(FileBrowserOpenedNotification.Type, eventParams => { Assert.True(eventParams.Succeeded); Assert.NotNull(eventParams.FileTree); Assert.NotNull(eventParams.FileTree.RootNode); Assert.NotNull(eventParams.FileTree.RootNode.Children); Assert.True(eventParams.FileTree.RootNode.Children.Count > 0); Assert.True(ContainsFileInTheFolder(eventParams.FileTree.SelectedNode, backupPath)); }) .Complete(); await service.RunFileBrowserOpenTask(openParams, openBrowserEventFlowValidator.Object); // Verify complete notification event was fired and the result openBrowserEventFlowValidator.Validate(); var expandParams = new FileBrowserExpandParams { OwnerUri = liveConnection.ConnectionInfo.OwnerUri, ExpandPath = backupConfigInfo.DefaultBackupFolder }; var expandEventFlowValidator = new EventFlowValidator <bool>() .AddEventValidation(FileBrowserExpandedNotification.Type, eventParams => { Assert.True(eventParams.Succeeded); Assert.NotNull(eventParams.Children); Assert.True(eventParams.Children.Length > 0); }) .Complete(); // Expand the node in file browser await service.RunFileBrowserExpandTask(expandParams, expandEventFlowValidator.Object); // Verify result expandEventFlowValidator.Validate(); var validateParams = new FileBrowserValidateParams { OwnerUri = liveConnection.ConnectionInfo.OwnerUri, ServiceType = FileValidationServiceConstants.Backup, SelectedFiles = new[] { backupPath } }; var validateEventFlowValidator = new EventFlowValidator <bool>() .AddEventValidation(FileBrowserValidatedNotification.Type, eventParams => Assert.True(eventParams.Succeeded)) .Complete(); // Validate selected files in the browser await service.RunFileBrowserValidateTask(validateParams, validateEventFlowValidator.Object); // Verify complete notification event was fired and the result validateEventFlowValidator.Validate(); // Remove the backup file if (File.Exists(backupPath)) { File.Delete(backupPath); } }
public void CreateBackupWithAdvancedOptionsTest() { string databaseName = "testbackup_" + new Random().Next(10000000, 99999999); SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName); string certificateName = "backupcertificate" + new Random().Next(10000000, 99999999); string masterkeyPassword = Guid.NewGuid().ToString(); string createCertificateQuery = string.Format(CreateCertificateQueryFormat, masterkeyPassword, certificateName); string cleanupCertificateQuery = string.Format(CleanupCertificateQueryFormat, certificateName); // create master key and certificate Console.WriteLine("Create master key and certificate.."); testDb.RunQuery(createCertificateQuery); var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName); // Initialize backup service DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true); SqlConnection sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo); // Get default backup path Console.WriteLine("Get default backup path.."); BackupConfigInfo backupConfigInfo = DisasterRecoveryService.Instance.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database); string backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + ".bak"); BackupInfo backupInfo = CreateBackupInfo(databaseName, BackupType.Full, new List <string>() { backupPath }, new Dictionary <string, int>() { { backupPath, (int)DeviceType.File } }); // Set advanced options backupInfo.ContinueAfterError = true; backupInfo.FormatMedia = true; backupInfo.SkipTapeHeader = true; backupInfo.Initialize = true; backupInfo.MediaName = "backup test media"; backupInfo.MediaDescription = "backup test"; backupInfo.RetainDays = 90; backupInfo.CompressionOption = (int)BackupCompressionOptions.On; // Set encryption backupInfo.EncryptionAlgorithm = (int)BackupEncryptionAlgorithm.Aes128; backupInfo.EncryptorType = (int)BackupEncryptorType.ServerCertificate; backupInfo.EncryptorName = certificateName; var backupParams = new BackupParams { OwnerUri = liveConnection.ConnectionInfo.OwnerUri, BackupInfo = backupInfo }; // Backup the database Console.WriteLine("Perform backup operation.."); BackupOperation backupOperation = DisasterRecoveryService.Instance.SetBackupInput(helper.DataContainer, sqlConn, backupParams.BackupInfo); DisasterRecoveryService.Instance.PerformBackup(backupOperation); // Verify backup file is created Assert.True(File.Exists(backupPath)); // Remove the backup file Console.WriteLine("Remove backup file.."); if (File.Exists(backupPath)) { File.Delete(backupPath); } // Delete certificate and master key Console.WriteLine("Remove certificate and master key.."); testDb.RunQuery(cleanupCertificateQuery); // Clean up the database Console.WriteLine("Clean up database.."); testDb.Cleanup(); }