path: root/build-scripts/post-build-lava.py

#!/usr/bin/env python
import sys
import os
import re
import json
import xmlrpclib


def obfuscate_credentials(s):
    return re.sub(r"([^ ]:).+?(@)", r"\1xxx\2", s)

# Map a TARGET_PRODUCT to LAVA parameters.
PRODUCT_MAP = {
    "pandaboard": {
        "test_device_type": "panda",
        "image_path": "%s%s" % (
            "target/product/",
            "pandaboard")},
    "full_panda": {
        "test_device_type": "panda",
        "image_path": "%s%s" % (
            "target/product/",
            "panda")},
    "beagleboard": {
        "test_device_type": "beaglexm",
        "image_path": "%s%s" % (
            "target/product/",
            "beagleboard")},
    "snowball": {
        "test_device_type": "snowball_sd",
        "image_path": "%s%s" % (
            "target/product/",
            "snowball")},
    "iMX53": {
        "test_device_type": "mx53loco",
        "image_path": "%s%s" % (
            "target/product/",
            "iMX53")},
    "origen": {
        "test_device_type": "origen",
        "image_path": "%s%s" % (
            "target/product/",
            "origen")},
    "vexpress": {
        "test_device_type": "vexpress",
        "image_path": "%s%s" % (
            "target/product/",
            "vexpress")},
}

OPTION_SUFFIX = "_OPTION"
TIMEOUT_SUFFIX = "_TIMEOUT"
# Special token for LAVA_TEST_PLAN that allows the build owner to encode a
# reboot in between test actions.
REBOOT_TOKEN = '[system-reboot]'


def gen_lava_android_test_actions(tests=[]):
    actions = []
    if len(tests) == 0:
        return actions
    test_actions = []
    for test in tests:
        if test == REBOOT_TOKEN:
            continue
        ## support for test that specified with option like methanol,methanol(DEFAULT)
        if test.find('(') >= 0\
            and test.rfind(')') > test.find('('):
            test = test[:test.find('(')].strip()
            if not test:
                continue
        test_actions.append(test)

    if len(test_actions) > 0:
        inst_action = {
                          "command": "lava_android_test_install",
                          "parameters": {
                                        # ensure only unique test names
                                        "tests": list(set(test_actions))
                                         }
                            }
        actions.append(inst_action)

    for test in tests:

        ## support for test that specified with option like methanol,methanol(DEFAULT)
        ## for this case, get the option from the test
        test_option = ''
        if test.find('(') >= 0 and test.rfind(')') > test.find('(') \
            and test[:test.find('(')].strip():
            test_option = test[test.find('(') + 1 : test.rfind(')')]
            test = test[:test.find('(')].strip()

        parameters = {'test_name': test}

        if not test_option:
            test_option = os.environ.get('%s%s' % (test.upper(), OPTION_SUFFIX))

        if test_option:
            parameters['option'] = test_option

        timeout_option = os.environ.get('%s%s' % (test.upper(),
                                                  TIMEOUT_SUFFIX))
        if timeout_option:
            parameters['timeout'] = int(timeout_option)

        if test != REBOOT_TOKEN:
            run_action = {
                          "command": "lava_android_test_run",
                          "parameters": parameters
                        }
            actions.append(run_action)
        else:
            actions.append({"command": "boot_linaro_android_image"})

    return actions


def gen_test_plan_actions():
    test_plan = os.environ.get("LAVA_TEST_PLAN")
    if test_plan == None:
        test_plan = '0xbench, glmark2, monkey'
    test_plans = test_plan.split(',')
    for index in range(len(test_plans)):
        test_plans[index] = test_plans[index].strip()
        if test_plans[index] == "test_android_0xbench":
            test_plans[index] = "0xbench"
    return gen_lava_android_test_actions(test_plans)


