def shutdown(self): """Tell the host daemon to shut down""" MM = ManagerMessage MT = MM.MessageTypes host = self.ip_address port = self.port shutdown_request_message = {} shutdown_request_message[MM.MESSAGE_TYPE] = MT.SHUT_DOWN sock = NetMessage.open_socket(host, port) NetMessage.send_message(sock, [shutdown_request_message]) NetMessage.get_message(sock) sock.close()
def toggle_running(self): """Create or destroy the Table Manager on the host""" MM = ManagerMessage MT = MM.MessageTypes TMR = MM.ToggleManagerRunning TMRF = MM.ToggleManagerRunningFields host = self.host_handle.ip_address port = self.manager_port toggle_running_message = {} toggle_running_message[MM.MESSAGE_TYPE] = MT.TOGGLE_MANAGER_RUNNING toggle_running = {} status = self.status() if status == "Running" or status == "Stopping": toggle_running[TMR.ACTION] = TMRF.STOP elif status == "Created": toggle_running[TMR.ACTION] = TMRF.START elif status == "Not Created": error = "Connect start or stop manager. It has not been created" raise ValueError(error) toggle_running_message[MT.TOGGLE_MANAGER_RUNNING] = toggle_running sock = NetMessage.open_socket(host, port) NetMessage.send_message(sock, [toggle_running_message]) response = NetMessage.get_message(sock) sock.close() for message in response: if message[MM.MESSAGE_TYPE] == MT.TOGGLE_MANAGER_RUNNING: toggle_response = message[MT.TOGGLE_MANAGER_RUNNING] if not toggle_response[TMR.SUCCESS]: raise ValueError(toggle_response[TMR.ERROR])
def add_table(self, table_id, table_size, big_blind, little_blind): """Instruct the remote table manager to create a new table""" MM = ManagerMessage MT = MM.MessageTypes TTC = MM.ToggleTableCreated TTCF = MM.ToggleTableCreatedFields TF = MM.TableFields host = self.host_handle.ip_address port = self.manager_port toggle_created_message = {} toggle_created_message[MM.MESSAGE_TYPE] = MT.TOGGLE_TABLE_CREATED toggle_created = {} toggle_created[TTC.ACTION] = TTCF.CREATE table_info = {} table_info[TF.ID] = table_id table_info[TF.SIZE] = table_size table_info[TF.BIG_BLIND] = big_blind table_info[TF.LITTLE_BLIND] = little_blind toggle_created[TTC.TABLE_INFO] = table_info toggle_created_message[MT.TOGGLE_TABLE_CREATED] = toggle_created sock = NetMessage.open_socket(host, port) NetMessage.send_message(sock, [toggle_created_message]) response = NetMessage.get_message(sock) sock.close() for message in response: if message[MM.MESSAGE_TYPE] == MT.TOGGLE_TABLE_CREATED: toggle_response = message[MT.TOGGLE_TABLE_CREATED] if not toggle_response[TTC.SUCCESS]: raise ValueError(toggle_response[TTC.ERROR])
def join_game(self): PM = PokerMessage MT = MessageTypes PCT = PlayerControlTypes PCF = PlayerControlFields PCRF = PlayerControlResponseFields success = False sock = self.open_socket(self.launcher_port) message = {} message[PM.MESSAGE_TYPE] = MT.PLAYER_CONTROL player_control = {} player_control[PCF.CONTROL_TYPE] = PCT.JOIN player_control[PCF.CHIPS] = self.chips player_control[PCF.PLAYER_ID] = self.player_id player_control[PCF.BCC_ID] = "test" player_control[PCF.TABLE_ID] = "table_0" message[MT.PLAYER_CONTROL] = player_control NetMessage.send_message(sock, [message]) response = NetMessage.get_message(sock) for message in response: if message[PM.MESSAGE_TYPE] == MT.PLAYER_CONTROL_RESPONSE: join_response = message[MT.PLAYER_CONTROL_RESPONSE] assert join_response[PCRF.CONTROL_TYPE] == PCT.JOIN if join_response[PCRF.SUCCESS] is True: self.game_port = join_response[PCRF.PORT] success = True else: print(join_response[PCRF.ERROR]) print("failed to join game") success = False sock.close() return success
def listen(self): """Listen for messages from users and pass them on to the controller""" ET = ErrorTypes s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(5) while self.port is None: try: host, port = self.port_manager.get_next_port() s.bind((host, port)) self.port = port except: pass s.listen(20) while not self.done: try: client_socket, address = s.accept() messages = NetMessage.get_message(client_socket) for message in messages: replies = [] try: replies = self.controller.handle_message(message) except: text = "Uncaught exception" error_type = ET.UNCAUGHT_EXCEPTION error_message = GameError(error_type, text, traceback.format_exc()) replies = [error_message.make_message()] NetMessage.send_message(client_socket, replies) client_socket.close() except socket.timeout: pass s.close()
def send_action(self, action_type, action_amount=None): """Attempt to send a player's action Arguments: action_type -- the type of action to be sent action_amount -- the amount associated with the action [default: None] """ PM = PokerMessage MT = MessageTypes AF = ActionFields message = {} message[PM.MESSAGE_TYPE] = MT.PLAYER_ACTION action = {} action[AF.BCC_ID] = self.bcc_id action[AF.ACTION_TYPE] = action_type if action_amount is not None: action[AF.ACTION_AMOUNT] = action_amount message[MT.PLAYER_ACTION] = action try: sock = NetMessage.open_socket(self.game_host, self.game_port) NetMessage.send_message(sock, [message]) responses = NetMessage.get_message(sock) return responses[len(responses) - 1] except: logging.error('An error occurred due to an action request. %s', traceback.format_exc()) return {'errors': 'An error occurred making your action'} finally: sock.close()
def quit_table(self): PM = PokerMessage MT = MessageTypes PCT = PlayerControlTypes PCF = PlayerControlFields PCRF = PlayerControlResponseFields sock = self.open_socket(self.launcher_port) success = False message = {} message[PM.MESSAGE_TYPE] = MT.PLAYER_CONTROL player_control = {} player_control[PCF.CONTROL_TYPE] = PCT.QUIT player_control[PCF.PLAYER_ID] = self.player_id player_control[PCF.TABLE_ID] = "table_0" message[MT.PLAYER_CONTROL] = player_control NetMessage.send_message(sock, [message]) responses = NetMessage.get_message(sock) for message in responses: assert message[PM.MESSAGE_TYPE] == MT.PLAYER_CONTROL_RESPONSE leave_response = message[MT.PLAYER_CONTROL_RESPONSE] assert leave_response[PCRF.CONTROL_TYPE] == PCT.LEAVE if leave_response[PCRF.SUCCESS] is True: success = True else: print(leave_response[PCRF.ERROR]) print("failed to leave table") success = False sock.close() return success
def status(self): """Return whether the host is up""" MM = ManagerMessage MT = MM.MessageTypes HS = MM.HostStatus HSF = MM.HostStatusFields host = self.ip_address port = self.port status_request_message = {} status_request_message[MM.MESSAGE_TYPE] = MT.HOST_STATUS status_request = {} status_request[HS.ACTION] = HSF.CHECK_STATUS status_request_message[MT.HOST_STATUS] = status_request sock = None try: sock = NetMessage.open_socket(host, port) NetMessage.send_message(sock, [status_request_message]) response = NetMessage.get_message(sock) except: response = [] finally: if sock is not None: sock.close() if response: return "Alive" else: return "Dead"
def status(self): """Return whether the manager is responding""" MM = ManagerMessage MT = MM.MessageTypes MI = MM.ManagerInfo MIF = MM.ManagerInfoFields host = self.host_handle.ip_address port = self.manager_port status_request_message = {} status_request_message[MM.MESSAGE_TYPE] = MT.MANAGER_INFO status_request = {} status_request[MI.REQUEST] = MIF.STATUS_CHECK status_request_message[MT.MANAGER_INFO] = status_request sock = None try: sock = NetMessage.open_socket(host, port) NetMessage.send_message(sock, [status_request_message]) response = NetMessage.get_message(sock) except: response = [] finally: if sock is not None: sock.close() if response: for message in response: if message[MM.MESSAGE_TYPE] == MT.MANAGER_INFO: status_response = message[MT.MANAGER_INFO] status = status_response[MIF.STATUS] if status == MIF.RUNNING: return "Running" elif status == MIF.STOPPING: return "Stopping" elif status == MIF.STOPPED: return "Created" return "Not Created"
def quit_table(self): """Attempt to quit the table If successful, return True and None. Otherwise, return False and an error message """ PM = PokerMessage MT = MessageTypes PCT = PlayerControlTypes PCF = PlayerControlFields PCRF = PlayerControlResponseFields success = False message = {} message[PM.MESSAGE_TYPE] = MT.PLAYER_CONTROL player_control = {} player_control[PCF.CONTROL_TYPE] = PCT.QUIT # player_control[PCF.PLAYER_ID] = self.player_id player_control[PCF.BCC_ID] = self.bcc_id player_control[PCF.TABLE_ID] = self.table_id message[MT.PLAYER_CONTROL] = player_control try: sock = NetMessage.open_socket(self.manager_host, self.manager_port) NetMessage.send_message(sock, [message]) responses = NetMessage.get_message(sock) error_message = None except: success = False error_message = "Could not reach the table" responses = [] logging.error('An error occurred communicating with the table ' + 'manager. Stacktrace: %s', traceback.format_exc()) finally: sock.close() try: for message in responses: assert(message[PM.MESSAGE_TYPE] == MT.PLAYER_CONTROL_RESPONSE) leave_response = message[MT.PLAYER_CONTROL_RESPONSE] assert(leave_response[PCRF.CONTROL_TYPE] == PCT.QUIT) #if leave_response[PCRF.SUCCESS] is True: success = True #else: # error_message = 'failed to leave table' # success = False except: success = False error_message = "The table sent an expected response" logging.error('An error occurred processing the table manager\'s' + 'response to a quit request. Response: %s\n' + 'stacktrace: %s', str(responses), traceback.format_exc()) return success, error_message
def send_update_request(self): PM = PokerMessage MT = MessageTypes PURF = PlayerUpdateRequestFields sock = self.open_socket(self.game_port) message = {} message[PM.MESSAGE_TYPE] = MT.PLAYER_UPDATE_REQUEST update_request = {} update_request[PURF.PLAYER_ID] = self.player_id message[MT.PLAYER_UPDATE_REQUEST] = update_request NetMessage.send_message(sock, [message]) responses = NetMessage.get_message(sock) return responses[0]
def get_all_poker_tables(big_blinds): """Return a list of the available poker tables Arguments: big_blinds -- a list of integers representing the acceptable big blinds """ PM = PokerMessage MT = MessageTypes TIF = TableInfoFields manager_host = hosts.TABLE_MANAGER_HOST manager_port = hosts.TABLE_MANAGER_PORT info_request_message = {} info_request_message[PM.MESSAGE_TYPE] = MT.TABLE_INFO_REQUEST info_request = {} info_request[TIF.BIG_BLINDS] = big_blinds # TODO: pagination info_request_message[MT.TABLE_INFO_REQUEST] = info_request sock = None try: sock = NetMessage.open_socket(manager_host, manager_port) NetMessage.send_message(sock, [info_request_message]) response = NetMessage.get_message(sock) except: logging.error('An error occurred communicating with the table ' + 'manager. Stacktrace: %s', traceback.format_exc()) response = [] finally: if sock is not None: sock.close() tables = [] try: for message in response: if (message[PM.MESSAGE_TYPE] == MT.TABLE_INFO_REQUEST): info_response = message[MT.TABLE_INFO_REQUEST] tables_info = info_response[TIF.TABLES_INFO] for table_info in tables_info: table_id = table_info[TIF.TABLE_ID] table_desc = table_info[TIF.DESCRIPTION] suggested_chips = table_info[TIF.SUGGESTED_CHIPS] #big_blind = table_info[TIF.BIG_BLIND] num_users = table_info[TIF.NUM_USERS] table = (table_id, table_desc, suggested_chips, num_users) tables.append(table) except: logging.error('An error occurred processing the table manager\'s ' + 'response to a table info request. Response: %s\n' + 'stacktrack: %s', str(response), traceback.format_exc()) return tables
def listen_for_user(self, s): """Listen for user requests Arguments: s -- the socket on which to listen for user requests """ PM = PokerMessage MT = MessageTypes PCF = PlayerControlFields PCT = PlayerControlTypes ET = ErrorTypes conn, addr = s.accept() messages = NetMessage.get_message(conn) responses = [] for message in messages: if message[PM.MESSAGE_TYPE] == MT.PLAYER_CONTROL: player_control = message[MT.PLAYER_CONTROL] if player_control[PCF.CONTROL_TYPE] == PCT.JOIN: response = self.handle_join_request(player_control) responses.append(response) elif player_control[PCF.CONTROL_TYPE] == PCT.QUIT: response = self.handle_quit_request(player_control) responses.append(response) elif player_control[PCF.CONTROL_TYPE] == PCT.STATUS: response = self.handle_player_status_request(player_control) responses.append(response) else: bcc_id = player_control[PCF.BCC_ID] text = "Got unexpected control type: " text = text + player_control[PCF.CONTROL_TYPE] error_type = ET.UNEXPECTED_CONTROL_TYPE error = PlayerError(bcc_id=bcc_id, text=text, error_type=error_type) response = error.make_message() responses.append(response) elif message[PM.MESSAGE_TYPE] == MT.TABLE_INFO_REQUEST: info_request = message[MT.TABLE_INFO_REQUEST] response = self.handle_table_info_request(info_request) responses.append(response) else: text = "Got an unexpected message type: " text = text + message[PM.MESSAGE_TYPE] error_type = ET.UNEXPECTED_MESSAGE error = PlayerError(text=text, error_type=error_type) response = error.make_message() responses.append(response) NetMessage.send_message(conn, responses) conn.close()
def check_for_valid_user_at_tables(bcc_id): """Find out if a user is already joined to a table in the backend Arguments: bcc_id -- the unique id of the player to search for """ PM = PokerMessage MT = MessageTypes PCT = PlayerControlTypes PCF = PlayerControlFields PCRF = PlayerControlResponseFields table_id = None port = None manager_host = hosts.TABLE_MANAGER_HOST manager_port = hosts.TABLE_MANAGER_PORT check_message = {} check_message[PM.MESSAGE_TYPE] = MT.PLAYER_CONTROL status_check = {} status_check[PCF.CONTROL_TYPE] = PCT.STATUS status_check[PCF.BCC_ID] = bcc_id check_message[MT.PLAYER_CONTROL] = status_check sock = None try: sock = NetMessage.open_socket(manager_host, manager_port) NetMessage.send_message(sock, [check_message]) response = NetMessage.get_message(sock) except: logging.error('An error occurred communicating with the table ' + 'manager. Stacktrace: %s', traceback.format_exc()) response = [] finally: if sock is not None: sock.close() try: for message in response: if (message[PM.MESSAGE_TYPE] == MT.PLAYER_CONTROL_RESPONSE): check_response = message[MT.PLAYER_CONTROL_RESPONSE] assert(check_response[PCRF.CONTROL_TYPE] == PCT.STATUS) if check_response[PCRF.VALID_USER] is True: table_id = check_response[PCRF.TABLE_ID] port = check_response[PCRF.PORT] except: logging.error('An error occurred processing the table manager\'s ' + 'response to a status check. Response: %s\n' + 'stacktrace: %s', str(response), traceback.format_exc()) return table_id, port
def send_action(self, action_type, action_amount=None): PM = PokerMessage MT = MessageTypes AF = ActionFields sock = self.open_socket(self.game_port) message = {} message[PM.MESSAGE_TYPE] = MT.PLAYER_ACTION action = {} action[AF.PLAYER_ID] = self.player_id action[AF.ACTION_TYPE] = action_type if action_amount is not None: action[AF.ACTION_AMOUNT] = action_amount message[MT.PLAYER_ACTION] = action NetMessage.send_message(sock, [message]) responses = NetMessage.get_message(sock) # self.process_responses(responses) return responses[0]
def get_tables(self): """Return a list of the tables and their information""" MM = ManagerMessage MT = MM.MessageTypes MI = MM.ManagerInfo MIF = MM.ManagerInfoFields TF = MM.TableFields host = self.host_handle.ip_address port = self.manager_port info_request_message = {} info_request_message[MM.MESSAGE_TYPE] = MT.MANAGER_INFO info_request = {} info_request[MI.REQUEST] = MIF.GET_TABLES info_request_message[MT.MANAGER_INFO] = info_request tables = [] sock = NetMessage.open_socket(host, port) NetMessage.send_message(sock, [info_request_message]) response = NetMessage.get_message(sock) sock.close() for message in response: if message[MM.MESSAGE_TYPE] == MT.MANAGER_INFO: info_response = message[MT.MANAGER_INFO] for table_info in info_response[MIF.TABLES]: table_id = table_info[TF.ID] status = table_info[TF.STATUS] big = table_info[TF.BIG_BLIND] little = table_info[TF.LITTLE_BLIND] size = table_info[TF.SIZE] num_users = table_info[TF.NUM_USERS] host = table_info[TF.HOST] port = table_info[TF.PORT] if status == TF.RUNNING or status == TF.WAITING: toggle_action = "Stop" elif status == TF.STOPPING: toggle_action = "Cancel stop" else: toggle_action = "Start" table = (table_id, status, big, little, size, num_users, host, port, toggle_action) tables.append(table) return tables
def toggle_table_running(self, table_id): """Make table manager start or stop the specified table""" MM = ManagerMessage MT = MM.MessageTypes TTR = MM.ToggleTableRunning host = self.host_handle.ip_address port = self.manager_port toggle_running_message = {} toggle_running_message[MM.MESSAGE_TYPE] = MT.TOGGLE_TABLE_RUNNING toggle_running = {} toggle_running[TTR.ID] = table_id toggle_running_message[MT.TOGGLE_TABLE_RUNNING] = toggle_running sock = NetMessage.open_socket(host, port) NetMessage.send_message(sock, [toggle_running_message]) response = NetMessage.get_message(sock) sock.close() for message in response: if message[MM.MESSAGE_TYPE] == MT.TOGGLE_TABLE_RUNNING: toggle_response = message[MT.TOGGLE_TABLE_RUNNING] if not toggle_response[TTR.SUCCESS]: raise ValueError(toggle_response[TTR.ERROR])
def num_tables(self): """Return the number of tables managed by the manager""" MM = ManagerMessage MT = MM.MessageTypes MI = MM.ManagerInfo MIF = MM.ManagerInfoFields host = self.host_handle.ip_address port = self.manager_port info_request_message = {} info_request_message[MM.MESSAGE_TYPE] = MT.MANAGER_INFO info_request = {} info_request[MI.REQUEST] = MIF.NUM_TABLES info_request_message[MT.MANAGER_INFO] = info_request sock = NetMessage.open_socket(host, port) NetMessage.send_message(sock, [info_request_message]) response = NetMessage.get_message(sock) sock.close() for message in response: if message[MM.MESSAGE_TYPE] == MT.MANAGER_INFO: info_response = message[MT.MANAGER_INFO] return info_response[MIF.NUM_TABLES]
def listen_for_command(self, s): """Read messages from the socket and handle them Arguments: s -- the socket on which to read messages """ MM = ManagerMessage MT = MM.MessageTypes conn, addr = s.accept() messages = NetMessage.get_message(conn) responses = [] for message in messages: if message[MM.MESSAGE_TYPE] == MT.HOST_STATUS: responses = self.handle_status_request(message) elif message[MM.MESSAGE_TYPE] == MT.SHUT_DOWN: responses = self.handle_shutdown_request(message) elif message[MM.MESSAGE_TYPE] == MT.TOGGLE_MANAGER_CREATED: responses = self.handle_toggle_created_message(message) NetMessage.send_message(conn, responses) conn.close()
def send_update_request(self): """Send an update request to the game and return the response""" PM = PokerMessage MT = MessageTypes PURF = PlayerUpdateRequestFields message = {} message[PM.MESSAGE_TYPE] = MT.PLAYER_UPDATE_REQUEST update_request = {} update_request[PURF.BCC_ID] = self.bcc_id message[MT.PLAYER_UPDATE_REQUEST] = update_request try: sock = NetMessage.open_socket(self.game_host, self.game_port) NetMessage.send_message(sock, [message]) responses = NetMessage.get_message(sock) return responses[len(responses) - 1] except: logging.error('An error occurred due to an update request. %s', traceback.format_exc()) return {'errors': 'An error occurred requesting an update of the table'} finally: sock.close()
def toggle_created(self): """Create or destroy the Table Manager on the host""" MM = ManagerMessage MT = MM.MessageTypes TMC = MM.ToggleManagerCreated TMCF = MM.ToggleManagerCreatedFields host = self.host_handle.ip_address toggle_created_message = {} toggle_created_message[MM.MESSAGE_TYPE] = MT.TOGGLE_MANAGER_CREATED toggle_created = {} toggle_created[TMC.USER_PORT] = self.user_port toggle_created[TMC.MANAGER_PORT] = self.manager_port toggle_created[TMC.TYPE] = self.table_type status = self.status() if status == "Running": raise ValueError('Cannot remove a running manager') elif status == "Created": toggle_created[TMC.ACTION] = TMCF.REMOVE port = self.manager_port elif status == "Not Created": toggle_created[TMC.ACTION] = TMCF.CREATE port = self.host_handle.port toggle_created_message[MT.TOGGLE_MANAGER_CREATED] = toggle_created sock = NetMessage.open_socket(host, port) NetMessage.send_message(sock, [toggle_created_message]) response = NetMessage.get_message(sock) sock.close() if response is not None: for message in response: if message[MM.MESSAGE_TYPE] == MT.TOGGLE_MANAGER_CREATED: toggle_response = message[MT.TOGGLE_MANAGER_CREATED] success = toggle_response[TMC.SUCCESS] if not success: raise ValueError(toggle_response[TMC.ERROR]) else: raise ValueError("Table could not be contacted")
def join_table(self): """Attempt to join the table If the join is successful, return True, None. Otherwise, return False and an error message """ PM = PokerMessage MT = MessageTypes PCT = PlayerControlTypes PCF = PlayerControlFields PCRF = PlayerControlResponseFields success = False join_request = {} join_request[PM.MESSAGE_TYPE] = MT.PLAYER_CONTROL join_message = {} join_message[PCF.CONTROL_TYPE] = PCT.JOIN join_message[PCF.CHIPS] = self.chips join_message[PCF.PLAYER_ID] = self.player_id join_message[PCF.BCC_ID] = self.bcc_id join_message[PCF.TABLE_ID] = self.table_id join_request[MT.PLAYER_CONTROL] = join_message try: sock = NetMessage.open_socket(self.manager_host, self.manager_port) NetMessage.send_message(sock, [join_request]) response = NetMessage.get_message(sock) error_message = None except: success = False error_message = "Could not reach the table" response = [] logging.error('An error occurred communicating with the table ' + 'manager. Stacktrace: %s', traceback.format_exc()) finally: sock.close() try: for message in response: if (message[PM.MESSAGE_TYPE] == MT.PLAYER_CONTROL_RESPONSE): join_response = message[MT.PLAYER_CONTROL_RESPONSE] assert(join_response[PCRF.CONTROL_TYPE] == PCT.JOIN) if join_response[PCRF.SUCCESS] is True: self.game_port = join_response[PCRF.PORT] self.game_host = join_response[PCRF.HOST] self.num_seats = join_response[PCRF.NUM_SEATS] success = True else: success = False error_message = join_response[PCRF.ERROR] else: logging.error('The table manager sent back an ' + 'inappropriate response. Message: %s', str(message)) success = False error_message = "The table sent an unexpected response" except: success = False error_message = "The table sent a malformed response" logging.error('An error occurred processing the table manager\'s' + ' response to a join request. Response: %s\n' + 'stacktrace: %s', str(response), traceback.format_exc()) return success, error_message
def listen(self): PM = PokerMessage MT = MessageTypes PCF = PlayerControlFields PCT = PlayerControlTypes PCRF = PlayerControlResponseFields ET = ErrorTypes self.controller1.start() HOST = '' PORT = 2423 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind((HOST, PORT)) s.listen(50) while len(self.users) < 5: conn, addr = s.accept() messages = NetMessage.get_message(conn) responses = [] for message in messages: if message[PM.MESSAGE_TYPE] == MT.PLAYER_CONTROL: player_control = message[MT.PLAYER_CONTROL] if player_control[PCF.CONTROL_TYPE] == PCT.JOIN: chips = player_control[PCF.CHIPS] player_id = player_control[PCF.PLAYER_ID] newUser = NetUser(player_id, chips) self.users.append(newUser) response = {} response[PM.MESSAGE_TYPE] = MT.PLAYER_CONTROL_RESPONSE join_success = {} join_success[PCRF.CONTROL_TYPE] = PCT.JOIN join_success[PCRF.PLAYER_ID] = player_id join_success[PCRF.SUCCESS] = True join_success[PCRF.PORT] = 2424 response[MT.PLAYER_CONTROL_RESPONSE] = join_success responses.append(response) else: player_id = player_control[PCF.PLAYER_ID] text = "Expected JOIN message, got " text = text + player_control[PCF.CONTROL_TYPE] error_type = ET.UNEXPECTED_CONTROL_TYPE error = PlayerError(player_id=player_id, text=text, error_type=error_type) response = error.make_message() responses.append(response) else: text = "Expected PLAYER_CONTROL message, got " text = text + message[PM.MESSAGE_TYPE] error_type = ET.UNEXPECTED_MESSAGE error = PlayerError(text=text, error_type=error_type) response = error.make_message() responses.append(response) NetMessage.send_message(conn, responses) conn.close() players = [] for user in self.users: players.append(Player(user, user.chips)) self.round1.players = players self.roundthread = RoundThread(self.round1) self.roundthread.start() print('started the roundthread') self.roundthread.join() print('joined with roundthread') time.sleep(30) self.controller1.stop_listener() print('waiting for the listener thread to end') self.controller1.join() print('joined with the controller')
def listen_for_manager(self, s): """Listen for manager requests Arguments: s -- the socket on which to listen for manager requests """ MM = ManagerMessage MT = MM.MessageTypes MI = MM.ManagerInfo MIF = MM.ManagerInfoFields TMC = MM.ToggleManagerCreated TMCF = MM.ToggleManagerCreatedFields TMR = MM.ToggleManagerRunning TMRF = MM.ToggleManagerRunningFields TTC = MM.ToggleTableCreated TTCF = MM.ToggleTableCreatedFields conn, addr = s.accept() messages = NetMessage.get_message(conn) responses = [] for message in messages: if message[MM.MESSAGE_TYPE] == MT.MANAGER_INFO: info_request = message[MT.MANAGER_INFO] if info_request[MI.REQUEST] == MIF.STATUS_CHECK: response = self.handle_manager_status_check(info_request) elif info_request[MI.REQUEST] == MIF.NUM_TABLES: response = self.handle_num_tables_check(info_request) elif info_request[MI.REQUEST] == MIF.GET_TABLES: response = self.handle_get_tables(info_request) else: print("Got unrecognized MANAGER INFO message") response = {} elif message[MM.MESSAGE_TYPE] == MT.TOGGLE_MANAGER_CREATED: toggle_request = message[MT.TOGGLE_MANAGER_CREATED] if toggle_request[TMC.ACTION] == TMCF.REMOVE: response = self.close_manager(toggle_request) else: print("Got unexpected TOGGLE_MANAGER_CREATED message") response = {} elif message[MM.MESSAGE_TYPE] == MT.TOGGLE_MANAGER_RUNNING: toggle_request = message[MT.TOGGLE_MANAGER_RUNNING] if toggle_request[TMR.ACTION] == TMRF.STOP: response = self.handle_stop_request(toggle_request) elif toggle_request[TMR.ACTION] == TMRF.START: response = self.handle_start_request(toggle_request) else: print("Got unrecognized TOGGLE_MANAGER_RUNNING message") response = {} elif message[MM.MESSAGE_TYPE] == MT.TOGGLE_TABLE_CREATED: toggle_request = message[MT.TOGGLE_TABLE_CREATED] if toggle_request[TTC.ACTION] == TTCF.CREATE: response = self.handle_create_table(toggle_request) elif toggle_request[TTC.ACTION] == TTCF.REMOVE: response = self.handle_remove_table(toggle_request) else: print("Got unrecognized TOGGLE_TABLE_CREATED message") response = {} elif message[MM.MESSAGE_TYPE] == MT.TOGGLE_TABLE_RUNNING: toggle_request = message[MT.TOGGLE_TABLE_RUNNING] response = self.handle_toggle_table_running(toggle_request) else: print("Got unrecognized message type") response = {} responses.append(response) NetMessage.send_message(conn, responses) conn.close()