Fixing rosparam names in default endpoint launch file. (#80)

* Fixing package name in endpoint launch file (#78)

* Fixing package name in endpoint launch file

The endpoint launch file is trying to launch `ros_tcp_endpoint`, but the package has been renamed to just `ros_tcp_endpoint`.  Correcting the typo in the launch file.

* Change github workflow action to pre-commit/action@v2.0.3

* add debugging

* Temporarily disable pre-commit

Co-authored-by: Shuo Diao <shuo@unity3d.com>

* Fixing rosparam names in default endpoint launch file.

Co-authored-by: Shuo Diao <shuo@unity3d.com>

Author: mrpropellers

.github/workflows/pre-commit.yaml

@@ -10,5 +10,4 @@ jobs:
             - uses: actions/checkout@v2
             - uses: actions/setup-python@v2
               with:
-                  python-version: 3.7.x
-            - uses: pre-commit/action@v2.0.0
+                  python-version: 3.7.x

launch/endpoint.py

@@ -1,16 +1,17 @@
 from launch import LaunchDescription
 from launch_ros.actions import Node
 
+
 def generate_launch_description():
     return LaunchDescription([
         Node(
-            package='ros2_tcp_endpoint',
+            package='ros_tcp_endpoint',
             executable='default_server_endpoint',
             emulate_tty=True,
             parameters=[
-                {'/ROS_IP': '0.0.0.0'},
-                {'/ROS_TCP_PORT': 10000},
+                {'ROS_IP': '0.0.0.0'},
+                {'ROS_TCP_PORT': 10000},
             ],
         ),
     ])
-    
+    

ros_tcp_endpoint/server.py

@@ -37,7 +37,7 @@ class TcpServer(Node):
     Initializes ROS node and TCP server.
     """
 
-    def __init__(self, node_name, buffer_size=1024, connections=10, tcp_ip="", tcp_port=-1, timeout=10):
+    def __init__(self, node_name, buffer_size=1024, connections=10, tcp_ip=None, tcp_port=None):
         """
         Initializes ROS node and class variables.
 
@@ -48,15 +48,17 @@ def __init__(self, node_name, buffer_size=1024, connections=10, tcp_ip="", tcp_p
         """
         super().__init__(node_name)
 
-        self.declare_parameter("ROS_IP", "127.0.0.1")
+        self.declare_parameter("ROS_IP", "0.0.0.0")
         self.declare_parameter("ROS_TCP_PORT", 10000)
 
-        if tcp_ip != "":
+        if tcp_ip:
+            self.get_logger().log("Using ROS_IP override from constructor: {}".format(tcp_ip))
             self.tcp_ip = tcp_ip
         else:
             self.tcp_ip = self.get_parameter("ROS_IP").get_parameter_value().string_value
-            
-        if tcp_port != -1:
+
+        if tcp_port:
+            self.get_logger().log("Using ROS_TCP_PORT override from constructor: {}".format(tcp_port))
             self.tcp_port = tcp_port
         else:
             self.tcp_port = self.get_parameter("ROS_TCP_PORT").get_parameter_value().integer_value
@@ -70,15 +72,15 @@ def __init__(self, node_name, buffer_size=1024, connections=10, tcp_ip="", tcp_p
         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
         server_thread = threading.Thread(target=self.listen_loop)
         # Exit the server thread when the main thread terminates
         server_thread.daemon = True
         server_thread.start()
-        
+
     def listen_loop(self):
         """
             Creates and binds sockets using TCP variables then listens for incoming connections.
@@ -91,7 +93,7 @@ def listen_loop(self):
 
         while True:
             tcp_server.listen(self.connections)
-            
+
             try:
                 (conn, (ip, port)) = tcp_server.accept()
                 ClientThread(conn, self, ip, port).start()
@@ -119,7 +121,6 @@ def handle_syscommand(self, topic, data):
             params = json.loads(message_json)
             function(**params)
 
-
     def setup_executor(self):
         """
             Since rclpy.spin() is a blocking call the server needed a way
@@ -155,6 +156,7 @@ def destroy_nodes(self):
 
         self.destroy_node()
 
+
 class SysCommands:
     def __init__(self, tcp_server):
         self.tcp_server = tcp_server
@@ -169,7 +171,7 @@ def subscribe(self, topic, message_name):
         if message_class is None:
             self.tcp_server.send_unity_error("SysCommand.subscribe - Unknown message class '{}'".format(message_name))
             return
-        
+
         self.tcp_server.unregister_node(topic)
 
         new_subscriber = RosSubscriber(topic, message_class, self.tcp_server)
@@ -191,9 +193,9 @@ def publish(self, topic, message_name):
             return
 
         self.tcp_server.unregister_node(topic)
-                
+
         new_publisher = RosPublisher(topic, message_class, queue_size=10)
-        
+
         self.tcp_server.source_destination_dict[topic] = new_publisher
         if self.tcp_server.executor is not None:
             self.tcp_server.executor.add_node(new_publisher)
@@ -207,19 +209,20 @@ def ros_service(self, topic, message_name):
             return
         message_class = self.resolve_message_name(message_name, "srv")
         if message_class is None:
-            self.tcp_server.send_unity_error("RegisterRosService({}, {}) - Unknown service class '{}'".format(topic, message_name, message_name))
+            self.tcp_server.send_unity_error(
+                "RegisterRosService({}, {}) - Unknown service class '{}'".format(topic, message_name, message_name))
             return
 
         self.tcp_server.unregister_node(topic)
-        
+
         new_service = RosService(topic, message_class)
 
         self.tcp_server.source_destination_dict[topic] = new_service
         if self.tcp_server.executor is not None:
             self.tcp_server.executor.add_node(new_service)
 
         self.tcp_server.get_logger().info("RegisterRosService({}, {}) OK".format(topic, message_class))
-        
+
     def unity_service(self, topic, message_name):
         if topic == '':
             self.tcp_server.send_unity_error(
@@ -228,7 +231,8 @@ def unity_service(self, topic, message_name):
 
         message_class = self.resolve_message_name(message_name, "srv")
         if message_class is None:
-            self.tcp_server.send_unity_error("RegisterUnityService({}, {}) - Unknown service class '{}'".format(topic, message_name, message_name))
+            self.tcp_server.send_unity_error(
+                "RegisterUnityService({}, {}) - Unknown service class '{}'".format(topic, message_name, message_name))
             return
 
         self.tcp_server.unregister_node(topic)
@@ -238,15 +242,15 @@ def unity_service(self, topic, message_name):
         self.tcp_server.source_destination_dict[topic] = new_service
         if self.tcp_server.executor is not None:
             self.tcp_server.executor.add_node(new_service)
-        
+
         self.tcp_server.get_logger().info("RegisterUnityService({}, {}) OK".format(topic, message_class))
 
-    def response(self, srv_id): # the next message is a service response
-        self.tcp_server.pending_srv_id = srv_id 
+    def response(self, srv_id):  # the next message is a service response
+        self.tcp_server.pending_srv_id = srv_id
         self.tcp_server.pending_srv_is_request = False
 
-    def request(self, srv_id): # the next message is a service request
-        self.tcp_server.pending_srv_id = srv_id 
+    def request(self, srv_id):  # the next message is a service request
+        self.tcp_server.pending_srv_id = srv_id
         self.tcp_server.pending_srv_is_request = True
 
     def topic_list(self):
@@ -257,7 +261,7 @@ def resolve_message_name(self, name, extension="msg"):
             names = name.split('/')
             module_name = names[0]
             class_name = names[1]
-            importlib.import_module(module_name+ "." + extension)
+            importlib.import_module(module_name + "." + extension)
             module = sys.modules[module_name]
             if module is None:
                 self.tcp_server.get_logger().error("Failed to resolve module {}".format(module_name))
@@ -266,7 +270,8 @@ def resolve_message_name(self, name, extension="msg"):
                 self.tcp_server.get_logger().error("Failed to resolve module {}.{}".format(module_name, extension))
             module = getattr(module, class_name)
             if module is None:
-                self.tcp_server.get_logger().error("Failed to resolve module {}.{}.{}".format(module_name, extension, class_name))
+                self.tcp_server.get_logger().error(
+                    "Failed to resolve module {}.{}.{}".format(module_name, extension, class_name))
             return module
         except (IndexError, KeyError, AttributeError, ImportError) as e:
             self.tcp_server.get_logger().error("Failed to resolve message name: {}".format(e))