Add the check_archlinux.py repo checker

This is to be used for integrity checked, generated
perhaps once a day

Signed-off-by: Aaron Griffin <aaronmgriffin@gmail.com>

1 files changed, 724 insertions, 0 deletions

diff --git a/cron-jobs/check_archlinux.py b/cron-jobs/check_archlinux.py
new file mode 100755
index 0000000..8e39c81
--- /dev/null
+++ b/cron-jobs/check_archlinux.py
@@ -0,0 +1,724 @@
+#!/usr/bin/env python
+#
+# check_archlinux.py
+#
+# Written by Scott Horowitz <stonecrest@gmail.com>
+# Graphical dependency tree by Cesar G. Miguel <cesargm@ime.usp.br>
+#
+# This script currently checks for a number of issues in your ABS tree:
+#   1. Directories with missing PKGBUILDS
+#   2. Duplicate PKGBUILDs
+#   3. Missing (make-)dependencies, taking into account 'provides'
+#   4. Provisioned dependencies
+#   5. Circular dependencies
+#   6. Valid arch's in PKGBUILDS
+#   7. Missing packages in Arch repos
+#   8. PKGBUILD names that don't match their directory
+#   9. Hierarchy of repos (e.g., that a core package doesn't depend on
+#      a non-core package)
+# It can also, optionally, generate a graphical representation of the
+# dependency tree.
+#
+# Todo:
+#   1. Accommodate testing repo?
+
+abs_conf_dir = "/etc/abs"
+valid_archs = ['i686', 'x86_64']
+cvs_tags = {'i686': 'CURRENT', 'x86_64': 'CURRENT-64'}
+include_paths = ['core', 'extra', 'community', 'unstable']
+
+base_server = "ftp.archlinux.org" # Must be ftp site
+# Ensure that core repo only depends on core, and the extra repo only
+# depends on core and extra, etc.
+repo_hierarchy = {'core': ('core'), \
+'extra': ('core', 'extra'), \
+'unstable': ('core', 'extra', 'unstable'), \
+'community': ('core', 'extra', 'unstable', 'community')} 
+
+pkgname_str = "pkgname="
+dep_str = "depends=("
+makedep_str = "makedepends=("
+provides_str = "provides=("
+arch_str = "arch=("
+pkgver_str = "pkgver="
+pkgrel_str = "pkgrel="
+build_str = "build()"
+source_str = "source="
+url_str = "url="
+mathlist = (">=", "<=", "=", ">", "<")
+sup_tag_str = "*default tag="
+
+import os, sys, getopt, tempfile
+from ftplib import FTP
+try:
+	import pydot
+	HAS_PYDOT = True
+except:
+	HAS_PYDOT = False
+
+def print_heading(heading):
+	print ""
+	print "=" * (len(heading) + 4)
+	print "= " + heading + " ="
+	print "=" * (len(heading) + 4)
+
+def print_subheading(subheading):
+	print ""
+	print subheading
+	print "-" * (len(subheading) + 2)
+
+def rmgeneric(path, __func__):
+	try:
+		__func__(path)
+	except OSError, (errno, strerror):
+		pass
+
+def removeall(path):
+	if not os.path.isdir(path):
+		return
+
+	files=os.listdir(path)
+
+	for x in files:
+		fullpath=os.path.join(path, x)
+		if os.path.isfile(fullpath):
+			f=os.remove
+			rmgeneric(fullpath, f)
+		elif os.path.isdir(fullpath):
+			removeall(fullpath)
+			f=os.rmdir
+			rmgeneric(fullpath, f)
+
+def update_var(line, user_vars, pkgpath):
+	if line.count("$") > 0:
+		export_line = ""
+		for var in user_vars:
+			if line.count(var[0]) > 0:
+				export_line = export_line + var[0] + "=" + var[1] + " && "
+		if line.startswith("(") and line.endswith(")"):
+			line = line[1:-1]
+		export_line = export_line + "echo \"" + line + "\""
+		line = os.popen(export_line).read().replace("\n", "")
+	return line
+
+def split_dep_prov_symbol(dep):
+	# Splits 'foo>=1.2.3' into ('foo', '1.2.3', '>=')
+	prov = ""
+	symbol = ""
+	for char in mathlist:
+		pos = dep.find(char)
+		if pos > -1:
+			prov = dep[pos:].replace(char, "")
+			dep = dep[:pos]
+			symbol = char
+			break
+	return (dep, prov, symbol)
+
+def repo_from_path(path):
+	return path.split("/")[-4]
+
+def create_supfile(sourcefile, destfile, newtag):
+	o = open(sourcefile, 'r')
+	info = o.read()
+	o.close()
+	lines = info.split("\n")
+	
+	o = open(destfile, 'w')
+	for line in lines:
+		line = line.strip()
+		if line[:len(sup_tag_str)] == sup_tag_str:
+			line = sup_tag_str + newtag
+		o.write(line + "\n")
+	o.close()
+
+def get_deps_provides_etc(pkgpath):
+	# Parse PKGBUILD for name, depends, makedepends, provides, arch's, and version
+	o = open(pkgpath, 'r')
+	info = o.read()
+	o.close()
+	lines = info.split("\n")
+
+	deps = []
+	provides = []
+	archs = []
+	makedeps = []
+	array = []
+	user_vars = []
+	continue_line = False
+	for line in lines:
+		line = line.strip()
+		if line.find("#") > -1:
+			line = line[:line.find("#")].strip()
+		if not continue_line:
+			deps_line = False
+			provides_line = False
+			arch_line = False
+			makedeps_line = False
+		if line[:len(dep_str)] == dep_str:
+			line = line.replace(dep_str,"")
+			deps_line = True
+		elif line[:len(makedep_str)] == makedep_str:
+			line = line.replace(makedep_str,"")
+			makedeps_line = True
+		elif line[:len(provides_str)] == provides_str:
+			line = line.replace(provides_str,"")
+			provides_line = True
+		elif line[:len(arch_str)] == arch_str:
+			line = line.replace(arch_str, "")
+			arch_line = True
+		elif line[:len(pkgname_str)] == pkgname_str:
+			pkgname = line.replace(pkgname_str, "")
+			if pkgname.startswith("\"") and pkgname.endswith("\""):
+				pkgname = pkgname[1:-1]
+			pkgname = update_var(pkgname, user_vars, pkgpath)
+			user_vars.append([pkgname_str, pkgname])
+			line = ""
+		elif line[:len(pkgver_str)] == pkgver_str:
+			pkgver = line.replace(pkgver_str, "")
+			if pkgver.startswith("\"") and pkgver.endswith("\""):
+				pkgver = pkgver[1:-1]
+			pkgver = update_var(pkgver, user_vars, pkgpath)
+			user_vars.append([pkgver_str[:-1], pkgver])
+			line = ""
+		elif line[:len(pkgrel_str)] == pkgrel_str:
+			pkgrel = line.replace(pkgrel_str, "")
+			if pkgrel.startswith("\"") and pkgrel.endswith("\""):
+				pkgrel = pkgrel[1:-1]
+			pkgrel = update_var(pkgrel, user_vars, pkgpath)
+			user_vars.append([pkgrel_str[:-1], pkgrel])
+			line = ""
+		elif line[:len(build_str)] == build_str:
+			break
+		elif not continue_line:
+			if line.count("=") == 1 and line.count(" ") == 0 and line[:1] != "#" and \
+			line[:len(source_str)] != source_str and line[:len(url_str)] != url_str:
+				split = line.split("=")
+				for item in range(len(split)):
+					split[item] = update_var(split[item], user_vars, pkgpath)
+				user_vars.append(split)
+			line = ""
+		if len(line) > 0:
+			pos = line.find(")")
+			if pos > -1:
+				# strip everything from closing paranthesis on
+				# since some PKGBUILDS have comments after the
+				# depends array
+				line = line[:pos]
+			line = line.split(' ')
+			for i in range(len(line)):
+				line[i] = line[i].replace("'","").replace('"','')
+				line[i] = update_var(line[i], user_vars, pkgpath)
+				if len(line[i]) > 0:
+					if deps_line:
+						deps.append(line[i])
+						array=deps
+					elif provides_line:
+						provides.append(line[i])
+						array=provides
+					elif arch_line:
+						archs.append(line[i])
+						array=archs
+					elif makedeps_line:
+						makedeps.append(line[i])
+						array=makedeps
+			if array and (array[-1] == "\\" or array[-1][-1] == "\\"):
+				# continue reading deps/provides on next line
+				if array[-1] == "\\":
+					array.pop(-1)
+				else:
+					array[-1] = array[-1].replace("\\", "")
+				continue_line = True
+			else:
+				continue_line = False
+	version = pkgver + "-" + pkgrel
+	return (pkgname, deps, makedeps, provides, archs, version)
+
+def get_pkgbuilds_in_dir(rootdir):
+	# Recursively populates pkgbuild_deps, pkgbuild_paths, etc.
+	# dicts with info from each PKGBUILD found in rootdir:
+	if rootdir != absroot:
+		if rootdir.count("/") == (absroot.count("/")+1) and rootdir not in curr_include_paths:
+			return
+	pkgfound = False
+	for f in os.listdir(rootdir):
+		fpath = rootdir + "/" + f
+		if os.path.isdir(fpath):
+			get_pkgbuilds_in_dir(fpath)
+		elif f == 'PKGBUILD':
+			pkgfound = True
+			name = rootdir.split("/")[-1]
+			if name in pkgbuild_deps:
+				dups.append(fpath.replace(absroot, "") + " vs. " + pkgbuild_paths[name].replace(absroot, ""))
+			else:
+				(pkgname, deps, makedeps, provides, archs, version) = get_deps_provides_etc(fpath)
+				pkgbuild_deps[pkgname] = deps
+				pkgbuild_makedeps[pkgname] = makedeps
+				pkgbuild_paths[pkgname] = fpath
+				pkgbuild_archs[pkgname] = archs
+				pkgbuild_versions[pkgname] = version
+				# We'll store the provides "backwards" compared to
+				# the other dicts. This will make searching for
+				# provides easier by being able to look up the
+				# provide name itself and find what provides it
+				for provide in provides:
+					pkgbuild_provides[provide] = pkgname
+				if pkgname != name:
+					mismatches.append(pkgname + " vs. " + fpath.replace(absroot, ""))
+	if not pkgfound and rootdir.replace(absroot, "").count("/") == 3:
+		misses.append(rootdir.replace(absroot, "") + "/PKGBUILD")
+	
+def verify_depends_makedepends(verify_makedeps=False):
+	# Make sure all the deps we parsed are actually packages; also
+	# ensure we meet dep provisions.
+	if verify_makedeps:
+		array = pkgbuild_makedeps
+	else:
+		array = pkgbuild_deps
+	for pkgname in array:
+		deps = array[pkgname]
+		pkg_repo = repo_from_path(pkgbuild_paths[pkgname])
+		deps_to_pop = []
+		for i in range(len(deps)):
+			dep = deps[i]
+			(dep, prov, char) = split_dep_prov_symbol(dep)
+			try:
+				x = pkgbuild_deps[dep]
+				# Check that prov is met too:
+				if len(prov) > 0:
+					compare_str = "vercmp " + pkgbuild_versions[dep] + " " + prov
+					error = False
+					if char == "<=":
+						if int(os.popen(compare_str).read().replace("\n", "")) > 0:
+							error = True
+					elif char == ">=":
+						if int(os.popen(compare_str).read().replace("\n", "")) < 0:
+							error = True
+					elif char == "=":
+						if int(os.popen(compare_str).read().replace("\n", "")) != 0:
+							error = True
+					elif char == ">":
+						if int(os.popen(compare_str).read().replace("\n", "")) <= 0:
+							error = True
+					elif char == "<":
+						if int(os.popen(compare_str).read().replace("\n", "")) >= 0:
+							error = True						
+					if error:
+						if verify_makedeps:
+							unmet_makedep_provs.append(pkgname + " --> '" + dep + char + prov + "'")
+						else:
+							unmet_dep_provs.append(pkgname + " --> '" + dep + char + prov + "'")
+				# Check repos fit hierarchy scheme:
+				dep_repo = repo_from_path(pkgbuild_paths[dep])
+				try:
+					valid_repos = repo_hierarchy[pkg_repo]
+					# Make sure dep repo is one of the valid repos:
+					if dep_repo not in valid_repos:
+						if verify_makedeps:
+							makedep_hierarchy.append(pkg_repo + "/" + pkgname + " depends on " + dep_repo + "/" + dep)
+						else:
+							dep_hierarchy.append(pkg_repo + "/" + pkgname + " depends on " + dep_repo + "/" + dep)
+				except:
+					pass
+			except:
+				# Check if a package provides this dep:
+				try:
+					x = pkgbuild_provides[dep]
+				except:
+					if verify_makedeps:
+						missing_makedeps.append(pkgname + " --> '" + dep + "'")
+					else:
+						missing_deps.append(pkgname + " --> '" + dep + "'")
+				deps_to_pop.append(i)
+		# Pop deps not found from end to beginning:
+		while len(deps_to_pop) > 0:
+			deps.pop(deps_to_pop[-1])
+			deps_to_pop.pop(-1)
+
+def verify_archs():
+	for pkgname in pkgbuild_archs:
+		newarch = []
+		archs = pkgbuild_archs[pkgname]
+		for arch in archs:
+			if arch not in valid_archs:
+				invalid_archs.append(pkgname + " --> " + arch)
+			else:
+				newarch.append(arch)
+		if len(newarch) > 0:
+			pkgbuild_archs[pkgname] = newarch
+	
+def verify_packages(tree_arch):
+	# Make sure packages exist in Arch repo(s):
+	ftp = FTP(base_server)
+	ftp.login()
+	prev_wd = ""
+	# Find all repos/archs; marching through them in order will greatly speed
+	# up searching for ftp files by minimizing the number of .nlst's that we
+	# have to do.
+	repos = []
+	for pkgname in pkgbuild_paths:
+		pkgrepo = repo_from_path(pkgbuild_paths[pkgname])
+		if not pkgrepo in repos:
+			repos.append(pkgrepo)
+	archs = []
+	for pkgname in pkgbuild_archs:
+		pkgarchs = pkgbuild_archs[pkgname]
+		for arch in pkgarchs:
+			if not arch in archs:
+				archs.append(arch)
+	for r in repos:
+		for pkgname in pkgbuild_archs:
+			repo = repo_from_path(pkgbuild_paths[pkgname])
+			if repo == r:
+				archs = pkgbuild_archs[pkgname]
+				pkgver_rel = pkgbuild_versions[pkgname]
+				for arch in archs:
+					if arch == tree_arch:
+						# Check for file:
+						wd = repo + "/os/" + arch
+						if wd != prev_wd:
+							ftpfiles = ftp.nlst(wd)
+							prev_wd = wd
+						fname_new = wd + "/" + pkgname + "-" + pkgver_rel + "-" + arch + ".pkg.tar.gz"
+						fname_old = wd + "/" + pkgname + "-" + pkgver_rel + ".pkg.tar.gz"
+						if fname_old not in ftpfiles and fname_new not in ftpfiles:
+							missing_pkgs.append(pkgname + "-" + pkgver_rel + " in " + wd)
+	ftp.quit()
+	
+def subset_superset_path(currpath, currpathnum, paths):
+	# If a pair of subset/superset paths are found,
+	# pop the superset one to show the more minimal
+	# case.
+	#
+	# e.g. foo > bar > baz > foo (superset)
+	#      foo > bar > foo (subset)
+	#      --> pop the superset
+	#
+	currdeps = currpath.split(">")
+	currdeps = list(set(currdeps))
+	currdeps.sort()
+	pathnum = 0
+	for path in paths:
+		if pathnum != currpathnum:
+			deps = path.split(">")
+			deps = list(set(deps))
+			deps.sort()
+			if len(currdeps) < len(path):
+				subset = True
+				for d in currdeps:
+					if not d in path:
+						subset = False
+						break
+				if subset:
+					circular_deps.pop(pathnum)
+					if pathnum <= currpathnum:
+						currpathnum -= 1
+			elif len(currdeps) > len(path):
+				superset = True
+				for d in path:
+					if not d in currdeps:
+						superset = False
+						break
+				if superset:
+					circular_deps.pop(currpathnum)
+					currpathnum -= 1
+		pathnum += 1
+	return True
+
+def unique_path(currpath, paths):
+	# Returns false if an equivalent path exists in
+	# paths.
+	#
+	# e.g. foo > bar > foo
+	#      bar > foo > bar
+	#
+	currdeps = currpath.split(">")
+	currdeps = list(set(currdeps))
+	currdeps.sort()
+	for path in paths:
+		deps = path.split(">")
+		deps = list(set(deps))
+		deps.sort()
+		if currdeps == deps:
+			return False
+	return True
+
+def update_paths(paths, dep, dep2):
+	# Update paths by appending new paths with dep2
+	# based on all the different ways we could get
+	# to dep2. Returns True if a path was updated.
+	new_path = False
+	for i in range(len(paths)):
+		array = paths[i].split(">")
+		newpath = paths[i] + ">" + dep2
+		if array[-1] == dep and not dep2 in array and unique_path(newpath, paths):
+			paths.append(newpath)
+			new_path = True
+	return new_path
+
+def check_name_in_recursive_deps(pkgname):
+	# Retrieve all recursive dependencies from a package and
+	# determines if pkgname is found in one of its deps.
+	recursive_deps = []
+	for dep in pkgbuild_deps[pkgname]:
+		dep = split_dep_prov_symbol(dep)[0] # Strip any provision
+		recursive_deps.append(dep)
+	paths = []
+	for dep in recursive_deps:
+		dep = split_dep_prov_symbol(dep)[0] # Strip any provision
+		paths.append(dep)
+	searching = True
+	while searching:
+		searching = False
+		for dep in recursive_deps:
+			for dep2 in pkgbuild_deps[dep]:
+				dep2 = split_dep_prov_symbol(dep2)[0] # Strip any provision
+				# This is a HUGE time-saver. Instead of generating every single
+				# possible path that can yield a circular dep, we'll reduce
+				# the number greatly by throwing out paths like such:
+				#
+				# If we have a path: foo>bar>baz>blah>poop>foo
+				# We will throw out any: 
+				#      foo>...>bar>baz>blah>poop>foo
+				#      foo>...>baz>blah>poop>foo
+				#      foo>...>blah>poop>foo
+				# and so on. Otherwise we will find hundreds or even thousands
+				# of possible paths that all essentially represent the same 
+				# circular dep.
+				#
+				# However, we will always let pkgname through in order to make
+				# sure we can find multiple circular deps for a given pkg.
+				if dep2 not in recursive_deps or dep2 == pkgname: 
+					updated = update_paths(paths, dep, dep2)
+					if dep2 not in recursive_deps:
+						recursive_deps.append(dep2)
+					if updated:
+						searching = True
+	# Done searching, store circular deps:
+	for path in paths:
+		if path.split(">")[-1] == pkgname:
+			if unique_path(pkgname + ">" + path, circular_deps):
+				circular_deps.append(pkgname + ">" + path)
+	# Reduce any subset/superset path pairs:
+	pathnum = 0
+	for path in circular_deps:
+		subset_superset_path(path, pathnum, circular_deps)
+		pathnum += 1
+
+def circular_deps_check():
+	# Check for circular dependencies:
+	for pkgname in pkgbuild_deps:
+		check_name_in_recursive_deps(pkgname)
+
+def visualize_repo():
+	output = 'digraph G { \n \
+		concentrate = true; \n \
+		ordering = out;     \n \
+		ranksep=5.0;        \n \
+		node [style=filled,fontsize=8]; \n'
+
+	# draws circular dependencies in red
+	for path in circular_deps:
+		output += '\t "'+path[0]+'"'
+		deps = path.split(">")
+		for d in deps:
+			output += ' -> "'+d+'"'
+		output += '  [color=red]\n'
+
+	for pkg in pkgbuild_deps.keys():
+		output += '\t "'+pkg+'" -> { '
+		for d in pkgbuild_deps[pkg]:
+			d = split_dep_prov_symbol(d)[0] # Strip any provision
+			output += '"'+d+'"; '
+		output += '}\n'
+
+	output += '}'
+
+	# Uncomment these lines to get a file dump called
+	# 'output'. This can be used to manually generate
+	# an image using, e.g., dot -Tsvg output tree.svg
+	#dump = open('output', 'w')
+	#dump.write(output)
+	#dump.close()
+
+	fname = 'dependency_tree-' + arch + '.svg'
+	print "Generating " + fname + "..."
+	g = pydot.graph_from_dot_data(output)
+	g.write(fname, prog='dot', format='svg')
+	
+def print_result(list, subheading):
+	if len(list) > 0:
+		print_subheading(subheading)
+		for item in list:
+			print item
+
+def print_results():
+	print_result(misses, "Missing PKGBUILDs")
+	print_result(mismatches, "Mismatched Pkgnames")
+	print_result(dups, "Duplicate PKGBUILDs")
+	print_result(missing_deps, "Missing Dependencies")
+	print_result(missing_makedeps, "Missing Makedepends")
+	print_result(unmet_dep_provs, "Unmet Dependency Provisions")
+	print_result(unmet_makedep_provs, "Unmet Makedepends Provisions")
+	print_result(dep_hierarchy, "Repo Hierarchy for Dependencies")
+	print_result(makedep_hierarchy, "Repo Hierarchy for Makedepends")
+	print_result(invalid_archs, "Invalid Archs")
+	print_result(circular_deps, "Circular Dependencies")
+	print_result(missing_pkgs, "Missing Repo Packages")
+	print_subheading("Summary")
+	print "Dirs with missing PKGBUILDs:          ", len(misses)
+	print "Duplicate PKGBUILDs:                  ", len(dups)
+	print "Missing (make)dependencies:           ", len(missing_deps)+len(missing_makedeps)
+	print "Unmet provisioned (make)dependencies: ", len(unmet_dep_provs)+len(unmet_makedep_provs)
+	print "Circular dependencies:                ", len(circular_deps)
+	print "Invalid archs:                        ", len(invalid_archs)
+	print "Missing packages in repos:            ", len(missing_pkgs)
+	print "Mismatching PKGBUILD names:           ", len(mismatches)
+	print "Repo hierarchy problems:              ", len(dep_hierarchy)+len(makedep_hierarchy)
+	print ""
+
+def print_usage():
+	print ""
+	print "Usage: check_archlinux [OPTION]"
+	print ""
+	print "Options:"
+	print "  --abs-tree=<path>           Check specified tree (assumes the abs tree"
+	print "                              is i686 unless overridden with --arch)"
+	print "  --arch=<arch>               Use specified arch (e.g. 'x86_64')"
+	print "  -g                          Generate graphical dependency tree(s)"
+	print "  -h, --help                  Show this help and exit"
+	print ""
+	print "Examples:"
+	print "\n  Check all arches and do fresh cvs checkouts:"
+	print "    check_archlinux"
+	print "\n  Check x_86_64 only and do fresh cvs checkout:"
+	print "    check_archlinux --arch=x86_64"
+	print "\n  Check existing i686 abs tree:"
+	print "    check_archlinux --abs-tree=/var/abs"
+	print "\n  Check existing x86_64 abs tree and also generate dep tree image:"
+	print "    check_archlinux --abs-tree=/var/abs --arch=x86_64 -g"
+	print ""
+
+graphdeptree = False
+user_absroot = ""
+user_arch = ""
+try:
+	opts, args = getopt.getopt(sys.argv[1:], "g", ["abs-tree=", "arch="])
+except getopt.GetoptError:
+	print_usage()
+	sys.exit()
+if opts != []:
+	for o, a in opts:
+		if o in ("-g"):
+			graphdeptree = True
+			if not HAS_PYDOT:
+				print "You must install pydot to generate a graphical dependency tree. Aborting..."
+				sys.exit()
+		elif o in ("--abs-tree"):
+			user_absroot = a
+		elif o in ("--arch"):
+			user_arch = a
+			if user_arch not in valid_archs:
+				print "You did not specify a valid arch. Aborting..."
+				sys.exit()
+		else:
+			print_usage()
+			sys.exit()
+		if args != []:
+			for a in args:
+				if a in ("play", "pause", "stop", "next", "prev", "pp", "info", "status", "repeat", "shuffle"):
+					self.single_connect_for_passed_arg(a)
+				else:
+					self.print_usage()
+				sys.exit()
+
+if len(user_absroot) > 0 and len(user_arch) == 0:
+	user_arch = valid_archs[0] # i686 default..
+
+if len(user_absroot) > 0:
+	print "Warning: Ensure your ABS tree is clean to prevent false positives."
+
+try:
+	absroots = []
+	fsup = 'supfile.curr'
+	for arch in valid_archs:
+		if len(user_arch) == 0 or user_arch == arch:
+			print_heading(arch + " Integrity Check")
+			if len(user_absroot) == 0:
+				# Create temp dir for cvs checkout:
+				absroot = tempfile.mkdtemp(prefix="abs-" + arch + "-") 
+				absroots.append(absroot)
+				print "\nChecking out clean abs tree"
+				for repo in include_paths:
+					print "==>", repo
+					# Create (and modify) supfile:
+					if not os.path.exists(abs_conf_dir + '/supfile.' + repo):
+						print "Cannot find file " + abs_conf_dir + '/supfile.' + repo + ". Aborting..."
+						sys.exit()
+					create_supfile(abs_conf_dir + '/supfile.' + repo, fsup, cvs_tags[arch])
+					cmd = 'csup -L 0 -r 0 -g -b ' + absroot + ' -c .sup ' + fsup
+					os.system(cmd)
+			else:
+				absroot = user_absroot
+				absroots.append(absroot)
+			curr_include_paths = []
+			for repo in include_paths:
+				curr_include_paths.append(absroot + "/" + repo)
+
+			# Re-init vars for new abs tree:
+			pkgbuild_deps = {} # pkgname: [dep1, dep2>foo, dep3=bar, ...]
+			pkgbuild_makedeps = {} # pkgname: [dep1, dep2>foo, dep3=bar, ...]
+			pkgbuild_provides = {} # provide_name: pkgname
+			pkgbuild_paths = {} # pkgname: /var/abs/foo/bar/pkgname/PKGBUILD
+			pkgbuild_archs = {} # pkgname: [i686, x86_64]
+			pkgbuild_versions = {} # pkname: 1.0.4-2
+			# circular_deps is not a dict to accommodate multiple circ deps for a given pkg
+			circular_deps = [] # pkgname>dep1>dep2>...>pkgname
+			mismatches = []
+			misses = []
+			dups = []
+			missing_deps = []
+			unmet_dep_provs = []
+			dep_hierarchy = []
+			missing_makedeps = []
+			unmet_makedep_provs = []
+			makedep_hierarchy = []
+			invalid_archs = []
+			missing_pkgs = []
+
+			# Verify stuff for abs tree:
+			print "\nPerforming integrity checks..."
+			print "==> parsing pkgbuilds"
+			get_pkgbuilds_in_dir(absroot)
+			print "==> checking dependencies"
+			verify_depends_makedepends()
+			print "==> checking makedepends"
+			verify_depends_makedepends(True)
+			print "==> checking archs"
+			verify_archs()
+			print "==> checking for circular dependencies"
+			circular_deps_check()
+			print "==> checking repo packages"
+			verify_packages(arch)
+			print_results()
+			if graphdeptree:
+				visualize_repo()
+			
+			print "\nCleaning up temporary abs tree..."
+			if len(user_absroot) == 0:
+				# Delete temp abs tree:
+				if os.path.exists(absroot):
+					removeall(absroot)
+					os.rmdir(absroot)
+except:
+	# Cleanup files...
+	if len(user_absroot) == 0:
+		print "\nCleaning up temporary abs tree(s)..."
+		# Delete any temp abs trees:
+		for path in absroots:
+			if os.path.exists(path):
+				removeall(path)
+				os.rmdir(path)
+finally:
+	# Remove supfile:
+	if os.path.exists(fsup):
+		os.remove(fsup)