added more details to stream info

src/EvenireDB.Benchmark/EventsProviderBenckmarks.cs

@@ -32,8 +32,8 @@ public void GlobalSetup()
         var headersRepo = new HeadersRepository();
         var repo = new EventsProvider(headersRepo, dataRepo, extentInfoProvider);
 
-        var cache = new EventsCache(
-            new NullLogger<EventsCache>(),
+        var cache = new StreamsCache(
+            new NullLogger<StreamsCache>(),
             new LRUCache<Guid, CachedEvents>(this.EventsCount),
             repo);
 

src/EvenireDB/EventsReader.cs

@@ -7,12 +7,12 @@ namespace EvenireDB
 {
     internal class EventsReader : IEventsReader
     {
-        private readonly IEventsCache _cache;
+        private readonly IStreamsCache _cache;
         private readonly EventsReaderConfig _config;
 
         public EventsReader(
             EventsReaderConfig config,            
-            IEventsCache cache)
+            IStreamsCache cache)
         {
             _cache = cache ?? throw new ArgumentNullException(nameof(cache));
             _config = config ?? throw new ArgumentNullException(nameof(config));
@@ -27,7 +27,7 @@ public async IAsyncEnumerable<Event> ReadAsync(
             if (startPosition < 0)
                 throw new ArgumentOutOfRangeException(nameof(startPosition));
 
-            CachedEvents entry = await _cache.EnsureStreamAsync(streamId, cancellationToken).ConfigureAwait(false);
+            CachedEvents entry = await _cache.GetEventsAsync(streamId, cancellationToken).ConfigureAwait(false);
 
             if (entry?.Events == null || entry.Events.Count == 0)
                 yield break;

src/EvenireDB/EventsWriter.cs

@@ -6,12 +6,12 @@ namespace EvenireDB
     // TODO: append to a transaction log
     public class EventsWriter : IEventsWriter
     {
-        private readonly IEventsCache _cache;
+        private readonly IStreamsCache _cache;
         private readonly ChannelWriter<IncomingEventsGroup> _writer;
         private readonly IEventIdGenerator _idGenerator;
         private readonly ILogger<EventsWriter> _logger;
 
-        public EventsWriter(IEventsCache cache, ChannelWriter<IncomingEventsGroup> writer, IEventIdGenerator idGenerator, ILogger<EventsWriter> logger)
+        public EventsWriter(IStreamsCache cache, ChannelWriter<IncomingEventsGroup> writer, IEventIdGenerator idGenerator, ILogger<EventsWriter> logger)
         {
             _cache = cache;
             _writer = writer;
@@ -33,7 +33,7 @@ public async ValueTask<IOperationResult> AppendAsync(
             if (!incomingEvents.Any())
                 return new SuccessResult();
 
-            CachedEvents entry = await _cache.EnsureStreamAsync(streamId, cancellationToken).ConfigureAwait(false);
+            CachedEvents entry = await _cache.GetEventsAsync(streamId, cancellationToken).ConfigureAwait(false);
 
             if (expectedVersion.HasValue && entry.Events.Count != expectedVersion)
                 return FailureResult.VersionMismatch(streamId, expectedVersion.Value, entry.Events.Count);    

src/EvenireDB/IServiceCollectionExtensions.cs

@@ -22,7 +22,7 @@ public static IServiceCollection AddEvenire(this IServiceCollection services, Ev
             {
                 return new LRUCache<Guid, CachedEvents>(settings.MaxInMemoryStreamsCount);
             })
-            .AddSingleton<IEventsCache, EventsCache>()
+            .AddSingleton<IStreamsCache, StreamsCache>()
             .AddSingleton(ctx =>
             {
 

src/EvenireDB/IStreamsCache.cs

@@ -0,0 +1,8 @@
+namespace EvenireDB;
+
+public interface IStreamsCache
+{
+    void Update(Guid streamId, CachedEvents entry);
+    ValueTask<CachedEvents> GetEventsAsync(Guid streamId, CancellationToken cancellationToken);
+    bool ContainsKey(Guid streamId);
+}

src/EvenireDB/StreamInfo.cs

@@ -3,5 +3,6 @@ namespace EvenireDB;
 public readonly record struct StreamInfo(
     Guid StreamId, 
     long EventsCount, 
+    bool IsCached,
     DateTimeOffset CreatedAt,
     DateTimeOffset LastAccessedAt);

src/EvenireDB/StreamInfoProvider.cs

@@ -6,10 +6,12 @@ internal class StreamInfoProvider : IStreamInfoProvider
 {
     private readonly int _headerSize = Marshal.SizeOf<RawHeader>();
     private readonly IExtentInfoProvider _extentInfoProvider;
-
-    public StreamInfoProvider(IExtentInfoProvider extentInfoProvider)
+    private readonly IStreamsCache _cache;
+
+    public StreamInfoProvider(IExtentInfoProvider extentInfoProvider, IStreamsCache cache)
     {
         _extentInfoProvider = extentInfoProvider ?? throw new ArgumentNullException(nameof(extentInfoProvider));
+        _cache = cache ?? throw new ArgumentNullException(nameof(cache));
     }
 
     public StreamInfo GetStreamInfo(Guid streamId)
@@ -21,6 +23,7 @@ public StreamInfo GetStreamInfo(Guid streamId)
         return new StreamInfo(
             streamId,
             headersCount,
+            _cache.ContainsKey(streamId),
             fileInfo.CreationTimeUtc,
             fileInfo.LastWriteTimeUtc);
     }

src/EvenireDB/StreamsCache.cs

@@ -0,0 +1,41 @@
+using EvenireDB.Persistence;
+using EvenireDB.Utils;
+using Microsoft.Extensions.Logging;
+
+namespace EvenireDB;
+
+internal class StreamsCache : IStreamsCache
+{
+    private readonly ICache<Guid, CachedEvents> _cache;
+    private readonly ILogger<StreamsCache> _logger;
+    private readonly IEventsProvider _repo;
+
+    public StreamsCache(
+        ILogger<StreamsCache> logger,
+        ICache<Guid, CachedEvents> cache,
+        IEventsProvider repo)
+    {
+        _logger = logger;
+        _cache = cache;
+        _repo = repo;
+    }
+
+    private async ValueTask<CachedEvents> Factory(Guid streamId, CancellationToken cancellationToken)
+    {
+        _logger.ReadingStreamFromRepository(streamId);
+
+        var persistedEvents = new List<Event>();
+        await foreach (var @event in _repo.ReadAsync(streamId, cancellationToken: cancellationToken))
+            persistedEvents.Add(@event);
+        return new CachedEvents(persistedEvents, new SemaphoreSlim(1));
+    }
+
+    public ValueTask<CachedEvents> GetEventsAsync(Guid streamId, CancellationToken cancellationToken)
+    => _cache.GetOrAddAsync(streamId, this.Factory, cancellationToken);
+
+    public void Update(Guid streamId, CachedEvents entry)
+    => _cache.AddOrUpdate(streamId, entry);
+
+    public bool ContainsKey(Guid streamId)
+    => _cache.ContainsKey(streamId);
+}