def fill_msg(self, msg):
msg.package = self.package
msg.binary = self.binary
if self.binary_path:
msg.binary_path = self.binary_path
if self.name:
msg.name = self.name
if self.namespace:
msg.namespace = self.namespace
if self.fullname:
msg.fullname = self.fullname
if self.prefix:
msg.prefix = self.prefix
if self.cwd:
msg.cwd = self.cwd
if self.env:
msg.env.extend([lmsg.Argument(name=name, value=value) for name, value in self.env.items()])
if self.remaps:
msg.remaps.extend([lmsg.Remapping(from_name=name, to_name=value) for name, value in self.remaps.items()])
if self.params:
msg.params.extend([lmsg.Argument(name=name, value=utf8(value), value_type=self._msg_type(value)) for name, value in self.params.items()])
if self.clear_params:
msg.clear_params.extend(self.clear_params)
if self.args:
msg.args.extend(self.args)
if self.masteruri:
msg.masteruri = self.masteruri
if self.host:
msg.host = self.host
msg.loglevel = self.loglevel
msg.respawn = self.respawn
msg.respawn_delay = self.respawn_delay
msg.respawn_max = self.respawn_max
msg.respawn_min_runtime = self.respawn_min_runtime
def GetIncludedFiles(self, request, context):
rospy.logdebug('GetIncludedFiles request:\n%s' % str(request))
try:
pattern = INCLUDE_PATTERN
if request.pattern:
pattern = request.pattern
search_in_ext = SEARCH_IN_EXT
if request.search_in_ext:
search_in_ext = request.search_in_ext
# search for loaded file and get the arguments
resolve_args = {arg.name: arg.value for arg in request.include_args}
if not resolve_args:
for cfgid, lcfg in self._loaded_files.items():
if cfgid.path == request.path:
resolve_args.update(lcfg.resolve_dict)
break
# replay each file
for inc_file in find_included_files(request.path, request.recursive, request.unique, pattern, search_in_ext, resolve_args):
reply = lmsg.IncludedFilesReply()
reply.root_path = inc_file.path_or_str
reply.linenr = inc_file.line_number
reply.path = inc_file.inc_path
reply.exists = inc_file.exists
reply.rawname = inc_file.raw_inc_path
if reply.exists:
reply.size = os.path.getsize(reply.path)
reply.rec_depth = inc_file.rec_depth
reply.include_args.extend(lmsg.Argument(name=name, value=value) for name, value in inc_file.args.items())
# return each file one by one
yield reply
except Exception:
rospy.logwarn("Can't get include files for %s: %s" % (request.path, traceback.format_exc()))
def GetLoadedFiles(self, request, context):
rospy.logdebug('GetLoadedFiles request:\n%s' % str(request))
# self._register_callback(context)
for _cfgid, lf in self._loaded_files.items():
reply = lmsg.LoadedFile(package=lf.packagename, launch=lf.launchname, path=lf.filename, masteruri=lf.masteruri, host=lf.host)
reply.args.extend(lmsg.Argument(name=name, value=value) for name, value in lf.resolve_dict.items())
yield reply
def _get_included_files(self, path, recursive=True, unique=False, include_args={}, include_pattern=[], search_in_ext=[]):
'''
:return: Returns the result from grpc server
:rtype: stream lmsg.IncludedFilesReply
'''
request = lmsg.IncludedFilesRequest(path=path, recursive=recursive, unique=unique, pattern=include_pattern, search_in_ext=search_in_ext)
request.include_args.extend(lmsg.Argument(name=name, value=value) for name, value in include_args.items())
return self.lm_stub.GetIncludedFiles(request, timeout=settings.GRPC_TIMEOUT)
def load_launch(self,
package,
launch,
path='',
args=None,
request_args=False,
masteruri='',
host=''):
'''
:return: tuple with launch file, dictionary of requested arguments
:rtype: str, {str: str}
'''
arguments = args
if arguments is None:
arguments = {}
request = lmsg.LoadLaunchRequest(package=package,
launch=launch,
path=path,
request_args=request_args,
masteruri=masteruri,
host=host)
request.args.extend([
lmsg.Argument(name=name, value=value)
for name, value in arguments.items()
])
response = self.lm_stub.LoadLaunch(request,
timeout=settings.GRPC_TIMEOUT)
if response.status.code == OK:
pass
elif response.status.code == MULTIPLE_LAUNCHES:
raise exceptions.LaunchSelectionRequest(
[_path for _path in response.path], response.status.error_msg)
elif response.status.code == PARAMS_REQUIRED:
raise exceptions.ParamSelectionRequest(
{arg.name: arg.value
for arg in response.args}, response.status.error_msg)
elif response.status.code == ALREADY_OPEN:
raise exceptions.AlreadyOpenException(response.path[0],
response.status.error_msg)
else:
raise exceptions.RemoteException(response.status.code,
response.status.error_msg)
return response.path[0], {arg.name: arg.value for arg in response.args}
def LoadLaunch(self, request, context):
'''
Loads launch file
'''
result = lmsg.LoadLaunchReply()
launchfile = request.path
rospy.logdebug(
"Loading launch file: %s (package: %s, launch: %s), masteruri: %s, host: %s, args: %s"
% (launchfile, request.package, request.launch, request.masteruri,
request.host, request.args))
if not launchfile:
# determine path from package name and launch name
try:
paths = roslib.packages.find_resource(request.package,
request.launch)
if not paths:
result.status.code = FILE_NOT_FOUND
result.status.error_msg = utf8(
"Launch files %s in package %s found!" %
(request.launch, request.package))
return result
elif len(paths) > 1:
if request.force_first_file:
launchfile = paths[0]
else:
result.status.code = MULTIPLE_LAUNCHES
result.status.error_msg = utf8(
"Multiple launch files with name %s in package %s found!"
% (request.launch, request.package))
for mp in paths:
result.path.append(mp)
rospy.logdebug("..load aborted, MULTIPLE_LAUNCHES")
return result
else:
launchfile = paths[0]
except rospkg.ResourceNotFound as rnf:
result.status.code = FILE_NOT_FOUND
result.status.error_msg = utf8("Package %s not found: %s" %
(request.package, rnf))
rospy.logdebug("..load aborted, FILE_NOT_FOUND")
return result
result.path.append(launchfile)
# it is already loaded?
if (launchfile, request.masteruri) in self._loaded_files.keys():
result.status.code = ALREADY_OPEN
result.status.error_msg = utf8("Launch file %s already loaded!" %
(launchfile))
rospy.logdebug("..load aborted, ALREADY_OPEN")
return result
# load launch configuration
try:
# test for required args
provided_args = ["%s" % arg.name for arg in request.args]
launch_config = LaunchConfig(launchfile,
masteruri=request.masteruri,
host=request.host)
# get the list with needed launch args
req_args = launch_config.get_args()
req_args_dict = launch_config.argv2dict(req_args)
if request.request_args and req_args:
for arg, value in req_args_dict.items():
if arg not in provided_args:
result.args.extend([
lmsg.Argument(name=arg, value=value)
for arg, value in req_args_dict.items()
])
result.status.code = PARAMS_REQUIRED
rospy.logdebug("..load aborted, PARAMS_REQUIRED")
return result
argv = [
"%s:=%s" % (arg.name, arg.value) for arg in request.args
if arg.name in req_args_dict
]
_loaded, _res_argv = launch_config.load(argv)
# parse result args for reply
result.args.extend([
lmsg.Argument(name=name, value=value)
for name, value in launch_config.resolve_dict.items()
])
self._loaded_files[CfgId(launchfile,
request.masteruri)] = launch_config
rospy.logdebug("..load complete!")
except Exception as e:
err_text = "%s loading failed!" % launchfile
err_details = "%s: %s" % (err_text, utf8(e))
rospy.logwarn("Loading launch file: %s", err_details)
result.status.code = ERROR
result.status.error_msg = utf8(err_details)
return result
result.status.code = OK
return result
