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);
}
