AttachmentCache.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Threading.Tasks;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Cache;
using Waher.Runtime.Threading;
 
namespace Waher.Service.IoTBroker.Legal.Attachments
{
    public static class AttachmentCache
    {
        private static readonly Cache<CaseInsensitiveString, AttachmentCacheItem> cache = 
            new Cache<CaseInsensitiveString, AttachmentCacheItem>(int.MaxValue, TimeSpan.FromHours(1), TimeSpan.FromMinutes(1));
 
        public static async Task<AttachmentCacheItem> TryGetAttachment(CaseInsensitiveString AttachmentId)
        {
            using Semaphore Semaphore = await Semaphores.BeginRead("attachment:" + AttachmentId.LowerCase);
 
            if (cache.TryGetValue(AttachmentId, out AttachmentCacheItem Item))
                return Item;
 
            Item = await Database.FindFirstIgnoreRest<AttachmentCacheItem>(
                new FilterFieldEqualTo("AttachmentId", AttachmentId));
 
            if (!(Item is null))
                cache.Add(AttachmentId, Item);
 
            return Item;
        }
 
        public static async Task<bool> ContainsAttachment(CaseInsensitiveString AttachmentId)
        {
            return !((await TryGetAttachment(AttachmentId)) is null);
        }
 
        public static async Task<bool> AddLocalAttachment(Attachment Attachment, DateTime Expires)
        {
            using Semaphore Semaphore = await Semaphores.BeginWrite("attachment:" + Attachment.Id.LowerCase);
 
            if (cache.TryGetValue(Attachment.Id, out AttachmentCacheItem Item))
                return false;
 
            Item = await Database.FindFirstIgnoreRest<AttachmentCacheItem>(
                new FilterFieldEqualTo("AttachmentId", Attachment.Id));
 
            if (!(Item is null))
            {
                cache.Add(Attachment.Id, Item);
                return false;
            }
 
            Item = new AttachmentCacheItem()
            {
                AttachmentId = Attachment.Id,
                Created = DateTime.UtcNow,
                Expires = Expires,
                ContentType = Attachment.ContentType,
                LocalAttachmentId = Attachment.ObjectId,
                FileName = Attachment.LocalFileName,
                Size = Attachment.Size,
                Salt = Attachment.Salt
            };
 
            await Database.Insert(Item);
 
            return true;
        }
 
        public static async Task<bool> AddRemoteAttachment(CaseInsensitiveString AttachmentId,
            DateTime Expires, byte[] Data, string ContentType, LegalComponent Legal)
        {
            using Semaphore Semaphore = await Semaphores.BeginWrite("attachment:" + AttachmentId.LowerCase);
 
            if (cache.TryGetValue(AttachmentId, out AttachmentCacheItem Item))
                return false;
 
            Item = await Database.FindFirstIgnoreRest<AttachmentCacheItem>(
                new FilterFieldEqualTo("AttachmentId", AttachmentId));
 
            if (!(Item is null))
            {
                cache.Add(AttachmentId, Item);
                return false;
            }
 
            string Folder = LegalComponent.GetFolderName(Legal.AttachmentsFolder, out DateTime Timestamp);
            byte[] Salt = Gateway.NextBytes(48);
            byte[] Key = new byte[32];
            byte[] IV = new byte[16];
 
            Item = new AttachmentCacheItem()
            {
                AttachmentId = AttachmentId,
                Created = DateTime.UtcNow,
                Expires = Expires.ToUniversalTime(),
                ContentType = ContentType,
                LocalAttachmentId = null,
                FileName = Path.Combine(Folder, AttachmentId + ".bin"),
                Size = Data.Length,
                Salt = Salt
            };
 
            await Database.Insert(Item);
 
            using FileStream AttachmentFile = File.Create(Item.FileName);
            Aes Aes = Aes.Create();
 
            Aes.BlockSize = 128;
            Aes.KeySize = 256;
            Aes.Mode = CipherMode.CBC;
            Aes.Padding = PaddingMode.Zeros;
 
            using ICryptoTransform Encryptor = Aes.CreateEncryptor(Key, IV);
            using CryptoStream EncryptedAttachmentFile = new CryptoStream(AttachmentFile, Encryptor, CryptoStreamMode.Write);
 
            await EncryptedAttachmentFile.WriteAsync(Data, 0, Data.Length);
            EncryptedAttachmentFile.FlushFinalBlock();
 
            return true;
        }
 
        public static async Task<int> DeleteOldAttachments()
        {
            DateTime Limit = DateTime.UtcNow;
            const int MaxCount = 10;
            int Result = 0;
            int c;
            IEnumerable<AttachmentCacheItem> Items;
 
            Items = await Database.FindDelete<AttachmentCacheItem>(0, MaxCount,
               new FilterFieldLesserOrEqualTo("Expires", Limit));
 
            do
            {
                c = 0;
                foreach (AttachmentCacheItem Item in Items)
                {
                    cache.Remove(Item.AttachmentId);
                    Result++;
                    c++;
 
                    if (string.IsNullOrEmpty(Item.LocalAttachmentId) && File.Exists(Item.FileName))
                    {
                        try
                        {
                            File.Delete(Item.FileName);
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                        }
                    }
                }
            }
            while (c == MaxCount);
            
            return Result;
        }
    }
}