/// <summary>
/// Handles a restore config info request
/// </summary>
internal async Task HandleRestoreConfigInfoRequest(
RestoreConfigInfoRequestParams restoreConfigInfoParams,
RequestContext <RestoreConfigInfoResponse> requestContext)
{
RestoreConfigInfoResponse response = new RestoreConfigInfoResponse();
try
{
ConnectionInfo connInfo;
bool supported = IsBackupRestoreOperationSupported(restoreConfigInfoParams.OwnerUri, out connInfo);
if (supported && connInfo != null)
{
response = this.restoreDatabaseService.CreateConfigInfoResponse(restoreConfigInfoParams);
}
else
{
response.ErrorMessage = SR.RestoreNotSupported;
}
await requestContext.SendResult(response);
}
catch (Exception ex)
{
response.ErrorMessage = ex.Message;
await requestContext.SendResult(response);
}
}
/// <summary>
/// Creates response which includes information about the server given to restore (default data location, db names with backupsets)
/// </summary>
public RestoreConfigInfoResponse CreateConfigInfoResponse(RestoreConfigInfoRequestParams restoreConfigInfoRequest)
{
RestoreConfigInfoResponse response = new RestoreConfigInfoResponse();
RestoreDatabaseTaskDataObject restoreTaskObject = null;
try
{
restoreTaskObject = CreateRestoreForNewSession(restoreConfigInfoRequest.OwnerUri);
if (restoreTaskObject != null)
{
// Default Data folder path in the target server
response.ConfigInfo.Add(RestoreOptionsHelper.DataFileFolder, restoreTaskObject.DefaultDataFileFolder);
// Default log folder path in the target server
response.ConfigInfo.Add(RestoreOptionsHelper.LogFileFolder, restoreTaskObject.DefaultLogFileFolder);
// The db names with backup set
response.ConfigInfo.Add(RestoreOptionsHelper.SourceDatabaseNamesWithBackupSets, restoreTaskObject.GetDatabaseNamesWithBackupSets());
// Default backup folder path in the target server
response.ConfigInfo.Add(RestoreOptionsHelper.DefaultBackupFolder, restoreTaskObject.DefaultBackupFolder);
}
}
catch (Exception ex)
{
Logger.Write(LogLevel.Warning, $"Failed to create restore config info. error: { ex.Message}");
response.ErrorMessage = ex.Message;
}
finally
{
ServerConnection serverConnection = restoreTaskObject?.Server?.ConnectionContext;
if (serverConnection != null && serverConnection.IsOpen)
{
restoreTaskObject.Server.ConnectionContext.Disconnect();
}
}
return(response);
}
/// <summary>
/// Creates response which includes information about the server given to restore (default data location, db names with backupsets)
/// </summary>
public RestoreConfigInfoResponse CreateConfigInfoResponse(RestoreConfigInfoRequestParams restoreConfigInfoRequest)
{
RestoreConfigInfoResponse response = new RestoreConfigInfoResponse();
RestoreDatabaseTaskDataObject restoreTaskObject = CreateRestoreForNewSession(restoreConfigInfoRequest.OwnerUri);
if (restoreTaskObject != null)
{
// Default Data folder path in the target server
response.ConfigInfo.Add(RestoreOptionsHelper.DataFileFolder, restoreTaskObject.DefaultDataFileFolder);
// Default log folder path in the target server
response.ConfigInfo.Add(RestoreOptionsHelper.LogFileFolder, restoreTaskObject.DefaultLogFileFolder);
// The db names with backup set
response.ConfigInfo.Add(RestoreOptionsHelper.SourceDatabaseNamesWithBackupSets, restoreTaskObject.GetDatabaseNamesWithBackupSets());
}
return(response);
}
private async Task <RestorePlanResponse> VerifyRestore(
string[] backupFileNames = null,
string sourceDbName = null,
bool canRestore = true,
TaskExecutionModeFlag executionMode = TaskExecutionModeFlag.None,
string targetDatabase = null,
string[] selectedBackupSets = null,
Dictionary <string, object> options = null,
Func <Database, bool> verifyDatabase = null,
bool shouldFail = false)
{
string backUpFilePath = string.Empty;
if (backupFileNames != null)
{
var filePaths = backupFileNames.Select(x => GetBackupFilePath(x));
backUpFilePath = filePaths.Aggregate((current, next) => current + " ," + next);
}
using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
{
TestConnectionResult connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath);
RestoreDatabaseHelper service = new RestoreDatabaseHelper();
// If source database is sepecified verfiy it's part of source db list
if (!string.IsNullOrEmpty(sourceDbName))
{
RestoreConfigInfoResponse configInfoResponse = service.CreateConfigInfoResponse(new RestoreConfigInfoRequestParams
{
OwnerUri = queryTempFile.FilePath
});
IEnumerable <string> dbNames = configInfoResponse.ConfigInfo[RestoreOptionsHelper.SourceDatabaseNamesWithBackupSets] as IEnumerable <string>;
Assert.True(dbNames.Any(x => x == sourceDbName));
}
var request = new RestoreParams
{
BackupFilePaths = backUpFilePath,
TargetDatabaseName = targetDatabase,
OwnerUri = queryTempFile.FilePath,
SelectedBackupSets = selectedBackupSets,
SourceDatabaseName = sourceDbName
};
request.Options[RestoreOptionsHelper.ReadHeaderFromMedia] = backupFileNames != null;
if (options != null)
{
foreach (var item in options)
{
if (!request.Options.ContainsKey(item.Key))
{
request.Options.Add(item.Key, item.Value);
}
}
}
var restoreDataObject = service.CreateRestoreDatabaseTaskDataObject(request);
restoreDataObject.ConnectionInfo = connectionResult.ConnectionInfo;
var response = service.CreateRestorePlanResponse(restoreDataObject);
Assert.NotNull(response);
Assert.False(string.IsNullOrWhiteSpace(response.SessionId));
Assert.Equal(response.CanRestore, canRestore);
if (canRestore)
{
Assert.True(response.DbFiles.Any());
if (string.IsNullOrEmpty(targetDatabase))
{
targetDatabase = response.DatabaseName;
}
Assert.Equal(response.DatabaseName, targetDatabase);
Assert.NotNull(response.PlanDetails);
Assert.True(response.PlanDetails.Any());
Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.BackupTailLog]);
Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.TailLogBackupFile]);
Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.DataFileFolder]);
Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.LogFileFolder]);
Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.StandbyFile]);
Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.StandbyFile]);
if (executionMode != TaskExecutionModeFlag.None)
{
try
{
request.SessionId = response.SessionId;
restoreDataObject = service.CreateRestoreDatabaseTaskDataObject(request);
Assert.Equal(response.SessionId, restoreDataObject.SessionId);
request.RelocateDbFiles = !restoreDataObject.DbFilesLocationAreValid();
restoreDataObject.Execute((TaskExecutionMode)Enum.Parse(typeof(TaskExecutionMode), executionMode.ToString()));
if (executionMode.HasFlag(TaskExecutionModeFlag.Execute))
{
Assert.True(restoreDataObject.Server.Databases.Contains(targetDatabase));
if (verifyDatabase != null)
{
Assert.True(verifyDatabase(restoreDataObject.Server.Databases[targetDatabase]));
}
//To verify the backupset that are restored, verifying the database is a better options.
//Some tests still verify the number of backup sets that are executed which in some cases can be less than the selected list
if (verifyDatabase == null && selectedBackupSets != null)
{
Assert.Equal(selectedBackupSets.Count(), restoreDataObject.RestorePlanToExecute.RestoreOperations.Count());
}
}
if (executionMode.HasFlag(TaskExecutionModeFlag.Script))
{
Assert.False(string.IsNullOrEmpty(restoreDataObject.ScriptContent));
}
}
catch (Exception ex)
{
if (!shouldFail)
{
Assert.False(true, ex.Message);
}
}
finally
{
await DropDatabase(targetDatabase);
}
}
}
return(response);
}
}
