public override SparseStream OpenContent(SparseStream parent, Ownership ownsParent)
{
if (ownsParent == Ownership.Dispose && parent != null)
{
parent.Dispose();
}
return SparseStream.FromStream(Content, Ownership.None);
}
protected override void Dispose(bool disposing)
{
try
{
if (_parentStream != null)
{
if (_ownsParent == Ownership.Dispose)
{
_parentStream.Dispose();
}
_parentStream = null;
}
}
finally
{
base.Dispose(disposing);
}
}
/// <summary>
/// Disposes of underlying resources.
/// </summary>
/// <param name="disposing">Set to <c>true</c> if called within Dispose(),
/// else <c>false</c>.</param>
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
if (_ownsContent == Ownership.Dispose && _content != null)
{
_content.Dispose();
}
_content = null;
}
}
finally
{
base.Dispose(disposing);
}
}
/// <summary>
/// Gets the contents of this disk as a stream.
/// </summary>
/// <param name="parent">The content of the parent disk (needed if this is a differencing disk).</param>
/// <param name="ownsParent">A value indicating whether ownership of the parent stream is transfered.</param>
/// <returns>The stream containing the disk contents.</returns>
public override SparseStream OpenContent(SparseStream parent, Ownership ownsParent)
{
if (_descriptor.ParentContentId == uint.MaxValue)
{
if (parent != null && ownsParent == Ownership.Dispose)
{
parent.Dispose();
}
parent = null;
}
if (parent == null)
{
parent = new ZeroStream(Capacity);
ownsParent = Ownership.Dispose;
}
if (_descriptor.Extents.Count == 1)
{
if (_monolithicStream != null)
{
return(new HostedSparseExtentStream(
_monolithicStream,
Ownership.None,
0,
parent,
ownsParent));
}
return(OpenExtent(_descriptor.Extents[0], 0, parent, ownsParent));
}
long extentStart = 0;
SparseStream[] streams = new SparseStream[_descriptor.Extents.Count];
for (int i = 0; i < streams.Length; ++i)
{
streams[i] = OpenExtent(_descriptor.Extents[i], extentStart, parent,
i == streams.Length - 1 ? ownsParent : Ownership.None);
extentStart += _descriptor.Extents[i].SizeInSectors * Sizes.Sector;
}
return(new ConcatStream(Ownership.Dispose, streams));
}
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
if (_wrapped != null && _ownership == Ownership.Dispose)
{
_wrapped.Dispose();
}
_wrapped = null;
}
}
finally
{
base.Dispose(disposing);
}
}
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
UpdateFooter();
if (_ownsParentStream == Ownership.Dispose && _parentStream != null)
{
_parentStream.Dispose();
_parentStream = null;
}
}
}
finally
{
base.Dispose(disposing);
}
}
/// <summary>
/// Disposes of underlying resources.
/// </summary>
/// <param name="disposing">Set to <c>true</c> if called within Dispose(),
/// else <c>false</c>.</param>
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
if (_content != null)
{
_content.Dispose();
_content = null;
}
if (_diskImage != null)
{
_diskImage.Dispose();
}
}
}
finally
{
base.Dispose(disposing);
}
}
/// <summary>
/// Disposes of this instance.
/// </summary>
/// <param name="disposing"><c>true</c> if disposing, <c>false</c> if in destructor</param>
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
if (_contentStream != null)
{
_contentStream.Dispose();
_contentStream = null;
}
if (_ownsMonolithicStream == Ownership.Dispose && _monolithicStream != null)
{
_monolithicStream.Dispose();
_monolithicStream = null;
}
}
}
finally
{
base.Dispose(disposing);
}
}
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
if (_ownsFileStream == Ownership.Dispose && _fileStream != null)
{
_fileStream.Dispose();
}
_fileStream = null;
if (_ownsParentDiskStream == Ownership.Dispose && _parentDiskStream != null)
{
_parentDiskStream.Dispose();
}
_parentDiskStream = null;
}
}
finally
{
base.Dispose(disposing);
}
}
/// <summary>
/// Gets the contents of this disk as a stream.
/// </summary>
internal SparseStream OpenContent(SparseStream parent, Ownership ownsParent)
{
if (_descriptor.ParentContentId == uint.MaxValue)
{
if (parent != null && ownsParent == Ownership.Dispose)
{
parent.Dispose();
}
parent = null;
}
if (parent == null)
{
parent = new ZeroStream(Capacity);
ownsParent = Ownership.Dispose;
}
if (_descriptor.Extents.Count == 1)
{
if (_monolithicStream != null)
{
return new HostedSparseExtentStream(
_monolithicStream,
Ownership.None,
0,
parent,
ownsParent);
}
else
{
return OpenExtent(_descriptor.Extents[0], 0, parent, ownsParent);
}
}
else
{
long extentStart = 0;
SparseStream[] streams = new SparseStream[_descriptor.Extents.Count];
for (int i = 0; i < streams.Length; ++i)
{
streams[i] = OpenExtent(_descriptor.Extents[i], extentStart, parent, (i == streams.Length - 1) ? ownsParent : Ownership.None);
extentStart += _descriptor.Extents[i].SizeInSectors * Sizes.Sector;
}
return new ConcatStream(Ownership.Dispose, streams);
}
}
private SparseStream OpenExtent(ExtentDescriptor extent, long extentStart, SparseStream parent, Ownership ownsParent)
{
FileAccess access = FileAccess.Read;
FileShare share = FileShare.Read;
if(extent.Access == ExtentAccess.ReadWrite && _access != FileAccess.Read)
{
access = FileAccess.ReadWrite;
share = FileShare.None;
}
if (extent.Type != ExtentType.Sparse && extent.Type != ExtentType.VmfsSparse)
{
if (ownsParent == Ownership.Dispose && parent != null)
{
parent.Dispose();
}
}
switch (extent.Type)
{
case ExtentType.Flat:
case ExtentType.Vmfs:
return SparseStream.FromStream(
_fileLocator.Open(extent.FileName, FileMode.Open, access, share),
Ownership.Dispose);
case ExtentType.Zero:
return new ZeroStream(extent.SizeInSectors * Utilities.SectorSize);
case ExtentType.Sparse:
return new HostedSparseExtentStream(
_fileLocator.Open(extent.FileName, FileMode.Open, access, share),
Ownership.Dispose,
extentStart,
parent,
ownsParent);
case ExtentType.VmfsSparse:
return new ServerSparseExtentStream(
_fileLocator.Open(extent.FileName, FileMode.Open, access, share),
Ownership.Dispose,
extentStart,
parent,
ownsParent);
default:
throw new NotSupportedException();
}
}
/// <summary>
/// Opens the content of the disk layer as a stream.
/// </summary>
/// <param name="parent">The parent file's content (if any)</param>
/// <param name="ownsParent">Whether the created stream assumes ownership of parent stream</param>
/// <returns>The new content stream</returns>
public override SparseStream OpenContent(SparseStream parent, Ownership ownsParent)
{
if (ownsParent == Ownership.Dispose && parent != null)
{
parent.Dispose();
}
return new DiskStream(_vm.Archive, _capacity, _location);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
_wrapped.Dispose();
}
internal MappedStream DoOpenContent(SparseStream parent, Ownership ownsParent)
{
if (_footer.DiskType == FileType.Fixed)
{
if (parent != null && ownsParent == Ownership.Dispose)
{
parent.Dispose();
}
return new SubStream(_fileStream, 0, _fileStream.Length - 512);
}
else if (_footer.DiskType == FileType.Dynamic)
{
if (parent != null && ownsParent == Ownership.Dispose)
{
parent.Dispose();
}
return new DynamicStream(_fileStream, _dynamicHeader, _footer.CurrentSize, new ZeroStream(_footer.CurrentSize), Ownership.Dispose);
}
else
{
if (parent == null)
{
parent = new ZeroStream(_footer.CurrentSize);
ownsParent = Ownership.Dispose;
}
return new DynamicStream(_fileStream, _dynamicHeader, _footer.CurrentSize, parent, ownsParent);
}
}
public override MappedStream OpenContent(SparseStream parent, Ownership ownsParent)
{
FileAccess access = FileAccess.Read;
FileShare share = FileShare.Read;
if (_descriptor.Access == ExtentAccess.ReadWrite && _access != FileAccess.Read)
{
access = FileAccess.ReadWrite;
share = FileShare.None;
}
if (_descriptor.Type != ExtentType.Sparse && _descriptor.Type != ExtentType.VmfsSparse &&
_descriptor.Type != ExtentType.Zero)
{
if (ownsParent == Ownership.Dispose && parent != null)
{
parent.Dispose();
}
}
else if (parent == null)
{
parent = new ZeroStream(_descriptor.SizeInSectors * Sizes.Sector);
}
if (_monolithicStream != null)
{
// Early-out for monolithic VMDKs
return(new HostedSparseExtentStream(
_monolithicStream,
Ownership.None,
_diskOffset,
parent,
ownsParent));
}
switch (_descriptor.Type)
{
case ExtentType.Flat:
case ExtentType.Vmfs:
return(MappedStream.FromStream(
_fileLocator.Open(_descriptor.FileName, FileMode.Open, access, share),
Ownership.Dispose));
case ExtentType.Zero:
return(new ZeroStream(_descriptor.SizeInSectors * Sizes.Sector));
case ExtentType.Sparse:
return(new HostedSparseExtentStream(
_fileLocator.Open(_descriptor.FileName, FileMode.Open, access, share),
Ownership.Dispose,
_diskOffset,
parent,
ownsParent));
case ExtentType.VmfsSparse:
return(new ServerSparseExtentStream(
_fileLocator.Open(_descriptor.FileName, FileMode.Open, access, share),
Ownership.Dispose,
_diskOffset,
parent,
ownsParent));
default:
throw new NotSupportedException();
}
}
public override SparseStream OpenContent(SparseStream parentStream, Ownership ownsStream)
{
if (parentStream != null && ownsStream == Ownership.Dispose)
{
parentStream.Dispose();
}
if (_buffer != null)
{
SparseStream rawStream = new BufferStream(_buffer, FileAccess.Read);
return new BlockCacheStream(rawStream, Ownership.Dispose);
}
else
{
return SparseStream.FromStream(_stream, Ownership.None);
}
}
public override MappedStream OpenContent(SparseStream parent, Ownership ownsParent)
{
FileAccess access = FileAccess.Read;
FileShare share = FileShare.Read;
if (_descriptor.Access == ExtentAccess.ReadWrite && _access != FileAccess.Read)
{
access = FileAccess.ReadWrite;
share = FileShare.None;
}
if (_descriptor.Type != ExtentType.Sparse && _descriptor.Type != ExtentType.VmfsSparse && _descriptor.Type != ExtentType.Zero)
{
if (ownsParent == Ownership.Dispose && parent != null)
{
parent.Dispose();
}
}
else if (parent == null)
{
parent = new ZeroStream(_descriptor.SizeInSectors * Sizes.Sector);
}
if (_monolithicStream != null)
{
// Early-out for monolithic VMDKs
return new HostedSparseExtentStream(
_monolithicStream,
Ownership.None,
_diskOffset,
parent,
ownsParent);
}
else
{
switch (_descriptor.Type)
{
case ExtentType.Flat:
case ExtentType.Vmfs:
return MappedStream.FromStream(
_fileLocator.Open(_descriptor.FileName, FileMode.Open, access, share),
Ownership.Dispose);
case ExtentType.Zero:
return new ZeroStream(_descriptor.SizeInSectors * Utilities.SectorSize);
case ExtentType.Sparse:
return new HostedSparseExtentStream(
_fileLocator.Open(_descriptor.FileName, FileMode.Open, access, share),
Ownership.Dispose,
_diskOffset,
parent,
ownsParent);
case ExtentType.VmfsSparse:
return new ServerSparseExtentStream(
_fileLocator.Open(_descriptor.FileName, FileMode.Open, access, share),
Ownership.Dispose,
_diskOffset,
parent,
ownsParent);
default:
throw new NotSupportedException();
}
}
}
/// <summary>
/// Opens the content of the disk image file as a stream.
/// </summary>
/// <param name="parent">The parent file's content (if any)</param>
/// <param name="ownsParent">Whether the created stream assumes ownership of parent stream</param>
/// <returns>The new content stream</returns>
public override SparseStream OpenContent(SparseStream parent, Ownership ownsParent)
{
if (parent != null && ownsParent == Ownership.Dispose)
{
// Not needed until differencing disks supported.
parent.Dispose();
}
DiskStream stream = new DiskStream(_stream, Ownership.None, _header);
stream.WriteOccurred += OnWriteOccurred;
return stream;
}
