source_destination_dict shatters into 4 separate tables (#93)

* source_destination_dict shatters into 4 separate tables

* Update tests

* 1 more test fix

Author: LaurieCheers-unity

src/ros_tcp_endpoint/client.py

@@ -34,7 +34,9 @@ def __init__(self, conn, tcp_server, incoming_ip, incoming_port):
         Set class variables
         Args:
             conn:
-            source_destination_dict: dictionary of destination name to RosCommunicator class
+            tcp_server: server object
+            incoming_ip: connected from this IP address
+            incoming_port: connected from this port
         """
         self.conn = conn
         self.tcp_server = tcp_server
@@ -149,16 +151,16 @@ def serialize_command(command, params):
         return cmd_info + json_info
 
     def send_ros_service_request(self, srv_id, destination, data):
-        if destination not in self.tcp_server.source_destination_dict.keys():
-            error_msg = "Service destination '{}' is not registered! Known topics are: {} ".format(
-                destination, self.tcp_server.source_destination_dict.keys()
+        if destination not in self.tcp_server.ros_services.keys():
+            error_msg = "Service destination '{}' is not registered! Known services are: {} ".format(
+                destination, self.tcp_server.ros_services.keys()
             )
             self.tcp_server.send_unity_error(error_msg)
             rospy.logerr(error_msg)
             # TODO: send a response to Unity anyway?
             return
         else:
-            ros_communicator = self.tcp_server.source_destination_dict[destination]
+            ros_communicator = self.tcp_server.ros_services[destination]
             service_thread = threading.Thread(
                 target=self.service_call_thread, args=(srv_id, destination, data, ros_communicator)
             )
@@ -179,8 +181,8 @@ def service_call_thread(self, srv_id, destination, data, ros_communicator):
 
     def run(self):
         """
-        Read a message and determine where to send it based on the source_destination_dict
-         and destination string. Then send the read message.
+        Receive a message from Unity and determine where to send it based on the publishers table
+         and topic string. Then send the read message.
 
         If there is a response after sending the serialized data, assume it is a
         ROS service response.
@@ -199,6 +201,7 @@ def run(self):
             while not halt_event.is_set():
                 destination, data = self.read_message(self.conn)
 
+                # Process this message that was sent from Unity
                 if self.tcp_server.pending_srv_id is not None:
                     # if we've been told that the next message will be a service request/response, process it as such
                     if self.tcp_server.pending_srv_is_request:
@@ -216,12 +219,12 @@ def run(self):
                 elif destination.startswith("__"):
                     # handle a system command, such as registering new topics
                     self.tcp_server.handle_syscommand(destination, data)
-                elif destination in self.tcp_server.source_destination_dict:
-                    ros_communicator = self.tcp_server.source_destination_dict[destination]
-                    response = ros_communicator.send(data)
+                elif destination in self.tcp_server.publishers:
+                    ros_communicator = self.tcp_server.publishers[destination]
+                    ros_communicator.send(data)
                 else:
-                    error_msg = "Topic '{}' is not registered! Known topics are: {} ".format(
-                        destination, self.tcp_server.source_destination_dict.keys()
+                    error_msg = "Not registered to publish topic '{}'! Valid publish topics are: {} ".format(
+                        destination, self.tcp_server.publishers.keys()
                     )
                     self.tcp_server.send_unity_error(error_msg)
                     rospy.logerr(error_msg)

src/ros_tcp_endpoint/server.py

@@ -55,16 +55,21 @@ def __init__(self, node_name, buffer_size=1024, connections=2, tcp_ip="", tcp_po
         self.unity_tcp_sender = UnityTcpSender()
 
         self.node_name = node_name
-        self.source_destination_dict = {}
+        self.publishers = {}
+        self.subscribers = {}
+        self.ros_services = {}
+        self.unity_services = {}
         self.buffer_size = buffer_size
         self.connections = connections
         self.syscommands = SysCommands(self)
         self.pending_srv_id = None
         self.pending_srv_is_request = False
 
-    def start(self, source_destination_dict=None):
-        if source_destination_dict is not None:
-            self.source_destination_dict = source_destination_dict
+    def start(self, publishers=None, subscribers=None):
+        if publishers is not None:
+            self.publishers = publishers
+        if subscribers is not None:
+            self.subscribers = subscribers
         server_thread = threading.Thread(target=self.listen_loop)
         # Exit the server thread when the main thread terminates
         server_thread.daemon = True
@@ -134,12 +139,10 @@ def subscribe(self, topic, message_name):
 
         rospy.loginfo("RegisterSubscriber({}, {}) OK".format(topic, message_class))
 
-        if topic in self.tcp_server.source_destination_dict:
-            self.tcp_server.source_destination_dict[topic].unregister()
+        if topic in self.tcp_server.subscribers:
+            self.tcp_server.subscribers[topic].unregister()
 
-        self.tcp_server.source_destination_dict[topic] = RosSubscriber(
-            topic, message_class, self.tcp_server
-        )
+        self.tcp_server.subscribers[topic] = RosSubscriber(topic, message_class, self.tcp_server)
 
     def publish(self, topic, message_name, queue_size=10, latch=False):
         if topic == "":
@@ -159,12 +162,10 @@ def publish(self, topic, message_name, queue_size=10, latch=False):
 
         rospy.loginfo("RegisterPublisher({}, {}) OK".format(topic, message_class))
 
-        if topic in self.tcp_server.source_destination_dict:
-            self.tcp_server.source_destination_dict[topic].unregister()
+        if topic in self.tcp_server.publishers:
+            self.tcp_server.publishers[topic].unregister()
 
-        self.tcp_server.source_destination_dict[topic] = RosPublisher(
-            topic, message_class, queue_size, latch
-        )
+        self.tcp_server.publishers[topic] = RosPublisher(topic, message_class, queue_size, latch)
 
     def ros_service(self, topic, message_name):
         if topic == "":
@@ -186,10 +187,10 @@ def ros_service(self, topic, message_name):
 
         rospy.loginfo("RegisterRosService({}, {}) OK".format(topic, message_class))
 
-        if topic in self.tcp_server.source_destination_dict:
-            self.tcp_server.source_destination_dict[topic].unregister()
+        if topic in self.tcp_server.ros_services:
+            self.tcp_server.ros_services[topic].unregister()
 
-        self.tcp_server.source_destination_dict[topic] = RosService(topic, message_class)
+        self.tcp_server.ros_services[topic] = RosService(topic, message_class)
 
     def unity_service(self, topic, message_name):
         if topic == "":
@@ -211,12 +212,10 @@ def unity_service(self, topic, message_name):
 
         rospy.loginfo("RegisterUnityService({}, {}) OK".format(topic, message_class))
 
-        if topic in self.tcp_server.source_destination_dict:
-            self.tcp_server.source_destination_dict[topic].unregister()
+        if topic in self.tcp_server.unity_services:
+            self.tcp_server.unity_services[topic].unregister()
 
-        self.tcp_server.source_destination_dict[topic] = UnityService(
-            topic, message_class, self.tcp_server
-        )
+        self.tcp_server.unity_services[topic] = UnityService(topic, message_class, self.tcp_server)
 
     def response(self, srv_id):  # the next message is a service response
         self.tcp_server.pending_srv_id = srv_id

test/test_server.py

@@ -49,7 +49,7 @@ def test_unity_service_resolve_message_name_failure():
 )
 def test_unity_service_resolve_news_service(mock_resolve_message, mock_ros_service):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
-    assert server.source_destination_dict == {}
+    assert server.ros_services == {}
     system_cmds = SysCommands(server)
     result = system_cmds.unity_service("get_pos", "unity_interfaces.msg/RosUnitySrvMessage")
     mock_ros_service.assert_called_once
@@ -64,7 +64,7 @@ def test_unity_service_resolve_news_service(mock_resolve_message, mock_ros_servi
 )
 def test_unity_service_resolve_existing_service(mock_resolve_message, mock_ros_service):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
-    server.source_destination_dict = {"get_pos": mock.Mock()}
+    server.ros_services = {"get_pos": mock.Mock()}
     system_cmds = SysCommands(server)
     result = system_cmds.unity_service("get_pos", "unity_interfaces.msg/RosUnitySrvMessage")
     mock_ros_service.assert_called_once
@@ -85,31 +85,31 @@ def test_resolve_message_name(mock_import_module, mock_sys_modules):
 def test_publish_add_new_topic(mock_ros_publisher):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).publish("object_pos_topic", "std_msgs/Bool")
-    assert server.source_destination_dict != {}
+    assert server.publishers != {}
     mock_ros_publisher.assert_called_once
 
 
 @mock.patch.object(rospy, "Publisher")
 def test_publish_existing_topic(mock_ros_publisher):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
-    server.source_destination_dict = {"object_pos_topic": mock.Mock()}
+    server.publishers = {"object_pos_topic": mock.Mock()}
     result = SysCommands(server).publish("object_pos_topic", "std_msgs/Bool")
-    assert server.source_destination_dict["object_pos_topic"] is not None
+    assert server.publishers["object_pos_topic"] is not None
     mock_ros_publisher.assert_called_once
 
 
 def test_publish_empty_topic_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).publish("", "pos")
     assert result is None
