public async Task Execute(IJobExecutionContext context)
{
try
{
if (connectionManager.GetCount() > 0)
{
foreach (var WebSocketitem in connectionManager.GetAll().Values)
{
long interval = UTC.ConvertDateTimeLong(DateTime.Now) - UTC.ConvertDateTimeLong(WebSocketitem.HeartbeatTime);
if (interval >= 60)
{
await connectionManager.RemoveSocket(WebSocketitem.Guid);
}
else if (interval >= 10)
{
WebSocketitem.connectstate = false;
}
}
}
}
catch (Exception ex)
{
logger.LogError(ex.Message, ex);
}
}
public override async Task OnConnected(WebSocket socket)
{
await base.OnConnected(socket);
var socketId = WebSocketConnectionManager.GetId(socket);
var otherSocketIds = WebSocketConnectionManager
.GetAll()
.Where(it => it.Key != socketId)
.Select(it => it.Key);
var userDataMessageArgs = new UserDataMessageArgs
{
Id = socketId,
X = 1,
Y = 1,
Enemies = otherSocketIds,
EnemiesX = otherSocketIds.Select(it => 1),
EnemiesY = otherSocketIds.Select(it => 1)
};
await SendMessageAsync(socketId, WebSocketEvent.UserData, userDataMessageArgs);
var userConnectedMessageArgs = new UserConnectedMessageArgs
{
Id = socketId,
X = 1,
Y = 1
};
await SendMessageToAsync(WebSocketEvent.UserConnected, userConnectedMessageArgs, it => it != socketId);
}
public async Task SendMessageToAllAsync(SendFormat message)
{
foreach (var pair in _connectionManager.GetAll())
{
if (pair.State == WebSocketState.Open)
{
await SendMessageAsync(pair, message).ConfigureAwait(false);
}
}
}
public async Task SendMessageToAllAsync(string message)
{
foreach (var pair in WebSocketConnectionManager.GetAll())
{
if (pair.Value.Socket.State == WebSocketState.Open)
{
await SendMessageAsync(pair.Value, message);
}
}
}
public async Task InvokeAsync(HttpContext context)
{
_unitOfWork = context.RequestServices.GetRequiredService <IUnitOfWork>() as UnitOfWork;
_config = context.RequestServices.GetRequiredService <IConfiguration>();
var token = context.Request.Query.Extract(Token);
if (!context.WebSockets.IsWebSocketRequest)
{
await _next(context);
return;
}
if (token == null)
{
await _next(context);
return;
}
if (!Extensions.Extensions.AuthenticateJwt(token, _config))
{
await _next(context);
return;
}
var roomId = Convert.ToInt32(token.GetIdentityFromToken(_config).ExtractRoomId());
var userId = Convert.ToInt32(token.GetIdentityFromToken(_config).ExtractUserId());
var socket = await context.WebSockets.AcceptWebSocketAsync();
var id = _manager.AddSocket(socket);
var dbSocket = new Socket
{
SocketId = id,
UserId = userId
};
await _unitOfWork.SocketRepository.AddSocketAsync(dbSocket);
await _unitOfWork.CommitAsync();
if (id != null)
{
if (socket.State == WebSocketState.Open)
{
await socket.SendAsync(Encoding.UTF8.GetBytes(id), WebSocketMessageType.Text, true, CancellationToken.None);
}
}
await Receive(socket, async (result, buffer) =>
{
switch (result.MessageType)
{
case WebSocketMessageType.Text:
await RouteJSONMessageAsync(Encoding.UTF8.GetString(buffer, 0, result.Count), roomId, userId);
return;
case WebSocketMessageType.Close:
var id = _manager.GetAll().FirstOrDefault(x => x.Value == socket).Key;
WebSocket sock;
_manager.GetAll().TryRemove(id, out sock);
await sock.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
return;
}
});
}
public async Task <MessageModel <List <WebSocketModel> > > Query()
{
await Task.CompletedTask;
return(new MessageModel <List <WebSocketModel> >(connectionManager.GetAll().Values.OrderByDescending(p => p.connectTime).ToList()));
}
