public void Create() { Geometry g = new Geometry(100, 16, 63); Assert.AreEqual(100, g.Cylinders); Assert.AreEqual(16, g.HeadsPerCylinder); Assert.AreEqual(63, g.SectorsPerTrack); }
public void FromCapacity() { // Check the capacity calculated is no greater than requested, and off by no more than 10% const long ThreeTwentyMB = 1024 * 1024 * 320; Geometry g = Geometry.FromCapacity(ThreeTwentyMB); Assert.That(g.Capacity <= ThreeTwentyMB && g.Capacity > ThreeTwentyMB * 0.9); // Check exact sizes are maintained - do one pass to allow for finding a geometry that matches // the algorithm - then expect identical results each time. Geometry startGeometry = new Geometry(333,22,11); Geometry trip1 = Geometry.FromCapacity(startGeometry.Capacity); Assert.AreEqual(trip1, Geometry.FromCapacity(trip1.Capacity)); }
public void LBARoundTrip() { Geometry g = new Geometry(100, 16, 63); const int TestCylinder = 54; const int TestHead = 15; const int TestSector = 63; long lba = g.ToLogicalBlockAddress(TestCylinder, TestHead, TestSector); ChsAddress chs = g.ToChsAddress(lba); Assert.AreEqual(TestCylinder, chs.Cylinder); Assert.AreEqual(TestHead, chs.Head); Assert.AreEqual(TestSector, chs.Sector); }
private void _copydisks(EnvelopeType ovfEnv, string label, string targetPath) { m_iscsi = new iSCSI { UpdateHandler = iscsi_UpdateHandler, Cancel = Cancel //in case it has already been cancelled }; m_iscsi.ConfigureTvmNetwork(m_networkUuid, m_isTvmIpStatic, m_tvmIpAddress, m_tvmSubnetMask, m_tvmGateway); try { foreach (XenRef <VDI> vdiuuid in _vdiRefs) { string uuid = ""; string destinationFilename = ""; try { uuid = VDI.get_uuid(XenSession, vdiuuid); destinationFilename = Path.Combine(targetPath, string.Format(@"{0}.vhd", uuid)); if (File.Exists(destinationFilename)) { destinationFilename = Path.Combine(targetPath, string.Format(@"{0}_{1}.vhd", uuid, Thread.CurrentThread.ManagedThreadId)); OVF.UpdateFilename(ovfEnv, string.Format(@"{0}.vhd", uuid), string.Format(@"{0}_{1}.vhd", uuid, Thread.CurrentThread.ManagedThreadId)); log.InfoFormat("{0}: VHD Name collision, renamed {1}.vhd to {1}_{2}.vhd", label, uuid, Thread.CurrentThread.ManagedThreadId); } OnUpdate(new XenOvfTranportEventArgs(XenOvfTranportEventType.MarqueeOn, "Export", string.Format(Messages.FILES_TRANSPORT_SETUP, uuid + ".vhd"))); using (Stream source = m_iscsi.Connect(XenSession, uuid, true)) { OnUpdate(new XenOvfTranportEventArgs(XenOvfTranportEventType.MarqueeOff, "Export", "")); using (FileStream fs = new FileStream(destinationFilename, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None)) { // Create a geometry to give to DiscUtils.Vhd.Disk.InitializeDynamic() just so it doesn't override capacity // when initializing the . DiscUtils.Geometry geometry = DiscUtils.Geometry.FromCapacity(source.Length); using (DiscUtils.Vhd.Disk destination = DiscUtils.Vhd.Disk.InitializeDynamic(fs, Ownership.None, source.Length, geometry)) { m_iscsi.Copy(source, destination.Content, Path.GetFileName(destinationFilename), ShouldVerifyDisks); } } } if (ShouldVerifyDisks) { using (var target = new DiscUtils.Vhd.Disk(destinationFilename, FileAccess.Read)) { m_iscsi.Verify(target.Content, destinationFilename); } } } catch (Exception ex) { if (ex is OperationCanceledException) { throw; } var msg = string.Format(Messages.ISCSI_COPY_ERROR, destinationFilename); log.Error(msg); OnUpdate(new XenOvfTranportEventArgs(XenOvfTranportEventType.Failure, "Export", msg, ex)); throw new Exception(msg, ex); } finally { OnUpdate(new XenOvfTranportEventArgs(XenOvfTranportEventType.MarqueeOn, "Export", string.Format(Messages.FILES_TRANSPORT_CLEANUP, uuid + ".vhd"))); m_iscsi.Disconnect(XenSession); OnUpdate(new XenOvfTranportEventArgs(XenOvfTranportEventType.MarqueeOff, "Export", "")); } } } finally { _vdiRefs.Clear(); } }
private static void UpdateBiosGeometry(SparseStream contentStream, Geometry oldGeometry, Geometry newGeometry) { BiosPartitionTable partTable = new BiosPartitionTable(contentStream, oldGeometry); partTable.UpdateBiosGeometry(newGeometry); VolumeManager volMgr = new VolumeManager(contentStream); foreach (var volume in volMgr.GetLogicalVolumes()) { foreach (var fsInfo in FileSystemManager.DetectDefaultFileSystems(volume.Open())) { if (fsInfo.Name == "NTFS") { using (NtfsFileSystem fs = new NtfsFileSystem(volume.Open())) { fs.UpdateBiosGeometry(newGeometry); } } } } }
public void TotalSectors() { Geometry g = new Geometry(333, 22, 11); Assert.AreEqual(333 * 22 * 11, g.TotalSectors); }
/// <summary> /// Create a new virtual disk. /// </summary> /// <param name="type">The type of disk to create (see <see cref="SupportedDiskTypes"/>).</param> /// <param name="variant">The variant of the type to create (see <see cref="GetSupportedDiskVariants"/>).</param> /// <param name="path">The path (or URI) for the disk to create.</param> /// <param name="capacity">The capacity of the new disk.</param> /// <param name="geometry">The geometry of the new disk (or null).</param> /// <param name="user">The user identity to use when accessing the <c>path</c> (or null).</param> /// <param name="password">The password to use when accessing the <c>path</c> (or null).</param> /// <param name="parameters">Untyped parameters controlling the creation process (TBD).</param> /// <returns>The newly created disk.</returns> public static VirtualDisk CreateDisk(string type, string variant, string path, long capacity, Geometry geometry, string user, string password, Dictionary<string, string> parameters) { VirtualDiskParameters diskParams = new VirtualDiskParameters() { AdapterType = GenericDiskAdapterType.Scsi, Capacity = capacity, Geometry = geometry, }; if (parameters != null) { foreach (var key in parameters.Keys) { diskParams.ExtendedParameters[key] = parameters[key]; } } return CreateDisk(type, variant, path, diskParams, user, password); }
public void Capacity() { Geometry g = new Geometry(333, 22, 11); Assert.AreEqual(333 * 22 * 11 * 512, g.Capacity); }
/// <summary> /// Create a new virtual disk, possibly within an existing disk. /// </summary> /// <param name="fileSystem">The file system to create the disk on.</param> /// <param name="type">The type of disk to create (see <see cref="SupportedDiskTypes"/>).</param> /// <param name="variant">The variant of the type to create (see <see cref="GetSupportedDiskVariants"/>).</param> /// <param name="path">The path (or URI) for the disk to create.</param> /// <param name="capacity">The capacity of the new disk.</param> /// <param name="geometry">The geometry of the new disk (or null).</param> /// <param name="parameters">Untyped parameters controlling the creation process (TBD).</param> /// <returns>The newly created disk.</returns> public static VirtualDisk CreateDisk(DiscFileSystem fileSystem, string type, string variant, string path, long capacity, Geometry geometry, Dictionary<string, string> parameters) { VirtualDiskFactory factory = TypeMap[type]; VirtualDiskParameters diskParams = new VirtualDiskParameters() { AdapterType = GenericDiskAdapterType.Scsi, Capacity = capacity, Geometry = geometry, }; if (parameters != null) { foreach (var key in parameters.Keys) { diskParams.ExtendedParameters[key] = parameters[key]; } } return factory.CreateDisk(new DiscFileLocator(fileSystem, Utilities.GetDirectoryFromPath(path)), variant.ToLowerInvariant(), Utilities.GetFileFromPath(path), diskParams); }
/// <summary> /// Create a new virtual disk. /// </summary> /// <param name="type">The type of disk to create (see <see cref="SupportedDiskTypes"/>).</param> /// <param name="variant">The variant of the type to create (see <see cref="GetSupportedDiskVariants"/>).</param> /// <param name="path">The path (or URI) for the disk to create.</param> /// <param name="capacity">The capacity of the new disk.</param> /// <param name="geometry">The geometry of the new disk (or null).</param> /// <param name="parameters">Untyped parameters controlling the creation process (TBD).</param> /// <returns>The newly created disk.</returns> public static VirtualDisk CreateDisk(string type, string variant, string path, long capacity, Geometry geometry, Dictionary<string, string> parameters) { return CreateDisk(type, variant, path, capacity, geometry, null, null, parameters); }
/// <summary> /// Converts a geometry into one that is BIOS-safe, if not already. /// </summary> /// <param name="geometry">The geometry to make BIOS-safe.</param> /// <param name="capacity">The capacity of the disk.</param> /// <returns>The new geometry</returns> /// <remarks>This method returns the LBA-Assisted geometry if the given geometry isn't BIOS-safe.</remarks> public static Geometry MakeBiosSafe(Geometry geometry, long capacity) { if(geometry == null) { return LbaAssistedBiosGeometry(capacity); } else if (geometry.IsBiosSafe) { return geometry; } else { return LbaAssistedBiosGeometry(capacity); } }
/// <summary> /// Gets the 'Large' BIOS geometry for a disk, given it's physical geometry. /// </summary> /// <param name="ideGeometry">The physical (aka IDE) geometry of the disk</param> /// <returns>The geometry a BIOS using the 'Large' method for calculating disk geometry will indicate for the disk</returns> public static Geometry LargeBiosGeometry(Geometry ideGeometry) { int cylinders = ideGeometry.Cylinders; int heads = ideGeometry.HeadsPerCylinder; int sectors = ideGeometry.SectorsPerTrack; while (cylinders > 1024 && heads <= 127) { cylinders >>= 1; heads <<= 1; } return new Geometry(cylinders, heads, sectors); }
public abstract VirtualDisk CreateDisk(FileLocator locator, string variant, string path, long capacity, Geometry geometry, Dictionary<string, string> parameters);
/// <summary> /// Create a new virtual disk. /// </summary> /// <param name="type">The type of disk to create (see <see cref="SupportedDiskTypes"/>)</param> /// <param name="variant">The variant of the type to create (see <see cref="GetSupportedDiskVariants"/>)</param> /// <param name="path">The path (or URI) for the disk to create</param> /// <param name="capacity">The capacity of the new disk</param> /// <param name="geometry">The geometry of the new disk (or null).</param> /// <param name="user">The user identity to use when accessing the <c>path</c> (or null)</param> /// <param name="password">The password to use when accessing the <c>path</c> (or null)</param> /// <param name="parameters">Untyped parameters controlling the creation process (TBD)</param> /// <returns>The newly created disk</returns> public static VirtualDisk CreateDisk(string type, string variant, string path, long capacity, Geometry geometry, string user, string password, Dictionary<string, string> parameters) { Uri uri = PathToUri(path); VirtualDisk result = null; VirtualDiskTransport transport; if (!DiskTransports.TryGetValue(uri.Scheme.ToUpperInvariant(), out transport)) { throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Unable to parse path '{0}'", path), path); } try { transport.Connect(uri, user, password); if (transport.IsRawDisk) { result = transport.OpenDisk(FileAccess.ReadWrite); } else { VirtualDiskFactory factory = TypeMap[type]; result = factory.CreateDisk(transport.GetFileLocator(), variant.ToLowerInvariant(), Utilities.GetFileFromPath(path), capacity, geometry, parameters ?? new Dictionary<string, string>()); } if (result != null) { result._transport = transport; transport = null; } return result; } finally { if (transport != null) { transport.Dispose(); } } }
/// <summary> /// Create a new virtual disk, possibly within an existing disk. /// </summary> /// <param name="fileSystem">The file system to create the disk on</param> /// <param name="type">The type of disk to create (see <see cref="SupportedDiskTypes"/>)</param> /// <param name="variant">The variant of the type to create (see <see cref="GetSupportedDiskVariants"/>)</param> /// <param name="path">The path (or URI) for the disk to create</param> /// <param name="capacity">The capacity of the new disk</param> /// <param name="geometry">The geometry of the new disk (or null).</param> /// <param name="parameters">Untyped parameters controlling the creation process (TBD)</param> /// <returns>The newly created disk</returns> public static VirtualDisk CreateDisk(DiscFileSystem fileSystem, string type, string variant, string path, long capacity, Geometry geometry, Dictionary<string, string> parameters) { VirtualDiskFactory factory = TypeMap[type]; return factory.CreateDisk(new DiscFileLocator(fileSystem, Utilities.GetDirectoryFromPath(path)), variant.ToLowerInvariant(), Utilities.GetFileFromPath(path), capacity, geometry, parameters ?? new Dictionary<string, string>()); }