friendlynamazu/server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

adaptations to cache service, move dbcontext to factory and use lazy

Browse Source
This commit is contained in:
rootdarkarchon
2023-11-04 12:10:08 +01:00
parent 192ddfb188
commit 9590722749
8 changed files with 288 additions and 310 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
MareSynchronosServer/MareSynchronosServer/Hubs/MareHub.Functions.cs
View File

@@ -19,33 +19,33 @@ public partial class MareHub
private async Task DeleteUser(User user)
{
var ownPairData = await _dbContext.ClientPairs.Where(u => u.User.UID == user.UID).ToListAsync().ConfigureAwait(false);
var auth = await _dbContext.Auth.SingleAsync(u => u.UserUID == user.UID).ConfigureAwait(false);
var lodestone = await _dbContext.LodeStoneAuth.SingleOrDefaultAsync(a => a.User.UID == user.UID).ConfigureAwait(false);
var groupPairs = await _dbContext.GroupPairs.Where(g => g.GroupUserUID == user.UID).ToListAsync().ConfigureAwait(false);
var userProfileData = await _dbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == user.UID).ConfigureAwait(false);
var defaultpermissions = await _dbContext.UserDefaultPreferredPermissions.SingleOrDefaultAsync(u => u.UserUID == user.UID).ConfigureAwait(false);
var groupPermissions = await _dbContext.GroupPairPreferredPermissions.Where(u => u.UserUID == user.UID).ToListAsync().ConfigureAwait(false);
var individualPermissions = await _dbContext.Permissions.Where(u => u.UserUID == user.UID || u.OtherUserUID == user.UID).ToListAsync().ConfigureAwait(false);
var bannedEntries = await _dbContext.GroupBans.Where(u => u.BannedUserUID == user.UID).ToListAsync().ConfigureAwait(false);
var ownPairData = await DbContext.ClientPairs.Where(u => u.User.UID == user.UID).ToListAsync().ConfigureAwait(false);
var auth = await DbContext.Auth.SingleAsync(u => u.UserUID == user.UID).ConfigureAwait(false);
var lodestone = await DbContext.LodeStoneAuth.SingleOrDefaultAsync(a => a.User.UID == user.UID).ConfigureAwait(false);
var groupPairs = await DbContext.GroupPairs.Where(g => g.GroupUserUID == user.UID).ToListAsync().ConfigureAwait(false);
var userProfileData = await DbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == user.UID).ConfigureAwait(false);
var defaultpermissions = await DbContext.UserDefaultPreferredPermissions.SingleOrDefaultAsync(u => u.UserUID == user.UID).ConfigureAwait(false);
var groupPermissions = await DbContext.GroupPairPreferredPermissions.Where(u => u.UserUID == user.UID).ToListAsync().ConfigureAwait(false);
var individualPermissions = await DbContext.Permissions.Where(u => u.UserUID == user.UID || u.OtherUserUID == user.UID).ToListAsync().ConfigureAwait(false);
var bannedEntries = await DbContext.GroupBans.Where(u => u.BannedUserUID == user.UID).ToListAsync().ConfigureAwait(false);
if (lodestone != null)
{
_dbContext.Remove(lodestone);
DbContext.Remove(lodestone);
}
if (userProfileData != null)
{
_dbContext.Remove(userProfileData);
DbContext.Remove(userProfileData);
}
while (_dbContext.Files.Any(f => f.Uploader == user))
while (DbContext.Files.Any(f => f.Uploader == user))
{
await Task.Delay(1000).ConfigureAwait(false);
}
_dbContext.ClientPairs.RemoveRange(ownPairData);
var otherPairData = await _dbContext.ClientPairs.Include(u => u.User)
DbContext.ClientPairs.RemoveRange(ownPairData);
var otherPairData = await DbContext.ClientPairs.Include(u => u.User)
.Where(u => u.OtherUser.UID == user.UID).AsNoTracking().ToListAsync().ConfigureAwait(false);
foreach (var pair in otherPairData)
{
@@ -59,18 +59,18 @@ public partial class MareHub
if (defaultpermissions != null)
{
_dbContext.UserDefaultPreferredPermissions.Remove(defaultpermissions);
DbContext.UserDefaultPreferredPermissions.Remove(defaultpermissions);
}
_dbContext.GroupPairPreferredPermissions.RemoveRange(groupPermissions);
_dbContext.Permissions.RemoveRange(individualPermissions);
_dbContext.GroupBans.RemoveRange(bannedEntries);
DbContext.GroupPairPreferredPermissions.RemoveRange(groupPermissions);
DbContext.Permissions.RemoveRange(individualPermissions);
DbContext.GroupBans.RemoveRange(bannedEntries);
_mareMetrics.IncCounter(MetricsAPI.CounterUsersRegisteredDeleted, 1);
_dbContext.ClientPairs.RemoveRange(otherPairData);
_dbContext.Users.Remove(user);
_dbContext.Auth.Remove(auth);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
DbContext.ClientPairs.RemoveRange(otherPairData);
DbContext.Users.Remove(user);
DbContext.Auth.Remove(auth);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
}
private async Task<List<string>> GetAllPairedUnpausedUsers(string? uid = null)
@@ -114,7 +114,7 @@ public partial class MareHub
private async Task<List<string>> SendOfflineToAllPairedUsers()
{
var usersToSendDataTo = await GetAllPairedUnpausedUsers().ConfigureAwait(false);
var self = await _dbContext.Users.AsNoTracking().SingleAsync(u => u.UID == UserUID).ConfigureAwait(false);
var self = await DbContext.Users.AsNoTracking().SingleAsync(u => u.UID == UserUID).ConfigureAwait(false);
await Clients.Users(usersToSendDataTo).Client_UserSendOffline(new(self.ToUserData())).ConfigureAwait(false);
return usersToSendDataTo;
@@ -123,7 +123,7 @@ public partial class MareHub
private async Task<List<string>> SendOnlineToAllPairedUsers()
{
var usersToSendDataTo = await GetAllPairedUnpausedUsers().ConfigureAwait(false);
var self = await _dbContext.Users.AsNoTracking().SingleAsync(u => u.UID == UserUID).ConfigureAwait(false);
var self = await DbContext.Users.AsNoTracking().SingleAsync(u => u.UID == UserUID).ConfigureAwait(false);
await Clients.Users(usersToSendDataTo).Client_UserSendOnline(new(self.ToUserData(), UserCharaIdent)).ConfigureAwait(false);
return usersToSendDataTo;
@@ -136,7 +136,7 @@ public partial class MareHub
if (isOwnerResult.ReferredGroup == null) return (false, null);
var groupPairSelf = await _dbContext.GroupPairs.SingleOrDefaultAsync(g => g.GroupGID == gid && g.GroupUserUID == UserUID).ConfigureAwait(false);
var groupPairSelf = await DbContext.GroupPairs.SingleOrDefaultAsync(g => g.GroupGID == gid && g.GroupUserUID == UserUID).ConfigureAwait(false);
if (groupPairSelf == null || !groupPairSelf.IsModerator) return (false, null);
return (true, isOwnerResult.ReferredGroup);
@@ -144,7 +144,7 @@ public partial class MareHub
private async Task<(bool isValid, Group ReferredGroup)> TryValidateOwner(string gid)
{
var group = await _dbContext.Groups.SingleOrDefaultAsync(g => g.GID == gid).ConfigureAwait(false);
var group = await DbContext.Groups.SingleOrDefaultAsync(g => g.GID == gid).ConfigureAwait(false);
if (group == null) return (false, null);
return (string.Equals(group.OwnerUID, UserUID, StringComparison.Ordinal), group);
@@ -154,7 +154,7 @@ public partial class MareHub
{
uid ??= UserUID;
var groupPair = await _dbContext.GroupPairs.Include(c => c.GroupUser)
var groupPair = await DbContext.GroupPairs.Include(c => c.GroupUser)
.SingleOrDefaultAsync(g => g.GroupGID == gid && (g.GroupUserUID == uid || g.GroupUser.Alias == uid)).ConfigureAwait(false);
if (groupPair == null) return (false, null);
@@ -188,13 +188,13 @@ public partial class MareHub
var (exists, groupPair) = await TryValidateUserInGroup(dto.Group.GID, userUid).ConfigureAwait(false);
if (!exists) return;
var group = await _dbContext.Groups.SingleOrDefaultAsync(g => g.GID == dto.Group.GID).ConfigureAwait(false);
var group = await DbContext.Groups.SingleOrDefaultAsync(g => g.GID == dto.Group.GID).ConfigureAwait(false);
var groupPairs = await _dbContext.GroupPairs.Where(p => p.GroupGID == group.GID).ToListAsync().ConfigureAwait(false);
var groupPairs = await DbContext.GroupPairs.Where(p => p.GroupGID == group.GID).ToListAsync().ConfigureAwait(false);
var groupPairsWithoutSelf = groupPairs.Where(p => !string.Equals(p.GroupUserUID, userUid, StringComparison.Ordinal)).ToList();
_dbContext.GroupPairs.Remove(groupPair);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
DbContext.GroupPairs.Remove(groupPair);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
await Clients.User(userUid).Client_GroupDelete(new GroupDto(group.ToGroupData())).ConfigureAwait(false);
@@ -205,17 +205,17 @@ public partial class MareHub
{
_logger.LogCallInfo(MareHubLogger.Args(dto, "Deleted"));
_dbContext.Groups.Remove(group);
DbContext.Groups.Remove(group);
}
else
{
var groupHasMigrated = await SharedDbFunctions.MigrateOrDeleteGroup(_dbContext, group, groupPairsWithoutSelf, _maxExistingGroupsByUser).ConfigureAwait(false);
var groupHasMigrated = await SharedDbFunctions.MigrateOrDeleteGroup(DbContext, group, groupPairsWithoutSelf, _maxExistingGroupsByUser).ConfigureAwait(false);
if (groupHasMigrated.Item1)
{
_logger.LogCallInfo(MareHubLogger.Args(dto, "Migrated", groupHasMigrated.Item2));
var user = await _dbContext.Users.SingleAsync(u => u.UID == groupHasMigrated.Item2).ConfigureAwait(false);
var user = await DbContext.Users.SingleAsync(u => u.UID == groupHasMigrated.Item2).ConfigureAwait(false);
await Clients.Users(groupPairsWithoutSelf.Select(p => p.GroupUserUID)).Client_GroupSendInfo(new GroupInfoDto(group.ToGroupData(),
user.ToUserData(), group.ToEnum())).ConfigureAwait(false);
@@ -233,7 +233,7 @@ public partial class MareHub
}
}
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
_logger.LogCallInfo(MareHubLogger.Args(dto, "Success"));
@@ -249,8 +249,8 @@ public partial class MareHub
private async Task<UserInfo?> GetPairInfo(string uid, string otheruid)
{
var clientPairs = from cp in _dbContext.ClientPairs.AsNoTracking().Where(u => u.UserUID == uid && u.OtherUserUID == otheruid)
join cp2 in _dbContext.ClientPairs.AsNoTracking().Where(u => u.OtherUserUID == uid && u.UserUID == otheruid)
var clientPairs = from cp in DbContext.ClientPairs.AsNoTracking().Where(u => u.UserUID == uid && u.OtherUserUID == otheruid)
join cp2 in DbContext.ClientPairs.AsNoTracking().Where(u => u.OtherUserUID == uid && u.UserUID == otheruid)
on new
{
UserUID = cp.UserUID,
@@ -272,8 +272,8 @@ public partial class MareHub
};
var groupPairs = from gp in _dbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID == uid)
join gp2 in _dbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID == otheruid)
var groupPairs = from gp in DbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID == uid)
join gp2 in DbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID == otheruid)
on new
{
GID = gp.GroupGID
@@ -294,13 +294,13 @@ public partial class MareHub
var allPairs = clientPairs.Concat(groupPairs);
var result = from user in allPairs
join u in _dbContext.Users.AsNoTracking() on user.OtherUserUID equals u.UID
join o in _dbContext.Permissions.AsNoTracking().Where(u => u.UserUID == uid)
join u in DbContext.Users.AsNoTracking() on user.OtherUserUID equals u.UID
join o in DbContext.Permissions.AsNoTracking().Where(u => u.UserUID == uid)
on new { UserUID = user.UserUID, OtherUserUID = user.OtherUserUID }
equals new { UserUID = o.UserUID, OtherUserUID = o.OtherUserUID }
into ownperms
from ownperm in ownperms.DefaultIfEmpty()
join p in _dbContext.Permissions.AsNoTracking().Where(u => u.OtherUserUID == uid)
join p in DbContext.Permissions.AsNoTracking().Where(u => u.OtherUserUID == uid)
on new { UserUID = user.OtherUserUID, OtherUserUID = user.UserUID }
equals new { UserUID = p.UserUID, OtherUserUID = p.OtherUserUID }
into otherperms
@@ -335,8 +335,8 @@ public partial class MareHub
private async Task<Dictionary<string, UserInfo>> GetAllPairInfo(string uid)
{
var clientPairs = from cp in _dbContext.ClientPairs.AsNoTracking().Where(u => u.UserUID == uid)
join cp2 in _dbContext.ClientPairs.AsNoTracking().Where(u => u.OtherUserUID == uid)
var clientPairs = from cp in DbContext.ClientPairs.AsNoTracking().Where(u => u.UserUID == uid)
join cp2 in DbContext.ClientPairs.AsNoTracking().Where(u => u.OtherUserUID == uid)
on new
{
UserUID = cp.UserUID,
@@ -358,8 +358,8 @@ public partial class MareHub
};
var groupPairs = from gp in _dbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID == uid)
join gp2 in _dbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID != uid)
var groupPairs = from gp in DbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID == uid)
join gp2 in DbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID != uid)
on new
{
GID = gp.GroupGID
@@ -379,13 +379,13 @@ public partial class MareHub
var allPairs = clientPairs.Concat(groupPairs);
var result = from user in allPairs
join u in _dbContext.Users.AsNoTracking() on user.OtherUserUID equals u.UID
join o in _dbContext.Permissions.AsNoTracking().Where(u => u.UserUID == uid)
join u in DbContext.Users.AsNoTracking() on user.OtherUserUID equals u.UID
join o in DbContext.Permissions.AsNoTracking().Where(u => u.UserUID == uid)
on new { UserUID = user.UserUID, OtherUserUID = user.OtherUserUID }
equals new { UserUID = o.UserUID, OtherUserUID = o.OtherUserUID }
into ownperms
from ownperm in ownperms.DefaultIfEmpty()
join p in _dbContext.Permissions.AsNoTracking().Where(u => u.OtherUserUID == uid)
join p in DbContext.Permissions.AsNoTracking().Where(u => u.OtherUserUID == uid)
on new { UserUID = user.OtherUserUID, OtherUserUID = user.UserUID }
equals new { UserUID = p.UserUID, OtherUserUID = p.OtherUserUID }
into otherperms
@@ -419,8 +419,8 @@ public partial class MareHub
private async Task<List<string>> GetSyncedUnpausedOnlinePairs(string uid)
{
var clientPairs = from cp in _dbContext.ClientPairs.AsNoTracking().Where(u => u.UserUID == uid)
join cp2 in _dbContext.ClientPairs.AsNoTracking().Where(u => u.OtherUserUID == uid)
var clientPairs = from cp in DbContext.ClientPairs.AsNoTracking().Where(u => u.UserUID == uid)
join cp2 in DbContext.ClientPairs.AsNoTracking().Where(u => u.OtherUserUID == uid)
on new
{
UserUID = cp.UserUID,
@@ -440,8 +440,8 @@ public partial class MareHub
};
var groupPairs = from gp in _dbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID == uid)
join gp2 in _dbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID != uid)
var groupPairs = from gp in DbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID == uid)
join gp2 in DbContext.GroupPairs.AsNoTracking().Where(u => u.GroupUserUID != uid)
on new
{
GID = gp.GroupGID
@@ -459,12 +459,12 @@ public partial class MareHub
var allPairs = clientPairs.Concat(groupPairs);
var result = from user in allPairs
join o in _dbContext.Permissions.AsNoTracking().Where(u => u.UserUID == uid)
join o in DbContext.Permissions.AsNoTracking().Where(u => u.UserUID == uid)
on new { UserUID = user.UserUID, OtherUserUID = user.OtherUserUID }
equals new { UserUID = o.UserUID, OtherUserUID = o.OtherUserUID }
into ownperms
from ownperm in ownperms.DefaultIfEmpty()
join p in _dbContext.Permissions.AsNoTracking().Where(u => u.OtherUserUID == uid)
join p in DbContext.Permissions.AsNoTracking().Where(u => u.OtherUserUID == uid)
on new { UserUID = user.OtherUserUID, OtherUserUID = user.UserUID }
equals new { UserUID = p.UserUID, OtherUserUID = p.OtherUserUID }
into otherperms

140
MareSynchronosServer/MareSynchronosServer/Hubs/MareHub.Groups.cs
View File

@@ -36,8 +36,8 @@ public partial class MareHub
GroupGID = dto.Group.GID,
};
_dbContext.Add(ban);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
DbContext.Add(ban);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
await GroupRemoveUser(dto).ConfigureAwait(false);
@@ -57,9 +57,9 @@ public partial class MareHub
group.PreferDisableAnimations = dto.Permissions.HasFlag(GroupPermissions.PreferDisableAnimations);
group.PreferDisableVFX = dto.Permissions.HasFlag(GroupPermissions.PreferDisableVFX);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
var groupPairs = _dbContext.GroupPairs.Where(p => p.GroupGID == dto.Group.GID).Select(p => p.GroupUserUID).ToList();
var groupPairs = DbContext.GroupPairs.Where(p => p.GroupGID == dto.Group.GID).Select(p => p.GroupUserUID).ToList();
await Clients.Users(groupPairs).Client_GroupChangePermissions(new GroupPermissionDto(dto.Group, dto.Permissions)).ConfigureAwait(false);
}
@@ -74,20 +74,20 @@ public partial class MareHub
var (isInGroup, newOwnerPair) = await TryValidateUserInGroup(dto.Group.GID, dto.User.UID).ConfigureAwait(false);
if (!isInGroup) return;
var ownedShells = await _dbContext.Groups.CountAsync(g => g.OwnerUID == dto.User.UID).ConfigureAwait(false);
var ownedShells = await DbContext.Groups.CountAsync(g => g.OwnerUID == dto.User.UID).ConfigureAwait(false);
if (ownedShells >= _maxExistingGroupsByUser) return;
var prevOwner = await _dbContext.GroupPairs.SingleOrDefaultAsync(g => g.GroupGID == dto.Group.GID && g.GroupUserUID == UserUID).ConfigureAwait(false);
var prevOwner = await DbContext.GroupPairs.SingleOrDefaultAsync(g => g.GroupGID == dto.Group.GID && g.GroupUserUID == UserUID).ConfigureAwait(false);
prevOwner.IsPinned = false;
group.Owner = newOwnerPair.GroupUser;
group.Alias = null;
newOwnerPair.IsPinned = true;
newOwnerPair.IsModerator = false;
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
_logger.LogCallInfo(MareHubLogger.Args(dto, "Success"));
var groupPairs = await _dbContext.GroupPairs.Where(p => p.GroupGID == dto.Group.GID).Select(p => p.GroupUserUID).AsNoTracking().ToListAsync().ConfigureAwait(false);
var groupPairs = await DbContext.GroupPairs.Where(p => p.GroupGID == dto.Group.GID).Select(p => p.GroupUserUID).AsNoTracking().ToListAsync().ConfigureAwait(false);
await Clients.Users(groupPairs).Client_GroupSendInfo(new GroupInfoDto(group.ToGroupData(), newOwnerPair.GroupUser.ToUserData(), group.ToEnum())).ConfigureAwait(false);
}
@@ -103,7 +103,7 @@ public partial class MareHub
_logger.LogCallInfo(MareHubLogger.Args(dto, "Success"));
group.HashedPassword = StringUtils.Sha256String(dto.Password);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
return true;
}
@@ -116,7 +116,7 @@ public partial class MareHub
var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
if (!hasRights) return;
var groupPairs = await _dbContext.GroupPairs.Include(p => p.GroupUser).Where(p => p.GroupGID == dto.Group.GID).ToListAsync().ConfigureAwait(false);
var groupPairs = await DbContext.GroupPairs.Include(p => p.GroupUser).Where(p => p.GroupGID == dto.Group.GID).ToListAsync().ConfigureAwait(false);
await Clients.Users(groupPairs.Where(p => !p.IsPinned && !p.IsModerator).Select(g => g.GroupUserUID)).Client_GroupDelete(new GroupDto(group.ToGroupData())).ConfigureAwait(false);
@@ -124,7 +124,7 @@ public partial class MareHub
var notPinned = groupPairs.Where(g => !g.IsPinned && !g.IsModerator).ToList();
_dbContext.GroupPairs.RemoveRange(notPinned);
DbContext.GroupPairs.RemoveRange(notPinned);
foreach (var pair in notPinned)
{
@@ -140,22 +140,22 @@ public partial class MareHub
}
}
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
}
[Authorize(Policy = "Identified")]
public async Task<GroupJoinDto> GroupCreate()
{
_logger.LogCallInfo();
var existingGroupsByUser = await _dbContext.Groups.CountAsync(u => u.OwnerUID == UserUID).ConfigureAwait(false);
var existingJoinedGroups = await _dbContext.GroupPairs.CountAsync(u => u.GroupUserUID == UserUID).ConfigureAwait(false);
var existingGroupsByUser = await DbContext.Groups.CountAsync(u => u.OwnerUID == UserUID).ConfigureAwait(false);
var existingJoinedGroups = await DbContext.GroupPairs.CountAsync(u => u.GroupUserUID == UserUID).ConfigureAwait(false);
if (existingGroupsByUser >= _maxExistingGroupsByUser || existingJoinedGroups >= _maxJoinedGroupsByUser)
{
throw new System.Exception($"Max groups for user is {_maxExistingGroupsByUser}, max joined groups is {_maxJoinedGroupsByUser}.");
}
var gid = StringUtils.GenerateRandomString(12);
while (await _dbContext.Groups.AnyAsync(g => g.GID == "MSS-" + gid).ConfigureAwait(false))
while (await DbContext.Groups.AnyAsync(g => g.GID == "MSS-" + gid).ConfigureAwait(false))
{
gid = StringUtils.GenerateRandomString(12);
}
@@ -165,7 +165,7 @@ public partial class MareHub
using var sha = SHA256.Create();
var hashedPw = StringUtils.Sha256String(passwd);
UserDefaultPreferredPermission defaultPermissions = await _dbContext.UserDefaultPreferredPermissions.SingleAsync(u => u.UserUID == UserUID).ConfigureAwait(false);
UserDefaultPreferredPermission defaultPermissions = await DbContext.UserDefaultPreferredPermissions.SingleAsync(u => u.UserUID == UserUID).ConfigureAwait(false);
Group newGroup = new()
{
@@ -194,12 +194,12 @@ public partial class MareHub
DisableVFX = defaultPermissions.DisableGroupAnimations
};
await _dbContext.Groups.AddAsync(newGroup).ConfigureAwait(false);
await _dbContext.GroupPairs.AddAsync(initialPair).ConfigureAwait(false);
await _dbContext.GroupPairPreferredPermissions.AddAsync(initialPrefPermissions).ConfigureAwait(false);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.Groups.AddAsync(newGroup).ConfigureAwait(false);
await DbContext.GroupPairs.AddAsync(initialPair).ConfigureAwait(false);
await DbContext.GroupPairPreferredPermissions.AddAsync(initialPrefPermissions).ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
var self = await _dbContext.Users.SingleAsync(u => u.UID == UserUID).ConfigureAwait(false);
var self = await DbContext.Users.SingleAsync(u => u.UID == UserUID).ConfigureAwait(false);
await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(newGroup.ToGroupData(), self.ToUserData(),
newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal)))
@@ -219,7 +219,7 @@ public partial class MareHub
var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
if (!hasRights) return new();
var existingInvites = await _dbContext.GroupTempInvites.Where(g => g.GroupGID == group.GID).ToListAsync().ConfigureAwait(false);
var existingInvites = await DbContext.GroupTempInvites.Where(g => g.GroupGID == group.GID).ToListAsync().ConfigureAwait(false);
for (int i = 0; i < amount; i++)
{
@@ -243,8 +243,8 @@ public partial class MareHub
});
}
_dbContext.GroupTempInvites.AddRange(tempInvites);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
DbContext.GroupTempInvites.AddRange(tempInvites);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
return inviteCodes;
}
@@ -258,10 +258,10 @@ public partial class MareHub
_logger.LogCallInfo(MareHubLogger.Args(dto, "Success"));
var groupPairs = await _dbContext.GroupPairs.Where(p => p.GroupGID == dto.Group.GID).ToListAsync().ConfigureAwait(false);
_dbContext.RemoveRange(groupPairs);
_dbContext.Remove(group);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
var groupPairs = await DbContext.GroupPairs.Where(p => p.GroupGID == dto.Group.GID).ToListAsync().ConfigureAwait(false);
DbContext.RemoveRange(groupPairs);
DbContext.Remove(group);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
await Clients.Users(groupPairs.Select(g => g.GroupUserUID)).Client_GroupDelete(new GroupDto(group.ToGroupData())).ConfigureAwait(false);
@@ -276,7 +276,7 @@ public partial class MareHub
var (userHasRights, group) = await TryValidateGroupModeratorOrOwner(dto.GID).ConfigureAwait(false);
if (!userHasRights) return new List<BannedGroupUserDto>();
var banEntries = await _dbContext.GroupBans.Include(b => b.BannedUser).Where(g => g.GroupGID == dto.Group.GID).AsNoTracking().ToListAsync().ConfigureAwait(false);
var banEntries = await DbContext.GroupBans.Include(b => b.BannedUser).Where(g => g.GroupGID == dto.Group.GID).AsNoTracking().ToListAsync().ConfigureAwait(false);
List<BannedGroupUserDto> bannedGroupUsers = banEntries.Select(b =>
new BannedGroupUserDto(group.ToGroupData(), b.BannedUser.ToUserData(), b.BannedReason, b.BannedOn,
@@ -294,14 +294,14 @@ public partial class MareHub
_logger.LogCallInfo(MareHubLogger.Args(dto));
var group = await _dbContext.Groups.Include(g => g.Owner).AsNoTracking().SingleOrDefaultAsync(g => g.GID == aliasOrGid || g.Alias == aliasOrGid).ConfigureAwait(false);
var group = await DbContext.Groups.Include(g => g.Owner).AsNoTracking().SingleOrDefaultAsync(g => g.GID == aliasOrGid || g.Alias == aliasOrGid).ConfigureAwait(false);
var groupGid = group?.GID ?? string.Empty;
var existingPair = await _dbContext.GroupPairs.AsNoTracking().SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.GroupUserUID == UserUID).ConfigureAwait(false);
var existingPair = await DbContext.GroupPairs.AsNoTracking().SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.GroupUserUID == UserUID).ConfigureAwait(false);
var hashedPw = StringUtils.Sha256String(dto.Password);
var existingUserCount = await _dbContext.GroupPairs.AsNoTracking().CountAsync(g => g.GroupGID == groupGid).ConfigureAwait(false);
var joinedGroups = await _dbContext.GroupPairs.CountAsync(g => g.GroupUserUID == UserUID).ConfigureAwait(false);
var isBanned = await _dbContext.GroupBans.AnyAsync(g => g.GroupGID == groupGid && g.BannedUserUID == UserUID).ConfigureAwait(false);
var oneTimeInvite = await _dbContext.GroupTempInvites.SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.Invite == hashedPw).ConfigureAwait(false);
var existingUserCount = await DbContext.GroupPairs.AsNoTracking().CountAsync(g => g.GroupGID == groupGid).ConfigureAwait(false);
var joinedGroups = await DbContext.GroupPairs.CountAsync(g => g.GroupUserUID == UserUID).ConfigureAwait(false);
var isBanned = await DbContext.GroupBans.AnyAsync(g => g.GroupGID == groupGid && g.BannedUserUID == UserUID).ConfigureAwait(false);
var oneTimeInvite = await DbContext.GroupTempInvites.SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.Invite == hashedPw).ConfigureAwait(false);
if (group == null
|| (!string.Equals(group.HashedPassword, hashedPw, StringComparison.Ordinal) && oneTimeInvite == null)
@@ -322,14 +322,14 @@ public partial class MareHub
_logger.LogCallInfo(MareHubLogger.Args(dto));
var group = await _dbContext.Groups.Include(g => g.Owner).AsNoTracking().SingleOrDefaultAsync(g => g.GID == aliasOrGid || g.Alias == aliasOrGid).ConfigureAwait(false);
var group = await DbContext.Groups.Include(g => g.Owner).AsNoTracking().SingleOrDefaultAsync(g => g.GID == aliasOrGid || g.Alias == aliasOrGid).ConfigureAwait(false);
var groupGid = group?.GID ?? string.Empty;
var existingPair = await _dbContext.GroupPairs.AsNoTracking().SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.GroupUserUID == UserUID).ConfigureAwait(false);
var existingPair = await DbContext.GroupPairs.AsNoTracking().SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.GroupUserUID == UserUID).ConfigureAwait(false);
var hashedPw = StringUtils.Sha256String(dto.Password);
var existingUserCount = await _dbContext.GroupPairs.AsNoTracking().CountAsync(g => g.GroupGID == groupGid).ConfigureAwait(false);
var joinedGroups = await _dbContext.GroupPairs.CountAsync(g => g.GroupUserUID == UserUID).ConfigureAwait(false);
var isBanned = await _dbContext.GroupBans.AnyAsync(g => g.GroupGID == groupGid && g.BannedUserUID == UserUID).ConfigureAwait(false);
var oneTimeInvite = await _dbContext.GroupTempInvites.SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.Invite == hashedPw).ConfigureAwait(false);
var existingUserCount = await DbContext.GroupPairs.AsNoTracking().CountAsync(g => g.GroupGID == groupGid).ConfigureAwait(false);
var joinedGroups = await DbContext.GroupPairs.CountAsync(g => g.GroupUserUID == UserUID).ConfigureAwait(false);
var isBanned = await DbContext.GroupBans.AnyAsync(g => g.GroupGID == groupGid && g.BannedUserUID == UserUID).ConfigureAwait(false);
var oneTimeInvite = await DbContext.GroupTempInvites.SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.Invite == hashedPw).ConfigureAwait(false);
if (group == null
|| (!string.Equals(group.HashedPassword, hashedPw, StringComparison.Ordinal) && oneTimeInvite == null)
@@ -346,7 +346,7 @@ public partial class MareHub
if (oneTimeInvite != null)
{
_logger.LogCallInfo(MareHubLogger.Args(aliasOrGid, "TempInvite", oneTimeInvite.Invite));
_dbContext.Remove(oneTimeInvite);
DbContext.Remove(oneTimeInvite);
}
GroupPair newPair = new()
@@ -355,7 +355,7 @@ public partial class MareHub
GroupUserUID = UserUID,
};
var preferredPermissions = await _dbContext.GroupPairPreferredPermissions.SingleOrDefaultAsync(u => u.UserUID == UserUID && u.GroupGID == group.GID).ConfigureAwait(false);
var preferredPermissions = await DbContext.GroupPairPreferredPermissions.SingleOrDefaultAsync(u => u.UserUID == UserUID && u.GroupGID == group.GID).ConfigureAwait(false);
if (preferredPermissions == null)
{
GroupPairPreferredPermission newPerms = new()
@@ -368,7 +368,7 @@ public partial class MareHub
IsPaused = false
};
_dbContext.Add(newPerms);
DbContext.Add(newPerms);
preferredPermissions = newPerms;
}
else
@@ -377,21 +377,21 @@ public partial class MareHub
preferredPermissions.DisableVFX = dto.GroupUserPreferredPermissions.IsDisableVFX();
preferredPermissions.DisableAnimations = dto.GroupUserPreferredPermissions.IsDisableAnimations();
preferredPermissions.IsPaused = false;
_dbContext.Update(preferredPermissions);
DbContext.Update(preferredPermissions);
}
await _dbContext.GroupPairs.AddAsync(newPair).ConfigureAwait(false);
await DbContext.GroupPairs.AddAsync(newPair).ConfigureAwait(false);
_logger.LogCallInfo(MareHubLogger.Args(aliasOrGid, "Success"));
var groupInfos = await _dbContext.GroupPairs.Where(u => u.GroupGID == group.GID && (u.IsPinned || u.IsModerator)).ToListAsync().ConfigureAwait(false);
var groupInfos = await DbContext.GroupPairs.Where(u => u.GroupGID == group.GID && (u.IsPinned || u.IsModerator)).ToListAsync().ConfigureAwait(false);
await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(group.ToGroupData(), group.Owner.ToUserData(),
group.ToEnum(), preferredPermissions.ToEnum(), newPair.ToEnum(),
groupInfos.ToDictionary(u => u.GroupUserUID, u => u.ToEnum(), StringComparer.Ordinal))).ConfigureAwait(false);
var self = _dbContext.Users.Single(u => u.UID == UserUID);
var self = DbContext.Users.Single(u => u.UID == UserUID);
var groupPairs = await _dbContext.GroupPairs.Include(p => p.GroupUser)
var groupPairs = await DbContext.GroupPairs.Include(p => p.GroupUser)
.Where(p => p.GroupGID == group.GID && p.GroupUserUID != UserUID).ToListAsync().ConfigureAwait(false);
var userPairsAfterJoin = await GetAllPairInfo(UserUID).ConfigureAwait(false);
@@ -403,7 +403,7 @@ public partial class MareHub
var ownPermissionsToOther = userinfo?.OwnPermissions ?? null;
if (ownPermissionsToOther == null)
{
var existingPermissionsOnDb = await _dbContext.Permissions.SingleOrDefaultAsync(p => p.UserUID == UserUID && p.OtherUserUID == pair.GroupUserUID).ConfigureAwait(false);
var existingPermissionsOnDb = await DbContext.Permissions.SingleOrDefaultAsync(p => p.UserUID == UserUID && p.OtherUserUID == pair.GroupUserUID).ConfigureAwait(false);
if (existingPermissionsOnDb == null)
{
@@ -418,7 +418,7 @@ public partial class MareHub
Sticky = false
};
await _dbContext.Permissions.AddAsync(ownPermissionsToOther).ConfigureAwait(false);
await DbContext.Permissions.AddAsync(ownPermissionsToOther).ConfigureAwait(false);
}
else
{
@@ -428,7 +428,7 @@ public partial class MareHub
existingPermissionsOnDb.IsPaused = false;
existingPermissionsOnDb.Sticky = false;
_dbContext.Update(existingPermissionsOnDb);
DbContext.Update(existingPermissionsOnDb);
ownPermissionsToOther = existingPermissionsOnDb;
}
@@ -436,7 +436,7 @@ public partial class MareHub
}
else if (!ownPermissionsToOther.Sticky)
{
ownPermissionsToOther = await _dbContext.Permissions.SingleAsync(u => u.UserUID == UserUID && u.OtherUserUID == pair.GroupUserUID).ConfigureAwait(false);
ownPermissionsToOther = await DbContext.Permissions.SingleAsync(u => u.UserUID == UserUID && u.OtherUserUID == pair.GroupUserUID).ConfigureAwait(false);
// update the existing permission only if it was not set to sticky
ownPermissionsToOther.DisableAnimations = preferredPermissions.DisableAnimations;
@@ -444,18 +444,18 @@ public partial class MareHub
ownPermissionsToOther.DisableSounds = preferredPermissions.DisableSounds;
ownPermissionsToOther.IsPaused = false;
_dbContext.Update(ownPermissionsToOther);
DbContext.Update(ownPermissionsToOther);
}
// get others permissionset to self and eventually update it
var otherPermissionToSelf = userinfo?.OtherPermissions ?? null;
if (otherPermissionToSelf == null)
{
var existingPermissionsOnDb = await _dbContext.Permissions.SingleOrDefaultAsync(p => p.UserUID == pair.GroupUserUID && p.OtherUserUID == UserUID).ConfigureAwait(false);
var existingPermissionsOnDb = await DbContext.Permissions.SingleOrDefaultAsync(p => p.UserUID == pair.GroupUserUID && p.OtherUserUID == UserUID).ConfigureAwait(false);
if (existingPermissionsOnDb == null)
{
var otherPreferred = await _dbContext.GroupPairPreferredPermissions.SingleAsync(u => u.GroupGID == group.GID && u.UserUID == pair.GroupUserUID).ConfigureAwait(false);
var otherPreferred = await DbContext.GroupPairPreferredPermissions.SingleAsync(u => u.GroupGID == group.GID && u.UserUID == pair.GroupUserUID).ConfigureAwait(false);
existingPermissionsOnDb = new()
{
UserUID = pair.GroupUserUID,
@@ -467,7 +467,7 @@ public partial class MareHub
Sticky = false
};
await _dbContext.AddAsync(existingPermissionsOnDb).ConfigureAwait(false);
await DbContext.AddAsync(existingPermissionsOnDb).ConfigureAwait(false);
}
otherPermissionToSelf = existingPermissionsOnDb;
@@ -493,7 +493,7 @@ public partial class MareHub
}
}
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
return true;
}
@@ -518,17 +518,17 @@ public partial class MareHub
if (groupPair.IsModerator || string.Equals(group.OwnerUID, dto.User.UID, StringComparison.Ordinal)) return;
_logger.LogCallInfo(MareHubLogger.Args(dto, "Success"));
_dbContext.GroupPairs.Remove(groupPair);
DbContext.GroupPairs.Remove(groupPair);
var groupPairs = _dbContext.GroupPairs.Where(p => p.GroupGID == group.GID).AsNoTracking().ToList();
var groupPairs = DbContext.GroupPairs.Where(p => p.GroupGID == group.GID).AsNoTracking().ToList();
await Clients.Users(groupPairs.Select(p => p.GroupUserUID)).Client_GroupPairLeft(dto).ConfigureAwait(false);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
var userIdent = await GetUserIdent(dto.User.UID).ConfigureAwait(false);
if (userIdent == null)
{
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
return;
}
@@ -570,9 +570,9 @@ public partial class MareHub
userPair.IsModerator = false;
}
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
var groupPairs = await _dbContext.GroupPairs.AsNoTracking().Where(p => p.GroupGID == dto.Group.GID).Select(p => p.GroupUserUID).ToListAsync().ConfigureAwait(false);
var groupPairs = await DbContext.GroupPairs.AsNoTracking().Where(p => p.GroupGID == dto.Group.GID).Select(p => p.GroupUserUID).ToListAsync().ConfigureAwait(false);
await Clients.Users(groupPairs).Client_GroupPairChangeUserInfo(new GroupPairUserInfoDto(dto.Group, dto.User, userPair.ToEnum())).ConfigureAwait(false);
}
@@ -581,11 +581,11 @@ public partial class MareHub
{
_logger.LogCallInfo();
var groups = await _dbContext.GroupPairs.Include(g => g.Group).Include(g => g.Group.Owner).Where(g => g.GroupUserUID == UserUID).AsNoTracking().ToListAsync().ConfigureAwait(false);
var preferredPermissions = (await _dbContext.GroupPairPreferredPermissions.Where(u => u.UserUID == UserUID).ToListAsync().ConfigureAwait(false))
var groups = await DbContext.GroupPairs.Include(g => g.Group).Include(g => g.Group.Owner).Where(g => g.GroupUserUID == UserUID).AsNoTracking().ToListAsync().ConfigureAwait(false);
var preferredPermissions = (await DbContext.GroupPairPreferredPermissions.Where(u => u.UserUID == UserUID).ToListAsync().ConfigureAwait(false))
.Where(u => groups.Exists(k => string.Equals(k.GroupGID, u.GroupGID, StringComparison.Ordinal)))
.ToDictionary(u => groups.First(f => string.Equals(f.GroupGID, u.GroupGID, StringComparison.Ordinal)), u => u);
var groupInfos = await _dbContext.GroupPairs.Where(u => groups.Select(g => g.GroupGID).Contains(u.GroupGID) && (u.IsPinned || u.IsModerator))
var groupInfos = await DbContext.GroupPairs.Where(u => groups.Select(g => g.GroupGID).Contains(u.GroupGID) && (u.IsPinned || u.IsModerator))
.ToListAsync().ConfigureAwait(false);
return preferredPermissions.Select(g => new GroupFullInfoDto(g.Key.Group.ToGroupData(), g.Key.Group.Owner.ToUserData(),
@@ -602,11 +602,11 @@ public partial class MareHub
var (userHasRights, _) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
if (!userHasRights) return;
var banEntry = await _dbContext.GroupBans.SingleOrDefaultAsync(g => g.GroupGID == dto.Group.GID && g.BannedUserUID == dto.User.UID).ConfigureAwait(false);
var banEntry = await DbContext.GroupBans.SingleOrDefaultAsync(g => g.GroupGID == dto.Group.GID && g.BannedUserUID == dto.User.UID).ConfigureAwait(false);
if (banEntry == null) return;
_dbContext.Remove(banEntry);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
DbContext.Remove(banEntry);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
_logger.LogCallInfo(MareHubLogger.Args(dto, "Success"));
}

18
MareSynchronosServer/MareSynchronosServer/Hubs/MareHub.Permissions.cs
View File

@@ -17,7 +17,7 @@ public partial class MareHub
{
_logger.LogCallInfo(MareHubLogger.Args(defaultPermissions));
var permissions = await _dbContext.UserDefaultPreferredPermissions.SingleAsync(u => u.UserUID == UserUID).ConfigureAwait(false);
var permissions = await DbContext.UserDefaultPreferredPermissions.SingleAsync(u => u.UserUID == UserUID).ConfigureAwait(false);
permissions.DisableGroupAnimations = defaultPermissions.DisableGroupAnimations;
permissions.DisableGroupSounds = defaultPermissions.DisableGroupSounds;
@@ -27,8 +27,8 @@ public partial class MareHub
permissions.DisableIndividualVFX = defaultPermissions.DisableIndividualVFX;
permissions.IndividualIsSticky = defaultPermissions.IndividualIsSticky;
_dbContext.Update(permissions);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
DbContext.Update(permissions);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
await Clients.Caller.Client_UserUpdateDefaultPermissions(defaultPermissions).ConfigureAwait(false);
}
@@ -46,7 +46,7 @@ public partial class MareHub
// get all current pairs in any form
var allUsers = await GetAllPairInfo(UserUID).ConfigureAwait(false);
var ownDefaultPerms = await _dbContext.UserDefaultPreferredPermissions.SingleAsync(u => u.UserUID == UserUID).ConfigureAwait(false);
var ownDefaultPerms = await DbContext.UserDefaultPreferredPermissions.SingleAsync(u => u.UserUID == UserUID).ConfigureAwait(false);
foreach (var user in dto.AffectedUsers)
{
@@ -59,14 +59,14 @@ public partial class MareHub
}
var pauseChange = pairData.OwnPermissions.IsPaused != newPerm.IsPaused();
var prevPermissions = await _dbContext.Permissions.SingleAsync(u => u.UserUID == UserUID && u.OtherUserUID == user.Key).ConfigureAwait(false);
var prevPermissions = await DbContext.Permissions.SingleAsync(u => u.UserUID == UserUID && u.OtherUserUID == user.Key).ConfigureAwait(false);
prevPermissions.IsPaused = newPerm.IsPaused();
prevPermissions.DisableAnimations = newPerm.IsDisableAnimations();
prevPermissions.DisableSounds = newPerm.IsDisableSounds();
prevPermissions.DisableVFX = newPerm.IsDisableVFX();
prevPermissions.Sticky = newPerm.IsSticky() || setSticky;
_dbContext.Update(prevPermissions);
DbContext.Update(prevPermissions);
// send updated data to pair
var permCopy = newPerm;
@@ -104,7 +104,7 @@ public partial class MareHub
var (inGroup, groupPair) = await TryValidateUserInGroup(group.Key).ConfigureAwait(false);
if (!inGroup) continue;
var groupPreferredPermissions = await _dbContext.GroupPairPreferredPermissions
var groupPreferredPermissions = await DbContext.GroupPairPreferredPermissions
.SingleAsync(u => u.UserUID == UserUID && u.GroupGID == group.Key).ConfigureAwait(false);
var wasPaused = groupPreferredPermissions.IsPaused;
@@ -116,7 +116,7 @@ public partial class MareHub
var nonStickyPairs = allUsers.Where(u => !u.Value.OwnPermissions.Sticky).ToList();
var affectedGroupPairs = nonStickyPairs.Where(u => u.Value.GIDs.Contains(group.Key, StringComparer.Ordinal)).ToList();
var groupUserUids = affectedGroupPairs.Select(g => g.Key).ToList();
var affectedPerms = await _dbContext.Permissions.Where(u => u.UserUID == UserUID
var affectedPerms = await DbContext.Permissions.Where(u => u.UserUID == UserUID
&& groupUserUids.Any(c => c == u.OtherUserUID))
.ToListAsync().ConfigureAwait(false);
@@ -167,6 +167,6 @@ public partial class MareHub
}
}
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
}
}

