public void ShouldNotReadKeyfileIfKeyIsInPath() { var key = 1L; var filesystem = new MemoryFileSystem(); var options = new FilesystemStorageOptions(); var mockFormatter = new Mock <IFormatter <BinaryReader, BinaryWriter> >(); var entityIO = new FilesystemEntityReaderWriter <long, BinaryReader, BinaryWriter>( filesystem, mockFormatter.Object, options ); using (var stream = entityIO.BeginWrite(key)) stream.Write("mock"); Assert.True(entityIO.Exists(key)); var keys = entityIO.GetAllKeys(); Assert.Contains(key, keys); Assert.Single(keys); mockFormatter.Verify(mock => mock.Deserialize( It.IsAny <Type>(), It.IsAny <BinaryReader>(), null ), Times.Never()); }
public void TestNumericKeyWithPartitioning(string directory) { int key1 = 123; int key2 = 1123; var basePath = FileSystemPath.Root.AppendDirectory(directory); var options = new FilesystemStorageOptions() { BasePath = basePath, EntitiesPerDirectory = 1000 }; var expected1 = basePath.AppendDirectory("0") .AppendDirectory(key1.ToString()) .AppendFile(EntityFilename); var actual1 = FilesystemLocator.LocateEntityFile(key1, options); Assert.Equal(expected1, actual1); var expected2 = basePath.AppendDirectory("1") .AppendDirectory(key2.ToString()) .AppendFile(EntityFilename); var actual2 = FilesystemLocator.LocateEntityFile(key2, options); Assert.Equal(expected2, actual2); }
internal override ISnapshotManager <long, SampleData> Build() { var options = new FilesystemStorageOptions(); var filesystem = new MemoryFileSystem(); return(new SingleFileSnapshotManager <long, SampleData, XmlDocumentAdapter, XmlWriterAdapter>( options, new XmlFormatter(), filesystem)); }
/// <summary> /// Sets up the engine to use the last-in-first-out optimized snapshot storage, /// suitable for fast reading of recent data. /// </summary> /// <param name="formatter"> /// Specifies a <see cref="IFormatter<TInputStream, TOutputStream>"/> which /// will be used for serialization and deserialization. /// </param> /// <param name="options"> /// If not null, overrides the default <see cref="FilesystemStorageOptions"/>. /// </param> /// <param name="zeroPaddingBytes"> /// Specifies maximum free space at the start of the file for future /// snapshots. When there is no free space left for writing, the file /// expands by specified byte count and rewrites. /// <para> /// If the number is too small, rewrites may appear often. /// </para> /// <para> /// If the number is big, files will be bigger and may consist /// of big unused space depending on how many data is being written. /// </para> /// </param> public DiffstoreBuilder <TKey, TValue> WithLastFirstOptimizedSnapshots( IFileSystem fileSystem = null, FilesystemStorageOptions options = null, int zeroPaddingBytes = 256) { (fileSystem, options) = PrepareFileStorage(fileSystem, options); sm = new BinaryLIFOSnapshotManager <TKey, TValue>(options, fileSystem, zeroPaddingBytes); return(this); }
public BinaryLIFOSnapshotManager(FilesystemStorageOptions opts, IFileSystem fs, int maxPadding) { (options, fileSystem, zeroPaddingStep) = (opts, fs, maxPadding); if (options.MaxSnapshotFileSize % zeroPaddingStep != 0) { throw new ArgumentException( "MaxSnapshotFileSize must be a multiple of maxPadding"); } }
internal override ISnapshotManager <long, SampleData> Build() { var options = new FilesystemStorageOptions() { MaxSnapshotFileSize = 512 }; var filesystem = new MemoryFileSystem(); return(new BinaryLIFOSnapshotManager <long, SampleData>( options, filesystem, 128)); }
public FilesystemEntityReaderWriterTest() { var filesystem = new MemoryFileSystem(); var options = new FilesystemStorageOptions(); entityIO = new FilesystemEntityReaderWriter <long, BinaryReader, BinaryWriter>( filesystem, FastBinaryFormatter.Instance, options ); }
/// <summary> /// Sets up the engine to use file-based entity storage. /// </summary> /// <param name="formatter"> /// Specifies a <see cref="IFormatter<TInputStream, TOutputStream>"/> which /// will be used for serialization and deserialization. /// </param> /// <param name="options"> /// If not null, overrides the default <see cref="FilesystemStorageOptions"/>. /// </param> /// <param name="fileSystem"> /// If not null, uses the specified IFileSystem, otherwise uses /// what has been called before. /// </param> public DiffstoreBuilder <TKey, TValue> WithFileBasedEntities <TIn, TOut>( IFormatter <TIn, TOut> formatter, FilesystemStorageOptions options = null, IFileSystem fileSystem = null) where TIn : IDisposable where TOut : IDisposable { (fileSystem, options) = PrepareFileStorage(fileSystem, options); var entityIO = new FilesystemEntityReaderWriter <TKey, TIn, TOut>( fileSystem, formatter, options); em = new EntityManager <TKey, TValue, TIn, TOut>(formatter, entityIO); return(this); }
public void TestKeyfileLocation(string directory) { int key = 123; var basePath = FileSystemPath.Root.AppendDirectory(directory); var options = new FilesystemStorageOptions() { BasePath = basePath, EntitiesPerDirectory = 0 }; var expected = basePath.AppendDirectory(key.ToString()).AppendFile(KeyFilename); var actual = FilesystemLocator.LocateKeyFile(key, options); Assert.Equal(expected, actual); }
internal override IEntityManager <long, SampleData> Build() { var filesystem = new MemoryFileSystem(); var formatter = FastBinaryFormatter.Instance; var options = new FilesystemStorageOptions() { EntitiesPerDirectory = 1000 }; var entityIO = new FilesystemEntityReaderWriter <long, BinaryReader, BinaryWriter> (filesystem, formatter, options); return(new EntityManager <long, SampleData, BinaryReader, BinaryWriter> (formatter, entityIO)); }
public void TestNonPartitionableKey(string directory, int entitiesPerDir) { var key = "Hello World"; var basePath = FileSystemPath.Root.AppendDirectory(directory); var options = new FilesystemStorageOptions() { BasePath = basePath, EntitiesPerDirectory = entitiesPerDir }; var expected = basePath.AppendDirectory(key.GetHashCode().ToString()) .AppendFile(EntityFilename); var actual = FilesystemLocator.LocateEntityFile(key, options); Assert.Equal(expected, actual); }
private (IFileSystem, FilesystemStorageOptions) PrepareFileStorage( IFileSystem fileSystem, FilesystemStorageOptions options) { if (options == null) { options = new FilesystemStorageOptions(); } if (fileSystem == null) { fileSystem = this.fileSystem; } if (fileSystem == null) { throw new InvalidOperationException( "To use file-based snapshots, select the filesystem type " + "by calling either InMemory() or OnDisk(...)" ); } return(fileSystem, options); }
/// <summary> /// Sets up the engine to use file-based entity storage. /// </summary> /// <param name="format"> /// Specifies the <see cref="FileFormat"/> which will be used for /// serialization and deserialization. /// </param> /// <param name="options"> /// If not null, overrides the default <see cref="FilesystemStorageOptions"/>. /// </param> /// <param name="fileSystem"> /// If not null, uses the specified IFileSystem, otherwise uses /// what has been called before. /// </param> public DiffstoreBuilder <TKey, TValue> WithFileBasedEntities( FileFormat format, FilesystemStorageOptions options = null, IFileSystem fileSystem = null) { (fileSystem, options) = PrepareFileStorage(fileSystem, options); switch (format) { case FileFormat.Binary: return(WithFileBasedEntities(FastBinaryFormatter.Instance, options, fileSystem)); case FileFormat.XML: return(WithFileBasedEntities(XmlFormatter.Instance, options, fileSystem)); case FileFormat.JSON: return(WithFileBasedEntities(JsonFormatter.Instance, options, fileSystem)); default: throw new InvalidOperationException("Unsupported format"); } }
/// <summary> /// Sets up the engine to use the single-file-per-snapshot storage. /// Suitable for big entities and/or when they need to be human-readable. /// </summary> /// <param name="format"> /// Specifies the <see cref="FileFormat"/> which will be used for /// serialization and deserialization. /// </param> /// <param name="options"> /// If not null, overrides the default <see cref="FilesystemStorageOptions"/>. /// </param> /// <param name="fileSystem"> /// If not null, uses the specified IFileSystem, otherwise uses /// what has been called before. /// </param> public DiffstoreBuilder <TKey, TValue> WithSingleFileSnapshots( FileFormat format, IFileSystem fileSystem = null, FilesystemStorageOptions options = null) { (fileSystem, options) = PrepareFileStorage(fileSystem, options); switch (format) { case FileFormat.XML: sm = new SingleFileSnapshotManager <TKey, TValue, XmlDocumentAdapter, XmlWriterAdapter> (options, new XmlFormatter(), fileSystem); break; case FileFormat.JSON: sm = new SingleFileSnapshotManager <TKey, TValue, JsonReaderAdapter, JsonWriterAdapter> (options, JsonFormatter.Instance, fileSystem); break; default: sm = new SingleFileSnapshotManager <TKey, TValue, BinaryReader, BinaryWriter> (options, FastBinaryFormatter.Instance, fileSystem); break; } return(this); }
/// <summary> /// Sets up the engine to use file-based entity storage. /// </summary> /// <param name="options"> /// If not null, overrides the default <see cref="FilesystemStorageOptions"/>. /// </param> /// <param name="fileSystem"> /// If not null, uses the specified IFileSystem, otherwise uses /// what has been called before. /// </param> public DiffstoreBuilder <TKey, TValue> WithFileBasedEntities( FilesystemStorageOptions options = null, IFileSystem fileSystem = null) { return(WithFileBasedEntities(FastBinaryFormatter.Instance, options, fileSystem)); }
public SingleFileSnapshotManager(FilesystemStorageOptions opts, IFormatter <TIn, TOut> format, IFileSystem fs) => (options, fileSystem, formatter) = (opts, fs, format);