def test_script_resolve_name():
    from rosgraph.names import script_resolve_name, get_ros_namespace, ns_join

    assert '/global' == script_resolve_name('/myscript', '/global')
    val = script_resolve_name('/myscript', '')
    assert get_ros_namespace() == val, val
    val = script_resolve_name('/myscript', 'foo')
    assert ns_join(get_ros_namespace(), 'foo') == val, val
    assert '/myscript/private' == script_resolve_name('/myscript', '~private')
Exemple #2
0
def test_script_resolve_name():
    from rosgraph.names import script_resolve_name, get_ros_namespace, ns_join

    assert '/global' == script_resolve_name('/myscript', '/global')
    val = script_resolve_name('/myscript', '')    
    assert get_ros_namespace() == val, val
    val = script_resolve_name('/myscript', 'foo')    
    assert ns_join(get_ros_namespace(), 'foo') == val, val
    assert '/myscript/private' == script_resolve_name('/myscript', '~private')    
def _rosparam_cmd_get_dump(cmd, argv):
    """
    Process command line for rosparam get/dump, e.g.::
      rosparam get param
      rosparam dump file.yaml [namespace]

    :param cmd: command ('get' or 'dump'), ``str``
    :param argv: command-line args, ``str``
    """
    # get and dump are equivalent functionality, just different arguments
    if cmd == 'dump':
        parser = OptionParser(
            usage="usage: %prog dump [options] file [namespace]", prog=NAME)
    elif cmd == 'get':
        parser = OptionParser(usage="usage: %prog get [options] parameter",
                              prog=NAME)
        parser.add_option("-p",
                          dest="pretty",
                          default=False,
                          action="store_true",
                          help="pretty print. WARNING: not YAML-safe")

    parser.add_option("-v",
                      dest="verbose",
                      default=False,
                      action="store_true",
                      help="turn on verbose output")
    options, args = parser.parse_args(argv[2:])

    arg = None
    ns = ''

    if len(args) == 0:
        if cmd == 'dump':
            parser.error("invalid arguments. Please specify a file name")
        elif cmd == 'get':
            parser.error("invalid arguments. Please specify a parameter name")
    elif len(args) == 1:
        arg = args[0]
    elif len(args) == 2 and cmd == 'dump':
        arg = args[0]
        ns = args[1]
    else:
        parser.error("too many arguments")

    if cmd == 'get':
        _rosparam_cmd_get_param(script_resolve_name(NAME, arg),
                                pretty=options.pretty,
                                verbose=options.verbose)
    else:
        if options.verbose:
            print("dumping namespace [%s] to file [%s]" % (ns, arg))
        dump_params(arg,
                    script_resolve_name(NAME, ns),
                    verbose=options.verbose)
Exemple #4
0
def print_node_filename(node_name, roslaunch_files):
    try:
        # #2309
        node_name = script_resolve_name("roslaunch", node_name)

        loader = roslaunch.xmlloader.XmlLoader(resolve_anon=False)
        config = load_config_default(roslaunch_files, None, loader=loader, verbose=False, assign_machines=False)
        nodes = [n for n in config.nodes if _resolved_name(n) == node_name] + [
            t for t in config.tests if _resolved_name(t) == node_name
        ]

        if len(nodes) > 1:
            raise RLException(
                "ERROR: multiple nodes named [%s] in [%s].\nPlease fix the launch files as duplicate names are not allowed."
                % (node_name, ", ".join(roslaunch_files))
            )
        if not nodes:
            print >> sys.stderr, "ERROR: cannot find node named [%s]. Run \n\troslaunch --nodes <files>\nto see list of node names." % (
                node_name
            )
        else:
            print nodes[0].filename

    except RLException as e:
        print >> sys.stderr, str(e)
        sys.exit(1)
