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 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 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);
}
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);
}
/// <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 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 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);
}
}
/// <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();
}
}
