t0w0bi/ClubPenguinClient
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Client rework for API change and paradigm shift (#39)

Browse Source 
* most of the groups refactoring on client

* register OnMethods for group stuff

* start implementing client (still pretty broken)

* finish implementing new api first iteration

* idk rework everything for pair shit (still WIP); goal is to remove PairedClients and GroupPairClients from ApiController

* move everything to PairManager, remove dictionaries from APiController

* remove admin stuff from client, cleanup

* adjust reconnection handling, add new settings, todo still to remove access from old stuff that's marked obsolete from config

* add back adding servers, fix intro ui

* fix obsolete calls

* adjust config namespace

* add UI for setting animation/sound permissions to syncshells

* add ConfigurationService to hot reload config on change from external

* move transient data cache to configuration

* add deleting service to ui

* fix saving of transient resources

* fix group pair user assignments

* halt scanner when penumbra inactive, add visible/online/offline split to individual pairs and tags

* add presence to syncshell ui

* move fullpause from config to server config

* fixes in code style

* more codestyle

* show info icon on player in shells, don't show icon when no changes from default state are made, add online notifs

* fixes to intro UI

---------

Co-authored-by: rootdarkarchon <root.darkarchon@outlook.com>
This commit is contained in:
rootdarkarchon
2023-01-29 15:13:53 +01:00
committed by GitHub
parent 616af3626a
commit b2276a1883
79 changed files with 3585 additions and 2701 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
MareSynchronos/WebAPI/ApIController.Functions.Files.cs
View File

@@ -1,19 +1,14 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Collections.Concurrent;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Dalamud.Utility;
using LZ4;
using MareSynchronos.API;
using MareSynchronos.API.Data;
using MareSynchronos.API.Dto.Files;
using MareSynchronos.API.Routes;
using MareSynchronos.Utils;
using MareSynchronos.WebAPI.Utils;
using Microsoft.AspNetCore.SignalR.Client;
@@ -188,7 +183,7 @@ public partial class ApiController
public int GetDownloadId() => _downloadId++;
public async Task DownloadFiles(int currentDownloadId, List<FileReplacementDto> fileReplacementDto, CancellationToken ct)
public async Task DownloadFiles(int currentDownloadId, List<FileReplacementData> fileReplacementDto, CancellationToken ct)
{
DownloadStarted?.Invoke();
try
@@ -213,7 +208,7 @@ public partial class ApiController
private async Task<HttpResponseMessage> SendRequestInternalAsync(HttpRequestMessage requestMessage, CancellationToken? ct = null)
{
requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", this.Authorization);
requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", this._serverManager.GetToken());
if (requestMessage.Content != null)
{
@@ -224,7 +219,7 @@ public partial class ApiController
Logger.Debug("Sending " + requestMessage.Method + " to " + requestMessage.RequestUri);
}
if(ct != null)
if (ct != null)
return await _httpClient.SendAsync(requestMessage, ct.Value).ConfigureAwait(false);
return await _httpClient.SendAsync(requestMessage).ConfigureAwait(false);
}
@@ -236,12 +231,12 @@ public partial class ApiController
return await SendRequestInternalAsync(requestMessage, ct).ConfigureAwait(false);
}
private async Task DownloadFilesInternal(int currentDownloadId, List<FileReplacementDto> fileReplacementDto, CancellationToken ct)
private async Task DownloadFilesInternal(int currentDownloadId, List<FileReplacementData> fileReplacement, CancellationToken ct)
{
Logger.Debug("Downloading files (Download ID " + currentDownloadId + ")");
List<DownloadFileDto> downloadFileInfoFromService = new();
downloadFileInfoFromService.AddRange(await FilesGetSizes(fileReplacementDto.Select(f => f.Hash).ToList()).ConfigureAwait(false));
downloadFileInfoFromService.AddRange(await FilesGetSizes(fileReplacement.Select(f => f.Hash).ToList()).ConfigureAwait(false));
Logger.Debug("Files with size 0 or less: " + string.Join(", ", downloadFileInfoFromService.Where(f => f.Size <= 0).Select(f => f.Hash)));
@@ -261,7 +256,7 @@ public partial class ApiController
await Parallel.ForEachAsync(downloadGroups, new ParallelOptions()
{
MaxDegreeOfParallelism = downloadGroups.Count(),
CancellationToken = ct
CancellationToken = ct,
},
async (fileGroup, token) =>
{
@@ -277,7 +272,7 @@ public partial class ApiController
file.Transferred += bytesDownloaded;
});
var tempPath = Path.Combine(_pluginConfiguration.CacheFolder, file.Hash + ".tmp");
var tempPath = Path.Combine(_configService.Current.CacheFolder, file.Hash + ".tmp");
try
{
await DownloadFileHttpClient(file, tempPath, progress, token).ConfigureAwait(false);
@@ -298,7 +293,7 @@ public partial class ApiController
var tempFileData = await File.ReadAllBytesAsync(tempPath, token).ConfigureAwait(false);
var extratokenedFile = LZ4Codec.Unwrap(tempFileData);
File.Delete(tempPath);
var filePath = Path.Combine(_pluginConfiguration.CacheFolder, file.Hash);
var filePath = Path.Combine(_configService.Current.CacheFolder, file.Hash);
await File.WriteAllBytesAsync(filePath, extratokenedFile, token).ConfigureAwait(false);
var fi = new FileInfo(filePath);
Func<DateTime> RandomDayInThePast()
@@ -329,10 +324,10 @@ public partial class ApiController
CancelDownload(currentDownloadId);
}
public async Task PushCharacterData(CharacterCacheDto character, List<string> visibleCharacterIds)
public async Task PushCharacterData(API.Data.CharacterData character, List<UserData> visibleCharacters)
{
if (!IsConnected || string.Equals(SecretKey, "-", StringComparison.Ordinal)) return;
Logger.Debug("Sending Character data to service " + ApiUri);
if (!IsConnected) return;
Logger.Debug("Sending Character data to service " + _serverManager.CurrentApiUrl);
CancelUpload();
_uploadCancellationTokenSource = new CancellationTokenSource();
@@ -367,7 +362,7 @@ public partial class ApiController
{
CurrentUploads.Add(new UploadFileTransfer(file)
{
Total = new FileInfo(_fileDbManager.GetFileCacheByHash(file.Hash)!.ResolvedFilepath).Length
Total = new FileInfo(_fileDbManager.GetFileCacheByHash(file.Hash)!.ResolvedFilepath).Length,
});
}
catch (Exception ex)
@@ -383,7 +378,7 @@ public partial class ApiController
{
ForbiddenTransfers.Add(new UploadFileTransfer(file)
{
LocalFile = _fileDbManager.GetFileCacheByHash(file.Hash)?.ResolvedFilepath ?? string.Empty
LocalFile = _fileDbManager.GetFileCacheByHash(file.Hash)?.ResolvedFilepath ?? string.Empty,
});
}
}
@@ -431,7 +426,7 @@ public partial class ApiController
if (!uploadToken.IsCancellationRequested)
{
Logger.Info("Pushing character data for " + character.GetHashCode() + " to " + string.Join(", ", visibleCharacterIds));
Logger.Info("Pushing character data for " + character.GetHashCode() + " to " + string.Join(", ", visibleCharacters.Select(c => c.AliasOrUID)));
StringBuilder sb = new();
foreach (var item in character.FileReplacements)
{
@@ -442,14 +437,14 @@ public partial class ApiController
sb.AppendLine($"GlamourerData for {item.Key}: {!string.IsNullOrEmpty(item.Value)}");
}
Logger.Debug("Chara data contained: " + Environment.NewLine + sb.ToString());
await UserPushData(character, visibleCharacterIds).ConfigureAwait(false);
await UserPushData(new(visibleCharacters, character)).ConfigureAwait(false);
}
else
{
Logger.Warn("=== Upload operation was cancelled ===");
}
Logger.Verbose("Upload complete for " + character.GetHashCode());
Logger.Verbose("Upload complete for " + character.DataHash);
_uploadCancellationTokenSource = null;
}

42
MareSynchronos/WebAPI/ApIController.Functions.Users.cs
View File

@@ -1,7 +1,4 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using MareSynchronos.API;
using MareSynchronos.API.Dto.User;
using MareSynchronos.Utils;
using Microsoft.AspNetCore.SignalR.Client;
@@ -11,18 +8,17 @@ public partial class ApiController
{
public async Task UserDelete()
{
_pluginConfiguration.ClientSecret.Remove(ApiUri);
_pluginConfiguration.Save();
CheckConnection();
await FilesDeleteAll().ConfigureAwait(false);
await _mareHub!.SendAsync(nameof(UserDelete)).ConfigureAwait(false);
await CreateConnections().ConfigureAwait(false);
}
public async Task UserPushData(CharacterCacheDto characterCache, List<string> visibleCharacterIds)
public async Task UserPushData(UserCharaDataMessageDto dto)
{
try
{
await _mareHub!.InvokeAsync(nameof(UserPushData), characterCache, visibleCharacterIds).ConfigureAwait(false);
await _mareHub!.InvokeAsync(nameof(UserPushData), dto).ConfigureAwait(false);
}
catch (Exception ex)
{
@@ -30,33 +26,31 @@ public partial class ApiController
}
}
public async Task<List<ClientPairDto>> UserGetPairedClients()
public async Task<List<UserPairDto>> UserGetPairedClients()
{
return await _mareHub!.InvokeAsync<List<ClientPairDto>>(nameof(UserGetPairedClients)).ConfigureAwait(false);
return await _mareHub!.InvokeAsync<List<UserPairDto>>(nameof(UserGetPairedClients)).ConfigureAwait(false);
}
public async Task<List<string>> UserGetOnlineCharacters()
public async Task<List<OnlineUserIdentDto>> UserGetOnlinePairs()
{
return await _mareHub!.InvokeAsync<List<string>>(nameof(UserGetOnlineCharacters)).ConfigureAwait(false);
return await _mareHub!.InvokeAsync<List<OnlineUserIdentDto>>(nameof(UserGetOnlinePairs)).ConfigureAwait(false);
}
public async Task UserAddPair(string uid)
public async Task UserSetPairPermissions(UserPermissionsDto dto)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(UserAddPair), uid.Trim()).ConfigureAwait(false);
Logger.Verbose("Sending UserSetPairPermissions: " + dto);
await _mareHub!.SendAsync(nameof(UserSetPairPermissions), dto).ConfigureAwait(false);
}
public async Task UserChangePairPauseStatus(string uid, bool paused)
public async Task UserAddPair(UserDto dto)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(UserChangePairPauseStatus), uid, paused).ConfigureAwait(false);
if (!IsConnected) return;
await _mareHub!.SendAsync(nameof(UserAddPair), dto).ConfigureAwait(false);
}
public async Task UserRemovePair(string uid)
public async Task UserRemovePair(UserDto dto)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(UserRemovePair), uid).ConfigureAwait(false);
if (!IsConnected) return;
await _mareHub!.SendAsync(nameof(UserRemovePair), dto).ConfigureAwait(false);
}
}
}

