[lttng-ci.git] / scripts / lttng-baremetal-tests / lava-submit.py

#!/usr/bin/python
# Copyright (C) 2016 - Francis Deslauriers <francis.deslauriers@efficios.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import argparse
import base64
import json
import os
import sys
import time
import xmlrpc.client
from collections import OrderedDict
from enum import Enum

USERNAME = 'frdeso'
HOSTNAME = 'lava-master.internal.efficios.com'
SCP_PATH = 'scp://jenkins-lava@storage.internal.efficios.com'

class TestType(Enum):
    baremetal_benchmarks=1
    baremetal_tests=2
    kvm_tests=3

def get_job_bundle_content(server, job):
    try:
        bundle_sha = server.scheduler.job_status(str(job))['bundle_sha1']
        bundle = server.dashboard.get(bundle_sha)
    except xmlrpc.client.Fault as f:
        print('Error while fetching results bundle', f.faultString)

    return json.loads(bundle['content'])

# Parse the results bundle to see the run-tests testcase
# of the lttng-kernel-tests passed successfully
def check_job_all_test_cases_state_count(server, job):
    content = get_job_bundle_content(server, job)

    passed_tests=0
    failed_tests=0
    for run in content['test_runs']:
        for result in run['test_results']:
            if 'test_case_id' in result :
                if result['result'] in 'pass':
                    passed_tests+=1
                elif result['test_case_id'] in 'wait_for_test_image_prompt':
                    # FIXME:This test is part of the boot action and fails
                    # randomly but doesn't affect the behaviour of the tests.
                    # No reply on the Lava IRC channel yet. We should update
                    # our Lava installation and try to reproduce it. This error
                    # was encountered ont the KVM trusty image only. Not seen
                    # on Xenial at this point.
                    pass
                else:
                    failed_tests+=1
    return (passed_tests, failed_tests)

# Get the benchmark results from the lava bundle
# save them as CSV files localy
def fetch_benchmark_results(server, job):
    content = get_job_bundle_content(server, job)
    testcases = ['processed_results_close.csv', 'processed_results_open_enoent.csv', 'processed_results_open_efault.csv']

    # The result bundle is a large JSON containing the results of every testcase
    # of the LAVA job as well as the files that were attached during the run.
    # We need to iterate over this JSON to get the base64 representation of the
    # benchmark results produced during the run.
    for run in content['test_runs']:
        # We only care of the benchmark testcases
        if 'benchmark-syscall-' in run['test_id']:
            if 'test_results' in run:
                for res in run['test_results']:
                    if 'attachments' in res:
                        for a in res['attachments']:
                            # We only save the results file
                            if a['pathname'] in testcases:
                                with open(a['pathname'],'wb') as f:
                                    # Convert the b64 representation of the
                                    # result file and write it to a file
                                    # in the current working directory
                                    f.write(base64.b64decode(a['content']))

# Parse the attachment of the testcase to fetch the stdout of the test suite
def print_test_output(server, job):
    content = get_job_bundle_content(server, job)
    found = False

    for run in content['test_runs']:
        if run['test_id'] in 'lttng-kernel-test':
            for attachment in run['attachments']:
                if attachment['pathname'] in 'stdout.log':

                    # Decode the base64 file and split on newlines to iterate
                    # on list
                    testoutput = str(base64.b64decode(bytes(attachment['content'], encoding='UTF-8'))).split('\n')

                    # Create a generator to iterate on the lines and keeping
                    # the state of the iterator across the two loops.
                    testoutput_iter = iter(testoutput)
                    for line in testoutput_iter:

                        # Find the header of the test case and start printing
                        # from there
                        if 'LAVA_SIGNAL_STARTTC run-tests' in line:
                            found = True
                            print('---- TEST SUITE OUTPUT BEGIN ----')
                            for line in testoutput_iter:
                                if 'LAVA_SIGNAL_ENDTC run-tests' not in line:
                                    print(line)
                                else:
                                    # Print until we reach the end of the
                                    # section
                                    break

                        if found is True:
                            print('----- TEST SUITE OUTPUT END -----')
                            break

def create_new_job(name, build_device):
    job = OrderedDict({
        'health_check': False,
        'job_name': name,
        'device_type':build_device,
        'tags': [ ],
        'timeout': 18000,
        'actions': []
    })
    if build_device in 'x86':
        job['tags'].append('dev-sda1')

    return job