def _rosparam_cmd_delete(argv):
    """
    Process command line for rosparam delete, e.g.::
      rosparam delete param 

    :param cmd: command name, ``str``
    :param argv: command-line args, ``str``
    """
    parser = OptionParser(usage="usage: %prog delete [options] parameter",
                          prog=NAME)
    parser.add_option("-v",
                      dest="verbose",
                      default=False,
                      action="store_true",
                      help="turn on verbose output")
    options, args = parser.parse_args(argv[2:])

    arg2 = None
    if len(args) == 0:
        parser.error("invalid arguments. Please specify a parameter name")
    elif len(args) == 1:
        arg = args[0]
    else:
        parser.error("too many arguments")

    try:
        delete_param(script_resolve_name(NAME, arg), verbose=options.verbose)
    except rosgraph.masterapi.Error as e:
        raise RosParamException(str(e))
Exemple #6
0
def print_node_filename(node_name, roslaunch_files):
    try:
        # #2309
        node_name = script_resolve_name('roslaunch', node_name)

        loader = roslaunch.xmlloader.XmlLoader(resolve_anon=False)
        config = load_config_default(roslaunch_files,
                                     None,
                                     loader=loader,
                                     verbose=False,
                                     assign_machines=False)
        nodes = [n for n in config.nodes if _resolved_name(n) == node_name] + \
            [t for t in config.tests if _resolved_name(t) == node_name]

        if len(nodes) > 1:
            raise RLException(
                "ERROR: multiple nodes named [%s] in [%s].\nPlease fix the launch files as duplicate names are not allowed."
                % (node_name, ', '.join(roslaunch_files)))
        if not nodes:
            print(
                'ERROR: cannot find node named [%s]. Run \n\troslaunch --nodes <files>\nto see list of node names.'
                % (node_name),
                file=sys.stderr)
        else:
            print(nodes[0].filename)

    except RLException as e:
        print(str(e), file=sys.stderr)
        sys.exit(1)
Exemple #7
0
def _rosparam_cmd_delete(argv):
    """
    Process command line for rosparam delete, e.g.::
      rosparam delete param 

    :param cmd: command name, ``str``
    :param argv: command-line args, ``str``
    """
    parser = OptionParser(usage="usage: %prog delete [options] parameter", prog=NAME)
    parser.add_option("-v", dest="verbose", default=False,
                      action="store_true", help="turn on verbose output")
    options, args = parser.parse_args(argv[2:])

    arg2 = None
    if len(args) == 0:
        parser.error("invalid arguments. Please specify a parameter name")
    elif len(args) == 1:
        arg = args[0]
    else:
        parser.error("too many arguments")

    try:
        delete_param(script_resolve_name(NAME, arg), verbose=options.verbose)
    except rosgraph.masterapi.Error as e:
        raise RosParamException(str(e))
Exemple #8
0
def get_node_args(node_name, roslaunch_files):
    """
    Get the node arguments for a node in roslaunch_files. 

    @param node_name: name of node in roslaunch_files.
    @type  node_name: str
    @param roslaunch_files: roslaunch file names
    @type  roslaunch_files: [str]
    @return: list of command-line arguments used to launch node_name
    @rtype: [str]
    @raise RLException: if node args cannot be retrieved
    """

    # we have to create our own XmlLoader so that we can use the same
    # resolution context for substitution args

    loader = roslaunch.xmlloader.XmlLoader(resolve_anon=False)
    config = load_config_default(roslaunch_files,
                                 None,
                                 loader=loader,
                                 verbose=False,
                                 assign_machines=False)
    (node_name) = substitution_args.resolve_args((node_name),
                                                 resolve_anon=False)
    node_name = script_resolve_name(
        'roslaunch', node_name) if not node_name.startswith('$') else node_name

    node = [n for n in config.nodes if _resolved_name(n) == node_name] + \
        [n for n in config.tests if _resolved_name(n) == node_name]
    if not node:
        node_list = get_node_list(config)
        node_list_str = '\n'.join([" * %s" % x for x in node_list])
        raise RLException(
            "ERROR: Cannot find node named [%s] in [%s].\nNode names are:\n%s"
            % (node_name, ', '.join(roslaunch_files), node_list_str))
    elif len(node) > 1:
        raise RLException(
            "ERROR: multiple nodes named [%s] in [%s].\nPlease fix the launch files as duplicate names are not allowed."
            % (node_name, ', '.join(roslaunch_files)))
    node = node[0]

    master_uri = rosgraph.get_master_uri()
    machine = local_machine()
    env = setup_env(node, machine, master_uri)

    # remove setting identical to current environment for easier debugging
    to_remove = []
    for k in env.keys():
        if env[k] == os.environ.get(k, None):
            to_remove.append(k)
    for k in to_remove:
        del env[k]

    # resolve node name for generating args
    args = create_local_process_args(node, machine)
    # join environment vars are bash prefix args
    return ["%s=%s" % (k, v) for k, v in env.items()] + args
