`calls doebuild' type

usetest-kai.py (text/plain), 7.73 KB, created by Atzm Watanabe on 2004-10-12 03:39:44 UTC

#!/usr/bin/env python2
# Copyright 1999-2004 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: $

import sys, os
command = os.path.basename(sys.argv[0])
os.environ["PORTAGE_CALLER"] = command

import string, getopt
sys.path.insert(0, "/usr/lib/portage/pym")

import portage
from output import *

class ebuildinfo:
	def __init__(self, fullpackage):
		self.fullpackage = fullpackage
		self.category, self.pkgname, self.version, self.revision = portage.catpkgsplit(fullpackage)
		self.ebuild = self.find_ebuild()
		self.pkg_dir = os.path.dirname(self.ebuild)

	def find_ebuild(self, package=None):
		if package is not None:
			category, pkgname, version, revision = portage.catpkgsplit(package)
		else:
			category, pkgname, version, revision = self.category, self.pkgname, self.version, self.revision
			package = self.fullpackage

		portdir = string.split(portage.settings["PORTDIR"])
		overlay = string.split(portage.settings["PORTDIR_OVERLAY"])
		for d in portdir + overlay:
			if revision == "r0":
				cand = os.path.join(d, category, pkgname, (pkgname + "-" + version)) + ".ebuild"
			else:
				cand = os.path.join(d, category, pkgname, (pkgname + "-" + version + "-" + revision)) + ".ebuild"

			if os.path.exists(cand):
				return cand
		raise TypeError("ebuild not found: %s\n" % package)

	
class testpatterns:
	def __init__(self, package, ignore=[]):
		package = self.gen_package(package)
		self.fullpackage = portage.portdb.xmatch("bestmatch-visible", package)
		if not self.fullpackage:
			raise TypeError("Invalid package: %s\n" % package)

		self.patterns = self.usetest_patterns(ignore=ignore)

	def make_testpatterns(self, flaglist):
		tplist = []
		for n in range(2 ** len(flaglist)):
			testpattern = []
			for count in range(len(flaglist)):
				if (n >> count) & 1 == 1:
					testpattern.append("-" + flaglist[count])
				else:
					testpattern.append(" " + flaglist[count])
			tplist.append(testpattern)
		return tplist

	def usetest_patterns(self, package=None, ignore=[]):
		if package is None:
			package = self.fullpackage

		mykey = portage.dep_expand(package, portage.portdb)
		flaglist = string.split(portage.portdb.aux_get(mykey, ["IUSE"])[0])

		for i in ignore:
			while flaglist.count(i):
				flaglist.remove(i)

		tplist = self.make_testpatterns(flaglist)
		return tplist

	def gen_package(self, package=None):
		if package is None:
			package = self.fullpackage
		result = package

		if package[-7:] == ".ebuild":
			if not os.path.exists(package):
				result = None
			else:
				ebuild_path = os.path.abspath(package)
				pkg_dir     = os.path.dirname(ebuild_path)
				cat         = os.path.basename(os.path.normpath(pkg_dir + "/.."))
				mypv        = os.path.basename(ebuild_path)[:-7]
				result      = "=" + cat + "/" + mypv

		if result is None:
			raise TypeError("Invalid package: %s\n" % result)
		return result


def usage(status=1):
	sys.stderr.write(
		"%s:\n"
		"      %s [ %s ] ebuilds or atoms...\n\n"
		"%s:\n"
		"      %s is a tester for ebuild in all USE flag patterns.\n"
		"      It generates all patterns of USE flags from IUSE variables,\n"
		"      and tests ebuild on each USE flags.\n\n"
		"%s:\n"
		"      %s    (%s):      Don't use colors\n"
		"      %s    (%s):        Don't stop even if errors have occured\n"
		"      %s    (%s):        Enable debug\n"
		"      %s    (%s):      Prints test patterns\n"
		"      %sIGN (%s=IGN):   Ignore a flag specified by IGN (this option can set multiple)\n"
		"      %s    (%s):        Cleans WORKDIR even if errors have occured\n"
		"      %s    (%s):      Prints verbose message\n"
		"      %s    (%s):         Show help message\n"
		% (white("Usage"),
		   turquoise(command), green("options"),
		   white("Description"),
		   command,
		   white("Options"),
		   green("-n"), green("--nocolor"),
		   green("-f"), green("--force"),
		   green("-d"), green("--debug"),
		   green("-p"), green("--pretend"),
		   green("-i"), green("--ignore"),
		   green("-c"), green("--clean"),
		   green("-v"), green("--verbose"),
		   green("-h"), green("--help"))
	)
	sys.exit(status)

def get_patterns(package, ignore=[]):
	try:
		return testpatterns(package, ignore)
	except TypeError, e:
		sys.stderr.write(str(e))
		usage()
	except ValueError, errpkgs:
		sys.stderr.write('!!! The short ebuild name "' + package + '" is ambiguous. Please specify\n')
		sys.stderr.write("!!! one of the following fully-qualified ebuild names instead:\n\n")
		for i in errpkgs[0]:
			sys.stderr.write("   " + green(i) + "\n")
		sys.stderr.write("\n")
		sys.exit(1)

def do_pretend(packages, ignore=[]):
	print green(" * ") + "Test patterns are:"
	for package in packages:
		tests = get_patterns(package, ignore)
		print "     %s %s:" % (green("*"), turquoise(tests.fullpackage))
		for each in tests.patterns:
			print '         %s "%s"' % (green("*"), string.join(each, " "))
		print
	sys.exit(0)

def getroot():
	try:
		root = os.environ["ROOT"]
		if root == '/':
			return '/'
	except:
		return '/'
	return os.path.normpath(root + '/')

if __name__ == "__main__":
	if (not sys.stdout.isatty()) or (portage.settings["NOCOLOR"] in ["yes", "true"]):
		nocolor()

	args = sys.argv[1:]
	args.sort()
	try:
		options, packages = getopt.getopt(args, "dnfpi:cvh",
										  ["debug", "nocolor", "force", "pretend",
										   "ignore=", "clean", "verbose", "help"])
	except getopt.error, e:
		usage()
	if not packages:
		usage(0)

	force  = clean = pretend = debug = verbose = 0
	ignore = []
	for opt, val in options:
		if opt in ["-d", "--debug"]:
			debug = 1
		elif opt in ["-n", "--nocolor"]:
			nocolor()
		elif opt in ["-f", "--force"]:
			force = 1
		elif opt in ["-p", "--pretend"]:
			pretend = 1
		elif opt in ["-c", "--clean"]:
			clean = 1
		elif opt in ["-v", "--verbose"]:
			verbose = 1
		elif opt in ["-i", "--ignore"]:
			ignore.append(val)
		elif opt in ["-h", "--help"]:
			usage(0)

	if pretend:
		do_pretend(packages, ignore)

	settings   = portage.config(clone=portage.settings)
	root       = getroot()
	actions    = ["clean", "setup", "unpack", "compile", "install"]
	for package in packages:
		tests = get_patterns(package, ignore)
		pref  = ebuildinfo(tests.fullpackage)

		errlist = {}
		for each in tests.patterns:
 			use                       = string.join(each, " ")
			settings["USE"]           = use[:]
			settings.backupenv["USE"] = use[:]
			settings.regenerate()

			print green(" * ") + "Now testing %s using '%s'..." % (turquoise(tests.fullpackage),
																   green(use))
			for act in actions:
				if verbose:
					print "   %s %s" % (green("*"), act)
				res = portage.doebuild(pref.ebuild, act, root, settings, debug=debug)

				if res == 0:
					if verbose:
						print "     %s %s ('%s'): %s\n" % (green("*"), act, green(use), white("Success!"))
				else:
					print "     %s Failed to build %s in %s using %s" % (red("!!!"),
																		 turquoise(tests.fullpackage),
																		 white(act),
																		 green(use))

					if clean:
						if verbose:
							print "     %s Cleaning WORKDIR..." % red("!!!")
						portage.doebuild(pref.ebuild, "clean", root, settings, debug=debug)

					if not force:
						print
						sys.exit(1)
					else:
						if errlist.has_key(tests.fullpackage):
							if use not in errlist[tests.fullpackage]:
								errlist[tests.fullpackage].append(use)
						else:
							errlist[tests.fullpackage] = [use]

						if each is not tests.patterns[-1]:
							if verbose:
								print "     %s Continuing force. Go to next package..." % red("!!!")
						print
						break

			portage.doebuild(pref.ebuild, "clean", root, settings, debug=debug)

		print
		if force and errlist:
			print red(" * ") + "Failed patterns are:"
			for pkg in errlist.keys():
				print "     %s %s:" % (red("*"), turquoise(pkg))
				for use in errlist[pkg]:
					print "        %s USE='%s'" % (red("*"), green(use))
				print