def get_boot_cmd():
    command = OrderedDict({
        'command': 'boot_image'
        })
    return command

def get_config_cmd(build_device):
    packages=['bsdtar', 'psmisc', 'wget', 'python3', 'python3-pip', \
            'libglib2.0-dev', 'libffi-dev', 'elfutils', 'libdw-dev', \
            'libelf-dev', 'libmount-dev', 'libxml2', 'libpfm4-dev', \
            'libnuma-dev']
    command = OrderedDict({
        'command': 'lava_command_run',
        'parameters': {
            'commands': [
                'cat /etc/resolv.conf',
                'echo nameserver 172.18.0.12 > /etc/resolv.conf',
                'groupadd tracing'
                ]
            }
        })
    if build_device in 'x86':
        command['parameters']['commands'].extend([
                    'mount /dev/sda1 /tmp',
                    'rm -rf /tmp/*'])

    command['parameters']['commands'].extend([
                    'depmod -a',
                    'locale-gen en_US.UTF-8',
                    'apt-get update',
                    'apt-get upgrade',
                    'apt-get install -y {}'.format(' '.join(packages))
                ])
    return command

def get_baremetal_benchmarks_cmd():
    command = OrderedDict({
        'command': 'lava_test_shell',
        'parameters': {
            'testdef_repos': [
                {
                    'git-repo': 'https://github.com/lttng/lttng-ci.git',
                    'revision': 'master',
                    'testdef': 'lava/baremetal-tests/failing-close.yml'
                },
                {
                    'git-repo': 'https://github.com/lttng/lttng-ci.git',
                    'revision': 'master',
                    'testdef': 'lava/baremetal-tests/failing-open-efault.yml'
                },
                {
                    'git-repo': 'https://github.com/lttng/lttng-ci.git',
                    'revision': 'master',
                    'testdef': 'lava/baremetal-tests/failing-open-enoent.yml'
                }
                ],
            'timeout': 18000
            }
        })
    return command

def get_baremetal_tests_cmd():
    command = OrderedDict({
        'command': 'lava_test_shell',
        'parameters': {
            'testdef_repos': [
                {
                    'git-repo': 'https://github.com/lttng/lttng-ci.git',
                    'revision': 'master',
                    'testdef': 'lava/baremetal-tests/perf-tests.yml'
                }
                ],
            'timeout': 18000
            }
        })
    return command

def get_kvm_tests_cmd():
    command = OrderedDict({
        'command': 'lava_test_shell',
        'parameters': {
            'testdef_repos': [
                {
                    'git-repo': 'https://github.com/lttng/lttng-ci.git',
                    'revision': 'master',
                    'testdef': 'lava/baremetal-tests/kernel-tests.yml'
                },
                {
                    'git-repo': 'https://github.com/lttng/lttng-ci.git',
                    'revision': 'master',
                    'testdef': 'lava/baremetal-tests/destructive-tests.yml'
                }
                ],
            'timeout': 18000
            }
        })
    return command

def get_results_cmd(stream_name):
    command = OrderedDict({
            'command': 'submit_results',
            'parameters': {
                'server': 'http://lava-master.internal.efficios.com/RPC2/'
            }
        })
    command['parameters']['stream']='/anonymous/'+stream_name+'/'
    return command

def get_deploy_cmd_kvm(jenkins_job, kernel_path, linux_modules_path, lttng_modules_path):
    command = OrderedDict({
            'command': 'deploy_kernel',
            'metadata': {},
            'parameters': {
                'customize': {},
                'kernel': None,
                'target_type': 'ubuntu',
                'rootfs': 'file:///var/lib/lava-server/default/media/images/xenial.img.gz',
                'login_prompt': 'kvm02 login:',
                'username': 'root'
                }
            })

    command['parameters']['customize'][SCP_PATH+linux_modules_path]=['rootfs:/','archive']
    command['parameters']['customize'][SCP_PATH+lttng_modules_path]=['rootfs:/','archive']
    command['parameters']['kernel'] = str(SCP_PATH+kernel_path)
    command['metadata']['jenkins_jobname'] = jenkins_job

    return command

