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