-    assert server.source_destination_dict == {}
+    assert server.publishers == {}
 
 
 def test_publish_empty_message_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).publish("test-topic", "")
     assert result is None
-    assert server.source_destination_dict == {}
+    assert server.publishers == {}
 
 
 @mock.patch.object(rospy, "Subscriber")
@@ -119,7 +119,7 @@ def test_publish_empty_message_should_return_none():
 def test_subscribe_to_new_topic(mock_resolve_msg, mock_ros_subscriber):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).subscribe("object_pos_topic", "pos")
-    assert server.source_destination_dict != {}
+    assert server.subscribers != {}
     mock_ros_subscriber.assert_called_once
 
 
@@ -129,54 +129,54 @@ def test_subscribe_to_new_topic(mock_resolve_msg, mock_ros_subscriber):
 )
 def test_subscribe_to_existing_topic(mock_resolve_msg, mock_ros_subscriber):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
-    server.source_destination_dict = {"object_pos_topic": mock.Mock()}
+    server.subscribers = {"object_pos_topic": mock.Mock()}
     result = SysCommands(server).subscribe("object_pos_topic", "pos")
-    assert server.source_destination_dict["object_pos_topic"] is not None
+    assert server.subscribers["object_pos_topic"] is not None
     mock_ros_subscriber.assert_called_once
 
 
 def test_subscribe_to_empty_topic_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).subscribe("", "pos")
     assert result is None
