tko/parse.py

#!/usr/bin/python -u

import os, sys, optparse, fcntl, errno, traceback

import common
from autotest_lib.client.common_lib import mail as common_mail
from autotest_lib.tko import db as tko_db, utils, status_lib


def parse_args():
	# build up our options parser and parse sys.argv
	parser = optparse.OptionParser()
	parser.add_option("-m", help="Send mail for FAILED tests",
			  dest="mailit", action="store_true")
	parser.add_option("-r", help="Reparse the results of a job",
			  dest="reparse", action="store_true")
	parser.add_option("-o", help="Parse a single results directory",
			  dest="singledir", action="store_true")
	parser.add_option("-l", help=("Levels of subdirectories to include "
				      "in the job name"),
			  type="int", dest="level", default=1)
	parser.add_option("-n", help="No blocking on an existing parse",
			  dest="noblock", action="store_true")
	parser.add_option("-s", help="Database server hostname",
			  dest="db_host", action="store")
	parser.add_option("-u", help="Database username", dest="db_user",
			  action="store")
	parser.add_option("-p", help="Database password", dest="db_pass",
			  action="store")
	parser.add_option("-d", help="Database name", dest="db_name",
			  action="store")
	options, args = parser.parse_args()

	# we need a results directory
	if len(args) == 0:
		utils.dprint("ERROR: at least one results directory must "
			     "be provided")
		parser.print_help()
		sys.exit(1)

	# pass the options back
	return options, args


def format_failure_message(jobname, kernel, testname, status, reason):
	format_string = "%-12s %-20s %-12s %-10s %s"
	return format_string % (jobname, kernel, testname, status, reason)


def mailfailure(jobname, job, message):
	message_lines = [""]
	message_lines.append("The following tests FAILED for this job")
	message_lines.append("http://%s/results/%s" %
			     (socket.gethostname(), jobname))
	message_lines.append("")
	message_lines.append(format_failure_message("Job name", "Kernel",
						    "Test name", "FAIL/WARN",
						    "Failure reason"))
	message_lines.append(format_failure_message("=" * 8, "=" * 6, "=" * 8,
						    "=" * 8, "=" * 14))
	message_header = "\n".join(message_lines)

	subject = "AUTOTEST: FAILED tests from job %s" % jobname
	common_mail.send("", job.user, "", subject, message_header + message)


def parse_one(db, jobname, path, reparse, mail_on_failure):
	"""
	Parse a single job. Optionally send email on failure.
	"""
	utils.dprint("\nScanning %s (%s)" % (jobname, path))
	if reparse and db.find_job(jobname):
		utils.dprint("! Deleting old copy of job results to "
				 "reparse it")
		db.delete_job(jobname)
	if db.find_job(jobname):
		utils.dprint("! Job is already parsed, done")
		return

	# parse out the job
	parser = status_lib.parser(0)
	job = parser.make_job(path)
	status_log = os.path.join(path, "status.log")
	if not os.path.exists(status_log):
		status_log = os.path.join(path, "status")
	if not os.path.exists(status_log):
		utils.dprint("! Unable to parse job, no status file")
		return

	# parse the status logs
	utils.dprint("+ Parsing dir=%s, jobname=%s" % (path, jobname))
	status_lines = open(status_log).readlines()
	parser.start(job)
	tests = parser.end(status_lines)
	job.tests = tests

	# check for failures
	message_lines = [""]
	for test in job.tests:
		if not test.subdir:
			continue
		utils.dprint("* testname, status, reason: %s %s %s"
			     % (test.subdir, test.status, test.reason))
		if test.status in ("FAIL", "WARN"):
			message_lines.append(format_failure_message(
			    jobname, test.kernel.base, test.subdir,
			    test.status, test.reason))
	message = "\n".join(message_lines)

	# send out a email report of failure
	if len(message) > 2 and mail_on_failure:
		utils.dprint("Sending email report of failure on %s to %s"
			     % (jobname, job.user))
		mailfailure(jobname, job, message)

	# write the job into the database
	db.insert_job(jobname, job)
	db.commit()


def parse_path(db, path, level, reparse, mail_on_failure):
	machine_list = os.path.join(path, ".machines")
	if os.path.exists(machine_list):
		# multi-machine job
		for m in file(machine_list):
			machine = m.rstrip()
			if not machine:
				continue
			jobpath = os.path.join(path, machine)
			jobname = "%s/%s" % (os.path.basename(path), machine)
			try:
				parse_one(db, jobname, jobpath, reparse,
					  mail_on_failure)
			except Exception:
				traceback.print_exc()
				continue
	else:
		# single machine job
		job_elements = path.split("/")[-level:]
		jobname = "/".join(job_elements)
		try:
			parse_one(db, jobname, path, reparse, mail_on_failure)
		except Exception:
			traceback.print_exc()


def main():
	options, args = parse_args()
	results_dir = os.path.abspath(args[0])
	assert os.path.exists(results_dir)

	# build up the list of job dirs to parse
	if options.singledir:
		jobs_list = [results_dir]
	else:
		jobs_list = [os.path.join(results_dir, subdir)
			     for subdir in os.listdir(results_dir)]

	# build up the database
	db = tko_db.db(autocommit=False, host=options.db_host,
		       user=options.db_user, password=options.db_pass,
		       database=options.db_name)

	# parse all the jobs
	for path in jobs_list:
		lockfile = open(os.path.join(path, ".parse.lock"), "w")
		flags = fcntl.LOCK_EX
		if options.noblock:
			flags != fcntl.LOCK_NB
		try:
			fcntl.flock(lockfile, flags)
		except IOError, e:
			# was this because the lock is unavailable?
			if e.errno == errno.EWOULDBLOCK:
				lockfile.close()
				continue
			else:
				raise # something unexpected happened
		try:
			parse_path(db, path, options.level, options.reparse,
				   options.mailit)
		finally:
			fcntl.flock(lockfile, fcntl.LOCK_UN)
			lockfile.close()


if __name__ == "__main__":
	main()