/// <summary> /// Gets the locations of the parent file. /// </summary> /// <param name="fileLocator">The file locator to use.</param> /// <returns>Array of candidate file locations.</returns> private string[] GetParentLocations(FileLocator fileLocator) { if (!NeedsParent) { throw new InvalidOperationException("Only differencing disks contain parent locations"); } if (fileLocator == null) { // Use working directory by default fileLocator = new LocalFileLocator(string.Empty); } List <string> paths = new List <string>(); ParentLocator locator = _metadata.ParentLocator; string value; if (locator.Entries.TryGetValue("relative_path", out value)) { paths.Add(fileLocator.ResolveRelativePath(value)); } if (locator.Entries.TryGetValue("volume_path", out value)) { paths.Add(value); } if (locator.Entries.TryGetValue("absolute_win32_path", out value)) { paths.Add(value); } return(paths.ToArray()); }
/// <summary> /// Create a new differencing disk. /// </summary> /// <param name="path">The path (or URI) for the disk to create</param> /// <returns>The newly created disk</returns> public override VirtualDisk CreateDifferencingDisk(string path) { FileLocator locator = new LocalFileLocator(Path.GetDirectoryName(path)); DiskImageFile file = _files[0].First.CreateDifferencing(locator, Path.GetFileName(path)); return(new Disk(file, Ownership.Dispose)); }
/// <summary> /// Initializes a new instance of the Disk class. /// </summary> /// <param name="path">The path to the disk.</param> /// <param name="access">The access requested to the disk.</param> public Disk(string path, FileAccess access) { FileShare share = access == FileAccess.Read ? FileShare.Read : FileShare.None; var locator = new LocalFileLocator(string.Empty); _diskImage = new DiskImageFile(locator.Open(path, FileMode.Open, access, share), Ownership.Dispose); }
/// <summary> /// Writes the stream contents to a file. /// </summary> /// <param name="outputFile">The file to write to.</param> public void Build(string outputFile) { var locator = new LocalFileLocator(string.Empty); using (Stream destStream = locator.Open(outputFile, FileMode.Create, FileAccess.Write, FileShare.None)) { Build(destStream); } }
private void WriteFileData(BuilderContext context) { Stream outStream = context.RawStream; bool disposeSource = false; try { if (_source == null) { var locator = new LocalFileLocator(string.Empty); _source = locator.Open(_sourcePath, FileMode.Open, FileAccess.Read, FileShare.Read); disposeSource = true; } if (_source.Position != 0) { _source.Position = 0; } long startPos = outStream.Position; int bufferedBytes = StreamUtilities.ReadMaximum(_source, context.IoBuffer, 0, context.DataBlockSize); if (bufferedBytes < context.DataBlockSize) { // Fragment - less than one complete block of data _inode.StartBlock = 0xFFFFFFFF; _inode.FragmentKey = context.WriteFragment(bufferedBytes, out _inode.FragmentOffset); _inode.FileSize = (uint)bufferedBytes; } else { // At least one full block, no fragments used _inode.FragmentKey = 0xFFFFFFFF; _lengths = new List <uint>(); _inode.StartBlock = (uint)startPos; _inode.FileSize = bufferedBytes; while (bufferedBytes > 0) { _lengths.Add(context.WriteDataBlock(context.IoBuffer, 0, bufferedBytes)); bufferedBytes = StreamUtilities.ReadMaximum(_source, context.IoBuffer, 0, context.DataBlockSize); _inode.FileSize += (uint)bufferedBytes; } } } finally { if (disposeSource) { _source.Dispose(); } } }
internal Stream OpenStream() { if (_contentData != null) { return(new MemoryStream(_contentData, false)); } if (_contentPath != null) { var locator = new LocalFileLocator(string.Empty); return(locator.Open(_contentPath, FileMode.Open, FileAccess.Read, FileShare.Read)); } return(_contentStream); }
/// <summary> /// Creates a new VHD differencing disk file. /// </summary> /// <param name="path">The path to the new disk file</param> /// <param name="parentPath">The path to the parent disk file</param> /// <returns>An object that accesses the new file as a Disk</returns> public static Disk InitializeDifferencing(string path, string parentPath) { LocalFileLocator parentLocator = new LocalFileLocator(Path.GetDirectoryName(parentPath)); string parentFileName = Path.GetFileName(parentPath); DiskImageFile newFile; using (DiskImageFile parent = new DiskImageFile(parentLocator, parentFileName, FileAccess.Read)) { LocalFileLocator locator = new LocalFileLocator(Path.GetDirectoryName(path)); newFile = parent.CreateDifferencing(locator, Path.GetFileName(path)); } return(new Disk(newFile, Ownership.Dispose, parentLocator, parentFileName)); }
/// <summary> /// Directs trace output to a file as well as storing internally. /// </summary> /// <param name="path">The path to the file.</param> /// <remarks>Call this method after tracing has started to migrate to a new /// output file.</remarks> public void WriteToFile(string path) { if (_fileOut != null) { _fileOut.Dispose(); _fileOut = null; } if (!string.IsNullOrEmpty(path)) { var locator = new LocalFileLocator(string.Empty); _fileOut = new StreamWriter(locator.Open(path, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite)); } }
/// <summary> /// Gets the locations of the parent file. /// </summary> /// <param name="fileLocator">The file locator to use</param> /// <returns>Array of candidate file locations</returns> private string[] GetParentLocations(FileLocator fileLocator) { if (!NeedsParent) { throw new InvalidOperationException("Only differencing disks contain parent locations"); } if (fileLocator == null) { // Use working directory by default fileLocator = new LocalFileLocator(string.Empty); } List <string> absPaths = new List <string>(8); List <string> relPaths = new List <string>(8); foreach (var pl in _dynamicHeader.ParentLocators) { if (pl.PlatformCode == ParentLocator.PlatformCodeWindowsAbsoluteUnicode || pl.PlatformCode == ParentLocator.PlatformCodeWindowsRelativeUnicode) { _fileStream.Position = pl.PlatformDataOffset; byte[] buffer = Utilities.ReadFully(_fileStream, pl.PlatformDataLength); string locationVal = Encoding.Unicode.GetString(buffer); if (pl.PlatformCode == ParentLocator.PlatformCodeWindowsAbsoluteUnicode) { absPaths.Add(locationVal); } else { relPaths.Add(fileLocator.ResolveRelativePath(locationVal)); } } } // Order the paths to put absolute paths first List <string> paths = new List <string>(absPaths.Count + relPaths.Count + 1); paths.AddRange(absPaths); paths.AddRange(relPaths); // As a back-up, try to infer from the parent name... if (paths.Count == 0) { paths.Add(fileLocator.ResolveRelativePath(_dynamicHeader.ParentUnicodeName)); } return(paths.ToArray()); }
/// <summary> /// Gets the locations of the parent file. /// </summary> /// <param name="fileLocator">The file locator to use</param> /// <returns>Array of candidate file locations</returns> private string[] GetParentLocations(FileLocator fileLocator) { if (!NeedsParent) { throw new InvalidOperationException("Only differencing disks contain parent locations"); } if (fileLocator == null) { // Use working directory by default fileLocator = new LocalFileLocator(string.Empty); } throw new NotImplementedException(); }
/// <summary> /// Creates a new virtual disk that is a linked clone of an existing disk. /// </summary> /// <param name="path">The path to the new disk</param> /// <param name="type">The type of the new disk</param> /// <param name="parent">The disk to clone</param> /// <returns>The new virtual disk</returns> public static DiskImageFile InitializeDifferencing(string path, DiskCreateType type, string parent) { if (type != DiskCreateType.MonolithicSparse && type != DiskCreateType.TwoGbMaxExtentSparse && type != DiskCreateType.VmfsSparse) { throw new ArgumentException("Differencing disks must be sparse", "type"); } using (DiskImageFile parentFile = new DiskImageFile(parent, FileAccess.Read)) { DescriptorFile baseDescriptor = CreateDifferencingDiskDescriptor(type, parentFile, parent); FileLocator locator = new LocalFileLocator(Path.GetDirectoryName(path)); return(DoInitialize(locator, Path.GetFileName(path), parentFile.Capacity, type, baseDescriptor)); } }
/// <summary> /// Creates a new (empty) registry hive. /// </summary> /// <param name="path">The file to create the new hive in.</param> /// <returns>The new hive.</returns> public static RegistryHive Create(string path) { var locator = new LocalFileLocator(string.Empty); return(Create(locator.Open(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None), Ownership.Dispose)); }
/// <summary> /// Create a new differencing disk. /// </summary> /// <param name="path">The path (or URI) for the disk to create</param> /// <returns>The newly created disk</returns> public override VirtualDisk CreateDifferencingDisk(string path) { FileLocator locator = new LocalFileLocator(Path.GetDirectoryName(path)); DiskImageFile file = _files[0].First.CreateDifferencing(locator, Path.GetFileName(path)); return new Disk(file, Ownership.Dispose); }
/// <summary> /// Creates a new VHDX differencing disk file. /// </summary> /// <param name="path">The path to the new disk file</param> /// <param name="parentPath">The path to the parent disk file</param> /// <returns>An object that accesses the new file as a Disk</returns> public static Disk InitializeDifferencing(string path, string parentPath) { LocalFileLocator parentLocator = new LocalFileLocator(Path.GetDirectoryName(parentPath)); string parentFileName = Path.GetFileName(parentPath); DiskImageFile newFile; using (DiskImageFile parent = new DiskImageFile(parentLocator, parentFileName, FileAccess.Read)) { LocalFileLocator locator = new LocalFileLocator(Path.GetDirectoryName(path)); newFile = parent.CreateDifferencing(locator, Path.GetFileName(path)); } return new Disk(newFile, Ownership.Dispose, parentLocator, parentFileName); }
/// <summary> /// Creates a new virtual disk that is a linked clone of an existing disk. /// </summary> /// <param name="path">The path to the new disk</param> /// <param name="type">The type of the new disk</param> /// <param name="parent">The disk to clone</param> /// <returns>The new virtual disk</returns> public static DiskImageFile InitializeDifferencing(string path, DiskCreateType type, string parent) { if (type != DiskCreateType.MonolithicSparse && type != DiskCreateType.TwoGbMaxExtentSparse && type != DiskCreateType.VmfsSparse) { throw new ArgumentException("Differencing disks must be sparse", "type"); } using (DiskImageFile parentFile = new DiskImageFile(parent, FileAccess.Read)) { DescriptorFile baseDescriptor = CreateDifferencingDiskDescriptor(type, parentFile, parent); FileLocator locator = new LocalFileLocator(Path.GetDirectoryName(path)); return DoInitialize(locator, Path.GetFileName(path), parentFile.Capacity, type, baseDescriptor); } }
/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="path">The name of the VMDK to create.</param> /// <param name="parameters">The desired parameters for the new disk.</param> /// <returns>The newly created disk image</returns> public static DiskImageFile Initialize(string path, DiskParameters parameters) { FileLocator locator = new LocalFileLocator(Path.GetDirectoryName(path)); return Initialize(locator, Path.GetFileName(path), parameters); }
/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="path">The name of the VMDK to create.</param> /// <param name="parameters">The desired parameters for the new disk.</param> /// <returns>The newly created disk image</returns> public static DiskImageFile Initialize(string path, DiskParameters parameters) { FileLocator locator = new LocalFileLocator(Path.GetDirectoryName(path)); return(Initialize(locator, Path.GetFileName(path), parameters)); }
public override VirtualDisk OpenDisk(string path, FileAccess access) { var locator = new LocalFileLocator(string.Empty); return(OpenDisk(locator, path, access)); }
/// <summary> /// Gets the locations of the parent file. /// </summary> /// <param name="fileLocator">The file locator to use</param> /// <returns>Array of candidate file locations</returns> private string[] GetParentLocations(FileLocator fileLocator) { if (!NeedsParent) { throw new InvalidOperationException("Only differencing disks contain parent locations"); } if (fileLocator == null) { // Use working directory by default fileLocator = new LocalFileLocator(string.Empty); } List<string> paths = new List<string>(); ParentLocator locator = _metadata.ParentLocator; string value; if (locator.Entries.TryGetValue("relative_path", out value)) { paths.Add(fileLocator.ResolveRelativePath(value)); } if (locator.Entries.TryGetValue("volume_path", out value)) { paths.Add(value); } if (locator.Entries.TryGetValue("absolute_win32_path", out value)) { paths.Add(value); } return paths.ToArray(); }
/// <summary> /// Gets the locations of the parent file. /// </summary> /// <param name="fileLocator">The file locator to use.</param> /// <returns>Array of candidate file locations.</returns> private string[] GetParentLocations(FileLocator fileLocator) { if (!NeedsParent) { throw new InvalidOperationException("Only differencing disks contain parent locations"); } if (fileLocator == null) { // Use working directory by default fileLocator = new LocalFileLocator(string.Empty); } List<string> absPaths = new List<string>(8); List<string> relPaths = new List<string>(8); foreach (var pl in _dynamicHeader.ParentLocators) { if (pl.PlatformCode == ParentLocator.PlatformCodeWindowsAbsoluteUnicode || pl.PlatformCode == ParentLocator.PlatformCodeWindowsRelativeUnicode) { _fileStream.Position = pl.PlatformDataOffset; byte[] buffer = Utilities.ReadFully(_fileStream, pl.PlatformDataLength); string locationVal = Encoding.Unicode.GetString(buffer); if (pl.PlatformCode == ParentLocator.PlatformCodeWindowsAbsoluteUnicode) { absPaths.Add(locationVal); } else { relPaths.Add(fileLocator.ResolveRelativePath(locationVal)); } } } // Order the paths to put absolute paths first List<string> paths = new List<string>(absPaths.Count + relPaths.Count + 1); paths.AddRange(absPaths); paths.AddRange(relPaths); // As a back-up, try to infer from the parent name... if (paths.Count == 0) { paths.Add(fileLocator.ResolveRelativePath(_dynamicHeader.ParentUnicodeName)); } return paths.ToArray(); }