46
MareSynchronosServer/MareSynchronosServer/Hubs/MareHub.User.cs
View File

@@ -29,7 +29,7 @@ public partial class MareHub
if (string.Equals(dto.User.UID, UserUID, StringComparison.Ordinal) || string.IsNullOrWhiteSpace(dto.User.UID)) return;
// grab other user, check if it exists and if a pair already exists
var otherUser = await _dbContext.Users.SingleOrDefaultAsync(u => u.UID == uid || u.Alias == uid).ConfigureAwait(false);
var otherUser = await DbContext.Users.SingleOrDefaultAsync(u => u.UID == uid || u.Alias == uid).ConfigureAwait(false);
if (otherUser == null)
{
await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, $"Cannot pair with {dto.User.UID}, UID does not exist").ConfigureAwait(false);
@@ -43,7 +43,7 @@ public partial class MareHub
}
var existingEntry =
await _dbContext.ClientPairs.AsNoTracking()
await DbContext.ClientPairs.AsNoTracking()
.FirstOrDefaultAsync(p =>
p.User.UID == UserUID && p.OtherUserUID == otherUser.UID).ConfigureAwait(false);
@@ -54,7 +54,7 @@ public partial class MareHub
}
// grab self create new client pair and save
var user = await _dbContext.Users.SingleAsync(u => u.UID == UserUID).ConfigureAwait(false);
var user = await DbContext.Users.SingleAsync(u => u.UID == UserUID).ConfigureAwait(false);
_logger.LogCallInfo(MareHubLogger.Args(dto, "Success"));
@@ -63,14 +63,14 @@ public partial class MareHub
OtherUser = otherUser,
User = user,
};
await _dbContext.ClientPairs.AddAsync(wl).ConfigureAwait(false);
await DbContext.ClientPairs.AddAsync(wl).ConfigureAwait(false);
var existingData = await GetPairInfo(UserUID, otherUser.UID).ConfigureAwait(false);
var permissions = existingData?.OwnPermissions;
if (permissions == null || !permissions.Sticky)
{
var ownDefaultPermissions = await _dbContext.UserDefaultPreferredPermissions.AsNoTracking().SingleOrDefaultAsync(f => f.UserUID == UserUID).ConfigureAwait(false);
var ownDefaultPermissions = await DbContext.UserDefaultPreferredPermissions.AsNoTracking().SingleOrDefaultAsync(f => f.UserUID == UserUID).ConfigureAwait(false);
permissions = new UserPermissionSet()
{
@@ -83,10 +83,10 @@ public partial class MareHub
Sticky = true
};
var existingDbPerms = await _dbContext.Permissions.SingleOrDefaultAsync(u => u.UserUID == UserUID && u.OtherUserUID == otherUser.UID).ConfigureAwait(false);
var existingDbPerms = await DbContext.Permissions.SingleOrDefaultAsync(u => u.UserUID == UserUID && u.OtherUserUID == otherUser.UID).ConfigureAwait(false);
if (existingDbPerms == null)
{
await _dbContext.Permissions.AddAsync(permissions).ConfigureAwait(false);
await DbContext.Permissions.AddAsync(permissions).ConfigureAwait(false);
}
else
{
@@ -96,11 +96,11 @@ public partial class MareHub
existingDbPerms.IsPaused = false;
existingDbPerms.Sticky = true;
_dbContext.Permissions.Update(existingDbPerms);
DbContext.Permissions.Update(existingDbPerms);
}
}
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
// get the opposite entry of the client pair
var otherEntry = OppositeEntry(otherUser.UID);
@@ -141,8 +141,8 @@ public partial class MareHub
{
_logger.LogCallInfo();
var userEntry = await _dbContext.Users.SingleAsync(u => u.UID == UserUID).ConfigureAwait(false);
var secondaryUsers = await _dbContext.Auth.Include(u => u.User).Where(u => u.PrimaryUserUID == UserUID).Select(c => c.User).ToListAsync().ConfigureAwait(false);
var userEntry = await DbContext.Users.SingleAsync(u => u.UID == UserUID).ConfigureAwait(false);
var secondaryUsers = await DbContext.Auth.Include(u => u.User).Where(u => u.PrimaryUserUID == UserUID).Select(c => c.User).ToListAsync().ConfigureAwait(false);
foreach (var user in secondaryUsers)
{
await DeleteUser(user).ConfigureAwait(false);
@@ -192,7 +192,7 @@ public partial class MareHub
return new UserProfileDto(user.User, false, null, null, "Due to the pause status you cannot access this users profile.");
}
var data = await _dbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == user.User.UID).ConfigureAwait(false);
var data = await DbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == user.User.UID).ConfigureAwait(false);
if (data == null) return new UserProfileDto(user.User, false, null, null, null);
if (data.FlaggedForReport) return new UserProfileDto(user.User, true, null, null, "This profile is flagged for report and pending evaluation");
@@ -291,14 +291,14 @@ public partial class MareHub
// check if client pair even exists
ClientPair callerPair =
await _dbContext.ClientPairs.SingleOrDefaultAsync(w => w.UserUID == UserUID && w.OtherUserUID == dto.User.UID).ConfigureAwait(false);
await DbContext.ClientPairs.SingleOrDefaultAsync(w => w.UserUID == UserUID && w.OtherUserUID == dto.User.UID).ConfigureAwait(false);
if (callerPair == null) return;
var pairData = await GetPairInfo(UserUID, dto.User.UID).ConfigureAwait(false);
// delete from database, send update info to users pair list
_dbContext.ClientPairs.Remove(callerPair);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
DbContext.ClientPairs.Remove(callerPair);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
_logger.LogCallInfo(MareHubLogger.Args(dto, "Success"));
@@ -340,14 +340,14 @@ public partial class MareHub
{
_logger.LogCallInfo(MareHubLogger.Args(dto));
UserProfileDataReport report = await _dbContext.UserProfileReports.SingleOrDefaultAsync(u => u.ReportedUserUID == dto.User.UID && u.ReportingUserUID == UserUID).ConfigureAwait(false);
UserProfileDataReport report = await DbContext.UserProfileReports.SingleOrDefaultAsync(u => u.ReportedUserUID == dto.User.UID && u.ReportingUserUID == UserUID).ConfigureAwait(false);
if (report != null)
{
await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You already reported this profile and it's pending validation").ConfigureAwait(false);
return;
}
UserProfileData profile = await _dbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == dto.User.UID).ConfigureAwait(false);
UserProfileData profile = await DbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == dto.User.UID).ConfigureAwait(false);
if (profile == null)
{
await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "This user has no profile").ConfigureAwait(false);
@@ -364,9 +364,9 @@ public partial class MareHub
profile.FlaggedForReport = true;
await _dbContext.UserProfileReports.AddAsync(reportToAdd).ConfigureAwait(false);
await DbContext.UserProfileReports.AddAsync(reportToAdd).ConfigureAwait(false);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
await Clients.User(dto.User.UID).Client_ReceiveServerMessage(MessageSeverity.Warning, "Your Mare profile has been reported and disabled for admin validation").ConfigureAwait(false);
@@ -384,7 +384,7 @@ public partial class MareHub
if (!string.Equals(dto.User.UID, UserUID, StringComparison.Ordinal)) throw new HubException("Cannot modify profile data for anyone but yourself");
var existingData = await _dbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == dto.User.UID).ConfigureAwait(false);
var existingData = await DbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == dto.User.UID).ConfigureAwait(false);
if (existingData?.FlaggedForReport ?? false)
{
@@ -448,10 +448,10 @@ public partial class MareHub
IsNSFW = dto.IsNSFW ?? false
};
await _dbContext.UserProfileData.AddAsync(userProfileData).ConfigureAwait(false);
await DbContext.UserProfileData.AddAsync(userProfileData).ConfigureAwait(false);
}
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
var allPairedUsers = await GetAllPairedUnpausedUsers().ConfigureAwait(false);
var pairs = await GetOnlineUsers(allPairedUsers).ConfigureAwait(false);
@@ -470,5 +470,5 @@ public partial class MareHub
private static partial Regex UrlRegex();
private ClientPair OppositeEntry(string otherUID) =>
_dbContext.ClientPairs.AsNoTracking().SingleOrDefault(w => w.User.UID == otherUID && w.OtherUser.UID == UserUID);
DbContext.ClientPairs.AsNoTracking().SingleOrDefault(w => w.User.UID == otherUID && w.OtherUser.UID == UserUID);
}

