def _process(self, socket): data = helpers.read_all(socket, self._config.buffer_size) if data: msg = message.deserialize(data) try: action = self._actions[msg.action] action(socket, msg.arguments, msg.token) except KeyError: msg = message.Message() msg.action = message.Actions.SERVER_MESSAGE resp = models.Response() resp.error = True resp.error_code = message.ErrorCodes.UNKNOWN_ACTION resp.message = "Unknown action." msg.arguments = resp self._try_send(socket, message.serialize(msg)) except Exception as ex: msg = message.Message() msg.action = message.Actions.SERVER_MESSAGE resp = models.Response() resp.error = True resp.error_code = message.ErrorCodes.INTERNAL_SERVER_ERROR resp.message = "Internal server error." msg.arguments = resp self._try_send(socket, message.serialize(msg)) self._logger.exception(ex) else: raise EmptyDataError()
def _process(self, socket): data = helpers.read_all(socket, self._config.buffer_size) if data: msg = message.deserialize(data) try: action = self._actions[msg.action] action(socket, msg.arguments, msg.token) except KeyError: msg = message.Message() msg.action = message.Actions.SERVER_MESSAGE resp = models.Response() resp.error = True resp.error_code = message.ErrorCodes.UNKNOWN_ACTION resp.message = "Unknown action." msg.arguments = resp self._try_send(socket, message.serialize(msg)) except Exception as ex: msg = message.Message() msg.action = message.Actions.SERVER_MESSAGE resp = models.Response() resp.error = True resp.error_code = message.ErrorCodes.INTERNAL_SERVER_ERROR resp.message = "Internal server error." msg.arguments = resp self._try_send(socket, message.serialize(msg)) self._logger.exception(ex) else: raise EmptyDataError()
def _open_user_ban_vote(self, socket, model, token=""): """ Opens user ban vote :param socket: socket of the users who want to ban other user :param model: ban model :param token: response token """ resp = message.Message() session = self._connections.get_session(socket) can_ban = socket in self._active_chats.get(model.chat_id) \ and not server.services.chat_service.is_user_admin(model.banned_user_id, model.chat_id) if can_ban: chat = server.services.chat_service.get_chat(model.chat_id) if chat: if self._active_chats.has_key(model.chat_id): vote_key = (model.chat_id, model.banned_user_id) self._active_ban_votes.open_vote( vote_key, self._config.vote_timer, lambda r: (lambda c, u, r: self._close_vote(c, u, r)) (model.chat_id, model.banned_user_id, r)) # fill default votes for all users in chat # default value is False, True is only for user, who suggest ban sockets = self._active_chats.get(model.chat_id) for s in sockets: s_session = self._connections.get_session(s) if session.user_id != model.banned_user_id: self._active_ban_votes.vote( vote_key, s_session.user_id, s_session.user_id == session.user_id) resp.action = message.Actions.USER_BAN_VOTE_IS_OPENED resp_model = models.BanVote() resp_model.chat_id = model.chat_id resp_model.banned_user_id = model.banned_user_id resp_model.initiator_id = session.user_id resp_model.timeout = self._config.vote_timer resp.arguments = resp_model self._broadcast(model.chat_id, resp) else: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "Chat wasn't found" resp_model.error_code = message.ErrorCodes.CHAT_NOT_FOUND resp.arguments = resp_model self._try_send(socket, message.serialize(resp)) else: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "You don't have permissions to ban this user" resp_model.error_code = message.ErrorCodes.NOT_ENOUGH_PERMISSIONS resp.arguments = resp_model resp.token = token self._try_send(socket, message.serialize(resp))
def _open_user_ban_vote(self, socket, model, token=""): """ Opens user ban vote :param socket: socket of the users who want to ban other user :param model: ban model :param token: response token """ resp = message.Message() session = self._connections.get_session(socket) can_ban = socket in self._active_chats.get(model.chat_id) \ and not server.services.chat_service.is_user_admin(model.banned_user_id, model.chat_id) if can_ban: chat = server.services.chat_service.get_chat(model.chat_id) if chat: if self._active_chats.has_key(model.chat_id): vote_key = (model.chat_id, model.banned_user_id) self._active_ban_votes.open_vote(vote_key, self._config.vote_timer, lambda r: (lambda c, u, r: self._close_vote(c, u, r))( model.chat_id, model.banned_user_id, r)) # fill default votes for all users in chat # default value is False, True is only for user, who suggest ban sockets = self._active_chats.get(model.chat_id) for s in sockets: s_session = self._connections.get_session(s) if session.user_id != model.banned_user_id: self._active_ban_votes.vote(vote_key, s_session.user_id, s_session.user_id == session.user_id) resp.action = message.Actions.USER_BAN_VOTE_IS_OPENED resp_model = models.BanVote() resp_model.chat_id = model.chat_id resp_model.banned_user_id = model.banned_user_id resp_model.initiator_id = session.user_id resp_model.timeout = self._config.vote_timer resp.arguments = resp_model self._broadcast(model.chat_id, resp) else: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "Chat wasn't found" resp_model.error_code = message.ErrorCodes.CHAT_NOT_FOUND resp.arguments = resp_model self._try_send(socket, message.serialize(resp)) else: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "You don't have permissions to ban this user" resp_model.error_code = message.ErrorCodes.NOT_ENOUGH_PERMISSIONS resp.arguments = resp_model resp.token = token self._try_send(socket, message.serialize(resp))
def _authorize(self, socket, model, token=""): """ Authorize user :param socket: user's socket :param model: user's auth data. Type models.Authorization :param token: response token """ session = self._connections.get_session(socket) resp = message.Message() resp.action = message.Actions.RESPONSE resp_model = models.AuthorizationResponse() if not model.login: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_AUTHORIZATION_ERROR resp_model.message = "Login cannot be empty string" elif model.guest: keys = self._connections.get_keys() is_used = False for key in keys: s = self._connections.get_session(key) is_used = s.login == model.login and s.is_guest if is_used: break if is_used: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_AUTHORIZATION_ERROR resp_model.message = "User with the same login is already online." else: session.is_guest = True session.login = model.login resp_model.login = session.login resp_model.guest = session.is_guest resp_model.error = False else: valid, user_id = server.services.authorization.user_authorization( model.login, model.password) if valid: session.user_id = user_id session.is_guest = False session.login = model.login resp_model.error = False resp_model.user_id = session.user_id resp_model.login = session.login resp_model.guest = session.is_guest else: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_AUTHORIZATION_ERROR resp_model.message = "Invalid login or password" resp.token = token resp.arguments = resp_model self._try_send(socket, message.serialize(resp))
def _create_chat(self, socket, model, token=""): """ Create new chat :param socket: user's socket :param model: new chat data. Type is models.ChatCreation :param token: response token """ resp = message.Message() resp_model = None valid = True if not model.name: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "Chat name cannot be empty string." resp_model.error_code = message.ErrorCodes.INVALID_CHAT_NAME valid = False if valid: session = self._connections.get_session(socket) if session.is_guest and not model.opened: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "Only authorized users can create not opened chats" resp_model.error_code = message.ErrorCodes.NOT_ENOUGH_PERMISSIONS valid = False if valid and (not server.services.chat_service.get_chat_by_name( model.name) is None): resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "Chat with name " + model.name + " already exists" resp_model.error_code = message.ErrorCodes.CHAT_ALREADY_EXISTS valid = False if valid: chat = server.services.chat_service.add_chat( model.name, model.opened, model.private, model.password) if not session.is_guest and not model.opened: server.services.chat_service.add_admin_to_chat( session.user_id, chat.chat_id) resp.action = message.Actions.NEW_CHAT_RESPONSE resp_model = models.ChatResponse() resp_model.error = False resp_model.chat_id = chat.chat_id resp_model.name = chat.name resp_model.opened = chat.opened resp_model.private = chat.private resp.token = token resp.arguments = resp_model self._try_send(socket, message.serialize(resp))
def _authorize(self, socket, model, token=""): """ Authorize user :param socket: user's socket :param model: user's auth data. Type models.Authorization :param token: response token """ session = self._connections.get_session(socket) resp = message.Message() resp.action = message.Actions.RESPONSE resp_model = models.AuthorizationResponse() if not model.login: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_AUTHORIZATION_ERROR resp_model.message = "Login cannot be empty string" elif model.guest: keys = self._connections.get_keys() is_used = False for key in keys: s = self._connections.get_session(key) is_used = s.login == model.login and s.is_guest if is_used: break if is_used: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_AUTHORIZATION_ERROR resp_model.message = "User with the same login is already online." else: session.is_guest = True session.login = model.login resp_model.login = session.login resp_model.guest = session.is_guest resp_model.error = False else: valid, user_id = server.services.authorization.user_authorization(model.login, model.password) if valid: session.user_id = user_id session.is_guest = False session.login = model.login resp_model.error = False resp_model.user_id = session.user_id resp_model.login = session.login resp_model.guest = session.is_guest else: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_AUTHORIZATION_ERROR resp_model.message = "Invalid login or password" resp.token = token resp.arguments = resp_model self._try_send(socket, message.serialize(resp))
def _broadcast(self, chat_id, msg, sender=None): """ Broadcast message to all members of the chat :param chat_id: Chat id :param msg: Message :param sender: Sender of the message. If sender is also member of the chat message won't be send to it again. """ data = message.serialize(msg) room = self._active_chats.get(chat_id) for socket in room: if sender is None or socket != sender: self._try_send(socket, data)
def _create_chat(self, socket, model, token=""): """ Create new chat :param socket: user's socket :param model: new chat data. Type is models.ChatCreation :param token: response token """ resp = message.Message() resp_model = None valid = True if not model.name: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "Chat name cannot be empty string." resp_model.error_code = message.ErrorCodes.INVALID_CHAT_NAME valid = False if valid: session = self._connections.get_session(socket) if session.is_guest and not model.opened: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "Only authorized users can create not opened chats" resp_model.error_code = message.ErrorCodes.NOT_ENOUGH_PERMISSIONS valid = False if valid and (not server.services.chat_service.get_chat_by_name(model.name) is None): resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "Chat with name " + model.name + " already exists" resp_model.error_code = message.ErrorCodes.CHAT_ALREADY_EXISTS valid = False if valid: chat = server.services.chat_service.add_chat(model.name, model.opened, model.private, model.password) if not session.is_guest and not model.opened: server.services.chat_service.add_admin_to_chat(session.user_id, chat.chat_id) resp.action = message.Actions.NEW_CHAT_RESPONSE resp_model = models.ChatResponse() resp_model.error = False resp_model.chat_id = chat.chat_id resp_model.name = chat.name resp_model.opened = chat.opened resp_model.private = chat.private resp.token = token resp.arguments = resp_model self._try_send(socket, message.serialize(resp))
def _broadcast(self, chat_id, msg, sender=None): """ Broadcast message to all members of the chat :param chat_id: Chat id :param msg: Message :param sender: Sender of the message. If sender is also member of the chat message won't be send to it again. """ data = message.serialize(msg) room = self._active_chats.get(chat_id) for socket in room: if sender is None or socket != sender: self._try_send(socket, data)
def _remove_user_from_room(self, room, user_id, resp=None): if user_id <= 0: return if not self._active_chats.has_key(room): return for s in self._connections.get_keys(): if self._connections.get_session(s).user_id == user_id: if not resp is None: self._try_send(s, message.serialize(resp)) self._remove_socket_from_room(room, s) break
def _remove_user_from_room(self, room, user_id, resp=None): if user_id <= 0: return if not self._active_chats.has_key(room): return for s in self._connections.get_keys(): if self._connections.get_session(s).user_id == user_id: if not resp is None: self._try_send(s, message.serialize(resp)) self._remove_socket_from_room(room, s) break
def _try_to_ban_user(self, socket, model, token=""): """ User's ban request :param socket: socket of the users who want to ban other user :param model: ban model :param token: response token """ resp = message.Message() session = self._connections.get_session(socket) admin = server.services.chat_service.is_user_admin( session.user_id, model.chat_id) can_ban = socket in self._active_chats.get(model.chat_id) and \ admin and not server.services.chat_service.is_user_admin(model.banned_user_id, model.chat_id) \ and server.services.user_service.does_user_exist(model.banned_user_id) if can_ban: chat = server.services.chat_service.get_chat(model.chat_id) if chat: self._ban_user(model.chat_id, model.banned_user_id, session.user_id) else: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "Chat wasn't found" resp_model.error_code = message.ErrorCodes.CHAT_NOT_FOUND resp.arguments = resp_model resp.token = token self._try_send(socket, message.serialize(resp)) else: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "You don't have permissions to ban this user" resp_model.error_code = message.ErrorCodes.NOT_ENOUGH_PERMISSIONS resp.arguments = resp_model resp.token = token self._try_send(socket, message.serialize(resp))
def _try_to_ban_user(self, socket, model, token=""): """ User's ban request :param socket: socket of the users who want to ban other user :param model: ban model :param token: response token """ resp = message.Message() session = self._connections.get_session(socket) admin = server.services.chat_service.is_user_admin(session.user_id, model.chat_id) can_ban = socket in self._active_chats.get(model.chat_id) and \ admin and not server.services.chat_service.is_user_admin(model.banned_user_id, model.chat_id) \ and server.services.user_service.does_user_exist(model.banned_user_id) if can_ban: chat = server.services.chat_service.get_chat(model.chat_id) if chat: self._ban_user(model.chat_id, model.banned_user_id, session.user_id) else: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "Chat wasn't found" resp_model.error_code = message.ErrorCodes.CHAT_NOT_FOUND resp.arguments = resp_model resp.token = token self._try_send(socket, message.serialize(resp)) else: resp.action = message.Actions.RESPONSE resp_model = models.Response() resp_model.error = True resp_model.message = "You don't have permissions to ban this user" resp_model.error_code = message.ErrorCodes.NOT_ENOUGH_PERMISSIONS resp.arguments = resp_model resp.token = token self._try_send(socket, message.serialize(resp))
def _register(self, socket, model, token=""): """ Register user :param socket: user's socket :param model: user's registration data. Type is models.Registration :param token: response token """ session = self._connections.get_session(socket) resp = message.Message() resp.action = message.Actions.RESPONSE resp_model = models.AuthorizationResponse() if model.login: is_used = server.services.user_service.does_login_exist( model.login) user_id = server.services.authorization.user_registration( model.login, model.password) if is_used: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_REGISTRATION_ERROR resp_model.message = "User with the same login is already registered." else: session.user_id = user_id session.is_guest = False session.login = model.login resp_model.user_id = session.user_id resp_model.login = session.login resp_model.guest = session.is_guest resp_model.error = False else: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_REGISTRATION_ERROR resp_model.message = "Login cannot be empty string" resp.token = token resp.arguments = resp_model self._try_send(socket, message.serialize(resp))
def _register(self, socket, model, token=""): """ Register user :param socket: user's socket :param model: user's registration data. Type is models.Registration :param token: response token """ session = self._connections.get_session(socket) resp = message.Message() resp.action = message.Actions.RESPONSE resp_model = models.AuthorizationResponse() if model.login: is_used = server.services.user_service.does_login_exist(model.login) user_id = server.services.authorization.user_registration(model.login, model.password) if is_used: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_REGISTRATION_ERROR resp_model.message = "User with the same login is already registered." else: session.user_id = user_id session.is_guest = False session.login = model.login resp_model.user_id = session.user_id resp_model.login = session.login resp_model.guest = session.is_guest resp_model.error = False else: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_REGISTRATION_ERROR resp_model.message = "Login cannot be empty string" resp.token = token resp.arguments = resp_model self._try_send(socket, message.serialize(resp))
def _load_chats(self, socket, model=None, token=""): """ Load list of available chats :param socket: user's socket :param token: response token """ session = self._connections.get_session(socket) chats = server.services.chat_service.get_user_chats(session.user_id) resp = message.Message() resp.action = message.Actions.CHATS_LIST_RESPONSE resp.token = token resp_model = [] for (c, admin) in chats: m = models.CurrentUserChat() m.admin = admin m.chat_id = c.chat_id m.name = c.name m.opened = c.opened m.private = c.private resp_model.append(m) resp_model.sort(key=operator.attrgetter('name')) resp.arguments = resp_model self._try_send(socket, message.serialize(resp))
def _load_chats(self, socket, model=None, token=""): """ Load list of available chats :param socket: user's socket :param token: response token """ session = self._connections.get_session(socket) chats = server.services.chat_service.get_user_chats(session.user_id) resp = message.Message() resp.action = message.Actions.CHATS_LIST_RESPONSE resp.token = token resp_model = [] for (c, admin) in chats: m = models.CurrentUserChat() m.admin = admin m.chat_id = c.chat_id m.name = c.name m.opened = c.opened m.private = c.private resp_model.append(m) resp_model.sort(key=operator.attrgetter('name')) resp.arguments = resp_model self._try_send(socket, message.serialize(resp))
def _send_message(self, socket, msg): try: socket.send(message.serialize(msg)) except Exception as ex: self._logger.exception(ex) raise ServerUnavailableError()
def _enter_room(self, socket, model, token=""): """ Authorize users in the chat :param socket:user's socket :param model: chat authorization data. Type is models.ChatAuthorization :param token: response token """ session = self._connections.get_session(socket) chat = server.services.chat_service.get_chat(model.chat_id) resp = message.Message() resp.action = message.Actions.ENTER_CHAT_RESPONSE resp_model = models.ChatResponse() if not chat is None: #check if user was banned. is_banned = not session.is_guest \ and server.services.chat_service.is_user_banned(session.user_id, chat.chat_id) if is_banned: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_IS_BANNED resp_model.message = "User is banned" elif not chat.opened and session.is_guest: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_MUST_BE_AUTHORIZED resp_model.message = "Only authorized users can enter this chat" if not resp_model.error and chat.private: if not server.services.authorization.chat_authorization(model.chat_id, model.password): resp_model.error = True resp_model.error_code = message.ErrorCodes.CHAT_AUTHORIZATION_ERROR resp_model.message = "Chat authorization error" if not resp_model.error: resp_model.error = False resp_model.chat_id = chat.chat_id resp_model.name = chat.name resp_model.opened = chat.opened resp_model.private = chat.private resp_model.admin = server.services.chat_service.is_user_admin(session.user_id, chat.chat_id) resp_model.users = [] admins = server.services.chat_service.get_admins(chat.chat_id) self._active_chats.add(chat.chat_id, socket) for s in self._active_chats.get(chat.chat_id): if s != socket: chat_member = self._connections.get_session(s) user = models.UserOfChat() user.user_id = chat_member.user_id user.login = chat_member.login user.admin = chat_member.user_id in admins user.guest = chat_member.is_guest user.is_in_ban_vote = self._active_ban_votes.has_key((model.chat_id, chat_member.user_id)) user.can_be_voted = user.is_in_ban_vote resp_model.users.append(user) user = models.UserOfChat() user.user_id = session.user_id user.login = session.login user.admin = session.user_id in admins user.guest = session.is_guest server_message = message.Message() server_message.action = message.Actions.NEW_USER_IN_CHAT server_message.arguments = (chat.chat_id, user) self._broadcast(chat.chat_id, server_message, socket) else: resp_model.error = True resp_model.error_code = message.ErrorCodes.CHAT_NOT_FOUND resp.token = token resp.arguments = resp_model self._try_send(socket, message.serialize(resp))
def _enter_room(self, socket, model, token=""): """ Authorize users in the chat :param socket:user's socket :param model: chat authorization data. Type is models.ChatAuthorization :param token: response token """ session = self._connections.get_session(socket) chat = server.services.chat_service.get_chat(model.chat_id) resp = message.Message() resp.action = message.Actions.ENTER_CHAT_RESPONSE resp_model = models.ChatResponse() if not chat is None: #check if user was banned. is_banned = not session.is_guest \ and server.services.chat_service.is_user_banned(session.user_id, chat.chat_id) if is_banned: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_IS_BANNED resp_model.message = "User is banned" elif not chat.opened and session.is_guest: resp_model.error = True resp_model.error_code = message.ErrorCodes.USER_MUST_BE_AUTHORIZED resp_model.message = "Only authorized users can enter this chat" if not resp_model.error and chat.private: if not server.services.authorization.chat_authorization( model.chat_id, model.password): resp_model.error = True resp_model.error_code = message.ErrorCodes.CHAT_AUTHORIZATION_ERROR resp_model.message = "Chat authorization error" if not resp_model.error: resp_model.error = False resp_model.chat_id = chat.chat_id resp_model.name = chat.name resp_model.opened = chat.opened resp_model.private = chat.private resp_model.admin = server.services.chat_service.is_user_admin( session.user_id, chat.chat_id) resp_model.users = [] admins = server.services.chat_service.get_admins(chat.chat_id) self._active_chats.add(chat.chat_id, socket) for s in self._active_chats.get(chat.chat_id): if s != socket: chat_member = self._connections.get_session(s) user = models.UserOfChat() user.user_id = chat_member.user_id user.login = chat_member.login user.admin = chat_member.user_id in admins user.guest = chat_member.is_guest user.is_in_ban_vote = self._active_ban_votes.has_key( (model.chat_id, chat_member.user_id)) user.can_be_voted = user.is_in_ban_vote resp_model.users.append(user) user = models.UserOfChat() user.user_id = session.user_id user.login = session.login user.admin = session.user_id in admins user.guest = session.is_guest server_message = message.Message() server_message.action = message.Actions.NEW_USER_IN_CHAT server_message.arguments = (chat.chat_id, user) self._broadcast(chat.chat_id, server_message, socket) else: resp_model.error = True resp_model.error_code = message.ErrorCodes.CHAT_NOT_FOUND resp.token = token resp.arguments = resp_model self._try_send(socket, message.serialize(resp))