feat: first client->server test is passing

replication.py

@@ -37,8 +37,10 @@ class ReplicatedDataFactory(object):
 
     def match_type_by_name(self,type_name):
         for stypes, implementation in self.supported_types: 
-            if type_name == implementation.__class__.__name__:
+            if type_name == stypes.__name__:
                 return implementation
+        
+        return None
 
     def construct_from_dcc(self,data):
         implementation = self.match_type_by_instance(data)
@@ -48,7 +50,7 @@ class ReplicatedDataFactory(object):
         """
         Reconstruct a new replicated value from serialized data
         """
-        return self.match_type_by_name(data)
+        return self.match_type_by_name(type_name)
 
 class ReplicatedDatablock(object):
     """
@@ -66,7 +68,7 @@ class ReplicatedDatablock(object):
         assert(owner)
         self.owner = owner
         self.pointer = data
-        self.str_type = self.data.__class__.__name__
+        self.str_type = type(data).__name__
         
 
     def push(self, socket):
@@ -81,8 +83,8 @@ class ReplicatedDatablock(object):
         key = self.uuid.encode()
         type = self.str_type.encode()
 
-        socket.send_multipart([key,owner,str_type,data])
-   
+        socket.send_multipart([key,owner,type,data])
+  
     @classmethod
     def pull(cls, socket, factory):
         """
@@ -92,9 +94,14 @@ class ReplicatedDatablock(object):
         """
         uuid, owner,str_type, data = socket.recv_multipart(zmq.NOBLOCK)
 
-        instance = factory.construct_from_net(str_type.decode())(owner=owner.decode(), uuid=uuid.decode())
 
-        instance.data = instance.deserialize(data)
+        str_type = str_type.decode()
+        owner=owner.decode()
+        uuid=uuid.decode()
+
+        instance = factory.construct_from_net(str_type)(owner=owner, uuid=uuid)
+
+        # instance.data = instance.deserialize(data)
         return instance
 
 

replication_client.py

@@ -108,18 +108,18 @@ class ClientNetService(threading.Thread):
 
 class Server():
     def __init__(self,config=None, factory=None):
-        self.rep_store = {}
-        self.net = ServerNetService(store_reference=self.rep_store, factory=factory)
+        self._rep_store = {}
+        self._net = ServerNetService(store_reference=self._rep_store, factory=factory)
         # self.serve()
 
     def serve(self):
-        self.net.start()
+        self._net.start()
 
     def state(self):
-        return self.net.state
+        return self._net.state
 
     def stop(self):
-        self.net.stop()
+        self._net.stop()
 
 
 class ServerNetService(threading.Thread):
@@ -129,7 +129,7 @@ class ServerNetService(threading.Thread):
         self.name = "ServerNetLink"
         self.daemon = True
         self.exit_event = threading.Event()
-        self.store =  store_reference
+        self._rep_store =  store_reference
 
         self.context = zmq.Context.instance()
         self.snapshot = None
@@ -207,7 +207,7 @@ class ServerNetService(threading.Thread):
                 log.info("Receiving changes from client")
                 msg = ReplicatedDatablock.pull(self.pull, self.factory)
 
-                msg.store(self.store)
+                msg.store(self._rep_store)
                 # msg = message.Message.recv(self.collector_sock)
                 # # logger.info("received object")
                 # # Update all clients

test_replication.py

@@ -28,37 +28,7 @@ class RepSampleData(ReplicatedDatablock):
 
         return pickle.load(data)
 
-
-# class TestClient(unittest.TestCase):
-#     def setUp(self):
-#         factory = ReplicatedDataFactory()
-#         self.client_api = Client(factory=factory)
-
-#     def test_client_connect(self):
-#         self.client_api.connect()
-#         time.sleep(1)
-#         self.assertEqual(self.client_api._net.state,1)
-        
-
-#     def test_client_disconnect(self):
-#         self.client_api.disconnect()
-#         time.sleep(1)
-#         self.assertEqual(self.client_api._net.state,0)
-
-
-
 class TestDataReplication(unittest.TestCase):
-    # def test_server_launching(self):
-    #     log.info("test_server_launching")
-    #     self.server_api.serve()
-    #     time.sleep(1)
-    #     self.assertEqual(self.server_api.state(),1)
-
-    # def test_server_stop(self):
-    #     log.info("test_server_launching")
-    #     self.server_api.stop()
-    #     time.sleep(1)
-    #     self.assertEqual(self.server_api.state(),0)
 
     def test_setup_data_factory(self):
         factory = ReplicatedDataFactory()
@@ -80,8 +50,11 @@ class TestDataReplication(unittest.TestCase):
         data_sample = SampleData()
         data_sample_key = client_api.register(data_sample)
 
-        
-        self.assertNotEqual(client_api._rep_store[data_sample_key],None)
+        #Waiting for server to receive the datas
+        time.sleep(.1)
+
+        #Check if if receive them
+        self.assertNotEqual(server_api._rep_store[data_sample_key],None)