/// <summary>
/// Creates a new instance of this class.
/// </summary>
/// <param name="ioSessions">IoSessions to use to read from this disk</param>
public IndexParser(SubFileDiskIoSessionPool ioSessions)
: base(ioSessions.Header.BlockSize)
{
m_subFile = ioSessions.File;
m_ioSessions = ioSessions;
m_oldFirstOffset = -1;
}
/// <summary>
/// Creates an SubFileStream
/// </summary>
/// <param name="dataReader">The location to read from.</param>
/// <param name="subFile">The file to read.</param>
/// <param name="fileHeaderBlock">The FileAllocationTable</param>
/// <param name="isReadOnly">Determines if the stream allows editing.</param>
internal SubFileStream(DiskIo dataReader, SubFileHeader subFile, FileHeaderBlock fileHeaderBlock, bool isReadOnly)
{
if (dataReader == null)
throw new ArgumentNullException("dataReader");
if (subFile == null)
throw new ArgumentNullException("subFile");
if (fileHeaderBlock == null)
throw new ArgumentNullException("subFile");
if (!isReadOnly)
{
if (dataReader.IsReadOnly)
throw new ArgumentException("This parameter cannot be read only when opening for writing", "dataReader");
if (fileHeaderBlock.IsReadOnly)
throw new ArgumentException("This parameter cannot be read only when opening for writing", "fileHeaderBlock");
if (subFile.IsReadOnly)
throw new ArgumentException("This parameter cannot be read only when opening for writing", "subFile");
}
if (isReadOnly)
{
if (!fileHeaderBlock.IsReadOnly)
throw new ArgumentException("This parameter must be read only when opening for reading", "fileHeaderBlock");
if (!subFile.IsReadOnly)
throw new ArgumentException("This parameter must be read only when opening for reading", "subFile");
}
m_blockSize = dataReader.BlockSize;
m_dataReader = dataReader;
m_subFile = subFile;
m_fileHeaderBlock = fileHeaderBlock;
m_isReadOnly = isReadOnly;
}
internal static void CheckEqual(SubFileHeader RO, SubFileHeader RW)
{
if (!AreEqual(RO, RW))
{
throw new Exception();
}
}
public void Test()
{
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
Random rand = new Random();
ushort fileIdNumber = (ushort)rand.Next(int.MaxValue);
SubFileName fileName = SubFileName.CreateRandom();
int dataBlock1 = rand.Next(int.MaxValue);
int singleRedirect = rand.Next(int.MaxValue);
int doubleRedirect = rand.Next(int.MaxValue);
int tripleRedirect = rand.Next(int.MaxValue);
int quadrupleRedirect = rand.Next(int.MaxValue);
SubFileHeader node = new SubFileHeader(fileIdNumber, fileName, isImmutable: false, isSimplified:false);
node.DirectBlock = (uint)dataBlock1;
node.SingleIndirectBlock = (uint)singleRedirect;
node.DoubleIndirectBlock = (uint)doubleRedirect;
node.TripleIndirectBlock = (uint)tripleRedirect;
node.QuadrupleIndirectBlock = (uint)quadrupleRedirect;
SubFileHeader node2 = SaveItem(node);
if (node2.FileIdNumber != fileIdNumber) throw new Exception();
if (node2.FileName != fileName) throw new Exception();
if (node2.DirectBlock != dataBlock1) throw new Exception();
if (node2.SingleIndirectBlock != singleRedirect) throw new Exception();
if (node2.DoubleIndirectBlock != doubleRedirect) throw new Exception();
if (node2.TripleIndirectBlock != tripleRedirect) throw new Exception();
if (node2.QuadrupleIndirectBlock != quadrupleRedirect) throw new Exception();
Assert.IsTrue(true);
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
}
/// <summary>
/// Creates a <see cref="DiskIoSession"/> that can be used to perform basic read/write functions.
/// </summary>
/// <returns></returns>
public DiskIoSession CreateDiskIoSession(FileHeaderBlock header, SubFileHeader file)
{
if (m_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
return(new DiskIoSession(this, m_stream.CreateIoSession(), header, file));
}
/// <summary>
/// Creates a <see cref="ShadowCopyAllocator"/> that is used make shadow copies of blocks.
/// </summary>
/// <param name="ioSessions"></param>
public ShadowCopyAllocator(SubFileDiskIoSessionPool ioSessions)
: base(ioSessions)
{
if (ioSessions == null)
throw new ArgumentNullException("ioSessions");
if (ioSessions.IsReadOnly)
throw new ArgumentException("DataReader is read only", "ioSessions");
m_lastReadOnlyBlock = ioSessions.LastReadonlyBlock;
m_fileHeaderBlock = ioSessions.Header;
m_subFileHeader = ioSessions.File;
m_ioSessions = ioSessions;
}
public void Test()
{
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
Random rand = new Random();
ushort fileIdNumber = (ushort)rand.Next(int.MaxValue);
SubFileName fileName = SubFileName.CreateRandom();
int dataBlock1 = rand.Next(int.MaxValue);
int singleRedirect = rand.Next(int.MaxValue);
int doubleRedirect = rand.Next(int.MaxValue);
int tripleRedirect = rand.Next(int.MaxValue);
int quadrupleRedirect = rand.Next(int.MaxValue);
SubFileHeader node = new SubFileHeader(fileIdNumber, fileName, isImmutable: false, isSimplified: false);
node.DirectBlock = (uint)dataBlock1;
node.SingleIndirectBlock = (uint)singleRedirect;
node.DoubleIndirectBlock = (uint)doubleRedirect;
node.TripleIndirectBlock = (uint)tripleRedirect;
node.QuadrupleIndirectBlock = (uint)quadrupleRedirect;
SubFileHeader node2 = SaveItem(node);
if (node2.FileIdNumber != fileIdNumber)
{
throw new Exception();
}
if (node2.FileName != fileName)
{
throw new Exception();
}
if (node2.DirectBlock != dataBlock1)
{
throw new Exception();
}
if (node2.SingleIndirectBlock != singleRedirect)
{
throw new Exception();
}
if (node2.DoubleIndirectBlock != doubleRedirect)
{
throw new Exception();
}
if (node2.TripleIndirectBlock != tripleRedirect)
{
throw new Exception();
}
if (node2.QuadrupleIndirectBlock != quadrupleRedirect)
{
throw new Exception();
}
Assert.IsTrue(true);
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
}
private static void TestBinaryStream(DiskIo stream)
{
FileHeaderBlock header = stream.LastCommittedHeader;
header = header.CloneEditable();
SubFileHeader node = header.CreateNewFile(SubFileName.CreateRandom());
header.CreateNewFile(SubFileName.CreateRandom());
header.CreateNewFile(SubFileName.CreateRandom());
SubFileStream ds = new SubFileStream(stream, node, header, false);
BinaryStreamTest.Test(ds);
}
public void Test()
{
int blockSize = 4096;
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
DiskIo stream = DiskIo.CreateMemoryFile(Globals.MemoryPool, blockSize);
SubFileName name = SubFileName.CreateRandom();
SubFileHeader node = new SubFileHeader(1, name, false,false);
SubFileDiskIoSessionPool pool = new SubFileDiskIoSessionPool(stream, stream.LastCommittedHeader, node, true);
IndexParser parse = new IndexParser(pool);
parse.SetPositionAndLookup(14312);
pool.Dispose();
Assert.IsTrue(true);
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
}
public void Test()
{
int blockSize = 4096;
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
DiskIo stream = DiskIo.CreateMemoryFile(Globals.MemoryPool, blockSize);
SubFileName name = SubFileName.CreateRandom();
SubFileHeader node = new SubFileHeader(1, name, false, false);
SubFileDiskIoSessionPool pool = new SubFileDiskIoSessionPool(stream, stream.LastCommittedHeader, node, true);
IndexParser parse = new IndexParser(pool);
parse.SetPositionAndLookup(14312);
pool.Dispose();
Assert.IsTrue(true);
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
}
private static SubFileHeader SaveItem(SubFileHeader node)
{
//Serialize the header
MemoryStream stream = new MemoryStream();
node.Save(new BinaryWriter(stream));
stream.Position = 0;
//load the header
SubFileHeader node2 = new SubFileHeader(new BinaryReader(stream), isImmutable: true, isSimplified: false);
CheckEqual(node2, node);
SubFileHeader node3 = node2.CloneEditable();
CheckEqual(node2, node3);
return node3;
}
private static SubFileHeader SaveItem(SubFileHeader node)
{
//Serialize the header
MemoryStream stream = new MemoryStream();
node.Save(new BinaryWriter(stream));
stream.Position = 0;
//load the header
SubFileHeader node2 = new SubFileHeader(new BinaryReader(stream), isImmutable: true, isSimplified: false);
CheckEqual(node2, node);
SubFileHeader node3 = node2.CloneEditable();
CheckEqual(node2, node3);
return(node3);
}
public SimplifiedSubFileStreamIoSession(FileStream stream, SubFileHeader subFile, FileHeaderBlock header)
{
if (stream == null)
throw new ArgumentNullException("stream");
if (subFile == null)
throw new ArgumentNullException("subFile");
if (header == null)
throw new ArgumentNullException("header");
if (subFile.DirectBlock == 0)
throw new Exception("Must assign subFile.DirectBlock");
m_stream = stream;
m_header = header;
m_blockSize = header.BlockSize;
m_subFile = subFile;
m_memory = new Memory(m_blockSize);
m_buffer = new byte[m_blockSize];
m_currentPhysicalBlock = -1;
m_blockDataLength = m_blockSize - FileStructureConstants.BlockFooterLength;
}
/// <summary>
/// Creates an SimplifiedSubFileStream
/// </summary>
/// <param name="stream">The location to read from.</param>
/// <param name="subFile">The file to read.</param>
/// <param name="fileHeaderBlock">The FileAllocationTable</param>
internal SimplifiedSubFileStream(FileStream stream, SubFileHeader subFile, FileHeaderBlock fileHeaderBlock)
{
if (stream == null)
throw new ArgumentNullException("stream");
if (subFile == null)
throw new ArgumentNullException("subFile");
if (fileHeaderBlock == null)
throw new ArgumentNullException("fileHeaderBlock");
if (subFile.DirectBlock == 0)
throw new Exception("Must assign subFile.DirectBlock");
if (fileHeaderBlock.IsReadOnly)
throw new ArgumentException("This parameter cannot be read only when opening for writing", "fileHeaderBlock");
if (subFile.IsReadOnly)
throw new ArgumentException("This parameter cannot be read only when opening for writing", "subFile");
m_blockSize = fileHeaderBlock.BlockSize;
m_stream = stream;
m_subFile = subFile;
m_fileHeaderBlock = fileHeaderBlock;
}
private static void TestReadAndWrites(DiskIo stream)
{
FileHeaderBlock header = stream.LastCommittedHeader;
header = header.CloneEditable();
SubFileHeader node = header.CreateNewFile(SubFileName.CreateRandom());
header.CreateNewFile(SubFileName.CreateRandom());
header.CreateNewFile(SubFileName.CreateRandom());
SubFileStream ds = new SubFileStream(stream, node, header, false);
TestSingleByteWrite(ds);
TestSingleByteRead(ds);
TestCustomSizeWrite(ds, 5);
TestCustomSizeRead(ds, 5);
TestCustomSizeWrite(ds, BlockDataLength + 20);
TestCustomSizeRead(ds, BlockDataLength + 20);
stream.CommitChanges(header);
}
/// <summary>
/// Creates a new DiskIoSession that can be used to read from the disk subsystem.
/// </summary>
/// <param name="diskIo">owner of the disk</param>
/// <param name="ioSession">the base ioSession to use for this io session</param>
/// <param name="file">The file that will be read from this diskIoSession</param>
public DiskIoSession(DiskIo diskIo, BinaryStreamIoSessionBase ioSession, FileHeaderBlock header, SubFileHeader file)
{
if (diskIo == null)
throw new ArgumentNullException("diskIo");
if (diskIo.IsDisposed)
throw new ObjectDisposedException(diskIo.GetType().FullName);
if (ioSession == null)
throw new ArgumentNullException("ioSession");
if (file == null)
throw new ArgumentNullException("file");
m_args = new BlockArguments();
m_lastReadonlyBlock = diskIo.LastReadonlyBlock;
m_diskMediumIoSession = ioSession;
m_snapshotSequenceNumber = header.SnapshotSequenceNumber;
m_fileIdNumber = file.FileIdNumber;
m_isReadOnly = file.IsReadOnly | diskIo.IsReadOnly;
m_blockSize = diskIo.BlockSize;
m_diskIo = diskIo;
IsValid = false;
IsDisposed = false;
}
/// <summary>
/// Determines if the two objects are equal in value.
/// </summary>
/// <param name="a">the object to compare this class to</param>
/// <returns></returns>
/// <remarks>A debug function</remarks>
internal static bool AreEqual(SubFileHeader a, SubFileHeader b)
{
if (a is null || b is null)
{
return(false);
}
if (b.FileIdNumber != a.FileIdNumber)
{
return(false);
}
if (b.FileName != a.FileName)
{
return(false);
}
if (b.DirectBlock != a.DirectBlock)
{
return(false);
}
if (b.SingleIndirectBlock != a.SingleIndirectBlock)
{
return(false);
}
if (b.DoubleIndirectBlock != a.DoubleIndirectBlock)
{
return(false);
}
if (b.TripleIndirectBlock != a.TripleIndirectBlock)
{
return(false);
}
if (b.QuadrupleIndirectBlock != a.QuadrupleIndirectBlock)
{
return(false);
}
return(true);
}
internal static void CheckEqual(SubFileHeader RO, SubFileHeader RW)
{
if (!AreEqual(RO, RW)) throw new Exception();
}
/// <summary>
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
/// <remarks>A debug function</remarks>
internal static bool AreEqual(FileHeaderBlock other, FileHeaderBlock self)
{
if (other is null)
{
return(false);
}
if (self is null)
{
return(false);
}
if (self.CanWrite != other.CanWrite)
{
return(false);
}
if (self.CanRead != other.CanRead)
{
return(false);
}
if (self.ArchiveId != other.ArchiveId)
{
return(false);
}
if (self.ArchiveType != other.ArchiveType)
{
return(false);
}
if (self.SnapshotSequenceNumber != other.SnapshotSequenceNumber)
{
return(false);
}
if (self.LastAllocatedBlock != other.LastAllocatedBlock)
{
return(false);
}
if (self.FileCount != other.FileCount)
{
return(false);
}
//compare files.
if (self.Files is null)
{
if (other.Files != null)
{
return(false);
}
}
else
{
if (other.Files is null)
{
return(false);
}
if (self.Files.Count != other.Files.Count)
{
return(false);
}
for (int x = 0; x < self.Files.Count; x++)
{
SubFileHeader subFile = self.Files[x];
SubFileHeader subFileOther = other.Files[x];
if (subFile is null)
{
if (subFileOther != null)
{
return(false);
}
}
else
{
if (subFileOther is null)
{
return(false);
}
if (!SubFileMetaDataTest.AreEqual(subFile, subFileOther))
{
return(false);
}
}
}
}
return(self.GetBytes().SequenceEqual(other.GetBytes()));
}
/// <summary>
/// Determines if the two objects are equal in value.
/// </summary>
/// <param name="a">the object to compare this class to</param>
/// <returns></returns>
/// <remarks>A debug function</remarks>
internal static bool AreEqual(SubFileHeader a, SubFileHeader b)
{
if (a == null || b == null)
return false;
if (b.FileIdNumber != a.FileIdNumber) return false;
if (b.FileName != a.FileName) return false;
if (b.DirectBlock != a.DirectBlock) return false;
if (b.SingleIndirectBlock != a.SingleIndirectBlock) return false;
if (b.DoubleIndirectBlock != a.DoubleIndirectBlock) return false;
if (b.TripleIndirectBlock != a.TripleIndirectBlock) return false;
if (b.QuadrupleIndirectBlock != a.QuadrupleIndirectBlock) return false;
return true;
}
/// <summary>
/// Creates a new DiskIoSession that can be used to read from the disk subsystem.
/// </summary>
/// <param name="diskIo">owner of the disk</param>
/// <param name="ioSession">the base ioSession to use for this io session</param>
/// <param name="file">The file that will be read from this diskIoSession</param>
public DiskIoSession(DiskIo diskIo, BinaryStreamIoSessionBase ioSession, FileHeaderBlock header, SubFileHeader file)
{
if (diskIo == null)
{
throw new ArgumentNullException("diskIo");
}
if (diskIo.IsDisposed)
{
throw new ObjectDisposedException(diskIo.GetType().FullName);
}
if (ioSession == null)
{
throw new ArgumentNullException("ioSession");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
m_args = new BlockArguments();
m_lastReadonlyBlock = diskIo.LastReadonlyBlock;
m_diskMediumIoSession = ioSession;
m_snapshotSequenceNumber = header.SnapshotSequenceNumber;
m_fileIdNumber = file.FileIdNumber;
m_isReadOnly = file.IsReadOnly || diskIo.IsReadOnly;
m_blockSize = diskIo.BlockSize;
m_diskIo = diskIo;
IsValid = false;
IsDisposed = false;
}
/// <summary>
/// Creates a <see cref="DiskIoSession"/> that can be used to perform basic read/write functions.
/// </summary>
/// <returns></returns>
public DiskIoSession CreateDiskIoSession(FileHeaderBlock header, SubFileHeader file)
{
if (m_disposed)
throw new ObjectDisposedException(GetType().FullName);
return new DiskIoSession(this, m_stream.CreateIoSession(), header, file);
}
/// <summary>
/// Creates this file with the following data.
/// </summary>
/// <param name="diskIo"></param>
/// <param name="header"></param>
/// <param name="file"></param>
/// <param name="isReadOnly"></param>
public SubFileDiskIoSessionPool(DiskIo diskIo, FileHeaderBlock header, SubFileHeader file, bool isReadOnly)
{
LastReadonlyBlock = diskIo.LastCommittedHeader.LastAllocatedBlock;
File = file;
Header = header;
IsReadOnly = isReadOnly;
SourceData = diskIo.CreateDiskIoSession(header, file);
SourceIndex = diskIo.CreateDiskIoSession(header, file);
if (!isReadOnly)
{
DestinationData = diskIo.CreateDiskIoSession(header, file);
DestinationIndex = diskIo.CreateDiskIoSession(header, file);
}
}
