rtcd2_docker、rtcprof2_dockerのためのDefaultConfigurationの変更

OpenRTM_aist/CORBA_RTCUtil.py

@@ -1601,7 +1601,6 @@ class CorbaURI:
     #
     # @endif
     def __init__(self, uri, objkey=""):
-        import urllib.parse
         protocols_str = {"giop:tcp:": "corbaloc:iiop:",
                          "giop:ssl:": "corbaloc:ssliop:",
                          "giop:http:": "",
@@ -1615,9 +1614,10 @@ def __init__(self, uri, objkey=""):
                          "inet:": "corbaloc:iiop:"}
 
         converted = False
+
         for k, v in protocols_str.items():
-            if uri.find(k) == 0:
-                uri = uri.replace(k, v)
+            if uri.startswith(k):
+                uri = v + uri[len(k):]
                 converted = True
                 break
 
@@ -1627,51 +1627,107 @@ def __init__(self, uri, objkey=""):
                            "shmiop:": "corbaloc:shmiop:",
                            "htiop:": "corbaloc:htiop:"}
 
+
         if not converted:
             for k, v in protocols_o_str.items():
-                if uri.find(k) == 0:
-                    uri = uri.replace(k, v)
+                if uri.startswith(k):
+                    uri = v + uri[len(k):]
                     break
 
         self._uri = ""
         self._port = None
         self._addressonly = False
-        ret = urllib.parse.urlparse(uri)
-        self._protocol = ret.scheme
+        if uri.startswith("corbaloc:"):
+            self._protocol = "corbaloc"
+            rest, sep, fragment = uri.partition("/")
+            self._fragment = fragment if sep else ""
 
-        loc = [s.strip() for s in ret.netloc.split(":")]
-        if len(loc) >= 2:
-            self._host = loc[0]
-            self._port = int(loc[1])
-        else:
-            self._host = ret.netloc
-        self._path = ret.path
-        self._fragment = ret.fragment
+            if self._fragment:
+                self._uri = uri
+            else:
+                self._fragment = objkey
+                self._uri = uri + "/" + self._fragment
+
+
+            host_port = [s.strip() for s in rest.split(":")]
+            if len(host_port) == 4:
+                self._host = host_port[2]
+                try:
+                    self._port = int(host_port[3])
+                except BaseException:
+                    pass
+            elif len(host_port) == 3:
+                self._host = host_port[2]
+
+        elif uri.startswith("corbaname:"):
+            self._protocol = "corbaname"
+            rest, sep, fragment = uri.partition("#")
+            self._fragment = fragment if sep else ""
+
+
+            if self._fragment:
+                self._uri = uri
+            else:
+                self._fragment = objkey
+                self._uri = uri + "#" + self._fragment
+
+
+            host_port = [s.strip() for s in rest.split(":")]
+            if len(host_port) == 4:
+                self._host = host_port[2]
+                try:
+                    self._port = int(host_port[3])
+                except BaseException:
+                    pass
+            elif len(host_port) == 3:
+                self._host = host_port[2]
+
+
+
+        elif "://" in uri:
+            import urllib.parse
+            ret = urllib.parse.urlparse(uri)
+            self._protocol = ret.scheme
+            loc = [s.strip() for s in ret.netloc.split(":")]
+            if len(loc) >= 2:
+                self._host = loc[0]
+                try:
+                    self._port = int(loc[1])
+                except BaseException:
+                    pass
+            else:
+                self._host = ret.netloc
+            self._path = ret.path
+            self._fragment = ret.fragment
+            if self._fragment:
+                self._uri = uri
+            else:
+                self._fragment = objkey
+                self._uri = uri + "#" + self._fragment
 
-        if self._fragment:
-            self._uri = uri
-            return
         else:
-            self._fragment = objkey
-            if self._protocol == "corbaloc":
-                self._uri = uri + "/"
-                self._uri += self._fragment
-            elif self._protocol:
-                self._uri = uri + "#"
-                self._uri += self._fragment
+            rest, sep, fragment = uri.partition("/")
+            self._fragment = fragment if sep else ""
+
+            self._uri = "corbaloc:iiop:"
+            if self._fragment:
+                self._uri += uri
             else:
-                self._uri = "corbaloc:iiop:"
-                self._uri += uri + "/"
-                self._uri += self._fragment
-                self._protocol = "corbaloc"
-                self._addressonly = True
-                host_port = [s.strip() for s in uri.split(":")]
-                if len(host_port) == 2:
-                    self._host = host_port[0]
-                    try:
-                        self._port = int(host_port[1])
-                    except BaseException:
-                        pass
+                self._fragment = objkey
+                self._uri += uri + "/" + self._fragment
+
+            self._protocol = "corbaloc"
+            self._addressonly = True
+            host_port = [s.strip() for s in rest.split(":")]
+            if len(host_port) == 2:
+                self._host = host_port[0]
+                try:
+                    self._port = int(host_port[1])
+                except BaseException:
+                    pass
+            elif len(host_port) == 1:
+                self._host = host_port[0]
+
     ##
     # @if jp
     #

