internal static AllCollaborators CreateAllCollaborators(int numberOfBlocks, bool createTestFile)
{
var stream = new MemoryStream();
// new FileStream(@"e:\" + Guid.NewGuid().ToString("N"), FileMode.Create);
var formatter = new VirtualDiskFormatter();
VirtualDisk disk = VirtualDisk.CreateFormattingTheStream(stream, VirtualDisk.OnlySupportedBlockSize, VirtualDisk.OnlySupportedBlockSize * numberOfBlocks);
var diskStructuresManager = new FileSystemNodeStorage(disk);
formatter.Format(disk, diskStructuresManager);
FileSystemHeader header = diskStructuresManager.ReadFileSystemHeader(VirtualDiskFormatter.FileSystemHeaderBlockIndex);
var nameValidator = FileSystemArtifactNamesValidator.Default;
var pathValidator = PathValidator.Default;
var pathBuilder = PathBuilder.Default;
var nodeResolver = new NodeResolver(disk, diskStructuresManager, StringComparer.OrdinalIgnoreCase, header.RootBlockOffset, VirtualFileSystem.Root, VirtualFileSystem.DirectorySeparatorChar, pathValidator, pathBuilder);
var virtualFileSystem = VirtualFileSystem.CreateFromDisk(disk, StringComparer.OrdinalIgnoreCase, nodeResolver, pathBuilder, nameValidator, pathValidator);
FileInfo fileNodeFake = null;
if (createTestFile)
{
fileNodeFake = virtualFileSystem.CreateFile(@"\hey");
}
return(new AllCollaborators(disk, diskStructuresManager, nameValidator, pathValidator, nodeResolver, virtualFileSystem, fileNodeFake, stream));
}
public static DataStreamTestCollaboratorSet CreateCollaboratorsForTestingDataStreamsOneGigabyteDrive()
{
var stream = new FileStream(@"e:\tests.vhd", FileMode.Create);
var formatter = new VirtualDiskFormatter();
VirtualDisk disk = VirtualDisk.CreateFormattingTheStream(stream, 2048, 2048 * 500000);
var diskStructuresManager = new FileSystemNodeStorage(disk);
formatter.Format(disk, diskStructuresManager);
FileSystemHeader header = diskStructuresManager.ReadFileSystemHeader(VirtualDiskFormatter.FileSystemHeaderBlockIndex);
var nameValidator = FileSystemArtifactNamesValidator.Default;
var pathValidator = PathValidator.Default;
var pathBuilder = PathBuilder.Default;
var nodeResolver = new NodeResolver(disk, diskStructuresManager, StringComparer.OrdinalIgnoreCase, header.RootBlockOffset, VirtualFileSystem.Root, VirtualFileSystem.DirectorySeparatorChar, pathValidator, pathBuilder);
var virtualFileSystem = VirtualFileSystem.CreateFromDisk(disk, StringComparer.OrdinalIgnoreCase, nodeResolver, pathBuilder, nameValidator, pathValidator);
var fileNodeFake = virtualFileSystem.CreateFile(@"\hey");
return(new DataStreamTestCollaboratorSet(disk, diskStructuresManager, fileNodeFake, virtualFileSystem));
}
public void TryFormattingADiskAndInitializingFileSystemWithIt()
{
Stream stream = new MemoryStream(); // System.IO.File.Open(@"c:\bs.bin", FileMode.Create);
var formatter = new VirtualDiskFormatter();
VirtualDisk disk = VirtualDisk.CreateFormattingTheStream(stream, 2048, 2048 * 5000);
var diskStructuresManager = new FileSystemNodeStorage(disk);
formatter.Format(disk, diskStructuresManager);
FileSystemHeader header = diskStructuresManager.ReadFileSystemHeader(VirtualDiskFormatter.FileSystemHeaderBlockIndex);
var nameValidator = new FileSystemArtifactNamesValidator(Constants.IllegalCharactersForNames, Constants.FileAndFolderMaximumNameLength);
var pathValidator = new PathValidator(VirtualFileSystem.Root, Constants.IllegalCharactersForPaths, nameValidator, VirtualFileSystem.DirectorySeparatorChar);
var pathBuilder = PathBuilder.Default;
var nodeResolver = new NodeResolver(disk, diskStructuresManager, StringComparer.OrdinalIgnoreCase, header.RootBlockOffset, VirtualFileSystem.Root, VirtualFileSystem.DirectorySeparatorChar, pathValidator, pathBuilder);
VirtualFileSystem fileSystem = VirtualFileSystem.CreateFromDisk(disk, StringComparer.OrdinalIgnoreCase, nodeResolver, pathBuilder, nameValidator, pathValidator);
Assert.AreEqual(2048, fileSystem.FileSystemInfo.BlockSizeInBytes);
Assert.AreEqual(new Version(1, 0, 0, 0), fileSystem.FileSystemInfo.Version);
}
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>
/// Creates a new TDWay from an osmosis way entity using the given NodeResolver.
/// </summary>
/// <param name="way">
/// the way </param>
/// <param name="resolver">
/// the resolver </param>
/// <param name="preferredLanguages">
/// the preferred language(s) or null if no preference </param>
/// <returns> a new TDWay if it is valid, null otherwise </returns>
public static TDWay fromWay(Way way, NodeResolver resolver, IList <string> preferredLanguages)
{
if (way == null)
{
return(null);
}
SpecialTagExtractionResult ster = OSMUtils.extractSpecialFields(way, preferredLanguages);
short[] knownWayTags = OSMUtils.extractKnownWayTags(way);
// only ways with at least 2 way nodes are valid ways
if (way.WayNodes.size() >= 2)
{
bool validWay = true;
// retrieve way nodes from data store
TDNode[] waynodes = new TDNode[way.WayNodes.size()];
int i = 0;
foreach (WayNode waynode in way.WayNodes)
{
// TODO adjust interface to support a method getWayNodes()
waynodes[i] = resolver.getNode(waynode.NodeId);
if (waynodes[i] == null)
{
validWay = false;
LOGGER.finer("unknown way node: " + waynode.NodeId + " in way " + way.Id);
}
i++;
}
// for a valid way all way nodes must be existent in the input data
if (validWay)
{
// mark the way as polygon if the first and the last way node are the same
// and if the way has at least 4 way nodes
sbyte shape = LINE;
if (waynodes[0].Id == waynodes[waynodes.Length - 1].Id)
{
if (waynodes.Length >= GeoUtils.MIN_NODES_POLYGON)
{
if (OSMUtils.isArea(way))
{
shape = SIMPLE_POLYGON;
}
}
else
{
LOGGER.finer("Found closed polygon with fewer than 4 way nodes. Way-id: " + way.Id);
return(null);
}
}
return(new TDWay(way.Id, ster.Layer, ster.Name, ster.Housenumber, ster.Ref, knownWayTags, shape, waynodes));
}
}
return(null);
}
public Node(Tree tree, IToken token, IProvider provider, bool isNegative, NodeFilterInfo filterInfo, int id)
{
this.id = id;
Token = token;
Provider = provider;
IsNegative = isNegative;
FilterInfo = filterInfo;
Tree = tree;
Resolver = new NodeResolver(this);
}
/// <summary>
/// Создает виртуальную файловую систему с настройками по умолчанию, на основе указанного файла.
/// </summary>
/// <param name="fullPathForFile">Файл, который файловая система должна использовать для хранения своих данных. Принимаются только пути, ведущие к несуществующим файлам.</param>
/// <param name="desiredSizeInBytes">Размер нового диска. В текущей версии должен быть кратен 2048 байтам, не больше 1Гб.</param>
/// <returns>Экземпляр файловой системы, в качестве хранилища использующей указанный файл.</returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="FileSystemCreationFailedException"></exception>
public static VirtualFileSystem CreateNew(string fullPathForFile, int desiredSizeInBytes)
{
if (String.IsNullOrEmpty(fullPathForFile))
{
throw new ArgumentNullException("fullPathForFile", "Путь к файлу не может быть пустым.");
}
var stream = CreateStreamWrappingExceptions(fullPathForFile);
try
{
var formatter = new VirtualDiskFormatter();
VirtualDisk disk = VirtualDisk.CreateFormattingTheStream(stream, VirtualDisk.OnlySupportedBlockSize, desiredSizeInBytes);
var diskStructuresManager = new FileSystemNodeStorage(disk);
formatter.Format(disk, diskStructuresManager);
FileSystemHeader header = diskStructuresManager.ReadFileSystemHeader(VirtualDiskFormatter.FileSystemHeaderBlockIndex);
var nameValidator = FileSystemArtifactNamesValidator.Default;
var pathValidator = PathValidator.Default;
var pathBuilder = PathBuilder.Default;
var nodeResolver = new NodeResolver(disk, diskStructuresManager, StringComparer.OrdinalIgnoreCase, header.RootBlockOffset, VirtualFileSystem.Root, VirtualFileSystem.DirectorySeparatorChar, pathValidator, pathBuilder);
var newVirtualFileSystem = VirtualFileSystem.CreateFromDisk(disk, StringComparer.OrdinalIgnoreCase, nodeResolver, pathBuilder, nameValidator, pathValidator);
return(newVirtualFileSystem);
}
catch (InconsistentDataDetectedException exception)
{
CleanUpInconsistentFileSystemContainer(fullPathForFile, stream);
throw CreateGenericSystemCreationException(exception, fullPathForFile);
}
catch (VirtualDiskCreationFailedException exception)
{
CleanUpInconsistentFileSystemContainer(fullPathForFile, stream);
throw CreateGenericSystemCreationException(exception, fullPathForFile);
}
}
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;
}
static int?InvokeFunction(string name, System.Collections.IList arguments, NodeResolver document)
{
var finalArgs = new List <int?>();
var func = GetFunction(name);
if (func == null)
{
return(null);
}
int paramCount = func.Parameters.Count;
if (func.IsVariadic)
{
paramCount--;
}
if (arguments.Count < paramCount)
{
TrackerErrorLog.LogError("Function " + func.Name + " called with only " + arguments.Count + "arguments.");
}
if (arguments.Count > paramCount && !func.IsVariadic)
{
TrackerErrorLog.LogError("Function " + func.Name + " called with too many arguments.");
}
for (int i = 0; i < arguments.Count; i++)
{
finalArgs.Add(EvaluateArg(arguments[i], document));
}
while (finalArgs.Count < paramCount)
{
finalArgs.Add(null);
}
return(func.Executor(finalArgs));
}
public static VirtualFileSystem CreateFileSystemFromExistingStream(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
VirtualDisk disk = VirtualDisk.CreateFromStream(stream);
var diskStructuresManager = new FileSystemNodeStorage(disk);
FileSystemHeader header = diskStructuresManager.ReadFileSystemHeader(VirtualDiskFormatter.FileSystemHeaderBlockIndex);
var nameValidator = FileSystemArtifactNamesValidator.Default;
var pathValidator = PathValidator.Default;
var pathBuilder = PathBuilder.Default;
var nodeResolver = new NodeResolver(disk, diskStructuresManager, StringComparer.OrdinalIgnoreCase, header.RootBlockOffset, VirtualFileSystem.Root, VirtualFileSystem.DirectorySeparatorChar, pathValidator, pathBuilder);
return(VirtualFileSystem.CreateFromDisk(disk, StringComparer.OrdinalIgnoreCase, nodeResolver, pathBuilder, nameValidator, pathValidator));
}
// Note: этот код специально прилеплен к и без того немаленькому VirtualFileSystem. Это повышает discoverability фабричных методов (по сравнению с выделением фабрики) и усиливает ограничения (private-конструктор против internal-конструктора).
/// <summary>
/// Создает виртуальную файловую систему с настройками по умолчанию, на основе указанного файла.
/// </summary>
/// <param name="fullPathForFile"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="FileSystemCreationFailedException"></exception>
public static VirtualFileSystem OpenExisting(string fullPathForFile)
{
if (String.IsNullOrEmpty(fullPathForFile))
{
throw new ArgumentNullException("fullPathForFile");
}
FileStream stream = CreateStreamFromExistingFileWrappingExceptions(fullPathForFile);
try
{
VirtualDisk disk = VirtualDisk.CreateFromStream(stream);
var diskStructuresManager = new FileSystemNodeStorage(disk);
FileSystemHeader header = diskStructuresManager.ReadFileSystemHeader(VirtualDiskFormatter.FileSystemHeaderBlockIndex);
var nameValidator = FileSystemArtifactNamesValidator.Default;
var pathValidator = PathValidator.Default;
var pathBuilder = PathBuilder.Default;
var nodeResolver = new NodeResolver(disk, diskStructuresManager, StringComparer.OrdinalIgnoreCase, header.RootBlockOffset, VirtualFileSystem.Root, VirtualFileSystem.DirectorySeparatorChar, pathValidator, pathBuilder);
return(VirtualFileSystem.CreateFromDisk(disk, StringComparer.OrdinalIgnoreCase, nodeResolver, pathBuilder, nameValidator, pathValidator));
}
catch (VirtualDiskCreationFailedException exception)
{
throw CreateGenericSystemCreationFromExistingFileException(exception, fullPathForFile);
}
catch (InconsistentDataDetectedException exception)
{
throw CreateGenericSystemCreationFromExistingFileException(exception, fullPathForFile);
}
}
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;
}
private static int?EvaluateArg(object arg, NodeResolver document)
{
if (arg == null)
{
return(null);
}
if (arg is int?)
{
return((int?)arg);
}
if (arg is int)
{
return((int)arg);
}
if (arg is JToken)
{
if (arg is JObject)
{
var jArg = (JObject)arg;
if (jArg.Count != 1)
{
TrackerErrorLog.LogError("Invalid object. Only one child allowed.");
return(null);
}
string funcName = null;
JToken argList = null;
// It's kind of dumb that you can't just numerically index the properties
foreach (var p in jArg.Properties())
{
funcName = p.Name;
argList = p.Value;
if (!(argList is JArray))
{
TrackerErrorLog.LogError("Function parameters must be passed into an array.");
return(null);
}
if (funcName.Length == 0 || funcName[0] != '@')
{
TrackerErrorLog.LogError("Unexpected object. If this is supposed to be a function, prefix \"" + funcName + "\" with \"@\".");
return(null);
}
funcName = funcName.Substring(1);
}
return(InvokeFunction(funcName, (JArray)argList, document));
}
else
{
var jArg = (JToken)arg;
if (jArg.Type == JTokenType.String)
{
// Document property reference
return((int)document((string)jArg));
}
else if (jArg.Type == JTokenType.Integer)
{
return((int)jArg);
}
}
}
TrackerErrorLog.LogError("Invalid argument type: " + arg.GetType().ToString());
if (arg is int)
{
return((int)arg);
}
return(null);
}
public static int?EvaluateExpression(JToken expr, NodeResolver resolver)
{
return(EvaluateArg(expr, resolver));
}
/// <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));
}
