#!/usr/bin/env python
##
## Licensed to the Apache Software Foundation (ASF) under one
## or more contributor license agreements.  See the NOTICE file
## distributed with this work for additional information
## regarding copyright ownership.  The ASF licenses this file
## to you under the Apache License, Version 2.0 (the
## "License"); you may not use this file except in compliance
## with the License.  You may obtain a copy of the License at
##
##   http://www.apache.org/licenses/LICENSE-2.0
##
## Unless required by applicable law or agreed to in writing,
## software distributed under the License is distributed on an
## "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
## KIND, either express or implied.  See the License for the
## specific language governing permissions and limitations
## under the License
##


"""
Run a tool or test in a build tree with the correct PATH, PYTHONPATH, etc.
Run with no arguments for help.
"""

usage="""
Run a tool or test in a build tree with the correct PATH, PYTHONPATH, etc.

Usage:
run.py <program> [<arg>....]               # Run a program, can be an interactive shell. Use PATH.
run.py -m <python-module>  [<arg>....]     # Run a python module. Use PYTHONPATH.
run.py -s <python-script>.py  [<arg>....]  # Run a python script.
run.py --vg <program> [<arg>....]          # Run a program with valgrind if enabled. Use PATH.
run.py --sh                                # Print a shell script to set the run.py environment.

Valgrind can be enabled or disabled by the cmake 'USE_VALGRIND' option and the
environment variable 'USE_VALGRIND' (set to 'ON' or 'OFF'). The environment
variable takes precendence if set.  By default valgrind runs the 'memcheck'
tool. The valgrind tool and supression file can be overridden by setting the
'VALGRIND_TOOL' and 'VALGRIND_SUPPRESSIONS' environment variables,
respectively. Additional options can be provided via the 'VALGRIND_OPTS'
environment variable.
"""

import os, sys, runpy
from subprocess import Popen, PIPE

def dedup(l):
    """Remove duplicates from list l, keep first instance. Keep order of l."""
    s = set()
    return [i for i in l if i not in s and (s.add(i) or True)]

sys.path = dedup([
    "${CMAKE_SOURCE_DIR}/python",
    "${CMAKE_BINARY_DIR}/python",
    "${CMAKE_SOURCE_DIR}/tests"
] + sys.path)

def getpath(env):
    path = os.environ.get(env)
    if path:
        return path.split(os.pathsep)
    return []

env_vars = {
    'PYTHONPATH': os.pathsep.join(sys.path),
    'PATH': os.pathsep.join(dedup(["${CMAKE_BINARY_DIR}",
                                   os.path.join("${CMAKE_BINARY_DIR}", 'tests'),
                                   os.path.join("${CMAKE_BINARY_DIR}", 'router'),
                                   os.path.join("${CMAKE_SOURCE_DIR}", 'tools'),
                                   os.path.join("${CMAKE_BINARY_DIR}", 'tools'),
                                   os.path.join("${CMAKE_SOURCE_DIR}", 'bin')] +
                                  getpath('PATH'))),
    'MANPATH' : os.pathsep.join([os.path.join("${CMAKE_BINARY_DIR}",'doc','man')] +
                                getpath('MANPATH')),
    'SOURCE_DIR': "${CMAKE_SOURCE_DIR}",
    'BUILD_DIR': "${CMAKE_BINARY_DIR}",
    'QPID_DISPATCH_HOME': "${CMAKE_SOURCE_DIR}",
    'QPID_DISPATCH_LIB': "${CMAKE_BINARY_DIR}/src/${QPID_DISPATCH_LIB}"
}
os.environ.update(env_vars)

# Valgrind setup
valgrind_exe = "${VALGRIND_EXECUTABLE}"

def use_valgrind():
    """True if we should use valgrind"""
    if not os.path.exists(valgrind_exe): return False
    def on(str):
        return str.lower() in ['on', 'yes', '1']
    env = os.environ.get('USE_VALGRIND')
    if env: return on(env)
    return on("${USE_VALGRIND}")

def find_exe(program):
    """Find an executable in the system PATH"""
    def is_exe(fpath):
        return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
    mydir, name = os.path.split(program)
    if mydir:
        if is_exe(program): return program
    else:
        for path in os.environ["PATH"].split(os.pathsep):
            exe_file = os.path.join(path, program)
            if is_exe(exe_file): return exe_file
    return None

def is_binary_exe(program):
    """True if the program is a binary executable"""
    if not program: return None
    p = Popen(['file', '-bi', program], stdout=PIPE, stderr=PIPE)
    return p.communicate()[0].startswith('application/x-executable')

VALGRIND_ERROR = 42   # magic number indicating valgrind found errors
def with_valgrind(args, outfile=None):
    if use_valgrind() and is_binary_exe(find_exe(args[0])):
        opts = ['--trace-children=yes',
                #  '--leak-check=full',  way too noisy due to Python leaks
                '--demangle=yes',
                '--num-callers=12',
                '--error-exitcode=%d' % VALGRIND_ERROR,
                '--quiet']
        opts.append('--tool=%s' % os.environ.get('VALGRIND_TOOL', 'memcheck'))
        supp = os.environ.get('VALGRIND_SUPPRESSIONS',
                              '${CMAKE_SOURCE_DIR}/tests/valgrind.supp')
        opts.append('--suppressions=%s' % supp)
        if outfile: opts.append('--log-file=%s' % outfile)
        opts.extend(os.environ.get('VALGRIND_OPTS', "").split())
        return ([valgrind_exe]+opts+args, VALGRIND_ERROR)
    return (args, 0)

def run_path(file_path, run_name=None):
    """Wrapper for run path that falls back to exec python for python < 2.7"""
    if hasattr(runpy, 'run_path'):
        runpy.run_path(file_path, run_name=run_name)
    else:                       # Python < 2.7
        os.execvp(sys.executable, [sys.executable]+sys.argv)

if __name__ == "__main__":
    error_prefix = ""
    try:
        if len(sys.argv) == 1:
            print usage
        elif sys.argv[1] == '-m':
            sys.argv = sys.argv[2:]
            error_prefix = "Run python module '%s': "%(sys.argv[0])
            runpy.run_module(sys.argv[0], alter_sys=True, run_name="__main__")
        elif sys.argv[1] == '-s':
            sys.argv = sys.argv[2:]
            error_prefix = "Run python script '%s':"%(sys.argv[0])
            run_path(sys.argv[0], run_name="__main__")
        elif sys.argv[1] == '--sh':
            for name, value in env_vars.iteritems(): print "%s=%s"%(name, value)
            print "export %s"%' '.join(env_vars.keys())
        elif sys.argv[1] == '--vg':
            args, ignore = with_valgrind(sys.argv[2:])
            error_prefix = "Run executable '%s' with valgrind: "%(args[0])
            os.execvp(args[0], args)
        elif sys.argv[1].startswith('-'):
            print usage
        else:
            args = sys.argv[1:]
            error_prefix = "Run executable '%s': "%(args[0])
            os.execvp(args[0], args)
    except Exception, e:
        print "%s%s: %s"%(error_prefix, type(e).__name__, e)
        raise