OpenRTM_aist/DefaultConfiguration.py

@@ -97,6 +97,7 @@
                   "manager.modules.C++.manager_cmd", "rtcd2",
                   "manager.modules.Python.manager_cmd", "rtcd2_python",
                   "manager.modules.Java.manager_cmd", "rtcd2_java",
+                  "manager.modules.Docker.manager_cmd", "rtcd2_docker",
                   "manager.modules.search_auto", "YES",
                   "manager.local_service.enabled_services", "ALL",
                   "sdo.service.provider.enabled_services", "ALL",
@@ -105,10 +106,16 @@
                   "manager.modules.C++.profile_cmd", "rtcprof2",
                   "manager.modules.Python.profile_cmd", "rtcprof2_python",
                   "manager.modules.Java.profile_cmd", "rtcprof2_java",
+                  "manager.modules.Docker.profile_cmd", "rtcprof2_docker",
                   "manager.modules.C++.suffixes", cpp_suffixes,
                   "manager.modules.Python.suffixes", "py",
                   "manager.modules.Java.suffixes", "class",
+                  "manager.modules.Docker.suffixes", "docker",
                   "manager.modules.C++.load_paths", "",
                   "manager.modules.Python.load_paths", "",
-                  "manager.modules.Java.load_paths", ""]
+                  "manager.modules.Java.load_paths", "",
+                  "manager.modules.Docker.load_paths", "",
+                  "manager.modules.Docker.create_comp", "NO",
+                  "manager.modules.Docker.build_comp", "YES"
+                  ]
 

OpenRTM_aist/ManagerServant.py

@@ -522,23 +522,28 @@ def create_component(self, module_name):
         comp_param = CompParam(module_name)
 
         if self._isMaster:
-            guard = OpenRTM_aist.ScopedLock(self._slaveMutex)
-            for slave in self._slaves[:]:
-                try:
-                    prof = slave.get_configuration()
-                    prop = OpenRTM_aist.Properties()
-                    OpenRTM_aist.NVUtil.copyToProperties(prop, prof)
-                    slave_lang = prop.getProperty("manager.language")
-                    if slave_lang == comp_param.language():
-                        rtc = slave.create_component(module_name)
-                        if not CORBA.is_nil(rtc):
-                            return rtc
-                except BaseException:
-                    self._rtcout.RTC_ERROR("Unknown exception cought.")
-                    self._rtcout.RTC_DEBUG(
-                        OpenRTM_aist.Logger.print_exception())
-                    self._slaves.remove(slave)
-            del guard
+            lang_create_flag = "manager.modules."
+            lang_create_flag += comp_param.language() + ".create_comp"
+            create_comp = OpenRTM_aist.toBool(self._mgr.getConfig().getProperty(
+                lang_create_flag), "YES", "NO", True)
+            if create_comp:
+                guard = OpenRTM_aist.ScopedLock(self._slaveMutex)
+                for slave in self._slaves[:]:
+                    try:
+                        prof = slave.get_configuration()
+                        prop = OpenRTM_aist.Properties()
+                        OpenRTM_aist.NVUtil.copyToProperties(prop, prof)
+                        slave_lang = prop.getProperty("manager.language")
+                        if slave_lang == comp_param.language():
+                            rtc = slave.create_component(module_name)
+                            if not CORBA.is_nil(rtc):
+                                return rtc
+                    except BaseException:
+                        self._rtcout.RTC_ERROR("Unknown exception cought.")
+                        self._rtcout.RTC_DEBUG(
+                            OpenRTM_aist.Logger.print_exception())
+                        self._slaves.remove(slave)
+                del guard
 
             if not manager_name:
                 if "?" not in module_name:
@@ -1378,10 +1383,24 @@ def createComponentByManagerName(self, module_name):
             mgrobj = self.findManagerByName(mgrstr)
 
         comp_param = CompParam(arg)
+        lang = comp_param.language()
+        if not lang:
+            lang = "Python"
+        self._rtcout.RTC_INFO("Specified manager's language: %s", lang)
+
+        prop = self._mgr.getConfig()
+        lang_create_flag = "manager.modules."
+        lang_create_flag += lang + ".create_comp"
+        create_comp = OpenRTM_aist.toBool(prop.getProperty(
+                lang_create_flag), "YES", "NO", True)
+        lang_build_flag = "manager.modules."
+        lang_build_flag += lang + ".build_comp"
+        build_comp = OpenRTM_aist.toBool(prop.getProperty(
+                lang_build_flag), "YES", "NO", True)
 
         if CORBA.is_nil(mgrobj):
             self._rtcout.RTC_WARN("%s cannot be found.", mgrstr)
