public void RestoreDatabase(String databaseName, String filePath, String serverName, String userName, String password, String dataFilePath, String logFilePath)
{
try
{
Restore sqlRestore = new Restore();
BackupDeviceItem deviceItem = new BackupDeviceItem(filePath, DeviceType.File);
sqlRestore.Devices.Add(deviceItem);
sqlRestore.Database = databaseName;
ServerConnection connection = new ServerConnection(serverName, userName, password);
Server sqlServer = new Server(connection);
Database db = sqlServer.Databases[databaseName];
sqlRestore.Action = RestoreActionType.Database;
String dataFileLocation = dataFilePath + databaseName + ".mdf";
String logFileLocation = logFilePath + databaseName + "_Log.ldf";
db = sqlServer.Databases[databaseName];
RelocateFile rf = new RelocateFile(databaseName, dataFileLocation);
sqlRestore.RelocateFiles.Add(new RelocateFile(databaseName, dataFileLocation));
sqlRestore.RelocateFiles.Add(new RelocateFile(databaseName + "_log", logFileLocation));
sqlRestore.ReplaceDatabase = true;
sqlRestore.Complete += new ServerMessageEventHandler(sqlRestore_Complete);
sqlRestore.PercentCompleteNotification = 10;
sqlRestore.PercentComplete += new PercentCompleteEventHandler(sqlRestore_PercentComplete);
sqlRestore.SqlRestore(sqlServer);
db = sqlServer.Databases[databaseName];
db.SetOnline();
sqlServer.Refresh();
}
catch (SqlServerManagementException ex)
{
ex.Message.ToString();
}
}
public static void MakeRestore(ServerMessageEventHandler onComplete, Guid id,
string serverName, string dbName, string uncDir, string userName, string password)
{
var sc = new ServerConnection(serverName);
sc.LoginSecure = false;
sc.Login = userName;
sc.Password = password;
var srv = new Server(sc);
var rest = new Restore();
rest.Action = RestoreActionType.Database;
rest.Database = dbName;
rest.Devices.AddDevice(Path.Combine(uncDir, rest.Database + ".bak"), DeviceType.File);
rest.ReplaceDatabase = true;
var headers = rest.ReadBackupHeader(srv);
var query = from DataRow row in headers.Rows
where (string)row["BackupName"] == id.ToString()
select (Int16)row["Position"];
rest.FileNumber = query.First();
if (onComplete != null) rest.Complete += onComplete;
rest.SqlRestore(srv);
}
public SqlServerBackup(string backupPath,Server server)
{
Restore restore=new Restore();
restore.Devices.AddDevice(backupPath,DeviceType.File);
DataTable dt= restore.ReadBackupHeader(server);
if(dt.Rows.Count==1)
{
/*
DataRow row = dt.Rows[0];
BackupName = row[""].ToString();
BackupDescription = row[""].ToString();
Compressed = row[""].ToString();
BackupTypeDescription = row[""].ToString();
DifferentialBaseLSN = row[""].ToString();
DifferentialBaseGUID = row[""].ToString();
BackupSetGUID = row[""].ToString();
ServerName = row[""].ToString();
DatabaseName = row[""].ToString();
DatabaseVersion = row[""].ToString();
BackupStartDate = row[""].ToString();
BackupFinishDate = row[""].ToString();
MachineName = row[""].ToString();
CompatibilityLevel = row[""].ToString();
DatabaseVersion = row[""].ToString();
DatabaseVersion = row[""].ToString();
DatabaseVersion = row[""].ToString();
*/
}
}
protected override void ExecuteTask()
{
var server = new Server(ServerName);
server.ConnectionContext.LoginSecure = true;
server.ConnectionContext.Connect();
if (!ReplaceDB)
{
if (server.Databases.Contains(DBName))
{
Log(Level.Info, DBName + " exists on " + ServerName + " and will not be replaced");
return;
}
}
Log(Level.Info, "Restoring database " + DBName + " to " + ServerName);
var restore = new Restore();
restore.Database = DBName;
restore.ReplaceDatabase = ReplaceDB;
restore.Action = RestoreActionType.Database;
restore.Devices.AddDevice(BackupPath, DeviceType.File);
var table = restore.ReadFileList(server);
restore.RelocateFiles.Add(new RelocateFile(table.Rows[0][0].ToString(), Path.Combine(server.Settings.DefaultFile, DBName + ".mdf")));
restore.RelocateFiles.Add(new RelocateFile(table.Rows[1][0].ToString(), Path.Combine(server.Settings.DefaultFile, DBName + "_Log.ldf")));
restore.PercentComplete += UpdatePercent;
restore.Complete += RestoreCompleted;
restore.SqlRestore(server);
if (server.ConnectionContext.IsOpen)
server.ConnectionContext.Disconnect();
}
public void RestoreDatabase(SqlConnectionStringBuilder sqlConnection, String backUpFile)
{
ServerConnection serverConnection = null;
try
{
if (!FileManager.FileExists(backUpFile))
{
throw new FileNotFoundException();
}
serverConnection = new ServerConnection(sqlConnection.DataSource, sqlConnection.UserID, sqlConnection.Password);
Server sqlServer = new Server(serverConnection);
Restore restoreDatabase = new Restore()
{
Action = RestoreActionType.Database,
Database = sqlConnection.InitialCatalog,
};
BackupDeviceItem backupItem = new BackupDeviceItem(backUpFile, DeviceType.File);
restoreDatabase.Devices.Add(backupItem);
restoreDatabase.ReplaceDatabase = true;
restoreDatabase.SqlRestore(sqlServer);
}
finally
{
if (serverConnection != null && serverConnection.IsOpen)
{
serverConnection.Disconnect();
}
}
}
public static void RestoreDatabase(string databaseName, string backupName, string serverName = Server) {
Server server = string.IsNullOrEmpty(serverName) ? new Server() : new Server(serverName);
var restore = new Restore {
Database = databaseName,
Action = RestoreActionType.Database,
ReplaceDatabase = true,
NoRecovery = false
};
restore.Devices.AddDevice(backupName + ".bak", DeviceType.File);
server.KillAllProcesses(databaseName);
restore.SqlRestore(server);
}
/// <summary>
/// Initializes a new restore instance
/// </summary>
/// <param name="archive">
/// The SkyFloe archive for the restore
/// </param>
/// <param name="session">
/// The restore session being processed
/// </param>
public GlacierRestore(GlacierArchive archive, Restore.Session session)
{
this.archive = archive;
if (session.State == SkyFloe.Restore.SessionState.Pending)
ScheduleRetrievals(session);
this.downloader = new GlacierDownloader(
this.archive.Glacier,
this.archive.Vault
);
this.retrievalLimiter = new IO.RateLimiter(
Math.Min(session.RateLimit, MaxRetrievalRate)
);
}
static void Main(string[] args)
{
if (args.Length != 3)
return;
string serverName = args[0];
string databaseName = args[1];
string restoreFilePath = args[2];
Restore restoreDB = new Restore();
restoreDB.Database = databaseName;
restoreDB.Action = RestoreActionType.Database;
restoreDB.Devices.AddDevice(@restoreFilePath, DeviceType.File);
restoreDB.ReplaceDatabase = true;
/* If you have a differential or log restore after the current restore,
* you would need to specify NoRecovery = true, this will ensure no
* recovery performed and subsequent restores are allowed. It means it
* the database will be in a restoring state. */
restoreDB.NoRecovery = false;
restoreDB.PercentComplete += (obj, e) => { Console.WriteLine("Percent completed: {0}%.", e.Percent); };
Server srv = new Server(@serverName);
/* Check if database exists, if not, create one. */
Database db = srv.Databases[databaseName];
if (db == null)
{
db = new Database(srv,databaseName);
Console.WriteLine("Creating database...");
db.Create();
Console.WriteLine("Created {0}.", databaseName);
}
Console.WriteLine("Verifying backup media...");
bool valid = restoreDB.SqlVerify(srv);
if (valid)
{
Console.WriteLine("Backup media is valid.");
Console.WriteLine("Starting restore...");
restoreDB.SqlRestore(srv);
}
else
{
Console.WriteLine("Backup media is invalid. Aborting operation...");
}
}
/// <summary>
/// Restore DB from backup.
/// </summary>
private static bool RestoreDB()
{
string connectionString =
ConfigurationManager.ConnectionStrings["DeathsConnectionString"].ToString();
var builder = new SqlConnectionStringBuilder(connectionString);
var myServer = new Server(builder.DataSource);
var res = new Restore();
res.Database = "Deaths";
res.Action = RestoreActionType.Database;
res.Devices.AddDevice(
Environment.CurrentDirectory + @"\Resources\DeathsFullBackup", DeviceType.File);
res.ReplaceDatabase = true;
res.SqlRestore(myServer);
return true;
}
public void Restore(BackupParameters parameters)
{
var databaseName = parameters.DatabaseName;
var filePath = GetFullPathFrom(parameters.FilePath);
Logger.WriteLine("Restoring {0} from file {1}", databaseName, filePath);
var server = new Server(parameters.Server);
try
{
server.ConnectionContext.LoginSecure = true;
server.ConnectionContext.Connect();
var restore = new Restore { Database = databaseName, Action = RestoreActionType.Database };
restore.Devices.AddDevice(filePath, DeviceType.File);
restore.ReplaceDatabase = true;
var database = server.Databases[databaseName];
if (database == null)
{
Logger.WriteLine("Database {0} does not exist", databaseName);
return;
}
var users = server.GetLoginUsers(database);
Logger.WriteLine("User mappings to restore: {0}", string.Join(",", users));
RelocateFiles(database, restore);
server.RenewConnection();
restore.PercentComplete += HandlePercentComplete;
restore.Complete += HandleComplete;
restore.SqlRestore(server);
RestoreUserMappings(server, users, databaseName);
}
finally
{
if (server.ConnectionContext.IsOpen)
{
Logger.Write("Closing connection...");
server.ConnectionContext.Disconnect();
Logger.WriteLine("OK");
}
}
}
private void RelocateDataFiles(Database database, Restore restore)
{
for (var ii = 0; ii < database.FileGroups.Count; ii++)
{
var group = database.FileGroups[ii];
Logger.WriteLine("Group: " + @group.Name);
for (var jj = 0; jj < @group.Files.Count; jj++)
{
var file = @group.Files[jj];
Logger.WriteLine("Name: {0}", file.Name);
Logger.WriteLine("IsPrimary: {0}", file.IsPrimaryFile);
Logger.WriteLine("FileName: {0}", file.FileName);
if (file.IsPrimaryFile)
{
var physicalFilename = string.Format("{0}.mdf", database.Name);
var physicalPath = Path.Combine(Settings.DataDirectory, physicalFilename);
restore.RelocateFiles.Add(new RelocateFile(file.Name, physicalPath));
Logger.WriteLine("Relocating data file [" + file.Name + "] to " + physicalPath);
}
}
}
}
public BackupInfo GetBackupInfo(string backupFileName, Server server)
{
var restoreDb = new Restore();
var info = new BackupInfo();
restoreDb.Action = RestoreActionType.Database;
restoreDb.Devices.AddDevice(backupFileName, DeviceType.File);
DataTable fileList = restoreDb.ReadFileList(server);
foreach (DataRow row in fileList.Rows)
{
if (row.Field<string>("Type").Equals("D"))
{
info.DataLogicalName = row.Field<string>("LogicalName");
}
else if (row.Field<string>("Type").Equals("L"))
{
info.LogFiles.Add(new DatabaseFile {LogicalName = row.Field<string>("LogicalName")});
}
}
return info;
}
public static void RestoreDatabase(this Server server, string databaseName, string filePath)
{
var res = new Restore();
res.Devices.AddDevice(filePath, DeviceType.File);
var DataFile = new RelocateFile();
string MDF = res.ReadFileList(server).Rows[0][1].ToString();
DataFile.LogicalFileName = res.ReadFileList(server).Rows[0][0].ToString();
DataFile.PhysicalFileName = server.Databases[databaseName].FileGroups[0].Files[0].FileName;
var LogFile = new RelocateFile();
string LDF = res.ReadFileList(server).Rows[1][1].ToString();
LogFile.LogicalFileName = res.ReadFileList(server).Rows[1][0].ToString();
LogFile.PhysicalFileName = server.Databases[databaseName].LogFiles[0].FileName;
res.RelocateFiles.Add(DataFile);
res.RelocateFiles.Add(LogFile);
res.Database = databaseName;
res.NoRecovery = false;
res.ReplaceDatabase = true;
res.SqlRestore(server);
}
public static void Main()
{
// Connect to the local, default instance of SQL Server.
Server srv = new Server("DESKTOP-EPNEITS");
// Reference the AdventureWorks2012 database.
Database db = default(Database);
db = srv.Databases["Rating"];
// Store the current recovery model in a variable.
int recoverymod;
recoverymod = (int)db.DatabaseOptions.RecoveryModel;
// Define a Backup object variable.
Backup bk = new Backup();
// Specify the type of backup, the description, the name, and the database to be backed up.
bk.Action = BackupActionType.Database;
bk.BackupSetDescription = "Full backup of Rating";
bk.BackupSetName = "Rating " + DateTime.Now.ToString("yyyy-MM-dd") + " Backup";
bk.Database = "Rating";
// Declare a BackupDeviceItem by supplying the backup device file name in the constructor, and the type of device is a file.
BackupDeviceItem bdi = default(BackupDeviceItem);
bdi = new BackupDeviceItem("Full_Backup1", DeviceType.File);
// Add the device to the Backup object.
bk.Devices.Add(bdi);
// Set the Incremental property to False to specify that this is a full database backup.
bk.Incremental = false;
// Set the expiration date.
System.DateTime backupdate = new System.DateTime();
backupdate = new System.DateTime(2018, 10, 5);
bk.ExpirationDate = backupdate;
// Specify that the log must be truncated after the backup is complete.
bk.LogTruncation = BackupTruncateLogType.Truncate;
// Run SqlBackup to perform the full database backup on the instance of SQL Server.
bk.SqlBackup(srv);
// Inform the user that the backup has been completed.
System.Console.WriteLine("Full Backup complete.");
// Remove the backup device from the Backup object.
bk.Devices.Remove(bdi);
// Make a change to the database, in this case, add a table called test_table.
Table t = default(Table);
t = new Table(db, "test_table");
Column c = default(Column);
c = new Column(t, "col", DataType.Int);
t.Columns.Add(c);
t.Create();
// Create another file device for the differential backup and add the Backup object.
BackupDeviceItem bdid = default(BackupDeviceItem);
bdid = new BackupDeviceItem("Test_Differential_Backup1", DeviceType.File);
// Add the device to the Backup object.
bk.Devices.Add(bdid);
// Set the Incremental property to True for a differential backup.
bk.Incremental = true;
// Run SqlBackup to perform the incremental database backup on the instance of SQL Server.
bk.SqlBackup(srv);
// Inform the user that the differential backup is complete.
System.Console.WriteLine("Differential Backup complete.");
// Remove the device from the Backup object.
bk.Devices.Remove(bdid);
// Delete the AdventureWorks2012 database before restoring it
// db.Drop();
// Define a Restore object variable.
Restore rs = new Restore();
// Set the NoRecovery property to true, so the transactions are not recovered.
rs.NoRecovery = true;
// Add the device that contains the full database backup to the Restore object.
rs.Devices.Add(bdi);
// Specify the database name.
rs.Database = "Rating";
// Restore the full database backup with no recovery.
rs.SqlRestore(srv);
// reacquire a reference to the database
db = srv.Databases["Rating"];
// Remove the device from the Restore object.
rs.Devices.Remove(bdi);
// Set the NoRecovery property to False.
rs.NoRecovery = false;
// Add the device that contains the differential backup to the Restore object.
rs.Devices.Add(bdid);
// Restore the differential database backup with recovery.
rs.SqlRestore(srv);
// Inform the user that the differential database restore is complete.
System.Console.WriteLine("Differential Database Restore complete.");
// Remove the device.
rs.Devices.Remove(bdid);
// Set the database recovery mode back to its original value.
db.RecoveryModel = (RecoveryModel)recoverymod;
// Drop the table that was added.
db.Tables["test_table"].Drop();
db.Alter();
//// Remove the backup files from the hard disk.
//// This location is dependent on the installation of SQL Server
//System.IO.File.Delete("C:\\Program Files\\Microsoft SQL Server\\MSSQL12.MSSQLSERVER\\MSSQL\\Backup\\Test_Full_Backup1");
//System.IO.File.Delete("C:\\Program Files\\Microsoft SQL Server\\MSSQL12.MSSQLSERVER\\MSSQL\\Backup\\Test_Differential_Backup1");
}
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);
}
}
/// <summary>
/// Creates new BackupSet info
/// </summary>
/// <returns></returns>
public static BackupSetInfo Create(Restore restore, Server server)
{
BackupSet backupSet = restore.BackupSet;
Dictionary <string, LocalizedPropertyInfo> properties = new Dictionary <string, LocalizedPropertyInfo>();
string bkSetComponent;
string bkSetType;
CommonUtilities.GetBackupSetTypeAndComponent(backupSet.BackupSetType, out bkSetType, out bkSetComponent);
if (server.Version.Major > 8 && backupSet.IsCopyOnly)
{
bkSetType += SR.RestoreCopyOnly;
}
properties.Add(NamePropertyName, new LocalizedPropertyInfo
{
PropertyName = NamePropertyName,
PropertyValue = backupSet.Name,
PropertyDisplayName = SR.RestoreBackupSetName
});
properties.Add(BackupComponentPropertyName, new LocalizedPropertyInfo
{
PropertyName = BackupComponentPropertyName,
PropertyValue = bkSetComponent,
PropertyDisplayName = SR.RestoreBackupSetType
});
properties.Add(BackupTypePropertyName, new LocalizedPropertyInfo
{
PropertyName = BackupTypePropertyName,
PropertyValue = bkSetType,
PropertyDisplayName = SR.RestoreBackupSetComponent
});
properties.Add(ServerNamePropertyName, new LocalizedPropertyInfo
{
PropertyName = ServerNamePropertyName,
PropertyValue = backupSet.ServerName,
PropertyDisplayName = SR.RestoreBackupSetServer
});
properties.Add(DatabaseNamePropertyName, new LocalizedPropertyInfo
{
PropertyName = DatabaseNamePropertyName,
PropertyValue = backupSet.DatabaseName,
PropertyDisplayName = SR.RestoreBackupSetDatabase
});
properties.Add(PositionPropertyName, new LocalizedPropertyInfo
{
PropertyName = PositionPropertyName,
PropertyValueDisplayName = Convert.ToString(backupSet.Position, CultureInfo.CurrentCulture),
PropertyValue = backupSet.Position,
PropertyDisplayName = SR.RestoreBackupSetPosition
});
properties.Add(FirstLsnPropertyName, new LocalizedPropertyInfo
{
PropertyName = FirstLsnPropertyName,
PropertyValue = backupSet.FirstLsn,
PropertyDisplayName = SR.RestoreBackupSetFirstLsn
});
properties.Add(LastLsnPropertyName, new LocalizedPropertyInfo
{
PropertyName = LastLsnPropertyName,
PropertyValue = backupSet.LastLsn,
PropertyDisplayName = SR.RestoreBackupSetLastLsn
});
properties.Add(FullLsnPropertyName, new LocalizedPropertyInfo
{
PropertyName = FullLsnPropertyName,
PropertyValue = backupSet.DatabaseBackupLsn,
PropertyDisplayName = SR.RestoreBackupSetFullLsn
});
properties.Add(CheckpointLsnPropertyName, new LocalizedPropertyInfo
{
PropertyName = CheckpointLsnPropertyName,
PropertyValue = backupSet.CheckpointLsn,
PropertyDisplayName = SR.RestoreBackupSetCheckpointLsn
});
properties.Add(StartDatePropertyName, new LocalizedPropertyInfo
{
PropertyName = StartDatePropertyName,
PropertyValue = backupSet.BackupStartDate,
PropertyDisplayName = SR.RestoreBackupSetStartDate
});
properties.Add(FinishDatePropertyName, new LocalizedPropertyInfo
{
PropertyName = FinishDatePropertyName,
PropertyValue = backupSet.BackupFinishDate,
PropertyDisplayName = SR.RestoreBackupSetFinishDate
});
properties.Add(SizePropertyName, new LocalizedPropertyInfo
{
PropertyName = SizePropertyName,
PropertyValue = backupSet.BackupSize,
PropertyDisplayName = SR.RestoreBackupSetSize,
});
properties.Add(UserNamePropertyName, new LocalizedPropertyInfo
{
PropertyName = UserNamePropertyName,
PropertyValue = backupSet.UserName,
PropertyDisplayName = SR.RestoreBackupSetUserName,
});
properties.Add(ExpirationPropertyName, new LocalizedPropertyInfo
{
PropertyName = ExpirationPropertyName,
PropertyValue = backupSet.ExpirationDate,
PropertyDisplayName = SR.RestoreBackupSetExpiration,
});
properties.Add(DatabaseFileInfo.IdPropertyName, new LocalizedPropertyInfo
{
PropertyName = DatabaseFileInfo.IdPropertyName,
PropertyValue = backupSet.BackupSetGuid
});
return(new BackupSetInfo(properties));
}
private void btn_restore_Click(object sender, EventArgs e)
{
if (cmbDataBase.SelectedIndex.ToString().Equals(""))
{
MessageBox.Show("Please choose Database", "Server", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
// If there was a SQL connection created
if (_srvr != null)
{
try
{
btn_backup.Enabled = false;
btn_restore.Enabled = false;
db_change.Enabled = false;
server_change.Enabled = false;
Cursor = Cursors.WaitCursor;
// If the user has chosen the file from which he wants the database to be restored
// Create a new database restore operation
var rstDatabase = new Restore
{
Action = RestoreActionType.Database,
Database = cmbDataBase.SelectedItem.ToString()
};
// Set the restore type to a database restore
// Set the database that we want to perform the restore on
// Set the backup device from which we want to restore, to a file
var bkpDevice = new BackupDeviceItem(_dBpath + "\\Backup.bak", DeviceType.File);
// Add the backup device to the restore type
rstDatabase.Devices.Add(bkpDevice);
// If the database already exists, replace it
rstDatabase.ReplaceDatabase = true;
// Perform the restore
rstDatabase.SqlRestore(_srvr);
MessageBox.Show("Database " + cmbDataBase.Text + " succefully restored", "Server", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception)
{
MessageBox.Show("ERROR: An error ocurred while restoring the database", "Application Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
Cursor = Cursors.Arrow;
btn_backup.Enabled = true;
btn_restore.Enabled = true;
db_change.Enabled = true;
server_change.Enabled = true;
}
}
else
{
MessageBox.Show("ERROR: A connection to a SQL server was not established.", "Server", MessageBoxButtons.OK, MessageBoxIcon.Error);
Cursor = Cursors.Arrow;
}
}
/// <summary>
/// Execute backup
/// </summary>
public override void Execute()
{
this.backup = new Backup();
this.backup.Database = this.backupInfo.DatabaseName;
this.backup.Action = this.backupActionType;
this.backup.Incremental = this.isBackupIncremental;
this.SetBackupProps();
try
{
if (this.backup.Action == BackupActionType.Files)
{
IDictionaryEnumerator filegroupEnumerator = this.backupInfo.SelectedFileGroup.GetEnumerator();
filegroupEnumerator.Reset();
while (filegroupEnumerator.MoveNext())
{
string currentKey = Convert.ToString(filegroupEnumerator.Key,
System.Globalization.CultureInfo.InvariantCulture);
string currentValue = Convert.ToString(filegroupEnumerator.Value,
System.Globalization.CultureInfo.InvariantCulture);
if (currentKey.IndexOf(",", StringComparison.Ordinal) < 0)
{
// is a file group
this.backup.DatabaseFileGroups.Add(currentValue);
}
else
{
// is a file
int idx = currentValue.IndexOf(".", StringComparison.Ordinal);
currentValue = currentValue.Substring(idx + 1, currentValue.Length - idx - 1);
this.backup.DatabaseFiles.Add(currentValue);
}
}
}
this.backup.BackupSetName = this.backupInfo.BackupsetName;
for (int i = 0; i < this.backupInfo.BackupPathList.Count; i++)
{
string destName = Convert.ToString(this.backupInfo.BackupPathList[i], System.Globalization.CultureInfo.InvariantCulture);
int deviceType = (int)(this.backupInfo.BackupPathDevices[destName]);
switch (deviceType)
{
case (int)DeviceType.LogicalDevice:
int backupDeviceType =
GetDeviceType(Convert.ToString(destName,
System.Globalization.CultureInfo.InvariantCulture));
if (this.backupDeviceType == BackupDeviceType.Disk && backupDeviceType == constDeviceTypeFile)
{
this.backup.Devices.AddDevice(destName, DeviceType.LogicalDevice);
}
break;
case (int)DeviceType.File:
if (this.backupDeviceType == BackupDeviceType.Disk)
{
this.backup.Devices.AddDevice(destName, DeviceType.File);
}
break;
}
}
this.backup.CopyOnly = this.backupInfo.IsCopyOnly;
this.backup.FormatMedia = this.backupInfo.FormatMedia;
this.backup.Initialize = this.backupInfo.Initialize;
this.backup.SkipTapeHeader = this.backupInfo.SkipTapeHeader;
this.backup.Checksum = this.backupInfo.Checksum;
this.backup.ContinueAfterError = this.backupInfo.ContinueAfterError;
if (!string.IsNullOrEmpty(this.backupInfo.MediaName))
{
this.backup.MediaName = this.backupInfo.MediaName;
}
if (!string.IsNullOrEmpty(this.backupInfo.MediaDescription))
{
this.backup.MediaDescription = this.backupInfo.MediaDescription;
}
if (this.backupInfo.TailLogBackup &&
!this.backupRestoreUtil.IsHADRDatabase(this.backupInfo.DatabaseName) &&
!this.backupRestoreUtil.IsMirroringEnabled(this.backupInfo.DatabaseName))
{
this.backup.NoRecovery = true;
}
if (this.backupInfo.LogTruncation)
{
this.backup.LogTruncation = BackupTruncateLogType.Truncate;
}
else
{
this.backup.LogTruncation = BackupTruncateLogType.NoTruncate;
}
if (!string.IsNullOrEmpty(this.backupInfo.BackupSetDescription))
{
this.backup.BackupSetDescription = this.backupInfo.BackupSetDescription;
}
if (this.backupInfo.RetainDays >= 0)
{
this.backup.RetainDays = this.backupInfo.RetainDays;
}
else
{
this.backup.ExpirationDate = this.backupInfo.ExpirationDate;
}
this.backup.CompressionOption = (BackupCompressionOptions)this.backupInfo.CompressionOption;
if (!string.IsNullOrEmpty(this.backupInfo.EncryptorName))
{
this.backup.EncryptionOption = new BackupEncryptionOptions((BackupEncryptionAlgorithm)this.backupInfo.EncryptionAlgorithm,
(BackupEncryptorType)this.backupInfo.EncryptorType,
this.backupInfo.EncryptorName);
}
if (this.dataContainer.Server.ConnectionContext != null)
{
// Execute backup
this.backup.SqlBackup(this.dataContainer.Server);
// Verify backup if required
if (this.backupInfo.VerifyBackupRequired)
{
Restore restore = new Restore();
restore.Devices.AddRange(this.backup.Devices);
restore.Database = this.backup.Database;
string errorMessage = null;
restore.SqlVerifyLatest(this.dataContainer.Server, out errorMessage);
if (errorMessage != null)
{
throw new DisasterRecoveryException(errorMessage);
}
}
}
}
catch (Exception)
{
throw;
}
finally
{
if (this.serverConnection != null)
{
this.serverConnection.Disconnect();
}
if (this.dataContainer != null)
{
this.dataContainer.Dispose();
}
}
}
/// <summary>
/// Starts or resumes a restore session
/// </summary>
/// <param name="session">
/// The restore session to execute
/// </param>
public void ExecuteRestore(Restore.Session session)
{
Execute(new Tasks.ExecuteRestore() { Session = session });
}
/// <summary>
/// Starts/resumes a restore session
/// </summary>
/// <param name="session">
/// The session to execute
/// </param>
static void ExecuteSession(Restore.Session session)
{
engine.ExecuteRestore(session);
Console.WriteLine(" Restore complete.");
}
static void Main()
{
// For remote connection, remote server name / ServerInstance needs to be specified
ServerConnection srvConn2 = new ServerConnection("machinename" /* <--default sql instance on machinename*/); // or (@"machinename\sqlinstance") for named instances
srvConn2.LoginSecure = false;
srvConn2.Login = "******";
srvConn2.Password = "******";
srvConn2.DatabaseName = "msdb";
Server srv3 = new Server(srvConn2);
//server info
Console.WriteLine("servername:{0} ---- version:{1}", srv3.Name, srv3.Information.Version);
//server root directory
string serverRootDir = srv3.Information.RootDirectory;
//server backup directory
string serverBackupDir = srv3.Settings.BackupDirectory;
//database primary directory
string databasePrimaryFilepath = srv3.Databases[srvConn2.DatabaseName].PrimaryFilePath;
Console.WriteLine("server_root_dir:{0}\nserver_backup_dir:{1}\ndatabase_primary_dir{2}", serverRootDir, serverBackupDir, databasePrimaryFilepath);
Backup bkpDbFull = new Backup();
bkpDbFull.Action = BackupActionType.Database;
//comment out copyonly ....
bkpDbFull.CopyOnly = true; //copy only, just for testing....avoid messing up with existing backup processes
bkpDbFull.Database = srvConn2.DatabaseName;
//backup file name
string backupfile = $"\\backuptest_{DateTime.Now.ToString("dd/MM/yyyy/hh/mm/ss")}.bak";
//add multiple files, in each location
bkpDbFull.Devices.AddDevice(serverRootDir + backupfile, DeviceType.File);
bkpDbFull.Devices.AddDevice(serverBackupDir + backupfile, DeviceType.File);
bkpDbFull.Devices.AddDevice(databasePrimaryFilepath + backupfile, DeviceType.File);
bkpDbFull.Initialize = true;
foreach (BackupDeviceItem backupdevice in bkpDbFull.Devices)
{
Console.WriteLine("deviceitem:{0}", backupdevice.Name);
}
//backup is split/divided amongst the 3 devices
bkpDbFull.SqlBackup(srv3);
Restore restore = new Restore();
restore.Devices.AddRange(bkpDbFull.Devices);
DataTable backupHeader = restore.ReadBackupHeader(srv3);
//IsCopyOnly=True
for (int r = 0; r < backupHeader.Rows.Count; r++)
{
for (int c = 0; c < backupHeader.Columns.Count; c++)
{
Console.Write("{0}={1}\n", backupHeader.Columns[c].ColumnName, (string.IsNullOrEmpty(backupHeader.Rows[r].ItemArray[c].ToString())? "**": backupHeader.Rows[r].ItemArray[c].ToString()));
}
}
srvConn2.Disconnect(); //redundant
}
public static void RestoreDB(string backUpFilePath, string databaseName)
{
try
{
Console.WriteLine("Restore operation started");
Restore restore = new Restore();
//Set type of backup to be performed to database
restore.Database = databaseName;
restore.Action = RestoreActionType.Database;
//Set up the backup device to use filesystem.
restore.Devices.AddDevice(backUpFilePath, DeviceType.File);
//set ReplaceDatabase = true to create new database
//regardless of the existence of specified database
restore.ReplaceDatabase = true;
//If you have a differential or log restore to be followed,
//you would specify NoRecovery = true
restore.NoRecovery = false;
//if you want to restore to a different location, specify
//the logical and physical file names
restore.RelocateFiles.Add(new RelocateFile("Test",
@"C:\Temp\Test.mdf"));
restore.RelocateFiles.Add(new RelocateFile("Test_Log",
@"C:\Temp\Test_Log.ldf"));
ServerConnection connection = new
ServerConnection(@"SERVER_NAME");
//my SQL user doesnt have sufficient permissions,
//so i am using my windows account
connection.LoginSecure = true;
//connection.LoginSecure = false;
//connection.Login = "******";
//connection.Password = "******";
Server sqlServer = new Server(connection);
//SqlRestore method starts to restore database
restore.SqlRestore(sqlServer);
Console.WriteLine("Restore operation succeeded");
}
catch (Exception ex)
{
Console.WriteLine("Restore operation failed");
Console.WriteLine(ex.Message);
}
Console.ReadLine();
}
/// <summary>
/// Handles the Click event of the btnFinish control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void btnFinish_Click(object sender, EventArgs e)
{
try
{
Cursor = Cursors.WaitCursor;
var restore = new Restore
{
Action = RestoreActionType.Database,
Database = txtDatabaseName.Text.Trim(),
ReplaceDatabase = true,
ContinueAfterError = true
};
if (!System.IO.File.Exists(AppDomain.CurrentDomain.BaseDirectory + DatabaseTemplatePath))
{
XtraMessageBox.Show(ResourceHelper.GetResourceValueByName("ResDatabaseTempNotExist"), ResourceHelper.GetResourceValueByName("ResExceptionCaption"),
MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
var backupDeviceItem = new BackupDeviceItem(AppDomain.CurrentDomain.BaseDirectory + DatabaseTemplatePath, DeviceType.File);
restore.Devices.Add(backupDeviceItem);
var fileList = restore.ReadFileList(_server);
restore.RelocateFiles.Add(new RelocateFile(fileList.Rows[0][0].ToString().Trim(), btnDatabasePath.Text + @"\" + txtDatabaseName.Text.Trim() + ".mdf"));
restore.RelocateFiles.Add(new RelocateFile(fileList.Rows[1][0].ToString().Trim(), btnDatabasePath.Text + @"\" + txtDatabaseName.Text.Trim() + "_log.ldf"));
restore.SqlRestore(_server);
var database = _server.Databases[txtDatabaseName.Text.Trim()];
if (database != null)
{
database.SetOnline();
}
////LinhMC change logicalName, ThangNK comment lại khi chuyển sang tư vấn nó ko lỗi
//if (_server != null)
//{
// var databaseName = txtDatabaseName.Text.Trim();
// string strCommand = "ALTER DATABASE " + databaseName + " MODIFY FILE (NAME = aBigTime, NEWNAME = " +
// databaseName + "); ALTER DATABASE " + databaseName +
// " MODIFY FILE (NAME = aBigTime_log, NEWNAME = " + databaseName + "_log);";
// _server.ConnectionContext.ExecuteNonQuery(strCommand);
//}
//update registry
RegistryHelper.RemoveConnectionString();
RegistryHelper.SetValueForRegistry("DatabaseName", txtDatabaseName.Text);
RegistryHelper.SetValueForRegistry("DatabasePath", btnDatabasePath.Text + @"\");
RegistryHelper.SaveConfigFile();
//update options
var message = _dbOptionsPresenter.Save();
if (message != null)
{
XtraMessageBox.Show(message, ResourceHelper.GetResourceValueByName("ResDetailContent"), MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
//update currency
_currencyPresenter.DisplayByCurrencyCode(cboCurrencyAccounting.EditValue == null ? null : cboCurrencyAccounting.EditValue.ToString());
if (CurrencyId != 0)
{
IsActive = true;
_currencyPresenter.Save();
}
_currencyPresenter.DisplayByCurrencyCode(cboCurrencyAccounting.EditValue == null ? null : cboCurrencyLocal.EditValue.ToString());
if (CurrencyId != 0)
{
IsActive = true;
_currencyPresenter.Save();
}
_currencyPresenter.DisplayByCurrencyCode(cboCurrencyAccounting.EditValue == null ? null : cboCurrencyCodeOfSalary.EditValue.ToString());
if (CurrencyId != 0)
{
IsActive = true;
_currencyPresenter.Save();
}
XtraMessageBox.Show(ResourceHelper.GetResourceValueByName("ResCreateDBSucces"), ResourceHelper.GetResourceValueByName("ResDetailContent"), MessageBoxButtons.OK, MessageBoxIcon.Information);
}
//update account
_accountPresenter.DisplayByAccountCode("11122");
CurrencyCode = cboCurrencyLocal.EditValue.ToString().Trim();
_accountPresenter.Save();
_accountPresenter.DisplayByAccountCode("11222");
CurrencyCode = cboCurrencyLocal.EditValue.ToString().Trim();
_accountPresenter.Save();
//update cac khoan luong
LoadPayItem();
if (cboCurrencyCodeOfSalary.EditValue.Equals("USD"))
{
foreach (var payItem in _payItems)
{
_payItemPresenter.Display(payItem.PayItemId.ToString(CultureInfo.InvariantCulture));
CreditAccountCode = "11121";
_payItemPresenter.Save();
}
}
else
{
foreach (var payItem in _payItems)
{
_payItemPresenter.Display(payItem.PayItemId.ToString(CultureInfo.InvariantCulture));
CreditAccountCode = "11122";
_payItemPresenter.Save();
}
}
LoadAutoBusiness();
if (cboCurrencyLocal.EditValue != null && cboCurrencyAccounting.EditValue != null)
{
var lstAutoBusinessByNotUSD = _autoAutoBusiness.Where(w => w.CurrencyCode != null && w.CurrencyCode != string.Empty && w.CurrencyCode != cboCurrencyAccounting.EditValue.ToString()).ToList();
foreach (var autoBusiness in lstAutoBusinessByNotUSD)
{
_autoBusinessPresenter.Display(autoBusiness.AutoBusinessId.ToString(CultureInfo.InvariantCulture));
CurrencyCode = cboCurrencyLocal.EditValue.ToString();
_autoBusinessPresenter.Save();
}
}
Cursor = Cursors.Default;
System.Windows.Forms.Application.Restart();
}
catch (Exception ex)
{
Cursor = Cursors.Default;
XtraMessageBox.Show(ex.ToString(),
ResourceHelper.GetResourceValueByName("ResExceptionCaption"), MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// 组件初始化
/// </summary>
/// <param name="option"></param>
private void OptionComponent(Option option)
{
EChartsComponentTitle title = new EChartsComponentTitle {
Text = "hello World", Subtext = "UglyMelon007"
};
option.Title = title;
EChartsComponentTooltip tooltip = new EChartsComponentTooltip {
Trigger = "axis"
};
option.Tooltip = tooltip;
EChartsComponentLegend legend = new EChartsComponentLegend();
LegendData legendData = new LegendData {
Name = "最高温度"
};
legend.Data = new[] { legendData };
option.Legend = legend;
EChartsComponentAxis xAxis = new EChartsComponentAxis {
Type = "category", BoundaryGap = "false"
};
xAxis.Data = new[] {
new AxisData {
Value = "Monday"
},
new AxisData {
Value = "Tuesday"
},
new AxisData {
Value = "Wednesday"
},
new AxisData {
Value = "Thursday"
},
new AxisData {
Value = "Friday"
},
new AxisData {
Value = "Saturday"
},
new AxisData {
Value = "Sunday"
}
};
option.XAxis = xAxis;
EChartsComponentAxis yAxis = new EChartsComponentAxis {
Type = "value"
};
AxisLabel axisLabel = new AxisLabel {
Formatter = "{value} °C"
};
yAxis.AxisLabel = axisLabel;
option.YAxis = yAxis;
EChartsComponentToolbox toolbox = new EChartsComponentToolbox();
toolbox.Show = "true";
Feature feature = new Feature();
Mark mark = new Mark {
Show = "true"
};
DataView dataView = new DataView {
Show = "true", ReadOnly = "false"
};
MagicType magicType = new MagicType {
Show = "true", Type = new[] { "line", "bar" }
};
Restore restore = new Restore {
Show = "true"
};
SaveAsImage saveAsImage = new SaveAsImage {
Show = "true"
};
feature.Mark = mark;
feature.DataView = dataView;
feature.MagicType = magicType;
feature.Restore = restore;
feature.SaveAsImage = saveAsImage;
toolbox.Feature = feature;
option.Toolbox = toolbox;
}
public void RestoreDB(string connectionString, string backupFile)
{
if (connectionString == null)
{
FailedToRestore($"ConnectionString is null.");
// throw new ArgumentNullException($"ConnectionString is null.");
}
if (backupFile == null)
{
FailedToRestore($"BackupFile is null.");
// throw new ArgumentNullException($"BackupFile is null.");
}
if (string.IsNullOrEmpty(connectionString.Trim()) || string.IsNullOrEmpty(backupFile.Trim()))
{
FailedToRestore($"Either of the parameter is empty or having whitespace.");
//throw new ArgumentNullException($"Either of the parameter is empty or whitespace.");
}
try
{
using (SqlConnection connection = new SqlConnection())
{
//polish the connection string
connection.ConnectionString = connectionString;
_connection = new ServerConnection(connection);
_connection.StatementTimeout = ConnectionStatementTimeout;
_server = new Server(_connection);
string databaName = Path.GetFileNameWithoutExtension(backupFile);
Restore = new Restore();
Restore.Action = RestoreActionType.Database;
Restore.Database = databaName;
Restore.ReplaceDatabase = true;
Device = new BackupDeviceItem(backupFile, DeviceType.File);
Restore.Devices.Add(Device);
Database currentDb = _server.Databases[databaName];
if (currentDb != null)
{
KillDatabaseProcess(databaName);
}
//Restore DB
Restore.SqlRestore(_server);
RestoredSuccessfully();
}
}
catch (InvalidOperationException ioex)
{
FailedToRestore(ioex.Message);
}
catch (Exception ex)
{
FailedToRestore(ex.Message);
}
finally
{
Device = null;
Restore = null;
}
}
public Response Task()
{
Response response = new Response();
string dbBakFile = _db.File.FullName;
string dbtoRestore = _db.DatabaseName;
if (string.IsNullOrEmpty(dbBakFile) || !File.Exists(dbBakFile))
{
response.Status = Response.ResponseMessage.Failed;
response.Message = "No such .bak file found.";
return(response);
}
var smoServer = _db.Server;
var db = smoServer.Databases[dbtoRestore];
if (db != null)
{
smoServer.KillAllProcesses(dbtoRestore);
log.Debug("All processes on db killed");
db.SetOffline();
}
string dataPath = UtilityConfig.GetMachineConfigValue("DataPath");
string dbPath = Path.Combine(dataPath, dbtoRestore + ".mdf");
string logPath = Path.Combine(dataPath, dbtoRestore + ".ldf");
var restore = new Restore();
var deviceItem = new BackupDeviceItem(dbBakFile, DeviceType.File);
restore.ReplaceDatabase = true;
restore.PercentCompleteNotification = 10;
restore.PercentComplete += restore_PercentComplete;
restore.Complete += restore_Complete;
try
{
restore.Devices.Add(deviceItem);
if (db != null)
{
DataTable dtFileList = restore.ReadFileList(smoServer);
string dbLogicalName = dtFileList.Rows[0][0].ToString();
string logLogicalName = dtFileList.Rows[1][0].ToString();
restore.RelocateFiles.Add(new RelocateFile(dbLogicalName, dbPath));
restore.RelocateFiles.Add(new RelocateFile(logLogicalName, logPath));
}
else
{
Database smoDatabase = new Database(smoServer, dbtoRestore);
FileGroup fg = new FileGroup(smoDatabase, "PRIMARY");
smoDatabase.FileGroups.Add(fg);
DataFile df = new DataFile(fg, dbtoRestore, dbPath);
df.IsPrimaryFile = true;
fg.Files.Add(df);
LogFile lf = new LogFile(smoDatabase, dbtoRestore + "_log", logPath);
smoDatabase.LogFiles.Add(lf);
smoDatabase.Create();
smoServer.Refresh();
smoServer.KillAllProcesses(dbtoRestore);
log.Debug("All processes on db killed");
smoServer.Databases[dbtoRestore].SetOffline();
//restore.DatabaseFiles.Add(dbPath);
//restore.DatabaseFiles.Add(logPath);
DataTable dtFileList = restore.ReadFileList(smoServer);
string dbLogicalName = dtFileList.Rows[0][0].ToString();
string logLogicalName = dtFileList.Rows[1][0].ToString();
restore.RelocateFiles.Add(new RelocateFile(dbLogicalName, dbPath));
restore.RelocateFiles.Add(new RelocateFile(logLogicalName, logPath));
}
restore.Database = dbtoRestore;
restore.FileNumber = 1;
restore.Action = RestoreActionType.Files;
restore.SqlRestore(smoServer);
db = smoServer.Databases[dbtoRestore];
db.SetOnline();
smoServer.Refresh();
db.Refresh();
}
catch (Exception ex)
{
// cleanup
smoServer.Refresh();
db = smoServer.Databases[dbtoRestore];
if (db != null)
{
db.Drop();
}
if (File.Exists(dbPath))
{
File.Delete(dbPath);
}
if (File.Exists(logPath))
{
File.Delete(dbPath);
}
response.Status = Response.ResponseMessage.Failed;
response.Message = ex.GetExceptionMessages();
return(response);
}
response.Status = Response.ResponseMessage.Succeeded;
response.Message = string.Format("{0} file restored to database {1}.", _db.File.Name, dbtoRestore);
return(response);
}
public IDictionary <string, string> to_token_dictionary()
{
var tokens = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
{ nameof(AfterMigrationFolderName), AfterMigrationFolderName.to_string() },
{ nameof(AlterDatabaseFolderName), AlterDatabaseFolderName.to_string() },
{ nameof(Baseline), Baseline.to_string() },
{ nameof(BeforeMigrationFolderName), BeforeMigrationFolderName.to_string() },
{ nameof(CommandTimeout), CommandTimeout.to_string() },
{ nameof(CommandTimeoutAdmin), CommandTimeoutAdmin.to_string() },
{ nameof(ConfigurationFile), ConfigurationFile.to_string() },
{ nameof(ConnectionString), ConnectionString.to_string() },
{ nameof(ConnectionStringAdmin), ConnectionStringAdmin.to_string() },
{ nameof(CreateDatabaseCustomScript), CreateDatabaseCustomScript.to_string() },
{ nameof(DatabaseName), DatabaseName.to_string() },
{ nameof(DatabaseType), DatabaseType.to_string() },
{ nameof(Debug), Debug.to_string() },
{ nameof(DisableOutput), DisableOutput.to_string() },
{ nameof(DisableTokenReplacement), DisableTokenReplacement.to_string() },
{ nameof(DoNotAlterDatabase), DoNotAlterDatabase.to_string() },
{ nameof(DoNotCreateDatabase), DoNotCreateDatabase.to_string() },
{ nameof(DoNotStoreScriptsRunText), DoNotStoreScriptsRunText.to_string() },
{ nameof(DownFolderName), DownFolderName.to_string() },
{ nameof(Drop), Drop.to_string() },
{ nameof(DryRun), DryRun.to_string() },
#pragma warning disable 618
{ nameof(EnvironmentName), string.Join(",", EnvironmentNames) },
#pragma warning restore 618
{ nameof(EnvironmentNames), string.Join(",", EnvironmentNames) },
{ nameof(FunctionsFolderName), FunctionsFolderName.to_string() },
{ nameof(IndexesFolderName), IndexesFolderName.to_string() },
{ nameof(Initialize), Initialize.to_string() },
{ nameof(OutputPath), OutputPath.to_string() },
{ nameof(PermissionsFolderName), PermissionsFolderName.to_string() },
{ nameof(RecoveryMode), RecoveryMode.to_string() },
{ nameof(RepositoryPath), RepositoryPath.to_string() },
{ nameof(Restore), Restore.to_string() },
{ nameof(RestoreCustomOptions), RestoreCustomOptions.to_string() },
{ nameof(RestoreFromPath), RestoreFromPath.to_string() },
{ nameof(RestoreTimeout), RestoreTimeout.to_string() },
{ nameof(RunAfterCreateDatabaseFolderName), RunAfterCreateDatabaseFolderName.to_string() },
{ nameof(RunAfterOtherAnyTimeScriptsFolderName), RunAfterOtherAnyTimeScriptsFolderName.to_string() },
{ nameof(RunAllAnyTimeScripts), RunAllAnyTimeScripts.to_string() },
{ nameof(RunBeforeUpFolderName), RunBeforeUpFolderName.to_string() },
{ nameof(RunFirstAfterUpFolderName), RunFirstAfterUpFolderName.to_string() },
{ nameof(SchemaName), SchemaName.to_string() },
{ nameof(ScriptsRunErrorsTableName), ScriptsRunErrorsTableName.to_string() },
{ nameof(ScriptsRunTableName), ScriptsRunTableName.to_string() },
{ nameof(SearchAllSubdirectoriesInsteadOfTraverse), SearchAllSubdirectoriesInsteadOfTraverse.to_string() },
{ nameof(ServerName), ServerName.to_string() },
{ nameof(Silent), Silent.to_string() },
{ nameof(SprocsFolderName), SprocsFolderName.to_string() },
{ nameof(SqlFilesDirectory), SqlFilesDirectory.to_string() },
{ nameof(TriggersFolderName), TriggersFolderName.to_string() },
{ nameof(UpFolderName), UpFolderName.to_string() },
{ nameof(Version), Version.to_string() },
{ nameof(VersionFile), VersionFile.to_string() },
{ nameof(VersionTableName), VersionTableName.to_string() },
{ nameof(VersionXPath), VersionXPath.to_string() },
{ nameof(ViewsFolderName), ViewsFolderName.to_string() },
{ nameof(WarnAndIgnoreOnOneTimeScriptChanges), WarnAndIgnoreOnOneTimeScriptChanges.to_string() },
{ nameof(WarnOnOneTimeScriptChanges), WarnOnOneTimeScriptChanges.to_string() },
{ nameof(WithTransaction), WithTransaction.to_string() },
};
if (UserTokens != null)
{
foreach (var t in UserTokens)
{
tokens[t.Key] = t.Value;
}
}
return(tokens);
}
// Start is called before the first frame update
void Start()
{
restoreScript = GetComponent <Restore>();
}
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);
}
}
/// <summary>
/// Deletes a restore session
/// </summary>
/// <param name="session">
/// The restore session to delete
/// </param>
public void DeleteRestore(Restore.Session session)
{
this.archive.RestoreIndex.DeleteSession(session);
}
/// <summary>
/// Prepares the archive for a new restore process and returns
/// an object used to restore entries from the archive
/// </summary>
/// <param name="session">
/// The new restore session
/// </param>
/// <returns>
/// The archive restore implementation
/// </returns>
public IRestore PrepareRestore(Restore.Session session)
{
return new FileSystemRestore(this, session);
}
public static void RollBackDatabase(string databaseName, string bakfilePath)
{
SqlConnection.ClearAllPools();
SqlConnection cnn = SetSingleUser(databaseName);
ServerConnection serverConn = new ServerConnection(cnn);
Server server = new Server(serverConn);
Database db = server.Databases[cnn.Database];
Restore restore = new Restore();
restore.Action = RestoreActionType.Database;
restore.Devices.AddDevice(bakfilePath, DeviceType.File);
restore.Database = databaseName;
restore.ReplaceDatabase = true;
restore.Complete += new ServerMessageEventHandler(Restore_Completed);
restore.PercentComplete += new PercentCompleteEventHandler(CompletionStatusInPercent);
restore.PercentCompleteNotification = 10;
SqlCommand cmd = cnn.CreateCommand();
cmd.CommandText = string.Format("use master");
cmd.ExecuteNonQuery();
restore.SqlRestore(server);
db = server.Databases[databaseName];
db.SetOnline();
server.Refresh();
if (server.ConnectionContext.IsOpen)
server.ConnectionContext.Disconnect();
}
private void RollbackUpgrade(Server server, String databaseName)
{
if (backupFilePath != null)
{
Logger.DebugFormat("Restoring database from '{0}'.", backupFilePath);
var db = server.Databases[databaseName];
server.KillAllProcesses(databaseName);
Restore restoreDB = new Restore();
restoreDB.Database = databaseName;
/* Specify whether you want to restore database, files or log */
restoreDB.Action = RestoreActionType.Database;
restoreDB.Devices.AddDevice(backupFilePath, DeviceType.File);
restoreDB.ReplaceDatabase = true;
restoreDB.NoRecovery = false;
restoreDB.PercentComplete += restoreDB_PercentComplete;
restoreDB.Complete += restoreDB_Complete;
restoreDB.SqlRestore(server);
}
}
private static void Restore(string backupFileName, string destinationDbName, SqlConnection connection)
{
Contract.Ensures(File.Exists(backupFileName), "File.Exists(backupFileName)");
var restoreDb = new Restore
{
Database = destinationDbName,
Action = RestoreActionType.Database,
ReplaceDatabase = true,
NoRecovery = false
};
restoreDb.Devices.AddDevice(backupFileName, DeviceType.File);
connection.Open();
var server = new Server(new ServerConnection(connection));
var relocateFiles = GetRelocateFiles(connection, backupFileName, destinationDbName, server.DefaultFile, server.DefaultLog);
restoreDb.RelocateFiles.AddRange(relocateFiles);
restoreDb.SqlRestore(server);
}
private void OnRestore(object sender, EventArgs e)
{
Restore?.Invoke(sender, e);
}
public void ValidateCanExecuteAbortRestore(IValueTag sender, ValueChangedEventArgs args)
{
Abort.ValidateCanExecute(sender, args);
Restore.ValidateCanExecute(sender, args);
}
public void DoDataBaseBackup()
{
string connectionString = ConfigurationManager.ConnectionStrings["Test"].ToString();
SqlConnection connecton = new SqlConnection(connectionString);
ServerConnection serverConnection = new ServerConnection(connecton);
Server myServer = new Server(serverConnection);
//Using windows authentication
myServer.ConnectionContext.Connect();
Database myDatabase = myServer.Databases[ConfigurationManager.AppSettings["DatabaseNameToBackup"]];
//Backup operation
Backup bkpDBFull = new Backup();
/* Specify whether you want to back up database or files or log */
bkpDBFull.Action = BackupActionType.Database;
/* Specify the name of the database to back up */
bkpDBFull.Database = myDatabase.Name;
/* You can take backup on several media type (disk or tape), here I am
* using File type and storing backup on the file system */
string destinationFolderForDatabase = ConfigurationManager.AppSettings["DestinationFolderForDatabase"];
bkpDBFull.Devices.AddDevice(destinationFolderForDatabase, DeviceType.File);
bkpDBFull.BackupSetName = "Test database Backup";
bkpDBFull.BackupSetDescription = "test database - Full Backup";
/* You can specify the expiration date for your backup data
* after that date backup data would not be relevant */
bkpDBFull.ExpirationDate = DateTime.Today.AddDays(10);
/* You can specify Initialize = false (default) to create a new
* backup set which will be appended as last backup set on the media. You
* can specify Initialize = true to make the backup as first set on the
* medium and to overwrite any other existing backup sets if the all the
* backup sets have expired and specified backup set name matches with
* the name on the medium */
bkpDBFull.Initialize = false;
/* You can specify Incremental = false (default) to perform full backup or Incremental = true to perform differential backup since most recent full backup */
bkpDBFull.Incremental = false;
/* Wiring up events for progress monitoring */
bkpDBFull.PercentComplete += CompletionStatusInPercent;
bkpDBFull.Complete += Backup_Completed;
/* SqlBackup method starts to take back up
* You can also use SqlBackupAsync method to perform the backup
* operation asynchronously */
bkpDBFull.SqlBackup(myServer);
Restore restore = new Restore();
restore.Devices.AddDevice(@"C:\Test.bak", DeviceType.File);
restore.Database = "Test2012";
Console.WriteLine(restore.SqlVerify(myServer).ToString());
if (myServer.ConnectionContext.IsOpen)
{
myServer.ConnectionContext.Disconnect();
}
}
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;
}
/// <summary>
/// Initializes a new restore instance
/// </summary>
/// <param name="archive">
/// The file system archive for the restore
/// </param>
/// <param name="session">
/// The restore session being processed
/// </param>
public FileSystemRestore(FileSystemArchive archive, Restore.Session session)
{
this.blobFile = IO.FileSystem.Open(archive.BlobPath);
}
public bool RealizarRestoreBD(string rutaArchivo)
{
bool resultado = false;
try
{
string baseDeDatos = ConfigurationManager.AppSettings["BaseDeDatos"].ToString();
if (File.Exists(rutaArchivo))
{
using (SqlConnection conexion = Conexion.ObtenerInstancia().CrearConexionSQLMaster())
{
ServerConnection conexionServer = new ServerConnection(conexion);
Server servidor = new Server(conexionServer);
Restore restoreBD = new Restore();
restoreBD.Action = RestoreActionType.Database;
restoreBD.Database = baseDeDatos;
String query = "ALTER DATABASE " + baseDeDatos + " SET SINGLE_USER WITH ROLLBACK IMMEDIATE";
using(SqlCommand comando = new SqlCommand(query, conexion))
{
comando.Connection.Open();
comando.ExecuteNonQuery();
}
BackupDeviceItem deviceItem = new BackupDeviceItem(rutaArchivo, DeviceType.File);
restoreBD.Devices.Add(deviceItem);
restoreBD.ReplaceDatabase = true;
restoreBD.SqlRestore(servidor);
conexionServer.Disconnect();
}
resultado = true;
}
return resultado;
}
catch (AccesoBDException ex)
{
throw new DALException("BDDAO", "RealizarRestoreBD", "AccesoBD", ex.Message, ex);
}
catch (SqlException ex)
{
throw new DALException("BDDAO", "RealizarRestoreBD", "SQL", ex.Message, ex);
}
catch (Exception ex)
{
throw new DALException("BDDAO", "RealizarRestoreBD", "General: " + ex.GetType().ToString(), ex.Message, ex);
}
}
private void VerifyBackup()
{
if (this.DataFilePath == null)
{
this.Log.LogError("DataFilePath is required");
return;
}
if (!File.Exists(this.DataFilePath.GetMetadata("FullPath")))
{
this.Log.LogError(string.Format(CultureInfo.CurrentCulture, "DataFilePath not found: {0}", this.DataFilePath.GetMetadata("FullPath")));
return;
}
this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "Verifying Backup: {0}", this.DataFilePath.GetMetadata("FullPath")));
Restore sqlRestore = new Restore();
sqlRestore.Devices.AddDevice(this.DataFilePath.GetMetadata("FullPath"), DeviceType.File);
string error;
bool verified = sqlRestore.SqlVerify(this.sqlServer, out error);
if (!verified)
{
this.Log.LogError(string.Format(CultureInfo.CurrentCulture, "Verification failed for: {0}. Error: {1}", this.DataFilePath.GetMetadata("FullPath"), error));
return;
}
this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "Backup successfully verified: {0}", this.DataFilePath.GetMetadata("FullPath")));
}
public bool Create_DataBase(string db_nm, string restore_bak_up_nm)
{
DataSet dset = new DataSet();
objIni.SetKeyFieldValue("SQL", "initial catalog", "master");
ServerConnection con = new ServerConnection(objIni.GetKeyFieldValue("SQL", "data source"), objIni.GetKeyFieldValue("SQL", "user"), objIni.GetKeyFieldValue("SQL", "pwd"));//"INODE-SHA\\iMANTRA", "sa", "sa1985");
bool flg = true;
try
{
#region comment
string dbName = db_nm;
string backupFileName = AppDomain.CurrentDomain.BaseDirectory + @"DATABASE\" + restore_bak_up_nm + ".bak";
Server server = new Server(con);
if (!server.Databases.Contains(dbName))
{
Database database = new Database(server, db_nm);
database.FileGroups.Add(new FileGroup(database, "PRIMARY"));
DataFile dtPrimary = new DataFile(database.FileGroups["PRIMARY"], db_nm, AppDomain.CurrentDomain.BaseDirectory + @"DATABASE\" + db_nm + ".mdf".Trim());
dtPrimary.Size = 77.0 * 1024.0;
dtPrimary.GrowthType = FileGrowthType.KB;
dtPrimary.Growth = 1.0 * 1024.0;
database.FileGroups["PRIMARY"].Files.Add(dtPrimary);
LogFile logFile = new LogFile(database, db_nm + "_log", AppDomain.CurrentDomain.BaseDirectory + @"DATABASE\" + db_nm + ".ldf".Trim());
logFile.Size = 7.0 * 1024.0;
logFile.GrowthType = FileGrowthType.Percent;
logFile.Growth = 10.0;
database.LogFiles.Add(logFile);
database.Create();
database.Refresh();
}
SqlConnection myConn = new SqlConnection(objIni.GetSectionDetails("SQL", ";"));//"data source=INODE-SHA\\iMANTRA;initial catalog=master;user=sa;pwd=sa1985");
string str = "RESTORE FILELISTONLY FROM DISK = '" + backupFileName + "'";
SqlDataAdapter cmd = new SqlDataAdapter(str, myConn);
myConn.Open();
cmd.Fill(dset);
Restore restore = new Restore();
Database database1 = server.Databases[db_nm];
restore.Database = database1.Name;
restore.ReplaceDatabase = true;
restore.Action = RestoreActionType.Database;
restore.Devices.AddDevice(backupFileName, DeviceType.File);
RelocateFile relocateDataFile = new RelocateFile(dset.Tables[0].Rows[0][0].ToString(), AppDomain.CurrentDomain.BaseDirectory + @"DATABASE\" + db_nm + ".mdf");
RelocateFile relocateLogFile = new RelocateFile(dset.Tables[0].Rows[1][0].ToString(), AppDomain.CurrentDomain.BaseDirectory + @"DATABASE\" + db_nm + ".ldf");
restore.RelocateFiles.Add(relocateDataFile);
restore.RelocateFiles.Add(relocateLogFile);
restore.ReplaceDatabase = true;
restore.PercentCompleteNotification = 10;
restore.PercentComplete += new PercentCompleteEventHandler(ProgressEventHandler);
restore.SqlRestore(server);
#endregion
}
catch (Exception ex)
{
flg = false;
AutoClosingMessageBox.Show("Connection Error : " + ex.Message, "Error", 5000);
}
finally
{
con.Disconnect();
}
return(flg);
}
private void SetupSut()
{
_mockDataStatementReader = new Mock <IDataStatementReader>();
_runEnvironment = new RunEnvironment();
_sut = new Restore(_runEnvironment, _mockDataStatementReader.Object);
}
private void Button_Click_2(object sender, RoutedEventArgs e)
{
Restore rest = new Restore();
string PathtobackUp ="";
OpenFileDialog dlg = new OpenFileDialog();
dlg.InitialDirectory = "c:\\";
dlg.Filter = "Backup Files (*.bak)|*.bak|All Files (*.*)|*.*";
dlg.RestoreDirectory = true;
if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
PathtobackUp = dlg.FileName.ToString();
}
else
{
return;
}
string fileName = PathtobackUp;
//this.Cursor = Cursors.WaitCursor;
//this.dataGridView1.DataSource = string.Empty;
try
{
rest.Devices.AddDevice(fileName, DeviceType.File);
Server srv = new Server("(localdb)\\v11.0");
bool verifySuccessful = rest.SqlVerify(srv);
string databaseName = "LoanManagement.Domain.finalContext";
if (verifySuccessful)
{
System.Windows.MessageBox.Show("Backup Verified!", "Info");
System.Windows.MessageBoxResult dr = System.Windows.MessageBox.Show("Do you want to restore?","Question",MessageBoxButton.YesNo);
if (dr == MessageBoxResult.Yes)
{
//fileName = dlg.FileName.Replace(Directory.GetCurrentDirectory(), "");
System.Windows.MessageBox.Show(fileName);
rest.Database = databaseName;
rest.Action = RestoreActionType.Database;
BackupDeviceItem bdi = default(BackupDeviceItem);
bdi = new BackupDeviceItem(fileName, DeviceType.File);
rest.Devices.Add(bdi);
//rest.Devices.Add(bdi);
rest.ReplaceDatabase = true;
srv = new Server("(localdb)\\v11.0");
rest.SqlRestore(srv);
srv.Refresh();
System.Windows.MessageBox.Show("Restore of " + databaseName +" Complete!");
}
}
else
{
System.Windows.MessageBox.Show("ERROR: Backup not verified!", "Error");
}
}
catch (Exception ex)
{
System.Windows.MessageBox.Show("The system has been successfully restored");
}
finally
{
//this.Cursor = Cursors.Default;
}
}
public IDictionary <string, string> to_token_dictionary()
{
var tokens = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
tokens["AccessToken"] = AccessToken.to_string();
tokens["AfterMigrationFolderName"] = AfterMigrationFolderName.to_string();
tokens["AlterDatabaseFolderName"] = AlterDatabaseFolderName.to_string();
tokens["Baseline"] = Baseline.to_string();
tokens["BeforeMigrationFolderName"] = BeforeMigrationFolderName.to_string();
tokens["CommandTimeout"] = CommandTimeout.to_string();
tokens["CommandTimeoutAdmin"] = CommandTimeoutAdmin.to_string();
tokens["ConfigurationFile"] = ConfigurationFile.to_string();
tokens["ConnectionString"] = ConnectionString.to_string();
tokens["ConnectionStringAdmin"] = ConnectionStringAdmin.to_string();
tokens["CreateDatabaseCustomScript"] = CreateDatabaseCustomScript.to_string();
tokens["DatabaseName"] = DatabaseName.to_string();
tokens["DatabaseType"] = DatabaseType.to_string();
tokens["Debug"] = Debug.to_string();
tokens["DisableOutput"] = DisableOutput.to_string();
tokens["DisableTokenReplacement"] = DisableTokenReplacement.to_string();
tokens["DoNotAlterDatabase"] = DoNotAlterDatabase.to_string();
tokens["DoNotCreateDatabase"] = DoNotCreateDatabase.to_string();
tokens["DoNotStoreScriptsRunText"] = DoNotStoreScriptsRunText.to_string();
tokens["DownFolderName"] = DownFolderName.to_string();
tokens["Drop"] = Drop.to_string();
tokens["DryRun"] = DryRun.to_string();
tokens["EnvironmentName"] = string.Join(",", EnvironmentNames);
tokens["EnvironmentNames"] = string.Join(",", EnvironmentNames);
tokens["FunctionsFolderName"] = FunctionsFolderName.to_string();
tokens["IndexesFolderName"] = IndexesFolderName.to_string();
tokens["Initialize"] = Initialize.to_string();
tokens["OutputPath"] = OutputPath.to_string();
tokens["PermissionsFolderName"] = PermissionsFolderName.to_string();
tokens["RecoveryMode"] = RecoveryMode.to_string();
tokens["RepositoryPath"] = RepositoryPath.to_string();
tokens["Restore"] = Restore.to_string();
tokens["RestoreCustomOptions"] = RestoreCustomOptions.to_string();
tokens["RestoreFromPath"] = RestoreFromPath.to_string();
tokens["RestoreTimeout"] = RestoreTimeout.to_string();
tokens["RunAfterCreateDatabaseFolderName"] = RunAfterCreateDatabaseFolderName.to_string();
tokens["RunAfterOtherAnyTimeScriptsFolderName"] = RunAfterOtherAnyTimeScriptsFolderName.to_string();
tokens["RunAllAnyTimeScripts"] = RunAllAnyTimeScripts.to_string();
tokens["RunBeforeUpFolderName"] = RunBeforeUpFolderName.to_string();
tokens["RunFirstAfterUpFolderName"] = RunFirstAfterUpFolderName.to_string();
tokens["SchemaName"] = SchemaName.to_string();
tokens["ScriptsRunErrorsTableName"] = ScriptsRunErrorsTableName.to_string();
tokens["ScriptsRunTableName"] = ScriptsRunTableName.to_string();
tokens["SearchAllSubdirectoriesInsteadOfTraverse"] = SearchAllSubdirectoriesInsteadOfTraverse.to_string();
tokens["ServerName"] = ServerName.to_string();
tokens["Silent"] = Silent.to_string();
tokens["SprocsFolderName"] = SprocsFolderName.to_string();
tokens["SqlFilesDirectory"] = SqlFilesDirectory.to_string();
tokens["TriggersFolderName"] = TriggersFolderName.to_string();
tokens["UpFolderName"] = UpFolderName.to_string();
tokens["Version"] = Version.to_string();
tokens["VersionFile"] = VersionFile.to_string();
tokens["VersionTableName"] = VersionTableName.to_string();
tokens["VersionXPath"] = VersionXPath.to_string();
tokens["ViewsFolderName"] = ViewsFolderName.to_string();
tokens["WarnAndIgnoreOnOneTimeScriptChanges"] = WarnAndIgnoreOnOneTimeScriptChanges.to_string();
tokens["WarnOnOneTimeScriptChanges"] = WarnOnOneTimeScriptChanges.to_string();
tokens["WithTransaction"] = WithTransaction.to_string();
if (UserTokens != null)
{
foreach (var t in UserTokens)
{
tokens[t.Key] = t.Value;
}
}
return(tokens);
}
/// <summary>
/// Retrieves an entry from the archive
/// </summary>
/// <param name="entry">
/// The restore entry to retrieve
/// </param>
/// <returns>
/// A sub-stream of the blob file containing the entry's data
/// </returns>
public Stream Restore(Restore.Entry entry)
{
return new IO.Substream(this.blobFile, entry.Offset, entry.Length);
}
public void Restore(string backupFile, string DatabaseName)
{
Microsoft.SqlServer.Management.Common.ServerConnection connection;
Console.WriteLine(string.Format("Connecting to SQL server {0}", Server));
// Initialize our common objects
connection = new Microsoft.SqlServer.Management.Common.ServerConnection(Server);
smoServer = new Server(connection);
database = smoServer.Databases[DatabaseName];
if (false && database == null)
{
// Invalid database name.
Console.WriteLine(string.Format("Invalid database '{1}' on server '{0}'.", Server, DatabaseName));
foreach (Database db in smoServer.Databases)
{
Console.WriteLine(string.Format("Available database: '{1}' on server '{0}'.", Server, db.Name));
}
throw new Exception(string.Format("Invalid database '{1}' on server '{0}'.", Server, DatabaseName));
}
Restore restore = new Restore();
restore.Action = RestoreActionType.Database;
restore.Database = DatabaseName;
restore.Devices.AddDevice(backupFile, DeviceType.File);
restore.ReplaceDatabase = true;
RelocateFile DataFile = new RelocateFile();
var fileList = restore.ReadFileList(smoServer);
string MDF = fileList.Rows[0][1].ToString();
DataFile.LogicalFileName = restore.ReadFileList(smoServer).Rows[0][0].ToString();
DataFile.PhysicalFileName = smoServer.Databases[DatabaseName].FileGroups[0].Files[0].FileName;
RelocateFile LogFile = new RelocateFile();
string LDF = restore.ReadFileList(smoServer).Rows[1][1].ToString();
LogFile.LogicalFileName = restore.ReadFileList(smoServer).Rows[1][0].ToString();
LogFile.PhysicalFileName = smoServer.Databases[DatabaseName].LogFiles[0].FileName;
restore.RelocateFiles.Add(DataFile);
restore.RelocateFiles.Add(LogFile);
// Kill all connections on the database.
if (database != null)
{
Console.WriteLine(string.Format("Deleting database {0}.", DatabaseName));
smoServer.KillDatabase(DatabaseName);
//context.TrackBuildMessage("Killing all processes");
//smoServer.KillAllProcesses(database.Name);
//context.TrackBuildMessage("Setting single-user mode");
//database.DatabaseOptions.UserAccess = DatabaseUserAccess.Single;
//database.Alter(TerminationClause.RollbackTransactionsImmediately);
//context.TrackBuildMessage("Detatching database");
//smoServer.DetachDatabase(DatabaseName.Get(context), false);
}
// Set some status update event handlers.
restore.PercentCompleteNotification = 10; // Send updates every 10%
restore.PercentComplete += new PercentCompleteEventHandler(RestoreProgressEventHandler);
Console.WriteLine("Restoring");
restore.SqlRestore(smoServer);
}
private void Restore()
{
if (this.DatabaseItem == null)
{
this.Log.LogError("DatabaseItem is required");
return;
}
if (this.ReplaceDatabase && this.LogFilePath == null)
{
this.Log.LogError("LogFilePath must be specified if ReplaceDatabase is true.");
return;
}
string primaryDataFileName = (!string.IsNullOrEmpty(this.PrimaryDataFileName)) ? this.PrimaryDataFileName : this.DatabaseItem.ItemSpec;
this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "Restoring SQL {2}: {0} from {1}", this.DatabaseItem.ItemSpec, this.DataFilePath.GetMetadata("FullPath"), this.RestoreAction));
Restore sqlRestore = new Restore { Database = this.DatabaseItem.ItemSpec, Action = this.restoreAction, PercentCompleteNotification = this.NotificationInterval, ReplaceDatabase = this.ReplaceDatabase };
sqlRestore.Devices.AddDevice(this.DataFilePath.GetMetadata("FullPath"), DeviceType.File);
sqlRestore.PercentComplete += this.ProgressEventHandler;
if (string.IsNullOrEmpty(this.LogName))
{
this.LogName = primaryDataFileName + "_log";
}
// add primary data file
sqlRestore.RelocateFiles.Add(new RelocateFile(primaryDataFileName, (this.NewDataFilePath != null) ? this.NewDataFilePath.GetMetadata("FullPath") : this.DataFilePath.GetMetadata("FullPath")));
// add log file, if path provided
if (this.LogFilePath != null)
{
sqlRestore.RelocateFiles.Add(new RelocateFile(this.LogName, this.LogFilePath.GetMetadata("FullPath")));
}
// add secondary data file, if name and path provided
if (!string.IsNullOrEmpty(this.SecondaryDataFileName) && this.SecondaryDataFilePath != null)
{
sqlRestore.RelocateFiles.Add(new RelocateFile(this.SecondaryDataFileName, this.SecondaryDataFilePath.GetMetadata("FullPath")));
}
sqlRestore.SqlRestore(this.sqlServer);
}
private void btnRestore_Click(object sender, RoutedEventArgs e)
{
string blankDBFile = string.Empty;
string dbScriptsDefaultPath = string.Empty;
string backupFileName = string.Empty;
string sSQLServerDetails = string.Empty;
bool bDBExists = false;
try
{
Cursor = System.Windows.Input.Cursors.Wait;
sSQLServerDetails = GetConnectionString();
bDBExists = DBSettings.CheckDBExists(sSQLServerDetails, txtDataBases.Text, 60);
if (bDBExists == true)
{
MessageBox.ShowText(string.Format("{0} {1}", txtDataBases.Text, FindResource("MessageID50")), BMC_Icon.Information);
LogManager.WriteLog(string.Format("{0} {1}", txtDataBases.Text, FindResource("MessageID50")), LogManager.enumLogLevel.Info);
}
else
{
dbScriptsDefaultPath = ConfigurationManager.AppSettings.Get("DBScriptsDefaultPath");
if (this.strType.ToUpper() == "EXCHANGE")
{
blankDBFile = ConfigurationManager.AppSettings.Get("ExchangeBlankDB");
}
if (this.strType.ToUpper() == "TICKETING")
{
blankDBFile = ConfigurationManager.AppSettings.Get("TicketingBlankDB");
}
if (this.strType.ToUpper() == "EXTSYSMSG")
{
blankDBFile = ConfigurationManager.AppSettings.Get("EXTSYSMSGBlankDB");
}
backupFileName = string.Format("{0}\\{1}", dbScriptsDefaultPath, blankDBFile);
// Create a new connection to the Server
ServerConnection serverConnection = new ServerConnection(cmbServers.SelectedItem.ToString());
// Log in using SQL authentication instead of Windows authentication
serverConnection.LoginSecure = false;
// Give the login username
serverConnection.Login = txtUsername.Text;
// Give the login password
serverConnection.Password = txtPassword.Password;
// Create a new SQL Server object using the connection we created
Server server = new Server(serverConnection);
// Create a new database restore operation
Restore rstDatabase = new Restore();
// Set the restore type to a database restore
rstDatabase.Action = RestoreActionType.Database;
// Set the database that we want to perform the restore on
rstDatabase.Database = txtDataBases.Text;
// Set the backup device from which we want to restore the db
BackupDeviceItem bkpDevice = new BackupDeviceItem(backupFileName, DeviceType.File);
// Add the backup device to the restore type
rstDatabase.Devices.Add(bkpDevice);
// Optional. ReplaceDatabase property ensures that any existing copy of the database is overwritten.
rstDatabase.ReplaceDatabase = true;
// Perform the restore
rstDatabase.SqlRestore(server);
LogManager.WriteLog(string.Format("{0} - {1}", "Database Restore Complete. Running Updgrade Scripts for database", txtDataBases.Text), LogManager.enumLogLevel.Info);
if (this.strType.ToUpper() == "EXCHANGE" | this.strType.ToUpper() == "TICKETING")
{
if (Convert.ToBoolean(ConfigurationManager.AppSettings.Get("AutoRunUpgradeScriptAfterDBRestore")))
{
try
{
RunDatabaseUpgradeScripts();
}
catch (Exception ex)
{
ExceptionManager.Publish(ex);
if (this.strType.ToUpper() == "EXCHANGE")
{
MessageBox.ShowBox("MessageID106", BMC_Icon.Error);
}
if (this.strType.ToUpper() == "TICKETING")
{
MessageBox.ShowBox("MessageID107", BMC_Icon.Error);
}
}
}
LogManager.WriteLog(string.Format("{0} - {1}", "Updgrade Scripts run successfully for database", txtDataBases.Text), LogManager.enumLogLevel.Info);
}
MessageBox.ShowText(string.Format("{0} {1} {2}.", FindResource("MessageID53"), txtDataBases.Text, FindResource("MessageID54")), BMC_Icon.Information);
}
}
catch (Exception ex)
{
MessageBox.ShowBox("MessageID74", BMC_Icon.Error);
ExceptionManager.Publish(ex);
}
finally
{
btnRestore.IsEnabled = true;
Cursor = System.Windows.Input.Cursors.Arrow;
}
}
