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 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 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 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 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 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 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 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 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 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 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 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 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
