/* The GetFriendList MessageHandler * It handles messages of ADD_FRIEND_REQ type. */ private static void AddFriend(RMessage message, TcpClient connection) { Console.WriteLine("AddFriend"); uint thisUserId = ServerCore.GetIdByConnection(connection); UserData friend = UserConnector.GetUser((String)message.Data); UserData thisUser = UserConnector.GetUser(thisUserId); if(friend == null) return; if (friend.Id == thisUserId) return; List<FriendshipData> friendships = FriendshipConnector.GetFriendshipList(thisUserId); foreach(FriendshipData friendshipIt in friendships) if (friendshipIt.Former == friend.Id || friendshipIt.Latter == friend.Id) return; FriendshipData friendship = new FriendshipData(thisUserId, friend.Id, false); FriendshipConnector.AddFriendship(friendship); ClientWorker formerWorker = ServerCore.GetWorkerById(friendship.Former); ClientWorker latterWorker = ServerCore.GetWorkerById(friendship.Latter); RMessage replyMessageFormer = new RMessage(MessageType.ADD_FRIEND_REPLY, friend); RMessage replyMessageLatter = new RMessage(MessageType.ADD_FRIEND_REPLY, thisUser); RMessage replyMessage = new RMessage(MessageType.ADD_FRIENDSHIP_REPLY, friendship); if (formerWorker != null) { formerWorker.SendMessage(replyMessageFormer); formerWorker.SendMessage(replyMessage); } if (latterWorker != null) { latterWorker.SendMessage(replyMessageLatter); latterWorker.SendMessage(replyMessage); } }
/* The PartnerInfoRequested MessageHandler * It handles messages of PARTNER_INFO_REQUEST type. */ private static void PartnerInfoRequested(RMessage message, TcpClient connection) { Console.WriteLine("PartnerInfoRequested"); UserData partner = UserConnector.GetUserById((uint)message.Data); RMessage replyMessage = new RMessage(MessageType.PARTNER_INFO_REPLY,partner); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); }
/* The GetDomainQuestions MessageHandler * It handles messages of GET_DOMAIN_QUESTIONS_REQUEST type. */ private static void GetDomainQuestions(RMessage message, TcpClient connection) { Console.WriteLine("GetDomainQuestions"); List<QuestionData> questions = QuestionConnector.GetDomainQuestions((DomainData)message.Data); RMessage replyMessage = new RMessage(MessageType.GET_DOMAIN_QUESTIONS_REPLY, questions); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); }
public void AddMessage(RMessage message) { lock (mutex) { timeout[message] = TIMEOUT_TICKS; messageQueue.Add(message); } }
/* The GetAllDomains MessageHandler * It handles messages of GET_ALL_DOMAINS_REQUEST type. */ private static void GetAllDomains(RMessage message, TcpClient connection) { Console.WriteLine("GetAllDomains request"); RMessage replyMessage = new RMessage( MessageType.GET_ALL_DOMAINS_REPLY, DomainConnector.GetAllDomains()); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); }
/* The CheckUserDomainValidation MessageHandler * It handles messages of GET_USER_CERTIFIED_DOMAINS_REQUEST type. */ private static void CheckUserDomainValidation(RMessage message, TcpClient connection) { Console.WriteLine("GetUserDomainValidation"); List<Object> resultContent = new List<Object>(); resultContent.Add((Object)((UserData)message.Data)); resultContent.Add((Object)DomainConnector.GetUserValidations(((UserData)message.Data).Id)); RMessage replyMessage = new RMessage(MessageType.GET_USER_CERTIFIED_DOMAINS_REPLY, resultContent); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); }
public static void SendMessage(TcpClient connection, RMessage message) { NetworkStream writer = connection.GetStream(); byte[] buffer = Serial.ObjectToByteArray(message); UInt32 length = (UInt32)(buffer.Length); writer.Write(Serial.ObjectToByteArray(length), 0, Serial.ObjectToByteArray(length).Length); writer.Flush(); writer.Write(buffer,0,buffer.Length); writer.Flush(); }
/* The GetUserInfo MessageHandler * It handles messages of GET_USER_INFO_REQUEST type. */ private static void GetUserInfo(RMessage message, TcpClient connection) { UserData user = (UserData)message.Data; user = UserConnector.GetUserById(user.Id); List<Object> list = new List<Object>(); list.Add(user); list.Add(DomainConnector.GetAllDomains()); // all domains list.Add(DomainConnector.GetUserValidations(user.Id)); // domains for which the user has certificates RMessage replyMessage = new RMessage(MessageType.GET_USER_INFO_REPLY, list); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); }
private static void AddAnswer(RMessage message, TcpClient connection) { Console.WriteLine("ChangeQuestionStatus"); AnswerData answer = (AnswerData)message.Data; LogConnector.AddAnswer(answer); UserConnector.UpdateUserRank(answer.Owner, Ranking.ADD_ANSWER); foreach (ClientWorker workersIterator in ServerCore.GetAllWorkers()) { workersIterator.SendMessage(new RMessage(MessageType.ADD_ANSWER_REPLY, answer)); } }
/* The GetAllDomainsOrdered MessageHandler * It handles messages of GET_ALL_DOMAINS_ORDERED_REQUEST type. */ private static void GetAllDomainsOrdered(RMessage message, TcpClient connection) { uint uid = ServerCore.GetIdByConnection(connection); List<DomainData> validations = DomainConnector.GetUserValidations(uid); List<DomainData> nonValidations = DomainConnector.GetUserNonValidations(uid); validations.AddRange(nonValidations); RMessage replyMessage = new RMessage( MessageType.GET_ALL_DOMAINS_ORDERED_REPLY, validations); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); }
public static void SendMessage(TcpClient connection, RMessage message) { NetworkStream writer = connection.GetStream(); byte[] buffer = Serial.ObjectToByteArray(message); UInt32 length = (UInt32)(buffer.Length); writer.Write(Serial.ObjectToByteArray(length), 0, Serial.ObjectToByteArray(length).Length); writer.Flush(); writer.Write(buffer, 0, buffer.Length); writer.Flush(); }
public static void OnNewMessage(RMessage msg, TcpClient connection) { Dictionary<MessageHandler, TestTriggerCondition> copy_hash; lock (hashMutex) { copy_hash = new Dictionary<MessageHandler, TestTriggerCondition>(hash); } foreach (KeyValuePair<MessageHandler, TestTriggerCondition> entry in copy_hash) if (entry.Value(msg)) entry.Key(msg,connection); }
public void SendMessage(RMessage message) { try { WireMessage.SendMessage(connection, message); } catch (Exception) { // The connection is down, we destroy this ClientWorker CloseConnection(); chatThread.Abort(); } }
/* The CheckResourceVote MessageHandler * It handles messages of RANK_CHECK_RESOURCE_VOTE_REQUEST type. */ private static void CheckResourceVote(RMessage message, TcpClient connection) { Console.WriteLine("CheckResourceVote"); UserData usr = (UserData)(((List<Object>)message.Data)[0]); ResourceData res = (ResourceData)(((List<Object>)message.Data)[1]); ResourceVoteData resVote = ResourceVoteConnector.CheckResourceVote(usr, res); List<Object> replyContent = new List<Object>(); replyContent.Add(usr); replyContent.Add(res); replyContent.Add(resVote); RMessage replyMessage = new RMessage(MessageType.RANK_CHECK_RESOURCE_VOTE_REPLY, replyContent); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); }
/* The GetFriendList MessageHandler * It handles messages of ADD_SAY_REQUEST type. */ private static void AddSay(RMessage message, TcpClient connection) { Console.WriteLine("AddSay"); SayData say = (SayData)(message.Data); uint id = say.Id; say.Id = ServerCore.GetIdByConnection(connection); if (ServerCore.GetWorkerById(id) != null) { RMessage replyMessage = new RMessage(MessageType.ADD_SAY_REPLY, say); ServerCore.GetWorkerById(id).SendMessage(replyMessage); } UserConnector.UpdateUserRank(say.Id, Ranking.ADD_SAY); }
/* The SignIn MessageHandler * It handles messages of SIGN_IN_REQUEST type. */ private static void SignIn(RMessage message, TcpClient connection) { RMessage replyMessage; UserData user1 = (UserData)message.Data; UserData user2 = UserConnector.GetUser(user1.Username); // Check if the password match if (user2 != null && user2.Password != user1.Password) user2 = null; // If the credentials do not match, refuse the authentification if (user2 == null) { ServerCore.GetWorkerByConnection(connection).SendMessage( new RMessage(MessageType.SIGN_IN_REPLY, null)); return; } // If the user can authenticate, disconnect another user connected // with the same username if (user2 != null) { TcpClient previousConnection = ServerCore.GetConnectionById(user2.Id); if (previousConnection != null) { ServerCore.RemoveIdConnectionMapping(user2.Id, previousConnection); replyMessage = new RMessage( MessageType.SIGN_OUT_REPLY, user2); ServerCore.GetWorkerByConnection(previousConnection) .SendMessage(replyMessage); } } List<Object> payload = new List<Object>(); payload.Add(user2); // user data payload.Add(DomainConnector.GetAllDomains()); // all domains payload.Add(DomainConnector.GetUserValidations(user2.Id)); // domains for which the user has certificates replyMessage = new RMessage( MessageType.SIGN_IN_REPLY, payload); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); // If the user connected successfully, store the connection mapping if (user2 != null) ServerCore.AddIdConnectionMapping(user2.Id, connection); }
public static void FireCallback(RMessage msg) { lock (clb_mutex) { Dictionary<CallbackFunction, TestTriggerCondition> copy_hash; lock (mutex) { copy_hash = new Dictionary<CallbackFunction, TestTriggerCondition>(hash); } foreach (KeyValuePair<CallbackFunction, TestTriggerCondition> entry in copy_hash) if (entry.Value(msg)) entry.Key(msg); } }
/* The AddReference MessageHandler * It handles messages of ADD_REFERENCE_REQUEST type. */ private static void AddReference(RMessage message, TcpClient connection) { Console.WriteLine("AddReference"); List<UInt32> ids = (List<UInt32>)message.Data; QuestionConnector.AddReference(ids); RMessage replyMessage = new RMessage(MessageType.ADD_QUESTION_REFERENCE_REPLY, null); //ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); List<ClientWorker> allWorkers = ServerCore.GetAllWorkers(); foreach (ClientWorker workersIterator in allWorkers) { workersIterator.SendMessage(replyMessage); } }
/* The CreateNewUser MessageHandler * It handles messages of CREATE_NEW_USER_REQUEST type. */ private static void CreateNewUser(RMessage message, TcpClient connection) { Console.WriteLine("CreateNewUser request"); List<object> items = (List<object>)message.Data; UserData user = (UserData)items[0]; List<DomainData> domains = (List<DomainData>)items[1]; List<int> scores = (List<int>)items[2]; double initialRank = 0; for (int i = 0; i < domains.Count; ++i) initialRank += GetRank(scores[i]); UserConnector.AddUser(user.Username, user.Password, user.Email, initialRank); user = UserConnector.GetUser(user.Username); foreach (DomainData item in domains) ValidationConnector.AddValidation(user.Id, item.ID); }
/* The AddQuestion MessageHandler * It handles messages of ADD_QUESTION_REQUEST type. */ private static void AddQuestion(RMessage message, TcpClient connection) { Console.WriteLine("AddQuestion"); List<Object> data = (List<Object>)message.Data; QuestionData question0 = (QuestionData)data[0]; List<DomainData> domains = (List<DomainData>)data[1]; QuestionConnector.AddQuestion(question0); UserConnector.UpdateUserRank(question0.Owner, Ranking.ADD_QUESTION); UInt32 id = (UInt32)(Int64Connector.GetLastInsertId()); QuestionData question = QuestionConnector.GetQuestion(id); QuestionConnector.AddDomainQuestion(id, domains); List<ClientWorker> allWorkers = ServerCore.GetAllWorkers(); foreach (ClientWorker workersIterator in allWorkers) { workersIterator.SendMessage(new RMessage(MessageType.ADD_QUESTION_REPLY, question)); } }
/* The TriggerRule for the GetQuestion MessageHandler * The message must be of GET_ALL_QUESTIONS_REQUEST type to be * handled by this MessageHandler. */ private static Boolean GetQuestionRule(RMessage message) { return message.Type == MessageType.GET_QUESTION_REQUEST; }
/* The TriggerRule for the AddQuestion MessageHandler * The message must be of ADD_QUESTION_REQUEST type to be * handled by this MessageHandler. */ private static Boolean AddQuestionRule(RMessage message) { return message.Type == MessageType.ADD_QUESTION_REQUEST; }
/* The AddUserVote MessageHandler * It handles messages of ADD_USER_VOTE_REQUEST type. */ private static void AddUserVote(RMessage message, TcpClient connection) { Console.WriteLine("AddUserVote"); // Get the vote data from the message UserVoteData vote = (UserVoteData)message.Data; // Update the voter's rank UserVoteData rating = UserVoteConnector.CheckUserVote(vote); if (rating == null) UserConnector.UpdateUserRank(vote.Id_voter_user, Ranking.VOTE_USER); // Update the votee's rank UserConnector.VoteUser(vote); // Send the vote back to the client RMessage replyMessage = new RMessage(MessageType.ADD_USER_VOTE_REPLY, vote); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); // Send the updated user rank to all clients UserData user = UserConnector.GetUserById(vote.Id_votee_user); replyMessage = new RMessage(MessageType.RANK_USER_UPDATED, user); List<ClientWorker> allWorkers = ServerCore.GetAllWorkers(); foreach (ClientWorker workersIterator in allWorkers) { workersIterator.SendMessage(replyMessage); } }
/* The TriggerRule for the AddReference MessageHandler * The message must be of ADD_REFERENCE_REQUEST type to be * handled by this MessageHandler. */ private static Boolean AddReferenceRule(RMessage message) { return message.Type == MessageType.ADD_QUESTION_REFERENCE_REQUEST; }
private static Boolean AddAnswerRule(RMessage message) { return message.Type == MessageType.ADD_ANSWER_REQUEST; }
/* The TriggerRule for the GetUserById MessageHandler * The message must be of GET_USER_BY_ID_REQUEST type to be * handled by this MessageHandler. */ private static Boolean GetUserByIdRule(RMessage message) { return message.Type == MessageType.GET_USER_BY_ID_REQUEST; }
/* The GetUserById MessageHandler * It handles messages of GET_USER_BY_ID_REQUEST type. */ private static void GetUserById(RMessage message, TcpClient connection) { Console.WriteLine("GetUserById"); UserData user = UserConnector.GetUser((UInt32)message.Data); RMessage replyMessage = new RMessage(MessageType.GET_USER_BY_ID_REPLY, user); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); }
/* The TriggerRule for the GetResources MessageHandler * The message must be of GET_QUESTION_RESOURCES_REQUEST type to be * handled by this MessageHandler. */ private static Boolean GetResourcesRule(RMessage message) { return message.Type == MessageType.GET_QUESTION_DOMAINS_RESOURCES_REQUEST; }
/* The GetResources MessageHandler * It handles messages of GET_QUESTION_RESOURCES_REQUEST type. */ private static void GetResources(RMessage message, TcpClient connection) { Console.WriteLine("GetResources"); List<DomainData> domains = (List<DomainData>)message.Data; List<ResourceData> resources = new List<ResourceData>(); for (int i = 0; i < domains.Count; i++) { List<ResourceData> res = ResourceConnector.GetDomainResources(domains[i]); for (int j = 0; j < res.Count; j++) resources.Add(res[j]); } RMessage replyMessage = new RMessage(MessageType.GET_QUESTION_DOMAINS_RESOURCES_REPLY, resources); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); }
/* The TriggerRule for the GetQuestionDomains MessageHandler * The message must be of GET_QUESTION_DOMAINS_REQUEST type to be * handled by this MessageHandler. */ private static Boolean GetQuestionDomainsRule(RMessage message) { return message.Type == MessageType.GET_QUESTION_DOMAINS_REQUEST; }
/* The GetQuestionResources MessageHandler * It handles messages of GET_QUESTION_RESOURCES_REQUEST type. */ private static void GetQuestionResources(RMessage message, TcpClient connection) { Console.WriteLine("GetQuestionResources"); QuestionData question = (QuestionData)message.Data; List<ResourceData> resources = ResourceConnector.GetQuestionResources(question.Id); RMessage replyMessage = new RMessage(MessageType.GET_QUESTION_RESOURCES_REPLY, resources); ServerCore.GetWorkerByConnection(connection).SendMessage(replyMessage); }