def test_basic_delete1(self):
df = Dataframe("TEST", [Car])
c = Car(0)
df.checkout()
df.add_one(Car, c)
c.xvel = 1
self.assertFalse("xvel" in c.__dict__)
self.assertFalse("yvel" in c.__dict__)
self.assertFalse("xpos" in c.__dict__)
self.assertFalse("ypos" in c.__dict__)
self.assertFalse("oid" in c.__dict__)
self.assertTrue(hasattr(c, "__r_df__"))
self.assertEqual(df.local_heap, c.__r_df__)
self.assertEqual(c.xvel, 1)
self.assertEqual(c.yvel, 0)
self.assertEqual(c.xpos, 0)
self.assertEqual(c.ypos, 0)
self.assertEqual(c.oid, 0)
df.commit()
df.delete_one(Car, c)
df.commit()
self.assertListEqual(list(), df.read_all(Car))
self.assertFalse("xvel" in c.__dict__)
self.assertFalse("yvel" in c.__dict__)
self.assertFalse("xpos" in c.__dict__)
self.assertFalse("ypos" in c.__dict__)
self.assertFalse("oid" in c.__dict__)
self.assertTrue(hasattr(c, "__r_df__"))
self.assertEqual(None, c.__r_df__)
self.assertEqual(c.xvel, 1)
self.assertEqual(c.yvel, 0)
self.assertEqual(c.xpos, 0)
self.assertEqual(c.ypos, 0)
self.assertEqual(c.oid, 0)
def test_basic_delete1(self):
df = Dataframe("TEST", [Car])
c = Car(0)
df.checkout()
df.add_one(Car, c)
c.xvel = 1
self.assertFalse("xvel" in c.__dict__)
self.assertFalse("yvel" in c.__dict__)
self.assertFalse("xpos" in c.__dict__)
self.assertFalse("ypos" in c.__dict__)
self.assertFalse("oid" in c.__dict__)
self.assertTrue(hasattr(c, "__r_df__"))
self.assertEqual(df.local_heap, c.__r_df__)
self.assertEqual(c.xvel, 1)
self.assertEqual(c.yvel, 0)
self.assertEqual(c.xpos, 0)
self.assertEqual(c.ypos, 0)
self.assertEqual(c.oid, 0)
df.commit()
df.delete_one(Car, c)
df.commit()
self.assertListEqual(list(), df.read_all(Car))
self.assertFalse("xvel" in c.__dict__)
self.assertFalse("yvel" in c.__dict__)
self.assertFalse("xpos" in c.__dict__)
self.assertFalse("ypos" in c.__dict__)
self.assertFalse("oid" in c.__dict__)
self.assertTrue(hasattr(c, "__r_df__"))
self.assertEqual(None, c.__r_df__)
self.assertEqual(c.xvel, 1)
self.assertEqual(c.yvel, 0)
self.assertEqual(c.xpos, 0)
self.assertEqual(c.ypos, 0)
self.assertEqual(c.oid, 0)
def server_app(dataframe: Dataframe,
env_class: Type[BaseEnvironment],
observation_type: Type,
args: dict,
whitelist: list = None,
ready_event: Event = None):
timeout = Timeout()
fr: FrameRateKeeper = FrameRateKeeper(max_frame_rate=args['tick_rate'])
# Keep track of each player and their associated observations
observation_dataframes: Dict[int, Dataframe] = {}
observations: Dict[int, _Observation] = {}
players: Dict[int, Player] = {}
# Function to help push all observations
def push_observations():
for df in observation_dataframes.values():
df.commit()
# Add the server state to the master dataframe
server_state = ServerState(env_class.__name__, args["config"], env_class.observation_names())
dataframe.add_one(ServerState, server_state)
dataframe.commit()
# Function to help clean up server if it ever needs to shutdown
def close_server(message: str):
server_state.terminal = True
logger.error(message)
dataframe.commit()
sleep(5)
# Create the environment and start the server
env: BaseEnvironment = env_class(args["config"])
logger.info("Waiting for enough players to join ({} required)...".format(env.min_players))
# Add whitelist support, players will be rejected if their key does not match the expected keys
whitelist = [] if whitelist is None else whitelist
whitelist_used = len(whitelist) > 0
whitelist_connected = {key: False for key in whitelist}
# If we were created by some server manager, inform them we are ready for players
if ready_event is not None:
ready_event.set()
# -----------------------------------------------------------------------------------------------
# Wait for all players to connect
# -----------------------------------------------------------------------------------------------
fr.start_timeout(timeout.connect)
while len(players) < env.min_players:
if fr.tick():
close_server("Game could not find enough players. Shutting down game server.")
return 1
dataframe.sync()
new_players: Dict[int, Player] = dict((p.pid, p) for p in dataframe.read_all(Player))
# Any players that have connected by have not been acknowledged yet
for new_id in new_players.keys() - players.keys():
name = new_players[new_id].name
auth_key = new_players[new_id].authentication_key
if whitelist_used and auth_key not in whitelist_connected:
logger.info("Player tried to join with invalid authentication_key: {}".format(name))
dataframe.delete_one(Player, new_id)
del new_players[new_id]
continue
if whitelist_used and whitelist_connected[auth_key]:
logger.info("Player tried to join twice with the same authentication_key: {}".format(name))
dataframe.delete_one(Player, new_id)
del new_players[new_id]
continue
logger.info("New player joined with name: {}".format(name))
# Create new observation dataframe for the new player
obs_df = Dataframe("{}_observation".format(name), [observation_type])
obs = observation_type(new_id)
obs_df.add_one(observation_type, obs)
# Add the dataframes to the database
observation_dataframes[new_id] = obs_df
observations[new_id] = obs
whitelist_connected[auth_key] = True
# If any players that we have added before have dropped out
for remove_id in players.keys() - new_players.keys():
logger.info("Player {} has left.".format(players[remove_id].name))
auth_key = players[remove_id].authentication_key
whitelist_connected[auth_key] = False
del observations[remove_id]
del observation_dataframes[remove_id]
players = new_players
# -----------------------------------------------------------------------------------------------
# Create all of the player data and wait for the game to begin
# -----------------------------------------------------------------------------------------------
logger.info("Finalizing players and setting up new environment.")
server_state.server_no_longer_joinable = True
# Create the initial state for the environment and push it if enabled
state, player_turns = env.new_state(num_players=len(players))
if not args["observations_only"] and env.serializable():
server_state.serialized_state = env.serialize_state(state)
# Set up each player
for i, (pid, player) in enumerate(players.items()):
# Add the initial observation to each player
observations[pid].set_observation(env.state_to_observation(state=state, player=i))
# Finalize each player by giving it a player number and a port for the dataframe
player.finalize_player(number=i, observation_port=observation_dataframes[pid].details[1])
if i in player_turns:
player.turn = True
# Push all of the results to the player
players_by_number: Dict[int, Player] = dict((p.number, p) for p in players.values())
push_observations()
dataframe.sync()
# Wait for all players to be ready
fr.start_timeout(timeout.start)
while not all(player.ready_for_start for player in players.values()):
if fr.tick():
close_server("Players have dropped out between entering the game and starting the game.")
return 2
dataframe.checkout()
# -----------------------------------------------------------------------------------------------
# Primary game loop
# -----------------------------------------------------------------------------------------------
logger.info("Game started...")
terminal = False
winners = None
dataframe.commit()
fr.start_timeout(timeout.move)
while not terminal:
# Wait for a frame to tick
move_timeout = fr.tick()
# Get new data
dataframe.checkout()
# Get the player dataframes of the players who's turn it is right now
current_players: List[Player] = [p for p in players.values() if p.number in player_turns]
current_actions: List[str] = []
ready = args['realtime'] or move_timeout or all(p.ready_for_action_to_be_taken for p in current_players)
if not ready:
continue
# Queue up each players action if it is legal
# If the player failed to respond in time, we will simply execute the previous action
# If it is invalid, we will pass in a blank string
for player in current_players:
if player.action == '' or env.is_valid_action(state=state, player=player.number, action=player.action):
current_actions.append(player.action)
else:
logger.info("Player #{}, {}'s, action of {} was invalid, passing empty string as action"
.format(player.number, player.name, player.action))
current_actions.append('')
# Execute the current move
state, player_turns, rewards, terminal, winners = (
env.next_state(state=state, players=player_turns, actions=current_actions)
)
# Update true state if enabled
if not args["observations_only"] and env.serializable():
server_state.serialized_state = env.serialize_state(state)
# Update the player data from the previous move.
for player, reward in zip(current_players, rewards):
player.reward_from_last_turn = float(reward)
player.ready_for_action_to_be_taken = False
player.turn = False
# Tell the new players that its their turn and provide observation
for player_number in player_turns:
player = players_by_number[player_number]
observations[player.pid].set_observation(env.state_to_observation(state=state, player=player_number))
player.turn = True
if terminal:
server_state.terminal = True
server_state.winners = dill.dumps(winners)
for player_number in winners:
players_by_number[player_number].winner = True
logger.info("Player: {} won the game.".format(winners))
push_observations()
dataframe.commit()
fr.start_timeout(timeout.move)
# -----------------------------------------------------------------------------------------------
# Clean up after game
# -----------------------------------------------------------------------------------------------
for player in players.values():
player.turn = True
dataframe.commit()
dataframe.push()
# TODO| The code below attempts to ensure that the players have the final state of the game before the server quits.
# TODO| However, an error is thrown when players disconnect during the checkout. If this snippet was removed,
# TODO| players would have a similar error when the server would quit while they are pulling.
# TODO| May need to talk to Rohan about cleanly exiting this kind of situation.
# TODO| It would also be great if we could instead properly confirm that recipients got a message.
fr.start_timeout(timeout.end)
for player in players.values():
while not player.acknowledges_game_over and not fr.tick():
dataframe.checkout()
rankings = env.compute_ranking(state, list(range(len(players))), winners)
ranking_dict = {players_by_number[number].name: ranking for number, ranking in rankings.items()}
logger.info("Game has ended. Player {} is the winner.".format([key for key, value in ranking_dict.items() if value == 0]))
return ranking_dict
def server_df5(send_q, recv_q, server_ready, client_ready):
df = Dataframe("SERVER_TEST5", [Car])
send_q.put(df.details)
client_name = recv_q.get()
# The server goes first.
df.checkout()
#Add car to server
c1 = Car(0)
df.add_one(Car, c1)
# Modify the car value.
c1.xvel = 1
# Push record into server.
df.commit()
# Setting point C1
server_ready.set()
# Client
# Pull and read the changes.
# Waiting at point S1
client_ready.wait()
client_ready.clear()
# modify the object.
df.checkout()
c2 = Car(1)
df.add_one(Car, c2)
df.commit()
df.checkout()
df.delete_one(Car, c2)
c1.yvel = 1
df.commit()
# Setting point C2
server_ready.set()
# Waiting at point S2
client_ready.wait()
client_ready.clear()
df.checkout()
assert ("xvel" not in c1.__dict__)
assert ("yvel" not in c1.__dict__)
assert ("xpos" not in c1.__dict__)
assert ("ypos" not in c1.__dict__)
assert ("oid" not in c1.__dict__)
assert (c1.xvel is 1)
assert (c1.yvel is 1)
assert (c1.xpos is 1)
assert (c1.ypos is 1)
assert (c1.oid is 0)
c2 = df.read_one(Car, 1)
assert ("xvel" not in c2.__dict__)
assert ("yvel" not in c2.__dict__)
assert ("xpos" not in c2.__dict__)
assert ("ypos" not in c2.__dict__)
assert ("oid" not in c2.__dict__)
assert (c2.xvel is 0)
assert (c2.yvel is 0)
assert (c2.xpos is 0)
assert (c2.ypos is 0)
assert (c2.oid is 1)
df.commit()
# Going for delete.
df.checkout()
c3 = Car(2)
df.add_one(Car, c3)
c4 = df.read_one(Car, 2)
assert (c3.xvel is c4.xvel)
assert (c3.yvel is c4.yvel)
assert (c3.xpos is c4.xpos)
assert (c3.ypos is c4.ypos)
assert (c3.oid is c4.oid)
c2.yvel = 1
c2.xvel = 1
df.delete_one(Car, c2)
assert (df.read_one(Car, 1) is None)
assert (c2.__r_df__ is None)
assert (c2.xvel == 1)
assert (c2.yvel == 1)
c2.xvel = 2
c2.yvel = 2
assert (c2.xvel == 2)
assert (c2.yvel == 2)
assert (Car.__r_table__.object_table[1] == {
"oid": {
"type": Datatype.INTEGER,
"value": 1
},
"xvel": {
"type": Datatype.INTEGER,
"value": 2
},
"yvel": {
"type": Datatype.INTEGER,
"value": 2
},
"xpos": {
"type": Datatype.INTEGER,
"value": 0
},
"ypos": {
"type": Datatype.INTEGER,
"value": 0
}
})
df.delete_one(Car, c3)
assert (df.read_one(Car, 2) is None)
df.commit()
assert (set(df.local_heap.data[Car.__r_meta__.name].keys()) == set([0]))
# Setting point C3
server_ready.set()
# Waiting for S3
client_ready.wait()
def server_df5(send_q, recv_q, server_ready, client_ready):
df = Dataframe("SERVER_TEST5", [Car])
send_q.put(df.details)
client_name = recv_q.get()
# The server goes first.
df.checkout()
#Add car to server
c1 = Car(0)
df.add_one(Car, c1)
# Modify the car value.
c1.xvel = 1
# Push record into server.
df.commit()
# Setting point C1
server_ready.set()
# Client
# Pull and read the changes.
# Waiting at point S1
client_ready.wait()
client_ready.clear()
# modify the object.
df.checkout()
c2 = Car(1)
df.add_one(Car, c2)
df.commit()
df.checkout()
df.delete_one(Car, c2)
c1.yvel = 1
df.commit()
# Setting point C2
server_ready.set()
# Waiting at point S2
client_ready.wait()
client_ready.clear()
df.checkout()
assert ("xvel" not in c1.__dict__)
assert ("yvel" not in c1.__dict__)
assert ("xpos" not in c1.__dict__)
assert ("ypos" not in c1.__dict__)
assert ("oid" not in c1.__dict__)
assert (c1.xvel is 1)
assert (c1.yvel is 1)
assert (c1.xpos is 1)
assert (c1.ypos is 1)
assert (c1.oid is 0)
c2 = df.read_one(Car, 1)
assert ("xvel" not in c2.__dict__)
assert ("yvel" not in c2.__dict__)
assert ("xpos" not in c2.__dict__)
assert ("ypos" not in c2.__dict__)
assert ("oid" not in c2.__dict__)
assert (c2.xvel is 0)
assert (c2.yvel is 0)
assert (c2.xpos is 0)
assert (c2.ypos is 0)
assert (c2.oid is 1)
df.commit()
# Going for delete.
df.checkout()
c3 = Car(2)
df.add_one(Car, c3)
c4 = df.read_one(Car, 2)
assert (c3.xvel is c4.xvel)
assert (c3.yvel is c4.yvel)
assert (c3.xpos is c4.xpos)
assert (c3.ypos is c4.ypos)
assert (c3.oid is c4.oid)
c2.yvel = 1
c2.xvel = 1
df.delete_one(Car, c2)
assert (df.read_one(Car, 1) is None)
assert (c2.__r_df__ is None)
assert (c2.xvel == 1)
assert (c2.yvel == 1)
c2.xvel = 2
c2.yvel = 2
assert (c2.xvel == 2)
assert (c2.yvel == 2)
assert (Car.__r_table__.object_table[1] == {
"oid": {"type": Datatype.INTEGER, "value": 1},
"xvel": {"type": Datatype.INTEGER, "value": 2},
"yvel": {"type": Datatype.INTEGER, "value": 2},
"xpos": {"type": Datatype.INTEGER, "value": 0},
"ypos": {"type": Datatype.INTEGER, "value": 0}
})
df.delete_one(Car, c3)
assert (df.read_one(Car, 2) is None)
df.commit()
assert (set(df.local_heap.data[Car.__r_meta__.name].keys()) == set([0]))
# Setting point C3
server_ready.set()
# Waiting for S3
client_ready.wait()