/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="fileLocator">The object used to locate / create the component files.</param> /// <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> internal static DiskImageFile Initialize(FileLocator fileLocator, string path, DiskParameters parameters) { if (parameters.Capacity <= 0) { throw new ArgumentException("Capacity must be greater than zero", "parameters"); } Geometry geometry = parameters.Geometry ?? DefaultGeometry(parameters.Capacity); Geometry biosGeometry; if (parameters.BiosGeometry != null) { biosGeometry = parameters.BiosGeometry; } else { biosGeometry = Geometry.MakeBiosSafe(geometry, parameters.Capacity); } DiskAdapterType adapterType = (parameters.AdapterType == DiskAdapterType.None) ? DiskAdapterType.LsiLogicScsi : parameters.AdapterType; DiskCreateType createType = (parameters.CreateType == DiskCreateType.None) ? DiskCreateType.MonolithicSparse : parameters.CreateType; DescriptorFile baseDescriptor = CreateSimpleDiskDescriptor(geometry, biosGeometry, createType, adapterType); return(DoInitialize(fileLocator, path, parameters.Capacity, createType, baseDescriptor)); }
private static ExtentType CreateTypeToExtentType(DiskCreateType type) { switch (type) { case DiskCreateType.FullDevice: case DiskCreateType.MonolithicFlat: case DiskCreateType.PartitionedDevice: case DiskCreateType.TwoGbMaxExtentFlat: return(ExtentType.Flat); case DiskCreateType.MonolithicSparse: case DiskCreateType.StreamOptimized: case DiskCreateType.TwoGbMaxExtentSparse: return(ExtentType.Sparse); case DiskCreateType.Vmfs: return(ExtentType.Vmfs); case DiskCreateType.VmfsPassthroughRawDeviceMap: return(ExtentType.VmfsRdm); case DiskCreateType.VmfsRaw: case DiskCreateType.VmfsRawDeviceMap: return(ExtentType.VmfsRaw); case DiskCreateType.VmfsSparse: return(ExtentType.VmfsSparse); default: throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Unable to convert {0}", type)); } }
/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="path">The name of the VMDK to create.</param> /// <param name="capacity">The desired capacity of the new disk</param> /// <param name="type">The type of virtual disk to create</param> /// <returns>The newly created disk image</returns> public static DiskImageFile Initialize(string path, long capacity, DiskCreateType type) { DiskParameters diskParams = new DiskParameters(); diskParams.Capacity = capacity; diskParams.CreateType = type; return(Initialize(path, diskParams)); }
private static DescriptorFile CreateDifferencingDiskDescriptor(DiskCreateType type, DiskImageFile parent, string parentPath) { DescriptorFile baseDescriptor = new DescriptorFile(); baseDescriptor.ContentId = (uint)_rng.Next(); baseDescriptor.ParentContentId = parent.ContentId; baseDescriptor.ParentFileNameHint = parentPath; baseDescriptor.CreateType = type; return(baseDescriptor); }
/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="fileSystem">The file system to create the VMDK on.</param> /// <param name="path">The name of the VMDK to create.</param> /// <param name="capacity">The desired capacity of the new disk.</param> /// <param name="createType">The type of virtual disk to create.</param> /// <returns>The newly created disk image.</returns> public static DiskImageFile Initialize(DiscFileSystem fileSystem, string path, long capacity, DiskCreateType createType) { DiskParameters diskParams = new DiskParameters(); diskParams.Capacity = capacity; diskParams.CreateType = createType; return(Initialize(fileSystem, path, diskParams)); }
internal static VirtualDiskTypeInfo MakeDiskTypeInfo(DiskCreateType createType) { return new VirtualDiskTypeInfo() { Name = "VMDK", Variant = CreateTypeToVariant(createType), CanBeHardDisk = true, DeterministicGeometry = false, PreservesBiosGeometry = false, CalcGeometry = c => DiskImageFile.DefaultGeometry(c), }; }
internal static VirtualDiskTypeInfo MakeDiskTypeInfo(DiskCreateType createType) { return(new VirtualDiskTypeInfo() { Name = "VMDK", Variant = CreateTypeToVariant(createType), CanBeHardDisk = true, DeterministicGeometry = false, PreservesBiosGeometry = false, CalcGeometry = c => DiskImageFile.DefaultGeometry(c), }); }
private static string FormatCreateType(DiskCreateType value) { switch (value) { case DiskCreateType.MonolithicSparse: return("monolithicSparse"); case DiskCreateType.VmfsSparse: return("vmfsSparse"); case DiskCreateType.MonolithicFlat: return("monolithicFlat"); case DiskCreateType.Vmfs: return("vmfs"); case DiskCreateType.TwoGbMaxExtentSparse: return("twoGbMaxExtentSparse"); case DiskCreateType.TwoGbMaxExtentFlat: return("twoGbMaxExtentFlat"); case DiskCreateType.FullDevice: return("fullDevice"); case DiskCreateType.VmfsRaw: return("vmfsRaw"); case DiskCreateType.PartitionedDevice: return("partitionedDevice"); case DiskCreateType.VmfsRawDeviceMap: return("vmfsRawDeviceMap"); case DiskCreateType.VmfsPassthroughRawDeviceMap: return("vmfsPassthroughRawDeviceMap"); case DiskCreateType.StreamOptimized: return("streamOptimized"); case DiskCreateType.SeSparse: return("seSparse"); case DiskCreateType.VsanSparse: return("vsanSparse"); default: throw new ArgumentException( string.Format(CultureInfo.InvariantCulture, "Unknown type: {0}", value), nameof(value)); } }
internal static DescriptorFile CreateSimpleDiskDescriptor(Geometry geometry, Geometry biosGeometery, DiskCreateType createType, DiskAdapterType adapterType) { DescriptorFile baseDescriptor = new DescriptorFile(); baseDescriptor.DiskGeometry = geometry; baseDescriptor.BiosGeometry = biosGeometery; baseDescriptor.ContentId = (uint)_rng.Next(); baseDescriptor.CreateType = createType; baseDescriptor.UniqueId = Guid.NewGuid(); baseDescriptor.HardwareVersion = "4"; baseDescriptor.AdapterType = adapterType; return(baseDescriptor); }
/// <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)); } }
private static DiskCreateType DiffDiskCreateType(DiskCreateType diskCreateType) { switch (diskCreateType) { case DiskCreateType.FullDevice: case DiskCreateType.MonolithicFlat: case DiskCreateType.MonolithicSparse: case DiskCreateType.PartitionedDevice: case DiskCreateType.StreamOptimized: case DiskCreateType.TwoGbMaxExtentFlat: case DiskCreateType.TwoGbMaxExtentSparse: return(DiskCreateType.MonolithicSparse); default: return(DiskCreateType.VmfsSparse); } }
private static string CreateTypeToVariant(DiskCreateType createType) { switch (createType) { case DiskCreateType.MonolithicFlat: case DiskCreateType.TwoGbMaxExtentFlat: return("fixed"); case DiskCreateType.MonolithicSparse: case DiskCreateType.TwoGbMaxExtentSparse: return("dynamic"); case DiskCreateType.Vmfs: return("vmfsfixed"); case DiskCreateType.VmfsSparse: return("vmfsdynamic"); default: return("fixed"); } }
private static ExtentType CreateTypeToExtentType(DiskCreateType type) { switch (type) { case DiskCreateType.FullDevice: case DiskCreateType.MonolithicFlat: case DiskCreateType.PartitionedDevice: case DiskCreateType.TwoGbMaxExtentFlat: return ExtentType.Flat; case DiskCreateType.MonolithicSparse: case DiskCreateType.StreamOptimized: case DiskCreateType.TwoGbMaxExtentSparse: return ExtentType.Sparse; case DiskCreateType.Vmfs: return ExtentType.Vmfs; case DiskCreateType.VmfsPassthroughRawDeviceMap: return ExtentType.VmfsRdm; case DiskCreateType.VmfsRaw: case DiskCreateType.VmfsRawDeviceMap: return ExtentType.VmfsRaw; case DiskCreateType.VmfsSparse: return ExtentType.VmfsSparse; default: throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Unable to convert {0}", type)); } }
private static DiskImageFile DoInitialize(FileLocator fileLocator, string file, long capacity, DiskCreateType type, DescriptorFile baseDescriptor) { if (type == DiskCreateType.MonolithicSparse) { // MonolithicSparse is a special case, the descriptor is embedded in the file itself... using (Stream fs = fileLocator.Open(file, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) { long descriptorStart; CreateExtent(fs, capacity, ExtentType.Sparse, 10 * Sizes.OneKiB, out descriptorStart); ExtentDescriptor extent = new ExtentDescriptor(ExtentAccess.ReadWrite, capacity / Sizes.Sector, ExtentType.Sparse, file, 0); fs.Position = descriptorStart * Sizes.Sector; baseDescriptor.Extents.Add(extent); baseDescriptor.Write(fs); } } else { ExtentType extentType = CreateTypeToExtentType(type); long totalSize = 0; List<ExtentDescriptor> extents = new List<ExtentDescriptor>(); if (type == DiskCreateType.MonolithicFlat || type == DiskCreateType.VmfsSparse || type == DiskCreateType.Vmfs) { string adornment = "flat"; if(type == DiskCreateType.VmfsSparse) { adornment = string.IsNullOrEmpty(baseDescriptor.ParentFileNameHint) ? "sparse" : "delta"; } string fileName = AdornFileName(file, adornment); using(Stream fs = fileLocator.Open(fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) { CreateExtent(fs, capacity, extentType); extents.Add(new ExtentDescriptor(ExtentAccess.ReadWrite, capacity / Sizes.Sector, extentType, fileName, 0)); totalSize = capacity; } } else if (type == DiskCreateType.TwoGbMaxExtentFlat || type == DiskCreateType.TwoGbMaxExtentSparse) { int i = 1; while (totalSize < capacity) { string adornment; if (type == DiskCreateType.TwoGbMaxExtentSparse) { adornment = string.Format(CultureInfo.InvariantCulture, "s{0:x3}", i); } else { adornment = string.Format(CultureInfo.InvariantCulture, "{0:x6}", i); } string fileName = AdornFileName(file, adornment); using (Stream fs = fileLocator.Open(fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) { long extentSize = Math.Min(2 * Sizes.OneGiB - Sizes.OneMiB, capacity - totalSize); CreateExtent(fs, extentSize, extentType); extents.Add(new ExtentDescriptor(ExtentAccess.ReadWrite, extentSize / Sizes.Sector, extentType, fileName, 0)); totalSize += extentSize; } ++i; } } else { throw new NotSupportedException("Creating disks of this type is not supported"); } using (Stream fs = fileLocator.Open(file, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) { baseDescriptor.Extents.AddRange(extents); baseDescriptor.Write(fs); } } return new DiskImageFile(fileLocator, file, FileAccess.ReadWrite); }
/// <summary> /// Creates a new virtual disk that is a linked clone of an existing disk. /// </summary> /// <param name="fileSystem">The file system to create the VMDK on</param> /// <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(DiscFileSystem fileSystem, 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"); } string basePath = Path.GetDirectoryName(path); FileLocator locator = new DiscFileLocator(fileSystem, basePath); FileLocator parentLocator = locator.GetRelativeLocator(Path.GetDirectoryName(parent)); using (DiskImageFile parentFile = new DiskImageFile(parentLocator, Path.GetFileName(parent), FileAccess.Read)) { DescriptorFile baseDescriptor = CreateDifferencingDiskDescriptor(type, parentFile, parent); return DoInitialize(locator, Path.GetFileName(path), parentFile.Capacity, type, baseDescriptor); } }
/// <summary> /// Creates a new virtual disk that is a linked clone of an existing disk. /// </summary> /// <param name="fileSystem">The file system to create the VMDK on.</param> /// <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(DiscFileSystem fileSystem, 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"); } string basePath = Utilities.GetDirectoryFromPath(path); FileLocator locator = new DiscFileLocator(fileSystem, basePath); FileLocator parentLocator = locator.GetRelativeLocator(Utilities.GetDirectoryFromPath(parent)); using (DiskImageFile parentFile = new DiskImageFile(parentLocator, Utilities.GetFileFromPath(parent), FileAccess.Read)) { DescriptorFile baseDescriptor = CreateDifferencingDiskDescriptor(type, parentFile, parent); return(DoInitialize(locator, Utilities.GetFileFromPath(path), parentFile.Capacity, type, baseDescriptor)); } }
/// <summary> /// Creates a new virtual disk at the specified location on a file system. /// </summary> /// <param name="fileSystem">The file system to contain the disk</param> /// <param name="path">The file system path to the disk</param> /// <param name="capacity">The desired capacity of the new disk</param> /// <param name="type">The type of virtual disk to create</param> /// <param name="adapterType">The type of virtual disk adapter</param> /// <returns>The newly created disk image</returns> public static Disk Initialize(DiscFileSystem fileSystem, string path, long capacity, DiskCreateType type, DiskAdapterType adapterType) { return(new Disk(DiskImageFile.Initialize(fileSystem, path, capacity, type, adapterType), Ownership.Dispose)); }
/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="path">The name of the VMDK to create.</param> /// <param name="capacity">The desired capacity of the new disk</param> /// <param name="type">The type of virtual disk to create</param> /// <param name="adapterType">The type of virtual disk adapter</param> /// <returns>The newly created disk image</returns> public static Disk Initialize(string path, long capacity, DiskCreateType type, DiskAdapterType adapterType) { return(Initialize(path, capacity, null, type, adapterType)); }
/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="path">The name of the VMDK to create.</param> /// <param name="capacity">The desired capacity of the new disk</param> /// <param name="type">The type of virtual disk to create</param> /// <param name="adapterType">The type of virtual disk adapter</param> /// <returns>The newly created disk image</returns> public static Disk Initialize(string path, long capacity, DiskCreateType type, DiskAdapterType adapterType) { return Initialize(path, capacity, null, type, adapterType); }
private static string CreateTypeToVariant(DiskCreateType createType) { switch (createType) { case DiskCreateType.MonolithicFlat: case DiskCreateType.TwoGbMaxExtentFlat: return "fixed"; case DiskCreateType.MonolithicSparse: case DiskCreateType.TwoGbMaxExtentSparse: return "dynamic"; case DiskCreateType.Vmfs: return "vmfsfixed"; case DiskCreateType.VmfsSparse: return "vmfsdynamic"; default: return "fixed"; } }
/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="path">The name of the VMDK to create.</param> /// <param name="capacity">The desired capacity of the new disk</param> /// <param name="geometry">The desired geometry of the new disk, or <c>null</c> for default</param> /// <param name="type">The type of virtual disk to create</param> /// <param name="adapterType">The type of virtual disk adapter</param> /// <returns>The newly created disk image</returns> public static Disk Initialize(string path, long capacity, Geometry geometry, DiskCreateType type, DiskAdapterType adapterType) { return new Disk(DiskImageFile.Initialize(path, capacity, geometry, type, adapterType), Ownership.Dispose); }
/// <summary> /// Initializes a new instance of the DiskBuilder class. /// </summary> public DiskBuilder() { _diskType = DiskCreateType.Vmfs; _adapterType = DiskAdapterType.LsiLogicScsi; }
/// <summary> /// Creates a new virtual disk at the specified location on a file system. /// </summary> /// <param name="fileSystem">The file system to contain the disk</param> /// <param name="path">The file system path to the disk</param> /// <param name="capacity">The desired capacity of the new disk</param> /// <param name="type">The type of virtual disk to create</param> /// <param name="adapterType">The type of virtual disk adapter</param> /// <returns>The newly created disk image</returns> public static Disk Initialize(DiscFileSystem fileSystem, string path, long capacity, DiskCreateType type, DiskAdapterType adapterType) { return new Disk(DiskImageFile.Initialize(fileSystem, path, capacity, type, adapterType), Ownership.Dispose); }
private static DiskImageFile DoInitialize(FileLocator fileLocator, string file, long capacity, DiskCreateType type, DescriptorFile baseDescriptor) { if (type == DiskCreateType.MonolithicSparse) { // MonolithicSparse is a special case, the descriptor is embedded in the file itself... using (Stream fs = fileLocator.Open(file, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) { long descriptorStart; CreateExtent(fs, capacity, ExtentType.Sparse, 10 * Sizes.OneKiB, out descriptorStart); ExtentDescriptor extent = new ExtentDescriptor(ExtentAccess.ReadWrite, capacity / Sizes.Sector, ExtentType.Sparse, file, 0); fs.Position = descriptorStart * Sizes.Sector; baseDescriptor.Extents.Add(extent); baseDescriptor.Write(fs); } } else { ExtentType extentType = CreateTypeToExtentType(type); long totalSize = 0; List <ExtentDescriptor> extents = new List <ExtentDescriptor>(); if (type == DiskCreateType.MonolithicFlat || type == DiskCreateType.VmfsSparse || type == DiskCreateType.Vmfs) { string adornment = "flat"; if (type == DiskCreateType.VmfsSparse) { adornment = string.IsNullOrEmpty(baseDescriptor.ParentFileNameHint) ? "sparse" : "delta"; } string fileName = AdornFileName(file, adornment); using (Stream fs = fileLocator.Open(fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) { CreateExtent(fs, capacity, extentType); extents.Add(new ExtentDescriptor(ExtentAccess.ReadWrite, capacity / Sizes.Sector, extentType, fileName, 0)); totalSize = capacity; } } else if (type == DiskCreateType.TwoGbMaxExtentFlat || type == DiskCreateType.TwoGbMaxExtentSparse) { int i = 1; while (totalSize < capacity) { string adornment; if (type == DiskCreateType.TwoGbMaxExtentSparse) { adornment = string.Format(CultureInfo.InvariantCulture, "s{0:x3}", i); } else { adornment = string.Format(CultureInfo.InvariantCulture, "{0:x6}", i); } string fileName = AdornFileName(file, adornment); using (Stream fs = fileLocator.Open(fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) { long extentSize = Math.Min(2 * Sizes.OneGiB - Sizes.OneMiB, capacity - totalSize); CreateExtent(fs, extentSize, extentType); extents.Add(new ExtentDescriptor(ExtentAccess.ReadWrite, extentSize / Sizes.Sector, extentType, fileName, 0)); totalSize += extentSize; } ++i; } } else { throw new NotSupportedException("Creating disks of this type is not supported"); } using (Stream fs = fileLocator.Open(file, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) { baseDescriptor.Extents.AddRange(extents); baseDescriptor.Write(fs); } } return(new DiskImageFile(fileLocator, file, FileAccess.ReadWrite)); }
/// <summary> /// Creates a new virtual disk as a thin clone of an existing disk. /// </summary> /// <param name="fileSystem">The file system to contain the disk</param> /// <param name="path">The path to the new disk.</param> /// <param name="type">The type of disk to create</param> /// <param name="parentPath">The path to the parent disk.</param> /// <returns>The new disk.</returns> public static Disk InitializeDifferencing(DiscFileSystem fileSystem, string path, DiskCreateType type, string parentPath) { return new Disk(DiskImageFile.InitializeDifferencing(fileSystem, path, type, parentPath), Ownership.Dispose); }
internal static DescriptorFile CreateSimpleDiskDescriptor(Geometry geometry, Geometry biosGeometery, DiskCreateType createType, DiskAdapterType adapterType) { DescriptorFile baseDescriptor = new DescriptorFile(); baseDescriptor.DiskGeometry = geometry; baseDescriptor.BiosGeometry = biosGeometery; baseDescriptor.ContentId = (uint)_rng.Next(); baseDescriptor.CreateType = createType; baseDescriptor.UniqueId = Guid.NewGuid(); baseDescriptor.HardwareVersion = "4"; baseDescriptor.AdapterType = adapterType; return baseDescriptor; }
private static string FormatCreateType(DiskCreateType value) { switch (value) { case DiskCreateType.MonolithicSparse: return "monolithicSparse"; case DiskCreateType.VmfsSparse: return "vmfsSparse"; case DiskCreateType.MonolithicFlat: return "monolithicFlat"; case DiskCreateType.Vmfs: return "vmfs"; case DiskCreateType.TwoGbMaxExtentSparse: return "twoGbMaxExtentSparse"; case DiskCreateType.TwoGbMaxExtentFlat: return "twoGbMaxExtentFlat"; case DiskCreateType.FullDevice: return "fullDevice"; case DiskCreateType.VmfsRaw: return "vmfsRaw"; case DiskCreateType.PartitionedDevice: return "partitionedDevice"; case DiskCreateType.VmfsRawDeviceMap: return "vmfsRawDeviceMap"; case DiskCreateType.VmfsPassthroughRawDeviceMap: return "vmfsPassthroughRawDeviceMap"; case DiskCreateType.StreamOptimized: return "streamOptimized"; default: throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Unknown type: {0}", value), "value"); } }
private static DescriptorFile CreateDifferencingDiskDescriptor(DiskCreateType type, DiskImageFile parent, string parentPath) { DescriptorFile baseDescriptor = new DescriptorFile(); baseDescriptor.ContentId = (uint)_rng.Next(); baseDescriptor.ParentContentId = parent.ContentId; baseDescriptor.ParentFileNameHint = parentPath; baseDescriptor.CreateType = type; return 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="capacity">The desired capacity of the new disk</param> /// <param name="type">The type of virtual disk to create</param> /// <returns>The newly created disk image</returns> public static DiskImageFile Initialize(string path, long capacity, DiskCreateType type) { DiskParameters diskParams = new DiskParameters(); diskParams.Capacity = capacity; diskParams.CreateType = type; return Initialize(path, diskParams); }
/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="path">The name of the VMDK to create.</param> /// <param name="capacity">The desired capacity of the new disk</param> /// <param name="geometry">The desired geometry of the new disk, or <c>null</c> for default</param> /// <param name="createType">The type of virtual disk to create</param> /// <param name="adapterType">The type of disk adapter used with the disk</param> /// <returns>The newly created disk image</returns> public static DiskImageFile Initialize(string path, long capacity, Geometry geometry, DiskCreateType createType, DiskAdapterType adapterType) { DiskParameters diskParams = new DiskParameters(); diskParams.Capacity = capacity; diskParams.Geometry = geometry; diskParams.CreateType = createType; diskParams.AdapterType = adapterType; return Initialize(path, diskParams); }
/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="path">The name of the VMDK to create.</param> /// <param name="capacity">The desired capacity of the new disk</param> /// <param name="geometry">The desired geometry of the new disk, or <c>null</c> for default</param> /// <param name="type">The type of virtual disk to create</param> /// <param name="adapterType">The type of virtual disk adapter</param> /// <returns>The newly created disk image</returns> public static Disk Initialize(string path, long capacity, Geometry geometry, DiskCreateType type, DiskAdapterType adapterType) { return(new Disk(DiskImageFile.Initialize(path, capacity, geometry, type, adapterType), Ownership.Dispose)); }
/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="fileSystem">The file system to create the VMDK on</param> /// <param name="path">The name of the VMDK to create.</param> /// <param name="capacity">The desired capacity of the new disk</param> /// <param name="createType">The type of virtual disk to create</param> /// <param name="adapterType">The type of disk adapter used with the disk</param> /// <returns>The newly created disk image</returns> public static DiskImageFile Initialize(DiscFileSystem fileSystem, string path, long capacity, DiskCreateType createType, DiskAdapterType adapterType) { DiskParameters diskParams = new DiskParameters(); diskParams.Capacity = capacity; diskParams.CreateType = createType; diskParams.AdapterType = adapterType; return Initialize(fileSystem, path, diskParams); }
/// <summary> /// Creates a new virtual disk as a thin clone of an existing disk. /// </summary> /// <param name="fileSystem">The file system to contain the disk</param> /// <param name="path">The path to the new disk.</param> /// <param name="type">The type of disk to create</param> /// <param name="parentPath">The path to the parent disk.</param> /// <returns>The new disk.</returns> public static Disk InitializeDifferencing(DiscFileSystem fileSystem, string path, DiskCreateType type, string parentPath) { return(new Disk(DiskImageFile.InitializeDifferencing(fileSystem, path, type, parentPath), Ownership.Dispose)); }
/// <summary> /// Creates a new virtual disk at the specified path. /// </summary> /// <param name="path">The name of the VMDK to create.</param> /// <param name="capacity">The desired capacity of the new disk</param> /// <param name="geometry">The desired geometry of the new disk, or <c>null</c> for default</param> /// <param name="createType">The type of virtual disk to create</param> /// <param name="adapterType">The type of disk adapter used with the disk</param> /// <returns>The newly created disk image</returns> public static DiskImageFile Initialize(string path, long capacity, Geometry geometry, DiskCreateType createType, DiskAdapterType adapterType) { DiskParameters diskParams = new DiskParameters(); diskParams.Capacity = capacity; diskParams.Geometry = geometry; diskParams.CreateType = createType; diskParams.AdapterType = adapterType; return(Initialize(path, diskParams)); }