Exemple #9
0
def _rosparam_cmd_get_dump(cmd, argv):
    """
    Process command line for rosparam get/dump, e.g.::
      rosparam get param
      rosparam dump file.yaml [namespace]

    :param cmd: command ('get' or 'dump'), ``str``
    :param argv: command-line args, ``str``
    """
    # get and dump are equivalent functionality, just different arguments
    if cmd == 'dump':
        parser = OptionParser(usage="usage: %prog dump [options] file [namespace]", prog=NAME)
    elif cmd == 'get':
        parser = OptionParser(usage="usage: %prog get [options] parameter", prog=NAME)        
        parser.add_option("-p", dest="pretty", default=False,
                          action="store_true", help="pretty print. WARNING: not YAML-safe")

    parser.add_option("-v", dest="verbose", default=False,
                      action="store_true", help="turn on verbose output")
    options, args = parser.parse_args(argv[2:])

    arg = None
    ns = ''
    
    if len(args) == 0:
        if cmd == 'dump':
            parser.error("invalid arguments. Please specify a file name")
        elif cmd == 'get':
            parser.error("invalid arguments. Please specify a parameter name")
    elif len(args) == 1:
        arg = args[0]
    elif len(args) == 2 and cmd == 'dump':
        arg = args[0]
        ns = args[1]
    else:
        parser.error("too many arguments")

    if cmd == 'get':
        _rosparam_cmd_get_param(script_resolve_name(NAME, arg), pretty=options.pretty, verbose=options.verbose)
    else:
        if options.verbose:
            print("dumping namespace [%s] to file [%s]"%(ns, arg))
        dump_params(arg, script_resolve_name(NAME, ns), verbose=options.verbose)
Exemple #10
0
def handle_rwt_rosparam_marc(req):

    paramList = []
    ns = ''
    tree = rosparam.get_param(script_resolve_name('rosparam', ns))
    dump = yaml.dump(tree)
    if dump.endswith('\n...\n'):
        dump = dump[:-5]
    paramList.append("%s\n" % (dump))
    
    return DumpParamsResponse(paramList)
