public void UpdateFromEntry(EntryInfo entity)
{
ID = entity.ID;
FileUrl = entity.FileUrl;
FileLength = entity.FileLength;
HasLongFileName = entity.HasLongFileName;
}
public void UpdateFromEntry(EntryInfo entity)
{
ID = entity.ID;
FileName = Path.GetFileNameWithoutExtension(entity.FileName);
FileExtension = Path.GetExtension(entity.FileName).Replace(".", "");
FileLength = entity.FileLength;
}
/// <summary>
/// Store a stream inside database
/// </summary>
/// <param name="fileName">Just a name of file, to get future reference (eg: MyPhoto.jpg)</param>
/// <param name="input">Stream thats contains the file</param>
/// <returns>EntryInfo with information store</returns>
public EntryInfo Store(string fileName, Stream input)
{
var entry = new EntryInfo(fileName);
_engine.Write(entry, input);
return(entry);
}
public static void ReadFileContent(string dbFileName, EntryInfo entry, Stream output)
{
using (var db = new FileDB(dbFileName, FileAccess.Read))
{
db.ReadContent(entry, output);
}
}
public void UpdateFromEntry(EntryInfo entity)
{
ID = entity.ID;
FileUrl = entity.FileUrl;
FileLength = entity.FileLength;
HasLongFileName = entity.HasLongFileName;
}
public void UpdateFromEntry(EntryInfo entity)
{
ID = entity.ID;
FileName = Path.GetFileNameWithoutExtension(entity.FileName);
FileExtension = Path.GetExtension(entity.FileName).Replace(".", "");
FileLength = entity.FileLength;
}
public static IndexNode BinaryInsert(EntryInfo target, IndexNode baseNode, Engine engine)
{
var dif = baseNode.ID.CompareTo(target.ID);
if (dif == 1) // > Maior (Right)
{
if (baseNode.Right.IsEmpty)
{
return(BinaryInsertNode(baseNode.Right, baseNode, target, engine));
}
else
{
return(BinaryInsert(target, GetChildIndexNode(baseNode.Right, engine), engine));
}
}
else if (dif == -1) // < Menor (Left)
{
if (baseNode.Left.IsEmpty)
{
return(BinaryInsertNode(baseNode.Left, baseNode, target, engine));
}
else
{
return(BinaryInsert(target, GetChildIndexNode(baseNode.Left, engine), engine));
}
}
else
{
throw new FileDBException("Same GUID?!?");
}
}
public static void ReadFile(IndexNode node, EntryInfo entry, Stream stream, Engine engine)
{
var dataPage = PageFactory.GetDataPage(node.DataPageID, engine.Reader, false);
int metaDataStartPos = 0;
int metaDataLength = entry.FileMetadataLength;
int dataStartPos = metaDataStartPos + metaDataLength;
int curReadPos = 0;
if (dataPage != null && entry.FileMetadataLength > 0)
{
//first round
//read file meta data
while (curReadPos < metaDataLength)
{
//1.marker
byte marker = ReadByte(dataPage.DataBlock, curReadPos, out curReadPos);
switch (marker)
{
case 1: //date time
long binaryTime = ReadInt64(dataPage.DataBlock, curReadPos, out curReadPos);
entry.FileDateTime = DateTime.FromBinary(binaryTime);
break;
case 2:
//long filename
int nameLen = (int)ReadUInt16(dataPage.DataBlock, curReadPos, out curReadPos);
byte[] nameBuffer = new byte[nameLen];
Array.Copy(dataPage.DataBlock, curReadPos, nameBuffer, 0, nameLen);
entry.FileUrl = System.Text.Encoding.UTF8.GetString(nameBuffer);
curReadPos += nameLen;
break;
default:
throw new NotSupportedException();
}
}
}
//-----------------------------------
//data part
int toReadLen = dataPage.DataBlockLength - curReadPos;
while (dataPage != null)
{
stream.Write(dataPage.DataBlock, curReadPos, toReadLen);
if (dataPage.NextPageID == uint.MaxValue)
{
dataPage = null;
}
else
{
dataPage = PageFactory.GetDataPage(dataPage.NextPageID, engine.Reader, false);
//reset
curReadPos = 0;
toReadLen = dataPage.DataBlockLength;
}
}
}
public static EntryInfo Store(string dbFileName, string fileName, byte[] inputBuffer)
{
using (MemoryStream ms = new MemoryStream(inputBuffer))
using (var db = new FileDB(dbFileName, FileAccess.ReadWrite))
{
EntryInfo en = db.Store(fileName, ms);
ms.Close();
return(en);
}
}
internal FileDBStream(Engine engine, Guid id)
{
_engine = engine;
var indexNode = _engine.Search(id);
if (indexNode != null)
{
_streamLength = indexNode.FileLength;
_currentPage = PageFactory.GetDataPage(indexNode.DataPageID, engine.Reader, false);
_info = new EntryInfo(indexNode);
}
}
void FillMetadata(EntryInfo entry)
{
// Search from index node
var indexNode = Search(entry.ID);
// If index node is null, not found the guid
if (indexNode == null)
{
return;
}
// Read data from the index pointer to stream
DataFactory.ReadFileMetadata(indexNode, entry, this);
}
internal FileDBStream(Engine engine, Guid id)
{
_engine = engine;
var indexNode = _engine.Search(id);
if (indexNode != null)
{
_streamLength = indexNode.FileLength;
_currentPage = PageFactory.GetDataPage(indexNode.DataPageID, engine.Reader, false);
_info = new EntryInfo(indexNode);
}
}
public void ReadContent(EntryInfo entry, Stream stream)
{
// Search from index node
var indexNode = Search(entry.ID);
// If index node is null, not found the guid
if (indexNode == null)
{
return;
}
// Create a entry based on index node
// Read data from the index pointer to stream
DataFactory.ReadOnlyFileContent(indexNode, entry, stream, this);
}
public EntryInfo Read(Guid id, Stream stream)
{
// Search from index node
var indexNode = Search(id);
// If index node is null, not found the guid
if (indexNode == null)
{
return(null);
}
// Create a entry based on index node
EntryInfo entry = new EntryInfo(indexNode);
// Read data from the index pointer to stream
DataFactory.ReadFile(indexNode, stream, this);
return(entry);
}
private static IndexNode BinaryInsertNode(IndexLink baseLink, IndexNode baseNode, EntryInfo entry, Engine engine)
{
// Must insert my new nodo
var pageIndex = engine.GetFreeIndexPage();
var newNode = pageIndex.Nodes[pageIndex.NodeIndex];
baseLink.PageID = pageIndex.PageID;
baseLink.Index = pageIndex.NodeIndex;
newNode.UpdateFromEntry(entry);
newNode.DataPageID = DataFactory.GetStartDataPageID(engine);
if (pageIndex.PageID != baseNode.IndexPage.PageID)
engine.CacheIndexPage.AddPage(baseNode.IndexPage, true);
engine.CacheIndexPage.AddPage(pageIndex, true);
return newNode;
}
// Implement file physic storage
public void Write(EntryInfo entry, Stream stream)
{
// Take the first index page
IndexNode rootIndexNode = IndexFactory.GetRootIndexNode(this);
// Search and insert the index
var indexNode = IndexFactory.BinaryInsert(entry, rootIndexNode, this);
// In this moment, the index are ready and saved. I use to add the file
DataFactory.InsertFile(indexNode, stream, this);
// Update entry information with file length (I know file length only after read all)
entry.FileLength = indexNode.FileLength;
// Only after insert all stream file I confirm that index node is valid
indexNode.IsDeleted = false;
// Mask header as dirty for save on dispose
Header.IsDirty = true;
}
// Implement file physic storage
public void Write(EntryInfo entry, Stream stream)
{
// Take the first index page
IndexNode rootIndexNode = IndexFactory.GetRootIndexNode(this);
// Search and insert the index
var indexNode = IndexFactory.BinaryInsert(entry, rootIndexNode, this);
// In this moment, the index are ready and saved. I use to add the file
DataFactory.InsertFile(indexNode, entry, stream, this);
// Update entry information with file length (I know file length only after read all)
entry.FileMetadataLength = indexNode.FileMetaDataLength;
entry.FileLength = indexNode.FileLength;
// Only after insert all stream file I confirm that index node is valid
indexNode.IsDeleted = false;
// Mask header as dirty for save on dispose
Header.IsDirty = true;
}
public static IndexNode BinaryInsert(EntryInfo target, IndexNode baseNode, Engine engine)
{
var dif = baseNode.ID.CompareTo(target.ID);
if (dif == 1) // > Maior (Right)
{
if (baseNode.Right.IsEmpty)
return BinaryInsertNode(baseNode.Right, baseNode, target, engine);
else
return BinaryInsert(target, GetChildIndexNode(baseNode.Right, engine), engine);
}
else if (dif == -1) // < Menor (Left)
{
if (baseNode.Left.IsEmpty)
return BinaryInsertNode(baseNode.Left, baseNode, target, engine);
else
return BinaryInsert(target, GetChildIndexNode(baseNode.Left, engine), engine);
}
else
{
throw new FileDBException("Same GUID?!?");
}
}
/// <summary>
/// Store a stream inside database
/// </summary>
/// <param name="fileName">Just a name of file, to get future reference (eg: MyPhoto.jpg)</param>
/// <param name="input">Stream thats contains the file</param>
/// <returns>EntryInfo with information store</returns>
public EntryInfo Store(string fileName, Stream input)
{
var entry = new EntryInfo(fileName);
_engine.Write(entry, input);
return entry;
}
public static void InsertFile(IndexNode node, EntryInfo enInfo, Stream stream, Engine engine)
{
var buffer = new byte[DataPage.DATA_PER_PAGE];
int dataFreeInPage = DataPage.DATA_PER_PAGE;
int writePos = 0;
int read = 0;
DataPage dataPage = engine.GetDataPage(node.DataPageID);
if (!dataPage.IsEmpty) // This is never to happend!!
{
throw new FileDBException("Page {0} is not empty", dataPage.PageID);
}
//-----------------------
//write metadata
//1. datetime of file
DateTime filedtm = enInfo.FileDateTime;
//--------------------------
writePos = WriteByte(dataPage.DataBlock, 0, 1); //marker - 1
writePos = WriteInt64(dataPage.DataBlock, writePos, filedtm.ToBinary()); //data part
//--------------------------
//2. long filename (if has long filename)
//-----------------------
if (enInfo.HasLongFileName)
{
//write full filename here
byte[] longFileNameBuff = System.Text.Encoding.UTF8.GetBytes(enInfo.FileUrl);
int buffLen = longFileNameBuff.Length;
if (buffLen > 512)
{
//for this version ***
throw new Exception("file name must not longer than 512 bytes");
}
writePos = WriteByte(dataPage.DataBlock, writePos, 2); //marker 2 long filename
//--------
writePos = WriteUInt16(dataPage.DataBlock, writePos, (ushort)buffLen); //2 bytes length of buffer
writePos = WriteBuffer(dataPage.DataBlock, writePos, longFileNameBuff); //buffer
//--------
}
dataPage.IsEmpty = false;
dataPage.DataBlockLength = (short)writePos;
dataFreeInPage -= writePos;
node.FileMetaDataLength = (ushort)writePos;
//-----------------------
bool isFirstRound = true;
uint fileLength = 0;
while ((read = stream.Read(buffer, 0, dataFreeInPage)) > 0)
{
//if we have some data to write
fileLength += (uint)read;
if (!isFirstRound)
{
dataPage = GetNewDataPage(dataPage, engine);
if (!dataPage.IsEmpty) // This is never to happend!!
{
throw new FileDBException("Page {0} is not empty", dataPage.PageID);
}
}
writePos = WriteBuffer(dataPage.DataBlock, writePos, buffer, read);
dataPage.IsEmpty = false;
dataPage.DataBlockLength = (short)writePos;
//----------------------------------------------
//reset for next
dataFreeInPage = DataPage.DATA_PER_PAGE;
writePos = 0;
isFirstRound = false;
//----------------------------------------------
}
// If the last page point to another one, i need to fix that
if (dataPage.NextPageID != uint.MaxValue)
{
engine.Header.FreeDataPageID = dataPage.NextPageID;
dataPage.NextPageID = uint.MaxValue;
}
// Save the last page on disk
PageFactory.WriteToFile(dataPage, engine.Writer);
// Save on node index that file length
node.FileLength = fileLength;
}
public EntryInfo Read(Guid id, Stream stream)
{
// Search from index node
var indexNode = Search(id);
// If index node is null, not found the guid
if (indexNode == null)
return null;
// Create a entry based on index node
EntryInfo entry = new EntryInfo(indexNode);
// Read data from the index pointer to stream
DataFactory.ReadFile(indexNode, stream, this);
return entry;
}
void FillMetadata(EntryInfo entry)
{
// Search from index node
var indexNode = Search(entry.ID);
// If index node is null, not found the guid
if (indexNode == null)
{
return;
}
// Read data from the index pointer to stream
DataFactory.ReadFileMetadata(indexNode, entry, this);
}
public void ReadContent(EntryInfo en, Stream outputStream)
{
_engine.ReadContent(en, outputStream);
}
private static IndexNode BinaryInsertNode(IndexLink baseLink, IndexNode baseNode, EntryInfo entry, Engine engine)
{
// Must insert my new nodo
var pageIndex = engine.GetFreeIndexPage();
var newNode = pageIndex.Nodes[pageIndex.UsedNodeCount];
baseLink.PageID = pageIndex.PageID;
baseLink.Index = pageIndex.UsedNodeCount;
newNode.UpdateFromEntry(entry);
newNode.DataPageID = DataFactory.GetStartDataPageID(engine);
if (pageIndex.PageID != baseNode.IndexPage.PageID)
{
engine.CacheIndexPage.AddPage(baseNode.IndexPage, true);
}
engine.CacheIndexPage.AddPage(pageIndex, true);
return(newNode);
}
internal void Store(EntryInfo entry, Stream input)
{
_engine.Write(entry, input);
}
public void ReadContent(EntryInfo en, Stream outputStream)
{
_engine.ReadContent(en, outputStream);
}
internal void Store(EntryInfo entry, Stream input)
{
_engine.Write(entry, input);
}
public void ReadContent(EntryInfo entry, Stream stream)
{
// Search from index node
var indexNode = Search(entry.ID);
// If index node is null, not found the guid
if (indexNode == null) { return; }
// Create a entry based on index node
// Read data from the index pointer to stream
DataFactory.ReadOnlyFileContent(indexNode, entry, stream, this);
}
public static void ReadFileContent(string dbFileName, EntryInfo entry, Stream output)
{
using (var db = new FileDB(dbFileName, FileAccess.Read))
{
db.ReadContent(entry, output);
}
}
