public SharpWsServerAdapter(IHostConfig config)
{
_wsServer = new WebSocketServer($"ws://0.0.0.0:{config.GetServerPort().ToString()}")
{
KeepClean = true,
AuthenticationSchemes = AuthenticationSchemes.Basic, // 用基本验证字段承载签名信息，因为传输的并非原始密码，所以虽然是基本验证但不存在安全问题
UserCredentialsFinder = id => {
string base64String = id.Name;
if (!AppRoot.TryGetUser(base64String, out WsUserName wsUserName, out UserData userData, out string _))
{
return(null);
}
var password = HashUtil.Sha1(base64String + AppRoot.GetUserPassword(wsUserName, userData));
// 经验证username对于基本验证来说没有用
return(new NetworkCredential(userData.LoginName, password, domain: null, roles: wsUserName.ClientType.GetName()));
}
};
//_wsServer.Log.Level = WebSocketSharp.LogLevel.Debug;
_wsServer.Log.File = Path.Combine(HomePath.HomeLogsDirFullName, NTKeyword.WebSocketSharpMinerStudioLogFileName);
_wsServer.Log.Output = (data, path) => {
Console.WriteLine(data.Message);
if (path != null && path.Length > 0)
{
using (var writer = new StreamWriter(path, true))
using (var syncWriter = TextWriter.Synchronized(writer)) {
syncWriter.WriteLine(data.ToString());
}
}
};
_wsServer.AddWebSocketService <MinerClientSharpWsSessionAdapter>(AppRoot.MinerClientPath);
_wsServer.AddWebSocketService <MinerStudioSharpWsSessionAdapter>(AppRoot.MinerStudioPath);
MinerClientWsSessions = new SharpWsSessionsAdapter(_wsServer.WebSocketServices[AppRoot.MinerClientPath].Sessions);
MinerStudioWsSessions = new SharpWsSessionsAdapter(_wsServer.WebSocketServices[AppRoot.MinerStudioPath].Sessions);
}
/// <summary>
///
/// </summary>
/// <param name="user"></param>
/// <param name="wsSessionID"></param>
public AbstractSession(IUser user, WsUserName wsUserName, string wsSessionID, IWsSessionsAdapter sessions)
{
_sessions = sessions;
this.WsUserName = wsUserName;
this.ClientId = wsUserName.ClientId;
this.ClientVersion = Version.Parse(wsUserName.ClientVersion);// 因为前面的流程已经过验证所以可以直接Parse
this.LoginName = user.LoginName;
this.ActiveOn = DateTime.Now;
this.WsSessionId = wsSessionID;
}
public AbstractSessionSet(IWsSessionsAdapter sessions)
{
this._sessions = sessions;
VirtualRoot.BuildEventPath <CleanTimeArrivedEvent>("打扫时间到，保持清洁", LogEnum.UserConsole, path: message => {
ClearDeath();
SendReGetServerAddressMessage(message.NodeAddresses);
}, this.GetType());
VirtualRoot.BuildEventPath <UserDisabledMqMessage>("收到了UserDisabledMq消息后断开该用户的连接", LogEnum.UserConsole, path: message => {
if (!string.IsNullOrEmpty(message.LoginName))
{
TSession[] toCloses;
lock (_locker) {
toCloses = _dicByWsSessionId.Values.Where(a => a.LoginName == message.LoginName).ToArray();
}
foreach (var item in toCloses)
{
item.CloseAsync(WsCloseCode.Normal, "用户已被禁用");
}
}
}, this.GetType());
}
public AbstractSessionSet(IWsSessionsAdapter wsSessions)
{
this._wsSessions = wsSessions;
VirtualRoot.BuildEventPath <Per1MinuteEvent>("周期清理死连接、周期通知需要重新连接的客户端重新连接", LogEnum.UserConsole, path: message => {
ClearDeath();
SendReGetServerAddressMessage(AppRoot.WsServerNodeAddressSet.AsEnumerable().ToArray());
}, this.GetType());
VirtualRoot.BuildEventPath <UserDisabledMqMessage>("收到了UserDisabledMq消息后断开该用户的连接", LogEnum.UserConsole, path: message => {
if (!string.IsNullOrEmpty(message.LoginName))
{
TSession[] toCloses;
lock (_locker) {
toCloses = _dicByWsSessionId.Values.Where(a => a.LoginName == message.LoginName).ToArray();
}
foreach (var item in toCloses)
{
item.CloseAsync(WsCloseCode.Normal, "用户已被禁用");
}
}
}, this.GetType());
}
public SharpWsServer(IHostConfig config)
{
_wsServer = new WebSocketServer($"ws://0.0.0.0:{config.GetServerPort().ToString()}")
{
KeepClean = true,
AuthenticationSchemes = AuthenticationSchemes.Basic, // 用基本验证字段承载签名信息，因为传输的并非原始密码，所以虽然是基本验证但不存在安全问题
UserCredentialsFinder = id => {
string base64String = id.Name;
if (!WsRoot.TryGetUser(base64String, out WsUserName wsUserName, out UserData userData, out string _))
{
return(null);
}
string password = WsCommonService.GetUserPassword(wsUserName, userData);
password = HashUtil.Sha1(base64String + password);
// 经验证username对于基本验证来说没有用
return(new NetworkCredential(userData.LoginName, password, domain: null, roles: wsUserName.ClientType.GetName()));
}
};
_wsServer.AddWebSocketService <MinerClientSharpWsSessionAdapter>(WsRoot.MinerClientPath);
_wsServer.AddWebSocketService <MinerStudioSharpWsSessionAdapter>(WsRoot.MinerStudioPath);
MinerClientWsSessionsAdapter = new SharpWsSessionsAdapter(_wsServer.WebSocketServices[WsRoot.MinerClientPath].Sessions);
MinerStudioWsSessionsAdapter = new SharpWsSessionsAdapter(_wsServer.WebSocketServices[WsRoot.MinerStudioPath].Sessions);
}
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
});
}
private MinerClientSession(IUser user, WsUserName wsUserName, string wsSessionID, IWsSessionsAdapter sessions)
: base(user, wsUserName, wsSessionID, sessions)
{
}
/// <summary>
/// 不会返回null
/// </summary>
/// <param name="user"></param>
/// <param name="wsUserName"></param>
/// <param name="wsSessionID"></param>
/// <param name="sessions"></param>
/// <returns></returns>
public static MinerClientSession Create(IUser user, WsUserName wsUserName, string wsSessionID, IWsSessionsAdapter sessions)
{
return(new MinerClientSession(user, wsUserName, wsSessionID, sessions));
}
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());
}
private MinerClientSession(
IUser user, WsUserName wsUserName, IPEndPoint remoteEndPoint, string wsSessionID, IWsSessionsAdapter wsSessions)
: base(user, wsUserName, remoteEndPoint, wsSessionID, wsSessions)
{
}
/// <summary>
/// 不会返回null
/// </summary>
/// <param name="user"></param>
/// <param name="wsUserName"></param>
/// <param name="remoteEndPoint"></param>
/// <param name="wsSessionID"></param>
/// <param name="wsSessions"></param>
/// <returns></returns>
public static MinerClientSession Create(
IUser user, WsUserName wsUserName, IPEndPoint remoteEndPoint, string wsSessionID, IWsSessionsAdapter wsSessions)
{
return(new MinerClientSession(user, wsUserName, remoteEndPoint, wsSessionID, wsSessions));
}
public MinerClientSessionSet(IWsSessionsAdapter wsSessions) : base(wsSessions)
{
VirtualRoot.BuildEventPath <GetConsoleOutLinesMqEvent>("收到GetConsoleOutLines Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(GetConsoleOutLinesMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(GetConsoleOutLinesMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetConsoleOutLines)
{
Data = message.Data
});
#endregion
});
VirtualRoot.BuildEventPath <GetLocalMessagesMqEvent>("收到GetLocalMessages Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(GetLocalMessagesMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(GetLocalMessagesMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetLocalMessages)
{
Data = message.Data
});
#endregion
});
VirtualRoot.BuildEventPath <GetOperationResultsMqEvent>("收到GetOperationResults Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(GetOperationResultsMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(GetOperationResultsMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetOperationResults)
{
Data = message.Data
});
#endregion
});
VirtualRoot.BuildEventPath <GetDrivesMqEvent>("收到GetDrives Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(GetDrivesMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(GetDrivesMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetDrives));
#endregion
});
VirtualRoot.BuildEventPath <GetLocalIpsMqEvent>("收到GetLocalIps Mq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(GetLocalIpsMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(GetLocalIpsMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetLocalIps));
#endregion
});
VirtualRoot.BuildEventPath <GetSpeedMqEvent>("收到GetSpeedMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (message.Requests == null || message.Requests.Length == 0)
{
return;
}
if (IsTooOld(message.Timestamp))
{
return;
}
foreach (var request in message.Requests)
{
ServerRoot.IfStudioClientTestIdLogElseNothing(request.StudioId, nameof(GetSpeedMqEvent));
foreach (var clientId in request.ClientIds.Where(a => TryGetByClientId(a, out _)))
{
if (!IsOwnerBy(clientId, request.LoginName, message.Timestamp))
{
continue;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(clientId, nameof(GetSpeedMqEvent));
SendToMinerClientAsync(clientId, new WsMessage(message.MessageId, WsMessage.GetSpeed));
}
}
#endregion
});
VirtualRoot.BuildEventPath <EnableRemoteDesktopMqEvent>("收到EnableRemoteDesktopMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(EnableRemoteDesktopMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(EnableRemoteDesktopMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.EnableRemoteDesktop));
#endregion
});
VirtualRoot.BuildEventPath <BlockWAUMqEvent>("收到BlockWAUMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(BlockWAUMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(BlockWAUMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.BlockWAU));
#endregion
});
VirtualRoot.BuildEventPath <SetVirtualMemoryMqEvent>("收到SetVirtualMemoryMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(SetVirtualMemoryMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(SetVirtualMemoryMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SetVirtualMemory)
{
Data = message.Data
});
#endregion
});
VirtualRoot.BuildEventPath <SetLocalIpsMqEvent>("收到SetLocalIpsMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(SetLocalIpsMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(SetLocalIpsMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SetLocalIps)
{
Data = message.Data
});
#endregion
});
VirtualRoot.BuildEventPath <SwitchRadeonGpuMqEvent>("收到SwitchRadeonGpuMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(SwitchRadeonGpuMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(SwitchRadeonGpuMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SwitchRadeonGpu)
{
Data = message.On
});
#endregion
});
VirtualRoot.BuildEventPath <GetSelfWorkLocalJsonMqEvent>("收到GetSelfWorkLocalJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(GetSelfWorkLocalJsonMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(GetSelfWorkLocalJsonMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetSelfWorkLocalJson));
#endregion
});
VirtualRoot.BuildEventPath <SaveSelfWorkLocalJsonMqEvent>("收到SaveSelfWorkLocalJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(SaveSelfWorkLocalJsonMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(SaveSelfWorkLocalJsonMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SaveSelfWorkLocalJson)
{
Data = message.Data
});
#endregion
});
VirtualRoot.BuildEventPath <GetGpuProfilesJsonMqEvent>("收到GetGpuProfilesJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(GetGpuProfilesJsonMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(GetGpuProfilesJsonMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.GetGpuProfilesJson));
#endregion
});
VirtualRoot.BuildEventPath <SaveGpuProfilesJsonMqEvent>("收到SaveGpuProfilesJsonMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(SaveGpuProfilesJsonMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(SaveGpuProfilesJsonMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SaveGpuProfilesJson)
{
Data = message.Data
});
#endregion
});
VirtualRoot.BuildEventPath <SetAutoBootStartMqEvent>("收到SetAutoBootStartMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(SetAutoBootStartMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(SetAutoBootStartMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.SetAutoBootStart)
{
Data = message.Data
});
#endregion
});
VirtualRoot.BuildEventPath <RestartWindowsMqEvent>("收到RestartWindowsMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(RestartWindowsMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(RestartWindowsMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.RestartWindows));
#endregion
});
VirtualRoot.BuildEventPath <ShutdownWindowsMqEvent>("收到ShutdownWindowsMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(ShutdownWindowsMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(ShutdownWindowsMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.ShutdownWindows));
#endregion
});
VirtualRoot.BuildEventPath <UpgradeNTMinerMqEvent>("收到UpgradeNTMinerMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(UpgradeNTMinerMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(UpgradeNTMinerMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.UpgradeNTMiner)
{
Data = message.Data
});
#endregion
});
// WsServer节点和WebApiServer节点都订阅了该消息，WsServer节点只处理非作业消息，WebApiServer节点只处理作业消息
VirtualRoot.BuildEventPath <StartMineMqEvent>("收到StartMineMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(StartMineMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(StartMineMqEvent));
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
});
// WebApiServer节点订阅了StartMineMqMessage消息，当StartMineMqMessage消息是作业消息时WebApiServer节点重新广播StartWorkMineMqMessage消息
VirtualRoot.BuildEventPath <StartWorkMineMqEvent>("收到StartWorkMineMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(StartWorkMineMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(StartWorkMineMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.StartMine)
{
Data = message.Data
});
#endregion
});
VirtualRoot.BuildEventPath <StopMineMqEvent>("收到StopMineMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, this.GetType(), PathPriority.Normal, path: message => {
#region
if (!IsOwnerBy(message.ClientId, message.LoginName, message.Timestamp))
{
return;
}
ServerRoot.IfMinerClientTestIdLogElseNothing(message.ClientId, nameof(StopMineMqEvent));
ServerRoot.IfStudioClientTestIdLogElseNothing(message.StudioId, nameof(StopMineMqEvent));
SendToMinerClientAsync(message.ClientId, new WsMessage(message.MessageId, WsMessage.StopMine));
#endregion
});
}
public MinerClientSessionSet(IWsSessionsAdapter sessions) : base(sessions)
{
VirtualRoot.BuildEventPath <GetConsoleOutLinesMqMessage>("收到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 <GetLocalMessagesMqMessage>("收到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 <GetDrivesMqMessage>("收到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 <GetLocalIpsMqMessage>("收到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 <GetOperationResultsMqMessage>("收到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 <GetSpeedMqMessage>("收到GetSpeedMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: 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.BuildEventPath <EnableRemoteDesktopMqMessage>("收到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 <BlockWAUMqMessage>("收到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 <SetVirtualMemoryMqMessage>("收到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 <SetLocalIpsMqMessage>("收到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 <SwitchRadeonGpuMqMessage>("收到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 <GetSelfWorkLocalJsonMqMessage>("收到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 <SaveSelfWorkLocalJsonMqMessage>("收到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 <GetGpuProfilesJsonMqMessage>("收到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 <SaveGpuProfilesJsonMqMessage>("收到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 <SetAutoBootStartMqMessage>("收到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 <RestartWindowsMqMessage>("收到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 <ShutdownWindowsMqMessage>("收到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 <UpgradeNTMinerMqMessage>("收到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());
VirtualRoot.BuildEventPath <StartMineMqMessage>("收到StartMineMq消息后检查是否是应由本节点处理的消息，如果是则处理，否则忽略", LogEnum.None, path: 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.BuildEventPath <StopMineMqMessage>("收到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 sessions) : base(sessions)
{
VirtualRoot.BuildEventPath <UserPasswordChangedMqMessage>("群控用户密码变更后通知群控客户端重新登录", LogEnum.None, path: message => {
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.ReLogin));
}, this.GetType());
VirtualRoot.BuildEventPath <ConsoleOutLinesMqMessage>("收到ConsoleOutLinesMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.ConsoleOutLines)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <LocalMessagesMqMessage>("收到LocalMessagesMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.LocalMessages)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <DrivesMqMessage>("收到DrivesMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.Drives)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <LocalIpsMqMessage>("收到LocalIpsMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.LocalIps)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <OperationResultsMqMessage>("收到OperationResultsMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.OperationResults)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <OperationReceivedMqMessage>("收到OperationReceivedMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.OperationReceived)
{
Data = new WrapperClientId {
ClientId = message.ClientId
}
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <LocalJsonMqMessage>("收到LocalJsonMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.SelfWorkLocalJson)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
}, this.GetType());
VirtualRoot.BuildEventPath <GpuProfilesJsonMqMessage>("收到GpuProfilesJsonMq消息后检查对应的用户是否登录着本节点，如果是则处理，否则忽略", LogEnum.None, path: message => {
#region
if (!IsValid(message.ClientId, message.Timestamp, message.LoginName))
{
return;
}
SendToMinerStudioAsync(message.LoginName, new WsMessage(message.MessageId, WsMessage.GpuProfilesJson)
{
Data = new WrapperClientIdData {
ClientId = message.ClientId,
Data = message.Data
}
});
#endregion
}, this.GetType());
}