-            config = copy.deepcopy(self._mgr.getConfig())
+            config = copy.deepcopy(prop)
             rtcd_cmd = config.getProperty(
                 "manager.modules." +
                 comp_param.language() +
@@ -1408,6 +1427,15 @@ def createComponentByManagerName(self, module_name):
                 cmd += " -f \"" + param["config_file"] + "\""
             elif config.findNode("config_file"):
                 cmd += " -f \"" + config.getProperty("config_file") + "\""
+            if create_comp:
+                cmd += " -o " + "\"manager.modules.load_path:" + load_path + "\""
+            else:
+                tmp = arg.split("?")
+                rtcd_cmd += " -o \"module_name:" +  tmp[0] + "\""
+                rtcd_cmd += " -o \"module_option:" +  param["module.options"] + "\""
+                if not build_comp:
+                    rtcd_cmd += " -o \"module_build:NO\""
+
 
             cmd += " -o " + "manager.is_master:NO"
             cmd += " -o " + "manager.corba_servant:YES"
@@ -1416,10 +1444,11 @@ def createComponentByManagerName(self, module_name):
             cmd += " -o " + "manager.name:" + \
                 config.getProperty("manager.name")
             cmd += " -o " + "manager.instance_name:" + mgrstr
-            cmd += " -o " + "\"manager.modules.load_path:" + load_path + "\""
+
             cmd += " -o " + "\"" + lang_path_key + ":" + load_path_language + "\""
             cmd += " -o " + "manager.supported_languages:" + comp_param.language()
-            cmd += " -o " + "manager.shutdown_auto:NO"
+            if create_comp:
+                cmd += " -o " + "manager.shutdown_auto:NO"
 
             self._rtcout.RTC_DEBUG("Invoking command: %s.", cmd)
 
@@ -1494,9 +1523,25 @@ def createComponentByManagerName(self, module_name):
         self._rtcout.RTC_DEBUG("arg: %s", arg)
 
         try:
-            rtobj = mgrobj.create_component(arg)
-
-            return rtobj, arg, mgrstr
+            if create_comp:
+                rtobj = mgrobj.create_component(arg)
+                return rtobj, arg, mgrstr
+            else:
+                for i in range(0, 1000):
+                    profs = mgrobj.get_component_profiles()
+                    for prof in profs:
+                        if comp_param.impl_id() == prof.type_name:
+                            instance_name = prof.instance_name
+                            try:
+                                rtc_list = mgrobj.get_components_by_name(instance_name)
+                                if rtc_list:
+                                    return rtc_list[0], arg, mgrstr
+                            except CORBA.SystemException as e:
+                                self._rtcout.RTC_ERROR("Exception was caught while creating component.")
+                            except BaseException as e:
+                                self._rtcout.RTC_ERROR("Unknown non-CORBA exception cought.")
+                    time.sleep(0.01)
+            return RTC.RTObject._nil, arg, mgrstr
         except CORBA.SystemException:
             self._rtcout.RTC_DEBUG(
                 "Exception was caught while creating component.")
@@ -1540,12 +1585,22 @@ def createComponentByAddress(self, module_name):
         mgrobj = self.findManager(mgrstr)
 
         comp_param = CompParam(arg)
+        lang = comp_param.language()
+        if not lang:
+            lang = "Python"
+        self._rtcout.RTC_INFO("Specified manager's language: %s", lang)
+
+        prop = self._mgr.getConfig()
+        lang_create_flag = "manager.modules."
+        lang_create_flag += lang + ".create_comp"
+        create_comp = OpenRTM_aist.toBool(prop.getProperty(
+                lang_create_flag), "YES", "NO", True)
 
         if CORBA.is_nil(mgrobj):
-            config = copy.deepcopy(self._mgr.getConfig())
+            config = copy.deepcopy(prop)
             rtcd_cmd = config.getProperty(
                 "manager.modules." +
-                comp_param.language() +
+                lang +
                 ".manager_cmd")
             if not rtcd_cmd:
                 lang = config.getProperty("manager.language")
@@ -1603,9 +1658,25 @@ def createComponentByAddress(self, module_name):
         self._rtcout.RTC_DEBUG("Creating component on %s", mgrstr)
         self._rtcout.RTC_DEBUG("arg: %s", arg)
         try:
-            rtobj = mgrobj.create_component(arg)
-            self._rtcout.RTC_DEBUG("Component created %s", arg)
-            return rtobj, arg, mgrstr
+            if create_comp:
+                rtobj = mgrobj.create_component(arg)
+                self._rtcout.RTC_DEBUG("Component created %s", arg)
+                return rtobj, arg, mgrstr
+            else:
+                profs = mgrobj.get_component_profiles()
+                for prof in profs:
+                    if comp_param.impl_id() == prof.type_name:
+                        instance_name = prof.instance_name
+                        try:
+                            rtc_list = mgrobj.get_components_by_name(instance_name)
+                            if rtc_list:
+                                return rtc_list[0], arg, mgrstr
+                        except CORBA.SystemException as e:
+                            self._rtcout.RTC_ERROR("Exception was caught while creating component.")
+                        except BaseException as e:
+                            self._rtcout.RTC_ERROR("Unknown non-CORBA exception cought.")
+            self._rtcout.RTC_ERROR("Component creatiion failed.")
+            return RTC.RTObject._nil, arg, mgrstr
         except CORBA.SystemException:
             self._rtcout.RTC_DEBUG(
                 "Exception was caught while creating component.")