IdentityCache.cs

Go to the documentation of this file.

using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using Tgstation.Server.Host.Core;
using Tgstation.Server.Host.Models;

namespace Tgstation.Server.Host.Security
{
    sealed class IdentityCache : IIdentityCache, IDisposable
    {
        readonly IAsyncDelayer asyncDelayer;

        readonly ILogger<IdentityCache> logger;

        readonly Dictionary<long, IdentityCacheObject> cachedIdentities;

        public IdentityCache(IAsyncDelayer asyncDelayer, ILogger<IdentityCache> logger)
        {
            this.asyncDelayer = asyncDelayer ?? throw new ArgumentNullException(nameof(asyncDelayer));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));

            cachedIdentities = new Dictionary<long, IdentityCacheObject>();
        }

        public void Dispose()
        {
            logger.LogTrace("Disposing...");
            foreach (var I in cachedIdentities.Select(x => x.Value).ToList())
                I.Dispose();
        }

        public void CacheSystemIdentity(User user, ISystemIdentity systemIdentity, DateTimeOffset expiry)
        {
            if (user == null)
                throw new ArgumentNullException(nameof(user));
            if (systemIdentity == null)
                throw new ArgumentNullException(nameof(systemIdentity));
            lock (cachedIdentities)
            {
                var uid = systemIdentity.Uid;
                logger.LogDebug("Caching system identity {0} of user {1}", uid, user.Id);

                if (cachedIdentities.TryGetValue(user.Id.Value, out var identCache))
                {
                    logger.LogTrace("Expiring previously cached identity...");
                    identCache.Dispose(); // also clears it out
                }

                identCache = new IdentityCacheObject(systemIdentity.Clone(), asyncDelayer, () =>
                {
                    logger.LogDebug("Expiring system identity cache for user {1}", uid, user.Id);
                    lock (cachedIdentities)
                        cachedIdentities.Remove(user.Id.Value);
                }, expiry);
                cachedIdentities.Add(user.Id.Value, identCache);
            }
        }

        public ISystemIdentity LoadCachedIdentity(User user)
        {
            if (user == null)
                throw new ArgumentNullException(nameof(user));
            lock (cachedIdentities)
                if (cachedIdentities.TryGetValue(user.Id.Value, out var identity))
                    return identity.SystemIdentity.Clone();
            throw new InvalidOperationException("Cached system identity has expired!");
        }
    }
}