/// <summary> /// The final phase of the backup involves some cleanup steps. /// If we're in component mode, we're supposed to notify each of the /// writers of the outcome of the backup. Once that's done, or if /// we're not in component mode, we send the BackupComplete event to /// all of the writers. /// </summary> /// <param name="succeeded">Success value for all of the writers.</param> void Complete(bool succeeded) { if (ComponentMode) { // As before, we iterate through all of the writers on the system. // A more efficient method might only iterate through those writers // that were actually involved in this backup. IList <IVssExamineWriterMetadata> writers = _backup.WriterMetadata; foreach (IVssExamineWriterMetadata metadata in writers) { foreach (IVssWMComponent component in metadata.Components) { // The BackupSucceeded call should mirror the AddComponent // call that was called during the discovery phase. _backup.SetBackupSucceeded( metadata.InstanceId, metadata.WriterId, component.Type, component.LogicalPath, component.ComponentName, succeeded); } } // Finally, we can dispose of the writer metadata. _backup.FreeWriterMetadata(); } try { // The BackupComplete event must be sent to all of the writers. _backup.BackupComplete(); } // Not sure why, but this throws a VSS_BAD_STATE on XP and W2K3. // Per some forum posts about this, I'm just ignoring it. catch (VssBadStateException) { } }
public void DoSnapshot() { try { logger.Debug("Doing snapshot..."); IVssImplementation vssImplementation = VssUtils.LoadImplementation(); backup = vssImplementation.CreateVssBackupComponents(); backup.InitializeForBackup(null); backup.SetBackupState(false, false, VssBackupType.Copy, false); backup.EnableWriterClasses(); backup.GatherWriterMetadata(); backup.GatherWriterStatus(); backup.SetContext(VssSnapshotContext.AppRollback); snapshotSetId = backup.StartSnapshotSet(); String rootPath = Volume.GetUniqueVolumeNameForPath(path); logger.Debug("RootPath: {0}.", rootPath); snapshotId = backup.AddToSnapshotSet(rootPath); backup.PrepareForBackup(); backup.DoSnapshotSet(); //File.WriteAllText(@"d:" + Path.DirectorySeparatorChar + "Document.xml", backup.SaveAsXml()); backup.BackupComplete(); } catch (Exception e) { logger.Error("Error occurred when doing snapshot, info: {0}.", e); } }
private void Cleanup() { if (_session._mountPoint != null) { _backup.BackupComplete(); VerifyWriterStatus(); _session._mountPoint = null; } if (_snapshotSetID != Guid.Empty) { // apparently fails on Windows 2008 - the non-persistent shadow copy // should be deleted as soon as _backup is disposed of anyway, // so just try to explicitly delete the snapshot set and ignore any issues try { _backup.DeleteSnapshotSet(_snapshotSetID, forceDelete: true); } catch { } } if (_backup != null) { _backup.Dispose(); } lock (_disposeEventSyncObject) { _disposeEvent.Dispose(); _disposeEvent = null; } }
// Cleanup Steps private void Complete(bool succeeded) { if (ComponentMode) { // Iterate through all of the writers on the system IList <IVssExamineWriterMetadata> writers = _backup.WriterMetadata; foreach (IVssExamineWriterMetadata metadata in writers) { foreach (IVssWMComponent component in metadata.Components) { // The BackupSucceeded call should mirror the AddComponent call that was called during the discovery phase. _backup.SetBackupSucceeded(metadata.InstanceId, metadata.WriterId, component.Type, component.LogicalPath, component.ComponentName, succeeded); } } // Dispose of the writer metadata. _backup.FreeWriterMetadata(); } try { // The BackupComplete event must be sent to all of the writers. _backup.BackupComplete(); } catch (VssBadStateException ex) { LogService.LogEvent("Error: VssBackup.Complete - " + ex.Message); } }
public void Dispose() { try { if (_mappedDrives != null) { foreach (var d in _mappedDrives) { d.Dispose(); } _mappedDrives = null; } } catch (Exception ex) { Logging.Log.WriteVerboseMessage(LOGTAG, "MappedDriveCleanupError", ex, "Failed during VSS mapped drive unmapping"); } try { _vssBackupComponents?.BackupComplete(); } catch (Exception ex) { Logging.Log.WriteVerboseMessage(LOGTAG, "VSSTerminateError", ex, "Failed to signal VSS completion"); } try { if (_vssBackupComponents != null) { foreach (var g in _volumes.Values) { try { _vssBackupComponents.DeleteSnapshot(g, false); } catch (Exception ex) { Logging.Log.WriteVerboseMessage(LOGTAG, "VSSSnapShotDeleteError", ex, "Failed to close VSS snapshot"); } } } } catch (Exception ex) { Logging.Log.WriteVerboseMessage(LOGTAG, "VSSSnapShotDeleteCleanError", ex, "Failed during VSS esnapshot closing"); } if (_vssBackupComponents != null) { _vssBackupComponents.Dispose(); _vssBackupComponents = null; } }
public void BackupComplete() { try { backup.BackupComplete(); } // Not sure why, but this throws a VSS_BAD_STATE on XP and W2K3. // Per some forum posts about this, I'm just ignoring it. catch (VssBadStateException) { } }
public void Complete(bool succeeded) { try { // The BackupComplete event must be sent to all of the writers. using (IVssAsync async = _backup.BackupComplete()) async.Wait(); } catch (VssBadStateException) { } }
private void RemoveVssSnapshotOfSystemVolume(IVssBackupComponents backupComponents) { if (this.vssSnapshotId != Guid.Empty) { try { backupComponents.BackupComplete(); } catch (VssBadStateException) { } VssSnapshotProperties snapshotInfo = backupComponents.GetSnapshotProperties(this.vssSnapshotId); logger.LogDebug($"Removing snapshot {snapshotInfo.SnapshotDeviceObject}"); backupComponents.DeleteSnapshot(this.vssSnapshotId, true); } }
private void BackupSubset(IDictionary <string, string> vmNamesMapSubset, Options options) { IVssImplementation vssImpl = VssUtils.LoadImplementation(); using (IVssBackupComponents vss = vssImpl.CreateVssBackupComponents()) { RaiseEvent(EventAction.InitializingVSS, null, null); vss.InitializeForBackup(null); vss.SetBackupState(true, true, VssBackupType.Full, false); vss.SetContext(VssSnapshotContext.Backup); // Add Hyper-V writer Guid hyperVwriterGuid = new Guid("66841cd4-6ded-4f4b-8f17-fd23f8ddc3de"); vss.EnableWriterClasses(new Guid[] { hyperVwriterGuid }); vss.GatherWriterMetadata(); IList <IVssWMComponent> components = new List <IVssWMComponent>(); // key: volumePath, value: volumeName. These values are equivalent on a standard volume, but differ in the CSV case IDictionary <string, string> volumeMap = new Dictionary <string, string>(); var wm = vss.WriterMetadata.Where((o) => o.WriterId.Equals(hyperVwriterGuid)).FirstOrDefault(); foreach (var component in wm.Components) { if (vmNamesMapSubset.ContainsKey(component.ComponentName)) { components.Add(component); vss.AddComponent(wm.InstanceId, wm.WriterId, component.Type, component.LogicalPath, component.ComponentName); foreach (var file in component.Files) { string volumeName = null; string volumePath = null; volumePath = Path.GetPathRoot(file.Path).ToUpper(); volumeName = volumePath; if (!volumeMap.ContainsKey(volumePath)) { volumeMap.Add(volumePath, volumeName); } } } } if (components.Count > 0) { Guid vssSet = vss.StartSnapshotSet(); // Key: volumeName, value: snapshotGuid IDictionary <string, Guid> snapshots = new Dictionary <string, Guid>(); foreach (var volumeName in volumeMap.Values) { snapshots.Add(volumeName, vss.AddToSnapshotSet(volumeName, Guid.Empty)); } vss.PrepareForBackup(); RaiseEvent(EventAction.StartingSnaphotSet, components, volumeMap); vss.DoSnapshotSet(); RaiseEvent(EventAction.SnapshotSetDone, components, volumeMap); // key: volumeName, value: snapshotVolumePath IDictionary <string, string> snapshotVolumeMap = new Dictionary <string, string>(); foreach (var kv in snapshots) { snapshotVolumeMap.Add(kv.Key, vss.GetSnapshotProperties(kv.Value).SnapshotDeviceObject); } BackupFiles(components, volumeMap, snapshotVolumeMap, vmNamesMapSubset, options); foreach (var component in components) { vss.SetBackupSucceeded(wm.InstanceId, wm.WriterId, component.Type, component.LogicalPath, component.ComponentName, true); } vss.BackupComplete(); RaiseEvent(EventAction.DeletingSnapshotSet, components, volumeMap); vss.DeleteSnapshotSet(vssSet, true); } } }
/// <inheritdoc /> protected override void Dispose(bool disposing) { if (disposing) { try { if (m_mappedDrives != null) { foreach (var d in m_mappedDrives) { d.Dispose(); } m_mappedDrives = null; } } catch (Exception ex) { Logging.Log.WriteVerboseMessage(LOGTAG, "MappedDriveCleanupError", ex, "Failed during VSS mapped drive unmapping"); } try { m_backup?.BackupComplete(); } catch (Exception ex) { Logging.Log.WriteVerboseMessage(LOGTAG, "VSSTerminateError", ex, "Failed to signal VSS completion"); } try { if (m_backup != null) { foreach (var g in m_volumes.Values) { try { m_backup.DeleteSnapshot(g, false); } catch (Exception ex) { Logging.Log.WriteVerboseMessage(LOGTAG, "VSSSnapShotDeleteError", ex, "Failed to close VSS snapshot"); } } } } catch (Exception ex) { Logging.Log.WriteVerboseMessage(LOGTAG, "VSSSnapShotDeleteCleanError", ex, "Failed during VSS esnapshot closing"); } if (m_backup != null) { m_backup.Dispose(); m_backup = null; } } base.Dispose(disposing); }
public ISnapshot[] CreateVolumeSnapShot(List <FileSystem> volumes, string[] spoPaths, SnapshotSupportedLevel level) { using (new Alphaleonis.Win32.Security.PrivilegeEnabler(Privilege.Backup, Privilege.Restore)){ //PrivilegesManager pm = new PrivilegesManager(); //pm.Grant(); VssBackupType vssLevel = VssBackupType.Full; if (level == SnapshotSupportedLevel.Full) { vssLevel = VssBackupType.Full; } else if (level == SnapshotSupportedLevel.Incremental) { vssLevel = VssBackupType.Incremental; } else if (level == SnapshotSupportedLevel.Differential) { vssLevel = VssBackupType.Differential; } else if (level == SnapshotSupportedLevel.TransactionLog) { vssLevel = VssBackupType.Log; } ArrayList snapshots = new ArrayList(); Metadata = new SPOMetadata(); bool snapshotSuccedeed = false; try{ IVssImplementation vss = VssUtils.LoadImplementation(); backup = vss.CreateVssBackupComponents(); Logger.Append(Severity.DEBUG, "0/6 Initializing Snapshot (" + ((spoPaths == null)? "NON-component mode" : "component mode") + ", level " + level + ")"); backup.InitializeForBackup(null); if (spoPaths == null) // component-less snapshot set { backup.SetBackupState(false, true, VssBackupType.Full, false); } else { backup.SetBackupState(true, true, vssLevel, (vssLevel == VssBackupType.Full)?false:true); } if (OperatingSystemInfo.IsAtLeast(OSVersionName.WindowsServer2003)) { // The only context supported on Windows XP is VssSnapshotContext.Backup backup.SetContext(VssSnapshotContext.AppRollback /*|VssSnapshotContext.All*/); } Logger.Append(Severity.DEBUG, "1/6 Gathering writers metadata and status"); using (IVssAsync async = backup.GatherWriterMetadata()){ async.Wait(); async.Dispose(); } // gather writers status before adding backup set components using (IVssAsync async = backup.GatherWriterStatus()){ async.Wait(); async.Dispose(); } Logger.Append(Severity.DEBUG, "2/6 Adding writers and components"); // Now we add the components (vss writers, writer paths/params) of this snapshot set if (spoPaths != null) { foreach (IVssExamineWriterMetadata writer in backup.WriterMetadata) { foreach (string spo in spoPaths) { //Logger.Append (Severity.TRIVIA, "Searching writer and/or component matching "+spo); int index = spo.IndexOf(writer.WriterName); if (index < 0 && spo != "*") { continue; } bool found = false; Logger.Append(Severity.TRIVIA, "Found matching writer " + writer.WriterName + ", instance name=" + writer.InstanceName); // First we check that the writer's status is OK, else we don't add it to avoid failure of complete snapshot if it's not bool writerOk = false; foreach (VssWriterStatusInfo status in backup.WriterStatus) { if (status.Name == writer.WriterName) { Logger.Append(Severity.TRIVIA, "Checking required writer " + status.Name + ", status=" + status.State.ToString() + ", error state=" + status.Failure.ToString()); if (status.State == VssWriterState.Stable && status.Failure == VssError.Success) // if we get there it means that we are ready to add the wanted component to VSS set { writerOk = true; } else { Logger.Append(Severity.ERROR, "Cannot add writer " + status.Name + " to snapshot set," + " status=" + status.State.ToString() + ". Backup data managed by this writer may not be consistent"); if (LogEvent != null) { LogEvent(this, new LogEventArgs(820, Severity.WARNING, status.Name + ", Status=" + status.State.ToString() + ", Failure=" + status.Failure.ToString())); } } } } if (!writerOk) { if (OperatingSystemInfo.IsAtLeast(OSVersionName.WindowsServer2003)) { backup.DisableWriterClasses(new Guid[] { writer.WriterId }); } continue; } bool addAllComponents = false; if (spo.Length == index + writer.WriterName.Length || spo == "*" || spo == "" + writer.WriterName + @"\*") { addAllComponents = true; } foreach (IVssWMComponent component in writer.Components) { found = false; //Console.WriteLine("createvolsnapshot : current component is :"+component.LogicalPath+@"\"+component.ComponentName); if ((!addAllComponents) && spo.IndexOf(component.LogicalPath + @"\" + component.ComponentName) < 0) { continue; } //Logger.Append (Severity.TRIVIA, "Asked to recursively select all '"+writer.WriterName+"' writer's components"); if (OperatingSystemInfo.IsAtLeast(OSVersionName.WindowsServer2003)) { foreach (VssWMDependency dep in component.Dependencies) { Logger.Append(Severity.TRIVIA, "Component " + component.ComponentName + " depends on component " + dep.ComponentName); } } if (component.Selectable) { backup.AddComponent(writer.InstanceId, writer.WriterId, component.Type, component.LogicalPath, component.ComponentName); } Logger.Append(Severity.INFO, "Added writer '" + writer.WriterName + "' component " + component.ComponentName); found = true; // Second we need to find every drive containing files necessary for writer's backup // and add them to drives list, in case they weren't explicitely selected as part of backuppaths List <VssWMFileDescription> componentFiles = new List <VssWMFileDescription>(); componentFiles.AddRange(component.Files); componentFiles.AddRange(component.DatabaseFiles); componentFiles.AddRange(component.DatabaseLogFiles); foreach (VssWMFileDescription file in componentFiles) { if (string.IsNullOrEmpty(file.Path)) { continue; } //Console.WriteLine ("component file path="+file.Path+", alt backuplocation="+file.AlternateLocation // +", backuptypemask="+file.BackupTypeMask.ToString()+", spec="+file.FileSpecification+", recursive="+file.IsRecursive); // TODO : Reuse GetInvolvedDrives (put it into VolumeManager class) string drive = file.Path.Substring(0, 3).ToUpper(); if (drive.Contains(":") && drive.Contains("\\")) { var searchedVol = from FileSystem vol in volumes where vol.MountPoint.Contains(drive) select vol; //if(!volumes.Contains(drive)){ if (searchedVol == null) { Logger.Append(Severity.INFO, "Select VSS component " + component.LogicalPath + @"\" + component.ComponentName + " requires snapshotting of drive " + drive + ", adding it to the list."); volumes.Add(searchedVol.First()); } break; } } //Logger.Append(Severity.TRIVIA, "Added writer/component "+spo); //break; } //metadata.Metadata.Add(writer.SaveAsXml()); Metadata.Metadata.Add(writer.WriterName, writer.SaveAsXml()); if (found == false) { Logger.Append(Severity.WARNING, "Could not find VSS component " + spo + " which was part of backup paths"); } } } } Logger.Append(Severity.DEBUG, "3/6 Preparing Snapshot "); //backup.SetBackupState(false, true, VssBackupType.Full, false); Guid snapID = backup.StartSnapshotSet(); //Guid volID = new Guid(); foreach (FileSystem volume in volumes) { VSSSnapshot snapshot = new VSSSnapshot(); snapshot.Type = this.Name; Logger.Append(Severity.DEBUG, "Preparing Snapshot of " + volume.MountPoint); if (volume.MountPoint != null && backup.IsVolumeSupported(volume.MountPoint)) { snapshot.Id = backup.AddToSnapshotSet(volume.MountPoint); snapshot.Path = volume.MountPoint; } else // return the fake provider to get at least a degraded backup, better than nothing { Logger.Append(Severity.WARNING, "Volume '" + volume.MountPoint + "' is not snapshottable (or null). Backup will be done without snapshot, risks of data inconsistancy."); ISnapshotProvider fakeSnapProvider = SnapshotProvider.GetProvider("NONE"); List <FileSystem> fakeList = new List <FileSystem>(); fakeList.Add(volume); snapshot = (VSSSnapshot)fakeSnapProvider.CreateVolumeSnapShot(fakeList, null, SnapshotSupportedLevel.Full)[0]; } if (snapshot.Id == System.Guid.Empty) { Logger.Append(Severity.ERROR, "Unable to add drive " + volume.MountPoint + " to snapshot set (null guid)"); } else { Logger.Append(Severity.TRIVIA, "Drive " + volume.MountPoint + " will be snapshotted to " + snapshot.Id); } snapshots.Add(snapshot); } Logger.Append(Severity.DEBUG, "4/6 Calling Prepare..."); using (IVssAsync async = backup.PrepareForBackup()){ async.Wait(); async.Dispose(); } Logger.Append(Severity.DEBUG, "5/6 Snapshotting volumes"); using (IVssAsync async = backup.DoSnapshotSet()){ async.Wait(); async.Dispose(); } //if(OperatingSystemInfo.IsAtLeast(OSVersionName.WindowsServer2003)) foreach (IVssExamineWriterMetadata w in backup.WriterMetadata) { foreach (IVssWMComponent comp in w.Components) { try{ backup.SetBackupSucceeded(w.InstanceId, w.WriterId, comp.Type, comp.LogicalPath, comp.ComponentName, true); Logger.Append(Severity.TRIVIA, "Component " + comp.ComponentName + " has been notified about backup success."); } catch (Exception) { //Logger.Append (Severity.WARNING, "Could not notify component "+comp.ComponentName+" about backup completion : "+se.Message); } } } //Node.Misc.VSSObjectHandle.StoreObject(backup); try{ //on XP backupcomplete consider that we have done with the snapshot and releases it. //if(OperatingSystemInfo.IsAtLeast(OSVersionName.WindowsServer2003)){ backup.BackupComplete(); Metadata.Metadata.Add("_bcd_", backup.SaveAsXml()); //} }catch (Exception bce) { Logger.Append(Severity.WARNING, "Error calling VSS BackupComplete() : " + bce.Message); } using (IVssAsync async = backup.GatherWriterStatus()){ async.Wait(); async.Dispose(); } Logger.Append(Severity.DEBUG, "6/6 Successfully shapshotted volume(s) "); foreach (ISnapshot sn in snapshots) { if (sn.Id == Guid.Empty) { continue; } sn.MountPoint = backup.GetSnapshotProperties(sn.Id).SnapshotDeviceObject; sn.TimeStamp = Utilities.Utils.GetUtcUnixTime(backup.GetSnapshotProperties(sn.Id).CreationTimestamp.ToUniversalTime()); /* * DirectoryInfo snapMountPoint = Directory.CreateDirectory( Path.Combine(Utilities.ConfigManager.GetValue("Backups.TempFolder"), "snapshot_"+sn.Id)); * Logger.Append(Severity.DEBUG, "Mounting shapshotted volume '"+sn.Name+"' to '"+snapMountPoint.FullName+"'"); * backup.ExposeSnapshot(sn.Id, null, VssVolumeSnapshotAttributes.ExposedLocally, snapMountPoint.FullName); * //sn.Path = snapMountPoint.FullName+Path.DirectorySeparatorChar; * //sn.Path = @"\\?\Volume{"+sn.Id+"}"+Path.DirectorySeparatorChar;*/ } } catch (Exception e) { try{ //backup.BackupComplete(); backup.AbortBackup(); } catch (Exception ae) { Logger.Append(Severity.ERROR, "Error trying to cancel VSS snapshot set : " + ae.Message); } // TODO !! report snapshoty failure to hub task Logger.Append(Severity.ERROR, "Error creating snapshot :'" + e.Message + " ---- " + e.StackTrace + "'. Backup will continue without snapshot. Backup of VSS components will fail. !TODO! report that to hub"); backup.Dispose(); throw new Exception(e.Message); } finally{ // TODO !!! reactivate dispose //backup.Dispose(); //pm.Revoke(); } return((ISnapshot[])snapshots.ToArray(typeof(ISnapshot))); } }
/// <summary> /// Makes a recursive snapshot of the directory as it is. /// </summary> /// <param name="baseDirectory">The directory to start in.</param> /// <returns>A file system snapshot</returns> public static SnapshotFilesystem MakeFsSnapshot(System.IO.DirectoryInfo baseDirectory) { DirectoryInfo baseDir = new DirectoryInfo(baseDirectory.FullName); if (!baseDir.Exists) { throw new ArgumentException("Base directory doesn't exist"); } SnapshotFilesystem res = new SnapshotFilesystem(); if (!baseDir.FullName.EndsWith(Path.DirectorySeparatorChar) && !baseDir.FullName.EndsWith(Path.AltDirectorySeparatorChar)) { // Add ending slash to get a uniform output baseDir = new DirectoryInfo(baseDir.FullName + Path.DirectorySeparatorChar); } res.BasePath = baseDir.FullName; res.Items = new LinkedList <SnapshotFilesystemItem>(); // Make VSS // Sequence of calls: http://us.generation-nt.com/answer/volume-shadow-copy-backupcomplete-vss-e-bad-state-help-29094302.html IVssImplementation vssImplementation = VssUtils.LoadImplementation(); IVssBackupComponents backupComponents = vssImplementation.CreateVssBackupComponents(); backupComponents.InitializeForBackup(null); backupComponents.SetContext(VssSnapshotContext.Backup); backupComponents.SetBackupState(false, false, VssBackupType.Copy, false); backupComponents.GatherWriterMetadata(); try { Guid snapshotSetGuid = backupComponents.StartSnapshotSet(); Guid backupVolumeGuid = backupComponents.AddToSnapshotSet(baseDir.Root.FullName); backupComponents.PrepareForBackup(); backupComponents.DoSnapshotSet(); VssSnapshotProperties properties = backupComponents.GetSnapshotProperties(backupVolumeGuid); DirectoryInfo shadowCopyBase = new DirectoryInfo(Path.Combine(properties.SnapshotDeviceObject, Path.GetDirectoryNameWithoutRoot(baseDir.FullName))); if (!shadowCopyBase.FullName.EndsWith(Path.DirectorySeparatorChar) && !shadowCopyBase.FullName.EndsWith(Path.AltDirectorySeparatorChar)) { // Add ending slash to get a uniform output shadowCopyBase = new DirectoryInfo(shadowCopyBase.FullName + Path.DirectorySeparatorChar); } // Do stuff DoFsSnapshot(shadowCopyBase, shadowCopyBase, res.Items); // Delete snapshot backupComponents.BackupComplete(); backupComponents.DeleteSnapshotSet(snapshotSetGuid, false); } catch (Exception) { backupComponents.AbortBackup(); } //DoFsSnapshot(baseDirectory, baseDirectory, res.Items); return(res); }