def get_deploy_cmd_x86(jenkins_job, kernel_path, linux_modules_path, lttng_modules_path, nb_iter=None):
    command = OrderedDict({
            'command': 'deploy_kernel',
            'metadata': {},
            'parameters': {
                'overlays': [],
                'kernel': None,
                'nfsrootfs': str(SCP_PATH+'/storage/jenkins-lava/rootfs/rootfs_amd64_trusty_2016-02-23-1134.tar.gz'),
                'target_type': 'ubuntu'
                }
            })

    command['parameters']['overlays'].append( str(SCP_PATH+linux_modules_path))
    command['parameters']['overlays'].append( str(SCP_PATH+lttng_modules_path))
    command['parameters']['kernel'] = str(SCP_PATH+kernel_path)
    command['metadata']['jenkins_jobname'] = jenkins_job
    if nb_iter is not None:
        command['metadata']['nb_iterations'] = nb_iter

    return command


def get_env_setup_cmd(build_device, lttng_tools_commit, lttng_ust_commit=None):
    command = OrderedDict({
        'command': 'lava_command_run',
        'parameters': {
            'commands': [
                'pip3 install --upgrade pip',
                'hash -r',
                'git clone https://github.com/frdeso/syscall-bench-it.git bm',
                'pip3 install vlttng',
                        ],
            'timeout': 18000
            }
        })

    vlttng_cmd = 'vlttng --jobs=$(nproc) --profile urcu-master' \
                    ' --profile babeltrace-stable-1.4 ' \
                    ' --profile lttng-tools-master' \
                    ' --override projects.lttng-tools.checkout='+lttng_tools_commit + \
                    ' --profile lttng-tools-no-man-pages'

    if lttng_ust_commit is not None:
        vlttng_cmd += ' --profile lttng-ust-master ' \
                    ' --override projects.lttng-ust.checkout='+lttng_ust_commit+ \
                    ' --profile lttng-ust-no-man-pages'

    virtenv_path = None
    if build_device in 'kvm':
        virtenv_path = '/root/virtenv'
    else:
        virtenv_path = '/tmp/virtenv'

    vlttng_cmd += ' '+virtenv_path

    command['parameters']['commands'].append(vlttng_cmd)
    command['parameters']['commands'].append('ln -s '+virtenv_path+' /root/lttngvenv')
    command['parameters']['commands'].append('sync')

    return command

def main():
    test_type = None
    parser = argparse.ArgumentParser(description='Launch baremetal test using Lava')
    parser.add_argument('-t', '--type', required=True)
    parser.add_argument('-j', '--jobname', required=True)
    parser.add_argument('-k', '--kernel', required=True)
    parser.add_argument('-km', '--kmodule', required=True)
    parser.add_argument('-lm', '--lmodule', required=True)
    parser.add_argument('-tc', '--tools-commit', required=True)
    parser.add_argument('-uc', '--ust-commit', required=False)
    args = parser.parse_args()

    if args.type in 'baremetal-benchmarks':
        test_type = TestType.baremetal_benchmarks
    elif args.type in 'baremetal-tests':
        test_type = TestType.baremetal_tests
    elif args.type in 'kvm-tests':
        test_type = TestType.kvm_tests
    else:
        print('argument -t/--type {} unrecognized. Exiting...'.format(args.type))
        return -1

    lava_api_key = None
    try:
        lava_api_key = os.environ['LAVA_JENKINS_TOKEN']
    except Exception as e:
        print('LAVA_JENKINS_TOKEN not found in the environment variable. Exiting...', e )
        return -1

    if test_type is TestType.baremetal_benchmarks:
        j = create_new_job(args.jobname, build_device='x86')
        j['actions'].append(get_deploy_cmd_x86(args.jobname, args.kernel, args.kmodule, args.lmodule))
    elif test_type is TestType.baremetal_tests:
        j = create_new_job(args.jobname, build_device='x86')
        j['actions'].append(get_deploy_cmd_x86(args.jobname, args.kernel, args.kmodule, args.lmodule))
    elif test_type  is TestType.kvm_tests:
        j = create_new_job(args.jobname, build_device='kvm')
        j['actions'].append(get_deploy_cmd_kvm(args.jobname, args.kernel, args.kmodule, args.lmodule))

    j['actions'].append(get_boot_cmd())

    if test_type is TestType.baremetal_benchmarks:
        j['actions'].append(get_config_cmd('x86'))
        j['actions'].append(get_env_setup_cmd('x86', args.tools_commit))
        j['actions'].append(get_baremetal_benchmarks_cmd())
        j['actions'].append(get_results_cmd(stream_name='benchmark-kernel'))
    elif test_type is TestType.baremetal_tests:
        if args.ust_commit is None:
            print('Tests runs need -uc/--ust-commit options. Exiting...')
            return -1
        j['actions'].append(get_config_cmd('x86'))
        j['actions'].append(get_env_setup_cmd('x86', args.tools_commit, args.ust_commit))
        j['actions'].append(get_baremetal_tests_cmd())
        j['actions'].append(get_results_cmd(stream_name='tests-kernel'))
    elif test_type  is TestType.kvm_tests:
        if args.ust_commit is None:
            print('Tests runs need -uc/--ust-commit options. Exiting...')
            return -1
        j['actions'].append(get_config_cmd('kvm'))
        j['actions'].append(get_env_setup_cmd('kvm', args.tools_commit, args.ust_commit))
        j['actions'].append(get_kvm_tests_cmd())
        j['actions'].append(get_results_cmd(stream_name='tests-kernel'))
    else:
        assert False, 'Unknown test type'

    server = xmlrpc.client.ServerProxy('http://%s:%s@%s/RPC2' % (USERNAME, lava_api_key, HOSTNAME))

    jobid = server.scheduler.submit_job(json.dumps(j))

    print('Lava jobid:{}'.format(jobid))

    #Check the status of the job every 30 seconds
    jobstatus = server.scheduler.job_status(jobid)['job_status']
    not_running = False
    while jobstatus in 'Submitted' or jobstatus in 'Running':
        if not_running is False and jobstatus in 'Running':
            print('Job started running')
            not_running = True
        time.sleep(30)
        jobstatus = server.scheduler.job_status(jobid)['job_status']

    if test_type is TestType.kvm_tests or test_type is TestType.baremetal_tests:
        print_test_output(server, jobid)
    elif test_type is TestType.baremetal_benchmarks:
        fetch_benchmark_results(server, jobid)

    print('Job ended with {} status.'.format(jobstatus))
    if jobstatus not in 'Complete':
        return -1
    else:
        passed, failed=check_job_all_test_cases_state_count(server, jobid)
        print('With {} passed and {} failed Lava test cases.'.format(passed, failed))

        if failed == 0:
            return 0
        else:
            return -1

