def get_included_files_set(self, grpc_path='grpc://localhost:12321', recursive=True, include_pattern=[], search_in_ext=[]): ''' :param str root: the root path to search for included files :param bool recursive: True for recursive search :param include_pattern: the list with regular expression patterns to find include files. :type include_pattern: [str] :param search_in_ext: file extensions to search in :type search_in_ext: [str] :return: Returns a list of included files. :rtype: [str] ''' result = [] try: result = self._cache_file_unique_includes[grpc_path] except KeyError: rospy.logdebug("get_included_files_set for %s, recursive: %s" % (grpc_path, recursive)) uri, path = nmdurl.split(grpc_path, with_scheme=False) lm, channel = self.get_launch_manager(uri) url, path = nmdurl.split(grpc_path, with_scheme=True) reply = lm.get_included_files_set(path, recursive, {}, include_pattern, search_in_ext) for fname in reply: result.append(nmdurl.join(url, fname)) self._cache_file_unique_includes[grpc_path] = result self.close_channel(channel, uri) return result
def rename(self, grpc_path_old='grpc://localhost:12321', grpc_path_new='grpc://localhost:12321'): uri, old = nmdurl.split(grpc_path_old) _, new = nmdurl.split(grpc_path_new) rospy.logdebug("rename path on %s" % uri) fm = self.get_file_manager(uri) return fm.rename(old, new)
def rename(self, grpc_path_old='grpc://localhost:12321', grpc_path_new='grpc://localhost:12321'): uri, old = nmdurl.split(grpc_path_old) _, new = nmdurl.split(grpc_path_new) rospy.logdebug("rename path on %s" % uri) fm, channel = self.get_file_manager(uri) result = fm.rename(old, new) self.close_channel(channel, uri) return result
def get_package_binaries(self, pkgname, grpc_url='grpc://localhost:12321'): uri, _path = nmdurl.split(grpc_url) rospy.logdebug("get_package_binaries for '%s' from '%s'" % (pkgname, uri)) fm = self.get_file_manager(uri) response = fm.get_package_binaries(pkgname) url, _ = nmdurl.split(grpc_url, with_scheme=True) result = {} for item in response: result[nmdurl.join(url, item.path)] = item.mtime return result
def get_included_files(self, grpc_path='grpc://localhost:12321', recursive=True, include_args={}, include_pattern=[], search_in_ext=[]): ''' :param str grpc_path: the root path to search for included files :param bool recursive: True for recursive search :param include_args: dictionary with arguments to override while include. :type include_args: {str: str} :param include_pattern: the list with regular expression patterns to find include files. :type include_pattern: [str] :param search_in_ext: file extensions to search in :type search_in_ext: [str] :return: Returns an iterator for tuple with root path, line number, path of included file, file exists or not, file size and dictionary with defined arguments. :rtype: iterator (str, int, str, bool, int, {str: str}) ''' dorequest = False try: for entry in self._cache_file_includes[grpc_path]: do_return = True if not recursive and entry.rec_depth != 0: do_return = False if do_return: rospy.logdebug("get_included_files from cache: %s, include_args: %s" % (entry.inc_path, entry.args)) yield entry except KeyError: dorequest = True if dorequest: current_path = grpc_path try: uri, path = nmdurl.split(current_path) lm, channel = self.get_launch_manager(uri) rospy.logdebug("get_included_files for %s, recursive: %s, include_args: %s, pattern: %s, search_in_ext: %s" % (grpc_path, recursive, include_args, include_pattern, search_in_ext)) reply = lm.get_included_files(path, recursive, include_args, include_pattern, search_in_ext) url, _ = nmdurl.split(grpc_path, with_scheme=True) # initialize requested path in cache if recursive: if grpc_path not in self._cache_file_includes: self._cache_file_includes[grpc_path] = [] for inc_file in reply: entry = inc_file entry.path_or_str = nmdurl.join(url, inc_file.path_or_str) entry.inc_path = nmdurl.join(url, inc_file.inc_path) # initialize and add returned root path to cache, only on recursive if recursive: if current_path not in self._cache_file_includes: self._cache_file_includes[current_path] = [] self._cache_file_includes[current_path].append(entry) yield entry except grpc._channel._Rendezvous as grpc_error: self.clear_cache(grpc_path) self.clear_cache(current_path) if grpc_error.code() == grpc.StatusCode.DEADLINE_EXCEEDED: raise exceptions.GrpcTimeout(grpc_path, grpc_error) raise finally: self.close_channel(channel, uri)
def _get_mtimes_threaded(self, grpc_path='grpc://localhost:12321'): uri, path = nmdurl.split(grpc_path) rospy.logdebug("[thread] get mtimes from %s" % uri) try: lm, channel = self.get_launch_manager(uri) rpath, mtime, included_files = lm.get_mtimes(path) url, _ = nmdurl.split(grpc_path, with_scheme=True) self.mtimes.emit(nmdurl.join(url, rpath), mtime, {nmdurl.join(url, pobj.path): pobj.mtime for pobj in included_files}) except Exception: pass finally: self.close_channel(channel, uri) if hasattr(self, '_threads'): self._threads.finished("gmt_%s" % grpc_path)
def get_interpreted_path(self, grpc_url_or_path='grpc://localhost:12321', text=[]): ''' :param str grpc_url_or_path: the url for node manager daemon :param [str] text: list of string with text to interpret to a path :return: Returns an iterator for tuples with interpreted path and file exists or not :rtype: tuple(str, bool) ''' uri, _ = nmdurl.split(grpc_url_or_path) lm, channel = self.get_launch_manager(uri) rospy.logdebug("get_interpreted_path in text %s" % text) reply = lm.get_interpreted_path(text) url, _ = nmdurl.split(grpc_url_or_path, with_scheme=True) for path, exists in reply: yield (nmdurl.join(url, path), exists) self.close_channel(channel, uri)
def delete(self, grpc_path='grpc://*****:*****@ %s" % (path, uri)) fm, channel = self.get_file_manager(uri) result = fm.delete(path) self.close_channel(channel, uri) return result
def current_grpc(self): ''' Current URL of the node manager daemon. :rtype: str ''' netloc, _ = nmdurl.split(self._current_path, with_scheme=True) return netloc
def get_screens(self, grpc_url='grpc://localhost:12321', node=''): rospy.logdebug("get screen from %s for %s" % (grpc_url, node)) uri, _ = nmdurl.split(grpc_url) sm, channel = self.get_screen_manager(uri) screens = sm.screens(node) self.close_channel(channel, uri) return screens
def get_all_screens(self, grpc_url='grpc://localhost:12321'): rospy.logdebug("get all screens from %s" % (grpc_url)) uri, _ = nmdurl.split(grpc_url) sm, channel = self.get_screen_manager(uri) screens = sm.all_screens() self.close_channel(channel, uri) return screens
def delete_log(self, grpc_url='grpc://localhost:12321', nodes=[]): rospy.logdebug("delete logs on %s for %s" % (grpc_url, nodes)) uri, _ = nmdurl.split(grpc_url) sm, channel = self.get_screen_manager(uri) result = sm.delete_log(nodes) self.close_channel(channel, uri) return result
def start_standalone_node(self, grpc_url, package, binary, name, ns, args=[], env={}, masteruri=None, host=None): rospy.loginfo("start standalone node: %s on %s" % (name, grpc_url)) uri, _ = nmdurl.split(grpc_url) lm, channel = self.get_launch_manager(uri) try: startcfg = StartConfig(package, binary) startcfg.name = name startcfg.namespace = ns startcfg.fullname = rospy.names.ns_join(ns, name) startcfg.prefix = '' startcfg.cwd = '' startcfg.env = env startcfg.remaps = {} startcfg.params = {} startcfg.clear_params = [] startcfg.args = args startcfg.masteruri = masteruri startcfg.host = host startcfg.loglevel = '' startcfg.logformat = '' startcfg.respawn = False startcfg.respawn_delay = 30 startcfg.respawn_max = 0 startcfg.respawn_min_runtime = 0 return lm.start_standalone_node(startcfg) except grpc.RpcError as err: rospy.logdebug("remove connection %s" % uri) raise err except exceptions.BinarySelectionRequest as bsr: rospy.loginfo("Question while start node: %s" % bsr.error) binaries = bsr.choices raise BinarySelectionRequest(binaries, 'Needs binary selection') finally: self.close_channel(channel, uri)
def get_file_content(self, grpc_path='grpc://localhost:12321', force=False): file_size, file_mtime, file_content = (0, 0, '') try: if force: del self._cache_file_content[grpc_path] file_size, file_mtime, file_content = self._cache_file_content[ grpc_path] except KeyError: rospy.logdebug("get file content for %s:" % grpc_path) uri, path = nmdurl.split(grpc_path) fm, channel = self.get_file_manager(uri) try: file_size, file_mtime, file_content = fm.get_file_content(path) self._cache_file_content[grpc_path] = (file_size, file_mtime, file_content) except Exception as e: self.error.emit("get_file_content", "grpc://%s" % uri, grpc_path, e) raise e finally: self.close_channel(channel, uri) if hasattr(self, '_threads'): self._threads.finished("gfc_%s_%d" % (grpc_path, force)) self.file_content.emit(grpc_path, file_size, file_mtime, file_content) return file_size, file_mtime, file_content
def start_node(self, name, grpc_path='grpc://localhost:12321', masteruri='', reload_global_param=False, loglevel='', logformat='', opt_binary='', cmd_prefix=''): rospy.loginfo("start node: %s with %s" % (name, grpc_path)) uri, opt_launch = nmdurl.split(grpc_path) lm, channel = self.get_launch_manager(uri) try: return lm.start_node(name, opt_binary=opt_binary, opt_launch=opt_launch, loglevel=loglevel, logformat=logformat, masteruri=masteruri, reload_global_param=reload_global_param, cmd_prefix=cmd_prefix) except grpc.RpcError as gerr: rospy.logdebug("remove connection %s" % uri) raise gerr except exceptions.BinarySelectionRequest as bsr: rospy.loginfo("Question while start node: %s" % bsr.error) binaries = bsr.choices raise BinarySelectionRequest(binaries, 'Needs binary selection') except Exception as err: raise err finally: self.close_channel(channel, uri)
def _list_path_threaded(self, grpc_path='grpc://localhost:12321', clear_cache=False): uri, path = nmdurl.split(grpc_path) rospy.logdebug("[thread] list path: %s, '%s'" % (uri, path)) fm, channel = self.get_file_manager(uri) result = None try: if not clear_cache: result = self._cache_path[grpc_path] else: self._cache_path[''] # only to cause an exception except KeyError: try: result = fm.list_path(path) if uri not in self._cache_packages: self.list_packages_threaded(grpc_path, clear_cache) # self.get_loaded_files_threaded(grpc_path) except Exception as e: self.error.emit("list_path", "grpc://%s" % uri, path, e) # rospy.logwarn("LIST PATH: %s" % e) if result is not None: self._cache_path[grpc_path] = result self.listed_path.emit("grpc://%s" % uri, path, result) self.close_channel(channel, uri) if hasattr(self, '_threads'): self._threads.finished("lpt_%s" % grpc_path)
def _list_packages(self, grpc_url_or_path='grpc://localhost:12321', clear_ros_cache=False): uri, path = nmdurl.split(grpc_url_or_path) grpc_url = "grpc://%s" % uri result = {} try: if not clear_ros_cache: result = self._cache_packages[grpc_url] else: self._cache_packages[''] # only to cause an exception except KeyError: rospy.logdebug("[thread] get packages %s" % grpc_url) fm, channel = self.get_file_manager(uri) try: result = fm.list_packages(clear_ros_cache) fixed_result = { nmdurl.join(grpc_url, path): name for path, name in result.items() } self._cache_packages[grpc_url] = fixed_result self.packages.emit(grpc_url, fixed_result) self.packages_available.emit(grpc_url) except Exception as err: self.error.emit("_list_packages", "grpc://%s" % uri, path, err) finally: self.close_channel(channel, uri) if hasattr(self, '_threads'): self._threads.finished("gmt_%s_%d" % (grpc_url_or_path, clear_ros_cache))
def copy(self, grpc_path='grpc://localhost:12321', grpc_dest='grpc://localhost:12321'): uri, path = nmdurl.split(grpc_path) rospy.logdebug("copy '%s' to '%s'" % (grpc_path, grpc_dest)) fm = self.get_file_manager(uri) fm.copy(path, grpc_dest)
def rosclean(self, grpc_url='grpc://localhost:12321'): rospy.logdebug("clear log directory on %s" % (grpc_url)) uri, _ = nmdurl.split(grpc_url) sm, channel = self.get_screen_manager(uri) result = sm.rosclean() self.close_channel(channel, uri) return result
def _add_history(self): for hitem in nm.settings().launch_history: if not hitem.startswith(os.path.sep): hitem_uri, _ = nmdurl.split(hitem, with_scheme=True) current_uri = nmdurl.nmduri(self._current_path) if nmdurl.equal_uri(hitem_uri, current_uri): self._add_path(hitem, PathItem.RECENT_FILE, 0, 0, os.path.basename(hitem))
def kill_process(self, pid, grpc_url='grpc://localhost:12321'): rospy.logdebug("kill process %d on %s" % (pid, grpc_url)) uri, _ = nmdurl.split(grpc_url) vm = self.get_monitor_manager(uri) try: vm.kill_process(pid) except Exception as e: self.error.emit("kill_process", "grpc://%s" % uri, "", e)
def _check_for_changed_files_threaded(self, grpc_url, path_dict): rospy.logdebug( "[thread] check_for_changed_files_threaded: with %d files on %s" % (len(path_dict), grpc_url)) uri, _path = nmdurl.split(grpc_url, with_scheme=False) fm = self.get_file_manager(uri) try: response = fm.changed_files(path_dict) for item in response: self.changed_file.emit(nmdurl.join(grpc_url, item.path), item.mtime) except Exception as e: self.error.emit("changed_files", "grpc://%s" % uri, "", e) # rospy.logwarn("check_for_changed_files_threaded: %s" % e) url, _path = nmdurl.split(grpc_url, with_scheme=True) if hasattr(self, '_threads'): self._threads.finished("cft_%s" % url)
def expand_item(self, path, path_id, clear_cache=False): ''' Returns for the given item and path the file path if this is a file. Otherwise the folder will be expanded and None will be returned. :param str path: the real path of the item :param int path_id: the id of the path :param bool clear_cache: clear cache before reload :return: path of the launch file or None :rtype: str :raise Exception: if no path to given item was found ''' if path_id in [PathItem.NOTHING]: return None has_shift_mod = Qt.ShiftModifier & QApplication.keyboardModifiers() if path_id in [ PathItem.LAUNCH_FILE, PathItem.CFG_FILE, PathItem.PROFILE, PathItem.FILE, PathItem.RECENT_FILE, PathItem.LAUNCH_FILE ]: if not has_shift_mod: return path root = self.invisibleRootItem() while root.rowCount(): root.removeRow(0) self.pyqt_workaround.clear() if has_shift_mod: if path_id in [ PathItem.LAUNCH_FILE, PathItem.CFG_FILE, PathItem.PROFILE, PathItem.FILE, PathItem.RECENT_FILE, PathItem.LAUNCH_FILE ]: self._current_path = os.path.dirname(path) else: self._current_path = nmdurl.nmduri() else: if path_id in [PathItem.ROOT]: surl, spath = nmdurl.split(path, with_scheme=True) if self._is_root(path) or spath in ['', os.path.sep]: self._current_path = nmdurl.nmduri() elif self._is_ros_root(path): self._current_path = surl else: dir_path = os.path.dirname(spath) self._current_path = nmdurl.join(surl, dir_path) elif self._current_path != path: self._current_path = path self._add_path(self._current_path, PathItem.ROOT, 0, 0, 'loading...') nm.nmd().file.list_path_threaded(self._current_path, clear_cache) # TODO: add functionality to go deep automatically # else: # key_mod = QApplication.keyboardModifiers() # onestep = False # if key_mod & Qt.ControlModifier: # onestep = True # root_path, items = self._moveDown(path, onestep) # self._setNewList((root_path, items)) return None
def _get_loaded_files_threaded(self, grpc_path='grpc://localhost:12321'): uri, path = nmdurl.split(grpc_path) rospy.logdebug("[thread] get loaded_files from %s" % uri) try: lm, channel = self.get_launch_manager(uri) result = lm.get_loaded_files() url, _ = nmdurl.split(grpc_path, with_scheme=True) for _package, path, args, _masteruri, _host in result: with self._args_lock: gpath = nmdurl.join(url, path) rospy.logdebug("[thread] add args for %s: %s" % (gpath, args)) self._launch_args[gpath] = args except Exception: import traceback print(traceback.format_exc()) finally: self.close_channel(channel, uri) if hasattr(self, '_threads'): self._threads.finished("glft_%s" % grpc_path)
def save_file(self, grpc_path, content, mtime): rospy.logdebug("save_file_content: %s" % grpc_path) uri, path = nmdurl.split(grpc_path) fm = self.get_file_manager(uri) result = fm.save_file_content(path, content, mtime) for ack in result: if ack.path == path and ack.mtime != 0: self.clear_cache(grpc_path) return ack.mtime return 0
def new(self, grpc_path='grpc://*****:*****@ %s" % (path, uri)) fm, channel = self.get_file_manager(uri) result = fm.new(path, path_type) self.close_channel(channel, uri) return result
def get_start_cfg(self, name, grpc_path='grpc://localhost:12321', masteruri='', reload_global_param=False, loglevel='', logformat=''): rospy.logdebug("get start configuration for '%s' from %s" % (name, grpc_path)) uri, _ = nmdurl.split(grpc_path) lm, channel = self.get_launch_manager(uri) try: return lm.get_start_cfg(name, loglevel=loglevel, logformat=logformat, masteruri=masteruri, reload_global_param=reload_global_param) except Exception as err: raise err finally: self.close_channel(channel, uri)
def unload_launch(self, grpc_path, masteruri=''): rospy.logdebug("unload launch %s" % grpc_path) uri, path = nmdurl.split(grpc_path) lm, channel = self.get_launch_manager(uri) launch_file = lm.unload_launch(path, masteruri) with self._args_lock: if launch_file in self._launch_args: rospy.logdebug("delete args after unload %s" % launch_file) del self._launch_args[launch_file] self.close_channel(channel, uri) return launch_file
def _multiple_screens(self, grpc_url='grpc://localhost:12321'): rospy.logdebug("get multiple screens from %s" % (grpc_url)) try: uri, _ = nmdurl.split(grpc_url) sm = self.get_screen_manager(uri) result = sm.multiple_screens() self.multiple_screens.emit(grpc_url, result) except Exception as e: self.error.emit("get_multiple_screens", "grpc://%s" % uri, "", e) if hasattr(self, '_threads'): self._threads.finished("mst_%s" % grpc_url)
def kill_process(self, pid, grpc_url='grpc://localhost:12321'): if pid is not None: rospy.logdebug("kill process %d on %s" % (pid, grpc_url)) uri, _ = nmdurl.split(grpc_url) vm, channel = self.get_monitor_manager(uri) try: vm.kill_process(pid) except Exception as e: self.error.emit("kill_process", "grpc://%s" % uri, "", e) finally: self.close_channel(channel, uri)