57
MareSynchronos/WebAPI/ApiController.Functions.Admin.cs
View File

@@ -1,57 +0,0 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using MareSynchronos.API;
using Microsoft.AspNetCore.SignalR.Client;
namespace MareSynchronos.WebAPI;
public partial class ApiController
{
public async Task AdminUpdateOrAddForbiddenFile(ForbiddenFileDto forbiddenFile)
{
await _mareHub!.SendAsync(nameof(AdminUpdateOrAddForbiddenFile), forbiddenFile).ConfigureAwait(false);
}
public async Task AdminDeleteForbiddenFile(ForbiddenFileDto forbiddenFile)
{
await _mareHub!.SendAsync(nameof(AdminDeleteForbiddenFile), forbiddenFile).ConfigureAwait(false);
}
public async Task AdminUpdateOrAddBannedUser(BannedUserDto bannedUser)
{
await _mareHub!.SendAsync(nameof(AdminUpdateOrAddBannedUser), bannedUser).ConfigureAwait(false);
}
public async Task AdminDeleteBannedUser(BannedUserDto bannedUser)
{
await _mareHub!.SendAsync(nameof(AdminDeleteBannedUser), bannedUser).ConfigureAwait(false);
}
public async Task RefreshOnlineUsers()
{
AdminOnlineUsers = await AdminGetOnlineUsers().ConfigureAwait(false);
}
public async Task<List<OnlineUserDto>> AdminGetOnlineUsers()
{
return await _mareHub!.InvokeAsync<List<OnlineUserDto>>(nameof(AdminGetOnlineUsers)).ConfigureAwait(false);
}
public List<OnlineUserDto> AdminOnlineUsers { get; set; } = new List<OnlineUserDto>();
public async Task AdminChangeModeratorStatus(string onlineUserUID, bool isModerator)
{
await _mareHub!.SendAsync(nameof(AdminChangeModeratorStatus), onlineUserUID, isModerator).ConfigureAwait(false);
}
public async Task<List<ForbiddenFileDto>> AdminGetForbiddenFiles()
{
return await _mareHub!.InvokeAsync<List<ForbiddenFileDto>>(nameof(AdminGetForbiddenFiles)).ConfigureAwait(false);
}
public async Task<List<BannedUserDto>> AdminGetBannedUsers()
{
return await _mareHub!.InvokeAsync<List<BannedUserDto>>(nameof(AdminGetBannedUsers)).ConfigureAwait(false);
}
}

391
MareSynchronos/WebAPI/ApiController.Functions.Callbacks.cs
View File

