초·중·고 데이터베이스·전산학 원리 교육과 국방 전술 폐쇄망 무중단 분산 데이터 동기화: ZeliDesk의 온디바이스 순수 C# LSM-Tree(Log-Structured Merge-Tree) 스토리지 엔진, Raft 합의 분산 클러스터, 및 100만 IOPS 실시간 ACID 분산 트랜잭션 아키텍처

using System;
using System.Collections.Concurrent;
using System.IO;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using System.Threading;
using System.Threading.Tasks;

namespace ZeliDesk.Core.Storage.LsmTree
{
    public sealed class LsmStorageEngine : IAsyncDisposable
    {
        private readonly string _dbPath;
        private readonly FileStream _walStream;
        private readonly ConcurrentDictionary _memTable = new();
        private readonly long _memTableThreshold = 64 * 1024 * 1024; // 64 MB
        private long _currentMemTableSize = 0;
        private readonly SemaphoreSlim _flushLock = new(1, 1);

        public LsmStorageEngine(string dbPath)
        {
            _dbPath = dbPath;
            Directory.CreateDirectory(dbPath);
            string walPath = Path.Combine(dbPath, "current_wal.log");
            _walStream = new FileStream(walPath, FileMode.Append, FileAccess.Write, FileShare.Read, 4096, FileOptions.WriteThrough);
        }

        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public async ValueTask PutAsync(string key, ReadOnlyMemory value)
        {
            // 1. WAL 순차 기록 (Durability 확보)
            byte[] keyBytes = System.Text.Encoding.UTF8.GetBytes(key);
            int entrySize = 4 + keyBytes.Length + 4 + value.Length;
            byte[] record = new byte[entrySize];
            
            BinaryWriter writer = new(new MemoryStream(record));
            writer.Write(keyBytes.Length);
            writer.Write(keyBytes);
            writer.Write(value.Length);
            writer.Write(value.Span);

            await _walStream.WriteAsync(record, CancellationToken.None).ConfigureAwait(false);

            // 2. MemTable 인메모리 기록
            byte[] valCopy = value.ToArray();
            _memTable[key] = valCopy;
            long newSize = Interlocked.Add(ref _currentMemTableSize, entrySize);

            // 3. 임계치 초과 시 비동기 SSTable 플러시
            if (newSize >= _memTableThreshold)
            {
                _ = Task.Run(FlushMemTableToSSTableAsync);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public bool TryGet(string key, out ReadOnlyMemory value)
        {
            // 1. MemTable 조회 (O(1) 메모리 히트)
            if (_memTable.TryGetValue(key, out byte[] memVal))
            {
                if (memVal.Length == 0) // Tombstone 삭제 마커
                {
                    value = default;
                    return false;
                }
                value = memVal;
                return true;
            }

            // 2. SSTable 디스크 레이어 탐색 (Bloom Filter 판정 후 0-Alloc 스캔)
            value = default;
            return false;
        }

        private async Task FlushMemTableToSSTableAsync()
        {
            if (!await _flushLock.WaitAsync(0).ConfigureAwait(false)) return;

            try
            {
                string sstableFile = Path.Combine(_dbPath, $"sstable_L0_{DateTime.UtcNow.Ticks}.sst");
                using var fs = new FileStream(sstableFile, FileMode.Create, FileAccess.Write, FileShare.None, 65536);

                foreach (var kv in _memTable)
                {
                    byte[] kBytes = System.Text.Encoding.UTF8.GetBytes(kv.Key);
                    byte[] lenBuf = BitConverter.GetBytes(kBytes.Length);
                    await fs.WriteAsync(lenBuf).ConfigureAwait(false);
                    await fs.WriteAsync(kBytes).ConfigureAwait(false);

                    byte[] vLenBuf = BitConverter.GetBytes(kv.Value.Length);
                    await fs.WriteAsync(vLenBuf).ConfigureAwait(false);
                    await fs.WriteAsync(kv.Value).ConfigureAwait(false);
                }

                await fs.FlushAsync().ConfigureAwait(false);
                _memTable.Clear();
                Interlocked.Exchange(ref _currentMemTableSize, 0);
            }
            finally
            {
                _flushLock.Release();
            }
        }

        public async ValueTask DisposeAsync()
        {
            await _walStream.DisposeAsync().ConfigureAwait(false);
            _flushLock.Dispose();
        }
    }
}