33
MareSynchronosServer/MareSynchronosServer/Hubs/MareHub.cs
View File

@@ -24,7 +24,6 @@ public partial class MareHub : Hub<IMareHub>, IMareHub
private readonly SystemInfoService _systemInfoService;
private readonly IHttpContextAccessor _contextAccessor;
private readonly MareHubLogger _logger;
private readonly MareDbContext _dbContext;
private readonly string _shardName;
private readonly int _maxExistingGroupsByUser;
private readonly int _maxJoinedGroupsByUser;
@@ -33,9 +32,11 @@ public partial class MareHub : Hub<IMareHub>, IMareHub
private readonly OnlineSyncedPairCacheService _onlineSyncedPairCacheService;
private readonly Uri _fileServerAddress;
private readonly Version _expectedClientVersion;
private readonly Lazy<MareDbContext> _dbContextLazy;
private MareDbContext DbContext => _dbContextLazy.Value;
public MareHub(MareMetrics mareMetrics,
MareDbContext mareDbContext, ILogger<MareHub> logger, SystemInfoService systemInfoService,
IDbContextFactory<MareDbContext> mareDbContextFactory, ILogger<MareHub> logger, SystemInfoService systemInfoService,
IConfigurationService<ServerConfiguration> configuration, IHttpContextAccessor contextAccessor,
IRedisDatabase redisDb, OnlineSyncedPairCacheService onlineSyncedPairCacheService)
{
@@ -51,7 +52,17 @@ public partial class MareHub : Hub<IMareHub>, IMareHub
_redis = redisDb;
_onlineSyncedPairCacheService = onlineSyncedPairCacheService;
_logger = new MareHubLogger(this, logger);
_dbContext = mareDbContext;
_dbContextLazy = new Lazy<MareDbContext>(() => mareDbContextFactory.CreateDbContext());
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (_dbContextLazy.IsValueCreated) DbContext.Dispose();
}
base.Dispose(disposing);
}
[Authorize(Policy = "Identified")]
@@ -63,12 +74,12 @@ public partial class MareHub : Hub<IMareHub>, IMareHub
await Clients.Caller.Client_UpdateSystemInfo(_systemInfoService.SystemInfoDto).ConfigureAwait(false);
var dbUser = await _dbContext.Users.SingleAsync(f => f.UID == UserUID).ConfigureAwait(false);
var dbUser = await DbContext.Users.SingleAsync(f => f.UID == UserUID).ConfigureAwait(false);
dbUser.LastLoggedIn = DateTime.UtcNow;
await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Information, "Welcome to Mare Synchronos \"" + _shardName + "\", Current Online Users: " + _systemInfoService.SystemInfoDto.OnlineUsers).ConfigureAwait(false);
var defaultPermissions = await _dbContext.UserDefaultPreferredPermissions.SingleOrDefaultAsync(u => u.UserUID == UserUID).ConfigureAwait(false);
var defaultPermissions = await DbContext.UserDefaultPreferredPermissions.SingleOrDefaultAsync(u => u.UserUID == UserUID).ConfigureAwait(false);
if (defaultPermissions == null)
{
defaultPermissions = new UserDefaultPreferredPermission()
@@ -76,10 +87,10 @@ public partial class MareHub : Hub<IMareHub>, IMareHub
UserUID = UserUID,
};
_dbContext.UserDefaultPreferredPermissions.Add(defaultPermissions);
DbContext.UserDefaultPreferredPermissions.Add(defaultPermissions);
}
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
return new ConnectionDto(new UserData(dbUser.UID, string.IsNullOrWhiteSpace(dbUser.Alias) ? null : dbUser.Alias))
{
@@ -124,7 +135,7 @@ public partial class MareHub : Hub<IMareHub>, IMareHub
try
{
_logger.LogCallInfo(MareHubLogger.Args(_contextAccessor.GetIpAddress(), UserCharaIdent));
await _onlineSyncedPairCacheService.InitPlayer(UserUID).ConfigureAwait(false);
await UpdateUserOnRedis().ConfigureAwait(false);
}
catch { }
@@ -139,6 +150,8 @@ public partial class MareHub : Hub<IMareHub>, IMareHub
try
{
await _onlineSyncedPairCacheService.DisposePlayer(UserUID).ConfigureAwait(false);
_logger.LogCallInfo(MareHubLogger.Args(_contextAccessor.GetIpAddress(), UserCharaIdent));
if (exception != null)
_logger.LogCallWarning(MareHubLogger.Args(_contextAccessor.GetIpAddress(), exception.Message, exception.StackTrace));
@@ -147,8 +160,8 @@ public partial class MareHub : Hub<IMareHub>, IMareHub
await SendOfflineToAllPairedUsers().ConfigureAwait(false);
_dbContext.RemoveRange(_dbContext.Files.Where(f => !f.Uploaded && f.UploaderUID == UserUID));
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
DbContext.RemoveRange(DbContext.Files.Where(f => !f.Uploaded && f.UploaderUID == UserUID));
await DbContext.SaveChangesAsync().ConfigureAwait(false);
}
catch { }

226
MareSynchronosServer/MareSynchronosServer/Services/OnlineSyncedPairCacheService.cs
View File

@@ -2,178 +2,144 @@
namespace MareSynchronosServer.Services;
public class OnlineSyncedPairCacheService : IHostedService
public class OnlineSyncedPairCacheService
{
private const int CleanupCount = 1;
private const int CacheCount = 1000;
private Task? _cleanUpTask;
private readonly CancellationTokenSource _runnerCts = new();
private readonly Dictionary<string, Dictionary<string, DateTime>> _lastSeenCache = new(StringComparer.Ordinal);
private readonly SemaphoreSlim _cleanupSemaphore = new(CleanupCount);
private readonly SemaphoreSlim _cacheSemaphore = new(CacheCount);
private readonly SemaphoreSlim _cacheAdditionSemaphore = new(1);
private readonly Dictionary<string, PairCache> _lastSeenCache = new(StringComparer.Ordinal);
private readonly SemaphoreSlim _cacheModificationSemaphore = new(1);
private readonly ILogger<OnlineSyncedPairCacheService> _logger;
private readonly ILoggerFactory _loggerFactory;
private readonly MareMetrics _mareMetrics;
public OnlineSyncedPairCacheService(ILogger<OnlineSyncedPairCacheService> logger, MareMetrics mareMetrics)
public OnlineSyncedPairCacheService(ILogger<OnlineSyncedPairCacheService> logger, ILoggerFactory loggerFactory, MareMetrics mareMetrics)
{
_logger = logger;
_loggerFactory = loggerFactory;
_mareMetrics = mareMetrics;
}
public Task StartAsync(CancellationToken cancellationToken)
public async Task InitPlayer(string user)
{
_cleanUpTask = CleanUp(_runnerCts.Token);
return Task.CompletedTask;
if (_lastSeenCache.ContainsKey(user)) return;
await _cacheModificationSemaphore.WaitAsync().ConfigureAwait(false);
try
{
_logger.LogDebug("Initializing {user}", user);
_lastSeenCache[user] = new(_loggerFactory.CreateLogger<PairCache>(), user, _mareMetrics);
}
finally
{
_cacheModificationSemaphore.Release();
}
}
public async Task StopAsync(CancellationToken cancellationToken)
public async Task DisposePlayer(string user)
{
_runnerCts.Cancel();
await _cleanUpTask.WaitAsync(cancellationToken).ConfigureAwait(false);
if (!_lastSeenCache.ContainsKey(user)) return;
await _cacheModificationSemaphore.WaitAsync().ConfigureAwait(false);
try
{
_logger.LogDebug("Disposing {user}", user);
_lastSeenCache.Remove(user, out var pairCache);
pairCache?.Dispose();
}
finally
{
_cacheModificationSemaphore.Release();
}
}
public async Task<bool> AreAllPlayersCached(string sender, List<string> uids, CancellationToken ct)
{
while (_cleanupSemaphore.CurrentCount == 0)
await Task.Delay(250, ct).ConfigureAwait(false);
if (!_lastSeenCache.ContainsKey(sender)) await InitPlayer(sender).ConfigureAwait(false);
await _cacheSemaphore.WaitAsync(ct).ConfigureAwait(false);
try
{
if (ct.IsCancellationRequested)
return false;
if (!_lastSeenCache.TryGetValue(sender, out var senderCache))
{
_mareMetrics.IncCounter(MetricsAPI.CounterUserPairCacheMiss);
return false;
}
lock (senderCache)
{
var cachedUIDs = senderCache.Keys.ToList();
var allCached = uids.TrueForAll(u => cachedUIDs.Contains(u, StringComparer.OrdinalIgnoreCase));
_logger.LogDebug("AreAllPlayersCached:{uid}:{count}:{result}", sender, uids.Count, allCached);
if (allCached) _mareMetrics.IncCounter(MetricsAPI.CounterUserPairCacheHit);
else _mareMetrics.IncCounter(MetricsAPI.CounterUserPairCacheMiss);
return allCached;
}
}
finally
{
_cacheSemaphore.Release();
}
_lastSeenCache.TryGetValue(sender, out var pairCache);
return await pairCache.AreAllPlayersCached(uids, ct).ConfigureAwait(false);
}
public async Task CachePlayers(string sender, List<string> uids, CancellationToken ct)
{
while (_cleanupSemaphore.CurrentCount == 0)
await Task.Delay(250, ct).ConfigureAwait(false);
if (!_lastSeenCache.ContainsKey(sender)) await InitPlayer(sender).ConfigureAwait(false);
await _cacheSemaphore.WaitAsync(ct).ConfigureAwait(false);
try
{
if (ct.IsCancellationRequested) return;
if (!_lastSeenCache.TryGetValue(sender, out var senderCache))
{
await _cacheAdditionSemaphore.WaitAsync(ct).ConfigureAwait(false);
try
{
if (!_lastSeenCache.ContainsKey(sender))
{
_lastSeenCache[sender] = senderCache = new(StringComparer.Ordinal);
_mareMetrics.IncGauge(MetricsAPI.GaugeUserPairCacheEntries);
}
}
finally
{
_cacheAdditionSemaphore.Release();
}
}
lock (senderCache)
{
var lastSeen = DateTime.UtcNow.AddMinutes(60);
_logger.LogDebug("CacheOnlinePlayers:{uid}:{count}", sender, uids.Count);
var newEntries = uids.Count(u => !senderCache.ContainsKey(u));
_mareMetrics.IncCounter(MetricsAPI.CounterUserPairCacheNewEntries, newEntries);
_mareMetrics.IncCounter(MetricsAPI.CounterUserPairCacheUpdatedEntries, uids.Count - newEntries);
_mareMetrics.IncGauge(MetricsAPI.GaugeUserPairCacheEntries, newEntries);
uids.ForEach(u => senderCache[u] = lastSeen);
}
}
finally
{
_cacheSemaphore.Release();
}
_lastSeenCache.TryGetValue(sender, out var pairCache);
await pairCache.CachePlayers(uids, ct).ConfigureAwait(false);
}
private async Task CleanUp(CancellationToken ct)
private sealed class PairCache : IDisposable
{
while (!ct.IsCancellationRequested)
{
await Task.Delay(TimeSpan.FromSeconds(60), ct).ConfigureAwait(false);
private readonly ILogger<PairCache> _logger;
private readonly string _owner;
private readonly MareMetrics _metrics;
private readonly Dictionary<string, DateTime> _lastSeenCache = new(StringComparer.Ordinal);
private readonly SemaphoreSlim _lock = new(1);
_logger.LogInformation("Cleaning up stale entries: spin up");
public PairCache(ILogger<PairCache> logger, string owner, MareMetrics metrics)
{
metrics.IncGauge(MetricsAPI.GaugeUserPairCacheUsers);
_logger = logger;
_owner = owner;
_metrics = metrics;
}
public async Task<bool> AreAllPlayersCached(List<string> uids, CancellationToken ct)
{
await _lock.WaitAsync(ct).ConfigureAwait(false);
try
{
await _cleanupSemaphore.WaitAsync(ct).ConfigureAwait(false);
while (_cacheSemaphore.CurrentCount != CacheCount)
await Task.Delay(25, ct).ConfigureAwait(false);
CleanUpCache(ct);
var allCached = uids.TrueForAll(u => _lastSeenCache.TryGetValue(u, out var expiry) && expiry > DateTime.UtcNow);
_logger.LogDebug("AreAllPlayersCached:{uid}:{count}:{result}", _owner, uids.Count, allCached);
if (allCached) _metrics.IncCounter(MetricsAPI.CounterUserPairCacheHit);
else _metrics.IncCounter(MetricsAPI.CounterUserPairCacheMiss);
return allCached;
}
finally
{
_cleanupSemaphore.Release();
_lock.Release();
}
}
}
private void CleanUpCache(CancellationToken ct)
{
try
public async Task CachePlayers(List<string> uids, CancellationToken ct)
{
int entriesRemoved = 0;
int playersRemoved = 0;
_logger.LogInformation("Cleaning up stale entries: start");
Parallel.ForEach(_lastSeenCache.ToDictionary(k => k.Key, k => k.Value, StringComparer.Ordinal),
playerCache =>
await _lock.WaitAsync(ct).ConfigureAwait(false);
try
{
var lastSeen = DateTime.UtcNow.AddMinutes(60);
_logger.LogDebug("CacheOnlinePlayers:{uid}:{count}", _owner, uids.Count);
var newEntries = uids.Count(u => !_lastSeenCache.ContainsKey(u));
_metrics.IncCounter(MetricsAPI.CounterUserPairCacheNewEntries, newEntries);
_metrics.IncCounter(MetricsAPI.CounterUserPairCacheUpdatedEntries, uids.Count - newEntries);
_metrics.IncGauge(MetricsAPI.GaugeUserPairCacheEntries, newEntries);
uids.ForEach(u => _lastSeenCache[u] = lastSeen);
// clean up old entries
var outdatedEntries = _lastSeenCache.Where(u => u.Value < DateTime.UtcNow).Select(k => k.Key).ToList();
if (outdatedEntries.Any())
{
ct.ThrowIfCancellationRequested();
foreach (var cacheEntry in playerCache.Value.ToDictionary(k => k.Key, k => k.Value, StringComparer.Ordinal))
_metrics.DecGauge(MetricsAPI.GaugeUserPairCacheEntries, outdatedEntries.Count);
foreach (var entry in outdatedEntries)
{
if (cacheEntry.Value < DateTime.UtcNow)
{
Interlocked.Increment(ref entriesRemoved);
playerCache.Value.Remove(cacheEntry.Key);
}
_lastSeenCache.Remove(entry);
}
ct.ThrowIfCancellationRequested();
if (!playerCache.Value.Any())
{
Interlocked.Increment(ref playersRemoved);
_lastSeenCache.Remove(playerCache.Key, out _);
}
});
_logger.LogInformation("Cleaning up stale entries: complete; removed {entries} individual entries and {players} players", entriesRemoved, playersRemoved);
_mareMetrics.SetGaugeTo(MetricsAPI.GaugeUserPairCacheEntries, _lastSeenCache.Values.SelectMany(k => k.Keys).Count());
_mareMetrics.SetGaugeTo(MetricsAPI.GaugeUserPairCacheUsers, _lastSeenCache.Keys.Count);
}
}
finally
{
_lock.Release();
}
}
catch (Exception ex)
public void Dispose()
{
_logger.LogWarning(ex, "Cleaning up stale entries: failed");
_metrics.DecGauge(MetricsAPI.GaugeUserPairCacheUsers);
_metrics.DecGauge(MetricsAPI.GaugeUserPairCacheEntries, _lastSeenCache.Count);
_lock.Dispose();
}
}
}

1
MareSynchronosServer/MareSynchronosServer/Startup.cs
View File

@@ -92,7 +92,6 @@ public class Startup
services.AddSingleton<SystemInfoService>();
services.AddSingleton<OnlineSyncedPairCacheService>();
services.AddHostedService(provider => provider.GetService<SystemInfoService>());
services.AddHostedService(provider => provider.GetService<OnlineSyncedPairCacheService>());
// configure services based on main server status
ConfigureServicesBasedOnShardType(services, mareConfig, isMainServer);

24
MareSynchronosServer/MareSynchronosShared/Metrics/MareMetrics.cs
View File

@@ -11,49 +11,49 @@ public class MareMetrics
foreach (var counter in countersToServe)
{
logger.LogInformation($"Creating Metric for Counter {counter}");
counters.Add(counter, Prometheus.Metrics.CreateCounter(counter, counter));
_counters.Add(counter, Prometheus.Metrics.CreateCounter(counter, counter));
}
foreach (var gauge in gaugesToServe)
{
logger.LogInformation($"Creating Metric for Counter {gauge}");
gauges.Add(gauge, Prometheus.Metrics.CreateGauge(gauge, gauge));
_gauges.Add(gauge, Prometheus.Metrics.CreateGauge(gauge, gauge));
}
}
private readonly Dictionary<string, Counter> counters = new(StringComparer.Ordinal);
private readonly Dictionary<string, Counter> _counters = new(StringComparer.Ordinal);
private readonly Dictionary<string, Gauge> gauges = new(StringComparer.Ordinal);
private readonly Dictionary<string, Gauge> _gauges = new(StringComparer.Ordinal);
public void SetGaugeTo(string gaugeName, double value)
{
if (gauges.ContainsKey(gaugeName))
if (_gauges.TryGetValue(gaugeName, out Gauge gauge))
{
gauges[gaugeName].Set(value);
gauge.Set(value);
}
}
public void IncGauge(string gaugeName, double value = 1.0)
{
if (gauges.ContainsKey(gaugeName))
if (_gauges.TryGetValue(gaugeName, out Gauge gauge))
{
gauges[gaugeName].Inc(value);
gauge.Inc(value);
}
}
public void DecGauge(string gaugeName, double value = 1.0)
{
if (gauges.ContainsKey(gaugeName))
if (_gauges.TryGetValue(gaugeName, out Gauge gauge))
{
gauges[gaugeName].Dec(value);
gauge.Dec(value);
}
}
public void IncCounter(string counterName, double value = 1.0)
{
if (counters.ContainsKey(counterName))
if (_counters.TryGetValue(counterName, out Counter counter))
{
counters[counterName].Inc(value);
counter.Inc(value);
}
}
}