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