def gen_command_action(commands=[], cmd_file=None, parser=None, timeout=None):
    parameters = None
    if commands:
        parameters = {'commands': commands}
    elif cmd_file:
        parameters = {'command_file': cmd_file}

    if parameters and parser:
        parameters['parser'] = parser

    if timeout:
        parameters['timeout'] = int(timeout)

    action = {"command": "lava_android_test_run_custom",
              "parameters": parameters}
    return action


def gen_custom_actions():
    test_actions = []
    prefix = 'LAVA_TEST_'
    pat_suffix = '_PATTERN'
    test_list = []
    for var in os.environ.keys():
        if var.startswith(prefix) and (not var.endswith(pat_suffix)) \
           and (var != 'LAVA_TEST_PLAN') \
           and (not var.endswith(TIMEOUT_SUFFIX)):
            test_list.append(var)
    test_list.sort()
    for var in test_list:
        cmd = os.environ.get(var)
        pattern = os.environ.get('%s%s' % (var, pat_suffix))
        timeout = os.environ.get('%s%s' % (var, TIMEOUT_SUFFIX))
        test_actions.append(gen_command_action(commands=[cmd],
                                                parser=pattern,
                                                timeout=timeout))

    return test_actions


def gen_monkeyrunner_actions():
    test_actions = []
    prefix = 'MONKEY_RUNNER_URL_'
    test_list = []
    for var in os.environ.keys():
        if var.startswith(prefix) and (not var.endswith(TIMEOUT_SUFFIX)):
            test_list.append(var)
    test_list.sort()
    for var in test_list:
        url = os.environ.get(var)
        parameters = {"url": url}
        timeout = os.environ.get('%s%s' % (var, TIMEOUT_SUFFIX))
        if timeout:
            parameters['timeout'] = int(timeout)
        action = {
                    "command": "lava_android_test_run_monkeyrunner",
                    "parameters": parameters
                 }
        test_actions.append(action)
    return test_actions


def gen_test_actions():
    test_actions = []
    test_actions.extend(gen_custom_actions())
    test_actions.extend(gen_test_plan_actions())
    test_actions.extend(gen_monkeyrunner_actions())
    return test_actions


