public static void CopyFile(string from, string to)
{
FileInfo MyFileInfo = new FileInfo(from);
String _Volume = MyFileInfo.Directory.Root.Name;
// VSS step 1: Initialize
IVssImplementation _vssImplementation = VssUtils.LoadImplementation();
IVssBackupComponents _backup = _vssImplementation.CreateVssBackupComponents();
_backup.InitializeForBackup(null);
// VSS step 2: Getting Metadata from all the VSS writers
_backup.GatherWriterMetadata();
// VSS step 3: VSS Configuration
_backup.SetContext(VssVolumeSnapshotAttributes.Persistent | VssVolumeSnapshotAttributes.NoAutoRelease);
_backup.SetBackupState(false, true, Alphaleonis.Win32.Vss.VssBackupType.Full, false);
// VSS step 4: Declaring the Volumes that we need to use in this beckup.
// The Snapshot is a volume element (Here come the name "Volume Shadow-Copy")
// For each file that we nee to copy we have to make sure that the propere volume is in the "Snapshot Set"
Guid MyGuid01 = _backup.StartSnapshotSet();
Guid MyGuid02 = _backup.AddToSnapshotSet(_Volume, Guid.Empty);
// VSS step 5: Preparation (Writers & Provaiders need to start preparation)
_backup.PrepareForBackup();
// VSS step 6: Create a Snapshot For each volume in the "Snapshot Set"
_backup.DoSnapshotSet();
_backup.ExposeSnapshot(MyGuid02, null, VssVolumeSnapshotAttributes.ExposedLocally, "L:");
// VSS step 8: Copy Files!
/***********************************
* /* Now we start to copy the files/folders/disk!
* /* Execution time can depend on what we are copying
* /* We can copy one element or several element.
* /* As long as we are working under the same snapshot,
* /* the element should be in consist state from the same point-in-time
* /***********************************/
String sVSSFile1 = from.Replace(_Volume, @"L:\");
if (File.Exists(sVSSFile1))
{
System.IO.File.Copy(sVSSFile1, to + @"\" + System.IO.Path.GetFileName(from), true);
}
// VSS step 9: Delete the snapshot (using the Exposed Snapshot name)
foreach (VssSnapshotProperties prop in _backup.QuerySnapshots())
{
if (prop.ExposedName == @"L:\")
{
Console.WriteLine("prop.ExposedNam Found!");
_backup.DeleteSnapshot(prop.SnapshotId, true);
}
}
_backup = null;
}
private static void Zip()
{
Log2 vssLog = new Log2(nameof(AddonsBackup) + " - VSS Service");
// get free drive letter
string driveLetter = new string[] { "P:", "Q:", "R:", "S:", "T:", "U:", "V:", "W:" }.FirstOrDefault(l => !DriveInfo.GetDrives().Select(m => m.RootDirectory.Name).Contains(l));
if (driveLetter == default(string))
{
throw new IOException("Can't find free drive letter!");
}
vssLog.Info($"Free drive letter: {driveLetter}");
// making VSS snapshot
IVssImplementation vssImplementation = VssUtils.LoadImplementation();
IVssBackupComponents backupComponents = vssImplementation.CreateVssBackupComponents();
backupComponents.InitializeForBackup(null);
vssLog.Info("VssBackupComponents is initialized");
Guid backupGuid1 = Guid.Empty;
try
{
backupComponents.GatherWriterMetadata();
backupComponents.SetContext(VssVolumeSnapshotAttributes.Persistent | VssVolumeSnapshotAttributes.NoAutoRelease);
backupComponents.SetBackupState(false, true, VssBackupType.Full, false);
vssLog.Info("VssBackupComponents is set up");
backupComponents.StartSnapshotSet();
backupGuid1 = backupComponents.AddToSnapshotSet(new DirectoryInfo(_settings.WoWDirectory).Root.Name, Guid.Empty);
backupComponents.PrepareForBackup();
backupComponents.DoSnapshotSet();
vssLog.Info("Snapshot is taken");
backupComponents.ExposeSnapshot(backupGuid1, null, VssVolumeSnapshotAttributes.ExposedLocally, driveLetter);
// zipping
string zipPath = $"{_settings.WoWAddonsBackupPath}\\AddonsBackup_{DateTime.UtcNow:yyyyMMdd_HHmmss}.zip";
log.Info("Zipping to file: " + zipPath);
using (ZipFile zip = new ZipFile(zipPath, Encoding.UTF8))
{
zip.CompressionLevel = (CompressionLevel)_settings.WoWAddonsBackupCompressionLevel;
foreach (string dirName in FoldersToArchive)
{
zip.AddDirectory(_settings.WoWDirectory.Replace(new DirectoryInfo(_settings.WoWDirectory).Root.Name, $"{driveLetter}\\") + "\\" + dirName, "\\" + dirName);
}
zip.SaveProgress += AddonsBackup_SaveProgress;
var processPriority = Process.GetCurrentProcess().PriorityClass;
Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.BelowNormal;
zip.Save();
Process.GetCurrentProcess().PriorityClass = processPriority;
zip.SaveProgress -= AddonsBackup_SaveProgress;
}
}
finally
{
VssSnapshotProperties existingSnapshot = backupComponents.QuerySnapshots().FirstOrDefault(l => l.SnapshotId == backupGuid1);
if (existingSnapshot == default(VssSnapshotProperties))
{
vssLog.Error($"Can't delete snapshot {backupGuid1}");
}
else
{
backupComponents.DeleteSnapshot(existingSnapshot.SnapshotId, true);
backupComponents.Dispose();
vssLog.Info($"Snapshot is deleted ({existingSnapshot.SnapshotId})");
}
GC.Collect();
}
}
private void Main()
{
string sourceFolder = PathHelper.AppendSeparator(_session.SourceFolder); // C:\, C:\Folder\, \\Server\Share\, \\Server\Share\Folder\
string volume = PathHelper.RemoveTrailingSeparator(Path.GetPathRoot(sourceFolder)); // C:, C:, \\Server\Share, \\Server\Share
string pathFromRoot = PathHelper.RemoveTrailingSeparator(sourceFolder.Substring(volume.Length)); // "", \Folder, "", \Folder
if (pathFromRoot.Length == 0)
{
pathFromRoot = null; // null, \Folder, null, \Folder
}
try
{
// helper function throwing an ObjectDisposedException if _disposeEvent is currently signaled
Action CheckForDisposeRequest = () => { if (_disposeEvent.WaitOne(0))
{
throw new ObjectDisposedException("VscThread");
}
};
CheckForDisposeRequest();
_backup = VssUtils.LoadImplementation().CreateVssBackupComponents();
_backup.InitializeForBackup(null);
_backup.SetContext(VssSnapshotContext.Backup);
_backup.SetBackupState(false, false, VssBackupType.Copy, false);
CheckForDisposeRequest();
_backup.GatherWriterMetadata();
CheckForDisposeRequest();
_snapshotSetID = _backup.StartSnapshotSet();
_volumeSnapshotID = _backup.AddToSnapshotSet(PathHelper.AppendSeparator(volume));
CheckForDisposeRequest();
_backup.PrepareForBackup();
VerifyWriterStatus();
CheckForDisposeRequest();
// create the snapshot
_backup.DoSnapshotSet();
VerifyWriterStatus();
// mount the source folder as file share
// (non-persistent shadow copies cannot be mounted locally on a drive or folder)
string shareName = _backup.ExposeSnapshot(_volumeSnapshotID, pathFromRoot,
VssVolumeSnapshotAttributes.ExposedRemotely, null);
_session._mountPoint = @"\\localhost\" + shareName;
CheckForDisposeRequest();
}
catch (ObjectDisposedException) // by CheckForDisposeRequest()
{
Cleanup();
return;
}
catch (Exception e)
{
Cleanup();
string msg = (e is UnauthorizedAccessException
? "You lack the required privileges to create a volume shadow copy.\nPlease restart RoboMirror as administrator."
: "The volume shadow copy could not be created:\n\n" + e.Message);
_session.OnError(msg);
return;
}
// fire the Ready event
try { _session.OnReady(); }
// on unhandled exception by Ready event handler: Cleanup() before rethrowing
catch { Cleanup(); throw; }
// wait for Dispose() signal
_disposeEvent.WaitOne();
Cleanup();
}
//edit 05.04.2017
public void StartDiffBackup()
{
UpdateSosttask(2);
IVssBackupComponents backup = null;
string namedriver = "";
Boolean successtask = true;
try
{
if (DTask.Shadow == 1)
{
string[] massdrives = { "A:\\", "B:\\", "D:\\", "E:\\", "I:\\", "K:\\", "L:\\", "M:\\", "N:\\", "O:\\", "P:\\" };
string havedriver = "";
DriveInfo[] drives = DriveInfo.GetDrives();
foreach (DriveInfo d in drives)
{
havedriver = havedriver + d.Name;
}
foreach (string strdriver in massdrives)
{
if (!havedriver.Contains(strdriver))
{
namedriver = strdriver;
}
}
FileInfo MyFileInfo = new FileInfo(DTask.Source);
String _Volume = MyFileInfo.Directory.Root.Name;
IVssImplementation _vssImplementation = VssUtils.LoadImplementation();
backup = _vssImplementation.CreateVssBackupComponents();
backup.InitializeForBackup(null);
backup.GatherWriterMetadata();
backup.SetContext(VssVolumeSnapshotAttributes.Persistent | VssVolumeSnapshotAttributes.NoAutoRelease);
backup.SetBackupState(false, true, Alphaleonis.Win32.Vss.VssBackupType.Full, false);
Guid MyGuid01 = backup.StartSnapshotSet();
Guid MyGuid02 = backup.AddToSnapshotSet(_Volume, Guid.Empty);
backup.PrepareForBackup();
backup.DoSnapshotSet();
backup.ExposeSnapshot(MyGuid02, null, VssVolumeSnapshotAttributes.ExposedLocally, namedriver.Remove(2, 1));
DTask.Source = DTask.Source.Replace(_Volume, namedriver);
}
StringWriter SW = new StringWriter();
StringWriter Skip_file_log = new StringWriter();
string time_today = DateTime.Now.Date.ToShortDateString();
ZipFile zf = new ZipFile(DTask.Dest + "\\" + DTask.Taskname + "_" + time_today.Replace(".", "-") + "." + DTask.Extension);
zf.ProvisionalAlternateEncoding = Encoding.GetEncoding("cp866");
if (DTask.Password != "no")
{
zf.Password = DTask.Password;
}
zf.UseZip64WhenSaving = Zip64Option.AsNecessary;
zf.ZipErrorAction = ZipErrorAction.Skip;
zf.StatusMessageTextWriter = Skip_file_log;
string[] massexeption;
string[] separator = { Environment.NewLine };
massexeption = DTask.Exeption.Split(separator, StringSplitOptions.RemoveEmptyEntries);
Stack <string> dirs = new Stack <string>(20);
string root = DTask.Exeption;
if (!Directory.Exists(root))
{
throw new ArgumentException();
}
dirs.Push(root);
while (dirs.Count > 0)
{
string currentDir = dirs.Pop();
string[] subDirs;
try
{
subDirs = Directory.GetDirectories(currentDir);
}
catch (UnauthorizedAccessException e)
{
SW.WriteLine("Нет доступа к файлу или каталогу: " + currentDir);
successtask = false;
continue;
}
catch (DirectoryNotFoundException e)
{
SW.WriteLine("Не найден файл или каталог: " + currentDir);
successtask = false;
continue;
}
catch (PathTooLongException e)
{
SW.WriteLine("Слишком длинный путь или имя файла: " + currentDir);
successtask = false;
continue;
}
string[] files = null;
try
{
files = Directory.GetFiles(currentDir);
}
catch (UnauthorizedAccessException e)
{
SW.WriteLine(e.Message);
successtask = false;
continue;
}
catch (DirectoryNotFoundException e)
{
SW.WriteLine(e.Message);
successtask = false;
continue;
}
if (DTask.Exeption == "no")
{
foreach (string file in files)
{
try
{
FileInfo fi = new FileInfo(file);
if (fi.LastWriteTime > DTask.DateBeginBackup)
{
zf.AddFile(file, Path.GetDirectoryName(file).Replace(DTask.Source, string.Empty));
}
}
catch (FileNotFoundException e)
{
SW.WriteLine("Не найден файл: " + file);
successtask = false;
continue;
}
catch (PathTooLongException e)
{
SW.WriteLine("Слишком длинный путь или имя файла: " + file);
successtask = false;
continue;
}
}
}
else
{
int excludeflag = 0;
foreach (string file in files)
{
try
{
excludeflag = 0;
foreach (var exep in massexeption)
{
if (Path.GetFullPath(file).Contains(exep))
{
excludeflag = 1;
break;
}
}
if (excludeflag == 0)
{
FileInfo fi = new FileInfo(file);
if (fi.LastWriteTime > DTask.DateBeginBackup)
{
zf.AddFile(file, Path.GetDirectoryName(file).Replace(DTask.Source, string.Empty));
}
}
}
catch (FileNotFoundException e)
{
SW.WriteLine("Не найден файл: " + file);
successtask = false;
continue;
}
catch (PathTooLongException e)
{
SW.WriteLine("Слишком длинный путь или имя файла: " + file);
successtask = false;
continue;
}
}
}
foreach (string str in subDirs)
{
dirs.Push(str);
}
}
zf.Save();
zf.Dispose();
if (successtask)
{
UpdateSosttask(4);
}
else
{
UpdateSosttask(5);
}
if (DTask.Shadow == 1)
{
foreach (VssSnapshotProperties prop in backup.QuerySnapshots())
{
if (prop.ExposedName == namedriver)
{
backup.DeleteSnapshot(prop.SnapshotId, true);
}
}
backup = null;
}
string strLine;
int CountSkip = 0;
StringReader stringreader = new StringReader(SW.ToString());
while (true)
{
strLine = stringreader.ReadLine();
if (strLine != null)
{
CountSkip++;
BDAL.OpenConnection();
BDAL.AddDiffLog(strLine, CurrentDate, DTask.Idtask, 0);
BDAL.CloseConnection();
}
else
{
break;
}
}
string strLine2;
StringReader stringreader2 = new StringReader(Skip_file_log.ToString());
while (true)
{
strLine2 = stringreader2.ReadLine();
if (strLine2 != null)
{
if (strLine2.Contains("Skipping"))
{
CountSkip++;
BDAL.OpenConnection();
BDAL.AddDiffLog(strLine2, CurrentDate, DTask.Idtask, 0);
BDAL.CloseConnection();
}
}
else
{
break;
}
}
if (CountSkip > 0)
{
UpdateSosttask(5);
}
string msg = "Завершено успешно";
BDAL.OpenConnection();
BDAL.AddDiffLog(msg, CurrentDate, DTask.Idtask, 1);
BDAL.CloseConnection();
DeleteDimeLive();
if (DTask.Ftp == 1)
{
try
{
UpdateSosttask(2);
FtpClient client = new FtpClient();
StreamReader sr = File.OpenText(AppDomain.CurrentDomain.BaseDirectory + "ftp_sett.ini");
client.PassiveMode = true; //Включаем пассивный режим.
int TimeoutFTP = 30000; //Таймаут.
string FTP_SERVER = sr.ReadLine();
int FTP_PORT = Convert.ToInt32(sr.ReadLine());
string FTP_USER = sr.ReadLine();
string FTP_PASSWORD = Decrypt(sr.ReadLine(), "OFRna73");
string FTP_FOLDER = sr.ReadLine();
client.Connect(TimeoutFTP, FTP_SERVER, FTP_PORT);
client.Login(TimeoutFTP, FTP_USER, FTP_PASSWORD);
if (FTP_FOLDER != "not_folder")
{
client.ChangeDirectory(TimeoutFTP, FTP_FOLDER);
}
client.PutFile(TimeoutFTP, zf.Name.Substring(zf.Name.IndexOf(DTask.Taskname)), zf.Name);
sr.Close();
client.Disconnect(TimeoutFTP);
msg = "Копирование архива на FTP сервер завершено успешно";
BDAL.OpenConnection();
BDAL.AddDiffLog(msg, CurrentDate, DTask.Idtask, 1);
BDAL.CloseConnection();
UpdateSosttask(4);
}
catch (Exception ex)
{
BDAL.OpenConnection();
BDAL.AddDiffLog(ex.ToString(), CurrentDate, DTask.Idtask, 0);
BDAL.CloseConnection();
UpdateSosttask(3);
}
}
}
catch (Exception ex)
{
Add_Diff_Log_Error(ex.Message);
try
{
if (DTask.Shadow == 1)
{
foreach (VssSnapshotProperties prop in backup.QuerySnapshots())
{
if (prop.ExposedName == namedriver)
{
backup.DeleteSnapshot(prop.SnapshotId, true);
}
}
backup = null;
}
}
catch
{
}
}
}
public void Backup(Tuple <string, string> paths)
{
String _Source1 = paths.Item1;
String _Destination = paths.Item2;
FileInfo MyFileInfo = new FileInfo(_Source1);
String _Volume = MyFileInfo.Directory.Root.Name;
IVssImplementation _vssImplementation = VssUtils.LoadImplementation();
IVssBackupComponents _backup = _vssImplementation.CreateVssBackupComponents();
_backup.InitializeForBackup(null);
_backup.GatherWriterMetadata();
_backup.SetContext(VssVolumeSnapshotAttributes.Persistent | VssVolumeSnapshotAttributes.NoAutoRelease);
_backup.SetBackupState(false, true, Alphaleonis.Win32.Vss.VssBackupType.Full, false);
Guid MyGuid01 = _backup.StartSnapshotSet();
Guid MyGuid02 = _backup.AddToSnapshotSet(_Volume, Guid.Empty);
// VSS step 5: Preparation (Writers & Provaiders need to start preparation)
_backup.PrepareForBackup();
// VSS step 6: Create a Snapshot For each volume in the "Snapshot Set"
_backup.DoSnapshotSet();
// GET drive labels in use
var d_name = " ";
var d_nam = " ";
DriveInfo[] allDrives = DriveInfo.GetDrives();
foreach (DriveInfo d in allDrives)
{
if (d.Name != @"A:\")
{
d_name = @"A:\";
d_nam = @"A:";
}
else if (d.Name != @"B:\")
{
d_name = @"B:\";
d_nam = @"A:";
}
else if (d.Name != @"Z:\")
{
d_name = @"Z:\";
d_nam = @"Z:";
}
}
_backup.ExposeSnapshot(MyGuid02, null, VssVolumeSnapshotAttributes.ExposedLocally, d_nam);
String sVSSFile1 = _Source1.Replace(_Volume, d_name);
if (File.Exists(sVSSFile1))
{
System.IO.File.Copy(sVSSFile1, _Destination + @"\" + System.IO.Path.GetFileName(_Source1), true);
}
foreach (VssSnapshotProperties prop in _backup.QuerySnapshots())
{
if (prop.ExposedName == d_name)
{
Console.WriteLine("prop.ExposedNam Found!");
_backup.DeleteSnapshot(prop.SnapshotId, true);
}
}
_backup = null;
return;
}
/// <summary>
/// This is only first test of using AlphaVSS project.
/// Please make sure you read thoroughly and understand the code's comments and adapt it to your system and needs.
/// We are using constant links for "source files to copy" and for the "destination folder".
/// In any dynamic application you should get those values from the user.
///
/// building your project:
/// -----------------------
/// 1. Creating New Project
/// * Open Visual Studio As Administrator!
/// * Chose create new project type "Console application"
/// * use Dot.Net 4 framework
/// * named the project Ariely_AlphaVSS_Sample01
/// 2. Add NuGet Package named alphavss (use the search on-line option, and install the package)
/// 3. Go over the Code's comment and understand it!!! After you are ready you can use it.
/// 4. add "using Alphaleonis.Win32.Vss;" & "using System.IO;"
/// </summary>
/// <param name="args"></param>
public static void copy(string destination)
{
// Getting information on the files to copy (This is not part of the VSS action)
string userName = Environment.UserName;
string baseAddress = @"C:\Users\{0}\AppData\Local\Microsoft\Windows\WebCache\WebCacheV01.dat";
string directory = string.Format(baseAddress, userName);
String _Source1 = directory;
String _Destination = destination;
FileInfo MyFileInfo = new FileInfo(_Source1);
String _Volume = MyFileInfo.Directory.Root.Name;
// VSS step 1: Initialize
IVssImplementation _vssImplementation = VssUtils.LoadImplementation();
IVssBackupComponents _backup = _vssImplementation.CreateVssBackupComponents();
_backup.InitializeForBackup(null);
// VSS step 2: Getting Metadata from all the VSS writers
_backup.GatherWriterMetadata();
// VSS step 3: VSS Configuration
_backup.SetContext(VssVolumeSnapshotAttributes.Persistent | VssVolumeSnapshotAttributes.NoAutoRelease);
_backup.SetBackupState(false, true, Alphaleonis.Win32.Vss.VssBackupType.Full, false);
// VSS step 4: Declaring the Volumes that we need to use in this beckup.
// The Snapshot is a volume element (Here come the name "Volume Shadow-Copy")
// For each file that we nee to copy we have to make sure that the propere volume is in the "Snapshot Set"
Guid MyGuid01 = _backup.StartSnapshotSet();
Guid MyGuid02 = _backup.AddToSnapshotSet(_Volume, Guid.Empty);
// VSS step 5: Preparation (Writers & Provaiders need to start preparation)
_backup.PrepareForBackup();
// VSS step 6: Create a Snapshot For each volume in the "Snapshot Set"
_backup.DoSnapshotSet();
/***********************************
* /* At this point we have a snapshot!
* /* This action should not take more then 60 second, regardless of file or disk size.
* /* THe snapshot is not a backup or any copy!
* /* please more information at http://technet.microsoft.com/en-us/library/ee923636.aspx
* /***********************************/
// VSS step 7: Expose Snapshot
/***********************************
* /* Snapshot path look like:
* \\?\Volume{011682bf-23d7-11e2-93e7-806e6f6e6963}\
* The build in method System.IO.File.Copy do not work with path like this,
* Therefor, we are going to Expose the Snapshot to our application,
* by mapping the Snapshot to new virtual volume
* - Make sure that you are using a volume that is not already exist
* - This is only for learning purposes. usually we will use the snapshot directly as i show in the next example in the blog
* /***********************************/
_backup.ExposeSnapshot(MyGuid02, null, VssVolumeSnapshotAttributes.ExposedLocally, "S:");
// VSS step 8: Copy Files!
/***********************************
* /* Now we start to copy the files/folders/disk!
* /* Execution time can depend on what we are copying
* /* We can copy one element or several element.
* /* As long as we are working under the same snapshot,
* /* the element should be in consist state from the same point-in-time
* /***********************************/
String sVSSFile1 = _Source1.Replace(_Volume, @"S:\");
if (File.Exists(sVSSFile1))
{
System.IO.File.Copy(sVSSFile1, _Destination + @"\" + System.IO.Path.GetFileName(_Source1), true);
}
// VSS step 9: Delete the snapshot (using the Exposed Snapshot name)
foreach (VssSnapshotProperties prop in _backup.QuerySnapshots())
{
if (prop.ExposedName == @"S:\")
{
Console.WriteLine("prop.ExposedNam Found!");
_backup.DeleteSnapshot(prop.SnapshotId, true);
}
}
_backup = null;
}
public bool Create(List<String> Volumes)
{
try
{
if (OperatingSystemInfo.ProcessorArchitecture == ProcessorArchitecture.X64 || OperatingSystemInfo.ProcessorArchitecture == ProcessorArchitecture.IA64)
{
if (!System.IO.File.Exists(System.Windows.Forms.Application.StartupPath + "\\AlphaVSS.60.x64.dll"))
{
HelperFunctions.ShowError(Translations.Get("WrongVersion64"));
Settings.ShadowCopy = false;
return false;
}
}
else
{
if (!System.IO.File.Exists(System.Windows.Forms.Application.StartupPath + "\\AlphaVSS.60.x86.dll"))
{
HelperFunctions.ShowError(Translations.Get("WrongVersion32"));
Settings.ShadowCopy = false;
return false;
}
}
if (GlobalData.SettingsInAppData)
{
_OldSnapshotSetIdsPath = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "\\RoboGapp\\SnapshotIds.dat";
}
else
{
_OldSnapshotSetIdsPath = System.Windows.Forms.Application.StartupPath + "\\SnapshotIds.dat";
}
Abort();
HelperFunctions.WriteLog(Translations.Get("LoadingVSSImplementation"));
IVssImplementation VssImplementation = null;
try
{
VssImplementation = VssUtils.LoadImplementation();
}
catch (Exception ex)
{
HelperFunctions.ShowError(Translations.Get("ShadowCopyError") + "\n\n" + Translations.Get("Error") + "\n" + ex.Message);
if (OperatingSystemInfo.ProcessorArchitecture == ProcessorArchitecture.X64)
{
HelperFunctions.ShowError(Translations.Get("VCRedist64"));
}
else if (OperatingSystemInfo.ProcessorArchitecture == ProcessorArchitecture.IA64)
{
HelperFunctions.ShowError(Translations.Get("VCRedistIA64"));
}
else
{
HelperFunctions.ShowError(Translations.Get("VCRedist32"));
}
return false;
}
HelperFunctions.WriteLog(Translations.Get("CreatingBackupComponents"));
_BackupComponents = VssImplementation.CreateVssBackupComponents();
HelperFunctions.WriteLog(Translations.Get("InitializingVSSBackup"));
_BackupComponents.InitializeForBackup(null);
if (OperatingSystemInfo.OSVersionName > OSVersionName.WindowsServer2003)
{
HelperFunctions.WriteLog(Translations.Get("SettingVSSContext"));
_BackupComponents.SetContext(VssVolumeSnapshotAttributes.Persistent | VssVolumeSnapshotAttributes.NoAutoRelease);
}
HelperFunctions.WriteLog(Translations.Get("SettingVSSBackupState"));
_BackupComponents.SetBackupState(false, true, VssBackupType.Full, false);
HelperFunctions.WriteLog(Translations.Get("GatheringWriterMetadata"));
_BackupComponents.GatherWriterMetadata();
HelperFunctions.WriteLog(Translations.Get("CreatingSnapshotSet"));
_SnapshotSetId = _BackupComponents.StartSnapshotSet();
_SnapshotIds.Clear();
for (int i = 0; i < Volumes.Count; i++)
{
HelperFunctions.WriteLog(Translations.Get("AddingToSnapshotSet1") + Volumes[i] + Translations.Get("AddingToSnapshotSet2"));
Guid SnapshotId = _BackupComponents.AddToSnapshotSet(Volumes[i], Guid.Empty);
_SnapshotIds.Add(SnapshotId);
}
HelperFunctions.WriteLog(Translations.Get("SavingSnapshotSetID"));
SaveSnapshotSetId();
HelperFunctions.WriteLog(Translations.Get("PreparingVSSBackup"));
_BackupComponents.PrepareForBackup();
HelperFunctions.WriteLog(Translations.Get("CreatingVSSSnapshots"));
_BackupComponents.DoSnapshotSet();
HelperFunctions.WriteLog(Translations.Get("ExposingSnapshots"));
GlobalData.ShadowCopyMounts.Clear();
List<String> FreeDriveLetters = IO.GetFreeDriveLetters();
String Path = System.Windows.Forms.Application.StartupPath;
if (OperatingSystemInfo.OSVersionName > OSVersionName.WindowsServer2003)
{
try
{
if (System.IO.File.Exists(Path + "\\write.test")) File.Delete(Path + "\\write.test");
using (System.IO.File.Create(Path + "\\write.test")) { }
File.Delete(Path + "\\write.test");
}
catch
{
Path = IO.GetCommonApplicationDataPath();
if (Path == "")
{
HelperFunctions.ShowError(Translations.Get("ExposingSnapshotsDirError"));
return false;
}
}
}
for (int i = 0; i < Volumes.Count; i++)
{
if (OperatingSystemInfo.OSVersionName <= OSVersionName.WindowsServer2003)
{
GlobalData.ShadowCopyMounts.Add(Volumes[i], FreeDriveLetters[i]);
DefineDosDevice(0, FreeDriveLetters[i].Substring(0, 2), _BackupComponents.GetSnapshotProperties(_SnapshotIds[i]).SnapshotDeviceObject);
}
else
{
DriveInfo DriveInfo = null;
if (Path == System.Windows.Forms.Application.StartupPath)
{
DriveInfo = DriveInfo.GetDrives().FirstOrDefault((DriveInfo DI) => DI.RootDirectory.ToString() == System.Windows.Forms.Application.StartupPath.Substring(0, 3));
if (DriveInfo == null || DriveInfo.DriveType == DriveType.Network)
{
Path = IO.GetCommonApplicationDataPath();
if (Path == "")
{
HelperFunctions.ShowError(Translations.Get("ExposingSnapshotsDirError"));
return false;
}
}
}
GlobalData.ShadowCopyMounts.Add(Volumes[i], Path + "\\mnt" + i.ToString() + "\\");
if (System.IO.Directory.Exists(GlobalData.ShadowCopyMounts[Volumes[i]]))
{
try
{
Directory.Delete(GlobalData.ShadowCopyMounts[Volumes[i]], false);
}
catch (Exception ex)
{
HelperFunctions.ShowError(ex);
return false;
}
}
Directory.Create(GlobalData.ShadowCopyMounts[Volumes[i]]);
_BackupComponents.ExposeSnapshot(_SnapshotIds[i], null, VssVolumeSnapshotAttributes.ExposedLocally, GlobalData.ShadowCopyMounts[Volumes[i]]);
}
}
HelperFunctions.WriteLog(Translations.Get("SnapshotSuccessful"));
return true;
}
catch (Exception ex)
{
HelperFunctions.ShowError(ex);
return false;
}
}