Exemple #11
0
def get_node_args(node_name, roslaunch_files):
    """
    Get the node arguments for a node in roslaunch_files. 

    @param node_name: name of node in roslaunch_files.
    @type  node_name: str
    @param roslaunch_files: roslaunch file names
    @type  roslaunch_files: [str]
    @return: list of command-line arguments used to launch node_name
    @rtype: [str]
    @raise RLException: if node args cannot be retrieved
    """

    # we have to create our own XmlLoader so that we can use the same
    # resolution context for substitution args

    loader = roslaunch.xmlloader.XmlLoader(resolve_anon=False)
    config = load_config_default(roslaunch_files, None, loader=loader, verbose=False, assign_machines=False)
    (node_name) = substitution_args.resolve_args((node_name), resolve_anon=False)
    node_name = script_resolve_name("roslaunch", node_name) if not node_name.startswith("$") else node_name

    node = [n for n in config.nodes if _resolved_name(n) == node_name] + [
        n for n in config.tests if _resolved_name(n) == node_name
    ]
    if not node:
        node_list = get_node_list(config)
        node_list_str = "\n".join([" * %s" % x for x in node_list])
        raise RLException(
            "ERROR: Cannot find node named [%s] in [%s].\nNode names are:\n%s"
            % (node_name, ", ".join(roslaunch_files), node_list_str)
        )
    elif len(node) > 1:
        raise RLException(
            "ERROR: multiple nodes named [%s] in [%s].\nPlease fix the launch files as duplicate names are not allowed."
            % (node_name, ", ".join(roslaunch_files))
        )
    node = node[0]

    master_uri = rosgraph.get_master_uri()
    machine = local_machine()
    env = setup_env(node, machine, master_uri)

    # remove setting identical to current environment for easier debugging
    to_remove = []
    for k in env.iterkeys():
        if env[k] == os.environ.get(k, None):
            to_remove.append(k)
    for k in to_remove:
        del env[k]

    # resolve node name for generating args
    args = create_local_process_args(node, machine)
    # join environment vars are bash prefix args
    return ["%s=%s" % (k, v) for k, v in env.iteritems()] + args
Exemple #12
0
def print_node_args(node_name, roslaunch_files):
    """
    Print arguments of node to screen. Will cause system exit if
    exception occurs. This is a subroutine for the roslaunch main
    handler.
    
    @param node_name: node name
    @type  node_name: str
    @param roslaunch_files: list of launch files to load
    @type  roslaunch_files: str
    """
    try:
        node_name = script_resolve_name('roslaunch', node_name)
        args = get_node_args(node_name, roslaunch_files)
        print(' '.join(args))
    except RLException as e:
        print(str(e), file=sys.stderr)
        sys.exit(1)
def _rosparam_cmd_list(argv):
    """
    Process command line for rosparam set/load, e.g.::
      rosparam load file.yaml [namespace]
      rosparam set param value

    :param argv: command-line args, ``str``
    """
    parser = OptionParser(usage="usage: %prog list [namespace]", prog=NAME)
    options, args = parser.parse_args(argv[2:])

    ns = GLOBALNS
    if len(args) == 1:
        ns = script_resolve_name(NAME, args[0])
    elif len(args) == 2:
        parser.error("too many arguments")

    print('\n'.join(list_params(ns)))
Exemple #14
0
def _rosparam_cmd_list(argv):
    """
    Process command line for rosparam set/load, e.g.::
      rosparam load file.yaml [namespace]
      rosparam set param value

    :param argv: command-line args, ``str``
    """
    parser = OptionParser(usage="usage: %prog list [namespace]", prog=NAME)
    options, args = parser.parse_args(argv[2:])

    ns = GLOBALNS
    if len(args) == 1:
        ns = script_resolve_name(NAME, args[0])
    elif len(args) == 2:
        parser.error("too many arguments")

    print('\n'.join(list_params(ns)))
Exemple #15
0
def print_node_args(node_name, roslaunch_files):
    """
    Print arguments of node to screen. Will cause system exit if
    exception occurs. This is a subroutine for the roslaunch main
    handler.
    
    @param node_name: node name
    @type  node_name: str
    @param roslaunch_files: list of launch files to load
    @type  roslaunch_files: str
    """
    try:
        node_name = script_resolve_name('roslaunch', node_name)
        args = get_node_args(node_name, roslaunch_files)
        print ' '.join(args)
    except RLException as e:
        print >> sys.stderr, str(e)
        sys.exit(1)
Exemple #16
0
def handle_rwt_rosparam_marc_load(req):

    paramResponse = []
    paramList = []
    ns = ''

    for doc in yaml.load_all(req.params):
        paramList.append((doc, ns))

    for params, ns in paramList:
        rosparam.upload_params(ns, params)

    # TODO return test
    tree = rosparam.get_param(script_resolve_name('rosparam', ns))
    dump = yaml.dump(tree)
    if dump.endswith('\n...\n'):
        dump = dump[:-5]

    paramResponse.append("%s\n" % (dump))

    return LoadParamsResponse(paramResponse)