def main():
    """Script entry point: return some JSON based on calling args.
    We should be called from Jenkins and expect the following to
    be defined: $TARGET_PRODUCT $JOB_NAME $BUILD_NUMBER $BUILD_URL"""

    # Target product name, user defined, e.g. pandaboard
    target_product = os.environ.get("TARGET_PRODUCT")
    # Job name, defined by android-build, e.g. linaro-android_leb-panda
    job_name = os.environ.get("JOB_NAME")
    frontend_job_name = "~" + job_name.replace("_", "/", 1)
    # Build number, defined by android-build, e.g. 61
    build_number = os.environ.get("BUILD_NUMBER")
    # Build url, defined by android-build, e.g.
    # https://android-build.linaro.org/jenkins/job/linaro-android_leb-panda/61/
    build_url = os.environ.get("BUILD_URL")
    # download base URL, this may differ from job URL if we don't host
    # downloads in Jenkins any more
    download_url = "http://snapshots.linaro.org/android/%s/%s/" % \
    (frontend_job_name, build_number)
    # User can disable the installation of android binaries (doing this will
    # disable hardware acceleration)
    enable_android_install_binaries = os.environ.get("LAVA_ANDROID_BINARIES")
    if enable_android_install_binaries == None:  # Not set, default to True
        enable_android_install_binaries = True
    elif enable_android_install_binaries.lower() in ['1', 'true', 'yes']:
        enable_android_install_binaries = True
    else:
        enable_android_install_binaries = False

    # Set the default timeout for all test,
    # if this value is not set, then use the 18000 seconds as the default value
    default_timeout = os.environ.get("DEFAULT_TIMEOUT", 18000)

    # Board-specific parameters
    if target_product not in PRODUCT_MAP:
        # We don't know how to test this job, so skip testing.
        print "Don't know how to test this board. Skip testing."
        return

    lava_server = os.environ.get("LAVA_SERVER")
    if lava_server == None:
        schema = 'https'
        url_no_schema = "validation.linaro.org/lava-server/RPC2/"
    elif lava_server.find('://') >= 0:
        schema = lava_server[:lava_server.find('://')]
        url_no_schema = lava_server[lava_server.find('://') + len('://'):]
    else:
        ## the case that no https and http specified in the url
        ## like: validation.linaro.org/lava-server/RPC2/
        schema = 'https'
        url_no_schema = lava_server #for compare with above condition
    schema_url = '%s://%s' % (schema, url_no_schema)
    lava_server = url_no_schema

    lava_user = os.environ.get("LAVA_USER")
    if lava_user == None:
        f = open('/var/run/lava/lava-user')
        lava_user = f.read().strip()
        f.close()
    default_stream = '/private/team/linaro/android-daily/'

    actions = [
    {
    "command": "deploy_linaro_android_image",
    "parameters":
      {
        "boot": "%s%s%s" % (download_url,
                            PRODUCT_MAP[target_product]["image_path"],
                            "/boot.tar.bz2"),
        "system":"%s%s%s" % (download_url,
                             PRODUCT_MAP[target_product]["image_path"],
                             "/system.tar.bz2"),
        "data":"%s%s%s" % (download_url,
                           PRODUCT_MAP[target_product]["image_path"],
                           "/userdata.tar.bz2")
      },
    "metadata":
      {
        "android.name": job_name,
        "android.build": '%s' % build_number,
        "android.url": build_url
      }
    }]

    if enable_android_install_binaries:
        actions.append({"command": "android_install_binaries"})

    actions.append({"command": "boot_linaro_android_image"})

    actions.extend(gen_test_actions())

    actions.append(
    {
      "command": "submit_results_on_host",
      "parameters":
      {
        "server": schema_url,
        "stream": PRODUCT_MAP[target_product].get(
              "test_stream", default_stream)
      }
    })

    config_json = {"job_name": build_url,
                   "image_type": 'android',
                   "timeout": int(default_timeout),
                   "actions": actions
                  }

    # allow overload lava device_type by build config
    test_device_type = os.environ.get("LAVA_DEVICE_TYPE")
    if not test_device_type:
        test_device_type = PRODUCT_MAP[target_product]["test_device_type"]

    # allow to submit to a specific device
    test_device = os.environ.get("LAVA_DEVICE")

    # test_device set will win over test_device_type
    # LAVA parameter naming could use more consistency
    if test_device:
        config_json["target"] = test_device
    else:
        config_json["device_type"] = test_device_type

    config = json.dumps(config_json, indent=4)

    print config

    lava_token_f = os.environ.get("LAVA_TOKEN_FILE")
    if lava_token_f == None:
        lava_token_f = '/var/run/lava/lava-token'
    with open(lava_token_f) as fd:
        lava_token = fd.read().strip()

    try:
        report_url = ("%(schema)s://"
             "%(lava_user)s:%(lava_token)s@%(lava_server)s") % dict(
                                    schema=schema,
                                    lava_user=lava_user,
                                    lava_token=lava_token,
                                    lava_server=lava_server)
        server = xmlrpclib.ServerProxy(report_url)
        lava_job_id = server.scheduler.submit_job(config)
        lava_server_root = lava_server.rstrip("/")
        if lava_server_root.endswith("/RPC2"):
            lava_server_root = lava_server_root[:-len("/RPC2")]
    except xmlrpclib.ProtocolError, e:
        print "Error making a LAVA request:", obfuscate_credentials(str(e))
        sys.exit(1)

    print "LAVA Job Id: %s, URL: %s://%s/scheduler/job/%s" % \
    (lava_job_id, schema, lava_server_root, lava_job_id)

    json.dump({
        'lava_url': "%s://%s" % (schema, lava_server_root),
        'job_id': lava_job_id,
        }, open('out/lava-job-info', 'w'))

if __name__ == "__main__":
        main()