From dfcf70f8f5fb6b730f518452138afb436d4f1a40 Mon Sep 17 00:00:00 2001
From: Juan Ignacio Ubeira <jubeira@ekumenlabs.com>
Date: Tue, 25 Jun 2019 17:23:01 -0300
Subject: [PATCH] Porting rosapi package. (#388)

Porting rosapi package.

Signed-off-by: Juan Ignacio Ubeira <jubeira@ekumenlabs.com>
---
 rosapi/package.xml                            |   6 +
 rosapi/scripts/rosapi_node                    | 328 ++++++++++--------
 rosapi/src/rosapi/glob_helper.py              |  32 +-
 rosapi/src/rosapi/objectutils.py              |   4 +-
 rosapi/src/rosapi/params.py                   | 158 +++++++--
 rosapi/src/rosapi/proxy.py                    | 274 +++++++--------
 rosapi/srv/DeleteParam.srv                    |   1 +
 rosapi/srv/GetParam.srv                       |   1 +
 rosapi/srv/GetParamNames.srv                  |   1 +
 rosapi/srv/HasParam.srv                       |   1 +
 rosapi/srv/SetParam.srv                       |   1 +
 .../rosbridge_library/internal/ros_loader.py  |  25 +-
 12 files changed, 490 insertions(+), 342 deletions(-)

diff --git a/rosapi/package.xml b/rosapi/package.xml
index 314a0809e..0a8770ffb 100644
--- a/rosapi/package.xml
+++ b/rosapi/package.xml
@@ -22,7 +22,13 @@
   <buildtool_depend>rosidl_default_generators</buildtool_depend>
 
   <exec_depend>rclpy</exec_depend>
+  <exec_depend>rcl_interfaces</exec_depend>
   <exec_depend>rosbridge_library</exec_depend>
+  <exec_depend>ros2node</exec_depend>
+  <exec_depend>ros2param</exec_depend>
+  <exec_depend>ros2pkg</exec_depend>
+  <exec_depend>ros2service</exec_depend>
+  <exec_depend>ros2topic</exec_depend>
   <!--
   <exec_depend>rosnode</exec_depend>
   <exec_depend>rosgraph</exec_depend>
diff --git a/rosapi/scripts/rosapi_node b/rosapi/scripts/rosapi_node
index f661ddbae..e8d763c35 100755
--- a/rosapi/scripts/rosapi_node
+++ b/rosapi/scripts/rosapi_node
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # Software License Agreement (BSD License)
 #
 # Copyright (c) 2012, Willow Garage, Inc.
@@ -31,149 +31,190 @@
 # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 
-import rospy
+import sys
 
-from rosapi import proxy, objectutils, params
-from rosapi.glob_helper import get_globs
+import rclpy
+from rclpy.clock import Clock, ClockType
+from rclpy.node import Node
+
+from rosapi import glob_helper, proxy, objectutils, params
 from rosapi.srv import *
 from rosapi.msg import *
 
 
-# Initialises the ROS node
-def register_services():
-    rospy.Service('/rosapi/topics', Topics, get_topics)
-    rospy.Service('/rosapi/topics_for_type', TopicsForType, get_topics_for_type)
-    rospy.Service('/rosapi/services', Services, get_services)
-    rospy.Service('/rosapi/services_for_type', ServicesForType, get_services_for_type)
-    rospy.Service('/rosapi/nodes', Nodes, get_nodes)
-    rospy.Service('/rosapi/node_details', NodeDetails, get_node_details)
-    rospy.Service('/rosapi/action_servers', GetActionServers, get_action_servers)
-    rospy.Service('/rosapi/topic_type', TopicType, get_topic_type)
-    rospy.Service('/rosapi/service_type', ServiceType, get_service_type)
-    rospy.Service('/rosapi/publishers', Publishers, get_publishers)
-    rospy.Service('/rosapi/subscribers', Subscribers, get_subscribers)
-    rospy.Service('/rosapi/service_providers', ServiceProviders, get_service_providers)
-    rospy.Service('/rosapi/service_node', ServiceNode, get_service_node)
-    rospy.Service('/rosapi/service_host', ServiceHost, get_service_host)
-    rospy.Service('/rosapi/message_details', MessageDetails, get_message_details)
-    rospy.Service('/rosapi/service_request_details', ServiceRequestDetails, get_service_request_details)
-    rospy.Service('/rosapi/service_response_details', ServiceResponseDetails, get_service_response_details)
-    rospy.Service('/rosapi/set_param', SetParam, set_param)
-    rospy.Service('/rosapi/get_param', GetParam, get_param)
-    rospy.Service('/rosapi/has_param', HasParam, has_param)
-    rospy.Service('/rosapi/search_param', SearchParam, search_param)
-    rospy.Service('/rosapi/delete_param', DeleteParam, delete_param)
-    rospy.Service('/rosapi/get_param_names', GetParamNames, get_param_names)
-    rospy.Service('/rosapi/get_time', GetTime, get_time)
-
-def get_topics(request):
-    """ Called by the rosapi/Topics service. Returns a list of all the topics being published. """
-    topics, types = proxy.get_topics_and_types(rosapi.glob_helper.topics_glob)
-    return TopicsResponse(topics, types)
-
-def get_topics_for_type(request):
-    """ Called by the rosapi/TopicsForType service. Returns a list of all the topics that are publishing a given type """
-    return TopicsForTypeResponse(proxy.get_topics_for_type(request.type, rosapi.glob_helper.topics_glob))
-
-def get_services(request):
-    """ Called by the rosapi/Services service. Returns a list of all the services being advertised. """
-    return ServicesResponse(proxy.get_services(rosapi.glob_helper.services_glob))
-
-def get_services_for_type(request):
-    """ Called by the rosapi/ServicesForType service. Returns a list of all the services that are publishing a given type """
-    return ServicesForTypeResponse(proxy.get_services_for_type(request.type, rosapi.glob_helper.services_glob))
-
-def get_nodes(request):
-    """ Called by the rosapi/Nodes service. Returns a list of all the nodes that are registered """
-    return NodesResponse(proxy.get_nodes())
-    
-def get_node_details(request):
-    """ Called by the rosapi/Nodes service. Returns a node description """
-    node = request.node
-    return NodeDetailsResponse(proxy.get_node_subscriptions(node), proxy.get_node_publications(node), proxy.get_node_services(node))
-    
-def get_action_servers(request):
-    """ Called by the rosapi/GetActionServers service. Returns a list of action servers based on actions standard topics """
-    topics = proxy.get_topics(rosapi.glob_helper.topics_glob)
-    action_servers = proxy.filter_action_servers(topics)
-    return GetActionServersResponse(action_servers)
-def get_topic_type(request):
-    """ Called by the rosapi/TopicType service.  Given the name of a topic, returns the name of the type of that topic.
-    Request class has one field, 'topic', which is a string value (the name of the topic)
-    Response class has one field, 'type', which is a string value (the type of the topic)
-    If the topic does not exist, an empty string is returned. """
-    return TopicTypeResponse(proxy.get_topic_type(request.topic, rosapi.glob_helper.topics_glob))
-    
-def get_service_type(request):
-    """ Called by the rosapi/ServiceType service.  Given the name of a service, returns the type of that service
-    Request class has one field, 'service', which is a string value (the name of the service)
-    Response class has one field, 'type', which is a string value (the type of the service)
-    If the service does not exist, an empty string is returned. """
-    return ServiceTypeResponse(proxy.get_service_type(request.service, rosapi.glob_helper.services_glob))
-
-def get_publishers(request):
-    """ Called by the rosapi/Publishers service.  Given the name of a topic, returns a list of node names
-    that are publishing on that topic. """
-    return PublishersResponse(proxy.get_publishers(request.topic, rosapi.glob_helper.topics_glob))
-
-def get_subscribers(request):
-    """ Called by the rosapi/Subscribers service.  Given the name of a topic, returns a list of node names
-    that are subscribing to that topic. """
-    return SubscribersResponse(proxy.get_subscribers(request.topic, rosapi.glob_helper.topics_glob))
-
-def get_service_providers(request):
-    """ Called by the rosapi/ServiceProviders service.  Given the name of a topic, returns a list of node names
-    that are advertising that service type """
-    return ServiceProvidersResponse(proxy.get_service_providers(request.service, rosapi.glob_helper.services_glob))
-
-def get_service_node(request):
-    """ Called by the rosapi/ServiceNode service.  Given the name of a service, returns the name of the node
-    that is providing that service. """
-    return ServiceNodeResponse(proxy.get_service_node(request.service))
-
+class Rosapi(Node):
+
+    def __init__(self):
+        super().__init__('rosapi')
+        self.globs = self.get_globs()
+        self.register_services()
+
+    # Initialises the ROS node
+    def register_services(self):
+        proxy.init(self)
+        params.init()
+        self.create_service(Topics, '/rosapi/topics', self.get_topics)
+        self.create_service(TopicsForType, '/rosapi/topics_for_type', self.get_topics_for_type)
+        self.create_service(Services, '/rosapi/services', self.get_services)
+        self.create_service(ServicesForType, '/rosapi/services_for_type', self.get_services_for_type)
+        self.create_service(Nodes, '/rosapi/nodes', self.get_nodes)
+        self.create_service(NodeDetails, '/rosapi/node_details', self.get_node_details)
+        self.create_service(GetActionServers, '/rosapi/action_servers', self.get_action_servers)
+        self.create_service(TopicType, '/rosapi/topic_type', self.get_topic_type)
+        self.create_service(ServiceType, '/rosapi/service_type', self.get_service_type)
+        self.create_service(Publishers, '/rosapi/publishers', self.get_publishers)
+        self.create_service(Subscribers, '/rosapi/subscribers', self.get_subscribers)
+        self.create_service(ServiceProviders, '/rosapi/service_providers', self.get_service_providers)
+        self.create_service(ServiceNode, '/rosapi/service_node', self.get_service_node)
+        self.create_service(MessageDetails, '/rosapi/message_details', self.get_message_details)
+        self.create_service(ServiceRequestDetails, '/rosapi/service_request_details', self.get_service_request_details)
+        self.create_service(ServiceResponseDetails, '/rosapi/service_response_details', self.get_service_response_details)
+        self.create_service(SetParam, '/rosapi/set_param', self.set_param)
+        self.create_service(GetParam, '/rosapi/get_param', self.get_param)
+        self.create_service(HasParam, '/rosapi/has_param', self.has_param)
+        self.create_service(DeleteParam, '/rosapi/delete_param', self.delete_param)
+        self.create_service(GetParamNames, '/rosapi/get_param_names', self.get_param_names)
+        self.create_service(GetTime, '/rosapi/get_time', self.get_time)
+
+        # TODO(@jubeira): Implement missing services:
+        # rospy.Service('/rosapi/service_host', ServiceHost, get_service_host)
+        # rospy.Service('/rosapi/search_param', SearchParam, search_param)
+
+    def get_globs(self):
+        return glob_helper.get_globs(self)
+
+
+    def get_topics(self, request, response):
+        """ Called by the rosapi/Topics service. Returns a list of all the topics being published. """
+        response.topics, response.types = proxy.get_topics_and_types(self.globs.topics)
+        return response
+
+
+    def get_topics_for_type(self, request, response):
+        """ Called by the rosapi/TopicsForType service. Returns a list of all the topics that are publishing a given type """
+        response.topics = proxy.get_topics_for_type(request.type, self.globs.topics)
+        return response
+
+    def get_services(self, request, response):
+        """ Called by the rosapi/Services service. Returns a list of all the services being advertised. """
+        response.services = proxy.get_services(self.globs.services)
+        return response
+
+    def get_services_for_type(self, request, response):
+        """ Called by the rosapi/ServicesForType service. Returns a list of all the services that are publishing a given type """
+        response.services = proxy.get_services_for_type(request.type, self.globs.services)
+        return response
+
+    def get_nodes(self, request, response):
+        """ Called by the rosapi/Nodes service. Returns a list of all the nodes that are registered """
+        response.nodes = proxy.get_nodes()
+        return response
+
+    def get_node_details(self, request, response):
+        """ Called by the rosapi/Nodes service. Returns a node description """
+        response.subscribing, response.publishing, response.services = proxy.get_node_info(request.node)
+        return response
+
+    def get_action_servers(self, request, response):
+        """ Called by the rosapi/GetActionServers service. Returns a list of action servers based on actions standard topics """
+        topics = proxy.get_topics(self.globs.topics, include_hidden=True)
+        response.action_servers = proxy.filter_action_servers(topics)
+        return response
+
+    def get_topic_type(self, request, response):
+        """ Called by the rosapi/TopicType service.  Given the name of a topic, returns the name of the type of that topic.
+        Request class has one field, 'topic', which is a string value (the name of the topic)
+        Response class has one field, 'type', which is a string value (the type of the topic)
+        If the topic does not exist, an empty string is returned. """
+        response.type = proxy.get_topic_type(request.topic, self.globs.topics)
+        return response
+
+    def get_service_type(self, request, response):
+        """ Called by the rosapi/ServiceType service.  Given the name of a service, returns the type of that service
+        Request class has one field, 'service', which is a string value (the name of the service)
+        Response class has one field, 'type', which is a string value (the type of the service)
+        If the service does not exist, an empty string is returned. """
+        response.type = proxy.get_service_type(request.service, self.globs.services)
+        return response
+
+    def get_publishers(self, request, response):
+        """ Called by the rosapi/Publishers service.  Given the name of a topic, returns a list of node names
+        that are publishing on that topic. """
+        response.publishers = proxy.get_publishers(request.topic, self.globs.topics)
+        return response
+
+    def get_subscribers(self, request, response):
+        """ Called by the rosapi/Subscribers service.  Given the name of a topic, returns a list of node names
+        that are subscribing to that topic. """
+        response.subscribers = proxy.get_subscribers(request.topic, self.globs.topics)
+        return response
+
+    def get_service_providers(self, request, response):
+        """ Called by the rosapi/ServiceProviders service.  Given the name of a topic, returns a list of node names
+        that are advertising that service type """
+        response.providers = proxy.get_service_providers(request.service, self.globs.services)
+        return response
+
+    def get_service_node(self, request, response):
+        """ Called by the rosapi/ServiceNode service.  Given the name of a service, returns the name of the node
+        that is providing that service. """
+        response.node = proxy.get_service_node(request.service, self.globs.services)
+        return response
+
+    def get_message_details(self, request, response):
+        """ Called by the rosapi/MessageDetails service.  Given the name of a message type, returns the TypeDef
+        for that type."""
+        response.typedefs = [dict_to_typedef(d) for d in objectutils.get_typedef_recursive(request.type)]
+        return response
+
+    def get_service_request_details(self, request, response):
+        """ Called by the rosapi/ServiceRequestDetails service. Given the name of a service type, returns the TypeDef
+        for the request message of that service type. """
+        response.typedefs = [dict_to_typedef(d) for d in objectutils.get_service_request_typedef_recursive(request.type)]
+        return response
+
+    def get_service_response_details(self, request, response):
+        """ Called by the rosapi/ServiceResponseDetails service. Given the name of a service type, returns the TypeDef
+        for the response message of that service type. """
+        response.typedefs = [dict_to_typedef(d) for d in objectutils.get_service_response_typedef_recursive(request.type)]
+        return response
+
+    def set_param(self, request, response):
+        params.set_param(request.node_name, request.name, request.value, self.globs.params)
+        return response
+
+    def get_param(self, request, response):
+        response.value = params.get_param(request.node_name, request.name, request.default_value, self.globs.params)
+        return response
+
+    def has_param(self, request, response):
+        response.exists = params.has_param(request.node_name, request.name, self.globs.params)
+        return response
+
+    def delete_param(self, request, response):
+        params.delete_param(request.node_name, request.name, self.globs.params)
+        return response
+
+    def get_param_names(self, request, response):
+        response.names = params.get_param_names(request.node_name, self.globs.params)
+        return response
+
+    def get_time(self, request, response):
+        response.time = Clock(clock_type=ClockType.ROS_TIME).now().to_msg()
+        return response
+
+
+# TODO(@jubeira): make all of these methods of the node and port them.
+
+# Note(@jubeira): there is no equivalent for this in ROS2 so far. The service doesn't seem to e used anywhere in rosbridge.
 def get_service_host(request):
     """ Called by the rosapi/ServiceNode service.  Given the name of a service, returns the name of the machine
     that is hosting that service. """
     return ServiceHostResponse(proxy.get_service_host(request.service))
 
-def get_message_details(request):
-    """ Called by the rosapi/MessageDetails service.  Given the name of a message type, returns the TypeDef
-    for that type."""
-    typedefs = [dict_to_typedef(d) for d in objectutils.get_typedef_recursive(request.type)]
-    return MessageDetailsResponse(typedefs)
-
-def get_service_request_details(request):
-    """ Called by the rosapi/ServiceRequestDetails service. Given the name of a service type, returns the TypeDef
-    for the request message of that service type. """
-    return ServiceRequestDetailsResponse([dict_to_typedef(d) for d in objectutils.get_service_request_typedef_recursive(request.type)])
-
-def get_service_response_details(request):
-    """ Called by the rosapi/ServiceResponseDetails service. Given the name of a service type, returns the TypeDef
-    for the response message of that service type. """
-    return ServiceResponseDetailsResponse([dict_to_typedef(d) for d in objectutils.get_service_response_typedef_recursive(request.type)])
-
-def set_param(request):
-    rosapi.params.set_param(request.name, request.value, rosapi.glob_helper.params_glob)
-    return SetParamResponse()
-
-def get_param(request):
-    return GetParamResponse(rosapi.params.get_param(request.name, request.default, rosapi.glob_helper.params_glob))
-
-def has_param(request):
-    return HasParamResponse(rosapi.params.has_param(request.name, rosapi.glob_helper.params_glob))
-
+# Note(@jubeira): rclpy does not have an equivalent for this. To be checked if this service is necessary or not.
 def search_param(request):
-    return SearchParamResponse(rosapi.params.search_param(request.name, rosapi.glob_helper.params_glob))
-
-def delete_param(request):
-    rosapi.params.delete_param(request.name, rosapi.glob_helper.params_glob)
-    return DeleteParamResponse()
-
-def get_param_names(request):
-    return GetParamNamesResponse(rosapi.params.get_param_names(rosapi.glob_helper.params_glob))
-
-def get_time(request):
-    return GetTimeResponse(rospy.get_rostime())
+    return SearchParamResponse(rosapi.params.search_param(request.name, rosapi.glob_helper.params))
 
 def dict_to_typedef(typedefdict):
     typedef = TypeDef()
@@ -184,12 +225,17 @@ def dict_to_typedef(typedefdict):
     typedef.examples = typedefdict["examples"]
     return typedef
 
+
+def main(args=None):
+    if args is None:
+        args = sys.argv
+    
+    rclpy.init(args=args)
+    rosapi_node = Rosapi()
+    rclpy.spin(rosapi_node)
+
+    node.destroy_node()
+    rclpy.shutdown()
+
 if __name__ == '__main__':
-     try:
-         rospy.init_node('rosapi_node')
-         get_globs()
-         register_services()
-         rospy.loginfo("Rosapi started")
-         rospy.spin()
-     except rospy.ROSInterruptException: 
-         pass
+    main()
diff --git a/rosapi/src/rosapi/glob_helper.py b/rosapi/src/rosapi/glob_helper.py
index 2be45204c..a431ed390 100644
--- a/rosapi/src/rosapi/glob_helper.py
+++ b/rosapi/src/rosapi/glob_helper.py
@@ -1,36 +1,36 @@
 #!/usr/bin/env python
 
-import rospy
+from collections import namedtuple
 import fnmatch
+from rcl_interfaces.msg import ParameterType
 
-topics_glob = []
-services_glob = []
-params_glob = []
+Globs = namedtuple('Globs', ['topics', 'services', 'params'])
 
 
-def get_globs():
+def get_globs(node):
 
-    global topics_glob
-    global services_glob
-    global params_glob
-
-    def get_param(param_name):
-        param = rospy.get_param(param_name, '')
+    def get_param(parameter_name):
+        parameter_value = node.get_parameter(parameter_name).get_parameter_value()
+        if parameter_value.type == ParameterType.PARAMETER_STRING:
+            parameter_value = parameter_value.string_value
+        else:
+            parameter_value = ''
         # strips array delimiters in case of an array style value
         return [
             element.strip().strip("'")
-            for element in param.strip('[').strip(']').split(',')
+            for element in parameter_value.strip('[').strip(']').split(',')
             if len(element.strip().strip("'")) > 0]
 
-    topics_glob = get_param('~topics_glob')
-    services_glob = get_param('~services_glob')
-    params_glob = get_param('~params_glob')
+    topics_glob = get_param('/topics_glob')
+    services_glob = get_param('/services_glob')
+    params_glob = get_param('/params_glob')
+    return Globs(topics_glob, services_glob, params_glob)
 
 
 def filter_globs(globs, full_list):
     # If the globs are empty (weren't defined in the params), return the full list
     if globs is not None and len(globs) > 0:
-        return filter(lambda x: any_match(x, globs), full_list)
+        return list(filter(lambda x: any_match(x, globs), full_list))
     else:
         return full_list
 
diff --git a/rosapi/src/rosapi/objectutils.py b/rosapi/src/rosapi/objectutils.py
index 90a57898a..79b0af864 100644
--- a/rosapi/src/rosapi/objectutils.py
+++ b/rosapi/src/rosapi/objectutils.py
@@ -95,7 +95,7 @@ def get_service_response_typedef_recursive(servicetype):
 
 def _get_typedef(instance):
     """ Gets a typedef dict for the specified instance """
-    if instance is None or not hasattr(instance, "__slots__") or not hasattr(instance, "_slot_types"):
+    if instance is None or not hasattr(instance, "__slots__") or not hasattr(instance, "_fields_and_field_types"):
         return None
 
     fieldnames = []
@@ -108,7 +108,7 @@ def _get_typedef(instance):
         fieldnames.append(name)
 
         # Pull out the type and determine whether it's an array
-        field_type = instance._slot_types[i]
+        field_type = instance._fields_and_field_types[name[1:]]  # Remove trailing underscore.
         arraylen = -1
         if field_type[-1:]==']':
             if field_type[-2:-1]=='[':
diff --git a/rosapi/src/rosapi/params.py b/rosapi/src/rosapi/params.py
index 0efdf874e..aee1bc43b 100644
--- a/rosapi/src/rosapi/params.py
+++ b/rosapi/src/rosapi/params.py
@@ -31,19 +31,40 @@
 # POSSIBILITY OF SUCH DAMAGE.
 
 import fnmatch
-import rospy
-import threading
-
 from json import loads, dumps
+import threading
 
+from rcl_interfaces.msg import Parameter, ParameterType, ParameterValue
+from rcl_interfaces.srv import ListParameters
+import rclpy
+from ros2node.api import get_absolute_node_name
+from ros2param.api import call_get_parameters, call_set_parameters, get_parameter_value
 
 """ Methods to interact with the param server.  Values have to be passed
 as JSON in order to facilitate dynamically typed SRV messages """
 
-# rospy parameter server isn't thread-safe
+# Ensure thread safety for setting / getting parameters.
 param_server_lock = threading.RLock()
+_node = None
+
+_parameter_type_mapping = ['', 'bool_value', 'integer_value', 'double_value', 'string_value', 'byte_array_value'
+                           'bool_array_value', 'integer_array_value', 'double_array_value', 'string_array_value']
+
+
+def init():
+    """
+    Initializes params module with a rclpy.node.Node for further use.
+    This function has to be called before any other for the module to work.
+    """
+    global _node
+    # TODO(@jubeira): remove this node; use rosapi node with MultiThreadedExecutor or
+    # async / await to prevent the service calls from blocking.
+    _node = rclpy.create_node('rosapi_params')
+
+
+def set_param(node_name, name, value, params_glob):
+    """ Sets a parameter in a given node """
 
-def set_param(name, value, params_glob):
     if params_glob and not any(fnmatch.fnmatch(str(name), glob) for glob in params_glob):
         # If the glob list is not empty and there are no glob matches,
         # stop the attempt to set the parameter.
@@ -55,48 +76,139 @@ def set_param(name, value, params_glob):
         d = loads(value)
     except ValueError:
         raise Exception("Due to the type flexibility of the ROS parameter server, the value argument to set_param must be a JSON-formatted string.")
+
+    node_name = get_absolute_node_name(node_name)
     with param_server_lock:
-        rospy.set_param(name, d)
-    
-    
-def get_param(name, default, params_glob):
+        _set_param(node_name, name, value)
+
+
+def _set_param(node_name, name, value, parameter_type=None):
+    """
+    Internal helper function for set_param.
+    Attempts to set the given parameter in the target node with the desired value,
+    deducing the parameter type if it's not specified.
+    parameter_type allows forcing a type for the given value; this is useful to delete parameters.
+    """
+    parameter = Parameter()
+    parameter.name = name
+    if parameter_type is None:
+        parameter.value = get_parameter_value(string_value=value)
+    else:
+        parameter.value = ParameterValue()
+        parameter.value.type = parameter_type
+        if parameter_type != ParameterType.PARAMETER_NOT_SET:
+            setattr(parameter.value, _parameter_type_mapping[parameter_type])
+
+    try:
+        # call_get_parameters will fail if node does not exist.
+        call_set_parameters(node=_node, node_name=node_name, parameters=[parameter])
+    except:
+        pass
+
+
+def get_param(node_name, name, default, params_glob):
+    """ Gets a parameter from a given node """
+
     if params_glob and not any(fnmatch.fnmatch(str(name), glob) for glob in params_glob):
         # If the glob list is not empty and there are no glob matches,
         # stop the attempt to get the parameter.
         return
     # If the glob list is empty (i.e. false) or the parameter matches
     # one of the glob strings, continue to get the parameter.
-    d = None
     if default is not "":
         try:
-            d = loads(default)
+            default = loads(default)
         except ValueError:
-            d = default
+            pass  # Keep default without modifications.
+
+    node_name = get_absolute_node_name(node_name)
     with param_server_lock:
-        value = rospy.get_param(name, d)
+        try:
+            # call_get_parameters will fail if node does not exist.
+            response = call_get_parameters(
+                node=_node, node_name=node_name,
+                parameter_names=[name])
+            pvalue = response.values[0]
+            # if type is 0 (parameter not set), the next line will raise an exception
+            # and return value shall go to default.
+            value = getattr(pvalue, _parameter_type_mapping[pvalue.type])
+        except:
+            # If either the node or the parameter does not exist, return default.
+            value = default
+
     return dumps(value)
 
-def has_param(name, params_glob):
+
+def has_param(node_name, name, params_glob):
+    """ Checks whether a given node has a parameter or not """
+
     if params_glob and not any(fnmatch.fnmatch(str(name), glob) for glob in params_glob):
         # If the glob list is not empty and there are no glob matches,
         # stop the attempt to set the parameter.
         return False
     # If the glob list is empty (i.e. false) or the parameter matches
     # one of the glob strings, check whether the parameter exists.
+    node_name = get_absolute_node_name(node_name)
     with param_server_lock:
-        return rospy.has_param(name)
+        try:
+            response = call_get_parameters(
+                node=_node, node_name=node_name,
+                parameter_names=[name])
+        except:
+            return False
+
+    return response.values[0].type > 0 and response.values[0].type < len(_parameter_type_mapping)
+
+
+def delete_param(node_name, name, params_glob):
+    """ Deletes a parameter in a given node """
 
-def delete_param(name, params_glob):
     if params_glob and not any(fnmatch.fnmatch(str(name), glob) for glob in params_glob):
         # If the glob list is not empty and there are no glob matches,
         # stop the attempt to delete the parameter.
         return
     # If the glob list is empty (i.e. false) or the parameter matches
     # one of the glob strings, continue to delete the parameter.
-    if has_param(name, params_glob):
+    node_name = get_absolute_node_name(node_name)
+    if has_param(node_name, name, params_glob):
         with param_server_lock:
-            rospy.delete_param(name)
+            _set_param(node_name, name, None, ParameterType.PARAMETER_NOT_SET)
+
+
+def get_param_names(node_name, params_glob):
+    """ Gets list of parameter names for a given node """
+
+    node_name = get_absolute_node_name(node_name)
+
+    with param_server_lock:
+        if params_glob:
+            # If there is a parameter glob, filter by it.
+            return list(filter(
+                lambda x: any(fnmatch.fnmatch(str(x), glob) for glob in params_glob),
+                _get_param_names(node_name)))
+        else:
+            # If there is no parameter glob, don't filter.
+            return _get_param_names(node_name)
+
 
+def _get_param_names(node_name):
+    client = _node.create_client(ListParameters, '{}/list_parameters'.format(node_name))
+
+    ready = client.wait_for_service(timeout_sec=5.0)
+    if not ready:
+        raise RuntimeError('Wait for list_parameters service timed out')
+
+    request = ListParameters.Request()
+    future = client.call_async(request)
+    rclpy.spin_until_future_complete(_node, future)
+    response = future.result()
+    if response is not None:
+        return response.result.names
+    else:
+        return []
+
+
+# TODO(@jubeira): functions to be ported below.
 def search_param(name, params_glob):
     if params_glob and not any(fnmatch.fnmatch(str(name), glob) for glob in params_glob):
         # If the glob list is not empty and there are no glob matches,
@@ -105,13 +217,3 @@ def search_param(name, params_glob):
     # If the glob list is empty (i.e. false) or the parameter matches
     # one of the glob strings, continue to find the parameter.
     return rospy.search_param(name)
-
-def get_param_names(params_glob):
-    with param_server_lock:
-        if params_glob:
-            # If there is a parameter glob, filter by it.
-            return filter(lambda x: any(fnmatch.fnmatch(str(x), glob) for glob in params_glob), rospy.get_param_names())
-        else:
-            # If there is no parameter glob, don't filter.
-            return rospy.get_param_names()
-
diff --git a/rosapi/src/rosapi/proxy.py b/rosapi/src/rosapi/proxy.py
index 56e28c75a..7406cb56b 100644
--- a/rosapi/src/rosapi/proxy.py
+++ b/rosapi/src/rosapi/proxy.py
@@ -33,210 +33,206 @@
 
 import fnmatch
 import socket
-from rosservice import get_service_list
-from rosservice import get_service_type as rosservice_get_service_type
-from rosservice import get_service_node as rosservice_get_service_node
-from rosservice import get_service_uri
-from rosservice import rosservice_find
-from rostopic import find_by_type
-from rostopic import get_topic_type as rosservice_get_topic_type
-from rosnode import get_node_names
-from rosgraph.masterapi import Master
+
+from ros2node.api import get_node_names, get_publisher_info, get_service_info, get_subscriber_info
+from ros2service.api import get_service_names, get_service_names_and_types
+from ros2topic.api import get_topic_names, get_topic_names_and_types
 
 from rosapi.msg import TypeDef
 
 from .glob_helper import filter_globs, any_match
 
+_node = None
+
+
+def init(node):
+    """
+    Initializes proxy module with a rclpy.node.Node for further use.
+    This function has to be called before any other for the module to work.
+    """
+    global _node
+    _node = node
 
-def get_topics_and_types(topics_glob):
+
+def get_topics(topics_glob, include_hidden=False):
     """ Returns a list of all the active topics in the ROS system """
-    try:
-        # Function getTopicTypes also returns inactive topics and does not
-        # return topics with unknown message types, so it must be compared
-        # to results from getSystemState.
-        master = Master('/rosbridge')
-        topic_types = master.getTopicTypes()
-        publishers, subscribers, services = master.getSystemState()
-        topics = set([x for x, _ in publishers] + [x for x, _ in subscribers])
-
-        # Filter the list of topics by whether they are public.
-        topics = set(filter_globs(topics_glob, topics))
-        topic_types = [x for x in topic_types if x[0] in topics]
-
-        # Add topics with unknown type messages.
-        unknown_type = topics.difference([x for x, _ in topic_types])
-        return zip(* topic_types + [[x,''] for x in unknown_type])
-    except:
-        return []
+    topic_names = get_topic_names(node=_node, include_hidden_topics=include_hidden)
+    return filter_globs(topics_glob, topic_names)
+
+
+def get_topics_and_types(topics_glob, include_hidden=False):
+    return get_publications_and_types(topics_glob, get_topic_names_and_types, include_hidden_topics=include_hidden)
 
 
-def get_topics_for_type(type, topics_glob):
-    # Filter the list of topics by whether they are public before returning.
-    return filter_globs(topics_glob, find_by_type(type))
+def get_topics_for_type(topic_type, topics_glob, include_hidden=False):
+    topic_names_and_types = get_topic_names_and_types(node=_node, include_hidden_topics=include_hidden)
+    # topic[0] has the topic name and topic[1] has the type wrapped in a list.
+    topics_for_type = [topic[0] for topic in topic_names_and_types if topic[1][0] == topic_type]
+    return filter_globs(topics_glob, topics_for_type)
 
 
-def get_services(services_glob):
+def get_services(services_glob, include_hidden=False):
     """ Returns a list of all the services advertised in the ROS system """
     # Filter the list of services by whether they are public before returning.
-    return filter_globs(services_glob, get_service_list())
+    service_names = get_service_names(node=_node, include_hidden_services=include_hidden)
+    return filter_globs(services_glob, service_names)
+
+
+def get_services_and_types(services_glob, include_hidden=False):
+    return get_publications_and_types(services_glob, get_service_names_and_types, include_hidden_services=include_hidden)
 
 
-def get_services_for_type(service_type, services_glob):
+def get_services_for_type(service_type, services_glob, include_hidden=False):
     """ Returns a list of services as specific service type """
     # Filter the list of services by whether they are public before returning.
-    return filter_globs(services_glob, rosservice_find(service_type))
+    services_names_and_types = get_service_names_and_types(node=_node, include_hidden_services=include_hidden)
+    # service[0] has the topic name and service[1] has the type wrapped in a list.
+    services_for_type = [service[0] for service in services_names_and_types if service[1][0] == service_type]
+    return filter_globs(services_glob, services_for_type)
 
 
-def get_nodes():
+def get_publications_and_types(glob, getter_function, **include_hidden_publications):
+    """ Generic getter function for both services and topics """
+    publication_names_and_types = getter_function(node=_node, **include_hidden_publications)
+    # publication[0] has the publication name and publication[1] has the type wrapped in a list.
+    all_publications = [publication[0] for publication in publication_names_and_types]
+    filtered_publications = filter_globs(glob, all_publications)
+    filtered_publication_types = [publication[1][0] for publication
+                                  in publication_names_and_types
+                                  if publication[0] in filtered_publications]
+    return filtered_publications, filtered_publication_types
+
+
+def get_nodes(include_hidden=False):
     """ Returns a list of all the nodes registered in the ROS system """
-    return get_node_names()
+    node_names = get_node_names(node=_node, include_hidden_nodes=include_hidden)
+    full_names = [node_name.full_name for node_name in node_names]
+    return full_names
 
 
-def get_node_publications(node):
-    """ Returns a list of topic names that are been published by the specified node """
-    try:
-        publishers, subscribers, services = Master('/rosbridge').getSystemState()
-        toReturn = []
-        for i, v in publishers:
-            if node in v:
-                toReturn.append(i)
-        toReturn.sort()
-        return toReturn
-    except socket.error:
-        return []
+def get_node_info(node_name, include_hidden=False):
+    node_names = get_node_names(node=_node, include_hidden_nodes=include_hidden)
+    if node_name in [n.full_name for n in node_names]:
+        # Only the name of each item is required as output.
+        subscribers = get_node_subscriptions(node_name)
+        publishers = get_node_publications(node_name)
+        services = get_node_services(node_name)
 
+        return subscribers, publishers, services
 
-def get_node_subscriptions(node):
-    """ Returns a list of topic names that are been subscribed by the specified node """
-    try:
-        publishers, subscribers, services = Master('/rosbridge').getSystemState()
-        toReturn = []
-        for i, v in subscribers:
-            if node in v:
-                toReturn.append(i)
-        toReturn.sort()
-        return toReturn
-    except socket.error:
-        return []
 
+def get_node_publications(node_name):
+    """ Returns a list of topic names that are being published by the specified node """
+    publishers = get_publisher_info(node=_node, remote_node_name=node_name)
+    return [publisher.name for publisher in publishers]
+
+
+def get_node_subscriptions(node_name):
+    """ Returns a list of topic names that are being subscribed by the specified node """
+    subscribers = get_subscriber_info(node=_node, remote_node_name=node_name)
+    return [subscriber.name for subscriber in subscribers]
 
-def get_node_services(node):
-    """ Returns a list of service names that are been hosted by the specified node """
-    try:
-        publishers, subscribers, services = Master('/rosbridge').getSystemState()
-        toReturn = []
-        for i, v in services:
-            if node in v:
-                toReturn.append(i)
-        toReturn.sort()
-        return toReturn
-    except socket.error:
-        return []
+
+def get_node_services(node_name):
+    """ Returns a list of service names that are being hosted by the specified node """
+    services = get_service_info(node=_node, remote_node_name=node_name)
+    return [service.name for service in services]
+
+
+def get_node_service_types(node_name):
+    """ Returns a list of service types that are being hosted by the specified node """
+    services = get_service_info(node=_node, remote_node_name=node_name)
+    return [service.types[0] for service in services]
 
 
 def get_topic_type(topic, topics_glob):
     """ Returns the type of the specified ROS topic """
-    # Check if the topic is hidden or public.
-    # If all topics are public then the type is returned
-    if any_match(str(topic), topics_glob):
-        # If the topic is published, return its type
-        topic_type, _, _ = rosservice_get_topic_type(topic)
-        if topic_type is None:
-            # Topic isn't published so return an empty string
-            return ""
-        return topic_type
-    else:
-        # Topic is hidden so return an empty string
+    # Note: this doesn't consider hidden topics.
+    topics, types = get_topics_and_types(topics_glob)
+    try:
+        return types[topics.index(topic)]
+    except ValueError as e:
+        # Return empty string if the topic is not present.
         return ""
 
 
 def filter_action_servers(topics):
     """ Returns a list of action servers """
+    # Note(@jubeira): filtering by topic should be enough; services can be taken into account as well.
     action_servers = []
     possible_action_server = ''
-    possibility = [0, 0, 0, 0, 0]
+    possibility = [0, 0]
 
-    action_topics = ['cancel', 'feedback', 'goal', 'result', 'status']
+    action_topics = ['feedback', 'status']
     for topic in sorted(topics):
         split = topic.split('/')
-        if(len(split) >= 3):
+        if(len(split) >= 4):
             topic = split.pop()
+            action_prefix = split.pop()
+            if action_prefix != '_action':
+                continue
+
             namespace = '/'.join(split)
             if(possible_action_server != namespace):
                 possible_action_server = namespace
-                possibility = [0, 0, 0, 0, 0]
+                possibility = [0, 0]
             if possible_action_server == namespace and topic in action_topics:
                 possibility[action_topics.index(topic)] = 1
-        if all(p == 1 for p in possibility):
-            action_servers.append(possible_action_server)
+            if all(p == 1 for p in possibility):
+                action_servers.append(possible_action_server)
+                possibility = [0, 0]
 
     return action_servers
 
 
 def get_service_type(service, services_glob):
     """ Returns the type of the specified ROS service, """
-    # Check if the service is hidden or public.
-    if any_match(str(service), services_glob):
-        try:
-            return rosservice_get_service_type(service)
-        except:
-            return ""
-    else:
-        # Service is hidden so return an empty string.
+    # Note: this doesn't consider hidden services.
+    services, types = get_services_and_types(services_glob)
+    try:
+        return types[services.index(service)]
+    except ValueError as e:
+        # Return empty string if the service is not present.
         return ""
 
 
-def get_publishers(topic, topics_glob):
-    """ Returns a list of node names that are publishing the specified topic """
-    try:
-        if any_match(str(topic), topics_glob):
-            publishers, subscribers, services = Master('/rosbridge').getSystemState()
-            pubdict = dict(publishers)
-            if topic in pubdict:
-                return pubdict[topic]
-            else:
-                return []
-        else:
-            return []
-    except socket.error:
+def get_channel_info(channel, channels_glob, getter_function, include_hidden=False):
+    """ Returns a list of node names that are publishing / subscribing to the specified topic,
+        or advertising a given service. """
+    if any_match(str(channel), channels_glob):
+        channel_info_list = []
+        node_list = get_nodes(include_hidden)
+        for node in node_list:
+            channel_info = getter_function(node)
+            if channel in channel_info:
+                channel_info_list.append(node)
+        return channel_info_list
+    else:
         return []
 
 
-def get_subscribers(topic, topics_glob):
-    """ Returns a list of node names that are subscribing to the specified topic """
-    try:
-        if any_match(str(topic), topics_glob):
-            publishers, subscribers, services = Master('/rosbridge').getSystemState()
-            subdict = dict(subscribers)
-            if topic in subdict:
-                return subdict[topic]
-            else:
-                return []
-        else:
-            return []
-    except socket.error:
-        return []
+def get_publishers(topic, topics_glob, include_hidden=False):
+    """ Returns a list of node names that are publishing the specified topic """
+    return get_channel_info(topic, topics_glob, get_node_publications, include_hidden=include_hidden)
 
 
-def get_service_providers(queried_type, services_glob):
-    """ Returns a list of node names that are advertising a service with the specified type """
-    _, _, services = Master('/rosbridge').getSystemState()
+def get_subscribers(topic, topics_glob, include_hidden=False):
+    """ Returns a list of node names that are subscribing to the specified topic """
+    return get_channel_info(topic, topics_glob, get_node_subscriptions, include_hidden=include_hidden)
 
-    service_type_providers = []
-    for service, providers in services:
-        service_type = get_service_type(service, services_glob)
 
-        if service_type == queried_type:
-            service_type_providers += providers
-    return service_type_providers
+def get_service_providers(queried_type, services_glob, include_hidden=False):
+    """ Returns a list of node names that are advertising a service with the specified type """
+    return get_channel_info(queried_type, services_glob, get_node_service_types, include_hidden=include_hidden)
 
 
-def get_service_node(service):
+def get_service_node(queried_type, services_glob, include_hidden=False):
     """ Returns the name of the node that is providing the given service, or empty string """
-    node = rosservice_get_service_node(service)
-    if node == None:
-        node = ""
-    return node
+    node_name = get_channel_info(queried_type, services_glob, get_node_services, include_hidden=include_hidden)
+    if node_name:
+        return node_name[0]
+    else:
+        return ""
 
 
 def get_service_host(service):
diff --git a/rosapi/srv/DeleteParam.srv b/rosapi/srv/DeleteParam.srv
index 1da96270a..a028f8715 100644
--- a/rosapi/srv/DeleteParam.srv
+++ b/rosapi/srv/DeleteParam.srv
@@ -1,2 +1,3 @@
+string node_name
 string name
 ---
\ No newline at end of file
diff --git a/rosapi/srv/GetParam.srv b/rosapi/srv/GetParam.srv
index f990926ea..0804ab4c0 100644
--- a/rosapi/srv/GetParam.srv
+++ b/rosapi/srv/GetParam.srv
@@ -1,3 +1,4 @@
+string node_name
 string name
 string default_value
 ---
diff --git a/rosapi/srv/GetParamNames.srv b/rosapi/srv/GetParamNames.srv
index c52d403f0..e7787b12c 100644
--- a/rosapi/srv/GetParamNames.srv
+++ b/rosapi/srv/GetParamNames.srv
@@ -1,2 +1,3 @@
+string node_name
 ---
 string[] names
\ No newline at end of file
diff --git a/rosapi/srv/HasParam.srv b/rosapi/srv/HasParam.srv
index 97208275f..694d37cb2 100644
--- a/rosapi/srv/HasParam.srv
+++ b/rosapi/srv/HasParam.srv
@@ -1,3 +1,4 @@
+string node_name
 string name
 ---
 bool exists
\ No newline at end of file
diff --git a/rosapi/srv/SetParam.srv b/rosapi/srv/SetParam.srv
index 4f0fdb3b9..104c82416 100644
--- a/rosapi/srv/SetParam.srv
+++ b/rosapi/srv/SetParam.srv
@@ -1,3 +1,4 @@
+string node_name
 string name
 string value
 ---
\ No newline at end of file
diff --git a/rosbridge_library/src/rosbridge_library/internal/ros_loader.py b/rosbridge_library/src/rosbridge_library/internal/ros_loader.py
index d1f4c7f7b..3c9a1de5d 100644
--- a/rosbridge_library/src/rosbridge_library/internal/ros_loader.py
+++ b/rosbridge_library/src/rosbridge_library/internal/ros_loader.py
@@ -1,4 +1,3 @@
-import time
 #!/usr/bin/env python
 # Software License Agreement (BSD License)
 #
@@ -32,9 +31,11 @@
 # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 
-import roslib
-import rospy
+from ros2pkg.api import get_prefix_path
 
+import importlib
+import os
+import sys
 from threading import Lock
 
 """ ros_loader contains methods for dynamically loading ROS message classes at
@@ -49,7 +50,6 @@
 _loaded_srvs = {}
 _msgs_lock = Lock()
 _srvs_lock = Lock()
-_manifest_lock = Lock()
 
 
 class InvalidTypeStringException(Exception):
@@ -111,12 +111,12 @@ def get_service_instance(typestring):
 
 def get_service_request_instance(typestring):
     cls = get_service_class(typestring)
-    return cls._request_class()
+    return cls.Request()
 
 
 def get_service_response_instance(typestring):
     cls = get_service_class(typestring)
-    return cls._response_class()
+    return cls.Response()
 
 
 def _get_msg_class(typestring):
@@ -177,22 +177,15 @@ def _load_class(modname, subname, classname):
     more expressive exceptions.
 
     Returns the loaded module, or None on failure """
-    global loaded_modules
 
+    # This assumes the module is already in the path.
     try:
-        with _manifest_lock:
-            # roslib maintains a cache of loaded manifests, so no need to duplicate
-            roslib.launcher.load_manifest(modname)
-    except Exception as exc:
-        raise InvalidPackageException(modname, exc)
-
-    try:
-        pypkg = __import__('%s.%s' % (modname, subname))
+        pypkg = importlib.import_module('%s.%s' % (modname, subname))
     except Exception as exc:
         raise InvalidModuleException(modname, subname, exc)
 
     try:
-        return getattr(getattr(pypkg, subname), classname)
+        return getattr(pypkg, classname)
     except Exception as exc:
         raise InvalidClassException(modname, subname, classname, exc)