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 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);
}
}
private MainMessage RoomExit(ulong msgId, ulong clientId, RoomExit roomExit)
{
_log.Debug("In RoomExit method.");
int roomId = (int)roomExit.RoomId;
ulong?userId = _api.Services.User.GetUserIdByClientId(clientId);
if (!userId.HasValue || roomId >= _roomList.Count || _roomList[roomId] == null)
{
return(ISystemService.CreateErrorMessage(msgId, 0, 0, "Unable to match client ID to any user."));
}
lock (_roomList[roomId])
{
int idx = _roomList[roomId].Players.FindIndex(x => x == userId.Value);
if (idx < 0)
{
return(ISystemService.CreateErrorMessage(msgId, 0, 0, "Your client is not connected to this room."));
}
Room room = _roomList[roomId];
room.Players.RemoveAt(idx);
room.LastActivity = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
OnUserDisconnected(userId.Value, room.Id, "Disconnected");
_user2Room[userId.Value] = null;
_log.Info($"User with id '{userId.Value}' exited room '{room.Name}'.");
}
return(ISystemService.CreateOkMessage(msgId));
}
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 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."));
}
}
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 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."));
}
}
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 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);
}
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 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);
}
private MainMessage HandleAuthMsg(MainMessage msg)
{
_log.Debug("Received authorization message.");
AuthMsg authMsg = msg.UserMngMsg.AuthMsg;
string username = authMsg.Username;
string password = authMsg.Password;
User user = User.Get(username);
if (user == null)
{
_log.Debug("Could not find user with this username.");
return(ISystemService.CreateErrorMessage(0, 0, 0,
"Could not find user with this username."));
}
if (!user.CheckPassword(password))
{
_log.Debug("Invalid password.");
return(ISystemService.CreateErrorMessage(0, 0, 0,
"Invalid password."));
}
MainMessage response = new MainMessage();
response.UserMngMsg = new UserMngMsg();
response.UserMngMsg.UserMsg = new UserMsg();
response.UserMngMsg.UserMsg.UserDetailMsg = user.ToMessage();
response.UserMngMsg.UserMsg.UserDetailMsg.Password = "";
// clientId == 0 --> unsassigned ID
if (msg.ClientId != 0 && msg.ClientId < (ulong)_clientMachines.Count)
{
_clientMachines[(int)msg.ClientId] = user;
response.ClientId = msg.ClientId;
}
else
{
response.ClientId = (uint)_clientMachines.Count;
_clientMachines.Add(user);
}
return(response);
}
public MainMessage HandleMessage(MainMessage msg)
{
EventDataMsg dataMsg = msg.EventMsg.EventDataMsg;
if (dataMsg == null)
{
return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Invalid msg type."));
}
EventResponse response;
if (msg.EventMsg.EventDataMsg.AppTypeCase != EventDataMsg.AppTypeOneofCase.None)
{
try
{
response = new EventResponse();
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
{
const string err_msg = "Main server does not handle events of this type.";
_log.Error(err_msg);
response = IEventService.CreateErrorResponse(msg.MsgId, 0, 0, err_msg);
}
response = _maskHandler.Handle(msg.ClientId, dataMsg, response);
MainMessage responseMsg = new MainMessage();
responseMsg.EventMsg = new EventMsg();
responseMsg.EventMsg.EventResponse = response;
return(responseMsg);
}
private MainMessage RoomDetail(ulong msgId, uint roomId)
{
Room room = null;
foreach (List <Room> rooms in _roomsPerServer.Values)
{
room = rooms.Find(x => x.Id == roomId);
if (room != null)
{
break;
}
}
if (room == null)
{
return(ISystemService.CreateErrorMessage(msgId, 0, 0, "Room with this ID could not be found."));
}
MainMessage msg = new MainMessage();
msg.RoomMsg = new RoomMsg();
msg.RoomMsg.RoomDetail = room.ToNetworkModel();
return(msg);
}
public MainMessage HandleMessage(MainMessage msg)
{
AppMsg appMsg = msg.AppMsg;
ulong? userId = _api.Services.User.GetUserIdByClientId(msg.ClientId, true);
if (!userId.HasValue)
{
return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Unauthenticated user."));
}
uint?roomId = _api.Services.Room.RoomByUserId(userId.Value);
if (!roomId.HasValue)
{
return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "User is not connected to any room."));
}
ulong appId = appMsg.AppId;
if (!_appInstances.ContainsKey(roomId.Value) || !_appInstances[roomId.Value].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
{
response.AppMsg.Data = ByteString.CopyFrom(
_appInstances[roomId.Value][appId].HandleMessage(data, data.Length, new MsgContext(msg))
);
}
catch (Exception e)
{
return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, e.Message));
}
return(response);
}
private MainMessage RoomCreate(ulong msgId, ulong clientId, MainMessage msg)
{
if (_roomsPerServer.Count == 0)
{
return(ISystemService.CreateErrorMessage(msgId, 0, 0, "There is currently no computing server."));
}
int serverId = 1;
foreach (KeyValuePair <int, List <Room> > pair in _roomsPerServer)
{
lock (_roomsPerServer[pair.Key])
{
if (_api.Services.System.IsAlive((ulong)pair.Key) && pair.Value.Count < _roomsPerServer[serverId].Count)
{
serverId = pair.Key;
}
}
}
IPEndPoint redirect = _api.Services.System.GetAddressById((uint)serverId);
return(ISystemService.CreateRedirectMessage(msg, redirect));
}
private MainMessage HandleUserRequest(MainMessage msg)
{
_log.Debug("In HandleUserRequest method.");
try
{
// TODO needs enhancemnets
UserRequestMsg userRequest = msg.UserMngMsg.UserMsg.UserRequestMsg;
switch (userRequest.UserRequestTypeCase)
{
// create new User
case UserRequestMsg.UserRequestTypeOneofCase.CreateQuery:
_log.Debug("Creating new user: "******"User sucessfuly created.");
return(new MainMessage {
UserMngMsg = userMngMsg
});
// List users (Username LIKE '%msg.username%')
case UserRequestMsg.UserRequestTypeOneofCase.ListQuery:
_log.Debug("Looking for user like: " + userRequest.ListQuery.Username);
UserDetailMsg userDetail = userRequest.ListQuery;
UserDetailMsg[] users = User.List(userDetail)
.Select(x => new UserDetailMsg {
Password = "", UserId = x.Id, Username = x.Username
})
.ToArray();
UserListMsg userList = new UserListMsg();
userList.Users.AddRange(users);
UserMngMsg userMngMsg1 = new UserMngMsg();
userMngMsg1.UserMsg = new UserMsg {
UserListMsg = userList
};
_log.Debug($"Found {users.Length} records.");
return(new MainMessage {
UserMngMsg = userMngMsg1
});
// Change password, where old and new password are in same filed, separated by newline
case UserRequestMsg.UserRequestTypeOneofCase.UpdateQuery:
_log.Debug("Changing password to user: "******"Password sucessfuly changed.");
return(ISystemService.CreateOkMessage(msg.MsgId));
// show user by its Id
case UserRequestMsg.UserRequestTypeOneofCase.UserIdDetail:
_log.Debug($"Looking for user with id {userRequest.UserIdDetail}");
User user2 = User.Get(userRequest.UserIdDetail);
UserDetailMsg userDetail1 = new UserDetailMsg();
userDetail1.UserId = user2.Id;
userDetail1.Password = "";
userDetail1.Username = user2.Username;
UserMsg userMsg1 = new UserMsg();
userMsg1.UserDetailMsg = userDetail1;
return(new MainMessage {
UserMngMsg = new UserMngMsg {
UserMsg = userMsg1
}
});
case UserRequestMsg.UserRequestTypeOneofCase.UserByClientId:
_log.Debug($"Looking for user with client id {userRequest.UserByClientId}");
if (msg.SenderIdCase != MainMessage.SenderIdOneofCase.ServerId)
{
return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Not enough permissions."));
}
ulong clientId = userRequest.UserByClientId;
if (clientId >= (ulong)_clientMachines.Count || _clientMachines[(int)clientId] == null)
{
return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Unable to find user with this client ID"));
}
MainMessage respUserDetail = new MainMessage();
respUserDetail.UserMngMsg = new UserMngMsg();
respUserDetail.UserMngMsg.UserMsg = new UserMsg();
respUserDetail.UserMngMsg.UserMsg.UserDetailMsg = _clientMachines[(int)clientId].ToMessage();
return(respUserDetail);
default:
throw new ErrorMsgException("This message cannot be empty.");
}
}
catch (Exception ex)
{
_log.Error(ex);
return(ISystemService.CreateErrorMessage(0, 0, 0, ex.Message));
}
}
public MainMessage HandleMessage(MainMessage msg)
{
return(ISystemService.CreateErrorMessage(msg.MsgId, 0, 0, "Provider cannot receive TickRateMsg."));
}
