protected override void OnMessage(MessageEventArgs e)
{
if (e.IsPing)
{
WsRoot.MinerStudioSessionSet.ActiveByWsSessionId(base.ID, out _);
return;
}
WsMessage message = e.ToWsMessage <WsMessage>();
if (message == null)
{
return;
}
if (!WsRoot.MinerStudioSessionSet.TryGetByWsSessionId(this.ID, out IMinerStudioSession minerSession))
{
this.CloseAsync(CloseStatusCode.Normal, "意外，会话不存在，请重新连接");
return;
}
if (!minerSession.IsValid(message))
{
this.CloseAsync(CloseStatusCode.Normal, "意外，签名验证失败，请重新连接");
return;
}
if (message.Type == WsMessage.QueryClientDatas)
{
if (message.TryGetData(out QueryClientsRequest query))
{
// 走的内网，因为WsServer启动时会设置内网Rpc地址
RpcRoot.OfficialServer.ClientDataBinaryService.QueryClientsForWsAsync(QueryClientsForWsRequest.Create(query, minerSession.LoginName), (QueryClientsResponse response, Exception ex) => {
if (response.IsSuccess())
{
var userData = WsRoot.ReadOnlyUserSet.GetUser(UserId.CreateLoginNameUserId(minerSession.LoginName));
if (userData != null)
{
this.SendAsync(new WsMessage(Guid.NewGuid(), WsMessage.ClientDatas)
{
Data = response
}.SignToBytes(userData.Password), completed: null);
}
}
});
}
return;
}
if (MinerStudioWsMessageHandler.TryGetHandler(message.Type, out Action <string, WsMessage> handler))
{
try {
handler.Invoke(minerSession.LoginName, message);
}
catch (Exception ex) {
Logger.ErrorDebugLine(ex);
}
}
else
{
NTMinerConsole.UserWarn($"{_behaviorName} {nameof(OnMessage)} Received InvalidType {e.Data}");
}
}
public static void HandleMinerStudioMessage(IWsSessionAdapter session, WsMessage message)
{
if (message == null)
{
return;
}
if (!WsRoot.MinerStudioSessionSet.TryGetByWsSessionId(session.SessionId, out IMinerStudioSession minerSession))
{
session.CloseAsync(WsCloseCode.Normal, "意外，会话不存在，请重新连接");
return;
}
if (!minerSession.IsValid(message))
{
session.CloseAsync(WsCloseCode.Normal, "意外，签名验证失败，请重新连接");
return;
}
if (message.Type == WsMessage.QueryClientDatas)
{
if (message.TryGetData(out QueryClientsRequest query))
{
// 走的内网，因为WsServer启动时会设置内网Rpc地址
RpcRoot.OfficialServer.ClientDataBinaryService.QueryClientsForWsAsync(QueryClientsForWsRequest.Create(query, minerSession.LoginName), (QueryClientsResponse response, Exception ex) => {
if (response.IsSuccess())
{
var userData = WsRoot.ReadOnlyUserSet.GetUser(UserId.CreateLoginNameUserId(minerSession.LoginName));
if (userData != null)
{
session.SendAsync(new WsMessage(Guid.NewGuid(), WsMessage.ClientDatas)
{
Data = response
}.SignToBytes(userData.Password));
}
}
});
}
return;
}
if (MinerStudioWsMessageHandler.TryGetHandler(message.Type, out Action <string, WsMessage> handler))
{
try {
handler.Invoke(minerSession.LoginName, message);
}
catch (Exception ex) {
Logger.ErrorDebugLine(ex);
}
}
else
{
NTMinerConsole.UserWarn($"{session.TypeName} {nameof(HandleMinerStudioMessage)} Received InvalidType {message.Type}");
}
}
public void SendToMinerStudioAsync(string loginName, WsMessage message)
{
// TODO:考虑给每一个登录的MinerStudio用户建立一个会话，由基于LoginName推送改为基于会话Id推送
var minerStudioSessions = GetSessionsByLoginName(loginName).ToArray();// 避免发生集合被修改的异常
var userData = AppRoot.UserSet.GetUser(UserId.CreateLoginNameUserId(loginName));
if (userData != null)
{
foreach (var minerStudioSession in minerStudioSessions)
{
minerStudioSession.SendAsync(message, userData.Password);
}
}
}
public bool IsValid(WsMessage message)
{
if (message == null || string.IsNullOrEmpty(message.Sign))
{
return(false);
}
var userData = WsRoot.ReadOnlyUserSet.GetUser(UserId.CreateLoginNameUserId(this.LoginName));
if (userData == null)
{
return(false);
}
return(message.Sign == message.CalcSign(userData.Password));
}
public void SendToMinerStudioAsync(string loginName, WsMessage message)
{
// TODO:考虑给每一个登录的MinerStudio用户建立一个会话，由基于LoginName推送改为基于会话Id推送
var minerStudioSessions = GetSessionsByLoginName(loginName).ToArray();// 避免发生集合被修改的异常
var userData = AppRoot.UserSet.GetUser(UserId.CreateLoginNameUserId(loginName));
if (userData != null)
{
foreach (var minerStudioSession in minerStudioSessions)
{
ServerRoot.IfStudioClientTestIdLogElseNothing(minerStudioSession.ClientId, $"{nameof(WsMessage)}.{message.Type}");
minerStudioSession.SendAsync(message, userData.Password);
}
}
}
public void SendToMinerStudioAsync(string loginName, WsMessage message)
{
var minerStudioSessions = GetSessionsByLoginName(loginName).ToArray();// 避免发生集合被修改的异常
foreach (var minerStudioSession in minerStudioSessions)
{
var userData = WsRoot.ReadOnlyUserSet.GetUser(UserId.CreateLoginNameUserId(minerStudioSession.LoginName));
if (userData != null)
{
try {
minerStudioSession.SendAsync(message, userData.Password);
}
catch {
}
}
}
}
public HttpResponseMessage QueryClientsForWs([FromBody] QueryClientsForWsRequest request)
{
QueryClientsResponse response;
if (request == null)
{
response = ResponseBase.InvalidInput <QueryClientsResponse>("参数错误");
}
else
{
request.PagingTrim();
try {
var user = WebApiRoot.UserSet.GetUser(UserId.CreateLoginNameUserId(request.LoginName));
if (user == null)
{
response = ResponseBase.InvalidInput <QueryClientsResponse>("用户不存在");
}
else
{
var data = WebApiRoot.ClientDataSet.QueryClients(
user,
request,
out int total,
out CoinSnapshotData[] latestSnapshots,
out int totalOnlineCount,
out int totalMiningCount) ?? new List <ClientData>();
response = QueryClientsResponse.Ok(data, total, latestSnapshots, totalMiningCount, totalOnlineCount);
}
}
catch (Exception e) {
Logger.ErrorDebugLine(e);
response = ResponseBase.ServerError <QueryClientsResponse>(e.Message);
}
}
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ByteArrayContent(VirtualRoot.BinarySerializer.Serialize(response))
};
httpResponseMessage.Content.Headers.ContentType = WebApiRoot.BinaryContentType;
return(httpResponseMessage);
}
public void SendToMinerStudioAsync(string loginName, WsMessage message)
{
List <IMinerStudioSession> minerStudioSessions = GetSessionsByLoginName(loginName);
if (TryGetWsSessions(out WebSocketSessionManager wsSessionManager))
{
foreach (var minerStudioSession in minerStudioSessions)
{
var userData = WsRoot.ReadOnlyUserSet.GetUser(UserId.CreateLoginNameUserId(minerStudioSession.LoginName));
if (userData != null)
{
try {
wsSessionManager.SendToAsync(message.SignToJson(userData.Password), minerStudioSession.WsSessionId, completed: null);
}
catch {
}
}
}
}
}
private void SendReGetServerAddressMessage(string[] nodeAddresses)
{
if (nodeAddresses == null || nodeAddresses.Length == 0)
{
return;
}
var thisNodeIp = ServerRoot.HostConfig.ThisServerAddress;
ShardingHasher hash = new ShardingHasher(nodeAddresses);
List <TSession> needReGetServerAddressSessions;
lock (_locker) {
needReGetServerAddressSessions = _dicByWsSessionId.Values.Where(a => hash.GetTargetNode(a.ClientId) != thisNodeIp).ToList();
}
if (needReGetServerAddressSessions.Count != 0)
{
foreach (var session in needReGetServerAddressSessions)
{
string password = null;
if (_isMinerClient)
{
password = ((IMinerClientSession)session).GetSignPassword();
}
else if (_isMinerStudio)
{
var userData = WsRoot.ReadOnlyUserSet.GetUser(UserId.CreateLoginNameUserId(session.LoginName));
if (userData != null)
{
password = userData.Password;
}
}
if (!string.IsNullOrEmpty(password))
{
try {
session.SendAsync(new WsMessage(Guid.NewGuid(), WsMessage.ReGetServerAddress), password);
}
catch {
}
}
}
}
}
protected static bool IsValid(Guid clientId, DateTime timestamp, string loginName)
{
if (clientId == Guid.Empty)
{
return(false);
}
if (IsTooOld(timestamp))
{
return(false);
}
IUser user = WsRoot.ReadOnlyUserSet.GetUser(UserId.CreateLoginNameUserId(loginName));
if (user == null || !user.IsEnabled)
{
return(false);
}
if (!WsRoot.MinerSignSet.TryGetByClientId(clientId, out MinerSign minerSign) || !minerSign.IsOwnerBy(user))
{
return(false);
}
return(true);
}
public static string GetSignPassword(this ISession session)
{
string password = null;
switch (session.WsUserName.ClientType)
{
case NTMinerAppType.MinerClient:
password = ((IMinerClientSession)session).GetSignPassword();
break;
case NTMinerAppType.MinerStudio:
var userData = UserSet.GetUser(UserId.CreateLoginNameUserId(session.LoginName));
if (userData != null)
{
password = userData.Password;
}
break;
default:
break;
}
return(password);
}
public static QueryClientsResponse QueryClientsForWs(QueryClientsForWsRequest request)
{
QueryClientsResponse response;
if (request == null)
{
response = ResponseBase.InvalidInput <QueryClientsResponse>("参数错误");
}
else
{
request.PagingTrim();
try {
var user = UserSet.GetUser(UserId.CreateLoginNameUserId(request.LoginName));
if (user == null)
{
response = ResponseBase.InvalidInput <QueryClientsResponse>("用户不存在");
}
else
{
var data = ClientDataSet.QueryClients(
user,
request,
out int total,
out CoinSnapshotData[] latestSnapshots,
out int totalOnlineCount,
out int totalMiningCount) ?? new List <ClientData>();
response = QueryClientsResponse.Ok(data, total, latestSnapshots, totalMiningCount, totalOnlineCount);
}
}
catch (Exception e) {
Logger.ErrorDebugLine(e);
response = ResponseBase.ServerError <QueryClientsResponse>(e.Message);
}
}
return(response);
}
public ResponseBase DisableUser([FromBody] DataRequest <string> request)
{
if (request == null || string.IsNullOrEmpty(request.Data))
{
return(ResponseBase.InvalidInput <DataResponse <string> >("参数错误"));
}
var user = AppRoot.UserSet.GetUser(UserId.CreateLoginNameUserId(request.Data));
if (user == null)
{
return(ResponseBase.NotExist($"登录名 {request.Data} 不存在"));
}
if (user.IsAdmin())
{
return(ResponseBase.InvalidInput <DataResponse <string> >("不能操作admin"));
}
try {
AppRoot.UserSet.Disable(request.Data);
return(ResponseBase.Ok("禁用成功"));
}
catch (Exception e) {
return(ResponseBase.ServerError(e.Message));
}
}
public ResponseBase RemoveUser([FromBody] DataRequest <string> request)
{
if (request == null || string.IsNullOrEmpty(request.Data))
{
return(ResponseBase.InvalidInput <DataResponse <string> >("参数错误"));
}
var user = WebApiRoot.UserSet.GetUser(UserId.CreateLoginNameUserId(request.Data));
if (user == null)
{
return(ResponseBase.Ok("删除成功"));
}
if (user.IsAdmin())
{
return(ResponseBase.InvalidInput <DataResponse <string> >("不能操作admin"));
}
try {
WebApiRoot.UserSet.Remove(request.Data);
return(ResponseBase.Ok("删除成功"));
}
catch (Exception e) {
return(ResponseBase.ServerError(e.Message));
}
}
public MinerClientSessionSet(IWsSessionsAdapter wsSessions) : base(wsSessions)
{
VirtualRoot.BuildEventPath <GetConsoleOutLinesMqEvent>("收到GetConsoleOutLines Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetConsoleOutLines)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <GetLocalMessagesMqEvent>("收到GetLocalMessages Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetLocalMessages)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <GetDrivesMqEvent>("收到GetDrives Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetDrives));
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <GetLocalIpsMqEvent>("收到GetLocalIps Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetLocalIps));
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <GetOperationResultsMqEvent>("收到GetOperationResults Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetOperationResults)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <GetSpeedMqEvent>("收到GetSpeedMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (message.ClientIds == null || message.ClientIds.Count == 0)
{
return;
}
if (IsTooOld(message.Timestamp))
{
return;
}
IUser user = AppRoot.UserSet.GetUser(UserId.CreateLoginNameUserId(message.LoginName));
if (user == null)
{
return;
}
foreach (var clientId in message.ClientIds.Where(a => TryGetByClientId(a, out _)))
{
if (clientId == null || clientId == Guid.Empty)
{
continue;
}
if (!AppRoot.MinerSignSet.TryGetByClientId(clientId, out MinerSign minerSign) || !minerSign.IsOwnerBy(user))
{
continue;
}
SendToMinerClientAsync(clientId, new WsMessage(message.MessageId, WsMessage.GetSpeed));
}
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <EnableRemoteDesktopMqEvent>("收到EnableRemoteDesktopMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.EnableRemoteDesktop));
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <BlockWAUMqEvent>("收到BlockWAUMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.BlockWAU));
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <SetVirtualMemoryMqEvent>("收到SetVirtualMemoryMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SetVirtualMemory)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <SetLocalIpsMqEvent>("收到SetLocalIpsMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SetLocalIps)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <SwitchRadeonGpuMqEvent>("收到SwitchRadeonGpuMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SwitchRadeonGpu)
{
Data = message.On
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <GetSelfWorkLocalJsonMqEvent>("收到GetSelfWorkLocalJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetSelfWorkLocalJson));
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <SaveSelfWorkLocalJsonMqEvent>("收到SaveSelfWorkLocalJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SaveSelfWorkLocalJson)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <GetGpuProfilesJsonMqEvent>("收到GetGpuProfilesJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetGpuProfilesJson));
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <SaveGpuProfilesJsonMqEvent>("收到SaveGpuProfilesJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SaveGpuProfilesJson)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <SetAutoBootStartMqEvent>("收到SetAutoBootStartMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SetAutoBootStart)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <RestartWindowsMqEvent>("收到RestartWindowsMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.RestartWindows));
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <ShutdownWindowsMqEvent>("收到ShutdownWindowsMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.ShutdownWindows));
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <UpgradeNTMinerMqEvent>("收到UpgradeNTMinerMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.UpgradeNTMiner)
{
Data = message.Data
});
#endregion
}, this.GetType());
// WsServer节点和WebApiServer节点都订阅了该消息，WsServer节点只处理非作业消息，WebApiServer节点只处理作业消息
VirtualRoot.BuildEventPath <StartMineMqEvent>("收到StartMineMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
Guid workId = message.Data;
// 只处理非作业的
if (workId == Guid.Empty)
{
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.StartMine)
{
Data = new WorkRequest {
WorkId = workId,
WorkerName = string.Empty,
LocalJson = string.Empty,
ServerJson = string.Empty
}
});
}
#endregion
}, this.GetType());
// WebApiServer节点订阅了StartMineMqMessage消息，当StartMineMqMessage消息是作业消息时WebApiServer节点重新广播StartWorkMineMqMessage消息
VirtualRoot.BuildEventPath <StartWorkMineMqEvent>("收到StartWorkMineMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.StartMine)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <StopMineMqEvent>("收到StopMineMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.StopMine));
#endregion
}, this.GetType());
}
public MinerStudioSessionSet(IWsSessionsAdapter wsSessions) : base(wsSessions)
{
VirtualRoot.BuildEventPath <UserPasswordChangedMqEvent>("群控用户密码变更后通知群控客户端重新登录", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.ReLogin));
});
VirtualRoot.BuildEventPath <ConsoleOutLinesMqEvent>("收到ConsoleOutLinesMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (IsTooOld(message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(ConsoleOutLinesMqEvent));
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.ConsoleOutLines)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
});
VirtualRoot.BuildEventPath <LocalMessagesMqEvent>("收到LocalMessagesMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (IsTooOld(message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(LocalMessagesMqEvent));
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.LocalMessages)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
});
VirtualRoot.BuildEventPath <DrivesMqEvent>("收到DrivesMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (IsTooOld(message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(DrivesMqEvent));
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.Drives)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
});
VirtualRoot.BuildEventPath <LocalIpsMqEvent>("收到LocalIpsMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (IsTooOld(message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(LocalIpsMqEvent));
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.LocalIps)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
});
VirtualRoot.BuildEventPath <OperationResultsMqEvent>("收到OperationResultsMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (IsTooOld(message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(OperationResultsMqEvent));
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.OperationResults)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
});
VirtualRoot.BuildEventPath <OperationReceivedMqEvent>("收到OperationReceivedMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (IsTooOld(message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(OperationReceivedMqEvent));
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.OperationReceived)
{
Data = new WrapperClientId {
ClientId = message.ClientId
}
});
#endregion
});
VirtualRoot.BuildEventPath <LocalJsonMqEvent>("收到LocalJsonMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (IsTooOld(message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(LocalJsonMqEvent));
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.SelfWorkLocalJson)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
});
VirtualRoot.BuildEventPath <GpuProfilesJsonMqEvent>("收到GpuProfilesJsonMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (IsTooOld(message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(GpuProfilesJsonMqEvent));
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.GpuProfilesJson)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
});
VirtualRoot.BuildEventPath <QueryClientsForWsResponseMqEvent>("收到QueryClientsResponseMq消息后通过Ws通道发送给群控客户端", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (IsTooOld(message.Timestamp))
{
return;
}
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(QueryClientsForWsResponseMqEvent));
var userData = AppRoot.UserSet.GetUser(UserId.CreateLoginNameUserId(message.LoginName));
if (userData != null && wsSessions.TryGetSession(message.SessionId, out IWsSessionAdapter session))
{
session.SendAsync(new WsMessage(Guid.NewGuid(), WsMessage.ClientDatas)
{
Data = message.Response
}.SignToBytes(userData.Password));
}
#endregion
});
}
public MinerClientSessionSet(WebSocketSessionManager wsSessionManager) : base(wsSessionManager)
{
VirtualRoot.AddEventPath <GetConsoleOutLinesMqMessage>("收到GetConsoleOutLines Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetConsoleOutLines)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <GetLocalMessagesMqMessage>("收到GetLocalMessages Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetLocalMessages)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <GetDrivesMqMessage>("收到GetDrives Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetDrives));
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <GetLocalIpsMqMessage>("收到GetLocalIps Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetLocalIps));
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <GetOperationResultsMqMessage>("收到GetOperationResults Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetOperationResults)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <GetSpeedMqMessage>("收到GetSpeedMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (message.ClientIds == null || message.ClientIds.Count == 0)
{
return;
}
if (IsTooOld(message.Timestamp))
{
return;
}
IUser user = WsRoot.ReadOnlyUserSet.GetUser(UserId.CreateLoginNameUserId(message.LoginName));
if (user == null)
{
return;
}
foreach (var clientId in message.ClientIds)
{
if (clientId == null || clientId == Guid.Empty)
{
continue;
}
if (!WsRoot.MinerSignSet.TryGetByClientId(clientId, out MinerSign minerSign) || !minerSign.IsOwnerBy(user))
{
continue;
}
SendToMinerClientAsync(clientId, new WsMessage(message.MessageId, WsMessage.GetSpeed));
}
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <EnableRemoteDesktopMqMessage>("收到EnableRemoteDesktopMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.EnableRemoteDesktop));
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <BlockWAUMqMessage>("收到BlockWAUMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.BlockWAU));
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <SetVirtualMemoryMqMessage>("收到SetVirtualMemoryMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SetVirtualMemory)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <SetLocalIpsMqMessage>("收到SetLocalIpsMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SetLocalIps)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <SwitchRadeonGpuMqMessage>("收到SwitchRadeonGpuMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SwitchRadeonGpu)
{
Data = message.On
});
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <GetSelfWorkLocalJsonMqMessage>("收到GetSelfWorkLocalJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetSelfWorkLocalJson));
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <SaveSelfWorkLocalJsonMqMessage>("收到SaveSelfWorkLocalJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SaveSelfWorkLocalJson)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <GetGpuProfilesJsonMqMessage>("收到GetGpuProfilesJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetGpuProfilesJson));
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <SaveGpuProfilesJsonMqMessage>("收到SaveGpuProfilesJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SaveGpuProfilesJson)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <SetAutoBootStartMqMessage>("收到SetAutoBootStartMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SetAutoBootStart)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <RestartWindowsMqMessage>("收到RestartWindowsMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.RestartWindows));
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <ShutdownWindowsMqMessage>("收到ShutdownWindowsMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.ShutdownWindows));
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <UpgradeNTMinerMqMessage>("收到UpgradeNTMinerMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.UpgradeNTMiner)
{
Data = message.Data
});
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <StartMineMqMessage>("收到StartMineMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
if (message.Data != Guid.Empty)
{
RpcRoot.OfficialServer.UserMineWorkService.GetWorkJsonAsync(message.Data, message.ClientId, (response, e) => {
if (response.IsSuccess())
{
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.StartMine)
{
Data = new WorkRequest {
WorkId = message.Data,
WorkerName = response.WorkerName,
LocalJson = response.LocalJson,
ServerJson = response.ServerJson
}
});
}
});
}
else
{
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.StartMine)
{
Data = new WorkRequest {
WorkId = message.Data,
WorkerName = string.Empty,
LocalJson = string.Empty,
ServerJson = string.Empty
}
});
}
#endregion
}, this.GetType());
VirtualRoot.AddEventPath <StopMineMqMessage>("收到StopMineMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, action: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.StopMine));
#endregion
}, this.GetType());
}
