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 client_df7(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [Blocker], details=server_name, resolver={Blocker: blocker_merge_func}) send_q.put(df.details) #print ("Client at start:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C1 #print ("Waiting for C1") server_ready.wait() server_ready.clear() #print ("Client after waiting for server first time.:", df.versioned_heap.version_graph.nodes.keys()) # Pull from the server. df.pull() #print ("Client after first pull:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() blockers = df.read_all(Blocker) assert (1 == len(blockers)) b1 = blockers[0] assert (b1.prop == 1) #print ("Setting S1") # Setting point S1 client_ready.set() b1.prop = 10 assert (b1.prop == 10) df.commit() #print ("Client after first modification:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C2 #print ("Waiting for C2") server_ready.wait() server_ready.clear() #print ("Client after waiting for server:", df.versioned_heap.version_graph.nodes.keys()) df.push() #print ("Client after pushing:", df.versioned_heap.version_graph.nodes.keys()) # Setting point S2 #print ("Setting S2") client_ready.set() # Waiting at point c3 #print ("Waiting for C3") server_ready.wait() server_ready.clear() df.pull() #print ("Client after pulling second time:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() assert (b1.prop == 10) b1.prop = 5 df.commit() df.push() # Setting point S3 #print ("Setting S3") client_ready.set() # Waiting at point c4 #print ("Waiting for C4") server_ready.wait() server_ready.clear()
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 client_df7(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [Blocker], details=server_name) send_q.put(df.details) #print ("Client at start:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C1 #print ("Waiting for C1") server_ready.wait() server_ready.clear() #print ("Client after waiting for server first time.:", df.versioned_heap.version_graph.nodes.keys()) # Pull from the server. df.pull() #print ("Client after first pull:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() blockers = df.read_all(Blocker) assert (1 == len(blockers)) b1 = blockers[0] assert (b1.prop == 1) #print ("Setting S1") # Setting point S1 client_ready.set() b1.prop = 10 assert (b1.prop == 10) df.commit() #print ("Client after first modification:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C2 #print ("Waiting for C2") server_ready.wait() server_ready.clear() #print ("Client after waiting for server:", df.versioned_heap.version_graph.nodes.keys()) df.push() #print ("Client after pushing:", df.versioned_heap.version_graph.nodes.keys()) # Setting point S2 #print ("Setting S2") client_ready.set() # Waiting at point c3 #print ("Waiting for C3") server_ready.wait() server_ready.clear() df.pull() #print ("Client after pulling second time:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() assert (b1.prop == 10) b1.prop = 5 df.commit() df.push() # Setting point S3 #print ("Setting S3") client_ready.set() # Waiting at point c4 #print ("Waiting for C4") server_ready.wait() server_ready.clear()
def server_df4(send_q, recv_q, server_ready, client_ready): df = Dataframe("SERVER_TEST4", [Car, Counter], resolver={Counter: counter_merge_func}) send_q.put(df.details) client_name = recv_q.get() # The server goes first. #print ("Server at start:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() #Add Counter to server c1 = Counter(0) car1 = Car(0) df.add_many(Counter, [c1]) df.add_many(Car, [car1]) assert (c1.count == 0) # Modify the counter value. c1.count += 1 assert (c1.count == 1) # Push record into server. df.commit() #print ("Server after adding 2 cars:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C1 #print ("Setting C1") server_ready.set() # Waiting at point S1 #print ("Waiting for S1") client_ready.wait() client_ready.clear() #print ("Server after waiting for client first time:", df.versioned_heap.version_graph.nodes.keys()) #print (df.versioned_heap.state_to_app) df.checkout() assert (c1.count == 1) c1.count += 1 assert (c1.count == 2) df.commit() #print (df.versioned_heap.state_to_app) #print ("Server after modifying once:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C2 #print ("Setting C2") server_ready.set() # Waiting at point S2 #print ("Waiting for S2") client_ready.wait() client_ready.clear() #print ("Server after waiting for client second time.:", df.versioned_heap.version_graph.nodes.keys()) # Check how the merge worked out. df.checkout() assert (c1.count == 3) # Setting point C3 #print ("Setting C3") server_ready.set() # Waiting at point S3 #print ("Waiting for S3") client_ready.wait() client_ready.clear()
def server_df4(send_q, recv_q, server_ready, client_ready): df = Dataframe("SERVER_TEST4", [Car, Counter]) send_q.put(df.details) client_name = recv_q.get() # The server goes first. #print ("Server at start:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() #Add Counter to server c1 = Counter(0) car1 = Car(0) df.add_many(Counter, [c1]) df.add_many(Car, [car1]) assert (c1.count == 0) # Modify the counter value. c1.count += 1 assert (c1.count == 1) # Push record into server. df.commit() #print ("Server after adding 2 cars:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C1 #print ("Setting C1") server_ready.set() # Waiting at point S1 #print ("Waiting for S1") client_ready.wait() client_ready.clear() #print ("Server after waiting for client first time:", df.versioned_heap.version_graph.nodes.keys()) #print (df.versioned_heap.state_to_app) df.checkout() assert (c1.count == 1) c1.count += 1 assert (c1.count == 2) df.commit() #print (df.versioned_heap.state_to_app) #print ("Server after modifying once:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C2 #print ("Setting C2") server_ready.set() # Waiting at point S2 #print ("Waiting for S2") client_ready.wait() client_ready.clear() #print ("Server after waiting for client second time.:", df.versioned_heap.version_graph.nodes.keys()) # Check how the merge worked out. df.checkout() assert (c1.count == 3) # Setting point C3 #print ("Setting C3") server_ready.set() # Waiting at point S3 #print ("Waiting for S3") client_ready.wait() client_ready.clear()
def client_df4(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [Counter], details=server_name, resolver={Counter: counter_merge_func}) send_q.put(df.details) #print ("Client at start:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C1 #print ("Waiting for C1") server_ready.wait() server_ready.clear() #print ("Client after waiting for server first time.:", df.versioned_heap.version_graph.nodes.keys()) # Pull from the server. df.pull() #print ("Client after first pull:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() counters = df.read_all(Counter) cars = df.read_all(Car) assert (1 == len(counters)) assert (0 == len(cars)) c1 = counters[0] assert (c1.count == 1) #print ("Setting S1") # Setting point S1 client_ready.set() c1.count += 1 assert (c1.count == 2) df.commit() #print ("Client after first modification:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C2 #print ("Waiting for C2") server_ready.wait() server_ready.clear() #print ("Client after waiting for server:", df.versioned_heap.version_graph.nodes.keys()) df.push() #print ("Client after pushing:", df.versioned_heap.version_graph.nodes.keys()) # Setting point S2 #print ("Setting S2") client_ready.set() # Waiting at point c3 #print ("Waiting for C3") server_ready.wait() server_ready.clear() df.pull() #print ("Client after pulling second time:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() assert (c1.count == 3) # Setting point S3 #print ("Setting S3") client_ready.set()
def client_df4(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [Counter], details=server_name) send_q.put(df.details) #print ("Client at start:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C1 #print ("Waiting for C1") server_ready.wait() server_ready.clear() #print ("Client after waiting for server first time.:", df.versioned_heap.version_graph.nodes.keys()) # Pull from the server. df.pull() #print ("Client after first pull:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() counters = df.read_all(Counter) cars = df.read_all(Car) assert (1 == len(counters)) assert (0 == len(cars)) c1 = counters[0] assert (c1.count == 1) #print ("Setting S1") # Setting point S1 client_ready.set() c1.count += 1 assert (c1.count == 2) df.commit() #print ("Client after first modification:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C2 #print ("Waiting for C2") server_ready.wait() server_ready.clear() #print ("Client after waiting for server:", df.versioned_heap.version_graph.nodes.keys()) df.push() #print ("Client after pushing:", df.versioned_heap.version_graph.nodes.keys()) # Setting point S2 #print ("Setting S2") client_ready.set() # Waiting at point c3 #print ("Waiting for C3") server_ready.wait() server_ready.clear() df.pull() #print ("Client after pulling second time:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() assert (c1.count == 3) # Setting point S3 #print ("Setting S3") client_ready.set()
def test_one_df_subset(self): df = Dataframe("test", [Car, ActiveCar]) car = Car(0, "BLUE") df.add_one(Car, car) df.commit() self.assertEqual(1, len(df.read_all(Car))) self.assertEqual(0, len(df.read_all(ActiveCar))) car.start((10, 10)) self.assertEqual(1, len(df.read_all(Car))) self.assertEqual(1, len(df.read_all(ActiveCar))) acar = df.read_one(ActiveCar, 0) self.assertEqual(acar.details, (0, 10, 10, 0, 0, "BLUE")) self.assertIsInstance(acar, ActiveCar) df.commit() self.assertEqual(1, len(df.read_all(Car))) self.assertEqual(1, len(df.read_all(ActiveCar))) self.assertEqual(acar.details, (0, 10, 10, 0, 0, "BLUE")) self.assertIsInstance(acar, ActiveCar)
def test_basic_delete2(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.push_call_back( "TEST2", [df.versioned_heap.version_graph.head.current, "NEXT"], { Car.__r_meta__.name: { 0: { "types": { Car.__r_meta__.name: Event.Delete } } } }) df.checkout() 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_delete2(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.push_call_back( "TEST2", [df.versioned_heap.version_graph.head.current, "NEXT"], { Car.__r_meta__.name: { 0: { "types": { Car.__r_meta__.name: Event.Delete } } } }) df.checkout() 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_df6(send_q, recv_q, server_ready, client_ready): df = Dataframe("SERVER_TEST6", [ClassWithCounter, Counter]) send_q.put(df.details) client_name = recv_q.get() # The server goes first. df.checkout() c1 = ClassWithCounter(0) df.add_one(Counter, c1.counter) df.add_one(ClassWithCounter, c1) c1.counter.count += 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()
def test_multiple_types(self): df1 = Dataframe("TEST1", [Car, Counter], version_by=VersionBy.TYPE) df2 = Dataframe("TEST2", [Car], details=df1.details, version_by=VersionBy.TYPE) appname1 = df1.appname appname2 = df2.appname c = Car(0) count = Counter(0) df2.checkout() df2.add_one(Car, c) c.xvel = 1 df2.commit() df1.checkout() df1.add_one(Counter, count) df1.commit() df2.sync() df1.checkout() self.assertEqual(1, len(df1.read_all(Car))) self.assertListEqual(list(), df2.read_all(Counter))
def server_df6(send_q, recv_q, server_ready, client_ready): df = Dataframe("SERVER_TEST6", [ClassWithCounter, Counter], resolver={Counter: counter_merge_func}) send_q.put(df.details) client_name = recv_q.get() # The server goes first. df.checkout() c1 = ClassWithCounter(0) df.add_one(Counter, c1.counter) df.add_one(ClassWithCounter, c1) c1.counter.count += 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()
def client_df6(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [ClassWithCounter, Counter], details=server_name) send_q.put(df.details) # Waiting at point C1 server_ready.wait() server_ready.clear() # Pull from the server. df.pull() df.checkout() ccs = df.read_all(ClassWithCounter) assert (1 == len(ccs)) c = ccs[0] assert ("counter" not in c.__dict__) assert ("oid" not in c.__dict__) assert (c.counter.oid is 0) assert (c.counter.count is 1) assert (c.oid is 0) df.commit() # Setting point S1 client_ready.set()
def client_df6(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [ClassWithCounter, Counter], details=server_name, resolver={Counter: counter_merge_func}) send_q.put(df.details) # Waiting at point C1 server_ready.wait() server_ready.clear() # Pull from the server. df.pull() df.checkout() ccs = df.read_all(ClassWithCounter) assert (1 == len(ccs)) c = ccs[0] assert ("counter" not in c.__dict__) assert ("oid" not in c.__dict__) assert (c.counter.oid is 0) assert (c.counter.count is 1) assert (c.oid is 0) df.commit() # Setting point S1 client_ready.set()
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 client_df2(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [Car], details=server_name) send_q.put(df.details) #print ("Client at start:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C1 #print ("Waiting for C1") server_ready.wait() server_ready.clear() #print ("Client after waiting for server first time.:", df.versioned_heap.version_graph.nodes.keys()) # Pull from the server. df.pull() #print ("Client after first pull:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() cars = df.read_all(Car) assert (2 == len(cars)) c1, c2 = cars #print ("Setting S1") # Setting point S1 client_ready.set() c2.yvel = 1 df.commit() #print ("Client after first modification:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C2 #print ("Waiting for C2") server_ready.wait() server_ready.clear() #print ("Client after waiting for server:", df.versioned_heap.version_graph.nodes.keys()) df.push() #print ("Client after pushing:", df.versioned_heap.version_graph.nodes.keys()) # Setting point S2 #print ("Setting S2") client_ready.set() # Waiting at point c3 #print ("Waiting for C3") server_ready.wait() server_ready.clear() df.pull() #print ("Client after pulling second time:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() c1 = df.read_one(Car, 0) c2 = df.read_one(Car, 1) 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 0) assert (c1.ypos is 0) assert (c1.oid is 0) 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 1) assert (c2.xpos is 0) assert (c2.ypos is 0) assert (c2.oid is 1) # Setting point S3 #print ("Setting S3") client_ready.set()
def server_df2(send_q, recv_q, server_ready, client_ready): df = Dataframe("SERVER_TEST2", [Car]) send_q.put(df.details) client_name = recv_q.get() # The server goes first. #print ("Server at start:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() #Add car to server c1 = Car(0) c2 = Car(1) df.add_many(Car, [c1, c2]) # Modify the car value. c1.xvel = 1 # Push record into server. df.commit() #print ("Server after adding 2 cars:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C1 #print ("Setting C1") server_ready.set() # Waiting at point S1 #print ("Waiting for S1") client_ready.wait() client_ready.clear() #print ("Server after waiting for client first time:", df.versioned_heap.version_graph.nodes.keys()) #print (df.versioned_heap.state_to_app) df.checkout() c1.yvel = 1 df.commit() #print (df.versioned_heap.state_to_app) #print ("Server after modifying once:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C2 #print ("Setting C2") server_ready.set() # Waiting at point S2 #print ("Waiting for S2") client_ready.wait() client_ready.clear() #print ("Server after waiting for client second time.:", df.versioned_heap.version_graph.nodes.keys()) # Check how the merge worked out. df.checkout() c1 = df.read_one(Car, 0) c2 = df.read_one(Car, 1) 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 0) assert (c1.ypos is 0) assert (c1.oid is 0) 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 1), c2.yvel assert (c2.xpos is 0) assert (c2.ypos is 0) assert (c2.oid is 1) # Setting point C3 #print ("Setting C3") server_ready.set() # Waiting at point S3 #print ("Waiting for S3") client_ready.wait() client_ready.clear()
def client_df1(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [Car], details=server_name) send_q.put(df.details) # Waiting at point C1 server_ready.wait() server_ready.clear() # Pull from the server. df.pull() df.checkout() cars = df.read_all(Car) assert (1 == len(cars)) c = cars[0] assert ("xvel" not in c.__dict__) assert ("yvel" not in c.__dict__) assert ("xpos" not in c.__dict__) assert ("ypos" not in c.__dict__) assert ("oid" not in c.__dict__) assert (c.xvel is 1) assert (c.yvel is 0) assert (c.xpos is 0) assert (c.ypos is 0) assert (c.oid is 0) df.commit() # Setting point S1 client_ready.set() # Waiting at point C2 server_ready.wait() server_ready.clear() df.pull() df.checkout() cars = df.read_all(Car) assert (1 == len(cars)) c = cars[0] assert ("xvel" not in c.__dict__) assert ("yvel" not in c.__dict__) assert ("xpos" not in c.__dict__) assert ("ypos" not in c.__dict__) assert ("oid" not in c.__dict__) assert (c.xvel is 1) assert (c.yvel is 1) assert (c.xpos is 0) assert (c.ypos is 0) assert (c.oid is 0) df.commit() df.checkout() c.xpos = 1 c.ypos = 1 c2 = Car(1) df.add_one(Car, c2) df.commit() df.push() # Setting point S2 client_ready.set() # Waiting at point C3 server_ready.wait() server_ready.clear() df.pull() df.checkout() assert (df.read_one(Car, 1) is None) assert (df.read_one(Car, 2) is None) # This does not work yet. Have to figure it out. # limitation of making it a framework rather than # a programming language itself. # Cannot invalidate old references without holding the # reference itself. #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) #assert (c2.__r_df__ is None) #assert (Car.__r_table__.object_table[1] == { # "oid": {"type": Datatype.INTEGER, "value": 0}, # "xvel": {"type": Datatype.INTEGER, "value": 0}, # "yvel": {"type": Datatype.INTEGER, "value": 0}, # "xpos": {"type": Datatype.INTEGER, "value": 0}, # "ypos": {"type": Datatype.INTEGER, "value": 0} # }) # Setting point S3 client_ready.set()
def server_df7(send_q, recv_q, server_ready, client_ready): df = Dataframe("SERVER_TEST7", [Blocker]) send_q.put(df.details) client_name = recv_q.get() # The server goes first. #print ("Server at start:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() #Add Counter to server b1 = Blocker(0) df.add_many(Blocker, [b1]) assert (b1.prop == 0) b1.prop += 1 assert (b1.prop == 1) # Push record into server. df.commit() #print ("Server after adding 2 cars:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C1 #print ("Setting C1") server_ready.set() # Waiting at point S1 #print ("Waiting for S1") client_ready.wait() client_ready.clear() #print ("Server after waiting for client first time:", df.versioned_heap.version_graph.nodes.keys()) #print (df.versioned_heap.state_to_app) df.checkout() assert (b1.prop == 1) b1.prop += 1 assert (b1.prop == 2) df.commit() #print (df.versioned_heap.state_to_app) #print ("Server after modifying once:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C2 #print ("Setting C2") server_ready.set() # Waiting at point S2 #print ("Waiting for S2") client_ready.wait() client_ready.clear() #print ("Server after waiting for client second time.:", df.versioned_heap.version_graph.nodes.keys()) # Check how the merge worked out. df.checkout() assert (b1.prop == 10), b1.prop # Setting point C3 #print ("Setting C3") server_ready.set() # Waiting at point S3 #print ("Waiting for S3") client_ready.wait() client_ready.clear() assert (b1.prop == 10) b1.prop = 20 assert (b1.prop == 20) df.commit() df.checkout() assert (b1.prop == 5) # Setting point C4 #print ("Setting C4") server_ready.set()
def client_df1(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [Car], details=server_name) send_q.put(df.details) # Waiting at point C1 server_ready.wait() server_ready.clear() # Pull from the server. df.pull() df.checkout() cars = df.read_all(Car) assert (1 == len(cars)) c = cars[0] assert ("xvel" not in c.__dict__) assert ("yvel" not in c.__dict__) assert ("xpos" not in c.__dict__) assert ("ypos" not in c.__dict__) assert ("oid" not in c.__dict__) assert (c.xvel is 1) assert (c.yvel is 0) assert (c.xpos is 0) assert (c.ypos is 0) assert (c.oid is 0) df.commit() # Setting point S1 client_ready.set() # Waiting at point C2 server_ready.wait() server_ready.clear() df.pull() df.checkout() cars = df.read_all(Car) assert (1 == len(cars)) c = cars[0] assert ("xvel" not in c.__dict__) assert ("yvel" not in c.__dict__) assert ("xpos" not in c.__dict__) assert ("ypos" not in c.__dict__) assert ("oid" not in c.__dict__) assert (c.xvel is 1) assert (c.yvel is 1) assert (c.xpos is 0) assert (c.ypos is 0) assert (c.oid is 0) df.commit() df.checkout() c.xpos = 1 c.ypos = 1 c2 = Car(1) df.add_one(Car, c2) df.commit() df.push() # Setting point S2 client_ready.set() # Waiting at point C3 server_ready.wait() server_ready.clear() df.pull() df.checkout() assert (df.read_one(Car, 1) is None) assert (df.read_one(Car, 2) is None) # This does not work yet. Have to figure it out. # limitation of making it a framework rather than # a programming language itself. # Cannot invalidate old references without holding the # reference itself. #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) #assert (c2.__r_df__ is None) #assert (Car.__r_table__.object_table[1] == { # "oid": {"type": Datatype.INTEGER, "value": 0}, # "xvel": {"type": Datatype.INTEGER, "value": 0}, # "yvel": {"type": Datatype.INTEGER, "value": 0}, # "xpos": {"type": Datatype.INTEGER, "value": 0}, # "ypos": {"type": Datatype.INTEGER, "value": 0} # }) # Setting point S3 client_ready.set()
def server_df2(send_q, recv_q, server_ready, client_ready): df = Dataframe("SERVER_TEST2", [Car]) send_q.put(df.details) client_name = recv_q.get() # The server goes first. #print ("Server at start:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() #Add car to server c1 = Car(0) c2 = Car(1) df.add_many(Car, [c1, c2]) # Modify the car value. c1.xvel = 1 # Push record into server. df.commit() #print ("Server after adding 2 cars:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C1 #print ("Setting C1") server_ready.set() # Waiting at point S1 #print ("Waiting for S1") client_ready.wait() client_ready.clear() #print ("Server after waiting for client first time:", df.versioned_heap.version_graph.nodes.keys()) #print (df.versioned_heap.state_to_app) df.checkout() c1.yvel = 1 df.commit() #print (df.versioned_heap.state_to_app) #print ("Server after modifying once:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C2 #print ("Setting C2") server_ready.set() # Waiting at point S2 #print ("Waiting for S2") client_ready.wait() client_ready.clear() #print ("Server after waiting for client second time.:", df.versioned_heap.version_graph.nodes.keys()) # Check how the merge worked out. df.checkout() c1 = df.read_one(Car, 0) c2 = df.read_one(Car, 1) 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 0) assert (c1.ypos is 0) assert (c1.oid is 0) 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 1), c2.yvel assert (c2.xpos is 0) assert (c2.ypos is 0) assert (c2.oid is 1) # Setting point C3 #print ("Setting C3") server_ready.set() # Waiting at point S3 #print ("Waiting for S3") client_ready.wait() client_ready.clear()
def server_df7(send_q, recv_q, server_ready, client_ready): df = Dataframe("SERVER_TEST7", [Blocker], resolver={Blocker: blocker_merge_func}) send_q.put(df.details) client_name = recv_q.get() # The server goes first. #print ("Server at start:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() #Add Counter to server b1 = Blocker(0) df.add_many(Blocker, [b1]) assert (b1.prop == 0) b1.prop += 1 assert (b1.prop == 1) # Push record into server. df.commit() #print ("Server after adding 2 cars:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C1 #print ("Setting C1") server_ready.set() # Waiting at point S1 #print ("Waiting for S1") client_ready.wait() client_ready.clear() #print ("Server after waiting for client first time:", df.versioned_heap.version_graph.nodes.keys()) #print (df.versioned_heap.state_to_app) df.checkout() assert (b1.prop == 1) b1.prop += 1 assert (b1.prop == 2) df.commit() #print (df.versioned_heap.state_to_app) #print ("Server after modifying once:", df.versioned_heap.version_graph.nodes.keys()) # Setting point C2 #print ("Setting C2") server_ready.set() # Waiting at point S2 #print ("Waiting for S2") client_ready.wait() client_ready.clear() #print ("Server after waiting for client second time.:", df.versioned_heap.version_graph.nodes.keys()) # Check how the merge worked out. df.checkout() assert (b1.prop == 10), b1.prop # Setting point C3 #print ("Setting C3") server_ready.set() # Waiting at point S3 #print ("Waiting for S3") client_ready.wait() client_ready.clear() assert (b1.prop == 10) b1.prop = 20 assert (b1.prop == 20) df.commit() df.checkout() assert (b1.prop == 5) # Setting point C4 #print ("Setting C4") server_ready.set()
def client_df5(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [Car], details=server_name) send_q.put(df.details) # Waiting at point C1 server_ready.wait() server_ready.clear() # Pull from the server. df.pull() df.checkout() cars = df.read_all(Car) assert (1 == len(cars)) c = cars[0] assert ("xvel" not in c.__dict__) assert ("yvel" not in c.__dict__) assert ("xpos" not in c.__dict__) assert ("ypos" not in c.__dict__) assert ("oid" not in c.__dict__) assert (c.xvel is 1) assert (c.yvel is 0) assert (c.xpos is 0) assert (c.ypos is 0) assert (c.oid is 0) df.commit() # Setting point S1 client_ready.set() # Waiting at point C2 server_ready.wait() server_ready.clear() df.pull() df.checkout() cars = df.read_all(Car) assert (1 == len(cars)) c = cars[0] assert ("xvel" not in c.__dict__) assert ("yvel" not in c.__dict__) assert ("xpos" not in c.__dict__) assert ("ypos" not in c.__dict__) assert ("oid" not in c.__dict__) assert (c.xvel is 1) assert (c.yvel is 1) assert (c.xpos is 0) assert (c.ypos is 0) assert (c.oid is 0) df.commit() df.checkout() c.xpos = 1 c.ypos = 1 c2 = Car(1) df.add_one(Car, c2) df.commit() df.push() # Setting point S2 client_ready.set() # Waiting at point C3 server_ready.wait() server_ready.clear() df.pull() df.checkout() assert (df.read_one(Car, 1) is None) assert (df.read_one(Car, 2) is None) # Setting point S3 client_ready.set()
def client_df2(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [Car], details=server_name) send_q.put(df.details) #print ("Client at start:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C1 #print ("Waiting for C1") server_ready.wait() server_ready.clear() #print ("Client after waiting for server first time.:", df.versioned_heap.version_graph.nodes.keys()) # Pull from the server. df.pull() #print ("Client after first pull:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() cars = df.read_all(Car) assert (2 == len(cars)) c1, c2 = cars #print ("Setting S1") # Setting point S1 client_ready.set() c2.yvel = 1 df.commit() #print ("Client after first modification:", df.versioned_heap.version_graph.nodes.keys()) # Waiting at point C2 #print ("Waiting for C2") server_ready.wait() server_ready.clear() #print ("Client after waiting for server:", df.versioned_heap.version_graph.nodes.keys()) df.push() #print ("Client after pushing:", df.versioned_heap.version_graph.nodes.keys()) # Setting point S2 #print ("Setting S2") client_ready.set() # Waiting at point c3 #print ("Waiting for C3") server_ready.wait() server_ready.clear() df.pull() #print ("Client after pulling second time:", df.versioned_heap.version_graph.nodes.keys()) df.checkout() c1 = df.read_one(Car, 0) c2 = df.read_one(Car, 1) 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 0) assert (c1.ypos is 0) assert (c1.oid is 0) 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 1) assert (c2.xpos is 0) assert (c2.ypos is 0) assert (c2.oid is 1) # Setting point S3 #print ("Setting S3") client_ready.set()
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_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 client_df5(send_q, recv_q, server_ready, client_ready): server_name = recv_q.get() df = Dataframe("CLIENT_TEST", [Car], details=server_name) send_q.put(df.details) # Waiting at point C1 server_ready.wait() server_ready.clear() # Pull from the server. df.pull() df.checkout() cars = df.read_all(Car) assert (1 == len(cars)) c = cars[0] assert ("xvel" not in c.__dict__) assert ("yvel" not in c.__dict__) assert ("xpos" not in c.__dict__) assert ("ypos" not in c.__dict__) assert ("oid" not in c.__dict__) assert (c.xvel is 1) assert (c.yvel is 0) assert (c.xpos is 0) assert (c.ypos is 0) assert (c.oid is 0) df.commit() # Setting point S1 client_ready.set() # Waiting at point C2 server_ready.wait() server_ready.clear() df.pull() df.checkout() cars = df.read_all(Car) assert (1 == len(cars)) c = cars[0] assert ("xvel" not in c.__dict__) assert ("yvel" not in c.__dict__) assert ("xpos" not in c.__dict__) assert ("ypos" not in c.__dict__) assert ("oid" not in c.__dict__) assert (c.xvel is 1) assert (c.yvel is 1) assert (c.xpos is 0) assert (c.ypos is 0) assert (c.oid is 0) df.commit() df.checkout() c.xpos = 1 c.ypos = 1 c2 = Car(1) df.add_one(Car, c2) df.commit() df.push() # Setting point S2 client_ready.set() # Waiting at point C3 server_ready.wait() server_ready.clear() df.pull() df.checkout() assert (df.read_one(Car, 1) is None) assert (df.read_one(Car, 2) is None) # Setting point S3 client_ready.set()