sam/Catalogger.NET
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

move classes around, name caches more consistently, add more caches

Browse source
This commit is contained in:
sam 2024-08-19 16:12:28 +02:00
parent e86b37ce2a
commit e17dcf90a1
Signed by: sam
GPG key ID: 5F3C3C1B3166639D
30 changed files with 443 additions and 51 deletions
Download patch file Download diff file Expand all files Collapse all files

10
Catalogger.Backend/Cache/IInviteCache.cs Normal file
View file

@ -0,0 +1,10 @@
using Remora.Discord.API.Abstractions.Objects;
using Remora.Rest.Core;
namespace Catalogger.Backend.Cache;
public interface IInviteCache
{
public Task<IEnumerable<IInvite>> TryGetAsync(Snowflake guildId);
public Task SetAsync(Snowflake guildId, IEnumerable<IInvite> invites);
}

14
Catalogger.Backend/Cache/IMemberCache.cs Normal file
View file

@ -0,0 +1,14 @@
using Remora.Discord.API.Abstractions.Objects;
using Remora.Rest.Core;
namespace Catalogger.Backend.Cache;
public interface IMemberCache
{
public Task<IGuildMember?> TryGetAsync(Snowflake guildId, Snowflake userId);
public Task SetAsync(Snowflake guildId, IGuildMember member);
public Task SetManyAsync(Snowflake guildId, IReadOnlyList<IGuildMember> members);
public Task<bool> IsGuildCachedAsync(Snowflake guildId);
public Task MarkAsCachedAsync(Snowflake guildId);
public Task MarkAsUncachedAsync(Snowflake guildId);
}

29
Catalogger.Backend/Cache/IWebhookCache.cs Normal file
View file

@ -0,0 +1,29 @@
using Catalogger.Backend.Extensions;
using Remora.Discord.API;
using Remora.Discord.API.Abstractions.Objects;
using Remora.Rest.Core;
namespace Catalogger.Backend.Cache;
public interface IWebhookCache
{
Task<Webhook?> GetWebhookAsync(ulong channelId);
Task SetWebhookAsync(ulong channelId, Webhook webhook);
public async Task<Webhook> GetOrFetchWebhookAsync(ulong channelId, Func<Snowflake, Task<IWebhook>> fetch)
{
var webhook = await GetWebhookAsync(channelId);
if (webhook != null) return webhook.Value;
var discordWebhook = await fetch(DiscordSnowflake.New(channelId));
webhook = new Webhook { Id = discordWebhook.ID.ToUlong(), Token = discordWebhook.Token.Value };
await SetWebhookAsync(channelId, webhook.Value);
return webhook.Value;
}
}
public struct Webhook
{
public required ulong Id { get; init; }
public required string Token { get; init; }
}

4
Catalogger.Backend/Cache/ChannelCacheService.cs → Catalogger.Backend/Cache/InMemoryCache/ChannelCache.cs
View file

