public void HandleEventResponse(EventResponse response) { bool[] maskValues = response.EventMask.ToBinary(); EventDataMsg[] eventData; ulong highestId; lock (_eventLock) { highestId = _eventsSent; eventData = _eventBuffer.ToArray(); } for (int i = 0; i < maskValues.Length; ++i) { if (!maskValues[i]) { ulong eventId = (ulong)((long)response.HighestEventId - (maskValues.Length - i - 1)); if ((long)(highestId - eventId) < eventData.Length) { ulong evIdx = (ulong)(eventData.Length - (int)(highestId - eventId) - 1); MainMessage msg = new MainMessage(); msg.EventMsg = new EventMsg(); msg.EventMsg.EventDataMsg = eventData[evIdx]; _api.OpenAPI.Networking.SendAsync(msg, _api.Services.Room.ForwarderAddress, _ => { }); } } } }
private MainMessage RoomEnter(ulong msgId, ulong clientId, RoomEnter roomEnter) { _log.Debug("In RoomEnter method."); int roomId = (int)roomEnter.RoomId; if (roomId >= _roomList.Count || _roomList[roomId] == null) { return(ISystemService.CreateErrorMessage(msgId, 0, 0, "There is no such room with this ID.")); } lock (_roomList[roomId]) { Room room = _roomList[roomId]; if (room.Capacity <= room.Players.Count) { return(ISystemService.CreateErrorMessage(msgId, 0, 0, "Room is full.")); } ulong?userId = _api.Services.User.GetUserIdByClientId(clientId); if (!userId.HasValue) { return(ISystemService.CreateErrorMessage(msgId, 0, 0, "Unable to match client ID to any user.")); } room.Players.Add(userId.Value); room.LastActivity = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); _user2Room[userId.Value] = (uint?)roomId; OnUserConnected(userId.Value, room.Id); _log.Info($"User with id '{userId.Value}' entered room '{room.Name}'."); MainMessage response = new MainMessage(); response.RoomMsg = new RoomMsg(); response.RoomMsg.RoomDetail = room.ToNetworkModel(); return(response); } }
public MainMessage HandleMessage(MainMessage msg) { AppMsg appMsg = msg.AppMsg; ulong appId = appMsg.AppId; if (!_appInstances.ContainsKey(appId)) { return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "No handler could be found for this event.")); } MainMessage response = new MainMessage(); response.AppMsg = new AppMsg(); response.AppMsg.AppId = appId; byte[] data = appMsg.Data.ToByteArray(); try { byte[] responseData = _appInstances[appId].HandleMessage(data, data.Length, new MsgContext(msg)); if (responseData != null) { response.AppMsg.Data = ByteString.CopyFrom(responseData); } } catch (Exception e) { _log.Error(e); return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, e.Message)); } return(response); }
public ulong?GetUserIdByClientId(ulong clientId, bool cached = false) { if (cached && _clientId2UserId.TryGetValue(clientId, out ulong?val)) { return(val); } UserRequestMsg userRequestMsg = new UserRequestMsg(); userRequestMsg.UserByClientId = clientId; MainMessage msg = new MainMessage(); msg.UserMngMsg = new UserMngMsg(); msg.UserMngMsg.UserMsg = new UserMsg(); msg.UserMngMsg.UserMsg.UserRequestMsg = userRequestMsg; MainMessage response = _api.OpenAPI.Networking.Send(msg, _api.OpenAPI.Config.MainServer); if (ISystemService.IsError(response)) { _log.Error(response.SystemMsg.ErrorMsg.ErrorMsg_); return(null); } User user = new User(response.UserMngMsg.UserMsg.UserDetailMsg); _userCache[user.Id] = user; _clientId2UserId[clientId] = user.Id; return(user.Id); }
public SendMainChatOrPMToHub() { UpdateBase = new FlowLib.Events.FmdcEventHandler(SendMainChatOrPMToHub_UpdateBase); HubSetting settings = new HubSetting(); settings.Address = "127.0.0.1"; settings.Port = 411; settings.DisplayName = "FlowLib"; settings.Protocol = "Auto"; Hub hubConnection = new Hub(settings, this); hubConnection.Connect(); // YOU should really listen for regmode change here. // Im not doing it here to make example more easy to understand. // Wait 10 seconds and hope we are connected. System.Threading.Thread.Sleep(10 * 1000); // Create mainchat message. MainMessage msg = new MainMessage(hubConnection.Me.ID, "Testing"); // message will here be converted to right format and then be sent. UpdateBase(this, new FlowLib.Events.FmdcEventArgs(FlowLib.Events.Actions.MainMessage, msg)); // Create private message. PrivateMessage privMsg = new PrivateMessage("DCpp706", hubConnection.Me.ID, "Testing"); // message will here be converted to right format and then be sent. UpdateBase(this, new FlowLib.Events.FmdcEventArgs(FlowLib.Events.Actions.PrivateMessage, privMsg)); }
public User GetUserById(ulong userId, bool cached = false) { if (cached && _userCache.TryGetValue(userId, out User user)) { return(user); } UserRequestMsg userRequestMsg = new UserRequestMsg(); userRequestMsg.UserIdDetail = userId; MainMessage msg = new MainMessage(); msg.UserMngMsg = new UserMngMsg(); msg.UserMngMsg.UserMsg = new UserMsg(); msg.UserMngMsg.UserMsg.UserRequestMsg = userRequestMsg; MainMessage response = _api.OpenAPI.Networking.Send(msg, _api.OpenAPI.Config.MainServer); if (response.MessageTypeCase != MainMessage.MessageTypeOneofCase.UserMngMsg) { if (ISystemService.IsError(response)) { _log.Error(response.SystemMsg.ErrorMsg.ErrorMsg_); } return(null); } user = new User(response.UserMngMsg.UserMsg.UserDetailMsg); _userCache[userId] = user; return(user); }
private MainMessage HandleListRoomUsers(MainMessage msg) { ulong?userId = _clientId2UserId[msg.ClientId]; if (!userId.HasValue) { return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Unauthorized request.")); } uint?roomId = _api.Services.Room.RoomByUserId(userId.Value); if (!roomId.HasValue) { return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "User must be connected to some Room.")); } ulong[] users = _api.Services.Room.GetConnectedUsers(roomId.Value); if (users == null) { users = new ulong[0]; } UserListMsg userListMsg = new UserListMsg(); userListMsg.Users.AddRange(users.Select(x => User.Get(x)).Where(x => x != null).Select(x => x.ToMessage())); MainMessage response = new MainMessage(); response.UserMngMsg = new UserMngMsg(); response.UserMngMsg.UserMsg = new UserMsg(); response.UserMngMsg.UserMsg.UserListMsg = userListMsg; return(response); }
private static MainMessage PrepareMsg() { MainMessage msg = new MainMessage(); msg.RoomMsg = new RoomMsg(); return(msg); }
public MainMessage HandleMessage(MainMessage msg) { _log.Debug("In HandleMessage method."); RoomMsg roomMsg = msg.RoomMsg; switch (roomMsg.MessageTypeCase) { case RoomMsg.MessageTypeOneofCase.RoomCreate: return(RoomCreate(msg.MsgId, roomMsg.RoomCreate)); case RoomMsg.MessageTypeOneofCase.RoomEnter: return(RoomEnter(msg.MsgId, msg.ClientId, roomMsg.RoomEnter)); case RoomMsg.MessageTypeOneofCase.RoomExit: return(RoomExit(msg.MsgId, msg.ClientId, roomMsg.RoomExit)); case RoomMsg.MessageTypeOneofCase.RoomQuery: switch (roomMsg.RoomQuery.RoomQueryCase) { case RoomQuery.RoomQueryOneofCase.RoomDetailId: return(RoomDetail(roomMsg.RoomQuery.RoomDetailId)); case RoomQuery.RoomQueryOneofCase.RoomListQuery: return(RoomList(roomMsg.RoomQuery.RoomListQuery)); default: return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Invalid Operation.")); } default: return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Invalid Operation.")); } }
public ServiceCallback <byte[]> SendAppMsg(AppInfo app, byte[] data, AppMsgRecipient recipient) { return(new ServiceCallback <byte[]>(() => { MainMessage mainMsg = new MainMessage(); mainMsg.AppMsg = new AppMsg(); mainMsg.AppMsg.AppId = app.ID; mainMsg.AppMsg.Data = ByteString.CopyFrom(data); MainMessage response = null; switch (recipient) { case AppMsgRecipient.FORWARDER: response = _api.OpenAPI.Networking.Send(mainMsg, _api.Services.Room.ForwarderAddress); break; case AppMsgRecipient.PROVIDER: response = _api.OpenAPI.Networking.Send(mainMsg, _api.OpenAPI.Config.MainServer); break; } if (response == null) { throw new AppServiceException("Unknown response."); } if (SystemServiceClient.IsErrorMsg(response)) { throw new AppServiceException(response.SystemMsg.ErrorMsg.ErrorMsg_); } AppMsg appMsg = response.AppMsg; if (appMsg == null) { throw new AppServiceException("Unknown response."); } return appMsg.Data.ToByteArray(); })); }
private void InitRoomListInfo() { Task roomListInfo = new Task(() => { while (true) { RoomList roomList = new RoomList(); lock (_roomList) { roomList.RoomList_.AddRange(_roomList.Select(x => x.ToNetworkModel())); } MainMessage msg = new MainMessage(); msg.RoomMsg = new RoomMsg(); msg.RoomMsg.RoomList = roomList; _api.OpenAPI.Networking.SendAsync(msg, _api.OpenAPI.Config.MainServer, (response) => { if (response.MessageTypeCase != MainMessage.MessageTypeOneofCase.SystemMsg) { _log.Error("Unexpected response from Provider Server."); } else if (response.SystemMsg.SystemMsgTypeCase == SystemMsg.SystemMsgTypeOneofCase.ErrorMsg) { _log.Error(response.SystemMsg.ErrorMsg.ErrorMsg_); } }, (ex) => _log.Error(ex)); Thread.Sleep(ROOM_INFO_INTERVAL); } }, TaskCreationOptions.LongRunning); roomListInfo.Start(); }
private MainMessage HandleServerMessage(MainMessage msg) { if (msg.ServerId != 0) { return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Forwarders cannot communicate with each other.")); } return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Communication between provider and forwarder is not supported in UserService.")); }
public void ParseMessage(MainMessage message) { Console.WriteLine(message.ParseMessage); var fooActor = childCreatorActor.Create <FooActor>(Context, "FooActor"); fooActor.Tell("doNothing"); Sender.Tell(message); }
private MainMessage RoomDetail(uint roomId) { _log.Debug("In RoomDetail method."); MainMessage msg = PrepareMsg(); msg.RoomMsg = new RoomMsg(); msg.RoomMsg.RoomDetail = _roomList[(int)roomId].ToNetworkModel(); return(msg); }
void prot_Update(object sender, FmdcEventArgs e) { Hub hubConnection = sender as Hub; if (hubConnection != null) { bool testFinishStatus = false; switch (e.Action) { case Actions.IsReady: bool isReady = (bool)e.Data; if (isReady) { // Create mainchat message. MainMessage msg = new MainMessage(hubConnection.Me.ID, "Testing - MainMessage"); // message will here be converted to right format and then be sent. UpdateBase(this, new FlowLib.Events.FmdcEventArgs(FlowLib.Events.Actions.MainMessage, msg)); // Create private message. PrivateMessage privMsg = new PrivateMessage(hubConnection.Me.ID, hubConnection.Me.ID, "Testing - PrivateMessage"); // message will here be converted to right format and then be sent. UpdateBase(this, new FlowLib.Events.FmdcEventArgs(FlowLib.Events.Actions.PrivateMessage, privMsg)); } break; case Actions.MainMessage: MainMessage msgMain = e.Data as MainMessage; if (string.Equals(hubConnection.Me.ID, msgMain.From)) { _gotMyMainMessage = true; } testFinishStatus = true; break; case Actions.PrivateMessage: PrivateMessage msgPriv = e.Data as PrivateMessage; if (string.Equals(hubConnection.Me.ID, msgPriv.From)) { _gotMyPrivateMessage = true; } testFinishStatus = true; break; } if (testFinishStatus) { if (_gotMyMainMessage && _gotMyPrivateMessage) { _isFinished = true; } } } }
public MainMessage HandleMessage(MainMessage msg) { if (msg.SenderIdCase == MainMessage.SenderIdOneofCase.ServerId) { return(HandleServerMessage(msg)); } else if (msg.UserMngMsg.UserMsg.UserRequestMsg.ListQuery != null) { return(HandleListRoomUsers(msg)); } return(ISystemService.CreateRedirectMessage(msg, _api.OpenAPI.Config.MainServer)); }
public MainMessage HandleMessage(MainMessage msg) { RoomMsg roomMsg = msg.RoomMsg; int serverId = 0; switch (roomMsg.MessageTypeCase) { case RoomMsg.MessageTypeOneofCase.RoomCreate: return(RoomCreate(msg.MsgId, msg.ClientId, msg)); case RoomMsg.MessageTypeOneofCase.RoomDetail: return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Invalid message.")); case RoomMsg.MessageTypeOneofCase.RoomEnter: serverId = _roomsPerServer.Where(x => x.Value.Find(y => y.Id == msg.RoomMsg.RoomEnter.RoomId) != null).FirstOrDefault().Key; if (serverId == 0) { return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Room with this ID could not be found.")); } return(ISystemService.CreateRedirectMessage(msg, _api.Services.System.GetAddressById((uint)serverId))); case RoomMsg.MessageTypeOneofCase.RoomExit: serverId = _roomsPerServer.Where(x => x.Value.Find(y => y.Id == msg.RoomMsg.RoomExit.RoomId) != null).FirstOrDefault().Key; if (serverId == 0) { return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Room with this ID could not be found.")); } return(ISystemService.CreateRedirectMessage(msg, _api.Services.System.GetAddressById((uint)serverId))); case RoomMsg.MessageTypeOneofCase.RoomList: if (msg.SenderIdCase == MainMessage.SenderIdOneofCase.ClientId) { return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Invalid message.")); } return(RoomListServer(msg.MsgId, (int)msg.ServerId, msg.RoomMsg.RoomList)); case RoomMsg.MessageTypeOneofCase.RoomQuery: switch (msg.RoomMsg.RoomQuery.RoomQueryCase) { case RoomQuery.RoomQueryOneofCase.RoomDetailId: return(RoomDetail(msg.MsgId, msg.RoomMsg.RoomQuery.RoomDetailId)); case RoomQuery.RoomQueryOneofCase.RoomListQuery: return(RoomListClient(msg.RoomMsg.RoomQuery.RoomListQuery)); default: return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Invalid message.")); } default: return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Invalid message.")); } }
private MainMessage HandleUserMsg(MainMessage msg) { UserMsg userMsg = msg.UserMngMsg.UserMsg; switch (userMsg.UserMsgTypeCase) { case UserMsg.UserMsgTypeOneofCase.UserRequestMsg: return(HandleUserRequest(msg)); default: return(ISystemService.CreateErrorMessage(0, 0, 0, this.GetType().Name + ": Cannot handle this type of message.")); } }
private void AfterFirstResponse(MainMessage msg) { this._log.Info("Received response from Main Server."); SystemMsg sysMsg = msg.SystemMsg; if (sysMsg.SystemMsgTypeCase.Equals(SystemMsg.SystemMsgTypeOneofCase.ErrorMsg)) { throw new ServerException(sysMsg.ErrorMsg.ErrorMsg_); } _serverId = msg.ServerId; _serverIdFiller.SetId(_serverId); this._log.Info("Assigned ID: " + _serverId.ToString()); this._log.Info("Preparing Services..."); _serviceProvider = new ServiceProvider( new SystemServiceForwarder(), new EventServiceForwarder(), new TickRateServiceForwarder(), new RoomServiceForwarder(), new UserServiceForwarder(), new AppServiceForwarder()); int maxIndex = Enum.GetValues(typeof(MainMessage.MessageTypeOneofCase)) .OfType <MainMessage.MessageTypeOneofCase>() .Select(x => (int)x) .Max(); coreServices.InsertRange(0, Enumerable.Repeat <IServiceForwarder>(null, maxIndex + 1)); coreServices[(int)MainMessage.MessageTypeOneofCase.SystemMsg] = _serviceProvider.System; coreServices[(int)MainMessage.MessageTypeOneofCase.TickMsg] = _serviceProvider.TickRate; coreServices[(int)MainMessage.MessageTypeOneofCase.EventMsg] = _serviceProvider.Event; coreServices[(int)MainMessage.MessageTypeOneofCase.RoomMsg] = _serviceProvider.Room; coreServices[(int)MainMessage.MessageTypeOneofCase.UserMngMsg] = _serviceProvider.User; coreServices[(int)MainMessage.MessageTypeOneofCase.AppMsg] = _serviceProvider.App; // APIs _openAPI = new OpenAPI(udpListenner, _config); _closedAPI = new ClosedAPI(_openAPI, _serviceProvider); _openAPI.Init(_closedAPI); // Initialization of services foreach (IServiceForwarder service in coreServices) { service?.Init(_closedAPI); } this._log.Info("All services have been initialized."); udpListenner.StartListening(); }
public void SendMessage(bool send) { var parserActor = childCreatorActor.Create <ParserActor>(Context, "ParserActor"); if (send) { var messageToParse = someService.ReturnValue("test"); var message = new MainMessage(messageToParse); parserActor.Tell(message); } Sender.Tell(send); }
public MainMessage HandleMessage(MainMessage msg) { SystemMsg sysMsg = msg.SystemMsg; switch (sysMsg.SystemMsgTypeCase) { case SystemMsg.SystemMsgTypeOneofCase.HiMsg: return(HandleHiMsg(sysMsg.HiMsg)); case SystemMsg.SystemMsgTypeOneofCase.StatMsg: return(HandleStatMsg(msg)); default: return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Unknown message type")); } }
public EventResponse HandleEvent(MainMessage msg) { EventDataMsg eventMsg = msg.EventMsg.EventDataMsg; EventType eventType = (EventType)eventMsg.EventType; switch (eventType) { case EventType.SKELETON_STATE: return(HandleSkeletonEvent(msg.MsgId, msg.ClientId, eventMsg)); case EventType.OBJECT_STATE: return(HandleGameObjectEvent(msg.MsgId, msg.ClientId, eventMsg)); default: return(IEventService.CreateErrorResponse(msg.MsgId, 0, 0, "Wrong event type.")); } }
void Protocol_MessageReceived(object sender, FlowLib.Events.FmdcEventArgs e) { FlowLib.Protocols.HubNmdc.To msg = e.Data as FlowLib.Protocols.HubNmdc.To; if (msg != null && !string.IsNullOrEmpty(msg.From)) { User usr = hubConnection.GetUserById(msg.From); if (usr != null) { // Note that this will always be empty if you dont set it. (As this took me like 1-2 min todo. i havnt added a none static one) usr.UserInfo.Set(UserInfo.IP, "193.0.19.25"); // http://ripe.net System.Text.StringBuilder sb = new System.Text.StringBuilder("\r\n"); sb.AppendLine("---------------------------------------------------------------------------------------------------------"); sb.AppendFormat("¦ Showing information on: {0}\r\n", usr.DisplayName); sb.AppendLine("---------------------------------------------------------------------------------------------------------"); sb.AppendLine("¦ General information:"); sb.AppendFormat("¦ User: {0} (Online)\r\n", usr.DisplayName); sb.AppendFormat("¦ Profile: {0}\r\n", usr.UserInfo.Account.ToString()); // Note that this will always be empty if you dont set it. (As this took me like 1-2 min todo. i havnt added a none static one) if (usr.UserInfo.ContainsKey(UserInfo.IP)) { sb.AppendFormat("¦ IP: {0}\r\n", usr.UserInfo.Get(UserInfo.IP)); try{ System.Net.IPHostEntry entry = System.Net.Dns.GetHostEntry(usr.UserInfo.Get(UserInfo.IP)); sb.AppendFormat("¦ DNS: {0}\r\n", entry.HostName); }catch {} } sb.AppendFormat("¦ Passive: {0}\r\n", (usr.Tag.Mode == FlowLib.Enums.ConnectionTypes.Passive)); sb.AppendFormat("¦ Operator: {0}\r\n", usr.IsOperator); sb.AppendFormat("¦ Sharesize: {0} (exact size: {1} B)\r\n", usr.UserInfo.ShareIEEE1541, usr.UserInfo.Share); sb.AppendFormat("¦ Description: {0}\r\n", usr.Description); sb.AppendFormat("¦ Tag: {0}\r\n", usr.Tag.Tag); sb.AppendFormat("¦ Hubs: {0}\r\n", usr.UserInfo.TagInfo.Normal + usr.UserInfo.TagInfo.OP + usr.UserInfo.TagInfo.Regged); sb.AppendFormat("¦ Slots: {0}\r\n", usr.UserInfo.TagInfo.Slots); sb.AppendLine("---------------------------------------------------------------------------------------------------------"); // Create mainchat message. MainMessage mm = new MainMessage(hubConnection.Me.ID, sb.ToString()); // message will here be converted to right format and then be sent. UpdateBase(this, new FlowLib.Events.FmdcEventArgs(FlowLib.Events.Actions.MainMessage, mm)); string str = string.Format("[{1}] IN: {0}", sb.ToString(), System.DateTime.Now.ToLongTimeString()); System.Console.WriteLine(str); } } }
public MainMessage HandleMessage(MainMessage msg) { Stopwatch sw = new Stopwatch(); sw.Start(); EventDataMsg eventMsg = msg.EventMsg.EventDataMsg; EventResponse response = new EventResponse(); if (eventMsg == null) { return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Forwarder can process only EventDataMsg type.")); } if (eventMsg.AppTypeCase != EventDataMsg.AppTypeOneofCase.None) { try { byte[] responseData = _api.Services.App.HandleEvent(msg); if (responseData != null) { response.Data = ByteString.CopyFrom(responseData); } } catch (EventErrorException e) { _log.Error(e); response = IEventService.CreateErrorResponse(msg.MsgId, 0, 0, e.Message); } } else { EventResponse handleResponse = HandleEvent(msg); if (handleResponse != null) { response = handleResponse; } } response.ProcessTime = (uint)sw.ElapsedMilliseconds; response = _maskHandler.Handle(msg.ClientId, eventMsg, response); MainMessage responseMsg = new MainMessage(); responseMsg.EventMsg = new EventMsg(); responseMsg.EventMsg.EventResponse = response; return(responseMsg); }
void Protocol_Update(object sender, FmdcEventArgs e) { UserInfo usr = null; switch (e.Action) { case Actions.MainMessage: MainMessage msg = e.Data as MainMessage; if (msg != null) { msgList.Add(string.Format("<{0}> {1}", msg.From, msg.Content)); listMainchat.Show(); } break; case Actions.UserOnline: usr = e.Data as UserInfo; if (usr != null) { userList.Add(usr.DisplayName); int pos = userList.IndexOf(usr.DisplayName); if ((listUserlist.Height + listUserlist.TopRowIndex) >= pos && pos >= listUserlist.TopRowIndex) { listUserlist.Show(); } } break; case Actions.UserOffline: usr = e.Data as UserInfo; if (usr != null) { int pos = userList.IndexOf(usr.DisplayName); if ((listUserlist.Height + listUserlist.TopRowIndex) >= pos && pos >= listUserlist.TopRowIndex) { listUserlist.Show(); } userList.Remove(usr.DisplayName); } break; default: break; } }
private MainMessage HandleStatMsg(MainMessage msg) { _log.Debug("In HandleStatMsg method"); uint serverId = msg.ServerId; if (serverId >= computingServers.Count) { _log.Error("Unknown Computing Server."); return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Unknown Computing Server.")); } StatMsg statMsg = msg.SystemMsg.StatMsg; computingServers[(int)serverId].cpuUsage = statMsg.CpuUsage; computingServers[(int)serverId].ramUsage = statMsg.MemoryUsed; computingServers[(int)serverId].lastResponse = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); _log.Debug($"server {serverId} status: CPU: {statMsg.CpuUsage}%, RAM: {statMsg.MemoryUsed} MB"); return(ISystemService.CreateOkMessage((uint)msg.MsgId)); }
private void InitStats() { uint cpuUsage = 0; long memoryTotal = 0; long memoryUsed = 0; bool firstRun = false; Task calculationT = new Task(() => { while (true) { cpuUsage = HwMonitor.GetCoreUsage(); Interlocked.Exchange(ref memoryTotal, (long)HwMonitor.GetTotalMemory()); Interlocked.Exchange(ref memoryUsed, (long)HwMonitor.GetUsedMemory()); firstRun = true; } }, TaskCreationOptions.LongRunning); Task sendingT = new Task(() => { while (!firstRun) { Thread.Sleep(1000); } while (true) { SystemMsg sysMsg = new SystemMsg(); StatMsg statMsg = new StatMsg(); statMsg.CpuUsage = cpuUsage; statMsg.MemoryTotal = (ulong)Interlocked.Read(ref memoryTotal); statMsg.MemoryUsed = (ulong)Interlocked.Read(ref memoryUsed); sysMsg.StatMsg = statMsg; MainMessage msg = new MainMessage(); msg.SystemMsg = sysMsg; Thread.Sleep((int)STATS_INTERVAL_MS); _api.OpenAPI.Networking.SendAsync(msg, _api.OpenAPI.Config.MainServer, (_) => { }, (err) => { _log.Error("There was an error during status sending to Main Server."); Environment.Exit(1); }); } }, TaskCreationOptions.LongRunning); calculationT.Start(); sendingT.Start(); }
void prot_Update(object sender, FmdcEventArgs e) { switch (e.Action) { case Actions.MainMessage: MainMessage msgMain = e.Data as MainMessage; System.Console.Write(string.Format("[{0}] <{1}> {2}\r\n", System.DateTime.Now.ToLongTimeString(), msgMain.From, msgMain.Content)); break; case Actions.PrivateMessage: PrivateMessage msgPriv = e.Data as PrivateMessage; System.Console.Write(string.Format("[{0}] PM:{1}\r\n", System.DateTime.Now.ToLongTimeString(), msgPriv.Content)); break; } }
private MainMessage RoomList(RoomListQuery listQuery) { _log.Debug("In RoomList method."); RoomList roomList = new RoomList(); IEnumerable <RoomDetail> roomEnum = _roomList.Select(x => x.ToNetworkModel()); if (listQuery.NotEmpty) { roomEnum = roomEnum.Where(x => x.Players.Count != 0); } if (listQuery.NotFull) { roomEnum = roomEnum.Where(x => x.Players.Count != x.Capacity); } roomList.RoomList_.Add(roomEnum); MainMessage msg = PrepareMsg(); msg.RoomMsg.RoomList = roomList; return(msg); }
private MainMessage HandleHiMsg(HiMsg msg) { this._log.Debug("Received Hi message."); if (msg.Version != VrLifeServer.VERSION) { this._log.Debug("Not compatiable version of client."); return(ISystemService.CreateErrorMessage(0, 0, 0, "Not compatiable version")); } MainMessage response = ISystemService.CreateOkMessage(); response.ServerId = (uint)computingServers.Count; this._log.Debug($"Sending {response.ServerId} as a new ServerID."); computingServers.Add( new ComputingServer { id = response.ServerId, cores = msg.Threads, memory = msg.Memory, address = new IPEndPoint(msg.Address, msg.Port), lastResponse = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() }); return(response); }