コード例 #1
0
    def test_push1(self):
        df1 = Dataframe("TEST1", [Car])
        df2 = Dataframe("TEST2", [Car], details=df1.details)
        appname1 = df1.appname
        appname2 = df2.appname
        c = Car(0)

        df2.checkout()
        df2.add_one(Car, c)
        c.xvel = 1
        df2.sync()
        version1 = df1.versioned_heap.version_graph.head.current
        version2 = df2.versioned_heap.version_graph.head.current
        self.assertEqual(version1, version2)
        self.assertDictEqual(df1.versioned_heap.state_to_app, {
            "ROOT": set([appname2]),
            version1: set([appname2])
        })
        self.assertDictEqual(df1.versioned_heap.app_to_state,
                             {appname2: version1})

        self.assertDictEqual(df2.versioned_heap.state_to_app, {
            'ROOT': {appname2},
            version1: {'SOCKETPARENT', appname2}
        })
        self.assertDictEqual(df2.versioned_heap.app_to_state, {
            appname2: version1,
            "SOCKETPARENT": version1
        })
コード例 #2
0
ファイル: test2.py プロジェクト: Mondego/spacetime
 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)
コード例 #3
0
ファイル: test2.py プロジェクト: Mondego/spacetime
    def test_push1(self):
        df1 = Dataframe("TEST1", [Car])
        df2 = Dataframe("TEST2", [Car], details=df1.details)
        appname1 = df1.appname
        appname2 = df2.appname
        c = Car(0)
        
        df2.checkout()
        df2.add_one(Car, c)
        c.xvel = 1
        df2.sync()
        version1 = df1.versioned_heap.version_graph.head.current
        version2 = df2.versioned_heap.version_graph.head.current
        self.assertEqual(version1, version2)
        self.assertDictEqual(
            df1.versioned_heap.state_to_app, {"ROOT": set([appname2]), version1: set([appname2])})
        self.assertDictEqual(
            df1.versioned_heap.app_to_state, {appname2: version1})

        self.assertDictEqual(
            df2.versioned_heap.state_to_app,
            {'ROOT': {appname2}, version1: {'SOCKETPARENT', appname2}})
        self.assertDictEqual(
            df2.versioned_heap.app_to_state,
            {appname2: version1, "SOCKETPARENT": version1})
コード例 #4
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)
コード例 #5
0
 def test_basic(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)
コード例 #6
0
 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)
コード例 #7
0
ファイル: test2.py プロジェクト: Mondego/spacetime
 def test_basic(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)
コード例 #8
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)
コード例 #9
0
ファイル: test2.py プロジェクト: Mondego/spacetime
 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)
コード例 #10
0
ファイル: test2.py プロジェクト: Mondego/spacetime
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()
コード例 #11
0
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()
コード例 #12
0
ファイル: test2.py プロジェクト: pridawn/spacetime
    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))
コード例 #13
0
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()
コード例 #14
0
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()
コード例 #15
0
ファイル: test2.py プロジェクト: Mondego/spacetime
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()
コード例 #16
0
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()
コード例 #17
0
ファイル: test2.py プロジェクト: Mondego/spacetime
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()
コード例 #18
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
コード例 #19
0
ファイル: test2.py プロジェクト: Mondego/spacetime
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()