SolarNetwork/Swarm
2
3
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

♻️ Refactor the way to handle websocket

Browse Source
This commit is contained in:
LittleSheep
2025-09-21 23:07:20 +08:00
parent e3657386cd
commit 204640a759
13 changed files with 196 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
DysonNetwork.Sphere/Chat/ChatService.cs
View File

@@ -5,6 +5,7 @@ using DysonNetwork.Sphere.Chat.Realtime;
using DysonNetwork.Sphere.WebReader;
using Microsoft.EntityFrameworkCore;
using NodaTime;
using WebSocketPacket = DysonNetwork.Shared.Proto.WebSocketPacket;
namespace DysonNetwork.Sphere.Chat;

128
DysonNetwork.Sphere/Connection/WebsocketHandler.cs
View File

@@ -1,128 +0,0 @@
using DysonNetwork.Shared.Cache;
using DysonNetwork.Shared.Proto;
using DysonNetwork.Sphere.Chat;
using Google.Protobuf.WellKnownTypes;
using Grpc.Core;
namespace DysonNetwork.Sphere.Connection;
public class WebSocketHandlerGrpc(RingService.RingServiceClient pusher, ChatRoomService crs, ChatService cs)
: RingHandlerService.RingHandlerServiceBase
{
public override async Task<Empty> ReceiveWebSocketPacket(
ReceiveWebSocketPacketRequest request,
ServerCallContext context
)
{
switch (request.Packet.Type)
{
case "messages.read":
await HandleMessageRead(request, context);
break;
case "messages.typing":
await HandleMessageTyping(request, context);
break;
}
return new Empty();
}
private async Task HandleMessageRead(ReceiveWebSocketPacketRequest request, ServerCallContext context)
{
var currentUser = request.Account;
var packet = request.Packet;
if (packet.Data == null)
{
await SendErrorResponse(
request,
"Mark message as read requires you to provide the ChatRoomId"
);
return;
}
var requestData = GrpcTypeHelper.ConvertByteStringToObject<ChatController.MarkMessageReadRequest>(packet.Data);
if (requestData == null)
{
await SendErrorResponse(request, "Invalid request data");
return;
}
var sender = await crs.GetRoomMember(
Guid.Parse(currentUser.Id),
requestData.ChatRoomId
);
if (sender == null)
{
await SendErrorResponse(request, "User is not a member of the chat room.");
return;
}
await cs.ReadChatRoomAsync(requestData.ChatRoomId, Guid.Parse(currentUser.Id));
}
private async Task HandleMessageTyping(ReceiveWebSocketPacketRequest request, ServerCallContext context)
{
var currentUser = request.Account;
var packet = request.Packet;
if (packet.Data == null)
{
await SendErrorResponse(request, "messages.typing requires you to provide the ChatRoomId");
return;
}
var requestData = GrpcTypeHelper.ConvertByteStringToObject<ChatController.ChatRoomWsUniversalRequest>(packet.Data);
if (requestData == null)
{
await SendErrorResponse(request, "Invalid request data");
return;
}
var sender = await crs.GetRoomMember(
Guid.Parse(currentUser.Id),
requestData.ChatRoomId
);
if (sender == null)
{
await SendErrorResponse(request, "User is not a member of the chat room.");
return;
}
var responsePacket = new WebSocketPacket
{
Type = "messages.typing",
Data = GrpcTypeHelper.ConvertObjectToByteString(new
{
room_id = sender.ChatRoomId,
sender_id = sender.Id,
sender = sender
})
};
// Broadcast typing indicator to other room members
var otherMembers = (await crs.ListRoomMembers(requestData.ChatRoomId))
.Where(m => m.AccountId != Guid.Parse(currentUser.Id))
.Select(m => m.AccountId.ToString())
.ToList();
var respRequest = new PushWebSocketPacketToUsersRequest() { Packet = responsePacket };
respRequest.UserIds.AddRange(otherMembers);
await pusher.PushWebSocketPacketToUsersAsync(respRequest);
}
private async Task SendErrorResponse(ReceiveWebSocketPacketRequest request, string message)
{
await pusher.PushWebSocketPacketToDeviceAsync(new PushWebSocketPacketToDeviceRequest
{
DeviceId = request.DeviceId,
Packet = new WebSocketPacket
{
Type = "error",
ErrorMessage = message
}
});
}
}

2
DysonNetwork.Sphere/Startup/ApplicationConfiguration.cs
View File

@@ -1,6 +1,5 @@
using DysonNetwork.Shared.Auth;
using DysonNetwork.Shared.Http;
using DysonNetwork.Sphere.Connection;
using DysonNetwork.Sphere.Publisher;
using Prometheus;
@@ -28,7 +27,6 @@ public static class ApplicationConfiguration
app.MapControllers();
// Map gRPC services
app.MapGrpcService<WebSocketHandlerGrpc>();
app.MapGrpcService<PublisherServiceGrpc>();
return app;

133
DysonNetwork.Sphere/Startup/BroadcastEventHandler.cs
View File