@ -3,9 +3,9 @@ using System.Diagnostics.CodeAnalysis;
using Remora.Discord.API.Abstractions.Objects;
using Remora.Rest.Core;
namespace Catalogger.Backend.Cache;
namespace Catalogger.Backend.Cache.InMemoryCache;
public class ChannelCacheService
public class ChannelCache
{
private readonly ConcurrentDictionary<Snowflake, IChannel> _channels = new();
private readonly ConcurrentDictionary<Snowflake, HashSet<Snowflake>> _guildChannels = new();

4
Catalogger.Backend/Cache/GuildCacheService.cs → Catalogger.Backend/Cache/InMemoryCache/GuildCache.cs
View file

@ -3,9 +3,9 @@ using System.Diagnostics.CodeAnalysis;
using Remora.Discord.API.Abstractions.Objects;
using Remora.Rest.Core;
namespace Catalogger.Backend.Cache;
namespace Catalogger.Backend.Cache.InMemoryCache;
public class GuildCacheService
public class GuildCache
{
private readonly ConcurrentDictionary<Snowflake, IGuild> _guilds = new();

20
Catalogger.Backend/Cache/InMemoryCache/InMemoryInviteCache.cs Normal file
View file

@ -0,0 +1,20 @@
using System.Collections.Concurrent;
using Remora.Discord.API.Abstractions.Objects;
using Remora.Rest.Core;
namespace Catalogger.Backend.Cache.InMemoryCache;
public class InMemoryInviteCache : IInviteCache
{
private readonly ConcurrentDictionary<Snowflake, IEnumerable<IInvite>> _invites = new();
public Task<IEnumerable<IInvite>> TryGetAsync(Snowflake guildId) => _invites.TryGetValue(guildId, out var invites)
? Task.FromResult(invites)
: Task.FromResult<IEnumerable<IInvite>>([]);
public Task SetAsync(Snowflake guildId, IEnumerable<IInvite> invites)
{
_invites[guildId] = invites;
return Task.CompletedTask;
}
}

46
Catalogger.Backend/Cache/InMemoryCache/InMemoryMemberCache.cs Normal file
View file

@ -0,0 +1,46 @@
using System.Collections.Concurrent;
using Remora.Discord.API.Abstractions.Objects;
using Remora.Rest.Core;
namespace Catalogger.Backend.Cache.InMemoryCache;
public class InMemoryMemberCache : IMemberCache
{
private readonly ConcurrentDictionary<(Snowflake, Snowflake), IGuildMember> _members = new();
private readonly ConcurrentDictionary<Snowflake, byte> _guilds = new();
#pragma warning disable CS8619 // Nullability of reference types in value doesn't match target type.
public Task<IGuildMember?> TryGetAsync(Snowflake guildId, Snowflake userId) =>
_members.TryGetValue((guildId, userId), out var member)
? Task.FromResult(member)
: Task.FromResult<IGuildMember?>(null);
#pragma warning restore CS8619 // Nullability of reference types in value doesn't match target type.
public Task SetAsync(Snowflake guildId, IGuildMember member)
{
if (!member.User.IsDefined())
throw new CataloggerError("Member with undefined User passed to RedisMemberCache.SetAsync");
_members[(guildId, member.User.Value.ID)] = member;
return Task.CompletedTask;
}
public async Task SetManyAsync(Snowflake guildId, IReadOnlyList<IGuildMember> members)
{
foreach (var member in members)
await SetAsync(guildId, member);
}
public Task<bool> IsGuildCachedAsync(Snowflake guildId) => Task.FromResult(_guilds.ContainsKey(guildId));
public Task MarkAsCachedAsync(Snowflake guildId)
{
_guilds[guildId] = 1;
return Task.CompletedTask;
}
public Task MarkAsUncachedAsync(Snowflake guildId)
{
_guilds.Remove(guildId, out _);
return Task.CompletedTask;
}
}

21
Catalogger.Backend/Cache/InMemoryCache/InMemoryWebhookCache.cs Normal file
View file

@ -0,0 +1,21 @@
using System.Collections.Concurrent;
namespace Catalogger.Backend.Cache.InMemoryCache;
public class InMemoryWebhookCache : IWebhookCache
{
private readonly ConcurrentDictionary<ulong, Webhook> _cache = new();
public Task<Webhook?> GetWebhookAsync(ulong channelId)
{
return _cache.TryGetValue(channelId, out var webhook)
? Task.FromResult<Webhook?>(webhook)
: Task.FromResult<Webhook?>(null);
}
public Task SetWebhookAsync(ulong channelId, Webhook webhook)
{
_cache[channelId] = webhook;
return Task.CompletedTask;
}
}

4
Catalogger.Backend/Cache/RoleCacheService.cs → Catalogger.Backend/Cache/InMemoryCache/RoleCache.cs
View file

@ -3,9 +3,9 @@ using System.Diagnostics.CodeAnalysis;
using Remora.Discord.API.Abstractions.Objects;
using Remora.Rest.Core;
namespace Catalogger.Backend.Cache;
namespace Catalogger.Backend.Cache.InMemoryCache;
public class RoleCacheService
public class RoleCache
{
private readonly ConcurrentDictionary<Snowflake, IRole> _roles = new();
private readonly ConcurrentDictionary<Snowflake, HashSet<Snowflake>> _guildRoles = new();

4
Catalogger.Backend/Cache/UserCacheService.cs → Catalogger.Backend/Cache/InMemoryCache/UserCache.cs
View file

@ -3,9 +3,9 @@ using Remora.Discord.API.Abstractions.Objects;
using Remora.Discord.API.Abstractions.Rest;
using Remora.Rest.Core;
namespace Catalogger.Backend.Cache;
namespace Catalogger.Backend.Cache.InMemoryCache;
public class UserCacheService(IDiscordRestUserAPI userApi)
public class UserCache(IDiscordRestUserAPI userApi)
{
private readonly ConcurrentDictionary<Snowflake, IUser> _cache = new();

53
Catalogger.Backend/Cache/RedisCache/RedisInviteCache.cs Normal file
View file

@ -0,0 +1,53 @@
using Catalogger.Backend.Database.Redis;
using Remora.Discord.API;
using Remora.Discord.API.Abstractions.Objects;
using Remora.Discord.API.Objects;
using Remora.Rest.Core;
namespace Catalogger.Backend.Cache.RedisCache;
public class RedisInviteCache(RedisService redisService) : IInviteCache
{
public async Task<IEnumerable<IInvite>> TryGetAsync(Snowflake guildId)
{
var redisInvites = await redisService.GetAsync<List<RedisInvite>>(InvitesKey(guildId)) ?? [];
return redisInvites.Select(r => r.ToRemoraInvite());
}
public async Task SetAsync(Snowflake guildId, IEnumerable<IInvite> invites) =>
await redisService.SetAsync(InvitesKey(guildId), invites.Select(RedisInvite.FromIInvite));
private static string InvitesKey(Snowflake guildId) => $"guild-invites:{guildId}";
}
internal record RedisInvite(
string Code,
RedisPartialGuild? Guild,
RedisPartialChannel? Channel,
RedisUser? Inviter,
DateTimeOffset? ExpiresAt)
{
public static RedisInvite FromIInvite(IInvite invite) => new(invite.Code,
invite.Guild.Map(RedisPartialGuild.FromIPartialGuild).OrDefault(),
invite.Channel != null ? RedisPartialChannel.FromIPartialChannel(invite.Channel) : null,
invite.Inviter.Map(RedisUser.FromIUser).OrDefault(), invite.ExpiresAt.OrDefault());
public Invite ToRemoraInvite() => new(Code, Guild?.ToRemoraPartialGuild() ?? new Optional<IPartialGuild>(),
Channel?.ToRemoraPartialChannel(), Inviter?.ToRemoraUser() ?? new Optional<IUser>(), ExpiresAt: ExpiresAt);
}
internal record RedisPartialGuild(ulong Id, string? Name)
{
public static RedisPartialGuild FromIPartialGuild(IPartialGuild guild) =>
new(guild.ID.Value.Value, guild.Name.OrDefault(null));
public PartialGuild ToRemoraPartialGuild() => new(DiscordSnowflake.New(Id), Name ?? new Optional<string>());
}
internal record RedisPartialChannel(ulong Id, string? Name)
{
public static RedisPartialChannel FromIPartialChannel(IPartialChannel channel) =>
new(channel.ID.Value.Value, channel.Name.OrDefault(null));
public PartialChannel ToRemoraPartialChannel() => new(DiscordSnowflake.New(Id), Name: Name);
}

85
Catalogger.Backend/Cache/RedisCache/RedisMemberCache.cs Normal file
View file

@ -0,0 +1,85 @@
using Catalogger.Backend.Database.Redis;
using Remora.Discord.API;
using Remora.Discord.API.Abstractions.Objects;
using Remora.Discord.API.Objects;
using Remora.Rest.Core;
namespace Catalogger.Backend.Cache.RedisCache;
public class RedisMemberCache(RedisService redisService) : IMemberCache
{
public async Task<IGuildMember?> TryGetAsync(Snowflake guildId, Snowflake userId)
{
var redisMember = await redisService.GetHashAsync<RedisMember>(GuildMembersKey(guildId), userId.ToString());
return redisMember?.ToRemoraMember();
}
public async Task SetAsync(Snowflake guildId, IGuildMember member)
{
if (!member.User.IsDefined())
throw new CataloggerError("Member with undefined User passed to RedisMemberCache.SetAsync");
await redisService.SetHashAsync(GuildMembersKey(guildId), member.User.Value.ID.ToString(),
RedisMember.FromIGuildMember(member));
}
public async Task SetManyAsync(Snowflake guildId, IReadOnlyList<IGuildMember> members)
{
if (members.Any(m => !m.User.IsDefined()))
throw new CataloggerError("Member with undefined User passed to RedisMemberCache.SetAsync");
var redisMembers = members.Select(RedisMember.FromIGuildMember).ToList();
await redisService.SetHashAsync(GuildMembersKey(guildId), redisMembers, m => m.User.Id.ToString());
}
public async Task<bool> IsGuildCachedAsync(Snowflake guildId) =>
await redisService.GetDatabase().SetContainsAsync(GuildCacheKey, guildId.ToString());
public async Task MarkAsCachedAsync(Snowflake guildId) =>
await redisService.GetDatabase().SetAddAsync(GuildCacheKey, guildId.ToString());
public async Task MarkAsUncachedAsync(Snowflake guildId) =>
await redisService.GetDatabase().SetRemoveAsync(GuildCacheKey, guildId.ToString());
private const string GuildCacheKey = "cached-guilds";
private static string GuildMembersKey(Snowflake guildId) => $"guild-members:{guildId}";
}
internal record RedisMember(
RedisUser User,
string? Nickname,
string? Avatar,
Snowflake[] Roles,
DateTimeOffset JoinedAt,
DateTimeOffset? PremiumSince,
GuildMemberFlags Flags,
bool? IsPending,
DateTimeOffset? CommunicationDisabledUntil)
{
public static RedisMember FromIGuildMember(IGuildMember member) => new(
RedisUser.FromIUser(member.User.Value), member.Nickname.OrDefault(null), member.Avatar.OrDefault(null)?.Value,
member.Roles.ToArray(), member.JoinedAt, member.PremiumSince.OrDefault(null), member.Flags,
member.IsPending.OrDefault(null), member.CommunicationDisabledUntil.OrDefault(null));
public GuildMember ToRemoraMember() => new(User.ToRemoraUser(), Nickname,
Avatar != null ? new ImageHash(Avatar) : null, Roles, JoinedAt, PremiumSince, false, false, Flags,
IsPending, default, CommunicationDisabledUntil);
}
internal record RedisUser(
ulong Id,
string Username,
ushort Discriminator,
string? GlobalName,
string? Avatar,
bool IsBot,
bool IsSystem,
string? Banner)
{
public static RedisUser FromIUser(IUser user) => new(user.ID.Value, user.Username, user.Discriminator,
user.GlobalName.OrDefault(null), user.Avatar?.Value, user.IsBot.OrDefault(false),
user.IsSystem.OrDefault(false), user.Banner.OrDefault(null)?.Value);
public User ToRemoraUser() => new(DiscordSnowflake.New(Id), Username, Discriminator, GlobalName,
Avatar != null ? new ImageHash(Avatar) : null, IsBot, IsSystem,
Banner: Banner != null ? new ImageHash(Banner) : null);
}

15
Catalogger.Backend/Cache/RedisCache/RedisWebhookCache.cs Normal file
View file

@ -0,0 +1,15 @@
using Catalogger.Backend.Database.Redis;
using Humanizer;
namespace Catalogger.Backend.Cache.RedisCache;
public class RedisWebhookCache(RedisService redisService) : IWebhookCache
{
public async Task<Webhook?> GetWebhookAsync(ulong channelId) =>
await redisService.GetAsync<Webhook?>(WebhookKey(channelId));
public async Task SetWebhookAsync(ulong channelId, Webhook webhook) =>
await redisService.SetAsync(WebhookKey(channelId), webhook, 24.Hours());
private static string WebhookKey(ulong channelId) => $"webhook:{channelId}";
}