public override void ReadInternal(byte[] b, int offset, int length)
{
if (b.Length == 0)
{
return;
}
LiteFileInfo fileInfo = _db.FileStorage.FindById(_name);
if (offset < _position)
{
fileInfo = _db.FileStorage.FindById(_name);
}
if (fileInfo == null)
{
return;
}
if (fileInfo.Length > 0)
{
using (var stream = new MemoryStream())
{
fileInfo.CopyTo(stream);
stream.Position = _position;
stream.Read(b, offset, length);
}
GC.Collect();
}
_position += length;
}
internal override RawBlock?GetRawBlock(HashDigest <SHA256> blockHash)
{
_blockLock.EnterUpgradeableReadLock();
try
{
LiteFileInfo file = _db.FileStorage.FindById(BlockFileId(blockHash));
if (file is null)
{
return(null);
}
_blockLock.EnterWriteLock();
try
{
using (var stream = new MemoryStream())
{
DownloadFile(file, stream);
stream.Seek(0, SeekOrigin.Begin);
var formatter = new BencodexFormatter <RawBlock>();
return((RawBlock)formatter.Deserialize(stream));
}
}
finally
{
_blockLock.ExitWriteLock();
}
}
finally
{
_blockLock.ExitUpgradeableReadLock();
}
}
public Task <IReadOnlyCollection <PersonalInfo> > GetListAsync(
int pageIndex, int pageSize, CancellationToken cancellationToken = default)
{
var query = _liteDatabase.GetCollection <PersonalInfo>().Query();
var list = query
.OrderByDescending(p => p.Name)
.Skip((pageIndex) * pageSize)
.Limit(pageSize)
.ToList();
if (list != null && list.Count > 0)
{
var fs = _liteDatabase.GetStorage <string>("dataFiles", "dataChunks");
foreach (var item in list)
{
if (fs.Exists($"$/Data/{item.AvatarName}"))
{
LiteFileInfo <string> file = fs.FindById($"$/Data/{item.AvatarName}");
Stream stream = new MemoryStream();
fs.Download(file.Id, stream);
stream.Seek(0, SeekOrigin.Begin);
item.AvatarStream = stream;
}
}
}
return(Task.FromResult((IReadOnlyCollection <PersonalInfo>)list));
}
/// <inheritdoc/>
public override void PutTransaction <T>(Transaction <T> tx)
{
string fileId = TxFileId(tx.Id);
string filename = tx.Id.ToHex();
byte[] txBytes = tx.ToBencodex(true);
_txLock.EnterUpgradeableReadLock();
try
{
LiteFileInfo file = _db.FileStorage.FindById(fileId);
if (file is LiteFileInfo)
{
// No-op if already exists.
return;
}
_txLock.EnterWriteLock();
try
{
UploadFile(fileId, filename, txBytes);
}
finally
{
_txLock.ExitWriteLock();
}
}
finally
{
_txLock.ExitUpgradeableReadLock();
}
}
/// <inheritdoc/>
public override IImmutableDictionary <Address, IValue> GetBlockStates(
HashDigest <SHA256> blockHash
)
{
if (_statesCache.TryGetValue(
blockHash,
out IImmutableDictionary <Address, IValue> cached))
{
return(cached);
}
LiteFileInfo file =
_db.FileStorage.FindById(BlockStateFileId(blockHash));
if (file is null)
{
return(null);
}
using (var stream = new MemoryStream())
{
DownloadFile(file, stream);
stream.Seek(0, SeekOrigin.Begin);
var deserialized = (Bencodex.Types.Dictionary)_codec.Decode(stream);
ImmutableDictionary <Address, IValue> states = deserialized.ToImmutableDictionary(
kv => new Address((Binary)kv.Key),
kv => kv.Value
);
_statesCache.AddOrUpdate(blockHash, states);
return(states);
}
}
public async Task <Stream> GetImageAsync(string path)
{
try
{
if (path.StartsWith("/"))
{
return(await ImageClient.GetStreamAsync("original" + path));
}
else if (!path.StartsWith("w"))
{
return(await YouTubeClient.GetStreamAsync(String.Format("{0}/0.jpg", path)));
}
string id = path.ComputeHash();
LiteFileInfo fileInfo = FileStorage.FindById(id);
if (fileInfo == null)
{
try
{
using (Stream stream = await ImageClient.GetStreamAsync(path))
{
if (stream != null)
{
using (MemoryStream memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
if (memoryStream.Length > 0)
{
memoryStream.Position = 0;
fileInfo = FileStorage.Upload(id, path, memoryStream);
}
}
}
}
}
catch (Exception)
{
return(null);
}
}
if (fileInfo == null)
{
return(null);
}
MemoryStream cachedStream = new MemoryStream();
fileInfo.CopyTo(cachedStream);
cachedStream.Position = 0;
return(cachedStream);
}
catch (Exception)
{
return(null);
}
}
private void DownloadFile(LiteFileInfo file, Stream stream)
{
file.CopyTo(stream);
if (stream.Length > file.Length)
{
stream.SetLength(file.Length);
}
}
private static void ExtractData(LiteFileInfo file, out LibGit2Sharp.ObjectId oid, out int length, out ObjectType objectType)
{
using (var reader = new BinaryReader(file.OpenRead()))
{
oid = new LibGit2Sharp.ObjectId(reader.ReadString());
objectType = (ObjectType)reader.ReadInt32();
length = reader.ReadInt32();
}
}
/// <summary>
/// Reads file from storage
/// </summary>
/// <param name="idOrName">Name or Id</param>
/// <returns>Null if not found otherwise filled <see cref="TFile"/></returns>
public TFile Get(String idOrName)
{
LiteFileInfo fileInfo = _fileStorage.FindById(idOrName);
if (fileInfo == null)
{
return(null);
}
return(fileInfo.ToStorageFile <TFile>());
}
public CustomFileInfo(LiteFileInfo <string> fileInfo)
{
if (fileInfo != null)
{
Id = fileInfo.Id;
Filename = fileInfo.Filename;
MimeType = fileInfo.MimeType;
Length = fileInfo.Length;
Chunks = fileInfo.Chunks;
UploadDate = fileInfo.UploadDate;
}
}
private void ExtractData(LiteFileInfo file, out LibGit2Sharp.ObjectId oid, out UnmanagedMemoryStream data, out ObjectType objectType)
{
using (var reader = new BinaryReader(file.OpenRead()))
{
oid = new LibGit2Sharp.ObjectId(reader.ReadString());
objectType = (ObjectType)reader.ReadInt32();
var length = reader.ReadInt32();
var bytes = reader.ReadBytes(length);
data = AllocateAndBuildFrom(bytes);
// Update last item
_lastItem = new StoreItem(oid.Sha, objectType, bytes);
}
}
// Copy the configuration file for default user to the Calendar_Configuration folder.
public void RETRIEVE_CONFIG_FILE(string NAME_RETRIEVE)
{
string INTERNAL_DATABASE = AppDomain.CurrentDomain.BaseDirectory + "database_internal.db";
CONFIG_DB = @"configurations/" + NAME_RETRIEVE + "/" + NAME_RETRIEVE + ".cfg";
using (var db = new LiteDatabase(INTERNAL_DATABASE))
{
if (db.FileStorage.Exists(CONFIG_DB))
{
LiteFileInfo file = db.FileStorage.FindById(CONFIG_DB);
file.SaveAs(AppDomain.CurrentDomain.BaseDirectory + "Calendar_Configuration/" + "configuration");
}
}
}
/// <inheritdoc/>
public override Transaction <T> GetTransaction <T>(TxId txid)
{
string fileId = TxFileId(txid);
byte[] bytes;
_txLock.EnterUpgradeableReadLock();
try
{
LiteFileInfo file = _db.FileStorage.FindById(fileId);
if (file is null)
{
return(null);
}
using (var stream = new MemoryStream())
{
DownloadFile(file, stream);
bytes = stream.ToArray();
if (bytes.Length != file.Length || bytes.Length < 1)
{
_logger.Warning(
"The data file for the transaction {TxId} seems corrupted; " +
"it will be treated nonexistent and removed at all.",
txid
);
_txLock.EnterWriteLock();
try
{
_db.FileStorage.Delete(fileId);
}
finally
{
_txLock.ExitWriteLock();
}
return(null);
}
}
}
finally
{
_txLock.ExitUpgradeableReadLock();
}
return(Transaction <T> .FromBencodex(bytes));
}
/// <summary>
/// Creates new instance of DatabaseFile based on file from LiteDB database.
/// </summary>
/// <param name="liteDbFile">LiteDB file.</param>
public DatabaseFile(LiteFileInfo liteDbFile)
{
Id = liteDbFile.Id;
Filename = liteDbFile.Filename;
MimeType = liteDbFile.MimeType;
Length = liteDbFile.Length;
UploadDate = liteDbFile.UploadDate;
if (liteDbFile.Metadata != null)
{
Metadata = new Dictionary <string, object>();
foreach (var key in liteDbFile.Metadata.Keys)
{
Metadata.Add(key, liteDbFile.Metadata[key]);
}
}
}
private XElement ReadElementFromFile(LiteFileInfo fileInfo)
{
using (var fileStream = fileInfo.OpenRead())
{
try
{
return(XElement.Load(fileStream));
}
catch (XmlException e)
{
var logger = LoggerFactory?.CreateLogger <LiteDbXmlStorage>();
logger?.LogError($"The key file '{fileInfo.Filename}' is corrupted.\nSee details:\n{e}");
return(null);
}
}
}
// Copy the avatar files for remote linked users to the local Calendar_Configuration folder.
public void RETRIEVE_REMOTE_IMAGES(string NAME_RETRIEVE)
{
string[] lines = File.ReadAllLines(AppDomain.CurrentDomain.BaseDirectory + "Calendar_Configuration/configuration");
DATABASE_NAME = null;
DATABASE_EXTERNAL = null;
DATABASE_NAME = lines[17];
DATABASE_EXTERNAL = lines[18];
EXTERNAL_DATABASE = DATABASE_EXTERNAL + DATABASE_NAME + ".db";
AVATAR_DB = @"images/" + NAME_RETRIEVE + "/" + NAME_RETRIEVE + ".avt";
FileInfo FileFromDirectory = new FileInfo(EXTERNAL_DATABASE);
MonolithConsole("File is unlocked in RETRIEVE REMOTE USERS " + IsFileLocked(FileFromDirectory, EXTERNAL_DATABASE));
using (var db = new LiteDatabase(EXTERNAL_DATABASE))
{
var EmployeeCollection = db.GetCollectionNames();
while (db.Engine.Locker.ThreadState != LockState.Unlocked)
{
Console.WriteLine("Wainting for file to be unlocked");
}
//
for (int x = 3; x < EmployeeCollection.Count(); x++)
{
string FULL_NAME = EmployeeCollection.ElementAtOrDefault(x);
LiteFileInfo file = db.FileStorage.FindById("images/" + FULL_NAME + "/" + FULL_NAME + ".avt");
if (file != null)
{
if (lines[8] + "_" + lines[9] != FULL_NAME)
{
if (File.Exists(AppDomain.CurrentDomain.BaseDirectory + "Calendar_Configuration/" + FULL_NAME + ".avt") == false)
{
file.SaveAs(AppDomain.CurrentDomain.BaseDirectory + "Calendar_Configuration/" + FULL_NAME + ".avt", true);
}
}
}
}
}
}
/// <inheritdoc/>
public Transaction <T> GetTransaction <T>(TxId txid)
where T : IAction, new()
{
LiteFileInfo file = _db.FileStorage.FindById(TxFileId(txid));
if (file is null)
{
return(null);
}
using (var stream = new MemoryStream())
{
file.CopyTo(stream);
stream.Seek(0, SeekOrigin.Begin);
return(Transaction <T> .FromBencodex(stream.ToArray()));
}
}
/// <inheritdoc/>
public IEnumerable <Tuple <HashDigest <SHA256>, long> > IterateStateReferences(
string @namespace,
Address address)
{
var fileId = $"{StateRefIdPrefix}{@namespace}/{address.ToHex()}";
LiteFileInfo file = _db.FileStorage.FindById(fileId);
if (file is null || file.Length == 0)
{
yield break;
}
int hashSize = HashDigest <SHA256> .Size;
int stateReferenceSize = hashSize + sizeof(long);
if (file.Length % stateReferenceSize != 0)
{
throw new FileLoadException(
$"State references file's size ({file.Length}) should be multiple of " +
$"state reference entry size {stateReferenceSize})."
);
}
using (var stream = new MemoryStream())
{
// Note that a stream made by file.OpenRead() does not support
// .Seek() operation --- although it implements the interface,
// the method throws a NotSupportedException.
file.CopyTo(stream);
var buffer = new byte[stateReferenceSize];
long position = stream.Seek(0, SeekOrigin.End);
for (var i = 1; position - buffer.Length >= 0; i++)
{
position = stream.Seek(-buffer.Length * i, SeekOrigin.End);
stream.Read(buffer, 0, buffer.Length);
byte[] hashBytes = buffer.Take(hashSize).ToArray();
long index = BitConverter.ToInt64(buffer, hashSize);
yield return(Tuple.Create(
new HashDigest <SHA256>(hashBytes),
index
));
}
}
}
public static TFile ToStorageFile <TFile>(this LiteFileInfo fileInfo) where TFile : class, IStorageFile, new()
{
TFile file = new TFile
{
Id = fileInfo.Id
};
// Read
using (LiteFileStream fs = fileInfo.OpenRead())
using (MemoryStream ms = new MemoryStream())
{
fs.CopyTo(ms);
file.Content = ms.ToArray();
}
return(file);
}
/// <inheritdoc/>
public override AddressStateMap GetBlockStates(HashDigest <SHA256> blockHash)
{
LiteFileInfo file =
_db.FileStorage.FindById(BlockStateFileId(blockHash));
if (file is null)
{
return(null);
}
using (var stream = new MemoryStream())
{
DownloadFile(file, stream);
stream.Seek(0, SeekOrigin.Begin);
var formatter = new BinaryFormatter();
return((AddressStateMap)formatter.Deserialize(stream));
}
}
// Retrieve image file from local database.
public void RETRIEVE_IMAGE_FILE(string NAME_RETRIEVE)
{
string INTERNAL_DATABASE = AppDomain.CurrentDomain.BaseDirectory + "database_internal.db";
AVATAR_DB = @"images/" + NAME_RETRIEVE + "/" + NAME_RETRIEVE + ".avt";
using (var db = new LiteDatabase(INTERNAL_DATABASE))
{
if (db.FileStorage.Exists(AVATAR_DB))
{
if (File.Exists(AppDomain.CurrentDomain.BaseDirectory + "Calendar_Configuration/" + "avatar") == false)
{
LiteFileInfo file = db.FileStorage.FindById(AVATAR_DB);
file.SaveAs(AppDomain.CurrentDomain.BaseDirectory + "Calendar_Configuration/" + "avatar");
}
}
}
}
/// <inheritdoc/>
public Block <T> GetBlock <T>(HashDigest <SHA256> blockHash)
where T : IAction, new()
{
LiteFileInfo file =
_db.FileStorage.FindById(BlockFileId(blockHash));
if (file is null)
{
return(null);
}
using (var stream = new MemoryStream())
{
file.CopyTo(stream);
stream.Seek(0, SeekOrigin.Begin);
var formatter = new BencodexFormatter <RawBlock>();
RawBlock rawBlock = (RawBlock)formatter.Deserialize(stream);
HashDigest <SHA256>?previousHash = null;
if (rawBlock.PreviousHash != null)
{
previousHash =
new HashDigest <SHA256>(rawBlock.PreviousHash);
}
return(new Block <T>(
index: rawBlock.Index,
difficulty: rawBlock.Difficulty,
nonce: new Nonce(rawBlock.Nonce),
miner: new Address(rawBlock.Miner),
previousHash: previousHash,
timestamp: DateTimeOffset.ParseExact(
rawBlock.Timestamp,
Block <T> .TimestampFormat,
CultureInfo.InvariantCulture
).ToUniversalTime(),
transactions: GetTransactions <T>(rawBlock.Transactions)
));
}
}
// Copy the configuration files for remote linked users to the local Calendar_Configuration folder.
public void RETRIEVE_REMOTE_USERS()
{
string[] lines = File.ReadAllLines(AppDomain.CurrentDomain.BaseDirectory + "Calendar_Configuration/configuration");
DATABASE_NAME = null;
DATABASE_EXTERNAL = null;
DATABASE_NAME = lines[17];
DATABASE_EXTERNAL = lines[18];
EXTERNAL_DATABASE = DATABASE_EXTERNAL + DATABASE_NAME + ".db";
FileInfo FileFromDirectory = new FileInfo(EXTERNAL_DATABASE);
using (var db = new LiteDatabase(EXTERNAL_DATABASE))
{
var EmployeeCollection = db.GetCollectionNames();
while (db.Engine.Locker.ThreadState != LockState.Unlocked)
{
Console.WriteLine("Wainting for file to be unlocked");
}
for (int x = 3; x < EmployeeCollection.Count(); x++)
{
MonolithConsole("Count Add List");
PersonnelList.Add(EmployeeCollection.ElementAtOrDefault(x));
string FULL_NAME = EmployeeCollection.ElementAtOrDefault(x);
LiteFileInfo file = db.FileStorage.FindById("configurations/" + FULL_NAME + "/" + FULL_NAME + ".cfg");
if (file != null)
{
if (lines[8] + "_" + lines[9] != FULL_NAME)
{
file.SaveAs(AppDomain.CurrentDomain.BaseDirectory + "Calendar_Configuration/" + FULL_NAME + ".cfg", true);
}
}
}
}
}
private void DownloadFile(LiteFileInfo file, Stream outStream)
{
using (var fileStream = file.OpenRead())
{
if (fileStream.Length > file.Length)
{
fileStream.SetLength(file.Length);
}
if (_compress)
{
using (var deflate = new DeflateStream(outStream, CompressionMode.Decompress))
{
deflate.CopyTo(outStream);
}
}
else
{
fileStream.CopyTo(outStream);
}
}
}
public void LoadFile(LiteFileInfo file)
{
var textRegex = new Regex("text|json|script|xml");
if (file.MimeType.StartsWith("image"))
{
using (var fStream = file.OpenRead())
{
var stream = new MemoryStream();
fStream.CopyTo(stream);
stream.Seek(0, SeekOrigin.Begin);
var bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.StreamSource = stream;
bitmap.CacheOption = BitmapCacheOption.OnLoad;
bitmap.EndInit();
bitmap.Freeze();
ImageImage.Source = bitmap;
ImageImage.Visibility = Visibility.Visible;
TextText.Visibility = Visibility.Collapsed;
}
}
else if (textRegex.IsMatch(file.MimeType))
{
using (var fileStream = file.OpenRead())
{
using (var reader = new StreamReader(fileStream))
{
var myStr = reader.ReadToEnd();
TextText.Text = myStr;
TextText.Visibility = Visibility.Visible;
ImageImage.Visibility = Visibility.Collapsed;
}
}
}
}
/// <inheritdoc/>
public void StoreStateReference <T>(
string @namespace,
IImmutableSet <Address> addresses,
Block <T> block)
where T : IAction, new()
{
int hashSize = HashDigest <SHA256> .Size;
byte[] hashBytes = block.Hash.ToByteArray();
byte[] indexBytes = BitConverter.GetBytes(block.Index);
foreach (Address address in addresses)
{
string addrHex = address.ToHex();
var fileId = $"{StateRefIdPrefix}{@namespace}/{addrHex}";
if (!_db.FileStorage.Exists(fileId))
{
_db.FileStorage.Upload(
fileId,
addrHex,
new MemoryStream());
}
LiteFileInfo file = _db.FileStorage.FindById(fileId);
using (var temp = new MemoryStream())
{
file.CopyTo(temp);
temp.Seek(0, SeekOrigin.Begin);
byte[] prev = temp.ToArray();
using (LiteFileStream stream = file.OpenWrite())
{
stream.Write(prev, 0, prev.Length);
stream.Write(hashBytes, 0, hashSize);
stream.Write(indexBytes, 0, sizeof(long));
}
}
}
}
/// <inheritdoc/>
public void ForkStateReferences <T>(
string srcNamespace,
string destNamespace,
Block <T> branchPoint,
IImmutableSet <Address> addressesToStrip)
where T : IAction, new()
{
long branchPointIndex = branchPoint.Index;
List <LiteFileInfo> files =
_db.FileStorage
.Find($"{StateRefIdPrefix}{srcNamespace}")
.ToList();
if (!files.Any() && addressesToStrip.Any())
{
throw new NamespaceNotFoundException(
srcNamespace,
"The source namespace to be forked does not exist.");
}
foreach (LiteFileInfo srcFile in files)
{
string destId =
$"{StateRefIdPrefix}{destNamespace}/{srcFile.Filename}";
_db.FileStorage.Upload(
destId,
srcFile.Filename,
new MemoryStream());
LiteFileInfo destFile = _db.FileStorage.FindById(destId);
using (LiteFileStream srcStream = srcFile.OpenRead())
using (LiteFileStream destStream = destFile.OpenWrite())
{
while (srcStream.Position < srcStream.Length)
{
var hashBytes = new byte[HashDigest <SHA256> .Size];
var indexBytes = new byte[sizeof(long)];
srcStream.Read(hashBytes, 0, hashBytes.Length);
srcStream.Read(indexBytes, 0, indexBytes.Length);
long currentIndex =
BitConverter.ToInt64(indexBytes, 0);
if (currentIndex <= branchPointIndex)
{
destStream.Write(hashBytes, 0, hashBytes.Length);
destStream.Write(indexBytes, 0, indexBytes.Length);
}
else
{
break;
}
}
}
if (destFile.Length == 0)
{
_db.FileStorage.Delete(destId);
}
}
}
