Mercurial Mercurial > ns-3.5 / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
wutils.py
changeset 4064 10222f483860
parent 3933 3c149230e98a
child 4108 92bae583f934
equal deleted inserted replaced
4031:d26a4018a9ef 4064:10222f483860 
     1 import os
 
     1 import os
 
     2 import os.path
 
     2 import os.path
 
     3 import Params
 
       
     4 import Object
 
       
     5 import sys
 
     3 import sys
 
     6 import pproc as subprocess
 
     4 import pproc as subprocess
 
     7 import shlex
 
     5 import shlex
 
       
     6 
       
     7 # WAF modules
 
     8 import ccroot
 
     8 import ccroot
 
       
     9 import Options
 
       
    10 import Utils
 
       
    11 import Logs
 
       
    12 import TaskGen
 
       
    13 import Build
 
       
    14 
     9 
    15 
    10 # these are set from the main wscript file
 
    16 # these are set from the main wscript file
 
    11 APPNAME=None
 
    17 APPNAME=None
 
    12 VERSION=None
 
    18 VERSION=None
 
       
    19 
    13 #
 
    20 #
 
    14 # The last part of the path name to use to find the regression traces tarball.
 
    21 # The last part of the path name to use to find the regression traces tarball.
 
    15 # path will be APPNAME + '-' + VERSION + REGRESSION_SUFFIX + TRACEBALL_SUFFIX,
 
    22 # path will be APPNAME + '-' + VERSION + REGRESSION_SUFFIX + TRACEBALL_SUFFIX,
 
    16 # e.g., ns-3-dev-ref-traces.tar.bz2
 
    23 # e.g., ns-3-dev-ref-traces.tar.bz2
 
    17 #
 
    24 #
 
    18 TRACEBALL_SUFFIX = ".tar.bz2"
 
    25 TRACEBALL_SUFFIX = ".tar.bz2"
 
    19 
    26 
    20 
    27 
    21 
    28 
    22 def get_command_template(*arguments):
 
    29 def get_command_template(*arguments):
 
    23     if Params.g_options.valgrind:
 
    30     if Options.options.valgrind:
 
    24         if Params.g_options.command_template:
 
    31         if Options.options.command_template:
 
    25             Params.fatal("Options --command-template and --valgrind are conflicting")
 
    32             raise Utils.WafError("Options --command-template and --valgrind are conflicting")
 
    26         cmd = "valgrind --leak-check=full %s"
 
    33         cmd = "valgrind --leak-check=full %s"
 
    27     else:
 
    34     else:
 
    28         cmd = Params.g_options.command_template or '%s'
 
    35         cmd = Options.options.command_template or '%s'
 
    29     for arg in arguments:
 
    36     for arg in arguments:
 
    30         cmd = cmd + " " + arg
 
    37         cmd = cmd + " " + arg
 
    31     return cmd
 
    38     return cmd
 
    32 
    39 
    33 
    40 
    34 
    41 
    35 def find_program(program_name, env):
 
    42 def find_program(program_name, env):
 
    36     launch_dir = os.path.abspath(Params.g_cwd_launch)
 
    43     launch_dir = os.path.abspath(Options.cwd_launch)
 
    37     found_programs = []
 
    44     found_programs = []
 
    38     for obj in Object.g_allobjs:
 
    45     for obj in Build.bld.all_task_gen:
 
    39         if not getattr(obj, 'is_ns3_program', False):
 
    46         if not getattr(obj, 'is_ns3_program', False):
 
    40             continue
 
    47             continue
 
    41 
    48 
    42         ## filter out programs not in the subtree starting at the launch dir
 
    49         ## filter out programs not in the subtree starting at the launch dir
 
    43         if not (obj.path.abspath().startswith(launch_dir)
 
    50         if not (obj.path.abspath().startswith(launch_dir)
 
    49             return obj
 
    56             return obj
 
    50     raise ValueError("program '%s' not found; available programs are: %r"
 
    57     raise ValueError("program '%s' not found; available programs are: %r"
 
    51                      % (program_name, found_programs))
 
    58                      % (program_name, found_programs))
 
    52 
    59 
    53 def get_proc_env(os_env=None):
 
    60 def get_proc_env(os_env=None):
 
    54     env = Params.g_build.env_of_name('default')
 
    61     env = Build.bld.env
 
    55     if sys.platform == 'linux2':
 
    62     if sys.platform == 'linux2':
 
    56         pathvar = 'LD_LIBRARY_PATH'
 
    63         pathvar = 'LD_LIBRARY_PATH'
 
    57     elif sys.platform == 'darwin':
 
    64     elif sys.platform == 'darwin':
 
    58         pathvar = 'DYLD_LIBRARY_PATH'
 
    65         pathvar = 'DYLD_LIBRARY_PATH'
 
    59     elif sys.platform == 'win32':
 
    66     elif sys.platform == 'win32':
 
    61     elif sys.platform == 'cygwin':
 
    68     elif sys.platform == 'cygwin':
 
    62         pathvar = 'PATH'
 
    69         pathvar = 'PATH'
 
    63     elif sys.platform.startswith('freebsd'):
 
    70     elif sys.platform.startswith('freebsd'):
 
    64         pathvar = 'LD_LIBRARY_PATH'
 
    71         pathvar = 'LD_LIBRARY_PATH'
 
    65     else:
 
    72     else:
 
    66         Params.warning(("Don't know how to configure "
 
    73         Logs.warn(("Don't know how to configure "
 
    67                         "dynamic library path for the platform %r;"
 
    74                         "dynamic library path for the platform %r;"
 
    68                         " assuming it's LD_LIBRARY_PATH.") % (sys.platform,))
 
    75                         " assuming it's LD_LIBRARY_PATH.") % (sys.platform,))
 
    69         pathvar = 'LD_LIBRARY_PATH'        
    76         pathvar = 'LD_LIBRARY_PATH'        
    70 
    77 
    71     proc_env = dict(os.environ)
 
    78     proc_env = dict(os.environ)
 
    76         if pathvar in proc_env:
 
    83         if pathvar in proc_env:
 
    77             proc_env[pathvar] = os.pathsep.join(list(env['NS3_MODULE_PATH']) + [proc_env[pathvar]])
 
    84             proc_env[pathvar] = os.pathsep.join(list(env['NS3_MODULE_PATH']) + [proc_env[pathvar]])
 
    78         else:
 
    85         else:
 
    79             proc_env[pathvar] = os.pathsep.join(list(env['NS3_MODULE_PATH']))
 
    86             proc_env[pathvar] = os.pathsep.join(list(env['NS3_MODULE_PATH']))
 
    80 
    87 
    81     pymoddir = Params.g_build.m_curdirnode.find_dir('bindings/python').abspath(env)
 
    88     pymoddir = Build.bld.path.find_dir('bindings/python').abspath(env)
 
    82     if 'PYTHONPATH' in proc_env:
 
    89     if 'PYTHONPATH' in proc_env:
 
    83         proc_env['PYTHONPATH'] = os.pathsep.join([pymoddir] + [proc_env['PYTHONPATH']])
 
    90         proc_env['PYTHONPATH'] = os.pathsep.join([pymoddir] + [proc_env['PYTHONPATH']])
 
    84     else:
 
    91     else:
 
    85         proc_env['PYTHONPATH'] = pymoddir
 
    92         proc_env['PYTHONPATH'] = pymoddir
 
    86 
    93 
    87     return proc_env
 
    94     return proc_env
 
    88 
    95 
    89 def run_argv(argv, os_env=None):
 
    96 def run_argv(argv, os_env=None):
 
    90     proc_env = get_proc_env(os_env)
 
    97     proc_env = get_proc_env(os_env)
 
    91     #env = Params.g_build.env_of_name('default')
 
    98     #env = Build.bld.env
 
    92     retval = subprocess.Popen(argv, env=proc_env).wait()
 
    99     retval = subprocess.Popen(argv, env=proc_env).wait()
 
    93     if retval:
 
   100     if retval:
 
    94         Params.fatal("Command %s exited with code %i" % (argv, retval))
 
   101         raise Utils.WafError("Command %s exited with code %i" % (argv, retval))
 
    95     return retval
 
   102     return retval
 
    96 
   103 
    97 def get_run_program(program_string, command_template=None):
 
   104 def get_run_program(program_string, command_template=None):
 
    98     """
 
   105     """
 
    99     Return the program name and argv of the process that would be executed by
 
   106     Return the program name and argv of the process that would be executed by
 
   100     run_program(program_string, command_template).
 
   107     run_program(program_string, command_template).
 
   101     """
 
   108     """
 
   102     #print "get_run_program_argv(program_string=%r, command_template=%r)" % (program_string, command_template)
 
   109     #print "get_run_program_argv(program_string=%r, command_template=%r)" % (program_string, command_template)
 
   103     env = Params.g_build.env_of_name('default')
 
   110     env = Build.bld.env
 
   104 
   111 
   105     if command_template in (None, '%s'):
 
   112     if command_template in (None, '%s'):
 
   106         argv = shlex.split(program_string)
 
   113         argv = shlex.split(program_string)
 
   107         program_name = argv[0]
 
   114         program_name = argv[0]
 
   108 
   115 
   109         try:
 
   116         try:
 
   110             program_obj = find_program(program_name, env)
 
   117             program_obj = find_program(program_name, env)
 
   111         except ValueError, ex:
 
   118         except ValueError, ex:
 
   112             Params.fatal(str(ex))
 
   119             raise Utils.WafError(str(ex))
 
   113 
   120 
   114         try:
 
   121         program_node = program_obj.path.find_or_declare(ccroot.get_target_name(program_obj))
 
   115             program_node = program_obj.path.find_build(ccroot.get_target_name(program_obj))
 
   122         #try:
 
   116         except AttributeError:
 
   123         #    program_node = program_obj.path.find_build(ccroot.get_target_name(program_obj))
 
   117             Params.fatal("%s does not appear to be a program" % (program_name,))
 
   124         #except AttributeError:
 
       
   125         #    raise Utils.WafError("%s does not appear to be a program" % (program_name,))
 
   118 
   126 
   119         execvec = [program_node.abspath(env)] + argv[1:]
 
   127         execvec = [program_node.abspath(env)] + argv[1:]
 
   120 
   128 
   121     else:
 
   129     else:
 
   122 
   130 
   123         program_name = program_string
 
   131         program_name = program_string
 
   124         try:
 
   132         try:
 
   125             program_obj = find_program(program_name, env)
 
   133             program_obj = find_program(program_name, env)
 
   126         except ValueError, ex:
 
   134         except ValueError, ex:
 
   127             Params.fatal(str(ex))
 
   135             raise Utils.WafError(str(ex))
 
   128         try:
 
   136 
   129             program_node = program_obj.path.find_build(ccroot.get_target_name(program_obj))
 
   137         program_node = program_obj.path.find_or_declare(ccroot.get_target_name(program_obj))
 
   130         except AttributeError:
 
   138         #try:
 
   131             Params.fatal("%s does not appear to be a program" % (program_name,))
 
   139         #    program_node = program_obj.path.find_build(ccroot.get_target_name(program_obj))
 
       
   140         #except AttributeError:
 
       
   141         #    raise Utils.WafError("%s does not appear to be a program" % (program_name,))
 
   132 
   142 
   133         execvec = shlex.split(command_template % (program_node.abspath(env),))
 
   143         execvec = shlex.split(command_template % (program_node.abspath(env),))
 
   134     return program_name, execvec
 
   144     return program_name, execvec
 
   135 
   145 
   136 def run_program(program_string, command_template=None):
 
   146 def run_program(program_string, command_template=None):
 
   140     full path to the program.  Else, program_string is interpreted as
 
   150     full path to the program.  Else, program_string is interpreted as
 
   141     a shell command with first name being the program name.
 
   151     a shell command with first name being the program name.
 
   142     """
 
   152     """
 
   143     dummy_program_name, execvec = get_run_program(program_string, command_template)
 
   153     dummy_program_name, execvec = get_run_program(program_string, command_template)
 
   144     former_cwd = os.getcwd()
 
   154     former_cwd = os.getcwd()
 
   145     if (Params.g_options.cwd_launch):
 
   155     if (Options.options.cwd_launch):
 
   146         os.chdir(Params.g_options.cwd_launch)
 
   156         os.chdir(Options.options.cwd_launch)
 
   147     else:
 
   157     else:
 
   148         os.chdir(Params.g_cwd_launch)
 
   158         os.chdir(Options.cwd_launch)
 
   149     try:
 
   159     try:
 
   150         retval = run_argv(execvec)
 
   160         retval = run_argv(execvec)
 
   151     finally:
 
   161     finally:
 
   152         os.chdir(former_cwd)
 
   162         os.chdir(former_cwd)
 
   153 
   163 
   154     return retval
 
   164     return retval
 
   155 
   165 
   156 
   166 
   157 
   167 
   158 def run_python_program(program_string):
 
   168 def run_python_program(program_string):
 
   159     env = Params.g_build.env_of_name('default')
 
   169     env = Build.bld.env
 
   160     execvec = shlex.split(program_string)
 
   170     execvec = shlex.split(program_string)
 
   161 
   171 
   162     former_cwd = os.getcwd()
 
   172     former_cwd = os.getcwd()
 
   163     if (Params.g_options.cwd_launch):
 
   173     if (Options.options.cwd_launch):
 
   164         os.chdir(Params.g_options.cwd_launch)
 
   174         os.chdir(Options.options.cwd_launch)
 
   165     else:
 
   175     else:
 
   166         os.chdir(Params.g_cwd_launch)
 
   176         os.chdir(Options.cwd_launch)
 
   167     try:
 
   177     try:
 
   168         retval = run_argv([env['PYTHON']] + execvec)
 
   178         retval = run_argv([env['PYTHON']] + execvec)
 
   169     finally:
 
   179     finally:
 
   170         os.chdir(former_cwd)
 
   180         os.chdir(former_cwd)
 
   171 
   181
ns-3.5