/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public DiskBlock(IVirtualDisk disk, int index, int occupiedSpaceInBytes, int position)
{
if (disk == null)
{
throw new ArgumentNullException("disk");
}
MethodArgumentValidator.ThrowIfNegative(index, "index");
MethodArgumentValidator.ThrowIfNegative(occupiedSpaceInBytes, "occupiedSpaceInBytes");
MethodArgumentValidator.ThrowIfNegative(position, "position");
if (index >= disk.NumberOfBlocks)
{
throw new ArgumentOutOfRangeException("index");
}
if (occupiedSpaceInBytes > disk.BlockSizeInBytes)
{
throw new ArgumentOutOfRangeException("occupiedSpaceInBytes");
}
if (position > disk.BlockSizeInBytes)
{
throw new ArgumentOutOfRangeException("position");
}
_disk = disk;
_blockIndex = index;
this.OccupiedSpaceInBytes = occupiedSpaceInBytes;
this.SizeInBytes = _disk.BlockSizeInBytes;
_position = position;
}
public NonEmptyDiskBlockEnumerator(
IVirtualDisk disk,
DataStreamDefinition dataStreamDefinition,
AddressingSystemParameters addressingSystemParameters,
IFileSystemNodeStorage fileSystemNodeStorage,
Node streamOwningNode,
EnumeratorAddressable <int> doubleIndirectListEnumerator)
{
if (disk == null)
{
throw new ArgumentNullException("disk");
}
if (dataStreamDefinition == null)
{
throw new ArgumentNullException("dataStreamDefinition");
}
if (addressingSystemParameters == null)
{
throw new ArgumentNullException("addressingSystemParameters");
}
if (fileSystemNodeStorage == null)
{
throw new ArgumentNullException("fileSystemNodeStorage");
}
if (streamOwningNode == null)
{
throw new ArgumentNullException("streamOwningNode");
}
if (doubleIndirectListEnumerator == null)
{
throw new ArgumentNullException("doubleIndirectListEnumerator");
}
_disk = disk;
_dataStreamDefinition = dataStreamDefinition;
_addressingSystemParameters = addressingSystemParameters;
_fileSystemNodeStorage = fileSystemNodeStorage;
_streamOwningNode = streamOwningNode;
_doubleIndirectListEnumerator = doubleIndirectListEnumerator;
if (doubleIndirectListEnumerator.Count == 0)
{
throw new ArgumentException("doubleIndirectListEnumerator");
}
_numberOfBlocks =
SpaceRequirementsCalculator.GetNumberOfChunksNeededToStoreData(_dataStreamDefinition.StreamLengthInBytes, _disk.BlockSizeInBytes);
_blockSizesCalculator = new AddressingBlockSizesCalculator(addressingSystemParameters.IndirectBlockReferencesCountInDoubleIndirectBlock,
addressingSystemParameters.DataBlockReferencesCountInSingleIndirectBlock);
_addressingSystemSizesOfLastBlocks = _blockSizesCalculator.GetSizesOfAddressingBlocksSufficientToStoreItems(_numberOfBlocks);
this.SetFirstSingleIndirectBlock();
_current = new NullDiskBlock();
_position = PositionBeforeFirstElement;
}
public FileManager(IVirtualDisk virtualDisk, FileSystemNodeStorage fileSystemNodeStorage, IEqualityComparer <string> namesComparer, NodeResolver nodeResolver, IFreeBlockManager freeBlockManager, IFolderEnumeratorRegistry folderEnumeratorRegistry, IFileSystemObjectLockingManager lockingManager, BlockReferenceListsEditor blockReferenceListsEditor, PathBuilder pathBuilder, IFileSystemArtifactNamesValidator nameValidator, IPathValidator pathValidator)
{
if (virtualDisk == null)
{
throw new ArgumentNullException("virtualDisk");
}
if (fileSystemNodeStorage == null)
{
throw new ArgumentNullException("fileSystemNodeStorage");
}
if (namesComparer == null)
{
throw new ArgumentNullException("namesComparer");
}
if (nodeResolver == null)
{
throw new ArgumentNullException("nodeResolver");
}
if (freeBlockManager == null)
{
throw new ArgumentNullException("freeBlockManager");
}
if (folderEnumeratorRegistry == null)
{
throw new ArgumentNullException("folderEnumeratorRegistry");
}
if (lockingManager == null)
{
throw new ArgumentNullException("lockingManager");
}
if (blockReferenceListsEditor == null)
{
throw new ArgumentNullException("blockReferenceListsEditor");
}
if (pathBuilder == null)
{
throw new ArgumentNullException("pathBuilder");
}
if (nameValidator == null)
{
throw new ArgumentNullException("nameValidator");
}
if (pathValidator == null)
{
throw new ArgumentNullException("pathValidator");
}
_virtualDisk = virtualDisk;
_pathValidator = pathValidator;
_nameValidator = nameValidator;
_pathBuilder = pathBuilder;
_blockReferenceListsEditor = blockReferenceListsEditor;
_lockingManager = lockingManager;
_folderEnumeratorRegistry = folderEnumeratorRegistry;
_freeBlockManager = freeBlockManager;
_nodeResolver = nodeResolver;
_namesComparer = namesComparer;
_fileSystemNodeStorage = fileSystemNodeStorage;
}
/// <summary>
///
/// </summary>
/// <param name="dataStreamDefinition"></param>
/// <param name="disk"></param>
/// <param name="freeBlockManager"></param>
/// <param name="fileSystemNodeStorage"></param>
/// <param name="governingNode"></param>
/// <param name="addressingSystemParameters"></param>
/// <exception cref="ArgumentNullException"></exception>
public DataStreamStructureBuilder(DataStreamDefinition dataStreamDefinition, IVirtualDisk disk, IFreeBlockManager freeBlockManager, IFileSystemNodeStorage fileSystemNodeStorage, Node governingNode, AddressingSystemParameters addressingSystemParameters)
: base(disk, dataStreamDefinition, addressingSystemParameters, fileSystemNodeStorage, governingNode)
{
if (freeBlockManager == null)
{
throw new ArgumentNullException("freeBlockManager");
}
_freeBlockManager = freeBlockManager;
}
private readonly object _stateProtectingCriticalSection = new object(); // TODO: revisit
public FileSystemNodeStorage(IVirtualDisk virtualDisk)
{
if (virtualDisk == null)
{
throw new ArgumentNullException("virtualDisk");
}
_virtualDisk = virtualDisk;
_binaryFormatter = new BinaryFormatter();
_binaryFormatter.AssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
}
public StructureBuilderTestCollaborators(NodeWithSurroundingsResolvingResult <FileNode> fileNode, IVirtualDisk disk)
{
if (fileNode == null)
{
throw new ArgumentNullException("fileNode");
}
if (disk == null)
{
throw new ArgumentNullException("disk");
}
FileNode = fileNode;
Disk = disk;
}
public static bool CanBlockBelongToDisk(this IVirtualDisk disk, int blockIndex)
{
if (disk == null)
{
throw new ArgumentNullException("disk");
}
if (blockIndex < 0)
{
return(false);
}
return(blockIndex < disk.NumberOfBlocks);
}
public FreeSpaceBitmapStore(IVirtualDisk disk, int freeSpaceMapStartingBlock)
{
if (disk == null)
{
throw new ArgumentNullException("disk");
}
if (!disk.CanBlockBelongToDisk(freeSpaceMapStartingBlock))
{
throw new ArgumentOutOfRangeException("freeSpaceMapStartingBlock");
}
_disk = disk;
_freeSpaceMapStartingBlock = freeSpaceMapStartingBlock;
}
public NodeResolver(
IVirtualDisk virtualDisk,
FileSystemNodeStorage fileSystemNodeStorage,
IEqualityComparer <string> namesComparer,
int rootBlockIndex,
string rootFolderPath,
char directorySeparatorChar,
IPathValidator pathValidator,
PathBuilder pathBuilder)
{
if (virtualDisk == null)
{
throw new ArgumentNullException("virtualDisk");
}
if (fileSystemNodeStorage == null)
{
throw new ArgumentNullException("fileSystemNodeStorage");
}
if (namesComparer == null)
{
throw new ArgumentNullException("namesComparer");
}
if (pathBuilder == null)
{
throw new ArgumentNullException("pathBuilder");
}
if (String.IsNullOrEmpty(rootFolderPath))
{
throw new ArgumentNullException("rootFolderPath");
}
MethodArgumentValidator.ThrowIfNegative(rootBlockIndex, "rootBlockIndex");
if (rootBlockIndex >= virtualDisk.NumberOfBlocks)
{
throw new ArgumentOutOfRangeException("rootBlockIndex");
}
_virtualDisk = virtualDisk;
_pathBuilder = pathBuilder;
_fileSystemNodeStorage = fileSystemNodeStorage;
_namesComparer = namesComparer;
_rootBlockIndex = rootBlockIndex;
_rootFolderPath = rootFolderPath;
_directorySeparatorChar = directorySeparatorChar;
_pathValidator = pathValidator;
}
public DataStreamStructureBuilderImmutable(IVirtualDisk disk, DataStreamDefinition dataStreamDefinition, AddressingSystemParameters addressingSystemParameters, IFileSystemNodeStorage fileSystemNodeStorage, Node governingNode)
{
if (disk == null)
{
throw new ArgumentNullException("disk");
}
if (dataStreamDefinition == null)
{
throw new ArgumentNullException("dataStreamDefinition");
}
if (addressingSystemParameters == null)
{
throw new ArgumentNullException("addressingSystemParameters");
}
if (fileSystemNodeStorage == null)
{
throw new ArgumentNullException("fileSystemNodeStorage");
}
if (governingNode == null)
{
throw new ArgumentNullException("governingNode");
}
_disk = disk;
_governingNode = governingNode;
_fileSystemNodeStorage = fileSystemNodeStorage;
_addressingSystemParameters = addressingSystemParameters;
_dataStreamDefinition = dataStreamDefinition;
int numberOfBlocks =
SpaceRequirementsCalculator.GetNumberOfChunksNeededToStoreData(
dataStreamDefinition.StreamLengthInBytes, addressingSystemParameters.BlockSize);
_addressingBlockSizesCalculator = new AddressingBlockSizesCalculator(addressingSystemParameters.IndirectBlockReferencesCountInDoubleIndirectBlock,
addressingSystemParameters.DataBlockReferencesCountInSingleIndirectBlock);
_sizesOfLastAddressingBlocks = AddressingBlockSizesCalculator.GetSizesOfAddressingBlocksSufficientToStoreItems(numberOfBlocks);
int doubleIndirectBlockSize = _sizesOfLastAddressingBlocks.DoubleIndirectBlockSize;
_doubleIndirectBlocks = new IntegerListConstrained(disk.ReadAllBytesFromBlock(dataStreamDefinition.ContentsBlockIndex), doubleIndirectBlockSize, _addressingSystemParameters.IndirectBlockReferencesCountInDoubleIndirectBlock);
CalculateAndSetMaximumSize(addressingSystemParameters);
}
public BlockReferenceListsEditor(IVirtualDisk virtualDisk, IFreeBlockManager freeBlockManager, FileSystemNodeStorage fileSystemNodeStorage)
{
if (virtualDisk == null)
{
throw new ArgumentNullException("virtualDisk");
}
if (freeBlockManager == null)
{
throw new ArgumentNullException("freeBlockManager");
}
if (fileSystemNodeStorage == null)
{
throw new ArgumentNullException("fileSystemNodeStorage");
}
_virtualDisk = virtualDisk;
_fileSystemNodeStorage = fileSystemNodeStorage;
_freeBlockManager = freeBlockManager;
}
public VHDInfo GetBaseCfg()
{
VHDInfo vhdInfo;
try
{
vhdInfo = this.GetCfg();
while (!string.IsNullOrEmpty(vhdInfo.ParentPath))
{
using (IVirtualDisk virtualDisk = (IVirtualDisk) new VirtualDisk(this._Host, vhdInfo.ParentPath, this._Logger))
vhdInfo = virtualDisk.GetCfg();
}
}
catch (Exception ex)
{
vhdInfo = new VHDInfo();
this._Logger.FormatErrorWithException(ex, "Failed to get the base vhd cfg information due to exception: ");
}
return(vhdInfo);
}
public AllCollaborators(IVirtualDisk disk, IFileSystemNodeStorage diskStructuresManager, IFileSystemArtifactNamesValidator nameValidator, IPathValidator pathValidator, NodeResolver nodeResolver, VirtualFileSystem virtualFileSystem, FileInfo fileNodeFake, Stream stream)
{
if (disk == null)
{
throw new ArgumentNullException("disk");
}
if (diskStructuresManager == null)
{
throw new ArgumentNullException("diskStructuresManager");
}
if (nameValidator == null)
{
throw new ArgumentNullException("nameValidator");
}
if (pathValidator == null)
{
throw new ArgumentNullException("pathValidator");
}
if (nodeResolver == null)
{
throw new ArgumentNullException("nodeResolver");
}
if (virtualFileSystem == null)
{
throw new ArgumentNullException("virtualFileSystem");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
Disk = disk;
DiskStructuresManager = diskStructuresManager;
NameValidator = nameValidator;
PathValidator = pathValidator;
NodeResolver = nodeResolver;
VirtualFileSystem = virtualFileSystem;
FileNodeFake = fileNodeFake;
Stream = stream;
}
public void Format(IVirtualDisk virtualDisk, FileSystemNodeStorage fileSystemNodeStorage)
{
var numberOfBlocksToMap = virtualDisk.NumberOfBlocks - FileSystemHeaderReservedBlocks;
int numberOfBytesNeededToStoreTheMap =
SpaceRequirementsCalculator.GetNumberOfChunksNeededToStoreData(numberOfBlocksToMap, Constants.NumberOfBitsInByte);
int numberOfBlocksNeededToStoreTheMap =
SpaceRequirementsCalculator.GetNumberOfChunksNeededToStoreData(numberOfBytesNeededToStoreTheMap,
virtualDisk.BlockSizeInBytes);
numberOfBlocksToMap -= numberOfBlocksNeededToStoreTheMap;
var freeSpaceBitmap = new BitArray(numberOfBytesNeededToStoreTheMap);
freeSpaceBitmap.Length = numberOfBlocksToMap;
var store = new FreeSpaceBitmapStore(virtualDisk, VirtualDiskFormatter.FreeSpaceStartingBlockIndex);
var freeBlockManagerBitArrayBased =
new FreeBlockManagerBitArrayBased(freeSpaceBitmap, FreeSpaceStartingBlockIndex + numberOfBlocksNeededToStoreTheMap, numberOfBlocksToMap);
var freeBlockManager = new FreeBlockManagerDiskWriting(store, freeBlockManagerBitArrayBased);
var freeBlocks = freeBlockManager.AcquireFreeBlocks(3);
int rootBlockIndex = freeBlocks[0];
int rootFileReferencesBlock = freeBlocks[1];
int rootFolderReferencesBlock = freeBlocks[2];
var fileContentsStreamDefinition = new DataStreamDefinition(rootFileReferencesBlock, 0);
var folderContentsStreamDefinition = new DataStreamDefinition(rootFolderReferencesBlock, 0);
var rootNode = new FolderNode("root", Guid.NewGuid(), rootBlockIndex, 0, fileContentsStreamDefinition, folderContentsStreamDefinition, DateTime.UtcNow, Guid.NewGuid());
fileSystemNodeStorage.WriteNode(rootNode);
fileSystemNodeStorage.WriteFileSystemHeader(new FileSystemHeader(rootBlockIndex, new Version(1, 0, 0, 0)), FileSystemHeaderBlockIndex);
}
public DataStreamTestCollaboratorSet(IVirtualDisk disk, IFileSystemNodeStorage fileSystemNodeStorage, FileInfo fileInfo, VirtualFileSystem virtualFileSystem)
{
if (disk == null)
{
throw new ArgumentNullException("disk");
}
if (fileSystemNodeStorage == null)
{
throw new ArgumentNullException("fileSystemNodeStorage");
}
if (fileInfo == null)
{
throw new ArgumentNullException("fileInfo");
}
if (virtualFileSystem == null)
{
throw new ArgumentNullException("virtualFileSystem");
}
Disk = disk;
FileSystemNodeStorage = fileSystemNodeStorage;
FileInfo = fileInfo;
VirtualFileSystem = virtualFileSystem;
}
public void CreateVirtualDisk(string path, ulong size, string virtualDiskType, ushort format)
{
if (File.Exists(path))
{
this._Logger.Information(string.Format("Validating existing disk {0}...", (object)path));
try
{
using (IVirtualDisk virtualDisk = this.ValidateVirtualDisk(path))
{
if (virtualDisk != null)
{
if (virtualDisk.GetCfg().MaxInternalSize >= (long)size)
{
this._Logger.Information("Existing disk validated.");
return;
}
}
}
}
catch (Exception ex)
{
if (this.HandleException(ex))
{
throw;
}
else
{
this._Logger.Warning(ex, "Existing disk validation failed");
}
}
this._Logger.Information(string.Format("Deleting existing disk {0}...", (object)path));
File.Delete(path);
}
if ((long)(size % 4096UL) != 0L)
{
size += 4096UL - size % 4096UL;
}
using (IImageManagementService managementService = ImageManagementService.GetImageManagementService(this._Host))
{
using (IVirtualHardDiskSettingData hardDiskSettingData = VirtualHardDiskSettingData.CreateVirtualHardDiskSettingData(this._Host))
{
hardDiskSettingData.Path = path;
hardDiskSettingData.MaxInternalSize = size;
if (!(virtualDiskType == "Fixed"))
{
if (!(virtualDiskType == "Dynamic"))
{
throw new HyperVException("Don't know how to create a disk of type " + virtualDiskType);
}
hardDiskSettingData.Type = (ushort)3;
}
else
{
hardDiskSettingData.Type = (ushort)2;
}
hardDiskSettingData.Format = format;
hardDiskSettingData.PhysicalSectorSize = 512U;
managementService.CreateVirtualHardDisk(hardDiskSettingData);
}
}
}
public TestDataStreamStructureBuilder(DataStreamDefinition dataStreamDefinition, IVirtualDisk disk, IFreeBlockManager freeBlockManager, IFileSystemNodeStorage fileSystemNodeStorage, Node governingNode, AddressingSystemParameters addressingSystemParameters)
: base(dataStreamDefinition, disk, freeBlockManager, fileSystemNodeStorage, governingNode, addressingSystemParameters)
{
}
/// <summary>
///
/// </summary>
/// <param name="disk"></param>
/// <param name="namesComparer"></param>
/// <param name="nodeResolver"></param>
/// <param name="pathBuilder"></param>
/// <param name="namesValidator"></param>
/// <param name="pathValidator"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="InconsistentDataDetectedException"></exception>
internal static VirtualFileSystem CreateFromDisk(IVirtualDisk disk, IEqualityComparer <string> namesComparer, NodeResolver nodeResolver, PathBuilder pathBuilder, IFileSystemArtifactNamesValidator namesValidator, IPathValidator pathValidator)
{
if (disk == null)
{
throw new ArgumentNullException("disk");
}
if (namesComparer == null)
{
throw new ArgumentNullException("namesComparer");
}
if (nodeResolver == null)
{
throw new ArgumentNullException("nodeResolver");
}
if (pathBuilder == null)
{
throw new ArgumentNullException("pathBuilder");
}
if (namesValidator == null)
{
throw new ArgumentNullException("namesValidator");
}
if (pathValidator == null)
{
throw new ArgumentNullException("pathValidator");
}
VirtualFileSystemInfo fileSystemInfo;
var fileSystemNodeStorage = new FileSystemNodeStorage(disk);
const int headerBlockIndex = VirtualDiskFormatter.FileSystemHeaderBlockIndex;
const int freeBlockBitmapStartingBlockIndex = VirtualDiskFormatter.FreeSpaceStartingBlockIndex;
var header = fileSystemNodeStorage.ReadFileSystemHeader(headerBlockIndex);
fileSystemInfo = new VirtualFileSystemInfo(header.Version, disk.BlockSizeInBytes, header.RootBlockOffset, freeBlockBitmapStartingBlockIndex);
var freeSpaceBitmapStore = new FreeSpaceBitmapStore(disk, VirtualDiskFormatter.FreeSpaceStartingBlockIndex);
int bitmapSize;
var freeSpaceMap = freeSpaceBitmapStore.ReadMap(out bitmapSize);
var freeSpaceBitArray = new BitArray(freeSpaceMap)
{
Length = bitmapSize
};
var freeBlockManagerBitArrayBased = new FreeBlockManagerBitArrayBased(freeSpaceBitArray,
fileSystemInfo.FirstNonReservedDiskBlockIndex,
bitmapSize);
IFreeBlockManager freeBlockManager = new FreeBlockManagerDiskWriting(freeSpaceBitmapStore, freeBlockManagerBitArrayBased);
IFolderEnumeratorRegistry folderEnumeratorRegistry = new FolderEnumeratorRegistry();
IFileSystemObjectLockingManager lockingManager = new FileSystemObjectLockingManager();
var blockReferenceEditor = new BlockReferenceListsEditor(disk, freeBlockManager, fileSystemNodeStorage);
//Note: много общих коллабораторов у трех классов. Недорефакторено.
var fileManager = new FileManager(disk, fileSystemNodeStorage, namesComparer, nodeResolver, freeBlockManager, folderEnumeratorRegistry, lockingManager, blockReferenceEditor, pathBuilder, namesValidator, pathValidator);
var folderManager = new FolderManager(fileSystemNodeStorage, namesComparer, nodeResolver, freeBlockManager, folderEnumeratorRegistry, lockingManager, blockReferenceEditor, pathBuilder, namesValidator, pathValidator);
return(new VirtualFileSystem(disk, fileSystemInfo, fileSystemNodeStorage, namesComparer, nodeResolver, freeBlockManager, folderEnumeratorRegistry, blockReferenceEditor, pathBuilder, namesValidator, pathValidator, fileManager, folderManager));
}
private VirtualFileSystem(
IVirtualDisk virtualDisk,
VirtualFileSystemInfo fileSystemInfo,
FileSystemNodeStorage fileSystemNodeStorage,
IEqualityComparer <string> namesComparer,
NodeResolver nodeResolver,
IFreeBlockManager freeBlockManager,
IFolderEnumeratorRegistry folderEnumeratorRegistry,
BlockReferenceListsEditor blockReferenceListsEditor,
PathBuilder pathBuilder,
IFileSystemArtifactNamesValidator nameValidator,
IPathValidator pathValidator,
FileManager fileManager,
FolderManager folderManager)
{
if (fileSystemInfo == null)
{
throw new ArgumentNullException("fileSystemInfo");
}
if (fileSystemNodeStorage == null)
{
throw new ArgumentNullException("fileSystemNodeStorage");
}
if (namesComparer == null)
{
throw new ArgumentNullException("namesComparer");
}
if (nodeResolver == null)
{
throw new ArgumentNullException("nodeResolver");
}
if (freeBlockManager == null)
{
throw new ArgumentNullException("freeBlockManager");
}
if (folderEnumeratorRegistry == null)
{
throw new ArgumentNullException("folderEnumeratorRegistry");
}
if (blockReferenceListsEditor == null)
{
throw new ArgumentNullException("blockReferenceListsEditor");
}
if (pathBuilder == null)
{
throw new ArgumentNullException("pathBuilder");
}
if (nameValidator == null)
{
throw new ArgumentNullException("nameValidator");
}
if (pathValidator == null)
{
throw new ArgumentNullException("pathValidator");
}
if (folderManager == null)
{
throw new ArgumentNullException("folderManager");
}
_virtualDisk = virtualDisk;
_folderManager = folderManager;
_folderManager = folderManager;
_folderManager = folderManager;
_folderManager = folderManager;
_fileManager = fileManager;
_pathBuilder = pathBuilder;
_folderEnumeratorRegistry = folderEnumeratorRegistry;
_nodeResolver = nodeResolver;
_freeBlockManager = freeBlockManager;
_fileSystemInfo = fileSystemInfo;
_namesComparer = namesComparer;
}