Exemple #17
0
def print_node_args(node_name, roslaunch_files):
    """
    Print arguments of node to screen. Will cause system exit if
    exception occurs. This is a subroutine for the roslaunch main
    handler.
    
    @param node_name: node name
    @type  node_name: str
    @param roslaunch_files: list of launch files to load
    @type  roslaunch_files: str
    """
    try:
        node_name = script_resolve_name('roslaunch', node_name)
        args = get_node_args(node_name, roslaunch_files)
        if sys.platform == 'win32':
            # launch in a new cmd window for isolated environment configuration
            print('cmd /c \"%s\"' % (' '.join(args)))
        else:
            # sys.platform.startswith('linux')
            print(' '.join(args))
    except RLException as e:
        print(str(e), file=sys.stderr)
        sys.exit(1)
def _rosparam_cmd_set_load(cmd, argv):
    """
    Process command line for rosparam set/load, e.g.::
      rosparam load file.yaml [namespace]
      rosparam set param value

    :param cmd: command name, ``str``
    :param argv: command-line args, ``str``
    """
    if cmd == 'load':
        parser = OptionParser(
            usage="usage: %prog load [options] file [namespace]", prog=NAME)
    elif cmd == 'set':
        parser = OptionParser(
            usage="usage: %prog set [options] parameter value", prog=NAME)
        parser.add_option("-t",
                          "--textfile",
                          dest="text_file",
                          default=None,
                          metavar="TEXT_FILE",
                          help="set parameters to contents of text file")
        parser.add_option("-b",
                          "--binfile",
                          dest="bin_file",
                          default=None,
                          metavar="BINARY_FILE",
                          help="set parameters to contents of binary file")

    parser.add_option("-v",
                      dest="verbose",
                      default=False,
                      action="store_true",
                      help="turn on verbose output")
    options, args = _set_optparse_neg_args(parser, argv)
    if cmd == 'set':
        if options.text_file and options.bin_file:
            parser.error("you may only specify one of --textfile or --binfile")

    arg2 = None
    if len(args) == 0:
        if cmd == 'load':
            parser.error("invalid arguments. Please specify a file name")
        elif cmd == 'set':
            parser.error("invalid arguments. Please specify a parameter name")
    elif len(args) == 1:
        arg = args[0]
        if cmd == 'set' and not (options.text_file or options.bin_file):
            parser.error("invalid arguments. Please specify a parameter value")
    elif len(args) == 2:
        arg = args[0]
        arg2 = args[1]
    else:
        parser.error("too many arguments")

    if cmd == 'set':
        name = script_resolve_name(NAME, arg)
        # #2647
        if options.text_file:
            if not os.path.isfile(options.text_file):
                parser.error("file '%s' does not exist" % (options.text_file))
            with open(options.text_file) as f:
                arg2 = f.read()
            set_param_raw(name, arg2, verbose=options.verbose)
        elif options.bin_file:
            with open(options.bin_file, 'rb') as f:
                arg2 = Binary(f.read())
            set_param_raw(name, arg2, verbose=options.verbose)
        else:
            # #2237: the empty string is really hard to specify on the
            # command-line due to bash quoting rules. We cheat here and
            # let an empty Python string be an empty YAML string (instead
            # of YAML null, which has no meaning to the Parameter Server
            # anyway).
            if arg2 == '':
                arg2 = '!!str'
            set_param(name, arg2, verbose=options.verbose)
    else:
        paramlist = load_file(arg,
                              default_namespace=script_resolve_name(
                                  NAME, arg2),
                              verbose=options.verbose)
        for params, ns in paramlist:
            upload_params(ns, params, verbose=options.verbose)
