private Cursor WriteFileDescriptor(IFileEntry file, bool isNewFile)
{
_logger.Information($"Start writing file descriptor for filename {file.EntryName}");
var allocatedCursor = _allocator.AllocateFile(file.DataLength, isNewFile);
var filesystemDescriptor = _filesystemDescriptorAccessor.Value;
var createdOn = DateTime.UtcNow.ToUnixTime();
var updatedOn = createdOn;
var id = Guid.NewGuid();
var fileDescriptor = new EntryDescriptor(id, file.ParentEntryId, file.EntryName, EntryType.File, createdOn, updatedOn, allocatedCursor.Offset, file.DataLength);
var fileDescriptorOffset = -FilesystemDescriptor.BytesTotal -
(filesystemDescriptor.EntryDescriptorsCount *
filesystemDescriptor.EntryDescriptorLength)
- filesystemDescriptor.EntryDescriptorLength;
var origin = SeekOrigin.End;
var cursor = new Cursor(fileDescriptorOffset, origin);
var storageItem = new StorageItem <EntryDescriptor>(in fileDescriptor, in cursor);
_entryDescriptorRepository.Write(storageItem);
_logger.Information($"Done writing file descriptor for filename {file.EntryName}");
return(allocatedCursor);
}
private void UpdateInternal(IFileEntry file, Action <Cursor> writeAction)
{
// 1. Find descriptor
var descriptorItem = _entryDescriptorRepository.Find(file.EntryName);
// 2. If new content size equals or smaller than was previously allocated to this file,
// we don't need to allocate new space, only change length
var allocatedCursor = file.DataLength <= descriptorItem.Value.DataLength
? new Cursor(descriptorItem.Value.DataOffset, SeekOrigin.Begin)
: _allocator.AllocateFile(file.DataLength, false);
// 3. Write file data
writeAction(allocatedCursor);
var updatedOn = DateTime.UtcNow.ToUnixTime();
var updatedDescriptor = new EntryDescriptor(
descriptorItem.Value.Id,
descriptorItem.Value.ParentId,
descriptorItem.Value.Name,
EntryType.File,
descriptorItem.Value.CreatedOn,
updatedOn,
allocatedCursor.Offset,
file.DataLength);
var cursor = descriptorItem.Cursor;
// 4. Write descriptor
_entryDescriptorRepository.Write(new StorageItem <EntryDescriptor>(in updatedDescriptor, in cursor));
}
/// <inheritdoc/>
public void Create(DirectoryEntry directoryEntry)
{
_logger.Information($"Start writing entry descriptor for directory {directoryEntry.EntryName}");
var filesystemDescriptor = _filesystemDescriptorAccessor.Value;
var createdOn = DateTime.UtcNow.ToUnixTime();
var updatedOn = createdOn;
var entryDescriptor = new EntryDescriptor(
directoryEntry.Id,
directoryEntry.ParentEntryId,
directoryEntry.EntryName,
EntryType.Directory,
createdOn,
updatedOn,
0,
0);
var entryDescriptorOffset = -FilesystemDescriptor.BytesTotal -
(filesystemDescriptor.EntryDescriptorsCount *
filesystemDescriptor.EntryDescriptorLength)
- filesystemDescriptor.EntryDescriptorLength;
var origin = SeekOrigin.End;
var cursor = new Cursor(entryDescriptorOffset, origin);
var storageItem = new StorageItem <EntryDescriptor>(in entryDescriptor, in cursor);
_entryDescriptorRepository.Write(storageItem);
_logger.Information($"Done writing entry descriptor for directory {directoryEntry.EntryName}");
IncreaseEntriesCount(1);
}
public void Write_StorageShouldContainCorrectItem(string fileName, long createdOn, long updatedOn, int dataOffset, int dataLength)
{
// Arrange
var storageBuffer = new byte[10000];
var fileDescriptor = new EntryDescriptor(Guid.NewGuid(), Guid.NewGuid(), fileName, EntryType.File, createdOn, updatedOn, dataOffset, dataLength);
var repository = CreateRepository(storageBuffer, true);
var cursor = new Cursor(-FilesystemDescriptor.BytesTotal - EntryDescriptor.BytesWithoutFilename - FileNameLength, SeekOrigin.End);
// Act
repository.Write(new StorageItem <EntryDescriptor>(fileDescriptor, cursor));
// Assert
var writtenFileDescriptor = repository.Read(cursor);
Assert.Equal(fileDescriptor, writtenFileDescriptor.Value);
Assert.Equal(cursor, writtenFileDescriptor.Cursor);
}
public Data GenerateTable(EntryDescriptor entry, DateTime timeSource, DateTime firstCaptureTime, TimeSpan capturePeriod, UInt32 profileEntries)
{
var result = new List <Data[]>();
var lastCaptureDate = GetLastCaptureDate(timeSource, firstCaptureTime, capturePeriod);
var entriesInUse = GetEntriesInUse(timeSource, firstCaptureTime, capturePeriod, profileEntries);
// new BillingDataResult((DateTime firstTimeCapture, TimeSpan capturePeriod, int numberOfCaptures, int entriesInUse)
var index = (int)(entriesInUse - entry.ToEntry);
if (entriesInUse < entry.FromEntry)
{
return(DataCoder.Encode(new Data[] { }));
}
var last = entry.ToEntry;
if (entriesInUse < entry.ToEntry)
{
last = entriesInUse;
}
else
{
firstCaptureTime = AddTime(firstCaptureTime, index, capturePeriod);
}
double seconds = TimeSpan.FromTicks(firstCaptureTime.Ticks).TotalSeconds;
for (int i = 0; i <= last - entry.FromEntry; i++)
{
result.Add(
Enumerable.Range(0, generatorColumns.Length)
.Select((column) => GenerateValue(column, seconds)).ToArray());
firstCaptureTime = AddTime(firstCaptureTime, 1, capturePeriod);
//TODO: Gal galima greiciau?
seconds = TimeSpan.FromTicks(firstCaptureTime.Ticks).TotalSeconds;
}
//Return billing data rezults
return(DataCoder.Encode(result.ToArray()));
}
public void ToBuffer_ShouldCreatedCorrectBufferWithData(int fileDescriptorLength, string fileName, long createdOn, long updatedOn, int dataOffset, int dataLength, EntryType type)
{
// Arrange
var id = Guid.NewGuid();
var parentId = Guid.NewGuid();
var filesystemDescriptor = new FilesystemDescriptor(0, 0, fileDescriptorLength);
var fileDescriptor = new EntryDescriptor(id, parentId, fileName, type, createdOn, updatedOn, dataOffset, dataLength);
var logger = new LoggerConfiguration().CreateLogger();
var filesystemDescriptorAccessor = CreateFilesystemDescriptorAccessor(filesystemDescriptor);
var serializer = new EntryDescriptorSerializer(filesystemDescriptorAccessor, logger);
// Act
var buffer = serializer.ToBytes(fileDescriptor);
// Assert
using var memoryStream = new MemoryStream(buffer);
using var reader = new BinaryReader(memoryStream);
var writtenIdBytes = reader.ReadGuidBytes();
var writtenId = new Guid(writtenIdBytes);
var writtenParentIdBytes = reader.ReadGuidBytes();
var writtenParentId = new Guid(writtenParentIdBytes);
var writtenStringLength = reader.ReadInt32();
var writtenEntryNameBytes = reader.ReadBytes(writtenStringLength);
var writtenEntryName = Encoding.UTF8.GetString(writtenEntryNameBytes);
memoryStream.Seek(filesystemDescriptor.EntryDescriptorLength - writtenStringLength - EntryDescriptor.BytesWithoutFilename, SeekOrigin.Current);
var writtenType = (EntryType)reader.ReadByte();
var writtenCreatedOn = reader.ReadInt64();
var writtenUpdatedOn = reader.ReadInt64();
var writtenDataOffset = reader.ReadInt32();
var writtenDataLength = reader.ReadInt32();
Assert.Equal(id, writtenId);
Assert.Equal(parentId, writtenParentId);
Assert.Equal(fileDescriptorLength, buffer.Length);
Assert.Equal(fileName, writtenEntryName);
Assert.Equal(type, writtenType);
Assert.Equal(createdOn, writtenCreatedOn);
Assert.Equal(updatedOn, writtenUpdatedOn);
Assert.Equal(dataOffset, writtenDataOffset);
Assert.Equal(dataLength, writtenDataLength);
}
/// <inheritdoc />
public void Move(string fromName, string toName)
{
var newParentName = toName.GetParentFullName();
var newParent = _entryDescriptorRepository.Find(newParentName).Value;
var descriptorItem = _entryDescriptorRepository.Find(fromName);
var newName = toName.GetParentFullName().CombineWith(toName.GetShortName());
var updatedDescriptor = new EntryDescriptor(
descriptorItem.Value.Id,
newParent.Id,
newName,
descriptorItem.Value.Type,
descriptorItem.Value.CreatedOn,
descriptorItem.Value.UpdatedOn,
descriptorItem.Value.DataOffset,
descriptorItem.Value.DataLength);
var cursor = descriptorItem.Cursor;
_entryDescriptorRepository.Write(new StorageItem <EntryDescriptor>(updatedDescriptor, cursor));
}
private void CreateRootDirectory()
{
var rootDirectoryId = Guid.NewGuid();
var createdOn = DateTime.UtcNow.ToUnixTime();
var updatedOn = createdOn;
var rootDirectory = new EntryDescriptor(
rootDirectoryId,
rootDirectoryId,
"/",
EntryType.Directory,
createdOn,
updatedOn,
0,
0);
// Write root directory descriptor
var filesystemDescriptor = _filesystemDescriptorAccessor.Value;
var cursor = new Cursor(-FilesystemDescriptor.BytesTotal - filesystemDescriptor.EntryDescriptorLength, SeekOrigin.End);
_entryDescriptorRepository.Write(new StorageItem <EntryDescriptor>(rootDirectory, cursor));
}
public void Exists_WhenItemExists_ShouldReturnTrue(string fileName, long createdOn, long updatedOn, int dataOffset, int dataLength)
{
// Arrange
var storageBuffer = new byte[10000];
var expectedFoundDescriptor = new EntryDescriptor(Guid.NewGuid(), Guid.NewGuid(), fileName, EntryType.File, createdOn, updatedOn, dataOffset, dataLength);
var descriptors = new[]
{
new EntryDescriptor(Guid.NewGuid(), Guid.NewGuid(), "/test1.storage", EntryType.File, 0, 0, 0, 0),
new EntryDescriptor(Guid.NewGuid(), Guid.NewGuid(), "/test2.storage", EntryType.File, 0, 0, 0, 0),
expectedFoundDescriptor,
new EntryDescriptor(Guid.NewGuid(), Guid.NewGuid(), "/test4.storage", EntryType.File, 0, 0, 0, 0),
};
var repository = CreateRepository(storageBuffer, true, descriptors);
// Act
var itemExists = repository.Exists(expectedFoundDescriptor.Name);
// Assert
Assert.True(itemExists);
}
public void Find_ShouldReturnCorrectItemByFilename()
{
// Arrange
var storageBuffer = new byte[10000];
var expectedFoundDescriptor = new EntryDescriptor(Guid.NewGuid(), Guid.NewGuid(), "/test3.storage", EntryType.File, 0, 0, 0, 0);
var descriptors = new[]
{
new EntryDescriptor(Guid.NewGuid(), Guid.NewGuid(), "/test1.storage", EntryType.File, 0, 0, 0, 0),
new EntryDescriptor(Guid.NewGuid(), Guid.NewGuid(), "/test2.storage", EntryType.File, 0, 0, 0, 0),
expectedFoundDescriptor,
new EntryDescriptor(Guid.NewGuid(), Guid.NewGuid(), "/test4.storage", EntryType.File, 0, 0, 0, 0),
};
var repository = CreateRepository(storageBuffer, true, descriptors);
// Act
var foundFileDescriptorItem = repository.Find(expectedFoundDescriptor.Name);
// Assert
Assert.Equal(expectedFoundDescriptor, foundFileDescriptorItem.Value);
}
private StorageItem <EntryDescriptor> CopyFile(EntryDescriptor entryDescriptor, Cursor cursor, int destinationOffset)
{
var newDescriptor = new EntryDescriptor(
entryDescriptor.Id,
entryDescriptor.ParentId,
entryDescriptor.Name,
entryDescriptor.Type,
entryDescriptor.CreatedOn,
entryDescriptor.UpdatedOn,
destinationOffset,
entryDescriptor.DataLength);
var newStorageItem = new StorageItem <EntryDescriptor>(in newDescriptor, in cursor);
_logger.Information($"Moving {entryDescriptor.DataLength} bytes of data from {entryDescriptor.DataOffset} to {destinationOffset}");
PerformCopy(entryDescriptor.DataOffset, destinationOffset, entryDescriptor.DataLength);
_entryDescriptorRepository.Write(newStorageItem);
_logger.Information($"{entryDescriptor.DataLength} bytes of data moved to offset {destinationOffset}");
return(newStorageItem);
}
public Data GenerateTable(EntryDescriptor entry, DateTimeOffset timeSource, DateTimeOffset firstCaptureTime, TimeSpan capturePeriod)
{
var result = new List <Data[]>();
var lastCaptureDate = GetLastCaptureDate(timeSource, firstCaptureTime, capturePeriod);
int numberOfCaptures = (int)entry.FromEntry;
var captureTime = SubstractTime(lastCaptureDate, (int)entry.FromEntry - 1, capturePeriod);
for (int i = 0; i <= entry.ToEntry - entry.FromEntry; i++)
{
result.Add(
Enumerable.Range(0, generatorColumns.Length + 1)
.Select((column) => GenerateValue(column, numberOfCaptures, captureTime)).ToArray());
captureTime = SubstractTime(captureTime, 1, capturePeriod);
numberOfCaptures++;
}
result.Reverse();
return(DataCoder.Encode(result.ToArray()));
}