if __name__ == "__main__":
    sys.exit(main())
Commit	Line	Data
b3d73c46 FD	1	#!/usr/bin/python
	2	# Copyright (C) 2016 - Francis Deslauriers <francis.deslauriers@efficios.com>
	3	#
	4	# This program is free software: you can redistribute it and/or modify
	5	# it under the terms of the GNU General Public License as published by
	6	# the Free Software Foundation, either version 3 of the License, or
	7	# (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program. If not, see <http://www.gnu.org/licenses/>.
	16
	17	import argparse
	18	import base64
	19	import json
	20	import os
	21	import sys
	22	import time
f42b2b7e	23	import xmlrpc.client
b3d73c46 FD	24	from collections import OrderedDict
	25	from enum import Enum
	26
	27	USERNAME = 'frdeso'
	28	HOSTNAME = 'lava-master.internal.efficios.com'
	29	SCP_PATH = 'scp://jenkins-lava@storage.internal.efficios.com'
	30
	31	class TestType(Enum):
1ac7fa2c FD	32	baremetal_benchmarks=1
	33	baremetal_tests=2
	34	kvm_tests=3
b3d73c46 FD	35
b3d73c46 FD	36	def get_job_bundle_content(server, job):
534a243d FD	37	try:
	38	bundle_sha = server.scheduler.job_status(str(job))['bundle_sha1']
	39	bundle = server.dashboard.get(bundle_sha)
f42b2b7e FD	40	except xmlrpc.client.Fault as f:
f42b2b7e FD	41	print('Error while fetching results bundle', f.faultString)
b3d73c46 FD	42
	43	return json.loads(bundle['content'])
	44
	45	# Parse the results bundle to see the run-tests testcase
	46	# of the lttng-kernel-tests passed successfully
	47	def check_job_all_test_cases_state_count(server, job):
	48	content = get_job_bundle_content(server, job)
	49
	50	passed_tests=0
	51	failed_tests=0
	52	for run in content['test_runs']:
	53	for result in run['test_results']:
3e7245a4	54	if 'test_case_id' in result :
b3d73c46 FD	55	if result['result'] in 'pass':
b3d73c46 FD	56	passed_tests+=1
3e7245a4 FD	57	elif result['test_case_id'] in 'wait_for_test_image_prompt':
	58	# FIXME:This test is part of the boot action and fails
	59	# randomly but doesn't affect the behaviour of the tests.
	60	# No reply on the Lava IRC channel yet. We should update
	61	# our Lava installation and try to reproduce it. This error
	62	# was encountered ont the KVM trusty image only. Not seen
	63	# on Xenial at this point.
	64	pass