@@ -1,21 +1,25 @@
using System;
using System.Linq;
using System.Threading.Tasks;
using MareSynchronos.API;
using MareSynchronos.API.Data.Enum;
using MareSynchronos.API.Dto;
using MareSynchronos.API.Dto.Group;
using MareSynchronos.API.Dto.User;
using MareSynchronos.Utils;
using MareSynchronos.WebAPI.Utils;
using Microsoft.AspNetCore.SignalR.Client;
namespace MareSynchronos.WebAPI;
public partial class ApiController
{
public ClientPairDto? LastAddedUser { get; set; }
public void OnUserUpdateClientPairs(Action<ClientPairDto> act)
public UserPairDto? LastAddedUser { get; set; }
private void ExecuteSafely(Action act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_UserUpdateClientPairs), act);
try
{
act();
}
catch (Exception ex)
{
Logger.Error("Error on executing safely", ex);
}
}
public void OnUpdateSystemInfo(Action<SystemInfoDto> act)
@@ -24,60 +28,12 @@ public partial class ApiController
_mareHub!.On(nameof(Client_UpdateSystemInfo), act);
}
public void OnUserReceiveCharacterData(Action<CharacterCacheDto, string> act)
public void OnUserReceiveCharacterData(Action<OnlineUserCharaDataDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_UserReceiveCharacterData), act);
}
public void OnUserChangePairedPlayer(Action<string, bool> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_UserChangePairedPlayer), act);
}
public void OnGroupChange(Action<GroupDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_GroupChange), act);
}
public void OnGroupUserChange(Action<GroupPairDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_GroupUserChange), act);
}
public void OnAdminForcedReconnect(Action act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_AdminForcedReconnect), act);
}
public void OnAdminDeleteBannedUser(Action<BannedUserDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_AdminDeleteBannedUser), act);
}
public void OnAdminDeleteForbiddenFile(Action<ForbiddenFileDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_AdminDeleteForbiddenFile), act);
}
public void OnAdminUpdateOrAddBannedUser(Action<BannedUserDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_AdminUpdateOrAddBannedUser), act);
}
public void OnAdminUpdateOrAddForbiddenFile(Action<ForbiddenFileDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_AdminUpdateOrAddForbiddenFile), act);
}
public void OnReceiveServerMessage(Action<MessageSeverity, string> act)
{
if (_initialized) return;
@@ -90,25 +46,200 @@ public partial class ApiController
_mareHub!.On(nameof(Client_DownloadReady), act);
}
public Task Client_UserUpdateClientPairs(ClientPairDto dto)
public void OnGroupSendFullInfo(Action<GroupFullInfoDto> act)
{
var entry = PairedClients.SingleOrDefault(e => string.Equals(e.OtherUID, dto.OtherUID, System.StringComparison.Ordinal));
if (dto.IsRemoved)
{
PairedClients.RemoveAll(p => string.Equals(p.OtherUID, dto.OtherUID, System.StringComparison.Ordinal));
return Task.CompletedTask;
}
if (entry == null)
{
LastAddedUser = dto;
PairedClients.Add(dto);
return Task.CompletedTask;
}
if (_initialized) return;
_mareHub!.On(nameof(Client_GroupSendFullInfo), act);
}
entry.IsPaused = dto.IsPaused;
entry.IsPausedFromOthers = dto.IsPausedFromOthers;
entry.IsSynced = dto.IsSynced;
public Task Client_GroupSendFullInfo(GroupFullInfoDto dto)
{
Logger.Verbose("Client_GroupSendFullInfo: " + dto);
ExecuteSafely(() => _pairManager.AddGroup(dto));
return Task.CompletedTask;
}
public void OnGroupSendInfo(Action<GroupInfoDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_GroupSendInfo), act);
}
public Task Client_GroupSendInfo(GroupInfoDto dto)
{
Logger.Verbose("Client_GroupSendInfo: " + dto);
ExecuteSafely(() => _pairManager.SetGroupInfo(dto));
return Task.CompletedTask;
}
public void OnGroupDelete(Action<GroupDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_GroupDelete), act);
}
public Task Client_GroupDelete(GroupDto dto)
{
Logger.Verbose("Client_GroupDelete: " + dto);
ExecuteSafely(() => _pairManager.RemoveGroup(dto.Group));
return Task.CompletedTask;
}
public void OnGroupPairJoined(Action<GroupPairFullInfoDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_GroupPairJoined), act);
}
public Task Client_GroupPairJoined(GroupPairFullInfoDto dto)
{
Logger.Verbose("Client_GroupPairJoined: " + dto);
ExecuteSafely(() => _pairManager.AddGroupPair(dto));
return Task.CompletedTask;
}
public void OnGroupPairLeft(Action<GroupPairDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_GroupPairLeft), act);
}
public Task Client_GroupPairLeft(GroupPairDto dto)
{
Logger.Verbose("Client_GroupPairLeft: " + dto);
ExecuteSafely(() => _pairManager.RemoveGroupPair(dto));
return Task.CompletedTask;
}
public void OnGroupChangePermissions(Action<GroupPermissionDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_GroupChangePermissions), act);
}
public Task Client_GroupChangePermissions(GroupPermissionDto dto)
{
Logger.Verbose("Client_GroupChangePermissions: " + dto);
ExecuteSafely(() => _pairManager.SetGroupPermissions(dto));
return Task.CompletedTask;
}
public void OnGroupPairChangePermissions(Action<GroupPairUserPermissionDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_GroupPairChangePermissions), act);
}
public Task Client_GroupPairChangePermissions(GroupPairUserPermissionDto dto)
{
Logger.Verbose("Client_GroupPairChangePermissions: " + dto);
ExecuteSafely(() =>
{
if (string.Equals(dto.UID, UID, StringComparison.Ordinal)) _pairManager.SetGroupUserPermissions(dto);
else _pairManager.SetGroupPairUserPermissions(dto);
});
return Task.CompletedTask;
}
public void OnGroupPairChangeUserInfo(Action<GroupPairUserInfoDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_GroupPairChangeUserInfo), act);
}
public Task Client_GroupPairChangeUserInfo(GroupPairUserInfoDto dto)
{
Logger.Verbose("Client_GroupPairChangeUserInfo: " + dto);
ExecuteSafely(() =>
{
if (string.Equals(dto.UID, UID, StringComparison.Ordinal)) _pairManager.SetGroupStatusInfo(dto);
else _pairManager.SetGroupPairStatusInfo(dto);
});
return Task.CompletedTask;
}
public Task Client_UserReceiveCharacterData(OnlineUserCharaDataDto dto)
{
Logger.Verbose("Client_UserReceiveCharacterData: " + dto.User);
ExecuteSafely(() => _pairManager.ReceiveCharaData(dto));
return Task.CompletedTask;
}
public void OnUserAddClientPair(Action<UserPairDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_UserAddClientPair), act);
}
public Task Client_UserAddClientPair(UserPairDto dto)
{
Logger.Debug($"Client_UserAddClientPair: " + dto);
ExecuteSafely(() => _pairManager.AddUserPair(dto));
return Task.CompletedTask;
}
public void OnUserRemoveClientPair(Action<UserDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_UserRemoveClientPair), act);
}
public Task Client_UserRemoveClientPair(UserDto dto)
{
Logger.Debug($"Client_UserRemoveClientPair: " + dto);
ExecuteSafely(() => _pairManager.RemoveUserPair(dto));
return Task.CompletedTask;
}
public void OnUserSendOffline(Action<UserDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_UserSendOffline), act);
}
public Task Client_UserSendOffline(UserDto dto)
{
Logger.Debug($"Client_UserSendOffline: {dto}");
ExecuteSafely(() => _pairManager.MarkPairOffline(dto.User));
return Task.CompletedTask;
}
public void OnUserSendOnline(Action<OnlineUserIdentDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_UserSendOnline), act);
}
public Task Client_UserSendOnline(OnlineUserIdentDto dto)
{
Logger.Debug($"Client_UserSendOnline: {dto}");
ExecuteSafely(() => _pairManager.MarkPairOnline(dto, this));
return Task.CompletedTask;
}
public void OnUserUpdateOtherPairPermissions(Action<UserPermissionsDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_UserUpdateOtherPairPermissions), act);
}
public Task Client_UserUpdateOtherPairPermissions(UserPermissionsDto dto)
{
Logger.Debug($"Client_UserUpdateOtherPairPermissions: {dto}");
ExecuteSafely(() => _pairManager.UpdatePairPermissions(dto));
return Task.CompletedTask;
}
public void OnUserUpdateSelfPairPermissions(Action<UserPermissionsDto> act)
{
if (_initialized) return;
_mareHub!.On(nameof(Client_UserUpdateSelfPairPermissions), act);
}
public Task Client_UserUpdateSelfPairPermissions(UserPermissionsDto dto)
{
Logger.Debug($"Client_UserUpdateSelfPairPermissions: {dto}");
ExecuteSafely(() => _pairManager.UpdateSelfPairPermissions(dto));
return Task.CompletedTask;
}
@@ -118,114 +249,6 @@ public partial class ApiController
return Task.CompletedTask;
}
public Task Client_UserReceiveCharacterData(CharacterCacheDto clientPairDto, string characterIdent)
{
Logger.Verbose("Received DTO for " + characterIdent);
CharacterReceived?.Invoke(null, new CharacterReceivedEventArgs(characterIdent, clientPairDto));
return Task.CompletedTask;
}
public Task Client_UserChangePairedPlayer(string characterIdent, bool isOnline)
{
if (isOnline) PairedClientOnline?.Invoke(characterIdent);
else PairedClientOffline?.Invoke(characterIdent);
return Task.CompletedTask;
}
public async Task Client_GroupChange(GroupDto dto)
{
if (dto.IsDeleted.GetValueOrDefault(false))
{
Groups.RemoveAll(g => string.Equals(g.GID, dto.GID, System.StringComparison.Ordinal));
GroupPairedClients.RemoveAll(g => string.Equals(g.GroupGID, dto.GID, System.StringComparison.Ordinal));
return;
}
var existingGroup = Groups.FirstOrDefault(g => string.Equals(g.GID, dto.GID, System.StringComparison.Ordinal));
if (existingGroup == null)
{
Groups.Add(dto);
GroupPairedClients.AddRange(await GroupsGetUsersInGroup(dto.GID).ConfigureAwait(false));
return;
}
existingGroup.OwnedBy = dto.OwnedBy ?? existingGroup.OwnedBy;
existingGroup.InvitesEnabled = dto.InvitesEnabled ?? existingGroup.InvitesEnabled;
existingGroup.IsPaused = dto.IsPaused ?? existingGroup.IsPaused;
existingGroup.IsModerator = dto.IsModerator ?? existingGroup.IsModerator;
}
public Task Client_GroupUserChange(GroupPairDto dto)
{
if (dto.IsRemoved.GetValueOrDefault(false))
{
GroupPairedClients.RemoveAll(g => string.Equals(g.GroupGID, dto.GroupGID, System.StringComparison.Ordinal) && string.Equals(g.UserUID, dto.UserUID, System.StringComparison.Ordinal));
return Task.CompletedTask;
}
var existingUser = GroupPairedClients.FirstOrDefault(f => string.Equals(f.GroupGID, dto.GroupGID, System.StringComparison.Ordinal) && string.Equals(f.UserUID, dto.UserUID, System.StringComparison.Ordinal));
if (existingUser == null)
{
GroupPairedClients.Add(dto);
return Task.CompletedTask;
}
existingUser.IsPaused = dto.IsPaused ?? existingUser.IsPaused;
existingUser.UserAlias = dto.UserAlias ?? existingUser.UserAlias;
existingUser.IsPinned = dto.IsPinned ?? existingUser.IsPinned;
existingUser.IsModerator = dto.IsModerator ?? existingUser.IsModerator;
return Task.CompletedTask;
}
public Task Client_AdminForcedReconnect()
{
_ = CreateConnections();
return Task.CompletedTask;
}
public Task Client_AdminDeleteBannedUser(BannedUserDto dto)
{
AdminBannedUsers.RemoveAll(a => string.Equals(a.CharacterHash, dto.CharacterHash, System.StringComparison.Ordinal));
return Task.CompletedTask;
}
public Task Client_AdminDeleteForbiddenFile(ForbiddenFileDto dto)
{
AdminForbiddenFiles.RemoveAll(f => string.Equals(f.Hash, dto.Hash, System.StringComparison.Ordinal));
return Task.CompletedTask;
}
public Task Client_AdminUpdateOrAddBannedUser(BannedUserDto dto)
{
var user = AdminBannedUsers.SingleOrDefault(b => string.Equals(b.CharacterHash, dto.CharacterHash, System.StringComparison.Ordinal));
if (user == null)
{
AdminBannedUsers.Add(dto);
}
else
{
user.Reason = dto.Reason;
}
return Task.CompletedTask;
}
public Task Client_AdminUpdateOrAddForbiddenFile(ForbiddenFileDto dto)
{
var user = AdminForbiddenFiles.SingleOrDefault(b => string.Equals(b.Hash, dto.Hash, System.StringComparison.Ordinal));
if (user == null)
{
AdminForbiddenFiles.Add(dto);
}
else
{
user.ForbiddenBy = dto.ForbiddenBy;
}
return Task.CompletedTask;
}
public Task Client_ReceiveServerMessage(MessageSeverity severity, string message)
{
switch (severity)
@@ -240,7 +263,7 @@ public partial class ApiController
break;
case MessageSeverity.Information:
Logger.Info(message);
if (!_pluginConfiguration.HideInfoMessages)
if (_configService.Current.HideInfoMessages)
{
_dalamudUtil.PrintInfoChat(message);
}

113
MareSynchronos/WebAPI/ApiController.Functions.Groups.cs
View File

@@ -1,116 +1,115 @@
using MareSynchronos.API;
using MareSynchronos.API.Dto.Group;
using MareSynchronos.Utils;
using Microsoft.AspNetCore.SignalR.Client;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace MareSynchronos.WebAPI;
public partial class ApiController
{
public async Task<GroupCreatedDto> GroupCreate()
private void CheckConnection()
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return new GroupCreatedDto();
return await _mareHub!.InvokeAsync<GroupCreatedDto>(nameof(GroupCreate)).ConfigureAwait(false);
if (ServerState is not (ServerState.Connected or ServerState.Connecting or ServerState.Reconnecting)) throw new System.Exception("Not connected");
}
public async Task<bool> GroupChangePassword(string gid, string newpassword)
public async Task<List<BannedGroupUserDto>> GroupGetBannedUsers(GroupDto group)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return false;
return await _mareHub!.InvokeAsync<bool>(nameof(GroupChangePassword), gid, newpassword).ConfigureAwait(false);
CheckConnection();
return await _mareHub!.InvokeAsync<List<BannedGroupUserDto>>(nameof(GroupGetBannedUsers), group).ConfigureAwait(false);
}
public async Task<List<GroupDto>> GroupsGetAll()
public async Task GroupClear(GroupDto group)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return new List<GroupDto>();
return await _mareHub!.InvokeAsync<List<GroupDto>>(nameof(GroupsGetAll)).ConfigureAwait(false);
CheckConnection();
await _mareHub!.SendAsync(nameof(GroupClear), group).ConfigureAwait(false);
}
public async Task<List<GroupPairDto>> GroupsGetUsersInGroup(string gid)
public async Task GroupChangeOwnership(GroupPairDto groupPair)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return new List<GroupPairDto>();
return await _mareHub!.InvokeAsync<List<GroupPairDto>>(nameof(GroupsGetUsersInGroup), gid).ConfigureAwait(false);
CheckConnection();
await _mareHub!.SendAsync(nameof(GroupChangeOwnership), groupPair).ConfigureAwait(false);
}
public async Task<bool> GroupJoin(string gid, string password)
public async Task<bool> GroupChangePassword(GroupPasswordDto groupPassword)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return false;
return await _mareHub!.InvokeAsync<bool>(nameof(GroupJoin), gid.Trim(), password).ConfigureAwait(false);
CheckConnection();
return await _mareHub!.InvokeAsync<bool>(nameof(GroupChangePassword), groupPassword).ConfigureAwait(false);
}
public async Task GroupChangeInviteState(string gid, bool opened)
public async Task<GroupPasswordDto> GroupCreate()
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(GroupChangeInviteState), gid, opened).ConfigureAwait(false);
CheckConnection();
return await _mareHub!.InvokeAsync<GroupPasswordDto>(nameof(GroupCreate)).ConfigureAwait(false);
}
public async Task GroupDelete(string gid)
public async Task<List<GroupFullInfoDto>> GroupsGetAll()
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(GroupDelete), gid).ConfigureAwait(false);
CheckConnection();
return await _mareHub!.InvokeAsync<List<GroupFullInfoDto>>(nameof(GroupsGetAll)).ConfigureAwait(false);
}
public async Task GroupChangePinned(string gid, string uid, bool isPinned)
public async Task<List<GroupPairFullInfoDto>> GroupsGetUsersInGroup(GroupDto group)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(GroupChangePinned), gid, uid, isPinned).ConfigureAwait(false);
CheckConnection();
return await _mareHub!.InvokeAsync<List<GroupPairFullInfoDto>>(nameof(GroupsGetUsersInGroup), group).ConfigureAwait(false);
}
public async Task GroupClear(string gid)
public async Task GroupBanUser(GroupPairDto dto, string reason)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(GroupClear), gid).ConfigureAwait(false);
CheckConnection();
await _mareHub!.SendAsync(nameof(GroupBanUser), dto, reason).ConfigureAwait(false);
}
public async Task GroupLeave(string gid)
public async Task GroupChangeGroupPermissionState(GroupPermissionDto dto)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(GroupLeave), gid).ConfigureAwait(false);
CheckConnection();
await _mareHub!.SendAsync(nameof(GroupChangeGroupPermissionState), dto).ConfigureAwait(false);
}
public async Task GroupChangePauseState(string gid, bool isPaused)
public async Task GroupChangeIndividualPermissionState(GroupPairUserPermissionDto dto)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(GroupChangePauseState), gid, isPaused).ConfigureAwait(false);
CheckConnection();
Logger.Debug("Sending " + dto);
await _mareHub!.SendAsync(nameof(GroupChangeIndividualPermissionState), dto).ConfigureAwait(false);
}
public async Task GroupRemoveUser(string gid, string uid)
public async Task GroupDelete(GroupDto group)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(GroupRemoveUser), gid, uid).ConfigureAwait(false);
CheckConnection();
await _mareHub!.SendAsync(nameof(GroupDelete), group).ConfigureAwait(false);
}
public async Task GroupChangeOwnership(string gid, string uid)
public async Task<bool> GroupJoin(GroupPasswordDto passwordedGroup)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(GroupChangeOwnership), gid, uid).ConfigureAwait(false);
CheckConnection();
return await _mareHub!.InvokeAsync<bool>(nameof(GroupJoin), passwordedGroup).ConfigureAwait(false);
}
public async Task GroupBanUser(string gid, string uid, string reason)
public async Task GroupLeave(GroupDto group)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(GroupBanUser), gid, uid, reason).ConfigureAwait(false);
CheckConnection();
await _mareHub!.SendAsync(nameof(GroupLeave), group).ConfigureAwait(false);
}
public async Task GroupUnbanUser(string gid, string uid)
public async Task GroupRemoveUser(GroupPairDto groupPair)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(GroupUnbanUser), gid, uid).ConfigureAwait(false);
CheckConnection();
await _mareHub!.SendAsync(nameof(GroupRemoveUser), groupPair).ConfigureAwait(false);
}
public async Task<List<BannedGroupUserDto>> GroupGetBannedUsers(string gid)
public async Task GroupUnbanUser(GroupPairDto groupPair)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return new();
return await _mareHub!.InvokeAsync<List<BannedGroupUserDto>>(nameof(GroupGetBannedUsers), gid).ConfigureAwait(false);
CheckConnection();
await _mareHub!.SendAsync(nameof(GroupUnbanUser), groupPair).ConfigureAwait(false);
}
public async Task GroupSetModerator(string gid, string uid, bool isModerator)
public async Task GroupSetUserInfo(GroupPairUserInfoDto userInfo)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return;
await _mareHub!.SendAsync(nameof(GroupSetModerator), gid, uid, isModerator).ConfigureAwait(false);
CheckConnection();
await _mareHub!.SendAsync(nameof(GroupSetUserInfo), userInfo).ConfigureAwait(false);
}
public async Task<List<string>> GroupCreateTempInvite(string gid, int amount)
public async Task<List<string>> GroupCreateTempInvite(GroupDto group, int amount)
{
if (!IsConnected || string.Equals(SecretKey, "-", System.StringComparison.Ordinal)) return new();
return await _mareHub!.InvokeAsync<List<string>>(nameof(GroupCreateTempInvite), gid, amount).ConfigureAwait(false);
CheckConnection();
return await _mareHub!.InvokeAsync<List<string>>(nameof(GroupCreateTempInvite), group, amount).ConfigureAwait(false);
}
}

