[WIP] Java interface

CMakeLists.txt

@@ -9,7 +9,8 @@ catkin_python_setup()
 
 add_service_files(
    FILES
-   Scan.srv
+   GetROSModel.srv
+   GetROSSystemModel.srv
 )
 
 generate_messages()
@@ -18,10 +19,6 @@ catkin_package(
    CATKIN_DEPENDS message_runtime
 )
 
-install(DIRECTORY launch
-   DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
-)
-
 catkin_install_python(PROGRAMS scripts/ros_node
                                 scripts/print_snapshot
                                 scripts/java_snapshot

scripts/ros_node

@@ -8,26 +8,24 @@ import rospy
 class RosGraphNode():
 
     def __init__(self):
-        rospy.Service('scan_ros_graph', rg_srv.Scan, self.create_snapshot)
-
-    def create_snapshot(self, request):
-        answer = rg_srv.ScanResponse()
-        answer.success, answer.message, answer.rosgraph = self._create_snapshot()
+        rospy.Service('get_ros_model', rg_srv.GetROSModel,
+                      self.get_ros_model)
+
+        rospy.Service('get_rossystem_model', rg_srv.GetROSSystemModel,
+                      self.get_rossystem_model)
+
+    def get_ros_model(self, request):
+        answer = rg_srv.GetROSModelResponse()
+        answer.success, answer.message, answer.model = rg.create_java_ros_model()
         return answer
 
-    def _create_snapshot(self):
-        try:
-            snapshot = rg.create_ros_graph_snapshot()
-            dump = dict()
-            dump['nodes']=dict()
-            for node in snapshot:
-                dump['nodes'][node.name] = node.dump_yaml()
-            return True, "Scanning Succeeded", str(dump)
-        except:
-            return False, "Scanning Failed", ""
+    def get_rossystem_model(self, request):
+        answer = rg_srv.GetROSSystemModelResponse()
+        answer.success, answer.message, answer.model = rg.create_java_system_model()
+        return answer
 
 
 if __name__ == "__main__":
     rospy.init_node("ros_graph_parser_node")
     RosGraphNode()
-    rospy.spin()
+    rospy.spin()

src/ros_graph_parser/core_class.py

@@ -2,8 +2,9 @@
 
 import rosgraph
 
-ACTION_FILTER = ['goal','cancel']
-ACTION_FILTER2= ['status', 'result', 'feedback']
+ACTION_FILTER = ['goal', 'cancel']
+ACTION_FILTER2 = ['status', 'result', 'feedback']
+
 
 def get_namespace(name):
     try:
@@ -13,6 +14,7 @@ def get_namespace(name):
         print(ex)
         return ""
 
+
 class Interface(object):
     def __init__(self, name, itype):
         self.resolved = name
@@ -25,71 +27,169 @@ def __eq__(self, other):
             return True
         else:
             return False
-    
+
     def get_dict(self):
-        return {"Type":self.itype, "Name": self.resolved, 
-                "Namespace":self.namespace, "Minimal":self.minimal}
-
-    def str_format(self, indent=""):
-        return ("%sType: %s\n%sName: %s\n%sNamespace: %s\n%sMinimal: %s\n")%(
-            indent, self.itype, indent, self.resolved, indent, 
-            self.namespace, indent, self.minimal)
+        return {"Type": self.itype, "Name": self.resolved,
+                "Namespace": self.namespace, "Minimal": self.minimal}
 
-    def java_format(self, indent="", name_type="", interface_type=""):
-        return ("%s%s { name '%s' %s '%s'}")%(
-            indent, name_type, self.resolved, interface_type, self.itype.replace("/","."))
 
 class InterfaceSet(set):
 
     def get_with_name(self, name):
         for elem in self:
             if name == elem.resolved:
                 return elem
-        raise KeyError("Interface with Name '%s' not found."%(name))
+        raise KeyError("Interface with Name '%s' not found." % (name))
 
     def get_with_minimal(self, name):
         for elem in self:
             if name == elem.minimal:
                 return elem
-        raise KeyError("Interface with Minimal Name '%s' not found."%(name))
-    
+        raise KeyError("Interface with Minimal Name '%s' not found." % (name))
+
     def get_with_type(self, itype):
         for elem in self:
             if itype == elem.itype:
                 return elem
-        raise KeyError("No Interface of Type '%s' found."%(itype))
+        raise KeyError("No Interface of Type '%s' found." % (itype))
 
     def remove_with_name(self, name):
         self.remove(self.get_with_name(name))
 
+    def get_list(self):
+        return [x.get_dict() for x in self]
+
+    def __str__(self):
+        self.str_format()
+
+    def iteritems(self):
+        return [(x.resolved, x.itype) for x in self]
+
+    def iterkeys(self):
+        return [x.resolved for x in self]
+
+
+class ParameterInterface(object):
+
+    def __init__(self, name, value, itype):
+        self.resolved = name
+        self.namespace = get_namespace(name)
+        self.minimal = name[len(self.namespace)-1:]
+        self.value = value
+        self.itype = self.get_type(value)
+        self.count = 0
+
+    def __eq__(self, other):
+        if self.value == other.value and self.resolved == other.resolved:
+            return True
+        else:
+            return False
+
+    def get_type(self, value):
+        itype = type(value)
+        itype = (str(itype)).replace("<type '", "").replace("'>", "")
+        if itype == 'float':
+            return 'Double'
+        elif itype == 'bool':
+            return 'Boolean'
+        elif itype == 'int':
+            return 'Integer'
+        elif itype == 'str':
+            return 'String'
+        elif itype == 'list' or itype == 'dict':
+            if ":" in str(value):
+                return 'Struct'
+            else:
+                return 'List'
+        else:
+            return itype
+
+    def set_value(self, value, indent):
+        str_param_value = ""
+        if self.itype == "String":
+            str_param_value += "'"+self.value+"'"
+        elif self.itype == "Boolean":
+            str_param_value += str(self.value).lower()
+        elif self.itype == "List":
+            str_param_value += str(self.value).replace(
+                "[", "{").replace("]", "}")
+        elif self.itype == 'Struct':
+            str_param_value += self.value_struct(self.value[0], indent+"  ")
+        else:
+            str_param_value += str(value)
+        return str_param_value
+
+    def get_dict(self):
+        return {"Value": self.value, "Name": self.resolved,
+                "Namespace": self.namespace, "Minimal": self.minimal}
+
     def str_format(self, indent=""):
-        str_ = ""
-        for elem in self:
-            str_ += elem.str_format(indent) + "\n"
-        return str_
+        return ("%sType: %s\n%sName: %s\n%sNamespace: %s\n%sMinimal: %s\n") % (
+            indent, self.value, indent, self.resolved, indent,
+            self.namespace, indent, self.minimal)
+
+    def types_struct(self, struct_dict, indent):
+        str_param = "{\n"
+        indent_new = indent+"  "
+        for struct_element in struct_dict:
+            sub_name = struct_element
+            sub_value = struct_dict[struct_element]
+            sub_type = self.get_type(sub_value)
+            str_param += "%s'%s' %s" % (indent_new, sub_name, sub_type)
+            if sub_type == 'List':
+                str_param += self.form_list(sub_value)
+            if isinstance(sub_value, dict):
+                str_param += self.types_struct(
+                    struct_dict[struct_element], indent_new)
+            str_param += ",\n"
+        str_param = str_param[:-2]
+        str_param += "}"
+        indent_new = ""
+        return str_param
+
+    def value_struct(self, struct_dict, indent):
+        str_param = "{\n"
+        indent_new = indent+"    "
+        for struct_element in struct_dict:
+            sub_name = struct_element
+            sub_value = struct_dict[struct_element]
+            sub_type = self.get_type(sub_value)
+            str_param += "%s{ '%s' { value " % (indent_new, sub_name)
+            if sub_type == "String":
+                sub_value = "'"+sub_value+"'"
+            if sub_type == 'List':
+                sub_value = str(sub_value).replace(
+                    "[", "{").replace("]", "}").replace("{{", "{").replace("}}", "}")
+            if sub_type == "Boolean":
+                sub_value = str(sub_value).lower()
+            if isinstance(sub_value, dict):
+                str_param += self.value_struct(
+                    struct_dict[struct_element], indent_new)
+                self.count = self.count + 1
+            else:
+                str_param += "%s}}" % (sub_value)
+            str_param += ",\n"
+        str_param = str_param[:-2]
+        str_param += "}"
+        if self.count == 1:
+            str_param += "}}"
+            self.count = self.count - 1
+        indent_new = ""
+        return str_param
+
+    def form_list(self, value_in):
+        str_param = "{"
+        for i in value_in:
+            str_param += self.get_type(i)
+            if self.get_type(i) == "List":
+                str_param += self.form_list(i)
+            str_param += ","
+        str_param = str_param[:-1]
+        str_param += "}"
+        return str_param
 
-    def java_format_ros_model(self, indent="", name_type="", interface_type="", name_block=""):
-        if len(self) == 0:
-            return ""
-        str_ = ("\n%s%s {\n")%(indent, name_block)
-        for elem in self:
-            str_+= elem.java_format(indent+"  ", name_type, interface_type) +",\n"
-        str_ = str_[:-2]
-        str_+="}"
-        return str_
-
-    def java_format_system_model(self, indent="", name_type="", name_type2="", node_name="", pkg_name="", name_type3=""):
-        if len(self) == 0:
-            return ""
-        if not name_type3:
-            name_type3 = name_type2
-        str_ = ("%sRos%s {\n")%(indent, name_type)
-        for elem in self:
-            str_ += ("%s    Ros%s '%s' {Ref%s '%s.%s.%s.%s'},\n")%(
-                indent, name_type3, elem.resolved, name_type2, pkg_name, node_name, node_name, elem.resolved)
-        str_ = str_[:-2]
-        str_+="}\n"
-        return str_
+
+class ParameterSet(set):
 
     def get_list(self):
         return [x.get_dict() for x in self]
@@ -102,7 +202,7 @@ def iteritems(self):
 
     def iterkeys(self):
         return [x.resolved for x in self]
-    
+
 
 class Node(object):
     def __init__(self, name=""):
@@ -111,7 +211,9 @@ def __init__(self, name=""):
         self.action_servers = InterfaceSet()
         self.publishers = InterfaceSet()
         self.subscribers = InterfaceSet()
-        self.services = InterfaceSet()
+        self.service_clients = InterfaceSet()
+        self.service_servers = InterfaceSet()
+        self.params = ParameterSet()
 
     def get_namespace(self):
         return get_namespace(self.name)
@@ -129,7 +231,7 @@ def _clean_action_server(self):
                 self.subscribers.remove_with_name(name+name_)
             for name_ in ACTION_FILTER2:
                 self.publishers.remove_with_name(name+name_)
-    
+
     def check_actions(self):
         # Check Action client
         for topic_name, topic_type in self.publishers.iteritems():
@@ -140,8 +242,8 @@ def check_actions(self):
                 for name in ACTION_FILTER2:
                     if not (_action_name + name in self.subscribers.iterkeys()):
                         continue
-                _action_type = topic_type[:-10] # Hardcoded ActionGoal
-                self.action_clients.add(Interface(_action_name,_action_type))
+                _action_type = topic_type[:-10]  # Hardcoded ActionGoal
+                self.action_clients.add(Interface(_action_name, _action_type))
         self._clean_action_client()
         # Check Action Server
         for topic_name, topic_type in self.subscribers.iteritems():
@@ -152,48 +254,16 @@ def check_actions(self):
                 for name in ACTION_FILTER2:
                     if not (_action_name + name in self.publishers.iterkeys()):
                         continue
-                _action_type = topic_type[:-10] # Hardcode ActionGoal
-                self.action_servers.add(Interface(_action_name,_action_type))
+                _action_type = topic_type[:-10]  # Hardcode ActionGoal
+                self.action_servers.add(Interface(_action_name, _action_type))
         self._clean_action_server()
 
-    def dump_print(self):
-        _str=""
-        _str = "Node: \n\t%s"%(self.name)
-        _str = _str +"\tPublishers:\n%s"%(self.publishers.str_format('\t\t'))
-        _str = _str +"\tSubscribers:\n%s"%(self.subscribers.str_format('\t\t'))
-        _str = _str +"\tServices:\n%s"%(self.services.str_format('\t\t'))
-        _str = _str +"\tActionClients:\n%s"%(self.action_clients.str_format('\t\t'))
-        _str = _str +"\tActionServers:\n%s"%(self.action_servers.str_format('\t\t'))
-        _str = _str + ("\n")
-        print(_str)
-
     def dump_yaml(self):
-        yaml_dict=dict()
+        yaml_dict = dict()
         yaml_dict['Publishers'] = self.publishers.get_list()
         yaml_dict['Subscribers'] = self.subscribers.get_list()
-        yaml_dict['Services'] = self.services.get_list()
+        yaml_dict['Services'] = self.service_servers.get_list()
         yaml_dict['ActionClients'] = self.action_clients.get_list()
         yaml_dict['ActionServers'] = self.action_servers.get_list()
+        yaml_dict['Parameters'] = self.params.get_list()
         return yaml_dict
-
-    def dump_java_ros_model(self):
-        ros_model_str="    Artifact "+self.name+" {\n"
-        ros_model_str+="      node Node { name "+ self.name+"\n"
-        ros_model_str+=self.services.java_format_ros_model("        ", "ServiceServer", "service","serviceserver")
-        ros_model_str+=self.publishers.java_format_ros_model("        ", "Publisher", "message","publisher")
-        ros_model_str+=self.subscribers.java_format_ros_model("        ", "Subscriber", "message", "subscriber")       
-        ros_model_str+=self.action_servers.java_format_ros_model("        ", "ActionServer", "action","actionserver")
-        ros_model_str+=self.action_clients.java_format_ros_model("        ", "ActionClient", "action","actionclient")
-        ros_model_str+="}},\n"
-        return ros_model_str
-
-    def dump_java_system_model(self, package=""):
-        system_model_str="        ComponentInterface { name '"+self.name+"'\n"
-        system_model_str+=self.publishers.java_format_system_model("            ", "Publishers", "Publisher", self.name, package)
-        system_model_str+=self.subscribers.java_format_system_model("            ", "Subscribers", "Subscriber",self.name, package)
-        system_model_str+=self.services.java_format_system_model("            ", "SrvServers", "Server", self.name, package, "ServiceServer")
-        system_model_str+=self.action_servers.java_format_system_model("            ", "ActionServers", "Server", self.name, package)
-        system_model_str+=self.action_clients.java_format_system_model("            ", "ActionClients", "Client", self.name, package)
-        system_model_str+="},\n"
-        return system_model_str
-