b3d73c46 FD	65	else:
	66	failed_tests+=1
	67	return (passed_tests, failed_tests)
	68
104ed94b FD	69	# Get the benchmark results from the lava bundle
	70	# save them as CSV files localy
	71	def fetch_benchmark_results(server, job):
	72	content = get_job_bundle_content(server, job)
	73	testcases = ['processed_results_close.csv', 'processed_results_open_enoent.csv', 'processed_results_open_efault.csv']
	74
	75	# The result bundle is a large JSON containing the results of every testcase
	76	# of the LAVA job as well as the files that were attached during the run.
	77	# We need to iterate over this JSON to get the base64 representation of the
	78	# benchmark results produced during the run.
	79	for run in content['test_runs']:
	80	# We only care of the benchmark testcases
	81	if 'benchmark-syscall-' in run['test_id']:
	82	if 'test_results' in run:
	83	for res in run['test_results']:
	84	if 'attachments' in res:
	85	for a in res['attachments']:
	86	# We only save the results file
	87	if a['pathname'] in testcases:
f42b2b7e	88	with open(a['pathname'],'wb') as f:
104ed94b FD	89	# Convert the b64 representation of the
	90	# result file and write it to a file
	91	# in the current working directory
	92	f.write(base64.b64decode(a['content']))
	93
b3d73c46 FD	94	# Parse the attachment of the testcase to fetch the stdout of the test suite
	95	def print_test_output(server, job):
	96	content = get_job_bundle_content(server, job)
	97	found = False
	98
	99	for run in content['test_runs']:
	100	if run['test_id'] in 'lttng-kernel-test':
	101	for attachment in run['attachments']:
	102	if attachment['pathname'] in 'stdout.log':
	103
	104	# Decode the base64 file and split on newlines to iterate
	105	# on list
f42b2b7e	106	testoutput = str(base64.b64decode(bytes(attachment['content'], encoding='UTF-8'))).split('\n')
b3d73c46 FD	107
	108	# Create a generator to iterate on the lines and keeping
	109	# the state of the iterator across the two loops.
	110	testoutput_iter = iter(testoutput)
	111	for line in testoutput_iter:
	112
	113	# Find the header of the test case and start printing
	114	# from there
	115	if 'LAVA_SIGNAL_STARTTC run-tests' in line:
	116	found = True
	117	print('---- TEST SUITE OUTPUT BEGIN ----')
	118	for line in testoutput_iter:
	119	if 'LAVA_SIGNAL_ENDTC run-tests' not in line:
	120	print(line)
	121	else:
	122	# Print until we reach the end of the
	123	# section
	124	break
	125
	126	if found is True:
	127	print('----- TEST SUITE OUTPUT END -----')
	128	break
	129
dc9700c9	130	def create_new_job(name, build_device):
b3d73c46 FD	131	job = OrderedDict({
	132	'health_check': False,
	133	'job_name': name,
dc9700c9 FD	134	'device_type':build_device,
dc9700c9 FD	135	'tags': [ ],
b3d73c46 FD	136	'timeout': 18000,
	137	'actions': []
	138	})
dc9700c9 FD	139	if build_device in 'x86':
	140	job['tags'].append('dev-sda1')
	141
b3d73c46 FD	142	return job
	143
	144	def get_boot_cmd():
	145	command = OrderedDict({
	146	'command': 'boot_image'
	147	})
	148	return command
	149
dc9700c9	150	def get_config_cmd(build_device):
b3d73c46 FD	151	packages=['bsdtar', 'psmisc', 'wget', 'python3', 'python3-pip', \
b3d73c46 FD	152	'libglib2.0-dev', 'libffi-dev', 'elfutils', 'libdw-dev', \
e1504b01 FD	153	'libelf-dev', 'libmount-dev', 'libxml2', 'libpfm4-dev', \
e1504b01 FD	154	'libnuma-dev']
b3d73c46 FD	155	command = OrderedDict({
	156	'command': 'lava_command_run',
	157	'parameters': {
	158	'commands': [
b3d73c46 FD	159	'cat /etc/resolv.conf',
b3d73c46 FD	160	'echo nameserver 172.18.0.12 > /etc/resolv.conf',
dc9700c9	161	'groupadd tracing'
b3d73c46 FD	162	]
	163	}
	164	})