220
MareSynchronos/WebAPI/ApiController.cs
View File

@@ -1,26 +1,19 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using MareSynchronos.API;
using System.Collections.Concurrent;
using MareSynchronos.API.Routes;
using MareSynchronos.FileCache;
using MareSynchronos.Utils;
using MareSynchronos.WebAPI.Utils;
using Microsoft.AspNetCore.Http.Connections;
using Microsoft.AspNetCore.SignalR.Client;
using Microsoft.Extensions.Logging;
using MareSynchronos.API.Dto;
using MareSynchronos.API.SignalR;
using MareSynchronos.Managers;
using Dalamud.Utility;
using MareSynchronos.MareConfiguration;
using MareSynchronos.Delegates;
namespace MareSynchronos.WebAPI;
public delegate void SimpleStringDelegate(string str);
public record JwtCache(string ApiUrl, string CharaIdent, string SecretKey);
public partial class ApiController : IDisposable, IMareHubClient
{
public const string MainServer = "Lunae Crescere Incipientis (Central Server EU)";
@@ -28,20 +21,19 @@ public partial class ApiController : IDisposable, IMareHubClient
public readonly int[] SupportedServerVersions = { IMareHub.ApiVersion };
private readonly Configuration _pluginConfiguration;
private readonly ConfigurationService _configService;
private readonly DalamudUtil _dalamudUtil;
private readonly FileCacheManager _fileDbManager;
private readonly PairManager _pairManager;
private readonly ServerConfigurationManager _serverManager;
private CancellationTokenSource _connectionCancellationTokenSource;
private Dictionary<JwtCache, string> _jwtToken = new();
private string Authorization => _jwtToken.GetValueOrDefault(new JwtCache(ApiUri, _dalamudUtil.PlayerNameHashed, SecretKey), string.Empty);
private HubConnection? _mareHub;
private CancellationTokenSource? _uploadCancellationTokenSource = new();
private CancellationTokenSource? _healthCheckTokenSource = new();
private ConnectionDto? _connectionDto;
public ServerInfoDto ServerInfo => _connectionDto?.ServerInfo ?? new ServerInfoDto();
public ServerInfo ServerInfo => _connectionDto?.ServerInfo ?? new ServerInfo();
public string AuthFailureMessage { get; private set; } = string.Empty;
public SystemInfoDto SystemInfoDto { get; private set; } = new();
@@ -51,18 +43,21 @@ public partial class ApiController : IDisposable, IMareHubClient
private HttpClient _httpClient;
public ApiController(Configuration pluginConfiguration, DalamudUtil dalamudUtil, FileCacheManager fileDbManager)
public ApiController(ConfigurationService configService, DalamudUtil dalamudUtil, FileCacheManager fileDbManager, PairManager pairManager, ServerConfigurationManager serverManager)
{
Logger.Verbose("Creating " + nameof(ApiController));
_pluginConfiguration = pluginConfiguration;
_configService = configService;
_dalamudUtil = dalamudUtil;
_fileDbManager = fileDbManager;
_pairManager = pairManager;
_serverManager = serverManager;
_connectionCancellationTokenSource = new CancellationTokenSource();
_dalamudUtil.LogIn += DalamudUtilOnLogIn;
_dalamudUtil.LogOut += DalamudUtilOnLogOut;
ServerState = ServerState.Offline;
_verifiedUploadedHashes = new(StringComparer.Ordinal);
_httpClient = new();
if (_dalamudUtil.IsLoggedIn)
{
@@ -72,25 +67,17 @@ public partial class ApiController : IDisposable, IMareHubClient
private void DalamudUtilOnLogOut()
{
Task.Run(async () => await StopConnection(_connectionCancellationTokenSource.Token).ConfigureAwait(false));
Task.Run(async () => await StopConnection(_connectionCancellationTokenSource.Token, ServerState.Disconnected).ConfigureAwait(false));
ServerState = ServerState.Offline;
}
private void DalamudUtilOnLogIn()
{
Task.Run(() => CreateConnections(true));
Task.Run(() => CreateConnections(forceGetToken: true));
}
public event EventHandler<CharacterReceivedEventArgs>? CharacterReceived;
public event VoidDelegate? Connected;
public event VoidDelegate? Disconnected;
public event SimpleStringDelegate? PairedClientOffline;
public event SimpleStringDelegate? PairedClientOnline;
public event VoidDelegate? DownloadStarted;
public event VoidDelegate? DownloadFinished;
@@ -100,33 +87,14 @@ public partial class ApiController : IDisposable, IMareHubClient
public List<FileTransfer> ForbiddenTransfers { get; } = new();
public List<BannedUserDto> AdminBannedUsers { get; private set; } = new();
public List<ForbiddenFileDto> AdminForbiddenFiles { get; private set; } = new();
public bool IsConnected => ServerState == ServerState.Connected;
public bool IsDownloading => CurrentDownloads.Count > 0;
public bool IsDownloading => !CurrentDownloads.IsEmpty;
public bool IsUploading => CurrentUploads.Count > 0;
public List<ClientPairDto> PairedClients { get; set; } = new();
public List<GroupPairDto> GroupPairedClients { get; set; } = new();
public List<GroupDto> Groups { get; set; } = new();
public string SecretKey => _pluginConfiguration.ClientSecret.ContainsKey(ApiUri)
? _pluginConfiguration.ClientSecret[ApiUri] : string.Empty;
public bool ServerAlive => ServerState is ServerState.Connected or ServerState.RateLimited or ServerState.Unauthorized or ServerState.Disconnected;
public Dictionary<string, string> ServerDictionary => new Dictionary<string, string>(StringComparer.Ordinal)
{ { MainServiceUri, MainServer } }
.Concat(_pluginConfiguration.CustomServerList)
.ToDictionary(k => k.Key, k => k.Value, StringComparer.Ordinal);
public string UID => _connectionDto?.UID ?? string.Empty;
public string DisplayName => _connectionDto?.UID ?? string.Empty;
private string ApiUri => _pluginConfiguration.ApiUri;
public string UID => _connectionDto?.User.UID ?? string.Empty;
public string DisplayName => _connectionDto?.User.AliasOrUID ?? string.Empty;
public int OnlineUsers => SystemInfoDto.OnlineUsers;
private ServerState _serverState;
@@ -149,16 +117,24 @@ public partial class ApiController : IDisposable, IMareHubClient
_httpClient?.Dispose();
_httpClient = new();
if (_pluginConfiguration.FullPause)
if (_serverManager.CurrentServer?.FullPause ?? true)
{
Logger.Info("Not recreating Connection, paused");
ServerState = ServerState.Disconnected;
_connectionDto = null;
await StopConnection(_connectionCancellationTokenSource.Token).ConfigureAwait(false);
await StopConnection(_connectionCancellationTokenSource.Token, ServerState.Disconnected).ConfigureAwait(false);
return;
}
await StopConnection(_connectionCancellationTokenSource.Token).ConfigureAwait(false);
var secretKey = _serverManager.GetSecretKey();
if (secretKey.IsNullOrEmpty())
{
Logger.Warn("No secret key set for current character");
_connectionDto = null;
await StopConnection(_connectionCancellationTokenSource.Token, ServerState.NoSecretKey).ConfigureAwait(false);
return;
}
await StopConnection(_connectionCancellationTokenSource.Token, ServerState.Disconnected).ConfigureAwait(false);
Logger.Info("Recreating Connection");
@@ -168,37 +144,31 @@ public partial class ApiController : IDisposable, IMareHubClient
_verifiedUploadedHashes.Clear();
while (ServerState is not ServerState.Connected && !token.IsCancellationRequested)
{
if (string.IsNullOrEmpty(SecretKey))
{
await Task.Delay(TimeSpan.FromSeconds(2)).ConfigureAwait(false);
continue;
}
AuthFailureMessage = string.Empty;
await StopConnection(token).ConfigureAwait(false);
await StopConnection(token, ServerState.Disconnected).ConfigureAwait(false);
ServerState = ServerState.Connecting;
try
{
Logger.Debug("Building connection");
if (!_jwtToken.TryGetValue(new JwtCache(ApiUri, _dalamudUtil.PlayerNameHashed, SecretKey), out var jwtToken) || forceGetToken)
if (_serverManager.GetToken() == null || forceGetToken)
{
Logger.Debug("Requesting new JWT");
using HttpClient httpClient = new();
var postUri = MareAuth.AuthFullPath(new Uri(ApiUri
var postUri = MareAuth.AuthFullPath(new Uri(_serverManager.CurrentApiUrl
.Replace("wss://", "https://", StringComparison.OrdinalIgnoreCase)
.Replace("ws://", "http://", StringComparison.OrdinalIgnoreCase)));
using var sha256 = SHA256.Create();
var auth = BitConverter.ToString(sha256.ComputeHash(Encoding.UTF8.GetBytes(SecretKey))).Replace("-", "", StringComparison.OrdinalIgnoreCase);
var auth = secretKey.GetHash256();
var result = await httpClient.PostAsync(postUri, new FormUrlEncodedContent(new[]
{
new KeyValuePair<string, string>("auth", auth),
new KeyValuePair<string, string>("charaIdent", _dalamudUtil.PlayerNameHashed)
new KeyValuePair<string, string>("charaIdent", _dalamudUtil.PlayerNameHashed),
})).ConfigureAwait(false);
AuthFailureMessage = await result.Content.ReadAsStringAsync().ConfigureAwait(false);
result.EnsureSuccessStatusCode();
_jwtToken[new JwtCache(ApiUri, _dalamudUtil.PlayerNameHashed, SecretKey)] = await result.Content.ReadAsStringAsync().ConfigureAwait(false);
_serverManager.SaveToken(await result.Content.ReadAsStringAsync().ConfigureAwait(false));
Logger.Debug("JWT Success");
}
@@ -214,8 +184,7 @@ public partial class ApiController : IDisposable, IMareHubClient
await _mareHub.StartAsync(token).ConfigureAwait(false);
OnReceiveServerMessage((sev, msg) => Client_ReceiveServerMessage(sev, msg));
OnUpdateSystemInfo((dto) => Client_UpdateSystemInfo(dto));
await InitializeData().ConfigureAwait(false);
_connectionDto = await GetConnectionDto().ConfigureAwait(false);
@@ -223,15 +192,12 @@ public partial class ApiController : IDisposable, IMareHubClient
if (_connectionDto.ServerVersion != IMareHub.ApiVersion)
{
ServerState = ServerState.VersionMisMatch;
await StopConnection(token).ConfigureAwait(false);
await StopConnection(token, ServerState.VersionMisMatch).ConfigureAwait(false);
return;
}
if (ServerState is ServerState.Connected) // user is authorized && server is legit
{
await InitializeData(token).ConfigureAwait(false);
_mareHub.Closed += MareHubOnClosed;
_mareHub.Reconnecting += MareHubOnReconnecting;
_mareHub.Reconnected += MareHubOnReconnected;
@@ -245,13 +211,12 @@ public partial class ApiController : IDisposable, IMareHubClient
if (ex.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
ServerState = ServerState.Unauthorized;
await StopConnection(token).ConfigureAwait(false);
await StopConnection(token, ServerState.Unauthorized).ConfigureAwait(false);
return;
}
else
{
ServerState = ServerState.Offline;
ServerState = ServerState.Reconnecting;
Logger.Info("Failed to establish connection, retrying");
await Task.Delay(TimeSpan.FromSeconds(new Random().Next(5, 20)), token).ConfigureAwait(false);
}
@@ -267,12 +232,6 @@ public partial class ApiController : IDisposable, IMareHubClient
}
}
private Task MareHubOnReconnected(string? arg)
{
_ = Task.Run(() => CreateConnections(false));
return Task.CompletedTask;
}
private async Task ClientHealthCheck(CancellationToken ct)
{
while (!ct.IsCancellationRequested && _mareHub != null)
@@ -289,36 +248,55 @@ public partial class ApiController : IDisposable, IMareHubClient
}
}
private async Task InitializeData(CancellationToken token)
private async Task InitializeData()
{
if (_mareHub == null) return;
Logger.Debug("Initializing data");
OnUserUpdateClientPairs((dto) => Client_UserUpdateClientPairs(dto));
OnUserChangePairedPlayer((ident, online) => Client_UserChangePairedPlayer(ident, online));
OnUserReceiveCharacterData((dto, ident) => Client_UserReceiveCharacterData(dto, ident));
OnGroupChange(async (dto) => await Client_GroupChange(dto).ConfigureAwait(false));
OnGroupUserChange((dto) => Client_GroupUserChange(dto));
OnDownloadReady((guid) => Client_DownloadReady(guid));
OnReceiveServerMessage((sev, msg) => Client_ReceiveServerMessage(sev, msg));
OnUpdateSystemInfo((dto) => Client_UpdateSystemInfo(dto));
OnAdminForcedReconnect(() => Client_AdminForcedReconnect());
OnUserSendOffline((dto) => Client_UserSendOffline(dto));
OnUserAddClientPair((dto) => Client_UserAddClientPair(dto));
OnUserReceiveCharacterData((dto) => Client_UserReceiveCharacterData(dto));
OnUserRemoveClientPair(dto => Client_UserRemoveClientPair(dto));
OnUserSendOnline(dto => Client_UserSendOnline(dto));
OnUserUpdateOtherPairPermissions(dto => Client_UserUpdateOtherPairPermissions(dto));
OnUserUpdateSelfPairPermissions(dto => Client_UserUpdateSelfPairPermissions(dto));
PairedClients = await UserGetPairedClients().ConfigureAwait(false);
Groups = await GroupsGetAll().ConfigureAwait(false);
GroupPairedClients.Clear();
foreach (var group in Groups)
OnGroupChangePermissions((dto) => Client_GroupChangePermissions(dto));
OnGroupDelete((dto) => Client_GroupDelete(dto));
OnGroupPairChangePermissions((dto) => Client_GroupPairChangePermissions(dto));
OnGroupPairChangeUserInfo((dto) => Client_GroupPairChangeUserInfo(dto));
OnGroupPairJoined((dto) => Client_GroupPairJoined(dto));
OnGroupPairLeft((dto) => Client_GroupPairLeft(dto));
OnGroupSendFullInfo((dto) => Client_GroupSendFullInfo(dto));
OnGroupSendInfo((dto) => Client_GroupSendInfo(dto));
foreach (var userPair in await UserGetPairedClients().ConfigureAwait(false))
{
GroupPairedClients.AddRange(await GroupsGetUsersInGroup(group.GID).ConfigureAwait(false));
Logger.Debug($"Pair: {userPair}");
_pairManager.AddUserPair(userPair);
}
foreach (var entry in await GroupsGetAll().ConfigureAwait(false))
{
Logger.Debug($"Group: {entry}");
_pairManager.AddGroup(entry);
}
foreach (var group in _pairManager.GroupPairs.Keys)
{
var users = await GroupsGetUsersInGroup(group).ConfigureAwait(false);
foreach (var user in users)
{
Logger.Debug($"GroupPair: {user}");
_pairManager.AddGroupPair(user);
}
}
if (IsModerator)
foreach (var entry in await UserGetOnlinePairs().ConfigureAwait(false))
{
AdminForbiddenFiles = await AdminGetForbiddenFiles().ConfigureAwait(false);
AdminBannedUsers = await AdminGetBannedUsers().ConfigureAwait(false);
OnAdminUpdateOrAddBannedUser((dto) => Client_AdminUpdateOrAddBannedUser(dto));
OnAdminDeleteBannedUser((dto) => Client_AdminDeleteBannedUser(dto));
OnAdminUpdateOrAddForbiddenFile(dto => Client_AdminUpdateOrAddForbiddenFile(dto));
OnAdminDeleteForbiddenFile(dto => Client_AdminDeleteForbiddenFile(dto));
_pairManager.MarkPairOnline(entry, this);
}
_healthCheckTokenSource?.Cancel();
@@ -338,7 +316,7 @@ public partial class ApiController : IDisposable, IMareHubClient
_dalamudUtil.LogOut -= DalamudUtilOnLogOut;
ServerState = ServerState.Offline;
Task.Run(async () => await StopConnection(_connectionCancellationTokenSource.Token).ConfigureAwait(false));
Task.Run(async () => await StopConnection(_connectionCancellationTokenSource.Token, ServerState.Disconnected).ConfigureAwait(false));
_connectionCancellationTokenSource?.Cancel();
_healthCheckTokenSource?.Cancel();
_uploadCancellationTokenSource?.Cancel();
@@ -347,9 +325,9 @@ public partial class ApiController : IDisposable, IMareHubClient
private HubConnection BuildHubConnection(string hubName)
{
return new HubConnectionBuilder()
.WithUrl(ApiUri + hubName, options =>
.WithUrl(_serverManager.CurrentApiUrl + hubName, options =>
{
options.Headers.Add("Authorization", "Bearer " + Authorization);
options.Headers.Add("Authorization", "Bearer " + _serverManager.GetToken());
options.Transports = HttpTransportType.WebSockets | HttpTransportType.ServerSentEvents | HttpTransportType.LongPolling;
})
.WithAutomaticReconnect(new ForeverRetryPolicy())
@@ -366,7 +344,9 @@ public partial class ApiController : IDisposable, IMareHubClient
CurrentUploads.Clear();
CurrentDownloads.Clear();
_uploadCancellationTokenSource?.Cancel();
_healthCheckTokenSource?.Cancel();
Disconnected?.Invoke();
_pairManager.ClearPairs();
ServerState = ServerState.Offline;
Logger.Info("Connection closed");
return Task.CompletedTask;
@@ -376,16 +356,24 @@ public partial class ApiController : IDisposable, IMareHubClient
{
_connectionDto = null;
_healthCheckTokenSource?.Cancel();
ServerState = ServerState.Disconnected;
ServerState = ServerState.Reconnecting;
Logger.Warn("Connection closed... Reconnecting");
Logger.Warn(arg?.Message ?? string.Empty);
Logger.Warn(arg?.StackTrace ?? string.Empty);
Disconnected?.Invoke();
ServerState = ServerState.Offline;
_pairManager.ClearPairs();
return Task.CompletedTask;
}
private async Task StopConnection(CancellationToken token)
private async Task MareHubOnReconnected(string? arg)
{
ServerState = ServerState.Connecting;
await InitializeData().ConfigureAwait(false);
_connectionDto = await GetConnectionDto().ConfigureAwait(false);
ServerState = ServerState.Connected;
}
private async Task StopConnection(CancellationToken token, ServerState state)
{
if (_mareHub is not null)
{
@@ -401,15 +389,9 @@ public partial class ApiController : IDisposable, IMareHubClient
CurrentUploads.Clear();
CurrentDownloads.Clear();
Disconnected?.Invoke();
_pairManager.ClearPairs();
_mareHub = null;
}
if (ServerState != ServerState.Disconnected)
{
while (ServerState != ServerState.Offline)
{
await Task.Delay(16).ConfigureAwait(false);
}
ServerState = state;
}
}

5
MareSynchronos/WebAPI/ServerState.cs
View File

@@ -3,9 +3,12 @@
public enum ServerState
{
Offline,
Connecting,
Reconnecting,
Disconnected,
Connected,
Unauthorized,
VersionMisMatch,
RateLimited
RateLimited,
NoSecretKey,
}

16
MareSynchronos/WebAPI/Utils/CharacterReceivedEventArgs.cs
View File

@@ -1,16 +0,0 @@
using System;
using MareSynchronos.API;
namespace MareSynchronos.WebAPI.Utils;
public class CharacterReceivedEventArgs : EventArgs
{
public CharacterReceivedEventArgs(string characterNameHash, CharacterCacheDto characterData)
{
CharacterData = characterData;
CharacterNameHash = characterNameHash;
}
public CharacterCacheDto CharacterData { get; set; }
public string CharacterNameHash { get; set; }
}

17
MareSynchronos/WebAPI/Utils/DownloadFileTransfer.cs Normal file
View File

@@ -0,0 +1,17 @@
using MareSynchronos.API.Dto.Files;
namespace MareSynchronos.WebAPI.Utils;
public class DownloadFileTransfer : FileTransfer
{
private DownloadFileDto Dto => (DownloadFileDto)TransferDto;
public DownloadFileTransfer(DownloadFileDto dto) : base(dto) { }
public Uri DownloadUri => new(Dto.Url);
public override long Total
{
set { }
get => Dto.Size;
}
public override bool CanBeTransferred => Dto.FileExists && !Dto.IsForbidden && Dto.Size > 0;
}

24
MareSynchronos/WebAPI/Utils/FileTransfer.cs
View File

@@ -1,5 +1,4 @@
using MareSynchronos.API;
using System;
using MareSynchronos.API.Dto.Files;
namespace MareSynchronos.WebAPI.Utils;
@@ -26,24 +25,3 @@ public abstract class FileTransfer
return Hash;
}
}
public class UploadFileTransfer : FileTransfer
{
public UploadFileTransfer(UploadFileDto dto) : base(dto) { }
public override long Total { get; set; }
public string LocalFile { get; set; } = string.Empty;
}
public class DownloadFileTransfer : FileTransfer
{
private DownloadFileDto Dto => (DownloadFileDto)TransferDto;
public DownloadFileTransfer(DownloadFileDto dto) : base(dto) { }
public Uri DownloadUri => new(Dto.Url);
public override long Total
{
set { }
get => Dto.Size;
}
public override bool CanBeTransferred => Dto.FileExists && !Dto.IsForbidden && Dto.Size > 0;
}

3
MareSynchronos/WebAPI/Utils/ForeverRetryPolicy.cs
View File

@@ -1,5 +1,4 @@
using System;
using Microsoft.AspNetCore.SignalR.Client;
using Microsoft.AspNetCore.SignalR.Client;
namespace MareSynchronos.WebAPI.Utils;

10
MareSynchronos/WebAPI/Utils/UploadFileTransfer.cs Normal file
View File

@@ -0,0 +1,10 @@
using MareSynchronos.API.Dto.Files;
namespace MareSynchronos.WebAPI.Utils;
public class UploadFileTransfer : FileTransfer
{
public UploadFileTransfer(UploadFileDto dto) : base(dto) { }
public override long Total { get; set; }
public string LocalFile { get; set; } = string.Empty;
}