Exemple #19
0
def _rosparam_cmd_set_load(cmd, argv):
    """
    Process command line for rosparam set/load, e.g.::
      rosparam load file.yaml [namespace]
      rosparam set param value

    :param cmd: command name, ``str``
    :param argv: command-line args, ``str``
    """
    if cmd == 'load':
        parser = OptionParser(usage="usage: %prog load [options] file [namespace]", prog=NAME)
    elif cmd == 'set':
        parser = OptionParser(usage="usage: %prog set [options] parameter value", prog=NAME)
        parser.add_option("-t", "--textfile", dest="text_file", default=None,
                          metavar="TEXT_FILE", help="set parameters to contents of text file")
        parser.add_option("-b", "--binfile", dest="bin_file", default=None,
                          metavar="BINARY_FILE", help="set parameters to contents of binary file")

    parser.add_option("-v", dest="verbose", default=False,
                      action="store_true", help="turn on verbose output")
    if cmd == 'set':
        options, args = _set_optparse_neg_args(parser, argv)
        if options.text_file and options.bin_file:
            parser.error("you may only specify one of --textfile or --binfile")
    else:
        options, args = parser.parse_args(argv[2:])

    arg2 = None
    if len(args) == 0:
        if cmd == 'load':
            parser.error("invalid arguments. Please specify a file name or - for stdin")
        elif cmd == 'set':
            parser.error("invalid arguments. Please specify a parameter name")
    elif len(args) == 1:
        arg = args[0]
        if cmd == 'set' and not (options.text_file or options.bin_file):
            parser.error("invalid arguments. Please specify a parameter value")
    elif len(args) == 2:
        arg = args[0]
        arg2 = args[1]
    else:
        parser.error("too many arguments")

    if cmd == 'set':
        name = script_resolve_name(NAME, arg)
        # #2647
        if options.text_file:
            if not os.path.isfile(options.text_file):
                parser.error("file '%s' does not exist"%(options.text_file))
            with open(options.text_file) as f:
                arg2 = f.read()
            set_param_raw(name, arg2, verbose=options.verbose) 
        elif options.bin_file:
            with open(options.bin_file, 'rb') as f:
                arg2 = Binary(f.read())
            set_param_raw(name, arg2, verbose=options.verbose)                
        else:
            # #2237: the empty string is really hard to specify on the
            # command-line due to bash quoting rules. We cheat here and
            # let an empty Python string be an empty YAML string (instead
            # of YAML null, which has no meaning to the Parameter Server
            # anyway).
            if arg2 == '':
                arg2 = '!!str'
            set_param(name, arg2, verbose=options.verbose)
    else:
        paramlist = load_file(arg, default_namespace=script_resolve_name(NAME, arg2), verbose=options.verbose)
        for params,ns in paramlist:
            upload_params(ns, params, verbose=options.verbose)
Exemple #20
0
    print("Usage: " + os.path.basename(__file__) + " package launchfile")
    print(
        "prints the paramters the node-executable gets if it is launched with roslaunch and the given launchfile."
        +
        " A common use case for this is to get the argument to make the gtcreator debugger work properly"
    )
    sys.exit()

launch_files = rlutil.resolve_launch_arguments(sys.argv[1:])
loader = roslaunch.xmlloader.XmlLoader(resolve_anon=False)
config = roslaunch.config.load_config_default(launch_files,
                                              None,
                                              loader=loader,
                                              verbose=False,
                                              assign_machines=False)
nodes = node_args.get_node_list(config)
if len(nodes) > 1:
    print("ERROR: the launchfile contains more than one launchfile!")
    sys.exit()

node = nodes[0]
node_name = script_resolve_name('roslaunch', node)
node_args = node_args.get_node_args(node_name, launch_files)
if len(node_args) < 2:
    print("ERROR: not enough node args!")
    sys.exit()

namespace = node_args[0].split("=")[1]
clean_args = node_args[2:] + ["__ns:=" + namespace]
print ' '.join(clean_args)