dc9700c9 FD	165	if build_device in 'x86':
	166	command['parameters']['commands'].extend([
	167	'mount /dev/sda1 /tmp',
	168	'rm -rf /tmp/*'])
	169
	170	command['parameters']['commands'].extend([
	171	'depmod -a',
	172	'locale-gen en_US.UTF-8',
	173	'apt-get update',
819f0b86	174	'apt-get upgrade',
dc9700c9 FD	175	'apt-get install -y {}'.format(' '.join(packages))
dc9700c9 FD	176	])
b3d73c46 FD	177	return command
b3d73c46 FD	178
1ac7fa2c	179	def get_baremetal_benchmarks_cmd():
b3d73c46 FD	180	command = OrderedDict({
	181	'command': 'lava_test_shell',
	182	'parameters': {
	183	'testdef_repos': [
	184	{
	185	'git-repo': 'https://github.com/lttng/lttng-ci.git',
	186	'revision': 'master',
	187	'testdef': 'lava/baremetal-tests/failing-close.yml'
	188	},
	189	{
	190	'git-repo': 'https://github.com/lttng/lttng-ci.git',
	191	'revision': 'master',
	192	'testdef': 'lava/baremetal-tests/failing-open-efault.yml'
	193	},
	194	{
	195	'git-repo': 'https://github.com/lttng/lttng-ci.git',
	196	'revision': 'master',
	197	'testdef': 'lava/baremetal-tests/failing-open-enoent.yml'
1ac7fa2c FD	198	}
	199	],
	200	'timeout': 18000
	201	}
	202	})
	203	return command
	204
	205	def get_baremetal_tests_cmd():
	206	command = OrderedDict({
	207	'command': 'lava_test_shell',
	208	'parameters': {
	209	'testdef_repos': [
f3d4ee9f FD	210	{
	211	'git-repo': 'https://github.com/lttng/lttng-ci.git',
	212	'revision': 'master',
	213	'testdef': 'lava/baremetal-tests/perf-tests.yml'
b3d73c46 FD	214	}
	215	],
	216	'timeout': 18000
	217	}
	218	})
	219	return command
	220
1ac7fa2c	221	def get_kvm_tests_cmd():
b3d73c46 FD	222	command = OrderedDict({
	223	'command': 'lava_test_shell',
	224	'parameters': {
	225	'testdef_repos': [
	226	{
	227	'git-repo': 'https://github.com/lttng/lttng-ci.git',
	228	'revision': 'master',
	229	'testdef': 'lava/baremetal-tests/kernel-tests.yml'
ee02050f FD	230	},
	231	{
	232	'git-repo': 'https://github.com/lttng/lttng-ci.git',
	233	'revision': 'master',
	234	'testdef': 'lava/baremetal-tests/destructive-tests.yml'
b3d73c46 FD	235	}
	236	],
	237	'timeout': 18000
	238	}
	239	})
	240	return command
	241
	242	def get_results_cmd(stream_name):
	243	command = OrderedDict({
	244	'command': 'submit_results',
	245	'parameters': {
	246	'server': 'http://lava-master.internal.efficios.com/RPC2/'
	247	}
	248	})
	249	command['parameters']['stream']='/anonymous/'+stream_name+'/'
	250	return command
	251
dc9700c9 FD	252	def get_deploy_cmd_kvm(jenkins_job, kernel_path, linux_modules_path, lttng_modules_path):
	253	command = OrderedDict({
	254	'command': 'deploy_kernel',
	255	'metadata': {},
	256	'parameters': {
	257	'customize': {},
	258	'kernel': None,
819f0b86 FD	259	'target_type': 'ubuntu',
	260	'rootfs': 'file:///var/lib/lava-server/default/media/images/xenial.img.gz',
	261	'login_prompt': 'kvm02 login:',
	262	'username': 'root'
dc9700c9 FD	263	}
	264	})
	265
	266	command['parameters']['customize'][SCP_PATH+linux_modules_path]=['rootfs:/','archive']
	267	command['parameters']['customize'][SCP_PATH+lttng_modules_path]=['rootfs:/','archive']
	268	command['parameters']['kernel'] = str(SCP_PATH+kernel_path)
	269	command['metadata']['jenkins_jobname'] = jenkins_job
	270
	271	return command
	272
	273	def get_deploy_cmd_x86(jenkins_job, kernel_path, linux_modules_path, lttng_modules_path, nb_iter=None):