-    assert server.source_destination_dict == {}
+    assert server.subscribers == {}
 
 
 def test_subscribe_to_empty_message_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).subscribe("test-topic", "")
     assert result is None
-    assert server.source_destination_dict == {}
+    assert server.subscribers == {}
 
 
 @mock.patch.object(rospy, "ServiceProxy")
 @mock.patch.object(ros_tcp_endpoint.server, "resolve_message_name")
 def test_ros_service_new_topic(mock_resolve_msg, mock_ros_service):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).ros_service("object_pos_topic", "pos")
-    assert server.source_destination_dict != {}
+    assert server.ros_services != {}
     mock_ros_service.assert_called_once
 
 
 @mock.patch.object(rospy, "ServiceProxy")
 @mock.patch.object(ros_tcp_endpoint.server, "resolve_message_name")
 def test_ros_service_existing_topic(mock_resolve_msg, mock_ros_service):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
-    server.source_destination_dict = {"object_pos_topic": mock.Mock()}
+    server.ros_services = {"object_pos_topic": mock.Mock()}
     result = SysCommands(server).ros_service("object_pos_topic", "pos")
-    assert server.source_destination_dict["object_pos_topic"] is not None
+    assert server.ros_services["object_pos_topic"] is not None
     mock_ros_service.assert_called_once
 
 
 def test_ros_service_empty_topic_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).ros_service("", "pos")
     assert result is None
-    assert server.source_destination_dict == {}
+    assert server.ros_services == {}
 
 
 def test_ros_service_empty_message_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).ros_service("test-topic", "")
     assert result is None
-    assert server.source_destination_dict == {}
+    assert server.ros_services == {}