private void btnRestoreDatabase_Click(object sender, EventArgs e)
{
progressBarBackup.Value = 0;
try
{
DialogResult res = MessageBox.Show("Are you sure you want to restore the database? Lost of data might occur.", "Restore Database", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (res == DialogResult.Yes)
{
Server server = new Server(new ServerConnection(@"HOME-PC\SQLEXPRESS", "sa", "p@ssphr@s3"));
Restore restore = new Restore()
{
Action = RestoreActionType.Database,
Database = "final",
ReplaceDatabase = true,
NoRecovery = false
};
server.KillAllProcesses(restore.Database);
directory = @"D:\Comfama-dbBackup\comfama_dbBackup_" + DateTime.Now.ToShortDateString() + ".bak";
restore.Devices.AddDevice(directory, DeviceType.File);
restore.PercentComplete += restore_PercentComplete;
restore.Complete += restore_Complete;
restore.SqlRestoreAsync(server);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Restore Database");
}
}
public override async Task Restore(DbRestorOptions opt, IProgressBarProvider progressBarProvider,
Action additionalCallbackOnCompleted)
{
await Task.Run(() =>
{
var srv = new Server(opt.SqlServerInstName);
if (srv.Databases.Contains(opt.TargetDbName))
{
srv.KillDatabase(opt.TargetDbName);
}
var res = new Restore();
srv.ConnectionContext.StatementTimeout = 0;
res.Devices.AddDevice(opt.SrcPath, DeviceType.File);
res.Database = opt.TargetDbName;
res.Action = RestoreActionType.Database;
res.PercentCompleteNotification = 1;
res.ReplaceDatabase = true;
res.Complete += (sender, args) =>
{
if (res.AsyncStatus.ExecutionStatus == ExecutionStatus.Failed)
{
progressBarProvider.OnError(args.Error.ToString());
return;
}
progressBarProvider.OnCompleted(FinishedRestore);
additionalCallbackOnCompleted?.Invoke();
};
res.PercentComplete += (sender, args) =>
{
if (res.AsyncStatus.ExecutionStatus == ExecutionStatus.Failed)
{
progressBarProvider.OnError(res.AsyncStatus.LastException.ToString());
}
// give 10% for the recovering which happens after restoring.
const double weightOfRestoring = 90.0 / 100.0;
progressBarProvider.ReportProgress((int)(args.Percent *weightOfRestoring));
};
var fileList = res.ReadFileList(srv);
var dataFile = new RelocateFile(
logicalFileName: fileList.Rows[0][0].ToString(),
physicalFileName: opt.RelocateMdfTo
);
var logFile = new RelocateFile(
logicalFileName: fileList.Rows[1][0].ToString(),
physicalFileName: opt.RelocateLdfTo
);
res.RelocateFiles.Add(dataFile);
res.RelocateFiles.Add(logFile);
res.ContinueAfterError = false;
progressBarProvider.Start(true, "Restoring...");
res.SqlRestoreAsync(srv);
});
}
private void btnRestore_Click(object sender, EventArgs e)
{
if (textBoxOkunanYedek.Text == "")
{
mesaj.Mesaj("Dosya Seçmediniz ", FontAwesome.Sharp.IconChar.ExclamationTriangle, System.Drawing.Color.Yellow);
return;
}
progressBar1.Value = 0;
try
{
//Init connect to sql database
//Microsoft.SqlServer.Management.Smo.Database db = new Microsoft.SqlServer.Management.Smo.Database(dbServer, "deneme");
//db.Drop();
dbServer.KillAllProcesses("KantarDb");
//dbServer = new Server(new ServerConnection("DESKTOP-JRJ4SS2\\SQLEXPRESS", "Elektronet", "123456"));
Restore dbRestore = new Restore()
{
Database = "KantarDb", Action = RestoreActionType.Database, ReplaceDatabase = true, NoRecovery = false
};
dbRestore.Devices.AddDevice(textBoxOkunanYedek.Text, DeviceType.File);
dbRestore.PercentComplete += DbRestore_PercentComplete;
dbRestore.Complete += DbRestore_Complete;
dbRestore.SqlRestoreAsync(dbServer);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
label5.Text = "%0";
labelYedekOku.Text = "";
}
//სარეზერვო ასლის აღდგენა
private void RestoreDB_Click(object sender, EventArgs e)
{
db.Dispose();
//სარეზერვო ასლის პოვნა და არჩევა
OpenFileDialog file = new OpenFileDialog();
file.Title = "აირჩიეთ სარეზერვო ასლი";
//.bak ფაილების გაფილტვრა
file.Filter = "SQL backup files (.bak)|*.bak";
file.InitialDirectory = $@"C:\Program Files (x86)\Microsoft SQL Server\MSSQL12.{ServerName.Text}\MSSQL\Backup";
file.FileName = "";
var result = file.ShowDialog();
if (result == DialogResult.OK)
{
Server DataBase = new Server(new ServerConnection($@".\{ServerName.Text}", "sa", "SaSa111"));
Restore dbRestore = new Restore()
{
Action = RestoreActionType.Database, Database = "Market"
};
//სარეზერვო ასლად არჩეული ფაილის გამოყენება
dbRestore.Devices.AddDevice($"{file.FileName}", DeviceType.File);
dbRestore.PercentComplete += DB_PercentComplete;
dbRestore.SqlRestoreAsync(DataBase);
}
}
private void RestoreDatabase()
{
try
{
var openFileDialog = new OpenFileDialog
{
Title = @"من فضلك قم بإختيار ملف قاعدة البيانات الذي تريد إسترجاعة",
Filter = @"bak files (.bak)|*.bak",
Multiselect = false
};
if (openFileDialog.ShowDialog() != DialogResult.OK)
{
return;
}
ShowOrHideControls(true);
var server = new Server(new ServerConnection(Constants.ServerName));
var restore = new Restore
{
Database = Constants.DatabaseName,
Action = RestoreActionType.Database,
ReplaceDatabase = true,
NoRecovery = false
};
restore.Devices.AddDevice($@"{openFileDialog.FileName}", DeviceType.File);
restore.PercentComplete += PercentComplete;
restore.Complete += Restore_Complete;
restore.SqlRestoreAsync(server);
}
catch
{
Cursor = Cursors.Default;
ShowErrorMsg(Resources.DatabaseRestoreFailes);
}
}
void RestoreData(string filePath)
{
labelStatus.Text = "Đang khôi phục dữ liệu...";
progressBarControl.EditValue = 0;
try
{
Server server = new Server(new ServerConnection(DataProvider.ServerName));
Restore dbRestore = new Restore()
{
Action = RestoreActionType.Database, Database = DataProvider.DatabaseName, ReplaceDatabase = true, NoRecovery = false
};
dbRestore.Devices.AddDevice(filePath, DeviceType.File);
dbRestore.PercentComplete += RestorePercenComplete;
dbRestore.Complete += RestoreComplete;
Database database = new Database(server, DataProvider.DatabaseName);
database.Refresh();
server.KillAllProcesses(DataProvider.DatabaseName);
database.DatabaseOptions.UserAccess = DatabaseUserAccess.Single;
database.Alter(TerminationClause.RollbackTransactionsImmediately);
dbRestore.SqlRestoreAsync(server);
database.DatabaseOptions.UserAccess = DatabaseUserAccess.Multiple;
}
catch (Exception ex)
{
XtraMessageBox.Show("Khôi phục dữ liệu thất bại!", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.Close();
}
}
public void RestoreDataBase(string fileBak)
{
progress_upload.EditValue = 0;
progress_upload.Visibility = BarItemVisibility.Always;
bar_status_download.Visibility = BarItemVisibility.Always;
btn_restore.Enabled = false;
try
{
string strConnection = $"Server={ConfigDatabase.IP_SERVER_LOCAL};Database={ConfigDatabase.DATABASE};Trusted_Connection=True;";
var conn = new SqlConnection(strConnection);
//Server dbServer = new Server(new ServerConnection(serverLocal, configDatabase.USER_NAME_DB, configDatabase.PASSWORD_DB));
Server dbServer = new Server(new ServerConnection(conn));
// Kill all processes
Restore dbRestore = new Restore {
Database = ConfigDatabase.DATABASE, Action = RestoreActionType.Database, ReplaceDatabase = true, NoRecovery = false
};
dbServer.KillAllProcesses(dbRestore.Database);
// Set single-user mode
Database db = dbServer.Databases[dbRestore.Database];
db.DatabaseOptions.UserAccess = DatabaseUserAccess.Single;
db.Alter(TerminationClause.RollbackTransactionsImmediately);
dbRestore.Devices.AddDevice(fileBak, DeviceType.File);
dbRestore.PercentCompleteNotification = 1;
dbRestore.PercentComplete += DbRestore_PercentComplete;
dbRestore.Complete += DbRestore_Complete;
dbRestore.SqlRestoreAsync(dbServer);
}
catch (Exception ex)
{
alertControl1.Show(this, "Thông báo", $"Error: => {ex.Message}");
}
}
private void btn_restore_Click(object sender, EventArgs e)
{
try
{
btn_restore.Enabled = false;
CloseAllConnection();
string SelectedBk = dg_backups.SelectedRows[0].Cells[0].Value.ToString().Trim();
string BackupdataBasePath = "your Backup Path";
Server dbServer = new Server(new ServerConnection("Server name",
"User name", "Password"));
Restore _Restore = new Restore()
{
Database = "Database name to be restored",
Action = RestoreActionType.Database,
ReplaceDatabase = true,
NoRecovery = false
};
_Restore.Devices.AddDevice(BackupdataBasePath, DeviceType.File);
_Restore.PercentComplete += DB_Restore_PersentComplete;
_Restore.Complete += DB_Restore_Complete;
_Restore.SqlRestoreAsync(dbServer);
}
catch (Exception ex)
{
btn_restore.Enabled = true;
MessageBox.Show(ex.Message);
}
}
private void RestoreDatabaseLog(Server myServer)
{
Restore restoreDBLog = new Restore();
restoreDBLog.Action = RestoreActionType.Log;
restoreDBLog.Devices.AddDevice($"{bteFile.Text}", DeviceType.File);
DataTable dataTable = restoreDBLog.ReadBackupHeader(myServer);
if (dataTable.Rows.Count > 0)
{
restoreDBLog.Database = dataTable.Rows[0]["DatabaseName"].ToString();
}
/* You can specify NoRecovery = false (default) so that transactions are
* rolled forward and recovered. */
restoreDBLog.NoRecovery = true;
/* Wiring up events for progress monitoring */
restoreDBLog.PercentComplete += PercentComplete;
restoreDBLog.Complete += (sender, e) => Completed(sender, e, "Restore");
/* SqlRestore method starts to restore database
* You cab also use SqlRestoreAsync method to perform restore
* operation asynchronously */
restoreDBLog.SqlRestoreAsync(myServer);
}
private void restoreButton_Click(object sender, EventArgs e)
{
if (this.restoreLocationTB.Text == string.Empty)
{
c.ErrorBox("Please select restore file", "Error");
return;
}
string database = this.comboBox1.SelectedItem.ToString().Replace(" ", String.Empty);
try
{
//Server dbServer = new Server(new ServerConnection(Properties.Settings.Default.LastIP + ", 1433", "sa", "Kdvghr2810@"));
Server dbServer = new Server(new ServerConnection(new SqlConnection(Global.getconnectionstring(database))));
Backup dbBackup = new Backup()
{
Action = BackupActionType.Database, Database = database
};
string s = this.restoreLocationTB.Text;
string backup_location = s.Substring(0, s.Length - 4) + "(" + DateTime.Now.ToString().Replace(":", "-").Replace('/', '-') + ")" + "restorebackup.bak";
dbBackup.Devices.AddDevice(backup_location, DeviceType.File);
dbBackup.Initialize = true;
dbBackup.PercentComplete += DbRestore_PercentComplete;
dbBackup.Complete += DbRestore_Complete;
dbBackup.SqlBackup(dbServer);
}
catch (Exception ex)
{
c.ErrorBox(ex.Message, "Error");
}
progressBar2.Value = 0;
try
{
//Server dbServer = new Server(new ServerConnection(Properties.Settings.Default.LastIP +", 1433", "sa", "Kdvghr2810@"));
Server dbServer = new Server(new ServerConnection(new SqlConnection(Global.getconnectionstring(database))));
Database db = dbServer.Databases[database];
dbServer.KillAllProcesses(db.Name);
db.DatabaseOptions.UserAccess = DatabaseUserAccess.Multiple;
db.Alter(TerminationClause.RollbackTransactionsImmediately);
Restore dbRestore = new Restore()
{
Database = database, Action = RestoreActionType.Database, ReplaceDatabase = true, NoRecovery = false
};
dbRestore.Devices.AddDevice(this.restoreLocationTB.Text, DeviceType.File);
dbRestore.PercentComplete += DbRestore_PercentComplete;
dbRestore.Complete += DbRestore_Complete;
dbRestore.SqlRestoreAsync(dbServer);
}
catch (Exception ex)
{
c.ErrorBox(ex.Message, "Error");
}
}
private void RestoreBackup()
{
ProgressBarDBRestore.Value = 0;
try
{
Server dbServer = new Server(new ServerConnection(_servername, _username, _password));
Restore dbRestore = new Restore()
{
Database = _database, Action = RestoreActionType.Database, ReplaceDatabase = true, NoRecovery = false
};
dbRestore.Devices.AddDevice(TextBoxDBRestore.Text, DeviceType.File);
dbRestore.PercentComplete += DbRestore_PercentComplete;
dbRestore.Complete += DbRestore_Complete;
dbRestore.SqlRestoreAsync(dbServer);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void btnRestore_Click(object sender, EventArgs e)
{
progressBar.Value = 0;
try
{
Server dbserver = new Server(new ServerConnection(txtServer.Text));
Restore dbrestore = new Restore()
{
Database = txtDB.Text, Action = RestoreActionType.Database, ReplaceDatabase = true, NoRecovery = false
};
dbrestore.Devices.AddDevice(@"C:\Data\LTUDQL1.txt", DeviceType.File);
dbrestore.Complete += Dbrestore_Complete;
dbrestore.PercentComplete += Dbrestore_PercentComplete;
dbrestore.SqlRestoreAsync(dbserver);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void btnRestore_Click(object sender, EventArgs e)
{
progressBar1.Value = 0;
try
{
Server dbServer = new Server(new ServerConnection(txtServer.Text, txtUsername.Text, txtPassword.Text));
Restore dbRestore = new Restore()
{
Database = txtDatabase.Text, Action = RestoreActionType.Database, ReplaceDatabase = true, NoRecovery = false
};
dbRestore.Devices.AddDevice(@"C:\Data\RetailShopDB.bak", DeviceType.File);
// dbRestore.Initialize = true;
dbRestore.PercentComplete += DbRestore_PercentComplete;
dbRestore.Complete += DbRestore_Complete;
dbRestore.SqlRestoreAsync(dbServer);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void RestoreDatabaseWithDifferentNameAndLocation(Server myServer)
{
Restore restoreDB = new Restore();
/* Specify whether you want to restore database or files or log etc */
restoreDB.Action = RestoreActionType.Database;
restoreDB.Devices.AddDevice($"{bteFile.Text}", DeviceType.File);
DataTable dataTable = restoreDB.ReadBackupHeader(myServer);
if (dataTable.Rows.Count > 0)
{
restoreDB.Database = dataTable.Rows[0]["DatabaseName"].ToString() + "New";
}
/* You can specify ReplaceDatabase = false (default) to not create a new image
* of the database, the specified database must exist on SQL Server instance.
* You can specify ReplaceDatabase = true to create new database image
* regardless of the existence of specified database with same name */
restoreDB.ReplaceDatabase = true;
/* If you have differential or log restore to be followed, you would need
* to specify NoRecovery = true, this will ensure no recovery is done after the
* restore and subsequent restores are allowed. It means it will database
* in the Restoring state. */
restoreDB.NoRecovery = false;
/* RelocateFiles collection allows you to specify the logical file names and
* physical file names (new locations) if you want to restore to a different location.*/
restoreDB.RelocateFiles.Add(new RelocateFile($"{ lokDB.Text}_Data", $@"{btePath.Text}\{ lokDB.Text}New_Data.mdf"));
restoreDB.RelocateFiles.Add(new RelocateFile($"{ lokDB.Text}_Log", $@"{btePath.Text}\{ lokDB.Text}New_Log.ldf"));
/* Wiring up events for progress monitoring */
restoreDB.PercentComplete += PercentComplete;
restoreDB.Complete += (sender, e) => Completed(sender, e, "Restore");
/* SqlRestore method starts to restore database
* You cab also use SqlRestoreAsync method to perform restore
* operation asynchronously */
restoreDB.SqlRestoreAsync(myServer);
}
private void lnkBackup_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(txtBackupLocation.Text))
{
lblError.Text = @"Select a location path first";
}
else
{
Cursor.Current = Cursors.WaitCursor;
progressBar.Value = 0;
lblError.Text = string.Empty;
var result = MetroMessageBox.Show(this, "Are you sure you want to restore this database?", "Database restore",
MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (result == DialogResult.No)
{
return;
}
try
{
var dbServer = new Server(new ServerConnection(Properties.Settings.Default.Server, Properties.Settings.Default.Username, Properties.Settings.Default.Password));
var dbRestore = new Restore()
{
Database = Properties.Settings.Default.Database,
Action = RestoreActionType.Database,
ReplaceDatabase = true,
NoRecovery = false
};
dbRestore.Devices.AddDevice(txtBackupLocation.Text, DeviceType.File);
dbRestore.PercentComplete += DbRestore_PercentComplete;
dbRestore.Complete += DbRestore_Complete;
dbRestore.SqlRestoreAsync(dbServer);
}
catch (Exception ex)
{
MetroMessageBox.Show(this, ex.Message, "Error restoring database", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
Cursor.Current = Cursors.Default;
}
}
private void RestoreDatabaseWithDifferentNameAndLocation(Server myServer)
{
Restore restoreDB = new Restore();
restoreDB.Action = RestoreActionType.Database;
restoreDB.Devices.AddDevice($"{bteFile.Text}", DeviceType.File);
DataTable dataTable = restoreDB.ReadBackupHeader(myServer);
if (dataTable.Rows.Count > 0)
{
restoreDB.Database = dataTable.Rows[0]["DatabaseName"].ToString() + "New";
}
restoreDB.ReplaceDatabase = true;
restoreDB.NoRecovery = false;
restoreDB.RelocateFiles.Add(new RelocateFile($"{ lokDatabase.Text}_Data", $@"{btePath.Text}\{ lokDatabase.Text}New_Data.mdf"));
restoreDB.RelocateFiles.Add(new RelocateFile($"{ lokDatabase.Text}_Log", $@"{btePath.Text}\{ lokDatabase.Text}New_Log.ldf"));
restoreDB.PercentComplete += PercentComplete;
restoreDB.Complete += (sender, e) => Completed(sender, e, "Restore");
restoreDB.SqlRestoreAsync(myServer);
restoreDB.Wait();
}
internal void RestoreDb()
{
Progress = 0;
Visible = Visibility.Visible;
var res = new Restore();
try
{
res.Database = SelectedDb;
res.Action = RestoreActionType.Database;
res.Devices.AddDevice(AttachDbFilename, DeviceType.File);
// res.ReadFileList(srv);
res.PercentCompleteNotification = 5;
res.ReplaceDatabase = true;
res.PercentComplete += (s, e) => Progress = e.Percent;
res.SqlRestoreAsync(Srv);
res.Complete += (s, e) =>
{
Visible = Visibility.Hidden;
MessageBox.Show("Restore of " + AttachDbFilename + " Complete!", "Restore", MessageBoxButton.OK, MessageBoxImage.Information);
};
//Task.Factory.StartNew(() => res.SqlRestore(Srv)).ContinueWith(
// t =>
// {
// MessageBox.Show("Restore of " + AttachDbFilename + " Complete!", "Restore", MessageBoxButton.OK, MessageBoxImage.Information);
// Visible = Visibility.Hidden;
// });
}
catch (SmoException exSMO)
{
MessageBox.Show(exSMO.ToString());
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
private void ExecuteTransactions()
{
try
{
var restore_name = _targetDatabase.Name;
Restore restore = new Restore();
var trFile = _transactions[0];
var backupDeviceItem = new BackupDeviceItem(trFile, DeviceType.File);
restore.Devices.Add(backupDeviceItem);
restore.Database = restore_name;
restore.ToPointInTime = _time.ToString("yyyy-MM-ddTHH:mm:ss");
restore.ReplaceDatabase = false;
restore.Action = RestoreActionType.Log;
Logger.Info("Log file left: " + _transactions.Count);
restore.PercentComplete += Restore_PercentComplete;
restore.SqlRestoreAsync(_smoServer);
restore.Information += Restore_Information;
restore.Wait();
Transaction_Complete();
}
catch (SmoException ex)
{
Logger.Error("SMO Message : " + ex.Message);
Logger.Error("SMO Exception : " + ex.InnerException);
}
catch (IOException ex)
{
Logger.Error("IO Message : " + ex.Message);
Logger.Error("IO Exception : " + ex.InnerException);
}
catch (Exception ex)
{
Logger.Error("Message : " + ex.Message);
Logger.Error("Exception : " + ex.InnerException);
}
}
private void RestoreDatabaseDifferential(Server myServer)
{
Restore restoreDB = new Restore();
restoreDB.Action = RestoreActionType.Database;
restoreDB.Devices.AddDevice($"{bteFile.Text}", DeviceType.File);
DataTable dataTable = restoreDB.ReadBackupHeader(myServer);
if (dataTable.Rows.Count > 0)
{
restoreDB.Database = dataTable.Rows[0]["DatabaseName"].ToString();
}
Database db = myServer.Databases[restoreDB.Database];
if (db != null)
{
db.DatabaseOptions.UserAccess = DatabaseUserAccess.Single;
db.Alter(TerminationClause.RollbackTransactionsImmediately);
db.Refresh();
}
restoreDB.ReplaceDatabase = true;
restoreDB.NoRecovery = true;
restoreDB.PercentComplete += PercentComplete;
restoreDB.Complete += (sender, e) => Completed(sender, e, "Restore");
restoreDB.SqlRestoreAsync(myServer);
restoreDB.Wait();
if (db != null)
{
db.DatabaseOptions.UserAccess = DatabaseUserAccess.Multiple;
db.Alter(TerminationClause.RollbackTransactionsImmediately);
db.Refresh();
}
}
public void Restore(DatabaseRestoreRequest request, PercentCompleteEventHandler percentCompleteDelegate)
{
var server = new Server(request.TargetInstance);
Database database = server.Databases[request.TargetDatabase];
// Start by locking down the database
database.DatabaseOptions.UserAccess = DatabaseUserAccess.Single;
database.Alter(TerminationClause.RollbackTransactionsImmediately);
var restoreDb = new Restore { Database = database.Name, Action = RestoreActionType.Database };
//Specify whether you want to restore database or files or log etc
restoreDb.Devices.AddDevice(request.FullBackupFile, DeviceType.File);
// For now we only support database replacement.
restoreDb.ReplaceDatabase = true;
// For full backup no recovery is not usefull. Will need to to change this if support for restoring transactional backup file happens.
restoreDb.NoRecovery = false;
// Associate the correct physical path for each file to be restored
foreach (FileToRestore fileToRestore in request.FilesLists)
{
restoreDb.RelocateFiles.Add(new RelocateFile(fileToRestore.BackupLogicalName,
fileToRestore.TargetPhysicalPath));
}
if (percentCompleteDelegate != null)
{
restoreDb.PercentComplete += percentCompleteDelegate;
}
// Magic!
restoreDb.SqlRestore(server);
restoreDb.SqlRestoreAsync(server);
// After the restore, ensure the recovery model is set to simple.
// Since we only support DEV/TEST/DEMO, we dont want the overhead of the other recovery models.
database.RecoveryModel = RecoveryModel.Simple;
database.Alter();
string sqlConnectionString = string.Format("Integrated Security=SSPI;Persist Security Info=True;Initial Catalog={1};Data Source={0}", server.Name, database.Name);
foreach (var script in request.ScriptsToExecute)
{
var fileInfo = new FileInfo(script);
string sql;
using (var text = fileInfo.OpenText())
{
sql = text.ReadToEnd();
text.Close();
}
SqlConnection connection = new SqlConnection(sqlConnectionString);
Server srv = new Server(new ServerConnection(connection));
srv.ConnectionContext.SqlExecutionModes = SqlExecutionModes.ExecuteAndCaptureSql;
srv.ConnectionContext.ExecuteNonQuery(sql);
}
}
public Task<string> RestoreAsync(DatabaseRestoreRequest request, PercentCompleteEventHandler percentCompleteDelegate)
{
var server = new Server(request.TargetInstance);
Database database = server.Databases[request.TargetDatabase];
// Start by locking down the database
database.DatabaseOptions.UserAccess = DatabaseUserAccess.Single;
database.Alter(TerminationClause.RollbackTransactionsImmediately);
var restoreDb = new Restore { Database = database.Name, Action = RestoreActionType.Database };
//Specify whether you want to restore database or files or log etc
restoreDb.Devices.AddDevice(request.FullBackupFile, DeviceType.File);
// For now we only support database replacement.
restoreDb.ReplaceDatabase = true;
// For full backup no recovery is not usefull. Will need to to change this if support for restoring transactional backup file happens.
restoreDb.NoRecovery = false;
// Associate the correct physical path for each file to be restored
foreach (FileToRestore fileToRestore in request.FilesLists)
{
restoreDb.RelocateFiles.Add(new RelocateFile(fileToRestore.BackupLogicalName,
fileToRestore.TargetPhysicalPath));
}
if (percentCompleteDelegate != null)
{
restoreDb.PercentComplete += percentCompleteDelegate;
}
var tcs = new TaskCompletionSource<string>();
//Handle the Complete event with a TaskCompletionSource that way when can control when the task is completed.
restoreDb.Complete += (sender, e) => RestoreWasCompleted(tcs, e, request, database, server);
try
{
// Start asynchrounos restore. That way the ThreadPool is not blocked,
restoreDb.SqlRestoreAsync(server);
}
catch (Exception ex)
{
// An exception occured. notify the task
tcs.TrySetException(ex);
}
return tcs.Task;
}
private void RestoreBackup(string path, string restore_name, RestoreOption restoreOption)
{
try
{
_restoreOption = restoreOption;
InitConnexion();
if (!_smoServer.Databases.Contains(restore_name))
{
var database = new Database(_smoServer, restore_name);
database.Create();
}
Logger.Success("SQL connected");
_targetDatabase = _smoServer.Databases[restore_name];
_targetDatabase.RecoveryModel = RecoveryModel.Simple;
_targetDatabase.Alter(TerminationClause.RollbackTransactionsImmediately);
Restore restore = new Restore();
var backupDeviceItem = new BackupDeviceItem(path, DeviceType.File);
restore.Devices.Add(backupDeviceItem);
restore.Database = restore_name;
restore.ReplaceDatabase = true;
restore.NoRecovery = false;
if (_mode == RestoreMode.AtTime)
{
restore.NoRecovery = true;
}
var fileList = restore.ReadFileList(_smoServer);
var dataFile = new RelocateFile();
dataFile.LogicalFileName = fileList.Rows[0][0].ToString();
dataFile.PhysicalFileName = _smoServer.Databases[restore_name].FileGroups[0].Files[0].FileName;
var logFile = new RelocateFile();
logFile.LogicalFileName = fileList.Rows[1][0].ToString();
logFile.PhysicalFileName = _smoServer.Databases[restore_name].LogFiles[0].FileName;
restore.RelocateFiles.Add(dataFile);
restore.RelocateFiles.Add(logFile);
_smoServer.KillAllProcesses(restore_name);
restore.PercentComplete += Restore_PercentComplete;
restore.SqlRestoreAsync(_smoServer);
restore.Information += Restore_Information;
restore.Wait();
Restore_Complete();
}
catch (SmoException ex)
{
Logger.Error("SMO Message : " + ex.Message);
Logger.Error("SMO Exception : " + ex.InnerException);
}
catch (IOException ex)
{
Logger.Error("IO Message : " + ex.Message);
Logger.Error("IO Exception : " + ex.InnerException);
}
catch (Exception ex)
{
Logger.Error("Message : " + ex.Message);
Logger.Error("Exception : " + ex.InnerException);
}
}
private void Restore(string databaseName,string backupPath,string dbLogicalName,string dbRelocatePath,
string logLogicalName,string logRelocatePath)
{
Restore restore = new Restore
{
Database = databaseName,
PercentCompleteNotification = 10,
NoRecovery = _diffBackupPending,
ReplaceDatabase = true,
ContinueAfterError = true
};
if (dbRelocatePath != null)
{
RelocateFile rf = new RelocateFile();
rf.LogicalFileName = dbLogicalName;
rf.PhysicalFileName = dbRelocatePath;
restore.RelocateFiles.Add(rf);
RelocateFile rfl = new RelocateFile();
rfl.LogicalFileName = logLogicalName;
rfl.PhysicalFileName = logRelocatePath;
restore.RelocateFiles.Add(rfl);
}
restore.PercentComplete += restore_PercentComplete;
restore.Complete += restore_Complete;
restore.Devices.AddDevice(backupPath, DeviceType.File);
restore.SqlRestoreAsync(_server);
}
