runner

#!/usr/bin/env python

import os, sys
import json
from datetime import datetime
from optparse import OptionParser

import gobject

parser = OptionParser()
parser.add_option("-t", "--test")
parser.add_option("-f", "--file")
parser.add_option("-r", "--results", default="/tmp/results.json")
parser.add_option("-u", "--user", default="")
parser.add_option("-w", "--hardware", default="")
parser.add_option("-o", "--output")

(options, args) = parser.parse_args()

user = options.user
hardware = options.hardware
tests_file = options.file
test_results = options.results
test_name = options.test

if options.output:
    output = open(options.output, "a")
else:
    output = sys.stdout

class Pipe(object):
	def __init__(self):
		r, w = os.pipe()
		r, w = os.fdopen(r, 'r', 0), os.fdopen(w, 'w', 0)
		self.r, self.w = r, w

	def close_in(self):
		self.r.close()

	def close_out(self):
		self.w.close()

	def dump(self, obj):
		json.dump(obj, self.w)
		print >> self.w

	def load(self):
		s = self.r.readline()
		if not s: return None
		try:
			return json.loads(s)
		except ValueError:
			print "bad data"
			return None

def run_child():
	gobject.threads_init()

	while True:
		data = p2.load()
		if not data: break

		base = data['base']
		env = data['env']
		if env:
			var, val = env.rsplit('=')
			os.putenv(var, val)

		try:
			mname = "tests." + base
			__import__(mname)
			module = sys.modules[mname]
			t = module.test_class()
			for kv in data['in'].iteritems():
				setattr(t, *kv)
			t.start()
			if t.error:
				data['error'] = t.error
			if hasattr(t, 'out') and t.out:
				data['out'] = t.out
			if hasattr(t, 'checks') and t.checks:
				data['checks'] = t.checks
				total = len(t.checks)
				result = 0.0
				for x in t.checks.values():
					result += 100 * float(x) / total
				data['result'] = result

		except ImportError, e:
			data['error'] = "bad test '%s': %s" % (base, e)

		p1.dump(data)

		if env:
			os.unsetenv(var)

	sys.exit(0)

def respawn():
	global p1, p2

	p1 = Pipe()
	p2 = Pipe()

	pid = os.fork()
	if pid:
		# Parent
		p1.close_out()
		p2.close_in()

		return pid

	else:
		# Child
		p1.close_in()
		p2.close_out()

		run_child()

def get_date():
	return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

def get_time(pid):
	cpu_values = file("/proc/stat", "r").readline().split()[1:]
	total_time = sum(map(int, cpu_values))

	pid_values = file("/proc/%s/stat" % (pid), "r").readline().split()
	utime, stime = map(int, pid_values[13:15])
	process_time = utime + stime

	return total_time, process_time

def run_test(t):
	global pid

	n = {}
	n['name'] = t.pop('name')
	n['base'] = t.pop('base')
	n['in'] = t
	n['env'] = t.pop('env', None)

	time_before = get_time(pid)

	p2.dump(n)
	data = p1.load()
	if not data:
		p, s = os.waitpid(pid, os.P_NOWAIT)
		pid = respawn()
		data = n
		data['error'] = "process died: signal %i" % s
	elif data['in'].get('respawn', False):
		pid = respawn()

	if 'error' in data:
		r = 0.0
	elif 'result' in data:
		r = data['result']
	else:
		r = 100.0

	if data['in'].get('expected_failure', False):
		r = 100.0 - r

	time_after = get_time(pid)

	total_time, process_time = [b - a for a, b in zip(time_before, time_after)]

	data['cpu_usage'] = 100 * (float(process_time) / float(total_time))

	data['result'] = r
	data['date'] = get_date()
	return data

if not tests_file:
	tests_file = os.environ.get('MILAATU_TESTS_FILE')
if not tests_file:
	tests_file = "tests.json"

run = {}
run['hw'] = hardware
run['user'] = user
run['date'] = get_date()

f = open(tests_file, "r")
tests = json.load(f)
results = []

pid = respawn()
to_run = None

for t in tests:
	if test_name:
		if t['name'] != test_name:
			continue
		to_run = t
		break
	else:
		print >> output, "== %s ==" % t['name']
		data = run_test(t)
		results.append(data)

if test_name:
	if not to_run:
		print >> sys.stderr, "test not found"
		sys.exit(-1)
	else:
		print >> output, "== %s ==" % t['name']
		data = run_test(t)
		if 'error' in data:
			print >> sys.stderr, "error: %s" % data['error']
		r = data['result']
		if (r == 100.0):
			e = 0
		else:
			print >> sys.stderr, "result: %d" % (r)
			e = -1
		print >> output, json.dumps(data, indent = 4, sort_keys = True)
		sys.exit(e)

run['results'] = results

o = open(test_results, "w")
print >> o, json.dumps(run, indent = 4, sort_keys = True)