@@ -2,11 +2,14 @@ using System.Text.Json;
using System.Text.Json.Serialization;
using DysonNetwork.Shared.Proto;
using DysonNetwork.Shared.Stream;
using DysonNetwork.Sphere.Chat;
using DysonNetwork.Sphere.Post;
using DysonNetwork.Sphere.Realm;
using Microsoft.EntityFrameworkCore;
using NATS.Client.Core;
using NATS.Client.JetStream.Models;
using NATS.Net;
using WebSocketPacket = DysonNetwork.Shared.Data.WebSocketPacket;
namespace DysonNetwork.Sphere.Startup;
@@ -25,17 +28,19 @@ public class PaymentOrderAwardMeta
}
public class BroadcastEventHandler(
INatsConnection nats,
IServiceProvider serviceProvider,
ILogger<BroadcastEventHandler> logger,
IServiceProvider serviceProvider
INatsConnection nats,
RingService.RingServiceClient pusher
) : BackgroundService
{
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var paymentTask = HandlePaymentOrders(stoppingToken);
var accountTask = HandleAccountDeletions(stoppingToken);
var websocketTask = HandleWebSocketPackets(stoppingToken);
await Task.WhenAll(paymentTask, accountTask);
await Task.WhenAll(paymentTask, accountTask, websocketTask);
}
private async Task HandlePaymentOrders(CancellationToken stoppingToken)
@@ -53,7 +58,7 @@ public class BroadcastEventHandler(
try
{
evt = JsonSerializer.Deserialize<PaymentOrderEvent>(msg.Data, GrpcTypeHelper.SerializerOptions);
logger.LogInformation(
"Received order event: {ProductIdentifier} {OrderId}",
evt?.ProductIdentifier,
@@ -101,9 +106,9 @@ public class BroadcastEventHandler(
private async Task HandleAccountDeletions(CancellationToken stoppingToken)
{
var js = nats.CreateJetStreamContext();
await js.EnsureStreamCreated("account_events", [AccountDeletedEvent.Type]);
var consumer = await js.CreateOrUpdateConsumerAsync("account_events",
new ConsumerConfig("sphere_account_deleted_handler"), cancellationToken: stoppingToken);
@@ -165,4 +170,120 @@ public class BroadcastEventHandler(
}
}
}
private async Task HandleWebSocketPackets(CancellationToken stoppingToken)
{
await foreach (var msg in nats.SubscribeAsync<WebSocketPacketEvent>(
WebSocketPacketEvent.SubjectPrefix + "sphere", cancellationToken: stoppingToken))
{
try
{
var evt = msg.Data;
var packet = WebSocketPacket.FromBytes(evt.PacketBytes);
switch (packet.Type)
{
case "messages.read":
await HandleMessageRead(evt, packet);
break;
case "messages.typing":
await HandleMessageTyping(evt, packet);
break;
}
}
catch (Exception ex)
{
logger.LogError(ex, "Error processing websocket packet");
}
}
}
private async Task HandleMessageRead(WebSocketPacketEvent evt, WebSocketPacket packet)
{
using var scope = serviceProvider.CreateScope();
var cs = scope.ServiceProvider.GetRequiredService<ChatService>();
var crs = scope.ServiceProvider.GetRequiredService<ChatRoomService>();
if (packet.Data == null)
{
await SendErrorResponse(evt, "Mark message as read requires you to provide the ChatRoomId");
return;
}
var requestData = packet.GetData<ChatController.MarkMessageReadRequest>();
if (requestData == null)
{
await SendErrorResponse(evt, "Invalid request data");
return;
}
var sender = await crs.GetRoomMember(evt.AccountId, requestData.ChatRoomId);
if (sender == null)
{
await SendErrorResponse(evt, "User is not a member of the chat room.");
return;
}
await cs.ReadChatRoomAsync(requestData.ChatRoomId, evt.AccountId);
}
private async Task HandleMessageTyping(WebSocketPacketEvent evt, WebSocketPacket packet)
{
using var scope = serviceProvider.CreateScope();
var crs = scope.ServiceProvider.GetRequiredService<ChatRoomService>();
if (packet.Data == null)
{
await SendErrorResponse(evt, "messages.typing requires you to provide the ChatRoomId");
return;
}
var requestData = packet.GetData<ChatController.ChatRoomWsUniversalRequest>();
if (requestData == null)
{
await SendErrorResponse(evt, "Invalid request data");
return;
}
var sender = await crs.GetRoomMember(evt.AccountId, requestData.ChatRoomId);
if (sender == null)
{
await SendErrorResponse(evt, "User is not a member of the chat room.");
return;
}
var responsePacket = new WebSocketPacket
{
Type = "messages.typing",
Data = GrpcTypeHelper.ConvertObjectToByteString(new
{
room_id = sender.ChatRoomId,
sender_id = sender.Id,
sender = sender
})
};
// Broadcast typing indicator to other room members
var otherMembers = (await crs.ListRoomMembers(requestData.ChatRoomId))
.Where(m => m.AccountId != evt.AccountId)
.Select(m => m.AccountId.ToString())
.ToList();
var respRequest = new PushWebSocketPacketToUsersRequest() { Packet = responsePacket.ToProtoValue() };
respRequest.UserIds.AddRange(otherMembers);
await pusher.PushWebSocketPacketToUsersAsync(respRequest);
}
private async Task SendErrorResponse(WebSocketPacketEvent evt, string message)
{
await pusher.PushWebSocketPacketToDeviceAsync(new PushWebSocketPacketToDeviceRequest
{
DeviceId = evt.DeviceId,
Packet = new WebSocketPacket
{
Type = "error",
ErrorMessage = message
}.ToProtoValue()
});
}
}