b3d73c46 FD	274	command = OrderedDict({
	275	'command': 'deploy_kernel',
	276	'metadata': {},
	277	'parameters': {
	278	'overlays': [],
	279	'kernel': None,
	280	'nfsrootfs': str(SCP_PATH+'/storage/jenkins-lava/rootfs/rootfs_amd64_trusty_2016-02-23-1134.tar.gz'),
	281	'target_type': 'ubuntu'
	282	}
	283	})
	284
	285	command['parameters']['overlays'].append( str(SCP_PATH+linux_modules_path))
	286	command['parameters']['overlays'].append( str(SCP_PATH+lttng_modules_path))
	287	command['parameters']['kernel'] = str(SCP_PATH+kernel_path)
dc9700c9	288	command['metadata']['jenkins_jobname'] = jenkins_job
b3d73c46 FD	289	if nb_iter is not None:
	290	command['metadata']['nb_iterations'] = nb_iter
	291
	292	return command
	293
	294
dc9700c9	295	def get_env_setup_cmd(build_device, lttng_tools_commit, lttng_ust_commit=None):
b3d73c46 FD	296	command = OrderedDict({
	297	'command': 'lava_command_run',
	298	'parameters': {
	299	'commands': [
819f0b86	300	'pip3 install --upgrade pip',
46fb8afa	301	'hash -r',
b3d73c46 FD	302	'git clone https://github.com/frdeso/syscall-bench-it.git bm',
	303	'pip3 install vlttng',
	304	],
	305	'timeout': 18000
	306	}
	307	})
	308
4418be37	309	vlttng_cmd = 'vlttng --jobs=$(nproc) --profile urcu-master' \
b3d73c46 FD	310	' --profile babeltrace-stable-1.4 ' \
	311	' --profile lttng-tools-master' \
	312	' --override projects.lttng-tools.checkout='+lttng_tools_commit + \
	313	' --profile lttng-tools-no-man-pages'
	314
	315	if lttng_ust_commit is not None:
	316	vlttng_cmd += ' --profile lttng-ust-master ' \
	317	' --override projects.lttng-ust.checkout='+lttng_ust_commit+ \
	318	' --profile lttng-ust-no-man-pages'
	319
dc9700c9 FD	320	virtenv_path = None
	321	if build_device in 'kvm':
	322	virtenv_path = '/root/virtenv'
	323	else:
	324	virtenv_path = '/tmp/virtenv'
	325
	326	vlttng_cmd += ' '+virtenv_path
b3d73c46 FD	327
b3d73c46 FD	328	command['parameters']['commands'].append(vlttng_cmd)
dc9700c9 FD	329	command['parameters']['commands'].append('ln -s '+virtenv_path+' /root/lttngvenv')
	330	command['parameters']['commands'].append('sync')
	331
b3d73c46 FD	332	return command
	333
	334	def main():
	335	test_type = None
	336	parser = argparse.ArgumentParser(description='Launch baremetal test using Lava')
	337	parser.add_argument('-t', '--type', required=True)
	338	parser.add_argument('-j', '--jobname', required=True)
	339	parser.add_argument('-k', '--kernel', required=True)
	340	parser.add_argument('-km', '--kmodule', required=True)
	341	parser.add_argument('-lm', '--lmodule', required=True)
b3d73c46 FD	342	parser.add_argument('-tc', '--tools-commit', required=True)
	343	parser.add_argument('-uc', '--ust-commit', required=False)
	344	args = parser.parse_args()
	345
1ac7fa2c FD	346	if args.type in 'baremetal-benchmarks':
	347	test_type = TestType.baremetal_benchmarks
	348	elif args.type in 'baremetal-tests':
	349	test_type = TestType.baremetal_tests
	350	elif args.type in 'kvm-tests':
	351	test_type = TestType.kvm_tests
b3d73c46 FD	352	else:
	353	print('argument -t/--type {} unrecognized. Exiting...'.format(args.type))
	354	return -1
	355
