public object Deserialize(IFileStream stream) { IFileObject value = null; stream.SerializePointer(ref value); return(value); }
private void When_writing_small_buffer_to_file_it_must_succeed() { // Arrange const string path = @"C:\file.txt"; IFileSystem fileSystem = new FakeFileSystemBuilder() .Build(); using (IFileStream stream = fileSystem.File.Create(path, 128)) { var writer = new StreamWriter(stream.AsStream()); // Act writer.Write("ABC"); writer.Flush(); // Assert stream.Length.Should().Be(3); stream.Position.Should().Be(3); } string contents = fileSystem.File.ReadAllText(path); contents.Should().Be("ABC"); }
public object Deserialize(IFileStream stream) { uint value = 0; stream.SerializeValue(ref value); return(value); }
public object Deserialize(IFileStream stream) { float value = 0.0f; stream.SerializeValue(ref value); return(value); }
public void Serialize(IFileStream stream) { stream.SerializeValue(ref this.X); stream.SerializeValue(ref this.Y); stream.SerializeValue(ref this.Z); stream.SerializeValue(ref this.W); }
public override void Serialize(IFileStream stream) { base.Serialize(stream); stream.SerializePointer(ref this.CNodeUnknown0, false); stream.SerializePointer(ref this.CNodeUnknown1, false); stream.SerializeObject(ref this.CNodeUnknown2); }
public object Deserialize(IFileStream stream) { Guid value = Guid.Empty; stream.SerializeValue(ref value); return(value); }
private void When_appending_small_buffer_to_file_it_must_succeed() { // Arrange const string path = @"C:\file.txt"; const int size = 4096 - 5; string existingText = new string('X', size); IFileSystem fileSystem = new FakeFileSystemBuilder() .IncludingTextFile(path, existingText) .Build(); const string textToAppend = "ZYXWVUTSRQPONMLKJIHGFEDCBA"; using (IFileStream stream = fileSystem.File.Open(path, FileMode.Append)) { var writer = new StreamWriter(stream.AsStream()); // Act writer.Write(textToAppend); writer.Flush(); // Assert stream.Length.Should().Be(existingText.Length + textToAppend.Length); stream.Position.Should().Be(existingText.Length + textToAppend.Length); } string contents = fileSystem.File.ReadAllText(path); contents.Should().Be(existingText + textToAppend); }
public object Deserialize(IFileStream stream) { string value = null; stream.SerializeValue(ref value); return(value); }
public object Deserialize(IFileStream stream) { List <string> value = null; stream.SerializeTagList(ref value); return(value); }
private void When_increasing_file_size_using_Seek_followed_by_write_it_must_fail() { // Arrange const string path = @"C:\file.txt"; IFileSystem fileSystem = new FakeFileSystemBuilder() .IncludingVolume("C:", new FakeVolumeInfoBuilder() .OfCapacity(8192) .WithFreeSpace(512)) .IncludingBinaryFile(path, BufferFactory.Create(32)) .Build(); using (IFileStream stream = fileSystem.File.OpenWrite(path)) { byte[] buffer = BufferFactory.Create(64); stream.Write(buffer, 0, buffer.Length); stream.Seek(1280, SeekOrigin.Begin); // Act // ReSharper disable once AccessToDisposedClosure Action action = () => stream.WriteByte(0x33); // Assert action.Should().ThrowExactly <IOException>().WithMessage("There is not enough space on the disk."); AssertFreeSpaceOnDrive(fileSystem, "C:", 448); } AssertFileSize(fileSystem, path, 64); }
public void CreateAndDeleteFile(IFileInfo fi) { IFileStream fs = fi.Create(); fs.Close(); fi.Delete(); }
private void When_writing_large_buffer_to_file_it_must_succeed() { // Arrange const string path = @"C:\file.txt"; IFileSystem fileSystem = new FakeFileSystemBuilder() .Build(); const int size = 4096 * 16; byte[] writeBuffer = CreateBuffer(size); using (IFileStream stream = fileSystem.File.Create(path, 2048)) { // Act stream.Write(writeBuffer, 0, writeBuffer.Length); // Assert stream.Length.Should().Be(size); stream.Position.Should().Be(size); } byte[] contents = fileSystem.File.ReadAllBytes(path); contents.SequenceEqual(writeBuffer).Should().BeTrue(); }
public object Deserialize(IFileStream stream) { string result = null; stream.SerializeDependency(ref result); return(result); }
private void When_reading_large_buffer_from_file_it_must_succeed() { // Arrange const string path = @"C:\file.txt"; const int size = 4096 * 16; byte[] contents = CreateBuffer(size); IFileSystem fileSystem = new FakeFileSystemBuilder() .IncludingBinaryFile(path, contents) .Build(); using (IFileStream stream = fileSystem.File.Open(path, FileMode.Open, FileAccess.Read)) { var buffer = new byte[size * 2]; // Act int numBytesRead = stream.Read(buffer, 0, buffer.Length); // Assert stream.Length.Should().Be(size); stream.Position.Should().Be(size); numBytesRead.Should().Be(size); buffer.Take(size).SequenceEqual(contents).Should().BeTrue(); } }
public object Deserialize(IFileStream stream) { uint count = 0; stream.SerializeValue(ref count); string elementTypeName = null; stream.SerializeName(ref elementTypeName); short unk2 = -1; stream.SerializeValue(ref unk2); if (unk2 != -1) { throw new InvalidOperationException(); } var list = new List <object>(); for (uint i = 0; i < count; i++) { var element = _Serializer.Deserialize(stream); list.Add(element); } return(list); }
private void When_seeking_from_current_to_past_end_it_must_add_extra_zero_bytes() { // Arrange const string path = @"C:\file.txt"; const string data = "ABC"; IFileSystem fileSystem = new FakeFileSystemBuilder() .IncludingTextFile(path, data) .Build(); using (IFileStream stream = fileSystem.File.Open(path, FileMode.Open, FileAccess.ReadWrite)) { stream.Seek(1, SeekOrigin.Begin); // Act stream.Seek(2 + 10, SeekOrigin.Current); // Assert stream.Length.Should().Be(data.Length + 10); } string contents = fileSystem.File.ReadAllText(path); contents.Substring(data.Length).Should().Be(new string('\0', 10)); }
/// <summary> /// CloseRemoteTable /// </summary> public byte[] CloseRemoteTable() { lock (lock_fs) { if (_fsData != null) { _fsData.Dispose(); _fsData = null; } if (_fsRollback != null) { _fsRollback.Dispose(); _fsRollback = null; } if (_fsRollbackHelper != null) { _fsRollbackHelper.Dispose(); _fsRollbackHelper = null; } } return(new byte[] { ProtocolVersion }); }
public object Deserialize(IFileStream stream) { var obj = new TType(); PropertySerializer.Serialize(obj, stream); return(obj); }
/// <summary> /// DeleteRemoteTable /// </summary> /// <returns></returns> public byte[] DeleteRemoteTable() { lock (lock_fs) { if (_fsData != null) { _fsData.Dispose(); _fsData = null; } if (_fsRollback != null) { _fsRollback.Dispose(); _fsRollback = null; } if (_fsRollbackHelper != null) { _fsRollbackHelper.Dispose(); _fsRollbackHelper = null; } this.rth.configuration.FSFactory.Delete(this._fileName); this.rth.configuration.FSFactory.Delete(this._fileName + ".rol"); this.rth.configuration.FSFactory.Delete(this._fileName + ".rhp"); } return(new byte[] { ProtocolVersion }); }
private void When_locking_segment_in_stream_it_must_not_update_file_timings() { // Arrange const string path = @"C:\some\file.txt"; DateTime creationTimeUtc = 17.March(2006).At(14, 03, 53).AsUtc(); var clock = new SystemClock(() => creationTimeUtc); IFileSystem fileSystem = new FakeFileSystemBuilder(clock) .IncludingTextFile(path, DefaultContents) .Build(); using (IFileStream stream = fileSystem.File.Open(path, FileMode.Open, FileAccess.ReadWrite)) { DateTime changeTimeUtc = 18.March(2006).At(14, 03, 53).AsUtc(); clock.UtcNow = () => changeTimeUtc; // Act stream.Lock(0, DefaultContents.Length); } // Assert fileSystem.File.GetCreationTimeUtc(path).Should().Be(creationTimeUtc); fileSystem.File.GetLastWriteTimeUtc(path).Should().Be(creationTimeUtc); fileSystem.File.GetLastAccessTimeUtc(path).Should().Be(creationTimeUtc); }
/// <summary> /// OpenRemoteTable /// </summary> /// <returns></returns> public byte[] OpenRemoteTable() { lock (lock_fs) { if (_fsData == null) { this._fsData = this.rth.configuration.FSFactory.CreateType1(this._fileName, _fileStreamBufferSize);// new FileStream(this._fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _fileStreamBufferSize, FileOptions.WriteThrough); } if (_fsRollback == null) { this._fsRollback = this.rth.configuration.FSFactory.CreateType1(this._fileName + ".rol", _fileStreamBufferSize);//new FileStream(this._fileName + ".rol", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _fileStreamBufferSize, FileOptions.WriteThrough); } if (_fsRollbackHelper == null) { this._fsRollbackHelper = this.rth.configuration.FSFactory.CreateType1(this._fileName + ".rhp", _fileStreamBufferSize); //new FileStream(this._fileName + ".rhp", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _fileStreamBufferSize, FileOptions.WriteThrough); } byte[] protocol = new byte[] { ProtocolVersion } //Protocol version .ConcatMany( BitConverter.GetBytes(tableId), BitConverter.GetBytes(_fsData.Length), BitConverter.GetBytes(_fsRollback.Length), BitConverter.GetBytes(_fsRollbackHelper.Length) ); return(protocol); } }
public object Deserialize(IFileStream stream) { bool value = false; stream.SerializeValue(ref value); return(value); }
public object Deserialize(IFileStream stream) { var obj = new TType(); obj.Serialize(stream); return(obj); }
/// <summary> /// Save file to given path /// </summary> /// <param name="file">File</param> /// <param name="path">Path</param> public static void SaveAs(this IFileStream file, string path) { using (var fileStream = new FileStream(path, FileMode.Create)) { file.Stream.CopyTo(fileStream); } }
public object Deserialize(IFileStream stream) { var transform = new Game.EngineTransform(); stream.SerializeValue(ref transform.Flags); if ((transform.Flags & 1) == 1) { stream.SerializeValue(ref transform.Unknown1); stream.SerializeValue(ref transform.Unknown2); stream.SerializeValue(ref transform.Unknown3); } if ((transform.Flags & 2) == 2) { stream.SerializeValue(ref transform.Unknown4); stream.SerializeValue(ref transform.Unknown5); stream.SerializeValue(ref transform.Unknown6); } if ((transform.Flags & 4) == 4) { stream.SerializeValue(ref transform.Unknown7); stream.SerializeValue(ref transform.Unknown8); stream.SerializeValue(ref transform.Unknown9); } return transform; }
public void Serialize(IFileStream stream) { stream.SerializeObject(ref this.A); stream.SerializeObject(ref this.B); stream.SerializeObject(ref this.C); stream.SerializeObject(ref this.D); }
public bool SeekLastLineFromCurrentAndPositionOnStartOfIt(IFileStream stream) { int steps = 80; var pos1 = stream.Position; var found1 = SeekNextLineFeedInNegativeDirectionAndPositionStreamOnIt(stream, steps); if (found1 == false) { if (pos1 == 0) { return(false); // We cannot differentiate between String.Empty nothing found and String.Empty = empty log } // (though by definition right now a log is not empty) but to prevent errors just return null == nothing found return(false); // No line feed found - so no line yet } var found2 = SeekNextLineFeedInNegativeDirectionAndPositionStreamOnIt(stream, steps); if (found2) { // Ok we found a second linefeed - so one character after will be the start of our line SetPositionRelative(stream, 1); } // We found one LF but not another one - so there is only one line // -> we can read this line if we position to the begin of the file else { SetPosition(stream, 0); } return(true); }
private void When_unlocking_bytes_in_stream_it_must_not_raise_events() { // Arrange const string directoryToWatch = @"c:\some"; string filePath = Path.Combine(directoryToWatch, "file.txt"); FakeFileSystem fileSystem = new FakeFileSystemBuilder() .IncludingBinaryFile(filePath, BufferFactory.Create(4096)) .Build(); using (IFileStream stream = fileSystem.File.Open(filePath, FileMode.Open)) { stream.Lock(0, 256); using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch)) { watcher.NotifyFilter = TestNotifyFilters.All; watcher.IncludeSubdirectories = true; using (var listener = new FileSystemWatcherEventListener(watcher)) { // Act stream.Unlock(0, 256); watcher.FinishAndWaitForFlushed(MaxTestDurationInMilliseconds); // Assert listener.EventsCollected.Should().BeEmpty(); } } } }
/// <summary> /// /// </summary> public void Table_Dispose() { lock (lock_fs) { if (_fsData != null) { _fsData.Dispose(); _fsData = null; } if (_fsRollback != null) { _fsRollback.Dispose(); _fsRollback = null; } if (_fsRollbackHelper != null) { _fsRollbackHelper.Dispose(); _fsRollbackHelper = null; } _seqBuf.Dispose(); _rollbackCache.Clear(); } }
private void When_creating_local_file_it_must_succeed() { // Arrange const string path = @"C:\some\file.txt"; DateTime creationTimeUtc = 9.September(2016); var clock = new SystemClock { UtcNow = () => creationTimeUtc }; IFileSystem fileSystem = new FakeFileSystemBuilder(clock) .IncludingDirectory(@"C:\some") .Build(); // Act using (IFileStream stream = fileSystem.File.Create(path)) { stream.WriteByte(0xFF); } // Assert IFileInfo info = fileSystem.ConstructFileInfo(path); info.Exists.Should().BeTrue(); info.CreationTimeUtc.Should().Be(creationTimeUtc); info.LastAccessTimeUtc.Should().Be(creationTimeUtc); info.LastWriteTimeUtc.Should().Be(creationTimeUtc); info.Attributes.Should().Be(FileAttributes.Archive); }
/// <summary> /// CloseRemoteTable /// </summary> public byte[] CloseRemoteTable() { lock (lock_fs) { if (_fsData != null) { _fsData.Dispose(); _fsData = null; } if (_fsRollback != null) { _fsRollback.Dispose(); _fsRollback = null; } if (_fsRollbackHelper != null) { _fsRollbackHelper.Dispose(); _fsRollbackHelper = null; } } return new byte[] { ProtocolVersion }; }
public static void Serialize(object target, IFileStream stream) { if (stream.Mode == SerializeMode.Reading) { while (true) { string name = null; stream.SerializeName(ref name); if (String.IsNullOrEmpty(name) == true || name == "None") { break; } string type = null; stream.SerializeName(ref type); short unk2 = -1; stream.SerializeValue(ref unk2); if (unk2 != -1) { throw new FormatException(); } var start = stream.Position; uint size = 0; stream.SerializeValue(ref size); if (size < 4) { throw new FormatException(); } var end = start + size; if (target is GenericObject) { ReadGenericObjectProperty((GenericObject) target, stream, type, size, name); } else { ReadPropertyValue(stream, target, type, name); } if (stream.Position != end) { throw new FormatException(); } } } else { throw new NotSupportedException(); } }
public void Serialize(IFileStream stream) { if (stream.Mode == SerializeMode.Reading) { stream.SerializeValue(ref this.Data, (int)stream.Length); } else { throw new NotSupportedException(); } }
public virtual void Serialize(IFileStream stream) { if (stream.Mode == SerializeMode.Reading) { PropertySerializer.Serialize(this, stream); stream.SerializeValue(ref _objectUnknown); } else { throw new NotSupportedException(); } }
public override void Serialize(IFileStream stream) { base.Serialize(stream); stream.SerializeValue(ref this._Unknown0); if (this.Unknown0 != 0) { throw new FormatException(); } if (stream.Mode == SerializeMode.Reading) { this.Mipmaps.Clear(); uint mipmapCount = 0; stream.SerializeValue(ref mipmapCount); for (uint i = 0; i < mipmapCount; i++) { var mip = new Mipmap(); stream.SerializeValue(ref mip.Width); stream.SerializeValue(ref mip.Height); stream.SerializeValue(ref mip.Unknown2); uint size = 0; stream.SerializeValue(ref size); stream.SerializeValue(ref mip.Data, size); this.Mipmaps.Add(mip); } } else { throw new NotSupportedException(); } uint unknown1 = 0; stream.SerializeValue(ref unknown1); if (unknown1 != 0) { throw new FormatException(); } byte unknown2 = 0; stream.SerializeValue(ref unknown2); if (unknown2 != 0) { throw new FormatException(); } }
public void Initialize() { _directory = Substitute.For<IDirectory>(); _file = Substitute.For<IFile>(); _path = Substitute.For<IPath>(); _path.SetPathDefaultBehavior(); _tagHelper = Substitute.For<ITagHelper>(); _streamFactory = Substitute.For<IStreamFactory>(); _fileStream = Substitute.For<IFileStream>(); _streamFactory.CreateFileStream(Arg.Any<string>(), Arg.Any<FileMode>(), Arg.Any<FileAccess>(), Arg.Any<FileShare>()).Returns(_fileStream); _geolocHelper = Substitute.For<IGeolocationHelper>(); _target = new FileSystemHelperTester(_directory, _file, _path, _tagHelper, _streamFactory, _geolocHelper); }
public object Deserialize(IFileStream stream) { string typeName = null; stream.SerializeName(ref typeName); uint valueSize = 0; stream.SerializeValue(ref valueSize); var serializer = PropertySerializer.GetSerializer(typeName); if (serializer != null) { var value = serializer.Deserialize(stream); return value; } stream.Position += valueSize - 4; return null; }
public override void Serialize(IFileStream stream) { base.Serialize(stream); stream.SerializePointer(ref this.CEntityUnknown1, true); }
public override void Serialize(IFileStream stream) { base.Serialize(stream); stream.SerializeBuffer(ref this.CEntityTemplateUnknown0); }
public virtual void Serialize(IFileStream stream) { PropertySerializer.Serialize(this, stream); stream.SerializeValue(ref this.CObjectUnknown0); }
public object Deserialize(IFileStream stream) { float value = 0.0f; stream.SerializeValue(ref value); return value; }
/// <summary> /// /// </summary> /// <param name="newTableFullPath"></param> public void RestoreTableFromTheOtherTable(string newTableFullPath) { lock (lock_fs) { if (_fsData != null) { _fsData.Dispose(); _fsData = null; } if (_fsRollback != null) { _fsRollback.Dispose(); _fsRollback = null; } if (_fsRollbackHelper != null) { _fsRollbackHelper.Dispose(); _fsRollbackHelper = null; } _randBuf.Clear(); _rollbackCache.Clear(); usedBufferSize = 0; eofRollback = 0; eofData = 0; _seqBuf.Clear(true); this._configuration.FSFactory.Delete(this._fileName); this._configuration.FSFactory.Delete(this._fileName + ".rol"); this._configuration.FSFactory.Delete(this._fileName + ".rhp"); //File.Delete(this._fileName); //File.Delete(this._fileName + ".rol"); //File.Delete(this._fileName + ".rhp"); if (this._configuration.FSFactory.Exists(newTableFullPath)) this._configuration.FSFactory.Move(newTableFullPath, this._fileName); if(this._configuration.FSFactory.Exists(newTableFullPath + ".rol")) this._configuration.FSFactory.Move(newTableFullPath + ".rol", this._fileName + ".rol"); if (this._configuration.FSFactory.Exists(newTableFullPath + ".rhp")) this._configuration.FSFactory.Move(newTableFullPath + ".rhp", this._fileName + ".rhp"); InitFiles(); } }
public override void Serialize(IFileStream stream) { base.Serialize(stream); throw new NotImplementedException(); }
private static void ReadPropertyValue( IFileStream stream, object target, string typeName, string propertyName) { if (target == null) { throw new ArgumentNullException("obj"); } else if (propertyName == null) { throw new ArgumentNullException("name"); } else if (typeName == null) { throw new ArgumentNullException("type"); } var type = target.GetType(); var info = GetTypeInfo(type); if (info == null) { throw new InvalidOperationException(); } if (info.Properties.ContainsKey(propertyName) == false) { throw new FormatException(String.Format( "{0} does not contain a property '{1}' ({2})", type, propertyName, typeName)); } var prop = info.Properties[propertyName]; IPropertySerializer serializer; if (SerializerCache.ContainsKey(prop.Serializer) == false) { serializer = (IPropertySerializer)Activator.CreateInstance(prop.Serializer); SerializerCache[prop.Serializer] = serializer; } else { serializer = SerializerCache[prop.Serializer]; } var value = serializer.Deserialize(stream); prop.PropertyInfo.SetValue(target, value, null); }
public void Serialize(IFileStream stream) { PropertySerializer.Serialize(this, stream); }
private static void ReadGenericObjectProperty(GenericObject target, IFileStream stream, string type, uint size, string name) { IPropertySerializer serializer = GetSerializer(type); if (serializer != null) { target.SetProperty(name, type, serializer.Deserialize(stream)); } else { uint valueSize = size - 4; byte[] value = new byte[valueSize]; stream.SerializeValue(ref value, valueSize); target.SetProperty(name, type, value); } }
private void InitRollback() { byte[] btWork = new byte[8]; _fsRollbackHelper.Position = 0; _fsRollbackHelper.Read(btWork, 0, 8); eofRollback = btWork.To_Int64_BigEndian(); if (eofRollback == 0) { if (this._fsRollback.Length >= MaxRollbackFileSize) { this._fsRollback.Dispose(); this._configuration.FSFactory.Delete(this._fileName + ".rol"); //this._fsRollback = new FileStream(this._fileName + ".rol", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _fileStreamBufferSize, FileOptions.WriteThrough); this._fsRollback = this._configuration.FSFactory.CreateType1(this._fileName + ".rol", _fileStreamBufferSize); //no sense to do anything with backup } return; } //!!!Check if data file is empty write first root 64 bytes, ??? Where it must stay after rollback restoration??? //Restoring rollback RestoreInitRollback(); //Checking if we can recreate rollback file if (this._fsRollback.Length >= MaxRollbackFileSize) { this._fsRollback.Dispose(); this._configuration.FSFactory.Delete(this._fileName + ".rol"); this._fsRollback = this._configuration.FSFactory.CreateType1(this._fileName + ".rol", _fileStreamBufferSize); //File.Delete(this._fileName + ".rol"); //this._fsRollback = new FileStream(this._fileName + ".rol", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _fileStreamBufferSize, FileOptions.WriteThrough); //no sense to do anything with backup } eofRollback = 0; _fsRollbackHelper.Position = 0; _fsRollbackHelper.Write(eofRollback.To_8_bytes_array_BigEndian(), 0, 8); NET_Flush(_fsRollbackHelper); //try //{ //} //catch (Exception ex) //{ // IsOperable = false; // throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.RESTORE_ROLLBACK_DATA_FAILED, this._fileName, ex); //} }
public static void NET_Flush(IFileStream mfs) { mfs.Flush(true); }
/// <summary> /// /// </summary> public void RecreateFiles() { lock (lock_fs) { if (_fsData != null) { _fsData.Dispose(); _fsData = null; } if (_fsRollback != null) { _fsRollback.Dispose(); _fsRollback = null; } if (_fsRollbackHelper != null) { _fsRollbackHelper.Dispose(); _fsRollbackHelper = null; } _randBuf.Clear(); _rollbackCache.Clear(); usedBufferSize = 0; eofRollback = 0; eofData = 0; _seqBuf.Clear(true); this._configuration.FSFactory.Delete(this._fileName); this._configuration.FSFactory.Delete(this._fileName + ".rol"); this._configuration.FSFactory.Delete(this._fileName + ".rhp"); InitFiles(); } }
public void Serialize(IFileStream stream, object value) { throw new NotImplementedException(); }
public object Deserialize(IFileStream stream) { IFileObject value = null; stream.SerializePointer(ref value); return value; }
public override void Serialize(IFileStream stream) { var bytesRemaining = (uint) (stream.Length - stream.Position); stream.SerializeValue(ref _data, bytesRemaining); }
public object Deserialize(IFileStream stream) { string value = null; stream.SerializeName(ref value); return value; }
public object Deserialize(IFileStream stream) { uint value = 0; stream.SerializeValue(ref value); return value; }
private void InitFiles() { //Creates filestreams and rollbacks, restores rollback to the initial file, if necessary try { //this._fsData = new FileStream(this._fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _fileStreamBufferSize, FileOptions.WriteThrough); //this._fsRollback = new FileStream(this._fileName + ".rol", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _fileStreamBufferSize, FileOptions.WriteThrough); //this._fsRollbackHelper = new FileStream(this._fileName + ".rhp", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _fileStreamBufferSize, FileOptions.WriteThrough); this._fsData = this._configuration.FSFactory.CreateType1(this._fileName, _fileStreamBufferSize); this._fsRollback = this._configuration.FSFactory.CreateType1(this._fileName + ".rol", _fileStreamBufferSize); this._fsRollbackHelper = this._configuration.FSFactory.CreateType1(this._fileName + ".rhp", _fileStreamBufferSize); //!!!!We dont have this value in root yet, could have and economize tail of the file in case if rollback occured if (this._fsData.Length == 0) { //Writing initial root data _fsData.Position = 0; _fsData.Write(new byte[this._trieSettings.ROOT_SIZE], 0, this._trieSettings.ROOT_SIZE); if (_backupIsActive) { this._configuration.Backup.WriteBackupElement(ulFileName, 0, 0, new byte[this._trieSettings.ROOT_SIZE]); } //no flush here } eofData = this._fsData.Length; //Check is .rhp is empty add 0 pointer if (this._fsRollbackHelper.Length == 0) { //no sense to write here //_fsRollbackHelper.Position = 0; //_fsRollbackHelper.Write(eofRollback.To_8_bytes_array_BigEndian(), 0, 8); //NET_Flush(_fsRollbackHelper); } else { InitRollback(); } _storageFixTime = DateTime.UtcNow; } catch (Exception ex) { IsOperable = false; throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.DB_IS_NOT_OPERABLE, "FSR INIT FAILED: " + this._fileName, ex); } }