8cef2adf FD	356	lava_api_key = None
8cef2adf FD	357	try:
30003819	358	lava_api_key = os.environ['LAVA_JENKINS_TOKEN']
f42b2b7e	359	except Exception as e:
30003819	360	print('LAVA_JENKINS_TOKEN not found in the environment variable. Exiting...', e )
8cef2adf FD	361	return -1
8cef2adf FD	362
1ac7fa2c	363	if test_type is TestType.baremetal_benchmarks:
dc9700c9 FD	364	j = create_new_job(args.jobname, build_device='x86')
dc9700c9 FD	365	j['actions'].append(get_deploy_cmd_x86(args.jobname, args.kernel, args.kmodule, args.lmodule))
1ac7fa2c FD	366	elif test_type is TestType.baremetal_tests:
	367	j = create_new_job(args.jobname, build_device='x86')
	368	j['actions'].append(get_deploy_cmd_x86(args.jobname, args.kernel, args.kmodule, args.lmodule))
	369	elif test_type is TestType.kvm_tests:
dc9700c9 FD	370	j = create_new_job(args.jobname, build_device='kvm')
	371	j['actions'].append(get_deploy_cmd_kvm(args.jobname, args.kernel, args.kmodule, args.lmodule))
	372
	373	j['actions'].append(get_boot_cmd())
	374
1ac7fa2c	375	if test_type is TestType.baremetal_benchmarks:
dc9700c9 FD	376	j['actions'].append(get_config_cmd('x86'))
dc9700c9 FD	377	j['actions'].append(get_env_setup_cmd('x86', args.tools_commit))
1ac7fa2c	378	j['actions'].append(get_baremetal_benchmarks_cmd())
b3d73c46	379	j['actions'].append(get_results_cmd(stream_name='benchmark-kernel'))
1ac7fa2c FD	380	elif test_type is TestType.baremetal_tests:
	381	if args.ust_commit is None:
	382	print('Tests runs need -uc/--ust-commit options. Exiting...')
	383	return -1
	384	j['actions'].append(get_config_cmd('x86'))
	385	j['actions'].append(get_env_setup_cmd('x86', args.tools_commit, args.ust_commit))
	386	j['actions'].append(get_baremetal_tests_cmd())
	387	j['actions'].append(get_results_cmd(stream_name='tests-kernel'))
	388	elif test_type is TestType.kvm_tests:
b3d73c46 FD	389	if args.ust_commit is None:
	390	print('Tests runs need -uc/--ust-commit options. Exiting...')
	391	return -1
dc9700c9 FD	392	j['actions'].append(get_config_cmd('kvm'))
dc9700c9 FD	393	j['actions'].append(get_env_setup_cmd('kvm', args.tools_commit, args.ust_commit))
1ac7fa2c	394	j['actions'].append(get_kvm_tests_cmd())
b3d73c46 FD	395	j['actions'].append(get_results_cmd(stream_name='tests-kernel'))
	396	else:
	397	assert False, 'Unknown test type'
	398
f42b2b7e	399	server = xmlrpc.client.ServerProxy('http://%s:%s@%s/RPC2' % (USERNAME, lava_api_key, HOSTNAME))
b3d73c46 FD	400
	401	jobid = server.scheduler.submit_job(json.dumps(j))
	402
21e89f7e FD	403	print('Lava jobid:{}'.format(jobid))
21e89f7e FD	404
b3d73c46 FD	405	#Check the status of the job every 30 seconds
b3d73c46 FD	406	jobstatus = server.scheduler.job_status(jobid)['job_status']
d9997fe4	407	not_running = False
b3d73c46	408	while jobstatus in 'Submitted' or jobstatus in 'Running':
d9997fe4 FD	409	if not_running is False and jobstatus in 'Running':
	410	print('Job started running')
	411	not_running = True
b3d73c46 FD	412	time.sleep(30)
	413	jobstatus = server.scheduler.job_status(jobid)['job_status']
	414
534a243d	415	if test_type is TestType.kvm_tests or test_type is TestType.baremetal_tests:
b3d73c46	416	print_test_output(server, jobid)
104ed94b FD	417	elif test_type is TestType.baremetal_benchmarks:
104ed94b FD	418	fetch_benchmark_results(server, jobid)
b3d73c46	419
d1b69f4d FD	420	print('Job ended with {} status.'.format(jobstatus))
	421	if jobstatus not in 'Complete':
	422	return -1
	423	else:
73c1d4bc	424	passed, failed=check_job_all_test_cases_state_count(server, jobid)
d1b69f4d FD	425	print('With {} passed and {} failed Lava test cases.'.format(passed, failed))
d1b69f4d FD	426
73c1d4bc FD	427	if failed == 0:
	428	return 0
	429	else:
	430	return -1
b3d73c46 FD	431
	432	if __name__ == "__main__":
	433	sys.exit(main())