[gentoo-commits] dev/zorry:master commit in: gobs/bin/, ebuild/dev-python/gobs/, gobs/doc/portage/all/, gobs/pym/, gobs/doc/

[Magnus Granberg]

commit:     d6c34d2aec0cdaac88c1dd6ed2866db7c5afebb5
Author:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
AuthorDate: Fri Apr 27 17:48:54 2012 +0000
Commit:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
CommitDate: Fri Apr 27 17:48:54 2012 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=dev/zorry.git;a=commit;h=d6c34d2a

major update part2

---
 ebuild/dev-python/gobs/gobs-9999.ebuild~ |   50 -
 gobs/bin/gobs_buildquerys~               |   38 -
 gobs/bin/gobs_portage_hooks~             |   79 --
 gobs/bin/gobs_setup_profile~             |   12 -
 gobs/bin/gobs_updatedb~                  |  123 --
 gobs/doc/Setup.txt~                      |    7 -
 gobs/doc/portage/all/bashrc~             |    7 -
 gobs/pym/ConnectionManager.py~           |   56 -
 gobs/pym/Scheduler.py~                   | 1994 ------------------------------
 gobs/pym/arch.py~                        |   25 -
 gobs/pym/build_log.py~                   |  572 ---------
 gobs/pym/build_queru.py~                 |  708 -----------
 gobs/pym/categories.py~                  |   30 -
 gobs/pym/check_setup.py~                 |  102 --
 gobs/pym/depclean.py~                    |  632 ----------
 gobs/pym/init_setup_profile.py~          |   86 --
 gobs/pym/manifest.py~                    |  124 --
 gobs/pym/old_cpv.py~                     |   89 --
 gobs/pym/package.py~                     |  306 -----
 gobs/pym/pgsql.py~                       |  638 ----------
 gobs/pym/readconf.py~                    |   46 -
 gobs/pym/repoman_gobs.py~                |   48 -
 gobs/pym/sync.py~                        |   23 -
 gobs/pym/text.py~                        |   48 -
 24 files changed, 0 insertions(+), 5843 deletions(-)

diff --git a/ebuild/dev-python/gobs/gobs-9999.ebuild~ b/ebuild/dev-python/gobs/gobs-9999.ebuild~
deleted file mode 100644
index 22fa1b7..0000000
--- a/ebuild/dev-python/gobs/gobs-9999.ebuild~
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright 1999-2010 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Header: $
-
-EAPI="2"
-PYTHON_DEPEND="*:2.7"
-SUPPORT_PYTHON_ABIS="1"
-
-inherit distutils git-2
-
-DESCRIPTION="Gobs"
-HOMEPAGE="http://git.overlays.gentoo.org/gitroot/dev/zorry.git"
-SRC_URI=""
-LICENSE="GPL-2"
-KEYWORDS="~amd64"
-SLOT="0"
-IUSE="+postgresql"
-
-RDEPEND="sys-apps/portage
-	>=dev-python/git-python-0.3.2_rc1
-	postgresql? ( dev-python/psycopg )"
-
-DEPEND="${RDEPEND}
-	dev-python/setuptools"
-
-# RESTRICT_PYTHON_ABIS="3.*"
-
-EGIT_REPO_URI="http://git.overlays.gentoo.org/gitroot/dev/zorry.git"
-#EGIT_FETCH_CMD="git clone"
-##EGIT_BRANCH="master"
-##EGIT_COMMIT=${EGIT_BRANCH}
-# The eclass is based on subversion eclass.
-# If you use this eclass, the ${S} is ${WORKDIR}/${P}.
-# It is necessary to define the EGIT_REPO_URI variable at least.
-
-PYTHON_MODNAME="gobs"
-
-src_install() {
-	dodir /var/lib/gobs || die
-	dodir etc/gobs || die
-	insinto /etc/gobs
-	doins ${FILESDIR}/gobs.conf || die
-	dobin ${S}/gobs/bin/gobs_updatedb || die
-	dobin ${S}/gobs/bin/gobs_portage_hooks || die
-	dosbin  ${S}/gobs/bin/gobs_buildquerys || die
-	dodoc ${S}/gobs/sql/pgdump.sql.gz || die
-	dodoc  ${S}/gobs/doc/Setup.txt || die
-
-	distutils_src_install
-}	
\ No newline at end of file

diff --git a/gobs/bin/gobs_buildquerys~ b/gobs/bin/gobs_buildquerys~
deleted file mode 100755
index 842b324..0000000
--- a/gobs/bin/gobs_buildquerys~
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/usr/bin/python
-
-# Get the options from the config file set in gobs.readconf
-from gobs.readconf import get_conf_settings
-reader=get_conf_settings()
-gobs_settings_dict=reader.read_gobs_settings_all()
-# make a CM
-from gobs.ConnectionManager import connectionManager
-
-from gobs.check_setup import check_configure_guest
-from gobs.sync import git_pull
-from gobs.build_queru import queruaction
-import portage
-import sys
-import os
-
-def main_loop(config_profile):
-	repeat = True
-	#get a connection from the pool
-	init_queru = queruaction(config_profile)
-	while repeat:
-		git_pull()
-		if check_configure_guest(config_profile) is not True:
-			# time.sleep(60)
-			continue		# retunr to the start of the function
-		else:
-			init_queru.procces_qureru()
-			# time.sleep(60)
-
-def main():
-  # Main
-  config_profile = gobs_settings_dict['gobs_config']
-  #we provide the main_loop with the ConnectionManager so we can hand out connections from within the loop
-  main_loop(config_profile)
-  connectionManager.closeAllConnections()
-
-if __name__ == "__main__":
-  main()

diff --git a/gobs/bin/gobs_portage_hooks~ b/gobs/bin/gobs_portage_hooks~
deleted file mode 100755
index 5432545..0000000
--- a/gobs/bin/gobs_portage_hooks~
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/usr/bin/python
-from __future__ import print_function
-import os
-import sys
-# Get the options from the config file set in gobs.readconf
-from gobs.readconf import get_conf_settings
-reader=get_conf_settings()
-gobs_settings_dict=reader.read_gobs_settings_all()
-# make a CM
-from gobs.ConnectionManager import connectionManager
-CM=connectionManager(gobs_settings_dict)
-#selectively import the pgsql/mysql querys
-if CM.getName()=='pgsql':
-  from gobs.pgsql import *
-
-from gobs.package import gobs_package
-from gobs.build_log import gobs_buildlog
-from gobs.flags import gobs_use_flags
-from portage.util import writemsg, writemsg_level, writemsg_stdout
-import portage
-
-def get_build_dict_db(mysettings, config_profile, gobs_settings_dict):
-	conn=CM.getConnection()
-	myportdb = portage.portdbapi(mysettings=mysettings)
-	categories = os.environ['CATEGORY']
-	package = os.environ['PN']
-	ebuild_version = os.environ['PVR']
-	cpv = categories + "/" + package + "-" + ebuild_version
-	init_package = gobs_package(mysettings, myportdb)
-	print("cpv", cpv)
-	package_id = have_package_db(conn, categories, package)
-	# print("package_id %s" % package_id, file=sys.stdout)
-	build_dict = {}
-	mybuild_dict = {}
-	build_dict['ebuild_version'] = ebuild_version
-	build_dict['package_id'] = package_id
-	build_dict['cpv'] = cpv
-	build_dict['categories'] = categories
-	build_dict['package'] = package
-	build_dict['config_profile'] = config_profile
-	init_useflags = gobs_use_flags(mysettings, myportdb, cpv)
-	iuse_flags_list, final_use_list = init_useflags.get_flags_looked()
-	#print 'final_use_list', final_use_list
-	if  final_use_list != []:
-		build_dict['build_useflags'] = final_use_list
-	else:
-		build_dict['build_useflags'] = None
-	#print "build_dict['build_useflags']", build_dict['build_useflags']
-	pkgdir = os.path.join(mysettings['PORTDIR'], categories + "/" + package)
-	ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir+ "/" + package + "-" + ebuild_version + ".ebuild")[0]
-	build_dict['checksum'] = ebuild_version_checksum_tree
-	print('checksum' ,ebuild_version_checksum_tree)
-	ebuild_id = get_ebuild_id_db_checksum(conn, build_dict)
-	print('ebuild_id in db', ebuild_id)
-	if ebuild_id is None:
-		#print 'have any ebuild',  get_ebuild_checksum(conn, package_id, ebuild_version)
-		init_package.update_ebuild_db(build_dict)
-		ebuild_id = get_ebuild_id_db_checksum(conn, build_dict)
-	build_dict['ebuild_id'] = ebuild_id
-	queue_id = check_revision(conn, build_dict)
-	print("queue_id in db", queue_id)
-	if queue_id is None:
-		build_dict['queue_id'] = None
-	else:
-		build_dict['queue_id'] = queue_id
-	return build_dict
-
-def main():
-  # Main
-  config_profile = gobs_settings_dict['gobs_config']
-  #we provide the main_loop with the ConnectionManager so we can hand out connections from within the loop
-  mysettings = portage.settings
-  build_dict = get_build_dict_db( mysettings, config_profile, gobs_settings_dict)
-  init_buildlog = gobs_buildlog(mysettings, build_dict)
-  init_buildlog.add_buildlog_main()
-  #connectionManager.closeAllConnections()
-
-if __name__ == "__main__":
-  main()
\ No newline at end of file

diff --git a/gobs/bin/gobs_setup_profile~ b/gobs/bin/gobs_setup_profile~
deleted file mode 100755
index cf926fa..0000000
--- a/gobs/bin/gobs_setup_profile~
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/usr/bin/python
-# Copyright 2006-2011 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-
-from gobs.init_setup_profile import setup_profile_main
-
-def main():
-	# Main
-	setup_profile_main(args=None):
-	
-if __name__ == "__main__":
-	main()
\ No newline at end of file

diff --git a/gobs/bin/gobs_updatedb~ b/gobs/bin/gobs_updatedb~
deleted file mode 100755
index 15271e4..0000000
--- a/gobs/bin/gobs_updatedb~
+++ /dev/null
@@ -1,123 +0,0 @@
-#!/usr/bin/python
-# Copyright 2006-2011 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-
-""" 	This code will update the sql backend with needed info for
-	the Frontend and the Guest deamon. """
-
-import sys
-import os
-import multiprocessing
-
-
-# Get the options from the config file set in gobs.readconf
-from gobs.readconf import get_conf_settings
-reader=get_conf_settings()
-gobs_settings_dict=reader.read_gobs_settings_all()
-# make a CM
-from gobs.ConnectionManager import connectionManager
-CM=connectionManager(gobs_settings_dict)
-#selectively import the pgsql/mysql querys
-if CM.getName()=='pgsql':
-  from gobs.pgsql import *
-
-from gobs.check_setup import check_make_conf
-from gobs.arch import gobs_arch
-from gobs.package import gobs_package
-from gobs.categories import gobs_categories
-from gobs.old_cpv import gobs_old_cpv
-from gobs.categories import gobs_categories
-from gobs.sync import git_pull, sync_tree
-import portage
-
-def init_portage_settings():
-	
-	""" Get the BASE Setup/Config for portage.settings
-	@type: module
-	@module: The SQL Backend
-	@type: dict
-	@parms: config options from the config file (host_setup_root)
-	@rtype: settings
-	@returns new settings
-	"""
-	# check config setup
-	#git stuff
-	conn=CM.getConnection()
-	check_make_conf()
-	print "Check configs done"
-	# Get default config from the configs table  and default_config=1
-	config_id = get_default_config(conn)			# HostConfigDir = table configs id
-	CM.putConnection(conn);
-	default_config_root = "/var/lib/gobs/" + gobs_settings_dict['gobs_gitreponame'] + "/" + config_id[0] + "/"
-	# Set config_root (PORTAGE_CONFIGROOT)  to default_config_root
-	mysettings = portage.config(config_root = default_config_root)
-	print "Setting default config to:", config_id[0]
-	return mysettings
-
-def update_cpv_db_pool(mysettings, package_line):
-	conn=CM.getConnection()
-	# Setup portdb, gobs_categories, gobs_old_cpv, package
-	myportdb = portage.portdbapi(mysettings=mysettings)
-	init_categories = gobs_categories(mysettings)
-	init_package = gobs_package(mysettings, myportdb)
-	# split the cp to categories and package
-	element = package_line.split('/')
-	categories = element[0]
-	package = element[1]    
-	# Check if we don't have the cp in the package table
-	package_id = have_package_db(conn,categories, package)
-	if package_id is None:  
-		# Add new package with ebuilds
-		init_package.add_new_package_db(categories, package)
-	# Ceck if we have the cp in the package table
-	elif package_id is not None:
-		# Update the packages with ebuilds
-		init_package.update_package_db(categories, package, package_id)
-	# Update the metadata for categories
-	init_categories.update_categories_db(categories)
-	CM.putConnection(conn)
-			
-def update_cpv_db(mysettings):
-	"""Code to update the cpv in the database.
-	@type:settings
-	@parms: portage.settings
-	@type: module
-	@module: The SQL Backend
-	@type: dict
-	@parms: config options from the config file
-	"""
-	print "Checking categories, package, ebuilds"
-	# Setup portdb, gobs_categories, gobs_old_cpv, package
-	myportdb = portage.portdbapi(mysettings=mysettings)
-	package_id_list_tree = []
-	# Will run some update checks and update package if needed
-	# Get categories/package list from portage
-	package_list_tree = myportdb.cp_all()
-	pool_cores= multiprocessing.cpu_count()
-	if pool_cores > "3":
-		use_pool_cores = pool_cores - 2
-	else
-		use_pool_cores = 1
-	pool = multiprocessing.Pool(processes=use_pool_cores)
-	# Run the update package for all package in the list in
-	# a multiprocessing pool
-	for package_line in sorted(package_list_tree):
-		pool.apply_async(update_cpv_db_pool, (mysettings, package_line,))
-	pool.close()
-	pool.join() 
-	print "Checking categories, package and ebuilds done"
-
-def main():
-	# Main
-	# Init settings for the default config
-	git_pull
-	if sync_tree():
-		mysettings =  init_portage_settings()
-		init_arch = gobs_arch()
-		init_arch.update_arch_db()
-		# Update the cpv db
-		update_cpv_db(mysettings)
-	CM.closeAllConnections()
-	
-if __name__ == "__main__":
-	main()
\ No newline at end of file

diff --git a/gobs/doc/Setup.txt~ b/gobs/doc/Setup.txt~
deleted file mode 100644
index 956990f..0000000
--- a/gobs/doc/Setup.txt~
+++ /dev/null
@@ -1,7 +0,0 @@
-1. Setup the Backend
-Setup the gobs.conf  for the db.
-Change GOBSGITREPONAME to point to the git repo with your configs for the profiles/setups.
-Import the *dump.sql.gz to your sql.
-The portage/base/make.conf should be in the base profile/setup
-The portage/all/bashrc should be in all the guest profiles/setups
-The porfiles dir need a dir call config with a parent file that point to base profile

diff --git a/gobs/doc/portage/all/bashrc~ b/gobs/doc/portage/all/bashrc~
deleted file mode 100644
index 092548e..0000000
--- a/gobs/doc/portage/all/bashrc~
+++ /dev/null
@@ -1,7 +0,0 @@
-pre_pkg_setup() {
-	register_die_hook gobs_portage_hook
-	register_success_hook gobs_portage_hook
-}
-gobs_portage_hook() {
-	/home/buildhost/portage_hooks
-}

diff --git a/gobs/pym/ConnectionManager.py~ b/gobs/pym/ConnectionManager.py~
deleted file mode 100644
index 1bbeb35..0000000
--- a/gobs/pym/ConnectionManager.py~
+++ /dev/null
@@ -1,56 +0,0 @@
-#a simple CM build around sie singleton so there can only be 1 CM but you can call the class in different place with out caring about it.
-#when the first object is created of this class, the SQL settings are read from the file and stored in the class for later reuse by the next object and so on.
-#(maybe later add support for connection pools)
-from __future__ import print_function
-
-class connectionManager(object):
-    _instance = None   
-
-    #size of the connection Pool
-    def __new__(cls, settings_dict, numberOfconnections=20, *args, **kwargs):
-        if not cls._instance:
-            cls._instance = super(connectionManager, cls).__new__(cls, *args, **kwargs)
-            #read the sql user/host etc and store it in the local object
-            print(settings_dict['sql_host'])
-            cls._host=settings_dict['sql_host']
-            cls._user=settings_dict['sql_user']
-            cls._password=settings_dict['sql_passwd']
-            cls._database=settings_dict['sql_db']
-            #shouldnt we include port also?
-            try:
-              from psycopg2 import pool
-              cls._connectionNumber=numberOfconnections
-              #always create 1 connection
-              cls._pool=pool.ThreadedConnectionPool(1,cls._connectionNumber,host=cls._host,database=cls._database,user=cls._user,password=cls._password)
-              cls._name='pgsql'
-            except ImportError:
-              print("Please install a recent version of dev-python/psycopg for Python")
-              sys.exit(1)
-            #setup connection pool
-        return cls._instance
-    
-    ## returns the name of the database pgsql/mysql etc
-    def getName(self):
-      return self._name
-      
-    def getConnection(self):
-      return self._pool.getconn()
-      
-    def putConnection(self, connection):
-      self._pool.putconn(connection)
-
-    def closeAllConnections(self):
-      self._pool.closeall()
-
-##how to use this class
-#get a instance of the class (there can only be 1 instance but many pointers (single ton))
-#get the connection
-#conn=cm.getConnection()
-#get a cursor
-#cur=conn.cursor()
-#do stuff
-#cur.execute(stuff)
-#"close a connection" temporarily put it away for reuse
-#cm.putConnection(conn)
-#kill all connections, should only be used just before the program terminates
-#cm.closeAllConnections()

diff --git a/gobs/pym/Scheduler.py~ b/gobs/pym/Scheduler.py~
deleted file mode 100644
index 005f861..0000000
--- a/gobs/pym/Scheduler.py~
+++ /dev/null
@@ -1,1994 +0,0 @@
-# Copyright 1999-2011 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-
-from __future__ import print_function
-
-from collections import deque
-import gc
-import gzip
-import logging
-import shutil
-import signal
-import sys
-import tempfile
-import textwrap
-import time
-import warnings
-import weakref
-import zlib
-
-import portage
-from portage import os
-from portage import _encodings
-from portage import _unicode_decode, _unicode_encode
-from portage.cache.mappings import slot_dict_class
-from portage.elog.messages import eerror
-from portage.localization import _
-from portage.output import colorize, create_color_func, red
-bad = create_color_func("BAD")
-from portage._sets import SETPREFIX
-from portage._sets.base import InternalPackageSet
-from portage.util import writemsg, writemsg_level
-from portage.package.ebuild.digestcheck import digestcheck
-from portage.package.ebuild.digestgen import digestgen
-from portage.package.ebuild.prepare_build_dirs import prepare_build_dirs
-
-import _emerge
-from _emerge.BinpkgFetcher import BinpkgFetcher
-from _emerge.BinpkgPrefetcher import BinpkgPrefetcher
-from _emerge.BinpkgVerifier import BinpkgVerifier
-from _emerge.Blocker import Blocker
-from _emerge.BlockerDB import BlockerDB
-from _emerge.clear_caches import clear_caches
-from _emerge.create_depgraph_params import create_depgraph_params
-from _emerge.create_world_atom import create_world_atom
-from _emerge.DepPriority import DepPriority
-from _emerge.depgraph import depgraph, resume_depgraph
-from _emerge.EbuildFetcher import EbuildFetcher
-from _emerge.EbuildPhase import EbuildPhase
-from _emerge.emergelog import emergelog
-from _emerge.FakeVartree import FakeVartree
-from _emerge._find_deep_system_runtime_deps import _find_deep_system_runtime_deps
-from _emerge._flush_elog_mod_echo import _flush_elog_mod_echo
-from _emerge.JobStatusDisplay import JobStatusDisplay
-from _emerge.MergeListItem import MergeListItem
-from _emerge.MiscFunctionsProcess import MiscFunctionsProcess
-from _emerge.Package import Package
-from _emerge.PackageMerge import PackageMerge
-from _emerge.PollScheduler import PollScheduler
-from _emerge.RootConfig import RootConfig
-from _emerge.SlotObject import SlotObject
-from _emerge.SequentialTaskQueue import SequentialTaskQueue
-
-from gobs.build_log import gobs_buildlog
-
-if sys.hexversion >= 0x3000000:
-	basestring = str
-
-class Scheduler(PollScheduler):
-
-	# max time between display status updates (milliseconds)
-	_max_display_latency = 3000
-
-	_opts_ignore_blockers = \
-		frozenset(["--buildpkgonly",
-		"--fetchonly", "--fetch-all-uri",
-		"--nodeps", "--pretend"])
-
-	_opts_no_background = \
-		frozenset(["--pretend",
-		"--fetchonly", "--fetch-all-uri"])
-
-	_opts_no_restart = frozenset(["--buildpkgonly",
-		"--fetchonly", "--fetch-all-uri", "--pretend"])
-
-	_bad_resume_opts = set(["--ask", "--changelog",
-		"--resume", "--skipfirst"])
-
-	class _iface_class(SlotObject):
-		__slots__ = ("fetch",
-			"output", "register", "schedule",
-			"scheduleSetup", "scheduleUnpack", "scheduleYield",
-			"unregister")
-
-	class _fetch_iface_class(SlotObject):
-		__slots__ = ("log_file", "schedule")
-
-	_task_queues_class = slot_dict_class(
-		("merge", "jobs", "ebuild_locks", "fetch", "unpack"), prefix="")
-
-	class _build_opts_class(SlotObject):
-		__slots__ = ("buildpkg", "buildpkg_exclude", "buildpkgonly",
-			"fetch_all_uri", "fetchonly", "pretend")
-
-	class _binpkg_opts_class(SlotObject):
-		__slots__ = ("fetchonly", "getbinpkg", "pretend")
-
-	class _pkg_count_class(SlotObject):
-		__slots__ = ("curval", "maxval")
-
-	class _emerge_log_class(SlotObject):
-		__slots__ = ("xterm_titles",)
-
-		def log(self, *pargs, **kwargs):
-			if not self.xterm_titles:
-				# Avoid interference with the scheduler's status display.
-				kwargs.pop("short_msg", None)
-			emergelog(self.xterm_titles, *pargs, **kwargs)
-
-	class _failed_pkg(SlotObject):
-		__slots__ = ("build_dir", "build_log", "pkg", "returncode")
-
-	class _ConfigPool(object):
-		"""Interface for a task to temporarily allocate a config
-		instance from a pool. This allows a task to be constructed
-		long before the config instance actually becomes needed, like
-		when prefetchers are constructed for the whole merge list."""
-		__slots__ = ("_root", "_allocate", "_deallocate")
-		def __init__(self, root, allocate, deallocate):
-			self._root = root
-			self._allocate = allocate
-			self._deallocate = deallocate
-		def allocate(self):
-			return self._allocate(self._root)
-		def deallocate(self, settings):
-			self._deallocate(settings)
-
-	class _unknown_internal_error(portage.exception.PortageException):
-		"""
-		Used internally to terminate scheduling. The specific reason for
-		the failure should have been dumped to stderr.
-		"""
-		def __init__(self, value=""):
-			portage.exception.PortageException.__init__(self, value)
-
-	def __init__(self, settings, trees, mtimedb, myopts,
-		spinner, mergelist=None, favorites=None, graph_config=None):
-		PollScheduler.__init__(self)
-
-		if mergelist is not None:
-			warnings.warn("The mergelist parameter of the " + \
-				"_emerge.Scheduler constructor is now unused. Use " + \
-				"the graph_config parameter instead.",
-				DeprecationWarning, stacklevel=2)
-
-		self.settings = settings
-		self.target_root = settings["ROOT"]
-		self.trees = trees
-		self.myopts = myopts
-		self._spinner = spinner
-		self._mtimedb = mtimedb
-		self._favorites = favorites
-		self._args_set = InternalPackageSet(favorites, allow_repo=True)
-		self._build_opts = self._build_opts_class()
-
-		for k in self._build_opts.__slots__:
-			setattr(self._build_opts, k, "--" + k.replace("_", "-") in myopts)
-		self._build_opts.buildpkg_exclude = InternalPackageSet( \
-			initial_atoms=" ".join(myopts.get("--buildpkg-exclude", [])).split(), \
-			allow_wildcard=True, allow_repo=True)
-
-		self._binpkg_opts = self._binpkg_opts_class()
-		for k in self._binpkg_opts.__slots__:
-			setattr(self._binpkg_opts, k, "--" + k.replace("_", "-") in myopts)
-
-		self.curval = 0
-		self._logger = self._emerge_log_class()
-		self._task_queues = self._task_queues_class()
-		for k in self._task_queues.allowed_keys:
-			setattr(self._task_queues, k,
-				SequentialTaskQueue())
-
-		# Holds merges that will wait to be executed when no builds are
-		# executing. This is useful for system packages since dependencies
-		# on system packages are frequently unspecified. For example, see
-		# bug #256616.
-		self._merge_wait_queue = deque()
-		# Holds merges that have been transfered from the merge_wait_queue to
-		# the actual merge queue. They are removed from this list upon
-		# completion. Other packages can start building only when this list is
-		# empty.
-		self._merge_wait_scheduled = []
-
-		# Holds system packages and their deep runtime dependencies. Before
-		# being merged, these packages go to merge_wait_queue, to be merged
-		# when no other packages are building.
-		self._deep_system_deps = set()
-
-		# Holds packages to merge which will satisfy currently unsatisfied
-		# deep runtime dependencies of system packages. If this is not empty
-		# then no parallel builds will be spawned until it is empty. This
-		# minimizes the possibility that a build will fail due to the system
-		# being in a fragile state. For example, see bug #259954.
-		self._unsatisfied_system_deps = set()
-
-		self._status_display = JobStatusDisplay(
-			xterm_titles=('notitles' not in settings.features))
-		self._max_load = myopts.get("--load-average")
-		max_jobs = myopts.get("--jobs")
-		if max_jobs is None:
-			max_jobs = 1
-		self._set_max_jobs(max_jobs)
-
-		# The root where the currently running
-		# portage instance is installed.
-		self._running_root = trees["/"]["root_config"]
-		self.edebug = 0
-		if settings.get("PORTAGE_DEBUG", "") == "1":
-			self.edebug = 1
-		self.pkgsettings = {}
-		self._config_pool = {}
-		for root in self.trees:
-			self._config_pool[root] = []
-
-		self._fetch_log = os.path.join(_emerge.emergelog._emerge_log_dir,
-			'emerge-fetch.log')
-		fetch_iface = self._fetch_iface_class(log_file=self._fetch_log,
-			schedule=self._schedule_fetch)
-		self._sched_iface = self._iface_class(
-			fetch=fetch_iface, output=self._task_output,
-			register=self._register,
-			schedule=self._schedule_wait,
-			scheduleSetup=self._schedule_setup,
-			scheduleUnpack=self._schedule_unpack,
-			scheduleYield=self._schedule_yield,
-			unregister=self._unregister)
-
-		self._prefetchers = weakref.WeakValueDictionary()
-		self._pkg_queue = []
-		self._running_tasks = {}
-		self._completed_tasks = set()
-
-		self._failed_pkgs = []
-		self._failed_pkgs_all = []
-		self._failed_pkgs_die_msgs = []
-		self._post_mod_echo_msgs = []
-		self._parallel_fetch = False
-		self._init_graph(graph_config)
-		merge_count = len([x for x in self._mergelist \
-			if isinstance(x, Package) and x.operation == "merge"])
-		self._pkg_count = self._pkg_count_class(
-			curval=0, maxval=merge_count)
-		self._status_display.maxval = self._pkg_count.maxval
-
-		# The load average takes some time to respond when new
-		# jobs are added, so we need to limit the rate of adding
-		# new jobs.
-		self._job_delay_max = 10
-		self._job_delay_factor = 1.0
-		self._job_delay_exp = 1.5
-		self._previous_job_start_time = None
-
-		# This is used to memoize the _choose_pkg() result when
-		# no packages can be chosen until one of the existing
-		# jobs completes.
-		self._choose_pkg_return_early = False
-
-		features = self.settings.features
-		if "parallel-fetch" in features and \
-			not ("--pretend" in self.myopts or \
-			"--fetch-all-uri" in self.myopts or \
-			"--fetchonly" in self.myopts):
-			if "distlocks" not in features:
-				portage.writemsg(red("!!!")+"\n", noiselevel=-1)
-				portage.writemsg(red("!!!")+" parallel-fetching " + \
-					"requires the distlocks feature enabled"+"\n",
-					noiselevel=-1)
-				portage.writemsg(red("!!!")+" you have it disabled, " + \
-					"thus parallel-fetching is being disabled"+"\n",
-					noiselevel=-1)
-				portage.writemsg(red("!!!")+"\n", noiselevel=-1)
-			elif merge_count > 1:
-				self._parallel_fetch = True
-
-		if self._parallel_fetch:
-				# clear out existing fetch log if it exists
-				try:
-					open(self._fetch_log, 'w').close()
-				except EnvironmentError:
-					pass
-
-		self._running_portage = None
-		portage_match = self._running_root.trees["vartree"].dbapi.match(
-			portage.const.PORTAGE_PACKAGE_ATOM)
-		if portage_match:
-			cpv = portage_match.pop()
-			self._running_portage = self._pkg(cpv, "installed",
-				self._running_root, installed=True)
-
-	def _terminate_tasks(self):
-		self._status_display.quiet = True
-		while self._running_tasks:
-			task_id, task = self._running_tasks.popitem()
-			task.cancel()
-		for q in self._task_queues.values():
-			q.clear()
-
-	def _init_graph(self, graph_config):
-		"""
-		Initialization structures used for dependency calculations
-		involving currently installed packages.
-		"""
-		self._set_graph_config(graph_config)
-		self._blocker_db = {}
-		for root in self.trees:
-			if graph_config is None:
-				fake_vartree = FakeVartree(self.trees[root]["root_config"],
-					pkg_cache=self._pkg_cache)
-				fake_vartree.sync()
-			else:
-				fake_vartree = graph_config.trees[root]['vartree']
-			self._blocker_db[root] = BlockerDB(fake_vartree)
-
-	def _destroy_graph(self):
-		"""
-		Use this to free memory at the beginning of _calc_resume_list().
-		After _calc_resume_list(), the _init_graph() method
-		must to be called in order to re-generate the structures that
-		this method destroys. 
-		"""
-		self._blocker_db = None
-		self._set_graph_config(None)
-		gc.collect()
-
-	def _poll(self, timeout=None):
-
-		self._schedule()
-
-		if timeout is None:
-			while True:
-				if not self._poll_event_handlers:
-					self._schedule()
-					if not self._poll_event_handlers:
-						raise StopIteration(
-							"timeout is None and there are no poll() event handlers")
-				previous_count = len(self._poll_event_queue)
-				PollScheduler._poll(self, timeout=self._max_display_latency)
-				self._status_display.display()
-				if previous_count != len(self._poll_event_queue):
-					break
-
-		elif timeout <= self._max_display_latency:
-			PollScheduler._poll(self, timeout=timeout)
-			if timeout == 0:
-				# The display is updated by _schedule() above, so it would be
-				# redundant to update it here when timeout is 0.
-				pass
-			else:
-				self._status_display.display()
-
-		else:
-			remaining_timeout = timeout
-			start_time = time.time()
-			while True:
-				previous_count = len(self._poll_event_queue)
-				PollScheduler._poll(self,
-					timeout=min(self._max_display_latency, remaining_timeout))
-				self._status_display.display()
-				if previous_count != len(self._poll_event_queue):
-					break
-				elapsed_time = time.time() - start_time
-				if elapsed_time < 0:
-					# The system clock has changed such that start_time
-					# is now in the future, so just assume that the
-					# timeout has already elapsed.
-					break
-				remaining_timeout = timeout - 1000 * elapsed_time
-				if remaining_timeout <= 0:
-					break
-
-	def _set_max_jobs(self, max_jobs):
-		self._max_jobs = max_jobs
-		self._task_queues.jobs.max_jobs = max_jobs
-		if "parallel-install" in self.settings.features:
-			self._task_queues.merge.max_jobs = max_jobs
-
-	def _background_mode(self):
-		"""
-		Check if background mode is enabled and adjust states as necessary.
-
-		@rtype: bool
-		@returns: True if background mode is enabled, False otherwise.
-		"""
-		background = (self._max_jobs is True or \
-			self._max_jobs > 1 or "--quiet" in self.myopts \
-			or "--quiet-build" in self.myopts) and \
-			not bool(self._opts_no_background.intersection(self.myopts))
-
-		if background:
-			interactive_tasks = self._get_interactive_tasks()
-			if interactive_tasks:
-				background = False
-				writemsg_level(">>> Sending package output to stdio due " + \
-					"to interactive package(s):\n",
-					level=logging.INFO, noiselevel=-1)
-				msg = [""]
-				for pkg in interactive_tasks:
-					pkg_str = "  " + colorize("INFORM", str(pkg.cpv))
-					if pkg.root != "/":
-						pkg_str += " for " + pkg.root
-					msg.append(pkg_str)
-				msg.append("")
-				writemsg_level("".join("%s\n" % (l,) for l in msg),
-					level=logging.INFO, noiselevel=-1)
-				if self._max_jobs is True or self._max_jobs > 1:
-					self._set_max_jobs(1)
-					writemsg_level(">>> Setting --jobs=1 due " + \
-						"to the above interactive package(s)\n",
-						level=logging.INFO, noiselevel=-1)
-					writemsg_level(">>> In order to temporarily mask " + \
-						"interactive updates, you may\n" + \
-						">>> specify --accept-properties=-interactive\n",
-						level=logging.INFO, noiselevel=-1)
-		self._status_display.quiet = \
-			not background or \
-			("--quiet" in self.myopts and \
-			"--verbose" not in self.myopts)
-
-		self._logger.xterm_titles = \
-			"notitles" not in self.settings.features and \
-			self._status_display.quiet
-
-		return background
-
-	def _get_interactive_tasks(self):
-		interactive_tasks = []
-		for task in self._mergelist:
-			if not (isinstance(task, Package) and \
-				task.operation == "merge"):
-				continue
-			if 'interactive' in task.metadata.properties:
-				interactive_tasks.append(task)
-		return interactive_tasks
-
-	def _set_graph_config(self, graph_config):
-
-		if graph_config is None:
-			self._graph_config = None
-			self._pkg_cache = {}
-			self._digraph = None
-			self._mergelist = []
-			self._deep_system_deps.clear()
-			return
-
-		self._graph_config = graph_config
-		self._pkg_cache = graph_config.pkg_cache
-		self._digraph = graph_config.graph
-		self._mergelist = graph_config.mergelist
-
-		if "--nodeps" in self.myopts or \
-			(self._max_jobs is not True and self._max_jobs < 2):
-			# save some memory
-			self._digraph = None
-			graph_config.graph = None
-			graph_config.pkg_cache.clear()
-			self._deep_system_deps.clear()
-			for pkg in self._mergelist:
-				self._pkg_cache[pkg] = pkg
-			return
-
-		self._find_system_deps()
-		self._prune_digraph()
-		self._prevent_builddir_collisions()
-		if '--debug' in self.myopts:
-			writemsg("\nscheduler digraph:\n\n", noiselevel=-1)
-			self._digraph.debug_print()
-			writemsg("\n", noiselevel=-1)
-
-	def _find_system_deps(self):
-		"""
-		Find system packages and their deep runtime dependencies. Before being
-		merged, these packages go to merge_wait_queue, to be merged when no
-		other packages are building.
-		NOTE: This can only find deep system deps if the system set has been
-		added to the graph and traversed deeply (the depgraph "complete"
-		parameter will do this, triggered by emerge --complete-graph option).
-		"""
-		deep_system_deps = self._deep_system_deps
-		deep_system_deps.clear()
-		deep_system_deps.update(
-			_find_deep_system_runtime_deps(self._digraph))
-		deep_system_deps.difference_update([pkg for pkg in \
-			deep_system_deps if pkg.operation != "merge"])
-
-	def _prune_digraph(self):
-		"""
-		Prune any root nodes that are irrelevant.
-		"""
-
-		graph = self._digraph
-		completed_tasks = self._completed_tasks
-		removed_nodes = set()
-		while True:
-			for node in graph.root_nodes():
-				if not isinstance(node, Package) or \
-					(node.installed and node.operation == "nomerge") or \
-					node.onlydeps or \
-					node in completed_tasks:
-					removed_nodes.add(node)
-			if removed_nodes:
-				graph.difference_update(removed_nodes)
-			if not removed_nodes:
-				break
-			removed_nodes.clear()
-
-	def _prevent_builddir_collisions(self):
-		"""
-		When building stages, sometimes the same exact cpv needs to be merged
-		to both $ROOTs. Add edges to the digraph in order to avoid collisions
-		in the builddir. Currently, normal file locks would be inappropriate
-		for this purpose since emerge holds all of it's build dir locks from
-		the main process.
-		"""
-		cpv_map = {}
-		for pkg in self._mergelist:
-			if not isinstance(pkg, Package):
-				# a satisfied blocker
-				continue
-			if pkg.installed:
-				continue
-			if pkg.cpv not in cpv_map:
-				cpv_map[pkg.cpv] = [pkg]
-				continue
-			for earlier_pkg in cpv_map[pkg.cpv]:
-				self._digraph.add(earlier_pkg, pkg,
-					priority=DepPriority(buildtime=True))
-			cpv_map[pkg.cpv].append(pkg)
-
-	class _pkg_failure(portage.exception.PortageException):
-		"""
-		An instance of this class is raised by unmerge() when
-		an uninstallation fails.
-		"""
-		status = 1
-		def __init__(self, *pargs):
-			portage.exception.PortageException.__init__(self, pargs)
-			if pargs:
-				self.status = pargs[0]
-
-	def _schedule_fetch(self, fetcher):
-		"""
-		Schedule a fetcher, in order to control the number of concurrent
-		fetchers. If self._max_jobs is greater than 1 then the fetch
-		queue is bypassed and the fetcher is started immediately,
-		otherwise it is added to the front of the parallel-fetch queue.
-		NOTE: The parallel-fetch queue is currently used to serialize
-		access to the parallel-fetch log, so changes in the log handling
-		would be required before it would be possible to enable
-		concurrent fetching within the parallel-fetch queue.
-		"""
-		if self._max_jobs > 1:
-			fetcher.start()
-		else:
-			self._task_queues.fetch.addFront(fetcher)
-
-	def _schedule_setup(self, setup_phase):
-		"""
-		Schedule a setup phase on the merge queue, in order to
-		serialize unsandboxed access to the live filesystem.
-		"""
-		if self._task_queues.merge.max_jobs > 1 and \
-			"ebuild-locks" in self.settings.features:
-			# Use a separate queue for ebuild-locks when the merge
-			# queue allows more than 1 job (due to parallel-install),
-			# since the portage.locks module does not behave as desired
-			# if we try to lock the same file multiple times
-			# concurrently from the same process.
-			self._task_queues.ebuild_locks.add(setup_phase)
-		else:
-			self._task_queues.merge.add(setup_phase)
-		self._schedule()
-
-	def _schedule_unpack(self, unpack_phase):
-		"""
-		Schedule an unpack phase on the unpack queue, in order
-		to serialize $DISTDIR access for live ebuilds.
-		"""
-		self._task_queues.unpack.add(unpack_phase)
-
-	def _find_blockers(self, new_pkg):
-		"""
-		Returns a callable.
-		"""
-		def get_blockers():
-			return self._find_blockers_impl(new_pkg)
-		return get_blockers
-
-	def _find_blockers_impl(self, new_pkg):
-		if self._opts_ignore_blockers.intersection(self.myopts):
-			return None
-
-		blocker_db = self._blocker_db[new_pkg.root]
-
-		blocker_dblinks = []
-		for blocking_pkg in blocker_db.findInstalledBlockers(new_pkg):
-			if new_pkg.slot_atom == blocking_pkg.slot_atom:
-				continue
-			if new_pkg.cpv == blocking_pkg.cpv:
-				continue
-			blocker_dblinks.append(portage.dblink(
-				blocking_pkg.category, blocking_pkg.pf, blocking_pkg.root,
-				self.pkgsettings[blocking_pkg.root], treetype="vartree",
-				vartree=self.trees[blocking_pkg.root]["vartree"]))
-
-		return blocker_dblinks
-
-	def _generate_digests(self):
-		"""
-		Generate digests if necessary for --digests or FEATURES=digest.
-		In order to avoid interference, this must done before parallel
-		tasks are started.
-		"""
-
-		if '--fetchonly' in self.myopts:
-			return os.EX_OK
-
-		digest = '--digest' in self.myopts
-		if not digest:
-			for pkgsettings in self.pkgsettings.values():
-				if pkgsettings.mycpv is not None:
-					# ensure that we are using global features
-					# settings rather than those from package.env
-					pkgsettings.reset()
-				if 'digest' in pkgsettings.features:
-					digest = True
-					break
-
-		if not digest:
-			return os.EX_OK
-
-		for x in self._mergelist:
-			if not isinstance(x, Package) or \
-				x.type_name != 'ebuild' or \
-				x.operation != 'merge':
-				continue
-			pkgsettings = self.pkgsettings[x.root]
-			if pkgsettings.mycpv is not None:
-				# ensure that we are using global features
-				# settings rather than those from package.env
-				pkgsettings.reset()
-			if '--digest' not in self.myopts and \
-				'digest' not in pkgsettings.features:
-				continue
-			portdb = x.root_config.trees['porttree'].dbapi
-			ebuild_path = portdb.findname(x.cpv, myrepo=x.repo)
-			if ebuild_path is None:
-				raise AssertionError("ebuild not found for '%s'" % x.cpv)
-			pkgsettings['O'] = os.path.dirname(ebuild_path)
-			if not digestgen(mysettings=pkgsettings, myportdb=portdb):
-				writemsg_level(
-					"!!! Unable to generate manifest for '%s'.\n" \
-					% x.cpv, level=logging.ERROR, noiselevel=-1)
-				return 1
-
-		return os.EX_OK
-
-	def _env_sanity_check(self):
-		"""
-		Verify a sane environment before trying to build anything from source.
-		"""
-		have_src_pkg = False
-		for x in self._mergelist:
-			if isinstance(x, Package) and not x.built:
-				have_src_pkg = True
-				break
-
-		if not have_src_pkg:
-			return os.EX_OK
-
-		for settings in self.pkgsettings.values():
-			for var in ("ARCH", ):
-				value = settings.get(var)
-				if value and value.strip():
-					continue
-				msg = _("%(var)s is not set... "
-					"Are you missing the '%(configroot)setc/make.profile' symlink? "
-					"Is the symlink correct? "
-					"Is your portage tree complete?") % \
-					{"var": var, "configroot": settings["PORTAGE_CONFIGROOT"]}
-
-				out = portage.output.EOutput()
-				for line in textwrap.wrap(msg, 70):
-					out.eerror(line)
-				return 1
-
-		return os.EX_OK
-
-	def _check_manifests(self):
-		# Verify all the manifests now so that the user is notified of failure
-		# as soon as possible.
-		if "strict" not in self.settings.features or \
-			"--fetchonly" in self.myopts or \
-			"--fetch-all-uri" in self.myopts:
-			return os.EX_OK
-
-		shown_verifying_msg = False
-		quiet_settings = {}
-		for myroot, pkgsettings in self.pkgsettings.items():
-			quiet_config = portage.config(clone=pkgsettings)
-			quiet_config["PORTAGE_QUIET"] = "1"
-			quiet_config.backup_changes("PORTAGE_QUIET")
-			quiet_settings[myroot] = quiet_config
-			del quiet_config
-
-		failures = 0
-
-		for x in self._mergelist:
-			if not isinstance(x, Package) or \
-				x.type_name != "ebuild":
-				continue
-
-			if x.operation == "uninstall":
-				continue
-
-			if not shown_verifying_msg:
-				shown_verifying_msg = True
-				self._status_msg("Verifying ebuild manifests")
-
-			root_config = x.root_config
-			portdb = root_config.trees["porttree"].dbapi
-			quiet_config = quiet_settings[root_config.root]
-			ebuild_path = portdb.findname(x.cpv, myrepo=x.repo)
-			if ebuild_path is None:
-				raise AssertionError("ebuild not found for '%s'" % x.cpv)
-			quiet_config["O"] = os.path.dirname(ebuild_path)
-			if not digestcheck([], quiet_config, strict=True):
-				failures |= 1
-
-		if failures:
-			return 1
-		return os.EX_OK
-
-	def _add_prefetchers(self):
-
-		if not self._parallel_fetch:
-			return
-
-		if self._parallel_fetch:
-			self._status_msg("Starting parallel fetch")
-
-			prefetchers = self._prefetchers
-			getbinpkg = "--getbinpkg" in self.myopts
-
-			for pkg in self._mergelist:
-				# mergelist can contain solved Blocker instances
-				if not isinstance(pkg, Package) or pkg.operation == "uninstall":
-					continue
-				prefetcher = self._create_prefetcher(pkg)
-				if prefetcher is not None:
-					self._task_queues.fetch.add(prefetcher)
-					prefetchers[pkg] = prefetcher
-
-			# Start the first prefetcher immediately so that self._task()
-			# won't discard it. This avoids a case where the first
-			# prefetcher is discarded, causing the second prefetcher to
-			# occupy the fetch queue before the first fetcher has an
-			# opportunity to execute.
-			self._task_queues.fetch.schedule()
-
-	def _create_prefetcher(self, pkg):
-		"""
-		@return: a prefetcher, or None if not applicable
-		"""
-		prefetcher = None
-
-		if not isinstance(pkg, Package):
-			pass
-
-		elif pkg.type_name == "ebuild":
-
-			prefetcher = EbuildFetcher(background=True,
-				config_pool=self._ConfigPool(pkg.root,
-				self._allocate_config, self._deallocate_config),
-				fetchonly=1, logfile=self._fetch_log,
-				pkg=pkg, prefetch=True, scheduler=self._sched_iface)
-
-		elif pkg.type_name == "binary" and \
-			"--getbinpkg" in self.myopts and \
-			pkg.root_config.trees["bintree"].isremote(pkg.cpv):
-
-			prefetcher = BinpkgPrefetcher(background=True,
-				pkg=pkg, scheduler=self._sched_iface)
-
-		return prefetcher
-
-	def _is_restart_scheduled(self):
-		"""
-		Check if the merge list contains a replacement
-		for the current running instance, that will result
-		in restart after merge.
-		@rtype: bool
-		@returns: True if a restart is scheduled, False otherwise.
-		"""
-		if self._opts_no_restart.intersection(self.myopts):
-			return False
-
-		mergelist = self._mergelist
-
-		for i, pkg in enumerate(mergelist):
-			if self._is_restart_necessary(pkg) and \
-				i != len(mergelist) - 1:
-				return True
-
-		return False
-
-	def _is_restart_necessary(self, pkg):
-		"""
-		@return: True if merging the given package
-			requires restart, False otherwise.
-		"""
-
-		# Figure out if we need a restart.
-		if pkg.root == self._running_root.root and \
-			portage.match_from_list(
-			portage.const.PORTAGE_PACKAGE_ATOM, [pkg]):
-			if self._running_portage is None:
-				return True
-			elif pkg.cpv != self._running_portage.cpv or \
-				'9999' in pkg.cpv or \
-				'git' in pkg.inherited or \
-				'git-2' in pkg.inherited:
-				return True
-		return False
-
-	def _restart_if_necessary(self, pkg):
-		"""
-		Use execv() to restart emerge. This happens
-		if portage upgrades itself and there are
-		remaining packages in the list.
-		"""
-
-		if self._opts_no_restart.intersection(self.myopts):
-			return
-
-		if not self._is_restart_necessary(pkg):
-			return
-
-		if pkg == self._mergelist[-1]:
-			return
-
-		self._main_loop_cleanup()
-
-		logger = self._logger
-		pkg_count = self._pkg_count
-		mtimedb = self._mtimedb
-		bad_resume_opts = self._bad_resume_opts
-
-		logger.log(" ::: completed emerge (%s of %s) %s to %s" % \
-			(pkg_count.curval, pkg_count.maxval, pkg.cpv, pkg.root))
-
-		logger.log(" *** RESTARTING " + \
-			"emerge via exec() after change of " + \
-			"portage version.")
-
-		mtimedb["resume"]["mergelist"].remove(list(pkg))
-		mtimedb.commit()
-		portage.run_exitfuncs()
-		# Don't trust sys.argv[0] here because eselect-python may modify it.
-		emerge_binary = os.path.join(portage.const.PORTAGE_BIN_PATH, 'emerge')
-		mynewargv = [emerge_binary, "--resume"]
-		resume_opts = self.myopts.copy()
-		# For automatic resume, we need to prevent
-		# any of bad_resume_opts from leaking in
-		# via EMERGE_DEFAULT_OPTS.
-		resume_opts["--ignore-default-opts"] = True
-		for myopt, myarg in resume_opts.items():
-			if myopt not in bad_resume_opts:
-				if myarg is True:
-					mynewargv.append(myopt)
-				elif isinstance(myarg, list):
-					# arguments like --exclude that use 'append' action
-					for x in myarg:
-						mynewargv.append("%s=%s" % (myopt, x))
-				else:
-					mynewargv.append("%s=%s" % (myopt, myarg))
-		# priority only needs to be adjusted on the first run
-		os.environ["PORTAGE_NICENESS"] = "0"
-		os.execv(mynewargv[0], mynewargv)
-
-	def _run_pkg_pretend(self):
-		"""
-		Since pkg_pretend output may be important, this method sends all
-		output directly to stdout (regardless of options like --quiet or
-		--jobs).
-		"""
-
-		failures = 0
-
-		# Use a local PollScheduler instance here, since we don't
-		# want tasks here to trigger the usual Scheduler callbacks
-		# that handle job scheduling and status display.
-		sched_iface = PollScheduler().sched_iface
-
-		for x in self._mergelist:
-			if not isinstance(x, Package):
-				continue
-
-			if x.operation == "uninstall":
-				continue
-
-			if x.metadata["EAPI"] in ("0", "1", "2", "3"):
-				continue
-
-			if "pretend" not in x.metadata.defined_phases:
-				continue
-
-			out_str =">>> Running pre-merge checks for " + colorize("INFORM", x.cpv) + "\n"
-			portage.util.writemsg_stdout(out_str, noiselevel=-1)
-
-			root_config = x.root_config
-			settings = self.pkgsettings[root_config.root]
-			settings.setcpv(x)
-			tmpdir = tempfile.mkdtemp()
-			tmpdir_orig = settings["PORTAGE_TMPDIR"]
-			settings["PORTAGE_TMPDIR"] = tmpdir
-
-			try:
-				if x.built:
-					tree = "bintree"
-					bintree = root_config.trees["bintree"].dbapi.bintree
-					fetched = False
-
-					# Display fetch on stdout, so that it's always clear what
-					# is consuming time here.
-					if bintree.isremote(x.cpv):
-						fetcher = BinpkgFetcher(pkg=x,
-							scheduler=sched_iface)
-						fetcher.start()
-						if fetcher.wait() != os.EX_OK:
-							failures += 1
-							continue
-						fetched = fetcher.pkg_path
-
-					verifier = BinpkgVerifier(pkg=x,
-						scheduler=sched_iface)
-					verifier.start()
-					if verifier.wait() != os.EX_OK:
-						failures += 1
-						continue
-
-					if fetched:
-						bintree.inject(x.cpv, filename=fetched)
-					tbz2_file = bintree.getname(x.cpv)
-					infloc = os.path.join(tmpdir, x.category, x.pf, "build-info")
-					os.makedirs(infloc)
-					portage.xpak.tbz2(tbz2_file).unpackinfo(infloc)
-					ebuild_path = os.path.join(infloc, x.pf + ".ebuild")
-					settings.configdict["pkg"]["EMERGE_FROM"] = "binary"
-					settings.configdict["pkg"]["MERGE_TYPE"] = "binary"
-
-				else:
-					tree = "porttree"
-					portdb = root_config.trees["porttree"].dbapi
-					ebuild_path = portdb.findname(x.cpv, myrepo=x.repo)
-					if ebuild_path is None:
-						raise AssertionError("ebuild not found for '%s'" % x.cpv)
-					settings.configdict["pkg"]["EMERGE_FROM"] = "ebuild"
-					if self._build_opts.buildpkgonly:
-						settings.configdict["pkg"]["MERGE_TYPE"] = "buildonly"
-					else:
-						settings.configdict["pkg"]["MERGE_TYPE"] = "source"
-
-				portage.package.ebuild.doebuild.doebuild_environment(ebuild_path,
-					"pretend", settings=settings,
-					db=self.trees[settings["ROOT"]][tree].dbapi)
-				prepare_build_dirs(root_config.root, settings, cleanup=0)
-
-				vardb = root_config.trees['vartree'].dbapi
-				settings["REPLACING_VERSIONS"] = " ".join(
-					set(portage.versions.cpv_getversion(match) \
-						for match in vardb.match(x.slot_atom) + \
-						vardb.match('='+x.cpv)))
-				pretend_phase = EbuildPhase(
-					phase="pretend", scheduler=sched_iface,
-					settings=settings)
-
-				pretend_phase.start()
-				ret = pretend_phase.wait()
-				if ret != os.EX_OK:
-					failures += 1
-				portage.elog.elog_process(x.cpv, settings)
-			finally:
-				shutil.rmtree(tmpdir)
-				settings["PORTAGE_TMPDIR"] = tmpdir_orig
-
-		if failures:
-			return 1
-		return os.EX_OK
-
-	def merge(self):
-		if "--resume" in self.myopts:
-			# We're resuming.
-			portage.writemsg_stdout(
-				colorize("GOOD", "*** Resuming merge...\n"), noiselevel=-1)
-			self._logger.log(" *** Resuming merge...")
-
-		self._save_resume_list()
-
-		try:
-			self._background = self._background_mode()
-		except self._unknown_internal_error:
-			return 1
-
-		for root in self.trees:
-			root_config = self.trees[root]["root_config"]
-
-			# Even for --pretend --fetch mode, PORTAGE_TMPDIR is required
-			# since it might spawn pkg_nofetch which requires PORTAGE_BUILDDIR
-			# for ensuring sane $PWD (bug #239560) and storing elog messages.
-			tmpdir = root_config.settings.get("PORTAGE_TMPDIR", "")
-			if not tmpdir or not os.path.isdir(tmpdir):
-				msg = "The directory specified in your " + \
-					"PORTAGE_TMPDIR variable, '%s', " % tmpdir + \
-				"does not exist. Please create this " + \
-				"directory or correct your PORTAGE_TMPDIR setting."
-				msg = textwrap.wrap(msg, 70)
-				out = portage.output.EOutput()
-				for l in msg:
-					out.eerror(l)
-				return 1
-
-			if self._background:
-				root_config.settings.unlock()
-				root_config.settings["PORTAGE_BACKGROUND"] = "1"
-				root_config.settings.backup_changes("PORTAGE_BACKGROUND")
-				root_config.settings.lock()
-
-			self.pkgsettings[root] = portage.config(
-				clone=root_config.settings)
-
-		keep_going = "--keep-going" in self.myopts
-		fetchonly = self._build_opts.fetchonly
-		mtimedb = self._mtimedb
-		failed_pkgs = self._failed_pkgs
-
-		rval = self._generate_digests()
-		if rval != os.EX_OK:
-			return rval
-
-		rval = self._env_sanity_check()
-		if rval != os.EX_OK:
-			return rval
-
-		# TODO: Immediately recalculate deps here if --keep-going
-		#       is enabled and corrupt manifests are detected.
-		rval = self._check_manifests()
-		if rval != os.EX_OK and not keep_going:
-			return rval
-
-		if not fetchonly:
-			rval = self._run_pkg_pretend()
-			if rval != os.EX_OK:
-				return rval
-
-		while True:
-
-			received_signal = []
-
-			def sighandler(signum, frame):
-				signal.signal(signal.SIGINT, signal.SIG_IGN)
-				signal.signal(signal.SIGTERM, signal.SIG_IGN)
-				portage.util.writemsg("\n\nExiting on signal %(signal)s\n" % \
-					{"signal":signum})
-				self.terminate()
-				received_signal.append(128 + signum)
-
-			earlier_sigint_handler = signal.signal(signal.SIGINT, sighandler)
-			earlier_sigterm_handler = signal.signal(signal.SIGTERM, sighandler)
-
-			try:
-				rval = self._merge()
-			finally:
-				# Restore previous handlers
-				if earlier_sigint_handler is not None:
-					signal.signal(signal.SIGINT, earlier_sigint_handler)
-				else:
-					signal.signal(signal.SIGINT, signal.SIG_DFL)
-				if earlier_sigterm_handler is not None:
-					signal.signal(signal.SIGTERM, earlier_sigterm_handler)
-				else:
-					signal.signal(signal.SIGTERM, signal.SIG_DFL)
-
-			if received_signal:
-				sys.exit(received_signal[0])
-
-			if rval == os.EX_OK or fetchonly or not keep_going:
-				break
-			if "resume" not in mtimedb:
-				break
-			mergelist = self._mtimedb["resume"].get("mergelist")
-			if not mergelist:
-				break
-
-			if not failed_pkgs:
-				break
-
-			for failed_pkg in failed_pkgs:
-				mergelist.remove(list(failed_pkg.pkg))
-
-			self._failed_pkgs_all.extend(failed_pkgs)
-			del failed_pkgs[:]
-
-			if not mergelist:
-				break
-
-			if not self._calc_resume_list():
-				break
-
-			clear_caches(self.trees)
-			if not self._mergelist:
-				break
-
-			self._save_resume_list()
-			self._pkg_count.curval = 0
-			self._pkg_count.maxval = len([x for x in self._mergelist \
-				if isinstance(x, Package) and x.operation == "merge"])
-			self._status_display.maxval = self._pkg_count.maxval
-
-		self._logger.log(" *** Finished. Cleaning up...")
-
-		if failed_pkgs:
-			self._failed_pkgs_all.extend(failed_pkgs)
-			del failed_pkgs[:]
-
-		printer = portage.output.EOutput()
-		background = self._background
-		failure_log_shown = False
-		if background and len(self._failed_pkgs_all) == 1:
-			# If only one package failed then just show it's
-			# whole log for easy viewing.
-			failed_pkg = self._failed_pkgs_all[-1]
-			build_dir = failed_pkg.build_dir
-			log_file = None
-			log_file_real = None
-
-			log_paths = [failed_pkg.build_log]
-
-			log_path = self._locate_failure_log(failed_pkg)
-			if log_path is not None:
-				try:
-					log_file = open(_unicode_encode(log_path,
-						encoding=_encodings['fs'], errors='strict'), mode='rb')
-				except IOError:
-					pass
-				else:
-					if log_path.endswith('.gz'):
-						log_file_real = log_file
-						log_file =  gzip.GzipFile(filename='',
-							mode='rb', fileobj=log_file)
-
-			if log_file is not None:
-				try:
-					for line in log_file:
-						writemsg_level(line, noiselevel=-1)
-				except zlib.error as e:
-					writemsg_level("%s\n" % (e,), level=logging.ERROR,
-						noiselevel=-1)
-				finally:
-					log_file.close()
-					if log_file_real is not None:
-						log_file_real.close()
-				failure_log_shown = True
-
-		# Dump mod_echo output now since it tends to flood the terminal.
-		# This allows us to avoid having more important output, generated
-		# later, from being swept away by the mod_echo output.
-		mod_echo_output =  _flush_elog_mod_echo()
-
-		if background and not failure_log_shown and \
-			self._failed_pkgs_all and \
-			self._failed_pkgs_die_msgs and \
-			not mod_echo_output:
-
-			for mysettings, key, logentries in self._failed_pkgs_die_msgs:
-				root_msg = ""
-				if mysettings["ROOT"] != "/":
-					root_msg = " merged to %s" % mysettings["ROOT"]
-				print()
-				printer.einfo("Error messages for package %s%s:" % \
-					(colorize("INFORM", key), root_msg))
-				print()
-				for phase in portage.const.EBUILD_PHASES:
-					if phase not in logentries:
-						continue
-					for msgtype, msgcontent in logentries[phase]:
-						if isinstance(msgcontent, basestring):
-							msgcontent = [msgcontent]
-						for line in msgcontent:
-							printer.eerror(line.strip("\n"))
-
-		if self._post_mod_echo_msgs:
-			for msg in self._post_mod_echo_msgs:
-				msg()
-
-		if len(self._failed_pkgs_all) > 1 or \
-			(self._failed_pkgs_all and keep_going):
-			if len(self._failed_pkgs_all) > 1:
-				msg = "The following %d packages have " % \
-					len(self._failed_pkgs_all) + \
-					"failed to build or install:"
-			else:
-				msg = "The following package has " + \
-					"failed to build or install:"
-
-			printer.eerror("")
-			for line in textwrap.wrap(msg, 72):
-				printer.eerror(line)
-			printer.eerror("")
-			for failed_pkg in self._failed_pkgs_all:
-				# Use _unicode_decode() to force unicode format string so
-				# that Package.__unicode__() is called in python2.
-				msg = _unicode_decode(" %s") % (failed_pkg.pkg,)
-				log_path = self._locate_failure_log(failed_pkg)
-				if log_path is not None:
-					msg += ", Log file:"
-				printer.eerror(msg)
-				if log_path is not None:
-					printer.eerror("  '%s'" % colorize('INFORM', log_path))
-			printer.eerror("")
-
-		if self._failed_pkgs_all:
-			return 1
-		return os.EX_OK
-
-	def _elog_listener(self, mysettings, key, logentries, fulltext):
-		errors = portage.elog.filter_loglevels(logentries, ["ERROR"])
-		if errors:
-			self._failed_pkgs_die_msgs.append(
-				(mysettings, key, errors))
-
-	def _locate_failure_log(self, failed_pkg):
-
-		build_dir = failed_pkg.build_dir
-		log_file = None
-
-		log_paths = [failed_pkg.build_log]
-
-		for log_path in log_paths:
-			if not log_path:
-				continue
-
-			try:
-				log_size = os.stat(log_path).st_size
-			except OSError:
-				continue
-
-			if log_size == 0:
-				continue
-
-			return log_path
-
-		return None
-
-	def _add_packages(self):
-		pkg_queue = self._pkg_queue
-		for pkg in self._mergelist:
-			if isinstance(pkg, Package):
-				pkg_queue.append(pkg)
-			elif isinstance(pkg, Blocker):
-				pass
-
-	def _system_merge_started(self, merge):
-		"""
-		Add any unsatisfied runtime deps to self._unsatisfied_system_deps.
-		In general, this keeps track of installed system packages with
-		unsatisfied RDEPEND or PDEPEND (circular dependencies). It can be
-		a fragile situation, so we don't execute any unrelated builds until
-		the circular dependencies are built and installed.
-		"""
-		graph = self._digraph
-		if graph is None:
-			return
-		pkg = merge.merge.pkg
-
-		# Skip this if $ROOT != / since it shouldn't matter if there
-		# are unsatisfied system runtime deps in this case.
-		if pkg.root != '/':
-			return
-
-		completed_tasks = self._completed_tasks
-		unsatisfied = self._unsatisfied_system_deps
-
-		def ignore_non_runtime_or_satisfied(priority):
-			"""
-			Ignore non-runtime and satisfied runtime priorities.
-			"""
-			if isinstance(priority, DepPriority) and \
-				not priority.satisfied and \
-				(priority.runtime or priority.runtime_post):
-				return False
-			return True
-
-		# When checking for unsatisfied runtime deps, only check
-		# direct deps since indirect deps are checked when the
-		# corresponding parent is merged.
-		for child in graph.child_nodes(pkg,
-			ignore_priority=ignore_non_runtime_or_satisfied):
-			if not isinstance(child, Package) or \
-				child.operation == 'uninstall':
-				continue
-			if child is pkg:
-				continue
-			if child.operation == 'merge' and \
-				child not in completed_tasks:
-				unsatisfied.add(child)
-
-	def _merge_wait_exit_handler(self, task):
-		self._merge_wait_scheduled.remove(task)
-		self._merge_exit(task)
-
-	def _merge_exit(self, merge):
-		self._running_tasks.pop(id(merge), None)
-		self._do_merge_exit(merge)
-		self._deallocate_config(merge.merge.settings)
-		if merge.returncode == os.EX_OK and \
-			not merge.merge.pkg.installed:
-			self._status_display.curval += 1
-		self._status_display.merges = len(self._task_queues.merge)
-		self._schedule()
-
-	def _do_merge_exit(self, merge):
-		pkg = merge.merge.pkg
-		settings = merge.merge.settings
-		trees = self.trees
-		init_buildlog = gobs_buildlog()
-		if merge.returncode != os.EX_OK:
-			build_dir = settings.get("PORTAGE_BUILDDIR")
-			build_log = settings.get("PORTAGE_LOG_FILE")
-
-			self._failed_pkgs.append(self._failed_pkg(
-				build_dir=build_dir, build_log=build_log,
-				pkg=pkg,
-				returncode=merge.returncode))
-			if not self._terminated_tasks:
-				self._failed_pkg_msg(self._failed_pkgs[-1], "install", "to")
-				self._status_display.failed = len(self._failed_pkgs)
-			init_buildlog.add_buildlog_main(settings, pkg, trees)
-			return
-
-		self._task_complete(pkg)
-		pkg_to_replace = merge.merge.pkg_to_replace
-		if pkg_to_replace is not None:
-			# When a package is replaced, mark it's uninstall
-			# task complete (if any).
-			if self._digraph is not None and \
-				pkg_to_replace in self._digraph:
-				try:
-					self._pkg_queue.remove(pkg_to_replace)
-				except ValueError:
-					pass
-				self._task_complete(pkg_to_replace)
-			else:
-				self._pkg_cache.pop(pkg_to_replace, None)
-
-		if pkg.installed:
-			init_buildlog.add_buildlog_main(settings, pkg, trees)
-			return
-
-		self._restart_if_necessary(pkg)
-
-		# Call mtimedb.commit() after each merge so that
-		# --resume still works after being interrupted
-		# by reboot, sigkill or similar.
-		mtimedb = self._mtimedb
-		mtimedb["resume"]["mergelist"].remove(list(pkg))
-		if not mtimedb["resume"]["mergelist"]:
-			del mtimedb["resume"]
-		mtimedb.commit()
-		init_buildlog.add_buildlog_main(settings, pkg, trees)
-
-	def _build_exit(self, build):
-		self._running_tasks.pop(id(build), None)
-		if build.returncode == os.EX_OK and self._terminated_tasks:
-			# We've been interrupted, so we won't
-			# add this to the merge queue.
-			self.curval += 1
-			self._deallocate_config(build.settings)
-		elif build.returncode == os.EX_OK:
-			self.curval += 1
-			merge = PackageMerge(merge=build)
-			self._running_tasks[id(merge)] = merge
-			if not build.build_opts.buildpkgonly and \
-				build.pkg in self._deep_system_deps:
-				# Since dependencies on system packages are frequently
-				# unspecified, merge them only when no builds are executing.
-				self._merge_wait_queue.append(merge)
-				merge.addStartListener(self._system_merge_started)
-			else:
-				merge.addExitListener(self._merge_exit)
-				self._task_queues.merge.add(merge)
-				self._status_display.merges = len(self._task_queues.merge)
-		else:
-			settings = build.settings
-			trees = self.trees
-			pkg=build.pkg
-			init_buildlog = gobs_buildlog()
-			build_dir = settings.get("PORTAGE_BUILDDIR")
-			build_log = settings.get("PORTAGE_LOG_FILE")
-
-			self._failed_pkgs.append(self._failed_pkg(
-				build_dir=build_dir, build_log=build_log,
-				pkg=pkg, returncode=build.returncode))
-			if not self._terminated_tasks:
-				self._failed_pkg_msg(self._failed_pkgs[-1], "emerge", "for")
-				self._status_display.failed = len(self._failed_pkgs)
-			self._deallocate_config(build.settings)
-			init_buildlog.add_buildlog_main(settings, pkg, trees)
-		self._jobs -= 1
-		self._status_display.running = self._jobs
-		self._schedule()
-
-	def _extract_exit(self, build):
-		self._build_exit(build)
-
-	def _task_complete(self, pkg):
-		self._completed_tasks.add(pkg)
-		self._unsatisfied_system_deps.discard(pkg)
-		self._choose_pkg_return_early = False
-		blocker_db = self._blocker_db[pkg.root]
-		blocker_db.discardBlocker(pkg)
-
-	def _merge(self):
-
-		self._add_prefetchers()
-		self._add_packages()
-		pkg_queue = self._pkg_queue
-		failed_pkgs = self._failed_pkgs
-		portage.locks._quiet = self._background
-		portage.elog.add_listener(self._elog_listener)
-		rval = os.EX_OK
-
-		try:
-			self._main_loop()
-		finally:
-			self._main_loop_cleanup()
-			portage.locks._quiet = False
-			portage.elog.remove_listener(self._elog_listener)
-			if failed_pkgs:
-				rval = failed_pkgs[-1].returncode
-
-		return rval
-
-	def _main_loop_cleanup(self):
-		del self._pkg_queue[:]
-		self._completed_tasks.clear()
-		self._deep_system_deps.clear()
-		self._unsatisfied_system_deps.clear()
-		self._choose_pkg_return_early = False
-		self._status_display.reset()
-		self._digraph = None
-		self._task_queues.fetch.clear()
-		self._prefetchers.clear()
-
-	def _choose_pkg(self):
-		"""
-		Choose a task that has all its dependencies satisfied. This is used
-		for parallel build scheduling, and ensures that we don't build
-		anything with deep dependencies that have yet to be merged.
-		"""
-
-		if self._choose_pkg_return_early:
-			return None
-
-		if self._digraph is None:
-			if self._is_work_scheduled() and \
-				not ("--nodeps" in self.myopts and \
-				(self._max_jobs is True or self._max_jobs > 1)):
-				self._choose_pkg_return_early = True
-				return None
-			return self._pkg_queue.pop(0)
-
-		if not self._is_work_scheduled():
-			return self._pkg_queue.pop(0)
-
-		self._prune_digraph()
-
-		chosen_pkg = None
-
-		# Prefer uninstall operations when available.
-		graph = self._digraph
-		for pkg in self._pkg_queue:
-			if pkg.operation == 'uninstall' and \
-				not graph.child_nodes(pkg):
-				chosen_pkg = pkg
-				break
-
-		if chosen_pkg is None:
-			later = set(self._pkg_queue)
-			for pkg in self._pkg_queue:
-				later.remove(pkg)
-				if not self._dependent_on_scheduled_merges(pkg, later):
-					chosen_pkg = pkg
-					break
-
-		if chosen_pkg is not None:
-			self._pkg_queue.remove(chosen_pkg)
-
-		if chosen_pkg is None:
-			# There's no point in searching for a package to
-			# choose until at least one of the existing jobs
-			# completes.
-			self._choose_pkg_return_early = True
-
-		return chosen_pkg
-
-	def _dependent_on_scheduled_merges(self, pkg, later):
-		"""
-		Traverse the subgraph of the given packages deep dependencies
-		to see if it contains any scheduled merges.
-		@param pkg: a package to check dependencies for
-		@type pkg: Package
-		@param later: packages for which dependence should be ignored
-			since they will be merged later than pkg anyway and therefore
-			delaying the merge of pkg will not result in a more optimal
-			merge order
-		@type later: set
-		@rtype: bool
-		@returns: True if the package is dependent, False otherwise.
-		"""
-
-		graph = self._digraph
-		completed_tasks = self._completed_tasks
-
-		dependent = False
-		traversed_nodes = set([pkg])
-		direct_deps = graph.child_nodes(pkg)
-		node_stack = direct_deps
-		direct_deps = frozenset(direct_deps)
-		while node_stack:
-			node = node_stack.pop()
-			if node in traversed_nodes:
-				continue
-			traversed_nodes.add(node)
-			if not ((node.installed and node.operation == "nomerge") or \
-				(node.operation == "uninstall" and \
-				node not in direct_deps) or \
-				node in completed_tasks or \
-				node in later):
-				dependent = True
-				break
-
-			# Don't traverse children of uninstall nodes since
-			# those aren't dependencies in the usual sense.
-			if node.operation != "uninstall":
-				node_stack.extend(graph.child_nodes(node))
-
-		return dependent
-
-	def _allocate_config(self, root):
-		"""
-		Allocate a unique config instance for a task in order
-		to prevent interference between parallel tasks.
-		"""
-		if self._config_pool[root]:
-			temp_settings = self._config_pool[root].pop()
-		else:
-			temp_settings = portage.config(clone=self.pkgsettings[root])
-		# Since config.setcpv() isn't guaranteed to call config.reset() due to
-		# performance reasons, call it here to make sure all settings from the
-		# previous package get flushed out (such as PORTAGE_LOG_FILE).
-		temp_settings.reload()
-		temp_settings.reset()
-		return temp_settings
-
-	def _deallocate_config(self, settings):
-		self._config_pool[settings["ROOT"]].append(settings)
-
-	def _main_loop(self):
-
-		# Only allow 1 job max if a restart is scheduled
-		# due to portage update.
-		if self._is_restart_scheduled() or \
-			self._opts_no_background.intersection(self.myopts):
-			self._set_max_jobs(1)
-
-		while self._schedule():
-			self._poll_loop()
-
-		while True:
-			self._schedule()
-			if not self._is_work_scheduled():
-				break
-			self._poll_loop()
-
-	def _keep_scheduling(self):
-		return bool(not self._terminated_tasks and self._pkg_queue and \
-			not (self._failed_pkgs and not self._build_opts.fetchonly))
-
-	def _is_work_scheduled(self):
-		return bool(self._running_tasks)
-
-	def _schedule_tasks(self):
-
-		while True:
-
-			# When the number of jobs and merges drops to zero,
-			# process a single merge from _merge_wait_queue if
-			# it's not empty. We only process one since these are
-			# special packages and we want to ensure that
-			# parallel-install does not cause more than one of
-			# them to install at the same time.
-			if (self._merge_wait_queue and not self._jobs and
-				not self._task_queues.merge):
-				task = self._merge_wait_queue.popleft()
-				task.addExitListener(self._merge_wait_exit_handler)
-				self._task_queues.merge.add(task)
-				self._status_display.merges = len(self._task_queues.merge)
-				self._merge_wait_scheduled.append(task)
-
-			self._schedule_tasks_imp()
-			self._status_display.display()
-
-			state_change = 0
-			for q in self._task_queues.values():
-				if q.schedule():
-					state_change += 1
-
-			# Cancel prefetchers if they're the only reason
-			# the main poll loop is still running.
-			if self._failed_pkgs and not self._build_opts.fetchonly and \
-				not self._is_work_scheduled() and \
-				self._task_queues.fetch:
-				self._task_queues.fetch.clear()
-				state_change += 1
-
-			if not (state_change or \
-				(self._merge_wait_queue and not self._jobs and
-				not self._task_queues.merge)):
-				break
-
-		return self._keep_scheduling()
-
-	def _job_delay(self):
-		"""
-		@rtype: bool
-		@returns: True if job scheduling should be delayed, False otherwise.
-		"""
-
-		if self._jobs and self._max_load is not None:
-
-			current_time = time.time()
-
-			delay = self._job_delay_factor * self._jobs ** self._job_delay_exp
-			if delay > self._job_delay_max:
-				delay = self._job_delay_max
-			if (current_time - self._previous_job_start_time) < delay:
-				return True
-
-		return False
-
-	def _schedule_tasks_imp(self):
-		"""
-		@rtype: bool
-		@returns: True if state changed, False otherwise.
-		"""
-
-		state_change = 0
-
-		while True:
-
-			if not self._keep_scheduling():
-				return bool(state_change)
-
-			if self._choose_pkg_return_early or \
-				self._merge_wait_scheduled or \
-				(self._jobs and self._unsatisfied_system_deps) or \
-				not self._can_add_job() or \
-				self._job_delay():
-				return bool(state_change)
-
-			pkg = self._choose_pkg()
-			if pkg is None:
-				return bool(state_change)
-
-			state_change += 1
-
-			if not pkg.installed:
-				self._pkg_count.curval += 1
-
-			task = self._task(pkg)
-
-			if pkg.installed:
-				merge = PackageMerge(merge=task)
-				self._running_tasks[id(merge)] = merge
-				merge.addExitListener(self._merge_exit)
-				self._task_queues.merge.addFront(merge)
-
-			elif pkg.built:
-				self._jobs += 1
-				self._previous_job_start_time = time.time()
-				self._status_display.running = self._jobs
-				self._running_tasks[id(task)] = task
-				task.addExitListener(self._extract_exit)
-				self._task_queues.jobs.add(task)
-
-			else:
-				self._jobs += 1
-				self._previous_job_start_time = time.time()
-				self._status_display.running = self._jobs
-				self._running_tasks[id(task)] = task
-				task.addExitListener(self._build_exit)
-				self._task_queues.jobs.add(task)
-
-		return bool(state_change)
-
-	def _task(self, pkg):
-
-		pkg_to_replace = None
-		if pkg.operation != "uninstall":
-			vardb = pkg.root_config.trees["vartree"].dbapi
-			previous_cpv = [x for x in vardb.match(pkg.slot_atom) \
-				if portage.cpv_getkey(x) == pkg.cp]
-			if not previous_cpv and vardb.cpv_exists(pkg.cpv):
-				# same cpv, different SLOT
-				previous_cpv = [pkg.cpv]
-			if previous_cpv:
-				previous_cpv = previous_cpv.pop()
-				pkg_to_replace = self._pkg(previous_cpv,
-					"installed", pkg.root_config, installed=True,
-					operation="uninstall")
-
-		prefetcher = self._prefetchers.pop(pkg, None)
-		if prefetcher is not None and not prefetcher.isAlive():
-			try:
-				self._task_queues.fetch._task_queue.remove(prefetcher)
-			except ValueError:
-				pass
-			prefetcher = None
-
-		task = MergeListItem(args_set=self._args_set,
-			background=self._background, binpkg_opts=self._binpkg_opts,
-			build_opts=self._build_opts,
-			config_pool=self._ConfigPool(pkg.root,
-			self._allocate_config, self._deallocate_config),
-			emerge_opts=self.myopts,
-			find_blockers=self._find_blockers(pkg), logger=self._logger,
-			mtimedb=self._mtimedb, pkg=pkg, pkg_count=self._pkg_count.copy(),
-			pkg_to_replace=pkg_to_replace,
-			prefetcher=prefetcher,
-			scheduler=self._sched_iface,
-			settings=self._allocate_config(pkg.root),
-			statusMessage=self._status_msg,
-			world_atom=self._world_atom)
-
-		return task
-
-	def _failed_pkg_msg(self, failed_pkg, action, preposition):
-		pkg = failed_pkg.pkg
-		msg = "%s to %s %s" % \
-			(bad("Failed"), action, colorize("INFORM", pkg.cpv))
-		if pkg.root != "/":
-			msg += " %s %s" % (preposition, pkg.root)
-
-		log_path = self._locate_failure_log(failed_pkg)
-		if log_path is not None:
-			msg += ", Log file:"
-		self._status_msg(msg)
-
-		if log_path is not None:
-			self._status_msg(" '%s'" % (colorize("INFORM", log_path),))
-
-	def _status_msg(self, msg):
-		"""
-		Display a brief status message (no newlines) in the status display.
-		This is called by tasks to provide feedback to the user. This
-		delegates the resposibility of generating \r and \n control characters,
-		to guarantee that lines are created or erased when necessary and
-		appropriate.
-
-		@type msg: str
-		@param msg: a brief status message (no newlines allowed)
-		"""
-		if not self._background:
-			writemsg_level("\n")
-		self._status_display.displayMessage(msg)
-
-	def _save_resume_list(self):
-		"""
-		Do this before verifying the ebuild Manifests since it might
-		be possible for the user to use --resume --skipfirst get past
-		a non-essential package with a broken digest.
-		"""
-		mtimedb = self._mtimedb
-
-		mtimedb["resume"] = {}
-		# Stored as a dict starting with portage-2.1.6_rc1, and supported
-		# by >=portage-2.1.3_rc8. Versions <portage-2.1.3_rc8 only support
-		# a list type for options.
-		mtimedb["resume"]["myopts"] = self.myopts.copy()
-
-		# Convert Atom instances to plain str.
-		mtimedb["resume"]["favorites"] = [str(x) for x in self._favorites]
-		mtimedb["resume"]["mergelist"] = [list(x) \
-			for x in self._mergelist \
-			if isinstance(x, Package) and x.operation == "merge"]
-
-		mtimedb.commit()
-
-	def _calc_resume_list(self):
-		"""
-		Use the current resume list to calculate a new one,
-		dropping any packages with unsatisfied deps.
-		@rtype: bool
-		@returns: True if successful, False otherwise.
-		"""
-		print(colorize("GOOD", "*** Resuming merge..."))
-
-		# free some memory before creating
-		# the resume depgraph
-		self._destroy_graph()
-
-		myparams = create_depgraph_params(self.myopts, None)
-		success = False
-		e = None
-		try:
-			success, mydepgraph, dropped_tasks = resume_depgraph(
-				self.settings, self.trees, self._mtimedb, self.myopts,
-				myparams, self._spinner)
-		except depgraph.UnsatisfiedResumeDep as exc:
-			# rename variable to avoid python-3.0 error:
-			# SyntaxError: can not delete variable 'e' referenced in nested
-			#              scope
-			e = exc
-			mydepgraph = e.depgraph
-			dropped_tasks = set()
-
-		if e is not None:
-			def unsatisfied_resume_dep_msg():
-				mydepgraph.display_problems()
-				out = portage.output.EOutput()
-				out.eerror("One or more packages are either masked or " + \
-					"have missing dependencies:")
-				out.eerror("")
-				indent = "  "
-				show_parents = set()
-				for dep in e.value:
-					if dep.parent in show_parents:
-						continue
-					show_parents.add(dep.parent)
-					if dep.atom is None:
-						out.eerror(indent + "Masked package:")
-						out.eerror(2 * indent + str(dep.parent))
-						out.eerror("")
-					else:
-						out.eerror(indent + str(dep.atom) + " pulled in by:")
-						out.eerror(2 * indent + str(dep.parent))
-						out.eerror("")
-				msg = "The resume list contains packages " + \
-					"that are either masked or have " + \
-					"unsatisfied dependencies. " + \
-					"Please restart/continue " + \
-					"the operation manually, or use --skipfirst " + \
-					"to skip the first package in the list and " + \
-					"any other packages that may be " + \
-					"masked or have missing dependencies."
-				for line in textwrap.wrap(msg, 72):
-					out.eerror(line)
-			self._post_mod_echo_msgs.append(unsatisfied_resume_dep_msg)
-			return False
-
-		if success and self._show_list():
-			mylist = mydepgraph.altlist()
-			if mylist:
-				if "--tree" in self.myopts:
-					mylist.reverse()
-				mydepgraph.display(mylist, favorites=self._favorites)
-
-		if not success:
-			self._post_mod_echo_msgs.append(mydepgraph.display_problems)
-			return False
-		mydepgraph.display_problems()
-		self._init_graph(mydepgraph.schedulerGraph())
-
-		msg_width = 75
-		for task in dropped_tasks:
-			if not (isinstance(task, Package) and task.operation == "merge"):
-				continue
-			pkg = task
-			msg = "emerge --keep-going:" + \
-				" %s" % (pkg.cpv,)
-			if pkg.root != "/":
-				msg += " for %s" % (pkg.root,)
-			msg += " dropped due to unsatisfied dependency."
-			for line in textwrap.wrap(msg, msg_width):
-				eerror(line, phase="other", key=pkg.cpv)
-			settings = self.pkgsettings[pkg.root]
-			# Ensure that log collection from $T is disabled inside
-			# elog_process(), since any logs that might exist are
-			# not valid here.
-			settings.pop("T", None)
-			portage.elog.elog_process(pkg.cpv, settings)
-			self._failed_pkgs_all.append(self._failed_pkg(pkg=pkg))
-
-		return True
-
-	def _show_list(self):
-		myopts = self.myopts
-		if "--quiet" not in myopts and \
-			("--ask" in myopts or "--tree" in myopts or \
-			"--verbose" in myopts):
-			return True
-		return False
-
-	def _world_atom(self, pkg):
-		"""
-		Add or remove the package to the world file, but only if
-		it's supposed to be added or removed. Otherwise, do nothing.
-		"""
-
-		if set(("--buildpkgonly", "--fetchonly",
-			"--fetch-all-uri",
-			"--oneshot", "--onlydeps",
-			"--pretend")).intersection(self.myopts):
-			return
-
-		if pkg.root != self.target_root:
-			return
-
-		args_set = self._args_set
-		if not args_set.findAtomForPackage(pkg):
-			return
-
-		logger = self._logger
-		pkg_count = self._pkg_count
-		root_config = pkg.root_config
-		world_set = root_config.sets["selected"]
-		world_locked = False
-		if hasattr(world_set, "lock"):
-			world_set.lock()
-			world_locked = True
-
-		try:
-			if hasattr(world_set, "load"):
-				world_set.load() # maybe it's changed on disk
-
-			if pkg.operation == "uninstall":
-				if hasattr(world_set, "cleanPackage"):
-					world_set.cleanPackage(pkg.root_config.trees["vartree"].dbapi,
-							pkg.cpv)
-				if hasattr(world_set, "remove"):
-					for s in pkg.root_config.setconfig.active:
-						world_set.remove(SETPREFIX+s)
-			else:
-				atom = create_world_atom(pkg, args_set, root_config)
-				if atom:
-					if hasattr(world_set, "add"):
-						self._status_msg(('Recording %s in "world" ' + \
-							'favorites file...') % atom)
-						logger.log(" === (%s of %s) Updating world file (%s)" % \
-							(pkg_count.curval, pkg_count.maxval, pkg.cpv))
-						world_set.add(atom)
-					else:
-						writemsg_level('\n!!! Unable to record %s in "world"\n' % \
-							(atom,), level=logging.WARN, noiselevel=-1)
-		finally:
-			if world_locked:
-				world_set.unlock()
-
-	def _pkg(self, cpv, type_name, root_config, installed=False,
-		operation=None, myrepo=None):
-		"""
-		Get a package instance from the cache, or create a new
-		one if necessary. Raises KeyError from aux_get if it
-		failures for some reason (package does not exist or is
-		corrupt).
-		"""
-
-		# Reuse existing instance when available.
-		pkg = self._pkg_cache.get(Package._gen_hash_key(cpv=cpv,
-			type_name=type_name, repo_name=myrepo, root_config=root_config,
-			installed=installed, operation=operation))
-
-		if pkg is not None:
-			return pkg
-
-		tree_type = depgraph.pkg_tree_map[type_name]
-		db = root_config.trees[tree_type].dbapi
-		db_keys = list(self.trees[root_config.root][
-			tree_type].dbapi._aux_cache_keys)
-		metadata = zip(db_keys, db.aux_get(cpv, db_keys, myrepo=myrepo))
-		pkg = Package(built=(type_name != "ebuild"),
-			cpv=cpv, installed=installed, metadata=metadata,
-			root_config=root_config, type_name=type_name)
-		self._pkg_cache[pkg] = pkg
-		return pkg

diff --git a/gobs/pym/arch.py~ b/gobs/pym/arch.py~
deleted file mode 100644
index ebd0017..0000000
--- a/gobs/pym/arch.py~
+++ /dev/null
@@ -1,25 +0,0 @@
-import portage
-from gobs.readconf import get_conf_settings
-reader=get_conf_settings()
-gobs_settings_dict=reader.read_gobs_settings_all()
-# make a CM
-from gobs.ConnectionManager import connectionManager
-CM=connectionManager(gobs_settings_dict)
-#selectively import the pgsql/mysql querys
-if CM.getName()=='pgsql':
-	from gobs.pgsql import *
-
-class gobs_arch(object):
-	
-	def update_arch_db(self):
-		conn = CM.getConnection()
-		# FIXME: check for new keyword
-		# Add arch db (keywords)
-		if get_arch_db(conn) is None:
-			arch_list =  portage.archlist
-			for arch in arch_list:
-				if arch[0] not in ["~","-"]:
-					arch_list.append("-" + arch)
-			arch_list.append("-*")
-			add_new_arch_db(conn,arch_list)
-		CM.putConnection(conn)
\ No newline at end of file

diff --git a/gobs/pym/build_log.py~ b/gobs/pym/build_log.py~
deleted file mode 100644
index 80a186a..0000000
--- a/gobs/pym/build_log.py~
+++ /dev/null
@@ -1,572 +0,0 @@
-from __future__ import print_function
-import re
-import os
-import platform
-try:
-	from subprocess import getstatusoutput as subprocess_getstatusoutput
-except ImportError:
-	from commands import getstatusoutput as subprocess_getstatusoutput
-from gobs.text import get_log_text_list
-from _emerge.main import parse_opts, load_emerge_config, \
-        getportageversion
-from portage.util import writemsg, \
-        writemsg_level, writemsg_stdout
-from _emerge.actions import _info_pkgs_ver
-from portage.exception import InvalidAtom
-from portage.dep import Atom
-from portage.dbapi._expand_new_virt import expand_new_virt
-from portage.const import GLOBAL_CONFIG_PATH, NEWS_LIB_PATH
-from portage.const import _ENABLE_DYN_LINK_MAP, _ENABLE_SET_CONFIG
-from portage.versions import catpkgsplit, cpv_getversion
-from portage import _encodings
-from portage import _unicode_encode
-from gobs.repoman_gobs import gobs_repoman
-import portage
-from gobs.package import gobs_package
-from gobs.readconf import get_conf_settings
-from gobs.flags import gobs_use_flags
-reader=get_conf_settings()
-gobs_settings_dict=reader.read_gobs_settings_all()
-# make a CM
-from gobs.ConnectionManager import connectionManager
-CM=connectionManager(gobs_settings_dict)
-#selectively import the pgsql/mysql querys
-if CM.getName()=='pgsql':
-	from gobs.pgsql import *
-
-class gobs_buildlog(object):
-	
-	def __init__(self):
-		self._config_profile = gobs_settings_dict['gobs_config']
-	
-	def get_build_dict_db(self, settings, pkg):
-		conn=CM.getConnection()
-		myportdb = portage.portdbapi(mysettings=settings)
-		cpvr_list = catpkgsplit(pkg.cpv, silent=1)
-		categories = cpvr_list[0]
-		package = cpvr_list[1]
-		ebuild_version = cpv_getversion(pkg.cpv)
-		print('cpv: ' + pkg.cpv)
-		init_package = gobs_package(settings, myportdb)
-		package_id = have_package_db(conn, categories, package)
-		# print("package_id %s" % package_id, file=sys.stdout)
-		build_dict = {}
-		mybuild_dict = {}
-		build_dict['ebuild_version'] = ebuild_version
-		build_dict['package_id'] = package_id
-		build_dict['cpv'] = pkg.cpv
-		build_dict['categories'] = categories
-		build_dict['package'] = package
-		build_dict['config_profile'] = self._config_profile
-		init_useflags = gobs_use_flags(settings, myportdb, pkg.cpv)
-		iuse_flags_list, final_use_list = init_useflags.get_flags_pkg(pkg, settings)
-		#print 'final_use_list', final_use_list
-		if  final_use_list != []:
-			build_dict['build_useflags'] = sorted(final_use_list)
-		else:
-			build_dict['build_useflags'] = None
-		#print "build_dict['build_useflags']", build_dict['build_useflags']
-		pkgdir = os.path.join(settings['PORTDIR'], categories + "/" + package)
-		ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir+ "/" + package + "-" + ebuild_version + ".ebuild")[0]
-		build_dict['checksum'] = ebuild_version_checksum_tree
-		ebuild_id = get_ebuild_id_db_checksum(conn, build_dict)
-		if ebuild_id is None:
-			#print 'have any ebuild',  get_ebuild_checksum(conn, package_id, ebuild_version)
-			init_package.update_ebuild_db(build_dict)
-			ebuild_id = get_ebuild_id_db_checksum(conn, build_dict)
-		build_dict['ebuild_id'] = ebuild_id
-		queue_id = check_revision(conn, build_dict)
-		if queue_id is None:
-			build_dict['queue_id'] = None
-		else:
-			build_dict['queue_id'] = queue_id
-		CM.putConnection(conn)
-		return build_dict
-
-	def add_new_ebuild_buildlog(self, settings, pkg, build_dict, build_error, summary_error, build_log_dict):
-		conn=CM.getConnection()
-		portdb = portage.portdbapi(mysettings=settings)
-		init_useflags = gobs_use_flags(settings, portdb, build_dict['cpv'])
-		iuse_flags_list, final_use_list = init_useflags.get_flags_pkg(pkg, settings)
-		iuse = []
-		use_flags_list = []
-		use_enable_list = []
-		for iuse_line in iuse_flags_list:
-			iuse.append(init_useflags.reduce_flag(iuse_line))
-		iuse_flags_list2 = list(set(iuse))
-		use_enable = final_use_list
-		use_disable = list(set(iuse_flags_list2).difference(set(use_enable)))
-		use_flagsDict = {}
-		for x in use_enable:
-			use_flagsDict[x] = True
-		for x in use_disable:
-			use_flagsDict[x] = False
-		for u, s in  use_flagsDict.iteritems():
-			use_flags_list.append(u)
-			use_enable_list.append(s)
-		build_id = add_new_buildlog(conn, build_dict, use_flags_list, use_enable_list, build_error, summary_error, build_log_dict)
-		CM.putConnection(conn)
-		return build_id
-
-	def search_info(self, textline, error_log_list):
-		if re.search(" * Package:", textline):
-			error_log_list.append(textline)
-		if re.search(" * Repository:", textline):
-			error_log_list.append(textline)
-		if re.search(" * Maintainer:", textline):
-			error_log_list.append(textline)
-		if re.search(" * USE:", textline):
-			error_log_list.append(textline)
-		if re.search(" * FEATURES:", textline):
-			error_log_list.append(textline)
-		return error_log_list
-
-	def search_error(self, logfile_text, textline, error_log_list, sum_build_log_list, i):
-		if re.search("Error 1", textline):
-			x = i - 20
-			endline = True
-			error_log_list.append(".....\n")
-			while x != i + 3 and endline:
-				try:
-					error_log_list.append(logfile_text[x])
-				except:
-					endline = False
-				else:
-					x = x +1
-		if re.search(" * ERROR:", textline):
-			x = i
-			endline= True
-			field = textline.split(" ")
-			sum_build_log_list.append("fail")
-			error_log_list.append(".....\n")
-			while x != i + 10 and endline:
-				try:
-					error_log_list.append(logfile_text[x])
-				except:
-					endline = False
-				else:
-					x = x +1
-		if re.search("configure: error:", textline):
-			x = i - 4
-			endline = True
-			error_log_list.append(".....\n")
-			while x != i + 3 and endline:
-				try:
-					error_log_list.append(logfile_text[x])
-				except:
-					endline = False
-				else:
-					x = x +1
-		return error_log_list, sum_build_log_list
-
-	def search_qa(self, logfile_text, textline, qa_error_list, error_log_list,i):
-		if re.search(" * QA Notice:", textline):
-			x = i
-			qa_error_list.append(logfile_text[x])
-			endline= True
-			error_log_list.append(".....\n")
-			while x != i + 3 and endline:
-				try:
-					error_log_list.append(logfile_text[x])
-				except:
-					endline = False
-				else:
-					x = x +1
-		return qa_error_list, error_log_list
-
-	def get_buildlog_info(self, settings, build_dict):
-		myportdb = portage.portdbapi(mysettings=settings)
-		init_repoman = gobs_repoman(settings, myportdb)
-		logfile_text = get_log_text_list(settings.get("PORTAGE_LOG_FILE"))
-		# FIXME to support more errors and stuff
-		i = 0
-		build_log_dict = {}
-		error_log_list = []
-		qa_error_list = []
-		repoman_error_list = []
-		sum_build_log_list = []
-		for textline in logfile_text:
-			error_log_list = self.search_info(textline, error_log_list)
-			error_log_list, sum_build_log_list = self.search_error(logfile_text, textline, error_log_list, sum_build_log_list, i)
-			qa_error_list, error_log_list = self.search_qa(logfile_text, textline, qa_error_list, error_log_list, i)
-			i = i +1
-		# Run repoman check_repoman()
-		repoman_error_list = init_repoman.check_repoman(build_dict['categories'], build_dict['package'], build_dict['ebuild_version'], build_dict['config_profile'])
-		if repoman_error_list != []:
-			sum_build_log_list.append("repoman")
-		if qa_error_list != []:
-			sum_build_log_list.append("qa")
-		build_log_dict['repoman_error_list'] = repoman_error_list
-		build_log_dict['qa_error_list'] = qa_error_list
-		build_log_dict['error_log_list'] = error_log_list
-		build_log_dict['summary_error_list'] = sum_build_log_list
-		return build_log_dict
-	
-	# Copy of the portage action_info but fixed so it post info to a list.
-	def action_info(self, settings, trees):
-		argscmd = []
-		myaction, myopts, myfiles = parse_opts(argscmd, silent=True)
-		msg = []
-		root = '/'
-		root_config = root
-		# root_config = trees[settings['ROOT']]['root_config']
-		msg.append(getportageversion(settings["PORTDIR"], settings["ROOT"],
-			settings.profile_path, settings["CHOST"],
-			trees[settings["ROOT"]]["vartree"].dbapi) + "\n")
-
-		header_width = 65
-		header_title = "System Settings"
-		if myfiles:
-			msg.append(header_width * "=" + "\n")
-			msg.append(header_title.rjust(int(header_width/2 + len(header_title)/2)) + "\n")
-		msg.append(header_width * "=" + "\n")
-		msg.append("System uname: "+platform.platform(aliased=1) + "\n")
-
-		lastSync = portage.grabfile(os.path.join(
-			settings["PORTDIR"], "metadata", "timestamp.chk"))
-		if lastSync:
-			msg.append("Timestamp of tree:" + lastSync[0] + "\n")
-		else:
-			msg.append("Timestamp of tree: Unknown" + "\n")
-
-		output=subprocess_getstatusoutput("distcc --version")
-		if not output[0]:
-			msg.append(str(output[1].split("\n",1)[0]))
-			if "distcc" in settings.features:
-				msg.append("[enabled]")
-			else:
-				msg.append("[disabled]")
-
-		output=subprocess_getstatusoutput("ccache -V")
-		if not output[0]:
-			msg.append(str(output[1].split("\n",1)[0]), end=' ')
-			if "ccache" in settings.features:
-				msg.append("[enabled]")
-			else:
-				msg.append("[disabled]")
-
-		myvars  = ["sys-devel/autoconf", "sys-devel/automake", "virtual/os-headers",
-			"sys-devel/binutils", "sys-devel/libtool",  "dev-lang/python"]
-		myvars += portage.util.grabfile(settings["PORTDIR"]+"/profiles/info_pkgs")
-		atoms = []
-		vardb = trees["/"]["vartree"].dbapi
-		for x in myvars:
-			try:
-				x = Atom(x)
-			except InvalidAtom:
-				writemsg_stdout("%-20s %s\n" % (x+":", "[NOT VALID]"),
-					noiselevel=-1)
-			else:
-				for atom in expand_new_virt(vardb, x):
-					if not atom.blocker:
-						atoms.append((x, atom))
-
-		myvars = sorted(set(atoms))
-
-		portdb = trees["/"]["porttree"].dbapi
-		main_repo = portdb.getRepositoryName(portdb.porttree_root)
-		cp_map = {}
-		cp_max_len = 0
-
-		for orig_atom, x in myvars:
-			pkg_matches = vardb.match(x)
-
-			versions = []
-			for cpv in pkg_matches:
-				matched_cp = portage.versions.cpv_getkey(cpv)
-				ver = portage.versions.cpv_getversion(cpv)
-				ver_map = cp_map.setdefault(matched_cp, {})
-				prev_match = ver_map.get(ver)
-				if prev_match is not None:
-					if prev_match.provide_suffix:
-						# prefer duplicate matches that include
-						# additional virtual provider info
-						continue
-
-				if len(matched_cp) > cp_max_len:
-					cp_max_len = len(matched_cp)
-				repo = vardb.aux_get(cpv, ["repository"])[0]
-				if repo == main_repo:
-					repo_suffix = ""
-				elif not repo:
-					repo_suffix = "::<unknown repository>"
-				else:
-					repo_suffix = "::" + repo
-
-				if matched_cp == orig_atom.cp:
-					provide_suffix = ""
-				else:
-					provide_suffix = " (%s)" % (orig_atom,)
-
-				ver_map[ver] = _info_pkgs_ver(ver, repo_suffix, provide_suffix)
-
-		for cp in sorted(cp_map):
-			versions = sorted(cp_map[cp].values())
-			versions = ", ".join(ver.toString() for ver in versions)
-			msg_extra = "%s %s\n" % \
-				((cp + ":").ljust(cp_max_len + 1), versions)
-			msg.append(msg_extra)
-
-		libtool_vers = ",".join(trees["/"]["vartree"].dbapi.match("sys-devel/libtool"))
-
-		repos = portdb.settings.repositories
-		msg_extra = "Repositories: %s\n" % \
-			" ".join(repo.name for repo in repos)
-		msg.append(msg_extra)
-
-		if _ENABLE_SET_CONFIG:
-			sets_line = "Installed sets: "
-			sets_line += ", ".join(s for s in \
-				sorted(root_config.sets['selected'].getNonAtoms()) \
-				if s.startswith(SETPREFIX))
-			sets_line += "\n"
-			msg.append(sets_line)
-
-		myvars = ['GENTOO_MIRRORS', 'CONFIG_PROTECT', 'CONFIG_PROTECT_MASK',
-			'PORTDIR', 'DISTDIR', 'PKGDIR', 'PORTAGE_TMPDIR',
-			'PORTDIR_OVERLAY', 'PORTAGE_BUNZIP2_COMMAND',
-			'PORTAGE_BZIP2_COMMAND',
-			'USE', 'CHOST', 'CFLAGS', 'CXXFLAGS',
-			'ACCEPT_KEYWORDS', 'ACCEPT_LICENSE', 'SYNC', 'FEATURES',
-			'EMERGE_DEFAULT_OPTS']
-		myvars.extend(portage.util.grabfile(settings["PORTDIR"]+"/profiles/info_vars"))
-
-		myvars_ignore_defaults = {
-			'PORTAGE_BZIP2_COMMAND' : 'bzip2',
-		}
-
-		myvars = portage.util.unique_array(myvars)
-		use_expand = settings.get('USE_EXPAND', '').split()
-		use_expand.sort()
-		use_expand_hidden = set(
-			settings.get('USE_EXPAND_HIDDEN', '').upper().split())
-		alphabetical_use = '--alphabetical' in myopts
-		unset_vars = []
-		myvars.sort()
-		for x in myvars:
-			if x in settings:
-				if x != "USE":
-					default = myvars_ignore_defaults.get(x)
-					if default is not None and \
-						default == settings[x]:
-						continue
-					msg_extra = '%s="%s"\n' % (x, settings[x])
-					msg.append(msg_extra)
-				else:
-					use = set(settings["USE"].split())
-					for varname in use_expand:
-						flag_prefix = varname.lower() + "_"
-						for f in list(use):
-							if f.startswith(flag_prefix):
-								use.remove(f)
-					use = list(use)
-					use.sort()
-					msg_extra = 'USE=%s' % " ".join(use)
-					msg.append(msg_extra + "\n")
-					for varname in use_expand:
-						myval = settings.get(varname)
-						if myval:
-							msg.append(varname + '=' + myval + "\n")
-			else:
-				unset_vars.append(x)
-		if unset_vars:
-			msg_extra = "Unset: "+", ".join(unset_vars)
-			msg.append(msg_extra + "\n")
-
-		# See if we can find any packages installed matching the strings
-		# passed on the command line
-		mypkgs = []
-		vardb = trees[settings["ROOT"]]["vartree"].dbapi
-		portdb = trees[settings["ROOT"]]["porttree"].dbapi
-		bindb = trees[settings["ROOT"]]["bintree"].dbapi
-		for x in myfiles:
-			match_found = False
-			installed_match = vardb.match(x)
-			for installed in installed_match:
-				mypkgs.append((installed, "installed"))
-				match_found = True
-
-			if match_found:
-				continue
-
-			for db, pkg_type in ((portdb, "ebuild"), (bindb, "binary")):
-				if pkg_type == "binary" and "--usepkg" not in myopts:
-					continue
-
-				matches = db.match(x)
-				matches.reverse()
-				for match in matches:
-					if pkg_type == "binary":
-						if db.bintree.isremote(match):
-							continue
-					auxkeys = ["EAPI", "DEFINED_PHASES"]
-					metadata = dict(zip(auxkeys, db.aux_get(match, auxkeys)))
-					if metadata["EAPI"] not in ("0", "1", "2", "3") and \
-						"info" in metadata["DEFINED_PHASES"].split():
-						mypkgs.append((match, pkg_type))
-						break
-
-		# If some packages were found...
-		if mypkgs:
-			# Get our global settings (we only print stuff if it varies from
-			# the current config)
-			mydesiredvars = [ 'CHOST', 'CFLAGS', 'CXXFLAGS', 'LDFLAGS' ]
-			auxkeys = mydesiredvars + list(vardb._aux_cache_keys)
-			auxkeys.append('DEFINED_PHASES')
-			global_vals = {}
-			pkgsettings = portage.config(clone=settings)
-
-			# Loop through each package
-			# Only print settings if they differ from global settings
-			header_title = "Package Settings"
-			msg.append(header_width * "=")
-			msg.append(header_title.rjust(int(header_width/2 + len(header_title)/2)))
-			msg.append(header_width * "=")
-			from portage.output import EOutput
-			out = EOutput()
-			for mypkg in mypkgs:
-				cpv = mypkg[0]
-				pkg_type = mypkg[1]
-				# Get all package specific variables
-				if pkg_type == "installed":
-					metadata = dict(zip(auxkeys, vardb.aux_get(cpv, auxkeys)))
-				elif pkg_type == "ebuild":
-					metadata = dict(zip(auxkeys, portdb.aux_get(cpv, auxkeys)))
-				elif pkg_type == "binary":
-					metadata = dict(zip(auxkeys, bindb.aux_get(cpv, auxkeys)))
-
-				pkg = Package(built=(pkg_type!="ebuild"), cpv=cpv,
-					installed=(pkg_type=="installed"), metadata=zip(Package.metadata_keys,
-					(metadata.get(x, '') for x in Package.metadata_keys)),
-					root_config=root_config, type_name=pkg_type)
-
-				if pkg_type == "installed":
-					msg.append("\n%s was built with the following:" % \
-						colorize("INFORM", str(pkg.cpv)))
-				elif pkg_type == "ebuild":
-					msg.append("\n%s would be build with the following:" % \
-						colorize("INFORM", str(pkg.cpv)))
-				elif pkg_type == "binary":
-					msg.append("\n%s (non-installed binary) was built with the following:" % \
-						colorize("INFORM", str(pkg.cpv)))
-
-				writemsg_stdout('%s\n' % pkg_use_display(pkg, myopts),
-					noiselevel=-1)
-				if pkg_type == "installed":
-					for myvar in mydesiredvars:
-						if metadata[myvar].split() != settings.get(myvar, '').split():
-							msg.append("%s=\"%s\"" % (myvar, metadata[myvar]))
-
-				if metadata['DEFINED_PHASES']:
-					if 'info' not in metadata['DEFINED_PHASES'].split():
-						continue
-
-				msg.append(">>> Attempting to run pkg_info() for '%s'" % pkg.cpv)
-
-				if pkg_type == "installed":
-					ebuildpath = vardb.findname(pkg.cpv)
-				elif pkg_type == "ebuild":
-					ebuildpath = portdb.findname(pkg.cpv, myrepo=pkg.repo)
-				elif pkg_type == "binary":
-					tbz2_file = bindb.bintree.getname(pkg.cpv)
-					ebuild_file_name = pkg.cpv.split("/")[1] + ".ebuild"
-					ebuild_file_contents = portage.xpak.tbz2(tbz2_file).getfile(ebuild_file_name)
-					tmpdir = tempfile.mkdtemp()
-					ebuildpath = os.path.join(tmpdir, ebuild_file_name)
-					file = open(ebuildpath, 'w')
-					file.write(ebuild_file_contents)
-					file.close()
-
-				if not ebuildpath or not os.path.exists(ebuildpath):
-					out.ewarn("No ebuild found for '%s'" % pkg.cpv)
-					continue
-
-				if pkg_type == "installed":
-					portage.doebuild(ebuildpath, "info", pkgsettings["ROOT"],
-						pkgsettings, debug=(settings.get("PORTAGE_DEBUG", "") == 1),
-						mydbapi=trees[settings["ROOT"]]["vartree"].dbapi,
-						tree="vartree")
-				elif pkg_type == "ebuild":
-					portage.doebuild(ebuildpath, "info", pkgsettings["ROOT"],
-						pkgsettings, debug=(settings.get("PORTAGE_DEBUG", "") == 1),
-						mydbapi=trees[settings["ROOT"]]["porttree"].dbapi,
-						tree="porttree")
-				elif pkg_type == "binary":
-					portage.doebuild(ebuildpath, "info", pkgsettings["ROOT"],
-						pkgsettings, debug=(settings.get("PORTAGE_DEBUG", "") == 1),
-						mydbapi=trees[settings["ROOT"]]["bintree"].dbapi,
-						tree="bintree")
-					shutil.rmtree(tmpdir)
-		return msg
-
-	def write_msg_file(self, msg, log_path):
-		"""
-		Output msg to stdout if not self._background. If log_path
-		is not None then append msg to the log (appends with
-		compression if the filename extension of log_path
-		corresponds to a supported compression type).
-		"""
-		msg_shown = False
-		if log_path is not None:
-			try:
-				f = open(_unicode_encode(log_path,
-					encoding=_encodings['fs'], errors='strict'),
-					mode='ab')
-				f_real = f
-			except IOError as e:
-				if e.errno not in (errno.ENOENT, errno.ESTALE):
-					raise
-				if not msg_shown:
-					writemsg_level(msg, level=level, noiselevel=noiselevel)
-			else:
-
-				if log_path.endswith('.gz'):
-					# NOTE: The empty filename argument prevents us from
-					# triggering a bug in python3 which causes GzipFile
-					# to raise AttributeError if fileobj.name is bytes
-					# instead of unicode.
-					f =  gzip.GzipFile(filename='', mode='ab', fileobj=f)
-
-				f.write(_unicode_encode(msg))
-				f.close()
-				if f_real is not f:
-					f_real.close()
-
-	def add_buildlog_main(self, settings, pkg, trees):
-		conn=CM.getConnection()
-		build_dict = self.get_build_dict_db(settings, pkg)
-		build_log_dict = {}
-		build_log_dict = self.get_buildlog_info(settings, build_dict)
-		sum_build_log_list = build_log_dict['summary_error_list']
-		error_log_list = build_log_dict['error_log_list']
-		build_error = ""
-		if error_log_list != []:
-			for log_line in error_log_list:
-				build_error = build_error + log_line
-		summary_error = ""
-		if sum_build_log_list != []:
-			for sum_log_line in sum_build_log_list:
-				summary_error = summary_error + " " + sum_log_line
-		build_log_dict['logfilename'] = re.sub("\/var\/log\/portage\/", "",  settings.get("PORTAGE_LOG_FILE"))
-		if build_dict['queue_id'] is None:
-			build_id = self.add_new_ebuild_buildlog(settings, pkg, build_dict, build_error, summary_error, build_log_dict)
-		else:
-			build_id = move_queru_buildlog(conn, build_dict['queue_id'], build_error, summary_error, build_log_dict)
-		# update_qa_repoman(conn, build_id, build_log_dict)
-		msg = self.action_info(settings, trees)
-		emerge_info_logfilename = settings.get("PORTAGE_LOG_FILE")[:-3] + "emerge_log.log"
-		if build_id is not None:
-			for msg_line in msg:
-				self.write_msg_file(msg_line, emerge_info_logfilename)
-			os.chmod(settings.get("PORTAGE_LOG_FILE"), 0664)
-			os.chmod(emerge_info_logfilename, 0664)
-			print("Package: ", pkg.cpv, "logged to db.")
-		else:
-			# FIXME Remove the log some way so 
-			# mergetask._locate_failure_log(x) works in action_build()
-			#try:
-			#	os.remove(settings.get("PORTAGE_LOG_FILE"))
-			#except:
-			#	pass
-			print("Package: ", pkg.cpv, "NOT logged to db.")
-		CM.putConnection(conn)

diff --git a/gobs/pym/build_queru.py~ b/gobs/pym/build_queru.py~
deleted file mode 100644
index 3f0bde8..0000000
--- a/gobs/pym/build_queru.py~
+++ /dev/null
@@ -1,708 +0,0 @@
-# Get the options from the config file set in gobs.readconf
-from __future__ import print_function
-from gobs.readconf import get_conf_settings
-reader=get_conf_settings()
-gobs_settings_dict=reader.read_gobs_settings_all()
-# make a CM
-from gobs.ConnectionManager import connectionManager
-CM=connectionManager(gobs_settings_dict)
-#selectively import the pgsql/mysql querys
-if CM.getName()=='pgsql':
-	from gobs.pgsql import *
-
-import portage
-import os
-import re
-import sys
-import signal
-from gobs.manifest import gobs_manifest
-from gobs.depclean import main_depclean
-from gobs.flags import gobs_use_flags
-from portage import _encodings
-from portage import _unicode_decode
-from portage.versions import cpv_getkey
-import portage.xpak, errno, re, time
-from _emerge.main import parse_opts, profile_check, apply_priorities, repo_name_duplicate_check, \
-	config_protect_check, check_procfs, ensure_required_sets, expand_set_arguments, \
-	validate_ebuild_environment, chk_updated_info_files, display_preserved_libs
-from _emerge.actions import action_config, action_sync, action_metadata, \
-	action_regen, action_search, action_uninstall, \
-	adjust_configs, chk_updated_cfg_files, display_missing_pkg_set, \
-	display_news_notification, getportageversion, load_emerge_config
-from portage.util import cmp_sort_key, writemsg, \
-	writemsg_level, writemsg_stdout, shlex_split
-from _emerge.sync.old_tree_timestamp import old_tree_timestamp_warn
-from _emerge.create_depgraph_params import create_depgraph_params
-from _emerge.depgraph import backtrack_depgraph, depgraph, resume_depgraph
-from _emerge.DepPrioritySatisfiedRange import DepPrioritySatisfiedRange
-from gobs.Scheduler import Scheduler
-from _emerge.clear_caches import clear_caches
-from _emerge.unmerge import unmerge
-from _emerge.emergelog import emergelog
-from _emerge._flush_elog_mod_echo import _flush_elog_mod_echo
-from portage._global_updates import _global_updates
-from portage._sets import SETPREFIX
-from portage.const import PORTAGE_PACKAGE_ATOM, USER_CONFIG_PATH
-from _emerge.is_valid_package_atom import is_valid_package_atom
-from _emerge.stdout_spinner import stdout_spinner
-from portage.output import blue, bold, colorize, create_color_func, darkgreen, \
-	red, yellow, colorize, xtermTitle, xtermTitleReset
-good = create_color_func("GOOD")
-bad = create_color_func("BAD")
-
-class queruaction(object):
-
-	def __init__(self, config_profile):
-		self._mysettings = portage.config(config_root = "/")
-		self._config_profile = config_profile
-		self._myportdb =  portage.portdb
-
-	def log_fail_queru(self, build_dict, settings):
-		conn=CM.getConnection()
-		print('build_dict', build_dict)
-		fail_querue_dict = get_fail_querue_dict(conn, build_dict)
-		print('fail_querue_dict', fail_querue_dict)
-		if fail_querue_dict is None:
-			fail_querue_dict = {}
-			fail_querue_dict['querue_id'] = build_dict['queue_id']
-			fail_querue_dict['fail_type'] = build_dict['type_fail']
-			fail_querue_dict['fail_times'] = 1
-			print('fail_querue_dict', fail_querue_dict)
-			add_fail_querue_dict(conn, fail_querue_dict)
-		else:
-			if fail_querue_dict['fail_times'][0] < 6:
-				fail_querue_dict['fail_times'] = fail_querue_dict['fail_times'][0] + 1
-				fail_querue_dict['querue_id'] = build_dict['queue_id']
-				fail_querue_dict['fail_type'] = build_dict['type_fail']
-				update_fail_times(conn, fail_querue_dict)
-				return
-			else:
-				build_log_dict = {}
-				error_log_list = []
-				qa_error_list = []
-				repoman_error_list = []
-				sum_build_log_list = []
-				sum_build_log_list.append("fail")
-				error_log_list.append(build_dict['type_fail'])
-				build_log_dict['repoman_error_list'] = repoman_error_list
-				build_log_dict['qa_error_list'] = qa_error_list
-				build_log_dict['summary_error_list'] = sum_build_log_list
-				if build_dict['type_fail'] == 'merge fail':
-					error_log_list = []
-					for k, v in build_dict['failed_merge'].iteritems():
-						error_log_list.append(v['fail_msg'])
-				build_log_dict['error_log_list'] = error_log_list
-				build_error = ""
-				if error_log_list != []:
-					for log_line in error_log_list:
-						build_error = build_error + log_line
-				summary_error = ""
-				if sum_build_log_list != []:
-					for sum_log_line in sum_build_log_list:
-						summary_error = summary_error + " " + sum_log_line
-				if settings.get("PORTAGE_LOG_FILE") is not None:
-					build_log_dict['logfilename'] = re.sub("\/var\/log\/portage\/", "",  settings.get("PORTAGE_LOG_FILE"))
-					# os.chmode(settings.get("PORTAGE_LOG_FILE"), 224)
-				else:
-					build_log_dict['logfilename'] = ""
-				move_queru_buildlog(conn, build_dict['queue_id'], build_error, summary_error, build_log_dict)
-		CM.putConnection(conn)
-
-	def action_build(self, settings, trees, mtimedb, myopts, myaction, myfiles, spinner, build_dict):
-
-		if '--usepkgonly' not in myopts:
-			old_tree_timestamp_warn(settings['PORTDIR'], settings)
-
-		# It's best for config updates in /etc/portage to be processed
-		# before we get here, so warn if they're not (bug #267103).
-		chk_updated_cfg_files(settings['EROOT'], ['/etc/portage'])
-
-		resume = False
-
-		ldpath_mtimes = mtimedb["ldpath"]
-		favorites=[]
-		buildpkgonly = "--buildpkgonly" in myopts
-		pretend = "--pretend" in myopts
-		fetchonly = "--fetchonly" in myopts or "--fetch-all-uri" in myopts
-		ask = "--ask" in myopts
-		enter_invalid = '--ask-enter-invalid' in myopts
-		nodeps = "--nodeps" in myopts
-		oneshot = "--oneshot" in myopts or "--onlydeps" in myopts
-		tree = "--tree" in myopts
-		if nodeps and tree:
-			tree = False
-			del myopts["--tree"]
-			portage.writemsg(colorize("WARN", " * ") + \
-				"--tree is broken with --nodeps. Disabling...\n")
-		debug = "--debug" in myopts
-		verbose = "--verbose" in myopts
-		quiet = "--quiet" in myopts
-
-		myparams = create_depgraph_params(myopts, myaction)
-		try:
-			success, mydepgraph, favorites = backtrack_depgraph(
-				settings, trees, myopts, myparams, myaction, myfiles, spinner)
-		except portage.exception.PackageSetNotFound as e:
-			root_config = trees[settings["ROOT"]]["root_config"]
-			display_missing_pkg_set(root_config, e.value)
-			build_dict['type_fail'] = "depgraph fail"
-			build_dict['check_fail'] = True
-		use_changes = None
-		if mydepgraph._dynamic_config._needed_use_config_changes:
-			use_changes = {}
-			for pkg, needed_use_config_changes in mydepgraph._dynamic_config._needed_use_config_changes.items():
-				new_use, changes = needed_use_config_changes
-				use_changes[pkg.cpv] = changes
-			iteritems_packages = {}
-			for k, v in use_changes.iteritems():
-				k_package = portage.versions.cpv_getkey(k)
-				iteritems_packages[ k_package ] = v
-			print('iteritems_packages', iteritems_packages)
-			build_cpv_dict = iteritems_packages
-		if use_changes is not None:
-			for k, v in build_cpv_dict.iteritems():
-				build_use_flags_list = []
-				for x, y in v.iteritems():
-					if y is True:
-						build_use_flags_list.append(x)
-					if y is False:
-						build_use_flags_list.append("-" + x)
-				print(k, build_use_flags_list)
-				if not build_use_flags_list == []:
-					build_use_flags = ""
-					for flags in build_use_flags_list:
-						build_use_flags = build_use_flags + flags + ' '
-					filetext = k + ' ' + build_use_flags
-					print('filetext', filetext)
-					with open("/etc/portage/package.use/gobs.use", "a") as f:
-						f.write(filetext)
-						f.write('\n')
-
-			settings, trees, mtimedb = load_emerge_config()
-			myparams = create_depgraph_params(myopts, myaction)
-			try:
-				success, mydepgraph, favorites = backtrack_depgraph(
-					settings, trees, myopts, myparams, myaction, myfiles, spinner)
-			except portage.exception.PackageSetNotFound as e:
-				root_config = trees[settings["ROOT"]]["root_config"]
-				display_missing_pkg_set(root_config, e.value)
-				build_dict['type_fail'] = "depgraph fail"
-				build_dict['check_fail'] = True
-		if not success:
-			mydepgraph.display_problems()
-			build_dict['type_fail'] = "depgraph fail"
-			build_dict['check_fail'] = True
-
-		if build_dict['check_fail'] is True:
-				self.log_fail_queru(build_dict, settings)
-				return 1, settings, trees, mtimedb
-
-		if "--buildpkgonly" in myopts:
-			graph_copy = mydepgraph._dynamic_config.digraph.copy()
-			removed_nodes = set()
-			for node in graph_copy:
-				if not isinstance(node, Package) or \
-					node.operation == "nomerge":
-					removed_nodes.add(node)
-			graph_copy.difference_update(removed_nodes)
-			if not graph_copy.hasallzeros(ignore_priority = \
-				DepPrioritySatisfiedRange.ignore_medium):
-				print("\n!!! --buildpkgonly requires all dependencies to be merged.")
-				print("!!! Cannot merge requested packages. Merge deps and try again.\n")
-				return 1, settings, trees, mtimedb
-
-		mydepgraph.saveNomergeFavorites()
-
-		mergetask = Scheduler(settings, trees, mtimedb, myopts,
-			spinner, favorites=favorites,
-			graph_config=mydepgraph.schedulerGraph())
-
-		del mydepgraph
-		clear_caches(trees)
-
-		retval = mergetask.merge()
-		print('retval', retval)
-		if retval:
-			build_dict['type_fail'] = 'merge fail'
-			build_dict['check_fail'] = True
-			attict = {}
-			failed_pkgs_dict = {}
-			for x in mergetask._failed_pkgs_all:
-				attict['fail_msg'] = str(x.pkg)[0] + ' ' + str(x.pkg)[1] + ' ' + re.sub("\/var\/log\/portage\/", "", mergetask._locate_failure_log(x))
-				failed_pkgs_dict[str(x.pkg.cpv)] = attict
-			build_dict['failed_merge'] = failed_pkgs_dict
-			self.log_fail_queru(build_dict, settings)
-		if retval == os.EX_OK and not (buildpkgonly or fetchonly or pretend):
-			if "yes" == settings.get("AUTOCLEAN"):
-				portage.writemsg_stdout(">>> Auto-cleaning packages...\n")
-				unmerge(trees[settings["ROOT"]]["root_config"],
-					myopts, "clean", [],
-					ldpath_mtimes, autoclean=1)
-			else:
-				portage.writemsg_stdout(colorize("WARN", "WARNING:")
-					+ " AUTOCLEAN is disabled.  This can cause serious"
-					+ " problems due to overlapping packages.\n")
-
-		return retval, settings, trees, mtimedb
-
-	def post_emerge(self, myaction, myopts, myfiles, target_root, trees, mtimedb, retval):
-
-		root_config = trees[target_root]["root_config"]
-		vardbapi = trees[target_root]["vartree"].dbapi
-		settings = vardbapi.settings
-		info_mtimes = mtimedb["info"]
-
-		# Load the most current variables from ${ROOT}/etc/profile.env
-		settings.unlock()
-		settings.reload()
-		settings.regenerate()
-		settings.lock()
-
-		config_protect = shlex_split(settings.get("CONFIG_PROTECT", ""))
-		infodirs = settings.get("INFOPATH","").split(":") + \
-			settings.get("INFODIR","").split(":")
-
-		os.chdir("/")
-
-		if retval == os.EX_OK:
-			exit_msg = " *** exiting successfully."
-		else:
-			exit_msg = " *** exiting unsuccessfully with status '%s'." % retval
-		emergelog("notitles" not in settings.features, exit_msg)
-
-		_flush_elog_mod_echo()
-
-		if not vardbapi._pkgs_changed:
-			display_news_notification(root_config, myopts)
-			# If vdb state has not changed then there's nothing else to do.
-			return
-
-		vdb_path = os.path.join(root_config.settings['EROOT'], portage.VDB_PATH)
-		portage.util.ensure_dirs(vdb_path)
-		vdb_lock = None
-		if os.access(vdb_path, os.W_OK) and not "--pretend" in myopts:
-			vardbapi.lock()
-			vdb_lock = True
-
-		if vdb_lock:
-			try:
-				if "noinfo" not in settings.features:
-					chk_updated_info_files(target_root,
-						infodirs, info_mtimes, retval)
-				mtimedb.commit()
-			finally:
-				if vdb_lock:
-					vardbapi.unlock()
-
-		chk_updated_cfg_files(settings['EROOT'], config_protect)
-
-		display_news_notification(root_config, myopts)
-		if retval in (None, os.EX_OK) or (not "--pretend" in myopts):
-			display_preserved_libs(vardbapi, myopts)	
-
-		postemerge = os.path.join(settings["PORTAGE_CONFIGROOT"],
-			portage.USER_CONFIG_PATH, "bin", "post_emerge")
-		if os.access(postemerge, os.X_OK):
-			hook_retval = portage.process.spawn(
-						[postemerge], env=settings.environ())
-			if hook_retval != os.EX_OK:
-				writemsg_level(
-					" %s spawn failed of %s\n" % (bad("*"), postemerge,),
-					level=logging.ERROR, noiselevel=-1)
-
-		if "--quiet" not in myopts and \
-			myaction is None and "@world" in myfiles:
-			show_depclean_suggestion()
-
-		return
-
-	def emerge_main(self, args, build_dict):
-
-		portage._disable_legacy_globals()
-		portage.dep._internal_warnings = True
-		# Disable color until we're sure that it should be enabled (after
-		# EMERGE_DEFAULT_OPTS has been parsed).
-		portage.output.havecolor = 0
-		# This first pass is just for options that need to be known as early as
-		# possible, such as --config-root.  They will be parsed again later,
-		# together with EMERGE_DEFAULT_OPTS (which may vary depending on the
-		# the value of --config-root).
-		myaction, myopts, myfiles = parse_opts(args, silent=True)
-		if "--debug" in myopts:
-			os.environ["PORTAGE_DEBUG"] = "1"
-		if "--config-root" in myopts:
-			os.environ["PORTAGE_CONFIGROOT"] = myopts["--config-root"]
-		if "--root" in myopts:
-			os.environ["ROOT"] = myopts["--root"]
-		if "--accept-properties" in myopts:
-			os.environ["ACCEPT_PROPERTIES"] = myopts["--accept-properties"]
-
-		# Portage needs to ensure a sane umask for the files it creates.
-		os.umask(0o22)
-		settings, trees, mtimedb = load_emerge_config()
-		portdb = trees[settings["ROOT"]]["porttree"].dbapi
-		rval = profile_check(trees, myaction)
-		if rval != os.EX_OK:
-			return rval
-
-		tmpcmdline = []
-		if "--ignore-default-opts" not in myopts:
-			tmpcmdline.extend(settings["EMERGE_DEFAULT_OPTS"].split())
-		tmpcmdline.extend(args)
-		myaction, myopts, myfiles = parse_opts(tmpcmdline)
-
-		if myaction not in ('help', 'info', 'version') and \
-			myopts.get('--package-moves') != 'n' and \
-			_global_updates(trees, mtimedb["updates"], quiet=("--quiet" in myopts)):
-			mtimedb.commit()
-			# Reload the whole config from scratch.
-			settings, trees, mtimedb = load_emerge_config(trees=trees)
-			portdb = trees[settings["ROOT"]]["porttree"].dbapi
-
-		xterm_titles = "notitles" not in settings.features
-		if xterm_titles:
-			xtermTitle("emerge")
-
-		adjust_configs(myopts, trees)
-		apply_priorities(settings)
-
-		spinner = stdout_spinner()
-		if "candy" in settings.features:
-			spinner.update = spinner.update_scroll
-
-		if "--quiet" not in myopts:
-			portage.deprecated_profile_check(settings=settings)
-			if portage.const._ENABLE_REPO_NAME_WARN:
-				# Bug #248603 - Disable warnings about missing
-				# repo_name entries for stable branch.
-				repo_name_check(trees)
-			repo_name_duplicate_check(trees)
-			config_protect_check(trees)
-		check_procfs()
-
-		if "getbinpkg" in settings.features:
-			myopts["--getbinpkg"] = True
-
-		if "--getbinpkgonly" in myopts:
-			myopts["--getbinpkg"] = True
-
-		if "--getbinpkgonly" in myopts:
-			myopts["--usepkgonly"] = True
-
-		if "--getbinpkg" in myopts:
-			myopts["--usepkg"] = True
-
-		if "--usepkgonly" in myopts:
-			myopts["--usepkg"] = True
-
-		if "buildpkg" in settings.features or "--buildpkgonly" in myopts:
-			myopts["--buildpkg"] = True
-
-		if "--buildpkgonly" in myopts:
-			# --buildpkgonly will not merge anything, so
-			# it cancels all binary package options.
-			for opt in ("--getbinpkg", "--getbinpkgonly",
-				"--usepkg", "--usepkgonly"):
-				myopts.pop(opt, None)
-
-		for mytrees in trees.values():
-			mydb = mytrees["porttree"].dbapi
-			# Freeze the portdbapi for performance (memoize all xmatch results).
-			mydb.freeze()
-
-			if myaction in ('search', None) and \
-				"--usepkg" in myopts:
-				# Populate the bintree with current --getbinpkg setting.
-				# This needs to happen before expand_set_arguments(), in case
-				# any sets use the bintree.
-				mytrees["bintree"].populate(
-					getbinpkgs="--getbinpkg" in myopts)
-
-		del mytrees, mydb
-
-		for x in myfiles:
-			ext = os.path.splitext(x)[1]
-			if (ext == ".ebuild" or ext == ".tbz2") and os.path.exists(os.path.abspath(x)):
-				print(colorize("BAD", "\n*** emerging by path is broken and may not always work!!!\n"))
-				break
-
-		root_config = trees[settings["ROOT"]]["root_config"]
-		if myaction == "list-sets":
-			writemsg_stdout("".join("%s\n" % s for s in sorted(root_config.sets)))
-			return os.EX_OK
-
-		ensure_required_sets(trees)
-
-		# only expand sets for actions taking package arguments
-		oldargs = myfiles[:]
-		if myaction in ("clean", "config", "depclean", "info", "prune", "unmerge", None):
-			myfiles, retval = expand_set_arguments(myfiles, myaction, root_config)
-			if retval != os.EX_OK:
-				return retval
-
-			# Need to handle empty sets specially, otherwise emerge will react 
-			# with the help message for empty argument lists
-			if oldargs and not myfiles:
-				print("emerge: no targets left after set expansion")
-				return 0
-
-		if ("--tree" in myopts) and ("--columns" in myopts):
-			print("emerge: can't specify both of \"--tree\" and \"--columns\".")
-			return 1
-
-		if '--emptytree' in myopts and '--noreplace' in myopts:
-			writemsg_level("emerge: can't specify both of " + \
-				"\"--emptytree\" and \"--noreplace\".\n",
-				level=logging.ERROR, noiselevel=-1)
-			return 1
-
-		if ("--quiet" in myopts):
-			spinner.update = spinner.update_quiet
-			portage.util.noiselimit = -1
-
-		if "--fetch-all-uri" in myopts:
-			myopts["--fetchonly"] = True
-
-		if "--skipfirst" in myopts and "--resume" not in myopts:
-			myopts["--resume"] = True
-
-		# Allow -p to remove --ask
-		if "--pretend" in myopts:
-			myopts.pop("--ask", None)
-
-		# forbid --ask when not in a terminal
-		# note: this breaks `emerge --ask | tee logfile`, but that doesn't work anyway.
-		if ("--ask" in myopts) and (not sys.stdin.isatty()):
-			portage.writemsg("!!! \"--ask\" should only be used in a terminal. Exiting.\n",
-				noiselevel=-1)
-			return 1
-
-		if settings.get("PORTAGE_DEBUG", "") == "1":
-			spinner.update = spinner.update_quiet
-			portage.util.noiselimit = 0
-			if "python-trace" in settings.features:
-				import portage.debug as portage_debug
-				portage_debug.set_trace(True)
-
-		if not ("--quiet" in myopts):
-			if '--nospinner' in myopts or \
-				settings.get('TERM') == 'dumb' or \
-				not sys.stdout.isatty():
-				spinner.update = spinner.update_basic
-
-		if "--debug" in myopts:
-			print("myaction", myaction)
-			print("myopts", myopts)
-
-		pretend = "--pretend" in myopts
-		fetchonly = "--fetchonly" in myopts or "--fetch-all-uri" in myopts
-		buildpkgonly = "--buildpkgonly" in myopts
-
-		# check if root user is the current user for the actions where emerge needs this
-		if portage.secpass < 2:
-			# We've already allowed "--version" and "--help" above.
-			if "--pretend" not in myopts and myaction not in ("search","info"):
-				need_superuser = myaction in ('clean', 'depclean', 'deselect',
-					'prune', 'unmerge') or not \
-					(fetchonly or \
-					(buildpkgonly and secpass >= 1) or \
-					myaction in ("metadata", "regen", "sync"))
-				if portage.secpass < 1 or \
-					need_superuser:
-					if need_superuser:
-						access_desc = "superuser"
-					else:
-						access_desc = "portage group"
-					# Always show portage_group_warning() when only portage group
-					# access is required but the user is not in the portage group.
-					from portage.data import portage_group_warning
-					if "--ask" in myopts:
-						myopts["--pretend"] = True
-						del myopts["--ask"]
-						print(("%s access is required... " + \
-							"adding --pretend to options\n") % access_desc)
-						if portage.secpass < 1 and not need_superuser:
-							portage_group_warning()
-					else:
-						sys.stderr.write(("emerge: %s access is required\n") \
-							% access_desc)
-						if portage.secpass < 1 and not need_superuser:
-							portage_group_warning()
-						return 1
-
-		disable_emergelog = False
-		if disable_emergelog:
-			""" Disable emergelog for everything except build or unmerge
-			operations.  This helps minimize parallel emerge.log entries that can
-			confuse log parsers.  We especially want it disabled during
-			parallel-fetch, which uses --resume --fetchonly."""
-			_emerge.emergelog._disable = True
-
-		else:
-			if 'EMERGE_LOG_DIR' in settings:
-				try:
-					# At least the parent needs to exist for the lock file.
-					portage.util.ensure_dirs(settings['EMERGE_LOG_DIR'])
-				except portage.exception.PortageException as e:
-					writemsg_level("!!! Error creating directory for " + \
-						"EMERGE_LOG_DIR='%s':\n!!! %s\n" % \
-						(settings['EMERGE_LOG_DIR'], e),
-						noiselevel=-1, level=logging.ERROR)
-				else:
-					global _emerge_log_dir
-					_emerge_log_dir = settings['EMERGE_LOG_DIR']
-
-		if not "--pretend" in myopts:
-			emergelog(xterm_titles, "Started emerge on: "+\
-				_unicode_decode(
-					time.strftime("%b %d, %Y %H:%M:%S", time.localtime()),
-					encoding=_encodings['content'], errors='replace'))
-			myelogstr=""
-			if myopts:
-				myelogstr=" ".join(myopts)
-			if myaction:
-				myelogstr+=" "+myaction
-			if myfiles:
-				myelogstr += " " + " ".join(oldargs)
-			emergelog(xterm_titles, " *** emerge " + myelogstr)
-		del oldargs
-
-		def emergeexitsig(signum, frame):
-			signal.signal(signal.SIGINT, signal.SIG_IGN)
-			signal.signal(signal.SIGTERM, signal.SIG_IGN)
-			portage.util.writemsg("\n\nExiting on signal %(signal)s\n" % {"signal":signum})
-			sys.exit(128 + signum)
-		signal.signal(signal.SIGINT, emergeexitsig)
-		signal.signal(signal.SIGTERM, emergeexitsig)
-
-		def emergeexit():
-			"""This gets out final log message in before we quit."""
-			if "--pretend" not in myopts:
-				emergelog(xterm_titles, " *** terminating.")
-			if xterm_titles:
-				xtermTitleReset()
-		portage.atexit_register(emergeexit)
-
-
-		# "update", "system", or just process files
-		validate_ebuild_environment(trees)
-
-		for x in myfiles:
-			if x.startswith(SETPREFIX) or \
-				is_valid_package_atom(x, allow_repo=True):
-				continue
-			if x[:1] == os.sep:
-				continue
-			try:
-				os.lstat(x)
-				continue
-			except OSError:
-				pass
-			msg = []
-			msg.append("'%s' is not a valid package atom." % (x,))
-			msg.append("Please check ebuild(5) for full details.")
-			writemsg_level("".join("!!! %s\n" % line for line in msg),
-				level=logging.ERROR, noiselevel=-1)
-			return 1
-		if "--pretend" not in myopts:
-			display_news_notification(root_config, myopts)
-		retval, settings, trees, mtimedb = self.action_build(settings, trees, mtimedb,
-			myopts, myaction, myfiles, spinner, build_dict)
-		self.post_emerge(myaction, myopts, myfiles, settings["ROOT"],
-			trees, mtimedb, retval)
-
-		return retval
-
-	def make_build_list(self, build_dict, settings, portdb):
-		cpv = build_dict['category']+'/'+build_dict['package']+'-'+build_dict['ebuild_version']
-		pkgdir = os.path.join(settings['PORTDIR'], build_dict['category'] + "/" + build_dict['package'])
-		init_manifest =  gobs_manifest(settings, pkgdir)
-		try:
-			ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir+ "/" + build_dict['package'] + "-" + build_dict['ebuild_version'] + ".ebuild")[0]
-		except:
-			ebuild_version_checksum_tree = None
-		if ebuild_version_checksum_tree == build_dict['checksum']:
-			init_flags = gobs_use_flags(settings, portdb, cpv)
-			build_use_flags_list = init_flags.comper_useflags(build_dict)
-			print("build_use_flags_list", build_use_flags_list)
-			manifest_error = init_manifest.check_file_in_manifest(portdb, cpv, build_dict, build_use_flags_list)
-			if manifest_error is None:
-				build_dict['check_fail'] = False
-				build_cpv_dict = {}
-				build_cpv_dict[cpv] = build_use_flags_list
-				print(build_cpv_dict)
-				return build_cpv_dict
-			else:
-				build_dict['type_fail'] = "Manifest error"
-				build_dict['check_fail'] = True
-		else:
-			build_dict['type_fail'] = "Wrong ebuild checksum"
-			build_dict['check_fail'] = True
-		if build_dict['check_fail'] is True:
-				self.log_fail_queru(build_dict, settings)
-				return None
-		return build_cpv_dict
-
-	def build_procces(self, buildqueru_cpv_dict, build_dict, settings, portdb):
-		build_cpv_list = []
-		depclean_fail = True
-		for k, build_use_flags_list in buildqueru_cpv_dict.iteritems():
-			build_cpv_list.append("=" + k)
-			if not build_use_flags_list == None:
-				build_use_flags = ""
-				for flags in build_use_flags_list:
-					build_use_flags = build_use_flags + flags + " "
-				filetext = '=' + k + ' ' + build_use_flags
-				print('filetext', filetext)
-				with open("/etc/portage/package.use/gobs.use", "a") as f:
-     					f.write(filetext)
-     					f.write('\n')
-		print('build_cpv_list', build_cpv_list)
-		argscmd = []
-		if not "nooneshort" in build_dict['post_message']:
-			argscmd.append("--oneshot")
-		argscmd.append("--buildpkg")
-		argscmd.append("--usepkg")
-		for build_cpv in build_cpv_list:
-			argscmd.append(build_cpv)
-		print(argscmd)
-		# Call main_emerge to build the package in build_cpv_list 
-		build_fail = self.emerge_main(argscmd, build_dict)
-		# Run depclean
-		print('build_fail', build_fail)
-		if not "noclean" in build_dict['post_message']:
-			depclean_fail = main_depclean()
-		try:
-			os.remove("/etc/portage/package.use/gobs.use")
-		except:
-			pass
-		if build_fail is False or depclean_fail is False:
-			return False
-		return True
-
-	def procces_qureru(self):
-		conn=CM.getConnection()
-		build_dict = {}
-		build_dict = get_packages_to_build(conn, self._config_profile)
-		settings, trees, mtimedb = load_emerge_config()
-		portdb = trees[settings["ROOT"]]["porttree"].dbapi
-		if build_dict is None:
-			CM.putConnection(conn)
-			return
-		print("build_dict",  build_dict)
-		if not build_dict['ebuild_id'] is None and build_dict['checksum'] is not None:
-			buildqueru_cpv_dict = self.make_build_list(build_dict, settings, portdb)
-			print('buildqueru_cpv_dict', buildqueru_cpv_dict)
-			if buildqueru_cpv_dict is None:
-				CM.putConnection(conn)
-				return
-			fail_build_procces = self.build_procces(buildqueru_cpv_dict, build_dict, settings, portdb)
-			CM.putConnection(conn)
-			return
-		if not build_dict['post_message'] is [] and build_dict['ebuild_id'] is None:
-			CM.putConnection(conn)
-			return
-		if not build_dict['ebuild_id'] is None and build_dict['checksum'] is None:
-			del_old_queue(conn, build_dict['queue_id'])
-		CM.putConnection(conn)
-		return

diff --git a/gobs/pym/categories.py~ b/gobs/pym/categories.py~
deleted file mode 100644
index f3b2457..0000000
--- a/gobs/pym/categories.py~
+++ /dev/null
@@ -1,30 +0,0 @@
-#from gobs.text import gobs_text
-from gobs.text import get_file_text
-import portage
-from gobs.readconf import get_conf_settings
-reader=get_conf_settings()
-gobs_settings_dict=reader.read_gobs_settings_all()
-# make a CM
-from gobs.ConnectionManager import connectionManager
-CM=connectionManager(gobs_settings_dict)
-#selectively import the pgsql/mysql querys
-if CM.getName()=='pgsql':
-	from gobs.pgsql import *
-
-class gobs_categories(object):
-	
-	def __init__(self, mysettings):
-		self._mysettings = mysettings
-	  
-	def update_categories_db(self, categories):
-		conn=CM.getConnection()
-		# Update categories_meta in the db
-		categories_dir = self._mysettings['PORTDIR'] + "/" + categories + "/"
-		categories_metadata_xml_checksum_tree = portage.checksum.sha256hash(categories_dir + "metadata.xml")[0]
-		categories_metadata_xml_text_tree = get_file_text(categories_dir + "metadata.xml")
-		categories_metadata_xml_checksum_db = get_categories_checksum_db(conn, categories)
-		if categories_metadata_xml_checksum_db is None:
-			add_new_categories_meta_sql(self._conn,categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree)
-		elif categories_metadata_xml_checksum_db != categories_metadata_xml_checksum_tree:
-			update_categories_meta_sql(self._conn,categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree)
-		CM.putConnection(conn)

diff --git a/gobs/pym/check_setup.py~ b/gobs/pym/check_setup.py~
deleted file mode 100644
index 8b9b883..0000000
--- a/gobs/pym/check_setup.py~
+++ /dev/null
@@ -1,102 +0,0 @@
-from __future__ import print_function
-import portage
-import os
-import errno
-from git import *
-from gobs.text import get_file_text
-from gobs.sync import sync_tree
-
-from gobs.readconf import get_conf_settings
-reader=get_conf_settings()
-gobs_settings_dict=reader.read_gobs_settings_all()
-# make a CM
-from gobs.ConnectionManager import connectionManager
-CM=connectionManager(gobs_settings_dict)
-#selectively import the pgsql/mysql querys
-if CM.getName()=='pgsql':
-	from gobs.pgsql import *
-
-def git_pull():
-	repo = Repo("/var/lib/gobs/" + gobs_settings_dict['gobs_gitreponame'] + "/")
-	repo_remote = repo.remotes.origin
-	repo_remote.pull()
-	master = repo.head.reference
-	print(master.log())
-
-def check_make_conf():
-  # FIXME: mark any config updating true in the db when updating the configs
-  # Get the config list
-  conn=CM.getConnection()
-  config_list_all = get_config_list_all(conn)
-  print("Checking configs for changes and errors")
-  configsDict = {}
-  for config_id in config_list_all:
-	  attDict={}
-	  # Set the config dir
-	  check_config_dir = "/var/lib/gobs/" + gobs_settings_dict['gobs_gitreponame'] + "/" + config_id[0] + "/"
-	  make_conf_file = check_config_dir + "etc/portage/make.conf"
-	  # Check if we can open the file and close it
-	  # Check if we have some error in the file (portage.util.getconfig)
-	  # Check if we envorment error with the config (settings.validate)
-	  try:
-		  open_make_conf = open(make_conf_file)
-		  open_make_conf.close()
-		  portage.util.getconfig(make_conf_file, tolerant=0, allow_sourcing=False, expand=True)
-		  mysettings = portage.config(config_root = check_config_dir)
-		  mysettings.validate()
-		  # With errors we update the db on the config and disable the config
-	  except Exception as e:
-		  attDict['config_error'] = e
-		  attDict['active'] = 'False'
-		  print("Fail", config_id[0])
-	  else:
-		  attDict['config_error'] = ''
-		  attDict['active'] = 'True'
-		  print("Pass", config_id[0])
-	  # Get the checksum of make.conf
-	  make_conf_checksum_tree = portage.checksum.sha256hash(make_conf_file)[0]
-	  # Check if we have change the make.conf and update the db with it
-	  attDict['make_conf_text'] = get_file_text(make_conf_file)
-	  attDict['make_conf_checksum_tree'] = make_conf_checksum_tree
-	  configsDict[config_id]=attDict
-  update__make_conf(conn,configsDict)
-  CM.putConnection(conn)
-  print("Updated configurtions")
-
-def check_make_conf_guest(config_profile):
-	conn=CM.getConnection()
-	print('config_profile', config_profile)
-	make_conf_checksum_db = get_profile_checksum(conn,config_profile)
-	print('make_conf_checksum_db', make_conf_checksum_db)
-	if make_conf_checksum_db is None:
-		if get_profile_sync(conn, config_profile) is True
-			if sync_tree():
-				reset_profile_sync(conn, config_profile)
-		CM.putConnection(conn)
-		return False
-	make_conf_file = "/etc/portage/make.conf"
-	make_conf_checksum_tree = portage.checksum.sha256hash(make_conf_file)[0]
-	print('make_conf_checksum_tree', make_conf_checksum_tree)
-	if make_conf_checksum_tree != make_conf_checksum_db[0]:
-		CM.putConnection(conn)
-		return False
-	# Check if we can open the file and close it
-	# Check if we have some error in the file (portage.util.getconfig)
-	# Check if we envorment error with the config (settings.validate)
-	try:
-		open_make_conf = open(make_conf_file)
-		open_make_conf.close()
-		portage.util.getconfig(make_conf_file, tolerant=0, allow_sourcing=False, expand=True)
-		mysettings = portage.config(config_root = "/")
-		mysettings.validate()
-		# With errors we return false
-	except Exception as e:
-		CM.putConnection(conn)
-		return False
-	CM.putConnection(conn)
-	return True
-
-def check_configure_guest(config_profile):
-	pass_make_conf = check_make_conf_guest(config_profile)
-	print(pass_make_conf)
-	return pass_make_conf
\ No newline at end of file

diff --git a/gobs/pym/depclean.py~ b/gobs/pym/depclean.py~
deleted file mode 100644
index b6096b6..0000000
--- a/gobs/pym/depclean.py~
+++ /dev/null
@@ -1,632 +0,0 @@
-from __future__ import print_function
-import errno
-import portage
-from portage._sets.base import InternalPackageSet
-from _emerge.main import parse_opts
-from _emerge.create_depgraph_params import create_depgraph_params
-from _emerge.depgraph import backtrack_depgraph, depgraph, resume_depgraph
-from _emerge.UnmergeDepPriority import UnmergeDepPriority
-from _emerge.SetArg import SetArg
-from _emerge.actions import load_emerge_config
-from _emerge.Package import Package
-from _emerge.unmerge import unmerge
-from portage.util import cmp_sort_key, writemsg, \
-	writemsg_level, writemsg_stdout
-from portage.util.digraph import digraph
-
-def main_depclean():
-	mysettings, mytrees, mtimedb = load_emerge_config()
-	myroot = mysettings["ROOT"]
-	root_config = mytrees[myroot]["root_config"]
-	psets = root_config.setconfig.psets
-	args_set = InternalPackageSet(allow_repo=True)
-	spinner=None
-	scheduler=None
-	tmpcmdline = []
-	tmpcmdline.append("--depclean")
-	tmpcmdline.append("--pretend")
-	print("depclean",tmpcmdline)
-	myaction, myopts, myfiles = parse_opts(tmpcmdline, silent=False)
-	if myfiles:
-		args_set.update(myfiles)
-		matched_packages = False
-		for x in args_set:
-			if vardb.match(x):
-				matched_packages = True
-		if not matched_packages:
-			return 0
-
-	rval, cleanlist, ordered, req_pkg_count, unresolvable = calc_depclean(mysettings, mytrees, mtimedb["ldpath"], myopts, myaction, args_set, spinner)
-	print('rval, cleanlist, ordered, req_pkg_count, unresolvable', rval, cleanlist, ordered, req_pkg_count, unresolvable)
-	if unresolvable != []:
-		return True
-	if cleanlist != []:
-		conflict_package_list = []
-		for depclean_cpv in cleanlist:
-			if portage.versions.cpv_getkey(depclean_cpv) in list(psets["system"]):
-				conflict_package_list.append(depclean_cpv)
-			if portage.versions.cpv_getkey(depclean_cpv) in list(psets['selected']):
-				conflict_package_list.append(depclean_cpv)
-		print('conflict_package_list', conflict_package_list)
-		if conflict_package_list == []:
-			tmpcmdline = []
-			tmpcmdline.append("--depclean")
-			myaction, myopts, myfiles = parse_opts(tmpcmdline, silent=False)
-			unmerge(root_config, myopts, "unmerge", cleanlist, mtimedb["ldpath"], ordered=ordered, scheduler=scheduler)
-			print("Number removed:       "+str(len(cleanlist)))
-			return True
-	return True
-
-def calc_depclean(settings, trees, ldpath_mtimes,
-	myopts, action, args_set, spinner):
-	allow_missing_deps = bool(args_set)
-
-	debug = '--debug' in myopts
-	xterm_titles = "notitles" not in settings.features
-	myroot = settings["ROOT"]
-	root_config = trees[myroot]["root_config"]
-	psets = root_config.setconfig.psets
-	deselect = myopts.get('--deselect') != 'n'
-	required_sets = {}
-	required_sets['world'] = psets['world']
-
-	# When removing packages, a temporary version of the world 'selected'
-	# set may be used which excludes packages that are intended to be
-	# eligible for removal.
-	selected_set = psets['selected']
-	required_sets['selected'] = selected_set
-	protected_set = InternalPackageSet()
-	protected_set_name = '____depclean_protected_set____'
-	required_sets[protected_set_name] = protected_set
-	system_set = psets["system"]
-
-	if not system_set or not selected_set:
-
-		if not system_set:
-			writemsg_level("!!! You have no system list.\n",
-				level=logging.ERROR, noiselevel=-1)
-
-		if not selected_set:
-			writemsg_level("!!! You have no world file.\n",
-					level=logging.WARNING, noiselevel=-1)
-
-		writemsg_level("!!! Proceeding is likely to " + \
-			"break your installation.\n",
-			level=logging.WARNING, noiselevel=-1)
-		if "--pretend" not in myopts:
-			countdown(int(settings["EMERGE_WARNING_DELAY"]), ">>> Depclean")
-
-	if action == "depclean":
-		print(" >>> depclean")
-
-	writemsg_level("\nCalculating dependencies  ")
-	resolver_params = create_depgraph_params(myopts, "remove")
-	resolver = depgraph(settings, trees, myopts, resolver_params, spinner)
-	resolver._load_vdb()
-	vardb = resolver._frozen_config.trees[myroot]["vartree"].dbapi
-	real_vardb = trees[myroot]["vartree"].dbapi
-
-	if action == "depclean":
-
-		if args_set:
-
-			if deselect:
-				# Start with an empty set.
-				selected_set = InternalPackageSet()
-				required_sets['selected'] = selected_set
-				# Pull in any sets nested within the selected set.
-				selected_set.update(psets['selected'].getNonAtoms())
-
-			# Pull in everything that's installed but not matched
-			# by an argument atom since we don't want to clean any
-			# package if something depends on it.
-			for pkg in vardb:
-				if spinner:
-					spinner.update()
-
-				try:
-					if args_set.findAtomForPackage(pkg) is None:
-						protected_set.add("=" + pkg.cpv)
-						continue
-				except portage.exception.InvalidDependString as e:
-					show_invalid_depstring_notice(pkg,
-						pkg.metadata["PROVIDE"], str(e))
-					del e
-					protected_set.add("=" + pkg.cpv)
-					continue
-
-	elif action == "prune":
-
-		if deselect:
-			# Start with an empty set.
-			selected_set = InternalPackageSet()
-			required_sets['selected'] = selected_set
-			# Pull in any sets nested within the selected set.
-			selected_set.update(psets['selected'].getNonAtoms())
-
-		# Pull in everything that's installed since we don't
-		# to prune a package if something depends on it.
-		protected_set.update(vardb.cp_all())
-
-		if not args_set:
-
-			# Try to prune everything that's slotted.
-			for cp in vardb.cp_all():
-				if len(vardb.cp_list(cp)) > 1:
-					args_set.add(cp)
-
-		# Remove atoms from world that match installed packages
-		# that are also matched by argument atoms, but do not remove
-		# them if they match the highest installed version.
-		for pkg in vardb:
-			spinner.update()
-			pkgs_for_cp = vardb.match_pkgs(pkg.cp)
-			if not pkgs_for_cp or pkg not in pkgs_for_cp:
-				raise AssertionError("package expected in matches: " + \
-					"cp = %s, cpv = %s matches = %s" % \
-					(pkg.cp, pkg.cpv, [str(x) for x in pkgs_for_cp]))
-
-			highest_version = pkgs_for_cp[-1]
-			if pkg == highest_version:
-				# pkg is the highest version
-				protected_set.add("=" + pkg.cpv)
-				continue
-
-			if len(pkgs_for_cp) <= 1:
-				raise AssertionError("more packages expected: " + \
-					"cp = %s, cpv = %s matches = %s" % \
-					(pkg.cp, pkg.cpv, [str(x) for x in pkgs_for_cp]))
-
-			try:
-				if args_set.findAtomForPackage(pkg) is None:
-					protected_set.add("=" + pkg.cpv)
-					continue
-			except portage.exception.InvalidDependString as e:
-				show_invalid_depstring_notice(pkg,
-					pkg.metadata["PROVIDE"], str(e))
-				del e
-				protected_set.add("=" + pkg.cpv)
-				continue
-
-	if resolver._frozen_config.excluded_pkgs:
-		excluded_set = resolver._frozen_config.excluded_pkgs
-		required_sets['__excluded__'] = InternalPackageSet()
-
-		for pkg in vardb:
-			if spinner:
-				spinner.update()
-
-			try:
-				if excluded_set.findAtomForPackage(pkg):
-					required_sets['__excluded__'].add("=" + pkg.cpv)
-			except portage.exception.InvalidDependString as e:
-				show_invalid_depstring_notice(pkg,
-					pkg.metadata["PROVIDE"], str(e))
-				del e
-				required_sets['__excluded__'].add("=" + pkg.cpv)
-
-	success = resolver._complete_graph(required_sets={myroot:required_sets})
-	writemsg_level("\b\b... done!\n")
-
-	resolver.display_problems()
-
-	if not success:
-		return True, [], False, 0, []
-
-	def unresolved_deps():
-
-		unresolvable = set()
-		for dep in resolver._dynamic_config._initially_unsatisfied_deps:
-			if isinstance(dep.parent, Package) and \
-				(dep.priority > UnmergeDepPriority.SOFT):
-				unresolvable.add((dep.atom, dep.parent.cpv))
-
-		if not unresolvable:
-			return None
-
-		if unresolvable and not allow_missing_deps:
-
-			prefix = bad(" * ")
-			msg = []
-			msg.append("Dependencies could not be completely resolved due to")
-			msg.append("the following required packages not being installed:")
-			msg.append("")
-			for atom, parent in unresolvable:
-				msg.append("  %s pulled in by:" % (atom,))
-				msg.append("    %s" % (parent,))
-				msg.append("")
-			msg.extend(textwrap.wrap(
-				"Have you forgotten to do a complete update prior " + \
-				"to depclean? The most comprehensive command for this " + \
-				"purpose is as follows:", 65
-			))
-			msg.append("")
-			msg.append("  " + \
-				good("emerge --update --newuse --deep --with-bdeps=y @world"))
-			msg.append("")
-			msg.extend(textwrap.wrap(
-				"Note that the --with-bdeps=y option is not required in " + \
-				"many situations. Refer to the emerge manual page " + \
-				"(run `man emerge`) for more information about " + \
-				"--with-bdeps.", 65
-			))
-			msg.append("")
-			msg.extend(textwrap.wrap(
-				"Also, note that it may be necessary to manually uninstall " + \
-				"packages that no longer exist in the portage tree, since " + \
-				"it may not be possible to satisfy their dependencies.", 65
-			))
-			if action == "prune":
-				msg.append("")
-				msg.append("If you would like to ignore " + \
-					"dependencies then use %s." % good("--nodeps"))
-			writemsg_level("".join("%s%s\n" % (prefix, line) for line in msg),
-				level=logging.ERROR, noiselevel=-1)
-			return unresolvable
-		return None
-
-	unresolvable = unresolved_deps()
-	if not unresolvable is None:
-		return False, [], False, 0, unresolvable
-
-	graph = resolver._dynamic_config.digraph.copy()
-	required_pkgs_total = 0
-	for node in graph:
-		if isinstance(node, Package):
-			required_pkgs_total += 1
-
-	def show_parents(child_node):
-		parent_nodes = graph.parent_nodes(child_node)
-		if not parent_nodes:
-			# With --prune, the highest version can be pulled in without any
-			# real parent since all installed packages are pulled in.  In that
-			# case there's nothing to show here.
-			return
-		parent_strs = []
-		for node in parent_nodes:
-			parent_strs.append(str(getattr(node, "cpv", node)))
-		parent_strs.sort()
-		msg = []
-		msg.append("  %s pulled in by:\n" % (child_node.cpv,))
-		for parent_str in parent_strs:
-			msg.append("    %s\n" % (parent_str,))
-		msg.append("\n")
-		portage.writemsg_stdout("".join(msg), noiselevel=-1)
-
-	def cmp_pkg_cpv(pkg1, pkg2):
-		"""Sort Package instances by cpv."""
-		if pkg1.cpv > pkg2.cpv:
-			return 1
-		elif pkg1.cpv == pkg2.cpv:
-			return 0
-		else:
-			return -1
-
-	def create_cleanlist():
-
-		# Never display the special internal protected_set.
-		for node in graph:
-			if isinstance(node, SetArg) and node.name == protected_set_name:
-				graph.remove(node)
-				break
-
-		pkgs_to_remove = []
-
-		if action == "depclean":
-			if args_set:
-
-				for pkg in sorted(vardb, key=cmp_sort_key(cmp_pkg_cpv)):
-					arg_atom = None
-					try:
-						arg_atom = args_set.findAtomForPackage(pkg)
-					except portage.exception.InvalidDependString:
-						# this error has already been displayed by now
-						continue
-
-					if arg_atom:
-						if pkg not in graph:
-							pkgs_to_remove.append(pkg)
-						elif "--verbose" in myopts:
-							show_parents(pkg)
-
-			else:
-				for pkg in sorted(vardb, key=cmp_sort_key(cmp_pkg_cpv)):
-					if pkg not in graph:
-						pkgs_to_remove.append(pkg)
-					elif "--verbose" in myopts:
-						show_parents(pkg)
-
-		elif action == "prune":
-
-			for atom in args_set:
-				for pkg in vardb.match_pkgs(atom):
-					if pkg not in graph:
-						pkgs_to_remove.append(pkg)
-					elif "--verbose" in myopts:
-						show_parents(pkg)
-
-		return pkgs_to_remove
-
-	cleanlist = create_cleanlist()
-	clean_set = set(cleanlist)
-
-	if cleanlist and \
-		real_vardb._linkmap is not None and \
-		myopts.get("--depclean-lib-check") != "n" and \
-		"preserve-libs" not in settings.features:
-
-		# Check if any of these packages are the sole providers of libraries
-		# with consumers that have not been selected for removal. If so, these
-		# packages and any dependencies need to be added to the graph.
-		linkmap = real_vardb._linkmap
-		consumer_cache = {}
-		provider_cache = {}
-		consumer_map = {}
-
-		writemsg_level(">>> Checking for lib consumers...\n")
-
-		for pkg in cleanlist:
-			pkg_dblink = real_vardb._dblink(pkg.cpv)
-			consumers = {}
-
-			for lib in pkg_dblink.getcontents():
-				lib = lib[len(myroot):]
-				lib_key = linkmap._obj_key(lib)
-				lib_consumers = consumer_cache.get(lib_key)
-				if lib_consumers is None:
-					try:
-						lib_consumers = linkmap.findConsumers(lib_key)
-					except KeyError:
-						continue
-					consumer_cache[lib_key] = lib_consumers
-				if lib_consumers:
-					consumers[lib_key] = lib_consumers
-
-			if not consumers:
-				continue
-
-			for lib, lib_consumers in list(consumers.items()):
-				for consumer_file in list(lib_consumers):
-					if pkg_dblink.isowner(consumer_file):
-						lib_consumers.remove(consumer_file)
-				if not lib_consumers:
-					del consumers[lib]
-
-			if not consumers:
-				continue
-
-			for lib, lib_consumers in consumers.items():
-
-				soname = linkmap.getSoname(lib)
-
-				consumer_providers = []
-				for lib_consumer in lib_consumers:
-					providers = provider_cache.get(lib)
-					if providers is None:
-						providers = linkmap.findProviders(lib_consumer)
-						provider_cache[lib_consumer] = providers
-					if soname not in providers:
-						# Why does this happen?
-						continue
-					consumer_providers.append(
-						(lib_consumer, providers[soname]))
-
-				consumers[lib] = consumer_providers
-
-			consumer_map[pkg] = consumers
-
-		if consumer_map:
-
-			search_files = set()
-			for consumers in consumer_map.values():
-				for lib, consumer_providers in consumers.items():
-					for lib_consumer, providers in consumer_providers:
-						search_files.add(lib_consumer)
-						search_files.update(providers)
-
-			writemsg_level(">>> Assigning files to packages...\n")
-			file_owners = real_vardb._owners.getFileOwnerMap(search_files)
-
-			for pkg, consumers in list(consumer_map.items()):
-				for lib, consumer_providers in list(consumers.items()):
-					lib_consumers = set()
-
-					for lib_consumer, providers in consumer_providers:
-						owner_set = file_owners.get(lib_consumer)
-						provider_dblinks = set()
-						provider_pkgs = set()
-
-						if len(providers) > 1:
-							for provider in providers:
-								provider_set = file_owners.get(provider)
-								if provider_set is not None:
-									provider_dblinks.update(provider_set)
-
-						if len(provider_dblinks) > 1:
-							for provider_dblink in provider_dblinks:
-								provider_pkg = resolver._pkg(
-									provider_dblink.mycpv, "installed",
-									root_config, installed=True)
-								if provider_pkg not in clean_set:
-									provider_pkgs.add(provider_pkg)
-
-						if provider_pkgs:
-							continue
-
-						if owner_set is not None:
-							lib_consumers.update(owner_set)
-
-					for consumer_dblink in list(lib_consumers):
-						if resolver._pkg(consumer_dblink.mycpv, "installed",
-							root_config, installed=True) in clean_set:
-							lib_consumers.remove(consumer_dblink)
-							continue
-
-					if lib_consumers:
-						consumers[lib] = lib_consumers
-					else:
-						del consumers[lib]
-				if not consumers:
-					del consumer_map[pkg]
-
-		if consumer_map:
-			# TODO: Implement a package set for rebuilding consumer packages.
-
-			msg = "In order to avoid breakage of link level " + \
-				"dependencies, one or more packages will not be removed. " + \
-				"This can be solved by rebuilding " + \
-				"the packages that pulled them in."
-
-			prefix = bad(" * ")
-			from textwrap import wrap
-			writemsg_level("".join(prefix + "%s\n" % line for \
-				line in wrap(msg, 70)), level=logging.WARNING, noiselevel=-1)
-
-			msg = []
-			for pkg in sorted(consumer_map, key=cmp_sort_key(cmp_pkg_cpv)):
-				consumers = consumer_map[pkg]
-				consumer_libs = {}
-				for lib, lib_consumers in consumers.items():
-					for consumer in lib_consumers:
-						consumer_libs.setdefault(
-							consumer.mycpv, set()).add(linkmap.getSoname(lib))
-				unique_consumers = set(chain(*consumers.values()))
-				unique_consumers = sorted(consumer.mycpv \
-					for consumer in unique_consumers)
-				msg.append("")
-				msg.append("  %s pulled in by:" % (pkg.cpv,))
-				for consumer in unique_consumers:
-					libs = consumer_libs[consumer]
-					msg.append("    %s needs %s" % \
-						(consumer, ', '.join(sorted(libs))))
-			msg.append("")
-			writemsg_level("".join(prefix + "%s\n" % line for line in msg),
-				level=logging.WARNING, noiselevel=-1)
-
-			# Add lib providers to the graph as children of lib consumers,
-			# and also add any dependencies pulled in by the provider.
-			writemsg_level(">>> Adding lib providers to graph...\n")
-
-			for pkg, consumers in consumer_map.items():
-				for consumer_dblink in set(chain(*consumers.values())):
-					consumer_pkg = resolver._pkg(consumer_dblink.mycpv,
-						"installed", root_config, installed=True)
-					if not resolver._add_pkg(pkg,
-						Dependency(parent=consumer_pkg,
-						priority=UnmergeDepPriority(runtime=True),
-						root=pkg.root)):
-						resolver.display_problems()
-						return True, [], False, 0, []
-
-			writemsg_level("\nCalculating dependencies  ")
-			success = resolver._complete_graph(
-				required_sets={myroot:required_sets})
-			writemsg_level("\b\b... done!\n")
-			resolver.display_problems()
-			if not success:
-				return True, [], False, 0, []
-			unresolvable = unresolved_deps()
-			if not unresolvable is None:
-				return False, [], False, 0, unresolvable
-
-			graph = resolver._dynamic_config.digraph.copy()
-			required_pkgs_total = 0
-			for node in graph:
-				if isinstance(node, Package):
-					required_pkgs_total += 1
-			cleanlist = create_cleanlist()
-			if not cleanlist:
-				return 0, [], False, required_pkgs_total, unresolvable
-			clean_set = set(cleanlist)
-
-	if clean_set:
-		writemsg_level(">>> Calculating removal order...\n")
-		# Use a topological sort to create an unmerge order such that
-		# each package is unmerged before it's dependencies. This is
-		# necessary to avoid breaking things that may need to run
-		# during pkg_prerm or pkg_postrm phases.
-
-		# Create a new graph to account for dependencies between the
-		# packages being unmerged.
-		graph = digraph()
-		del cleanlist[:]
-
-		dep_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
-		runtime = UnmergeDepPriority(runtime=True)
-		runtime_post = UnmergeDepPriority(runtime_post=True)
-		buildtime = UnmergeDepPriority(buildtime=True)
-		priority_map = {
-			"RDEPEND": runtime,
-			"PDEPEND": runtime_post,
-			"DEPEND": buildtime,
-		}
-
-		for node in clean_set:
-			graph.add(node, None)
-			mydeps = []
-			for dep_type in dep_keys:
-				depstr = node.metadata[dep_type]
-				if not depstr:
-					continue
-				priority = priority_map[dep_type]
-
-				try:
-					atoms = resolver._select_atoms(myroot, depstr,
-						myuse=node.use.enabled, parent=node,
-						priority=priority)[node]
-				except portage.exception.InvalidDependString:
-					# Ignore invalid deps of packages that will
-					# be uninstalled anyway.
-					continue
-
-				for atom in atoms:
-					if not isinstance(atom, portage.dep.Atom):
-						# Ignore invalid atoms returned from dep_check().
-						continue
-					if atom.blocker:
-						continue
-					matches = vardb.match_pkgs(atom)
-					if not matches:
-						continue
-					for child_node in matches:
-						if child_node in clean_set:
-							graph.add(child_node, node, priority=priority)
-
-		ordered = True
-		if len(graph.order) == len(graph.root_nodes()):
-			# If there are no dependencies between packages
-			# let unmerge() group them by cat/pn.
-			ordered = False
-			cleanlist = [pkg.cpv for pkg in graph.order]
-		else:
-			# Order nodes from lowest to highest overall reference count for
-			# optimal root node selection (this can help minimize issues
-			# with unaccounted implicit dependencies).
-			node_refcounts = {}
-			for node in graph.order:
-				node_refcounts[node] = len(graph.parent_nodes(node))
-			def cmp_reference_count(node1, node2):
-				return node_refcounts[node1] - node_refcounts[node2]
-			graph.order.sort(key=cmp_sort_key(cmp_reference_count))
-
-			ignore_priority_range = [None]
-			ignore_priority_range.extend(
-				range(UnmergeDepPriority.MIN, UnmergeDepPriority.MAX + 1))
-			while graph:
-				for ignore_priority in ignore_priority_range:
-					nodes = graph.root_nodes(ignore_priority=ignore_priority)
-					if nodes:
-						break
-				if not nodes:
-					raise AssertionError("no root nodes")
-				if ignore_priority is not None:
-					# Some deps have been dropped due to circular dependencies,
-					# so only pop one node in order to minimize the number that
-					# are dropped.
-					del nodes[1:]
-				for node in nodes:
-					graph.remove(node)
-					cleanlist.append(node.cpv)
-
-		return True, cleanlist, ordered, required_pkgs_total, []
-	return True, [], False, required_pkgs_total, []

diff --git a/gobs/pym/init_setup_profile.py~ b/gobs/pym/init_setup_profile.py~
deleted file mode 100644
index e647e1f..0000000
--- a/gobs/pym/init_setup_profile.py~
+++ /dev/null
@@ -1,86 +0,0 @@
-#!/usr/bin/python
-# Copyright 2006-2011 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-
-""" 	This code will update the sql backend with needed info for
-	the Frontend and the Guest deamon. """
-
-import sys
-import os
-
-# Get the options from the config file set in gobs.readconf
-from gobs.readconf import get_conf_settings
-reader=get_conf_settings()
-gobs_settings_dict=reader.read_gobs_settings_all()
-# make a CM
-from gobs.ConnectionManager import connectionManager
-CM=connectionManager(gobs_settings_dict)
-#selectively import the pgsql/mysql querys
-if CM.getName()=='pgsql':
-  from gobs.pgsql import *
-
-from gobs.check_setup import check_make_conf, git_pull
-from gobs.package import gobs_package
-import portage
-
-def setup_profile_main(args=None):
-	"""
-	@param args: command arguments (default: sys.argv[1:])
-	@type args: list
-	"""
-	conn=CM.getConnection()
-	if args is None:
-		args = sys.argv[1:]
-		if args[0] == "-add":
-			git_pull()
-			check_make_conf()
-			print "Check configs done"
-			# Get default config from the configs table  and default_config=1
-			config_id = args[1]
-			default_config_root = "/var/lib/gobs/" + gobs_settings_dict['gobs_gitreponame'] + "/" + config_id + "/"
-			# Set config_root (PORTAGE_CONFIGROOT)  to default_config_root
-			mysettings = portage.config(config_root = default_config_root)
-			myportdb = portage.portdbapi(mysettings=mysettings)
-			init_package = gobs_package(mysettings, myportdb)
-			# get the cp list
-			package_list_tree = package_list_tree = myportdb.cp_all()
-			print "Setting default config to:", config_id
-			config_id_list = []
-			config_id_list.append(config_id)
-			for package_line in sorted(package_list_tree):
-				# FIXME: remove the check for gobs when in tree
-				if package_line != "dev-python/gobs":
-					build_dict = {}
-					packageDict = {}
-					ebuild_id_list = []
-					# split the cp to categories and package
-					element = package_line.split('/')
-					categories = element[0]
-					package = element[1]
-					print "C", categories + "/" + package			# C = Checking
-					pkgdir = mysettings['PORTDIR'] + "/" + categories + "/" + package
-					config_cpv_listDict = init_package.config_match_ebuild(categories, package, config_id_list)
-					if config_cpv_listDict != {}:
-						cpv = categories + "/" + package + "-" + config_cpv_listDict[config_id]['ebuild_version']
-                                                attDict = {}
-                                                attDict['categories'] = categories
-                                                attDict['package'] = package
-                                                attDict['ebuild_version_tree'] = config_cpv_listDict[config_id]['ebuild_version']
-                                                packageDict[cpv] = attDict
-						build_dict['checksum'] = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + config_cpv_listDict[config_id]['ebuild_version'] + ".ebuild")[0]
-						build_dict['package_id'] = have_package_db(conn, categories, package)[0]
-						build_dict['ebuild_version'] = config_cpv_listDict[config_id]['ebuild_version']
-						ebuild_id = get_ebuild_id_db_checksum(conn, build_dict)
-						if ebuild_id is not None:
-							ebuild_id_list.append(ebuild_id)
-							init_package.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config_cpv_listDict)
-
-		if args[0] == "-del":
-			config_id = args[1]
-			querue_id_list = get_queue_id_list_config(conn, config_id)
-			if querue_id_list is not None:
-				for querue_id in querue_id_list:
-					del_old_queue(conn, querue_id)
-	CM.putConnection(conn)
-
-		
\ No newline at end of file

diff --git a/gobs/pym/manifest.py~ b/gobs/pym/manifest.py~
deleted file mode 100644
index fb29f0a..0000000
--- a/gobs/pym/manifest.py~
+++ /dev/null
@@ -1,124 +0,0 @@
-import os
-import warnings
-from portage import os, _encodings, _unicode_decode
-from portage.exception import DigestException, FileNotFound
-from portage.localization import _
-from portage.manifest import Manifest
-import portage
-
-class gobs_manifest(object):
-
-	def __init__ (self, mysettings, pkgdir):
-		self._mysettings = mysettings
-		self._pkgdir = pkgdir
-
-	# Copy of portage.digestcheck() but without the writemsg() stuff
-	def digestcheck(self):
-		"""
-		Verifies checksums. Assumes all files have been downloaded.
-		@rtype: int
-		@returns: None on success and error msg on failure
-		"""
-		
-		myfiles = []
-		justmanifest = None
-		self._mysettings['PORTAGE_QUIET'] = '1'
-			
-		if self._mysettings.get("EBUILD_SKIP_MANIFEST") == "1":
-			return None
-		manifest_path = os.path.join(self._pkgdir, "Manifest")
-		if not os.path.exists(manifest_path):
-			return ("!!! Manifest file not found: '%s'") % manifest_path
-			mf = Manifest(self._pkgdir, self._mysettings["DISTDIR"])
-			manifest_empty = True
-			for d in mf.fhashdict.values():
-				if d:
-					manifest_empty = False
-					break
-			if manifest_empty:
-				return ("!!! Manifest is empty: '%s'") % manifest_path
-			try:
-				if  "PORTAGE_PARALLEL_FETCHONLY" not in self._mysettings:
-					mf.checkTypeHashes("EBUILD")
-					mf.checkTypeHashes("AUX")
-					mf.checkTypeHashes("MISC", ignoreMissingFiles=True)
-				for f in myfiles:
-					ftype = mf.findFile(f)
-					if ftype is None:
-						return ("!!! Missing digest for '%s'") % (f,)
-					mf.checkFileHashes(ftype, f)
-			except FileNotFound as e:
-				return ("!!! A file listed in the Manifest could not be found: %s") % str(e)
-			except DigestException as e:
-				return ("!!! Digest verification failed: %s\nReason: %s\nGot: %s\nExpected: %s") \
-					 % (e.value[0], e.value[1], e.value[2], e.value[3])
-			# Make sure that all of the ebuilds are actually listed in the Manifest.
-			for f in os.listdir(self._pkgdir):
-				pf = None
-				if f[-7:] == '.ebuild':
-					pf = f[:-7]
-				if pf is not None and not mf.hasFile("EBUILD", f):
-					return ("!!! A file is not listed in the Manifest: '%s'") \
-						% os.path.join(pkgdir, f)
-			""" epatch will just grab all the patches out of a directory, so we have to
-			make sure there aren't any foreign files that it might grab."""
-			filesdir = os.path.join(self._pkgdir, "files")
-			for parent, dirs, files in os.walk(filesdir):
-				try:
-					parent = _unicode_decode(parent,
-						encoding=_encodings['fs'], errors='strict')
-				except UnicodeDecodeError:
-					parent = _unicode_decode(parent, encoding=_encodings['fs'], errors='replace')
-					return ("!!! Path contains invalid character(s) for encoding '%s': '%s'") \
-						% (_encodings['fs'], parent)
-				for d in dirs:
-					d_bytes = d
-					try:
-						d = _unicode_decode(d, encoding=_encodings['fs'], errors='strict')
-					except UnicodeDecodeError:
-						d = _unicode_decode(d, encoding=_encodings['fs'], errors='replace')
-						return ("!!! Path contains invalid character(s) for encoding '%s': '%s'") \
-							% (_encodings['fs'], os.path.join(parent, d))
-					if d.startswith(".") or d == "CVS":
-						dirs.remove(d_bytes)
-					for f in files:
-						try:
-							f = _unicode_decode(f, encoding=_encodings['fs'], errors='strict')
-						except UnicodeDecodeError:
-							f = _unicode_decode(f, encoding=_encodings['fs'], errors='replace')
-							if f.startswith("."):
-								continue
-							f = os.path.join(parent, f)[len(filesdir) + 1:]
-							return ("!!! File name contains invalid character(s) for encoding '%s': '%s'") \
-								% (_encodings['fs'], f)
-						if f.startswith("."):
-							continue
-						f = os.path.join(parent, f)[len(filesdir) + 1:]
-						file_type = mf.findFile(f)
-						if file_type != "AUX" and not f.startswith("digest-"):
-							return ("!!! A file is not listed in the Manifest: '%s'") \
-								 % os.path.join(filesdir, f)
-		return None
-
-	def check_file_in_manifest(self, portdb, cpv, build_dict, build_use_flags_list):
-		myfetchlistdict = portage.FetchlistDict(self._pkgdir, self._mysettings, portdb)
-		my_manifest = portage.Manifest(self._pkgdir, self._mysettings['DISTDIR'], fetchlist_dict=myfetchlistdict, manifest1_compat=False, from_scratch=False)
-		if my_manifest.findFile(build_dict['package'] + "-" + build_dict['ebuild_version'] + ".ebuild") is None:
-			return "Ebuild file not found."
-		cpv_fetchmap = portdb.getFetchMap(cpv, useflags=build_use_flags_list, mytree=None)
-		self._mysettings.unlock()
-		try:
-			portage.fetch(cpv_fetchmap, self._mysettings, listonly=0, fetchonly=0, locks_in_subdir='.locks', use_locks=1, try_mirrors=1)
-		except:
-			self._mysettings.lock()
-			return "Can't fetch the file."
-		self._mysettings.lock()
-		try:
-			my_manifest.checkCpvHashes(cpv, checkDistfiles=True, onlyDistfiles=False, checkMiscfiles=True)
-		except:
-			return "Can't fetch the file or the hash failed."
-		try:
-			portdb.fetch_check(cpv, useflags=build_use_flags_list, mysettings=self._mysettings, all=False)
-		except:	
-			return "Fetch check failed."
-		return None
\ No newline at end of file

diff --git a/gobs/pym/old_cpv.py~ b/gobs/pym/old_cpv.py~
deleted file mode 100644
index 4923bf7..0000000
--- a/gobs/pym/old_cpv.py~
+++ /dev/null
@@ -1,89 +0,0 @@
-from __future__ import print_function
-from gobs.readconf import get_conf_settings
-reader=get_conf_settings()
-gobs_settings_dict=reader.read_gobs_settings_all()
-# make a CM
-from gobs.ConnectionManager import connectionManager
-CM=connectionManager(gobs_settings_dict)
-#selectively import the pgsql/mysql querys
-if CM.getName()=='pgsql':
-	from gobs.pgsql import *
-
-class gobs_old_cpv(object):
-	
-	def __init__(self, myportdb, mysettings):
-		self._mysettings = mysettings
-		self._myportdb = myportdb
-
-	def mark_old_ebuild_db(self, categories, package, package_id):
-		conn=CM.getConnection()
-		ebuild_list_tree = sorted(self._myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None))
-		# Get ebuild list on categories, package in the db
-		ebuild_list_db = cp_list_db(conn,package_id)
-		# Check if don't have the ebuild in the tree
-		# Add it to the no active list
-		old_ebuild_list = []
-		for ebuild_line in ebuild_list_db:
-			ebuild_line_db = categories + "/" + package + "-" + ebuild_line[0]
-			if not ebuild_line_db in ebuild_list_tree:
-				old_ebuild_list.append(ebuild_line)
-			# Set no active on ebuilds in the db that no longer in tree
-			if  old_ebuild_list != []:
-				for old_ebuild in old_ebuild_list:
-					print("O", categories + "/" + package + "-" + old_ebuild[0])
-					add_old_ebuild(conn,package_id, old_ebuild_list)
-		# Check if we have older no activ ebuilds then 60 days
-		ebuild_old_list_db = cp_list_old_db(conn,package_id)
-		# Delete older ebuilds in the db
-		if ebuild_old_list_db != []:
-			for del_ebuild_old in ebuild_old_list_db:
-				print("D", categories + "/" + package + "-" + del_ebuild_old[1])
-			del_old_ebuild(conn,ebuild_old_list_db)
-		CM.putConnection(conn)
-
-	def mark_old_package_db(self, package_id_list_tree):
-		conn=CM.getConnection()
-		# Get categories/package list from db
-		package_list_db = cp_all_db(conn)
-		old_package_id_list = []
-		# Check if don't have the categories/package in the tree
-		# Add it to the no active list
-		for package_line in package_list_db:
-			if not package_line in package_id_list_tree:
-				old_package_id_list.append(package_line)
-		# Set no active on categories/package and ebuilds in the db that no longer in tree
-		if old_package_id_list != []:
-			mark_old_list = add_old_package(conn,old_package_id_list)
-			if mark_old_list != []:
-				for x in mark_old_list:
-					element = get_cp_from_package_id(conn,x)
-					print("O", element[0])
-			# Check if we have older no activ categories/package then 60 days
-			del_package_id_old_list = cp_all_old_db(conn,old_package_id_list)
-		# Delete older  categories/package and ebuilds in the db
-		if del_package_id_old_list != []:
-			for i in del_package_id_old_list:
-				element = get_cp_from_package_id(conn,i)
-				print("D", element)
-			del_old_package(conn,del_package_id_old_list)
-		CM.putConnection(conn)
-		
-	def mark_old_categories_db(self):
-		conn=CM.getConnection()
-		# Get categories list from the tree and db
-		categories_list_tree = self._mysettings.categories
-		categories_list_db =get_categories_db(conn)
-		categories_old_list = []
-		# Check if don't have the categories in the tree
-		# Add it to the no active list
-		for categories_line in categories_list_db:
-			if not categories_line[0] in categories_list_tree:
-				old_c = get_old_categories(conn,categories_line[0])
-				if old_c is not None:
-					categories_old_list.append(categories_line)
-		# Delete older  categories in the db
-		if categories_old_list != []:
-			for real_old_categories in categories_old_list:
-				del_old_categories(conn,real_old_categoriess)
-				print("D", real_old_categories)
-		CM.putConnection(conn)
\ No newline at end of file

diff --git a/gobs/pym/package.py~ b/gobs/pym/package.py~
deleted file mode 100644
index 9ae6c57..0000000
--- a/gobs/pym/package.py~
+++ /dev/null
@@ -1,306 +0,0 @@
-from __future__ import print_function
-import portage
-from gobs.flags import gobs_use_flags
-from gobs.repoman_gobs import gobs_repoman
-from gobs.manifest import gobs_manifest
-from gobs.text import get_file_text, get_ebuild_text
-from gobs.old_cpv import gobs_old_cpv
-from gobs.readconf import get_conf_settings
-from gobs.flags import gobs_use_flags
-reader=get_conf_settings()
-gobs_settings_dict=reader.read_gobs_settings_all()
-# make a CM
-from gobs.ConnectionManager import connectionManager
-CM=connectionManager(gobs_settings_dict)
-#selectively import the pgsql/mysql querys
-if CM.getName()=='pgsql':
-	from gobs.pgsql import *
-
-class gobs_package(object):
-
-	def __init__(self, mysettings, myportdb):
-		self._mysettings = mysettings
-		self._myportdb = myportdb
-
-	def change_config(self, config_id):
-		# Change config_root  config_id = table configs.id
-		my_new_setup = "/var/lib/gobs/" + gobs_settings_dict['gobs_gitreponame'] + "/" + config_id + "/"
-		mysettings_setup = portage.config(config_root = my_new_setup)
-		return mysettings_setup
-
-	def config_match_ebuild(self, categories, package, config_list):
-		config_cpv_listDict ={}
-		if config_list == []:
-			return config_cpv_listDict
-		conn=CM.getConnection()
-		for config_id in config_list:
-			# Change config/setup
-			mysettings_setup = self.change_config(config_id)
-			myportdb_setup = portage.portdbapi(mysettings=mysettings_setup)
-			# Get latest cpv from portage with the config
-			latest_ebuild = myportdb_setup.xmatch('bestmatch-visible', categories + "/" + package)
-			latest_ebuild_version = unicode("")
-			# Check if could get cpv from portage
-			if latest_ebuild != "":
-				# Get the version of cpv
-				latest_ebuild_version = portage.versions.cpv_getversion(latest_ebuild)
-				# Get the iuse and use flags for that config/setup
-				init_useflags = gobs_use_flags(mysettings_setup, myportdb_setup, latest_ebuild)
-				iuse_flags_list, final_use_list = init_useflags.get_flags()
-				iuse_flags_list2 = []
-				for iuse_line in iuse_flags_list:
-					iuse_flags_list2.append( init_useflags.reduce_flag(iuse_line))
-					# Dic the needed info
-				attDict = {}
-				attDict['ebuild_version'] = latest_ebuild_version
-				attDict['useflags'] = final_use_list
-				attDict['iuse'] = iuse_flags_list2
-				attDict['package'] = package
-				attDict['categories'] = categories
-				config_cpv_listDict[config_id] = attDict
-			# Clean some cache
-			myportdb_setup.close_caches()
-			portage.portdbapi.portdbapi_instances.remove(myportdb_setup)
-		CM.putConnection(conn)
-		return config_cpv_listDict
-
-	def get_ebuild_metadata(self, ebuild_line):
-		# Get the auxdbkeys infos for the ebuild
-		try:
-			ebuild_auxdb_list = self._myportdb.aux_get(ebuild_line, portage.auxdbkeys)
-		except:
-			ebuild_auxdb_list = []
-		else:
-			for i in range(len(ebuild_auxdb_list)):
-				if ebuild_auxdb_list[i] == '':
-					ebuild_auxdb_list[i] = ''
-		return ebuild_auxdb_list
-
-	def get_packageDict(self, pkgdir, ebuild_line, categories, package, config_id):
-		attDict = {}
-		ebuild_version_tree = portage.versions.cpv_getversion(ebuild_line)
-		ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")[0]
-		ebuild_version_text = get_ebuild_text(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")
-		init_repoman = gobs_repoman(self._mysettings, self._myportdb)
-		repoman_error = init_repoman.check_repoman(categories, package, ebuild_version_tree, config_id)
-		ebuild_version_metadata_tree = self.get_ebuild_metadata(ebuild_line)
-		# if there some error to get the metadata we add rubish to the 
-		# ebuild_version_metadata_tree and set ebuild_version_checksum_tree to 0
-		# so it can be updated next time we update the db
-		if ebuild_version_metadata_tree  == []:
-			ebuild_version_metadata_tree = ['','','','','','','','','','','','','','','','','','','','','','','','','']
-			ebuild_version_checksum_tree = ['0']
-		# add the ebuild to the dict packages
-		attDict['categories'] = categories
-		attDict['package'] = package
-		attDict['ebuild_version_tree'] = ebuild_version_tree
-		attDict['ebuild_version_checksum_tree']= ebuild_version_checksum_tree
-		attDict['ebuild_version_metadata_tree'] = ebuild_version_metadata_tree
-		attDict['ebuild_version_text'] = ebuild_version_text[0]
-		attDict['ebuild_version_revision'] = ebuild_version_text[1]
-		attDict['ebuild_error'] = repoman_error
-		return attDict
-
-	def get_metadataDict(self, packageDict, ebuild_id_list):
-		# Make the metadataDict from packageDict
-		ebuild_i = 0
-		metadataDict ={}
-		for k, v in packageDict.iteritems():
-			attDict = {}
-			metadata_restrictions = []
-			for i in v['ebuild_version_metadata_tree'][4].split():
-				metadata_restrictions.append(i)
-			metadata_keyword = []
-			for i in v['ebuild_version_metadata_tree'][8].split():
-				metadata_keyword.append(i)
-			metadata_iuse = []
-			for i in v['ebuild_version_metadata_tree'][10].split():
-				metadata_iuse.append(i)
-			attDict['restrictions'] = metadata_restrictions
-			attDict['keyword'] = metadata_keyword
-			attDict['iuse'] =  metadata_iuse
-			metadataDict[ebuild_id_list[ebuild_i]] = attDict
-			ebuild_i = ebuild_i +1
-		return metadataDict
-
-	def add_new_ebuild_buildquery_db(self, ebuild_id_list, packageDict, config_cpv_listDict):
-		conn=CM.getConnection()
-		# Get the needed info from packageDict and config_cpv_listDict and put that in buildqueue
-		# Only add it if ebuild_version in packageDict and config_cpv_listDict match
-		if config_cpv_listDict is not None:
-			message = None
-			# Unpack config_cpv_listDict
-			for k, v in config_cpv_listDict.iteritems():
-				config_id = k
-				latest_ebuild_version = v['ebuild_version']
-				iuse_flags_list = list(set(v['iuse']))
-				use_enable= v['useflags']
-				use_disable = list(set(iuse_flags_list).difference(set(use_enable)))
-				# Make a dict with enable and disable use flags for ebuildqueuedwithuses
-				use_flagsDict = {}
-				for x in use_enable:
-					use_flagsDict[x] = True
-				for x in use_disable:
-					use_flagsDict[x] = False
-				# Unpack packageDict
-				i = 0
-				for k, v in packageDict.iteritems():
-					ebuild_id = ebuild_id_list[i]
-					use_flags_list = []
-					use_enable_list = []
-					for u, s in  use_flagsDict.iteritems():
-						use_flags_list.append(u)
-						use_enable_list.append(s)
-					# Comper ebuild_version and add the ebuild_version to buildqueue
-					if portage.vercmp(v['ebuild_version_tree'], latest_ebuild_version) == 0:
-						add_new_package_buildqueue(conn,ebuild_id, config_id, use_flags_list, use_enable_list, message)
-						print("B",  config_id, v['categories'] + "/" + v['package'] + "-" + latest_ebuild_version, "USE:", use_enable)	# B = Build config cpv use-flags
-					i = i +1
-		CM.putConnection(conn)
-
-	def get_package_metadataDict(self, pkgdir, package):
-		# Make package_metadataDict
-		attDict = {}
-		package_metadataDict = {}
-		changelog_checksum_tree = portage.checksum.sha256hash(pkgdir + "/ChangeLog")
-		changelog_text_tree = get_file_text(pkgdir + "/ChangeLog")
-		metadata_xml_checksum_tree = portage.checksum.sha256hash(pkgdir + "/metadata.xml")
-		metadata_xml_text_tree = get_file_text(pkgdir + "/metadata.xml")
-		attDict['changelog_checksum'] =  changelog_checksum_tree[0]
-		attDict['changelog_text'] =  changelog_text_tree
-		attDict['metadata_xml_checksum'] =  metadata_xml_checksum_tree[0]
-		attDict[' metadata_xml_text'] =  metadata_xml_text_tree
-		package_metadataDict[package] = attDict
-		return package_metadataDict
-
-	def add_new_package_db(self, categories, package):
-		conn=CM.getConnection()
-		# add new categories package ebuild to tables package and ebuilds
-		print("C", categories + "/" + package)	# C = Checking
-		print("N", categories + "/" + package)	# N = New Package
-		pkgdir = self._mysettings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR + cp
-		categories_dir = self._mysettings['PORTDIR'] + "/" + categories + "/"
-		# Get the ebuild list for cp
-		ebuild_list_tree = self._myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
-		if ebuild_list_tree == []:
-			CM.putConnection(conn)
-			return
-		config_list  = get_config_list(conn)
-		config_cpv_listDict = self.config_match_ebuild(categories, package, config_list)
-		config_id  = get_default_config(conn)
-		packageDict ={}
-		for ebuild_line in sorted(ebuild_list_tree):
-			# Make the needed packageDict
-			packageDict[ebuild_line] = self.get_packageDict(pkgdir, ebuild_line, categories, package, config_id)
-			# Add the ebuild to db
-			return_id = add_new_package_sql(conn,packageDict)
-			ebuild_id_list = return_id[0]
-			package_id_list = return_id[1]
-			package_id = package_id_list[0]
-			# Add metadataDict to db
-			metadataDict = self.get_metadataDict(packageDict, ebuild_id_list)
-			add_new_metadata(conn,metadataDict)
-			# Add any qa and repoman erro for the ebuild to buildlog
-			qa_error = []
-			init_manifest =  gobs_manifest(self._mysettings, pkgdir)
-			manifest_error = init_manifest.digestcheck()
-			if manifest_error is not None:
-				qa_error.append(manifest_error)
-				print("QA:", categories + "/" + package, qa_error)
-			add_qa_repoman(conn,ebuild_id_list, qa_error, packageDict, config_id)
-			# Add the ebuild to the buildqueru table if needed
-			self.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config_cpv_listDict)
-			# Add some checksum on some files
-			package_metadataDict = self.get_package_metadataDict(pkgdir, package)
-			add_new_package_metadata(conn,package_id, package_metadataDict)
-			# Add the manifest file to db
-			manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
-			get_manifest_text = get_file_text(pkgdir + "/Manifest")
-			add_new_manifest_sql(conn,package_id, get_manifest_text, manifest_checksum_tree)
-		CM.putConnection(conn)
-		print("C", categories + "/" + package + " ... Done.")
-
-	def update_package_db(self, categories, package, package_id):
-		conn=CM.getConnection()
-		# Update the categories and package with new info
-		pkgdir = self._mysettings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR with cp
-		# Get the checksum from the file in portage tree
-		manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
-		# Get the checksum from the db in package table
-		manifest_checksum_db = get_manifest_db(conn,package_id)
-		# if we have the same checksum return else update the package
-		ebuild_list_tree = self._myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
-		print("C", categories + "/" + package)	# C = Checking
-		if manifest_checksum_tree != manifest_checksum_db:
-			print("U", categories + "/" + package)		# U = Update
-			# Get package_metadataDict and update the db with it
-			package_metadataDict = self.get_package_metadataDict(pkgdir, package)
-			update_new_package_metadata(conn,package_id, package_metadataDict)
-			# Get config_cpv_listDict
-			config_list  = get_config_list(conn)
-			config_cpv_listDict = self.config_match_ebuild(categories, package, config_list)
-			config_id  = get_default_config(conn)
-			packageDict ={}
-			for ebuild_line in sorted(ebuild_list_tree):
-				old_ebuild_list = []
-				# split out ebuild version
-				ebuild_version_tree = portage.versions.cpv_getversion(ebuild_line)
-				# Get the checksum of the ebuild in tree and db
-				ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")[0]
-				ebuild_version_manifest_checksum_db = get_ebuild_checksum(conn,package_id, ebuild_version_tree)
-				# Check if the checksum have change
-				if ebuild_version_manifest_checksum_db is None or ebuild_version_checksum_tree != ebuild_version_manifest_checksum_db:
-					# Get packageDict for ebuild
-					packageDict[ebuild_line] = self.get_packageDict(pkgdir, ebuild_line, categories, package, config_id)
-					if ebuild_version_manifest_checksum_db is None:
-						print("N", categories + "/" + package + "-" + ebuild_version_tree)	# N = New ebuild
-					else:
-						print("U", categories + "/" + package + "-" + ebuild_version_tree)	# U = Updated ebuild
-						# Fix so we can use add_new_package_sql(packageDict) to update the ebuilds
-						old_ebuild_list.append(ebuild_version_tree)
-						add_old_ebuild(conn,package_id, old_ebuild_list)
-						update_active_ebuild(conn,package_id, ebuild_version_tree)
-			# Use packageDictand and metadataDict to update the db
-			return_id = add_new_package_sql(conn,packageDict)
-			ebuild_id_list = return_id[0]
-			metadataDict = self.get_metadataDict(packageDict, ebuild_id_list)
-			add_new_metadata(conn,metadataDict)
-			# Get the text in Manifest and update it
-			get_manifest_text = get_file_text(pkgdir + "/Manifest")
-			update_manifest_sql(conn,package_id, get_manifest_text, manifest_checksum_tree)
-			# Add any qa and repoman erros to buildlog
-			qa_error = []
-			init_manifest =  gobs_manifest(self._mysettings, pkgdir)
-			manifest_error = init_manifest.digestcheck()
-			if manifest_error is not None:
-				qa_error.append(manifest_error)
-				print("QA:", categories + "/" + package, qa_error)
-			add_qa_repoman(conn,ebuild_id_list, qa_error, packageDict, config_id)
-			# Add the ebuild to the buildqueru table if needed
-			self.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config_cpv_listDict)
-			# Mark or remove any old ebuilds
-			init_old_cpv = gobs_old_cpv(self._myportdb, self._mysettings)
-			init_old_cpv.mark_old_ebuild_db(categories, package, package_id)
-		CM.putConnection(conn)
-		print("C", categories + "/" + package + " ... Done.")
-
-	def update_ebuild_db(self, build_dict):
-		conn=CM.getConnection()
-		config_id = build_dict['config_profile']
-		categories = build_dict['categories']
-		package = build_dict['package']
-		package_id = build_dict['package_id']
-		cpv = build_dict['cpv']
-		ebuild_version_tree = build_dict['ebuild_version']
-		pkgdir = self._mysettings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR with cp
-		packageDict ={}
-		ebuild_version_manifest_checksum_db = get_ebuild_checksum(conn,package_id, ebuild_version_tree)
-		packageDict[cpv] = self.get_packageDict(pkgdir, cpv, categories, package, config_id)
-		old_ebuild_list = []
-		if ebuild_version_manifest_checksum_db is not None:
-			old_ebuild_list.append(ebuild_version_tree)
-			add_old_ebuild(conn,package_id, old_ebuild_list)
-			update_active_ebuild(conn,package_id, ebuild_version_tree)
-		return_id = add_new_package_sql(conn,packageDict)
-		print('return_id', return_id)
-		CM.putConnection(conn)
\ No newline at end of file

diff --git a/gobs/pym/pgsql.py~ b/gobs/pym/pgsql.py~
deleted file mode 100644
index ea1f1f1..0000000
--- a/gobs/pym/pgsql.py~
+++ /dev/null
@@ -1,638 +0,0 @@
-#every function takes a connection as a parameter that is provided by the CM
-from __future__ import print_function
-
-def get_default_config(connection):
-	cursor = connection.cursor()
-	sqlQ = 'SELECT id FROM configs WHERE default_config = True'
-	cursor.execute(sqlQ)
-	return cursor.fetchone()
-
-def get_profile_checksum(connection, config_profile):
-    cursor = connection.cursor()
-    sqlQ = "SELECT make_conf_checksum FROM configs WHERE active = 'True' AND id = %s AND updateing = 'False' AND sync = 'False'"
-    cursor.execute(sqlQ, (config_profile,))
-    return cursor.fetchone()
-
-def get_profile_sync(connection, config_profile):
-	cursor = connection.cursor()
-	sqlQ = "SELECT sync FROM configs WHERE active = 'True' AND id = %s AND updateing = 'False'"
-	cursor.execute(sqlQ, (config_profile,))
-	return cursor.fetchone()
-
-def set_profile_sync(connection):
-	cursor = connection.cursor()
-	sqlQ = "UPDATE configs SET sync = 'False' WHERE active = 'True'"
-	cursor.execute(sqlQ)
-	connection.commit()
-
-def reset_profile_sync(connection, config_profile):
-	cursor = connection.cursor()
-	sqlQ = "UPDATE configs SET sync = 'False' WHERE active = 'True' AND  id = %s"
-	cursor.execute(sqlQ, (config_profile,))
-	connection.commit()
-
-def set_profile_updating(connection):
-	cursor = connection.cursor()
-	sqlQ = "UPDATE configs SET updating = 'True' WHERE active = 'True'"
-	cursor.execute(sqlQ)
-	connection.commit()
-
-def reset_profile_sync(connection, config_profile):
-	cursor = connection.cursor()
-	sqlQ = "UPDATE configs SET updating = 'False' WHERE active = 'True'"
-	cursor.execute(sqlQ)
-	connection.commit()
-
-def get_packages_to_build(connection, config_profile):
-  cursor =connection.cursor()
-  # no point in returning dead ebuilds, to just chuck em out later
-  sqlQ1 = '''SELECT post_message, queue_id, ebuild_id FROM buildqueue WHERE config = %s AND extract(epoch from (NOW()) - timestamp) > 7200 ORDER BY queue_id LIMIT 1'''
-
-  sqlQ2 ='''SELECT ebuild_id,category,package_name,ebuild_version,ebuild_checksum FROM ebuilds,buildqueue,packages
-    WHERE buildqueue.ebuild_id=ebuilds.id AND ebuilds.package_id=packages.package_id AND queue_id = %s AND ebuilds.active = TRUE'''
-  
-  # get use flags to use
-  sqlQ3 = "SELECT useflag, enabled FROM ebuildqueuedwithuses WHERE queue_id = %s"
-  cursor.execute(sqlQ1, (config_profile,))
-  build_dict={}
-  entries = cursor.fetchone()
-  if entries is None:
-    return None
-  if entries[2] is None:
-    build_dict['ebuild_id'] = None
-    build_dict['queue_id'] = entries[1]
-    return build_dict
-  msg_list = []
-  if not entries[0] is None:
-    for msg in entries[0].split(" "):
-      msg_list.append(msg)
-  build_dict['post_message'] = msg_list
-  build_dict['queue_id'] = entries[1]
-  build_dict['ebuild_id']=entries[2]
-  cursor.execute(sqlQ2, (build_dict['queue_id'],))
-  #make a list that contains objects that haves ebuild_id and post_message +the lot as attributes
-  entries = cursor.fetchone()
-  if entries is None:
-    build_dict['checksum']= None
-    return build_dict
-  build_dict['ebuild_id']=entries[0]
-  build_dict['category']=entries[1]
-  build_dict['package']=entries[2]
-  build_dict['ebuild_version']=entries[3]
-  build_dict['checksum']=entries[4]
-
-  #add a enabled and disabled list to the objects in the item list
-  cursor.execute(sqlQ3, (build_dict['queue_id'],))
-  uses={}
-  for row in cursor.fetchall():
-    uses[ row[0] ] = row[1]
-  build_dict['build_useflags']=uses
-  return build_dict
-
-def check_revision(connection, build_dict):
-  cursor = connection.cursor()
-  sqlQ1 = 'SELECT queue_id FROM buildqueue WHERE ebuild_id = %s AND config = %s'
-  sqlQ2 = "SELECT useflag FROM ebuildqueuedwithuses WHERE queue_id = %s AND enabled = 'True'"
-  cursor.execute(sqlQ1, (build_dict['ebuild_id'], build_dict['config_profile']))
-  queue_id_list = cursor.fetchall()
-  if queue_id_list == []:
-    return None
-  for queue_id in queue_id_list:
-    cursor.execute(sqlQ2, (queue_id[0],))
-    entries = cursor.fetchall()
-    queue_useflags = []
-    if entries == []:
-      queue_useflags = None
-    else:
-      for use_line in sorted(entries):
-	      queue_useflags.append(use_line[0])
-    if queue_useflags == build_dict['build_useflags']:
-      return queue_id[0]
-  return None
-
-def get_config_list(connection):
-  cursor = connection.cursor()
-  sqlQ = 'SELECT id FROM configs WHERE default_config = False AND active = True'
-  cursor.execute(sqlQ)
-  entries = cursor.fetchall()
-  if entries == ():
-    return None
-  else:
-    config_id_list = []
-    for config_id in entries:
-      config_id_list.append(config_id[0])
-    return config_id_list
-
-def get_config_list_all(connection):
-  cursor = connection.cursor()
-  sqlQ = 'SELECT id FROM configs'
-  cursor.execute(sqlQ)
-  return cursor.fetchall()
-
-def update__make_conf(connection, configsDict):
-  cursor = connection.cursor()
-  sqlQ = 'UPDATE configs SET make_conf_checksum = %s, make_conf_text = %s, active = %s, config_error = %s WHERE id = %s'
-  for k, v in configsDict.iteritems():
-    params = [v['make_conf_checksum_tree'], v['make_conf_text'], v['active'], v['config_error'], k]
-    cursor.execute(sqlQ, params)
-  connection.commit()
-
-def have_package_db(connection, categories, package):
-  cursor = connection.cursor()
-  sqlQ ='SELECT package_id FROM packages WHERE category = %s AND package_name = %s'
-  params = categories, package
-  cursor.execute(sqlQ, params)
-  return cursor.fetchone()
-  
-def have_activ_ebuild_id(connection, ebuild_id):
-	cursor = connection.cursor()
-	sqlQ = 'SELECT ebuild_checksum FROM ebuilds WHERE id = %s AND active = TRUE'
-	cursor.execute(sqlQ, (ebuild_id,))
-	entries = cursor.fetchone()
-	if entries is None:
-		return None
-	# If entries is not None we need [0]
-	return entries[0]
-
-def get_categories_db(connection):
-  cursor = connection.cursor()
-  sqlQ =' SELECT category FROM categories'
-  cursor.execute(sqlQ)
-  return cursor.fetchall()
-
-def get_categories_checksum_db(connection, categories):
-  cursor = connection.cursor()
-  sqlQ =' SELECT metadata_xml_checksum FROM categories_meta WHERE category = %s'
-  cursor.execute(sqlQ, (categories,))
-  return cursor.fetchone()
-
-def add_new_categories_meta_sql(connection, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree):
-  cursor = connection.cursor()
-  sqlQ = 'INSERT INTO categories_meta (category, metadata_xml_checksum, metadata_xml_text) VALUES  ( %s, %s, %s )'
-  params = categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree
-  cursor.execute(sqlQ, params)
-  connection.commit()
-
-def update_categories_meta_sql(connection, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree):
-  cursor = connection.cursor()
-  sqlQ ='UPDATE categories_meta SET metadata_xml_checksum = %s, metadata_xml_text = %s WHERE category = %s'
-  params = (categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree, categories)
-  cursor.execute(sqlQ, params)
-  connection.commit()
-
-def add_new_manifest_sql(connection, package_id, get_manifest_text, manifest_checksum_tree):
-  cursor = connection.cursor()
-  sqlQ = 'INSERT INTO manifest (package_id, manifest, checksum) VALUES  ( %s, %s, %s )'
-  params = package_id, get_manifest_text, manifest_checksum_tree
-  cursor.execute(sqlQ, params)
-  connection.commit()
-
-def add_new_package_metadata(connection, package_id, package_metadataDict):
-  cursor = connection.cursor()
-  sqlQ = 'SELECT changelog_checksum FROM packages_meta WHERE package_id = %s'
-  cursor.execute(sqlQ, (package_id,))
-  if cursor.fetchone() is None:
-    sqlQ = 'INSERT INTO packages_meta (package_id, changelog_text, changelog_checksum, metadata_text, metadata_checksum) VALUES  ( %s, %s, %s, %s, %s )'
-    for k, v in package_metadataDict.iteritems():
-      params = package_id, v['changelog_text'], v['changelog_checksum'], v[' metadata_xml_text'], v['metadata_xml_checksum']
-      cursor.execute(sqlQ, params)
-    connection.commit()
-
-def update_new_package_metadata(connection, package_id, package_metadataDict):
-  cursor = connection.cursor()
-  sqlQ = 'SELECT changelog_checksum, metadata_checksum FROM packages_meta WHERE package_id = %s'
-  cursor.execute(sqlQ, package_id)
-  entries = cursor.fetchone()
-  if entries is None:
-    changelog_checksum_db = None
-    metadata_checksum_db = None
-  else:
-    changelog_checksum_db = entries[0]
-    metadata_checksum_db = entries[1]
-  for k, v in package_metadataDict.iteritems():
-    if changelog_checksum_db != v['changelog_checksum']:
-      sqlQ = 'UPDATE packages_meta SET changelog_text = %s, changelog_checksum = %s WHERE package_id = %s'
-      params = v['changelog_text'], v['changelog_checksum'], package_id
-      cursor.execute(sqlQ, params)
-    if metadata_checksum_db != v['metadata_xml_checksum']:
-      sqlQ = 'UPDATE packages_meta SET metadata_text = %s, metadata_checksum = %s WHERE package_id = %s'
-      params = v[' metadata_xml_text'], v['metadata_xml_checksum'], package_id
-      cursor.execute(sqlQ, params)
-  connection.commit()
-
-def get_manifest_db(connection, package_id):
-  cursor = connection.cursor()
-  sqlQ = 'SELECT checksum FROM manifest WHERE package_id = %s'
-  cursor.execute(sqlQ, package_id)
-  entries = cursor.fetchone()
-  if entries is None:
-	  return None
-  # If entries is not None we need [0]
-  return entries[0]
-
-def update_manifest_sql(connection, package_id, get_manifest_text, manifest_checksum_tree):
-  cursor = connection.cursor()
-  sqlQ = 'UPDATE manifest SET checksum = %s, manifest = %s WHERE package_id = %s'
-  params = (manifest_checksum_tree, get_manifest_text, package_id)
-  cursor.execute(sqlQ, params)
-  connection.commit()
-
-def add_new_metadata(connection, metadataDict):
-  cursor = connection.cursor()
-  for k, v in metadataDict.iteritems():
-    #moved the cursor out side of the loop
-    sqlQ = 'SELECT updaterestrictions( %s, %s )'
-    params = k, v['restrictions']
-    cursor.execute(sqlQ, params)
-    sqlQ = 'SELECT updatekeywords( %s, %s )'
-    params = k, v['keyword']
-    cursor.execute(sqlQ, params)
-    sqlQ = 'SELECT updateiuse( %s, %s )'
-    params = k, v['iuse']
-    cursor.execute(sqlQ, params)
-  connection.commit()
-
-def add_new_package_sql(connection, packageDict):
-  #lets have a new cursor for each metod as per best practice
-  cursor = connection.cursor()
-  sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
-  ebuild_id_list = []
-  package_id_list = []
-  for k, v in packageDict.iteritems():
-    params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
-    v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
-    v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
-    v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
-    v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
-    v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
-    v['ebuild_version_metadata_tree'][16]]
-    cursor.execute(sqlQ, params)
-    mid = cursor.fetchone()
-    mid=mid[0]
-    ebuild_id_list.append(mid[1])
-    package_id_list.append(mid[0])
-  connection.commit()
-  # add_new_metadata(metadataDict)
-  return ebuild_id_list, package_id_list
-
-def add_new_ebuild_sql(connection, packageDict, new_ebuild_list):
-  #lets have a new cursor for each metod as per best practice
-  cursor = connection.cursor()
-  sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
-  ebuild_id_list = []
-  package_id_list = []
-  for k, v in packageDict.iteritems():
-    for x in new_ebuild_list:
-      if x == v['ebuild_version_tree']:
-        params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
-        v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
-        v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
-        v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
-        v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
-        v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
-        v['ebuild_version_metadata_tree'][16]]
-        cursor.execute(sqlQ, params)
-        mid = cursor.fetchone()
-        mid=mid[0]
-        ebuild_id_list.append(mid[1])
-        package_id_list.append(mid[0])
-  connection.commit()
-  # add_new_metadata(metadataDict)
-  return ebuild_id_list, package_id_list
-
-def update_active_ebuild(connection, package_id, ebuild_version_tree):
-  cursor = connection.cursor()
-  sqlQ ="UPDATE ebuilds SET active = 'False', timestamp = now() WHERE package_id = %s AND ebuild_version = %s AND active = 'True'"
-  cursor.execute(sqlQ, (package_id, ebuild_version_tree))
-  connection.commit()
-
-def get_ebuild_id_db(connection, categories, package, ebuild_version_tree):
-	cursor = connection.cursor()
-	sqlQ ='SELECT id FROM packages WHERE category = %s AND ebuild_name = %s AND ebuild_version = %s'
-	cursor.execute(sqlQ, (categories, package, ebuild_version_tree))
-	entries = cursor.fetchone()
-	return entries
-
-def get_ebuild_id_db_checksum(connection, build_dict):
-	cursor = connection.cursor()
-	sqlQ = 'SELECT id FROM ebuilds WHERE ebuild_version = %s AND ebuild_checksum = %s AND package_id = %s'
-	cursor.execute(sqlQ, (build_dict['ebuild_version'], build_dict['checksum'], build_dict['package_id']))
-	ebuild_id_list = sorted(cursor.fetchall())
-	if ebuild_id_list == []:
-		return None
-	return ebuild_id_list[0]
-
-def get_cpv_from_ebuild_id(connection, ebuild_id):
-	cursor = connection.cursor()
-	#wasent used
-	#sqlQ = 'SELECT package_id FROM ebuild WHERE id = %s'
-	sqlQ='SELECT category, ebuild_name, ebuild_version FROM packages WHERE id = %s'
-	cursor.execute(sqlQ, ebuild_id)
-	entries = cursor.fetchone()
-	return entries
-
-def get_cp_from_package_id(connection, package_id):
-  cursor =connection.cursor()
-  sqlQ = "SELECT ARRAY_TO_STRING(ARRAY[category, package_name] , '/') AS cp FROM packages WHERE package_id = %s"
-  cursor.execute(sqlQ, (package_id,))
-  return cursor.fetchone()
-
-def get_keyword_id_db(connection, arch, stable):
-	cursor =connection.cursor()
-	sqlQ ='SELECT id_keyword FROM keywords WHERE ARCH = %s AND stable = %s'
-	cursor.execute(sqlQ, (arch, stable))
-	entries = cursor.fetchone()
-	#why only return 1 entery? if that IS the point use top(1)
-	return entries
-	
-def add_new_keywords(connection, ebuild_id, keyword_id):
-	cursor = connection.cursor()
-	sqlQ ='INSERT INTO keywordsToEbuild (ebuild_id, id_keyword) VALUES  ( %s, %s )'
-	cursor.execute(sqlQ, (ebuild_id, keyword_id))
-	connection.commit()
-		
-def have_package_buildqueue(connection, ebuild_id, config_id):
-	cursor = connection.cursor()
-	sqlQ = 'SELECT useflags FROM buildqueue WHERE  ebuild_id = %s  AND config_id = %s'
-	params = (ebuild_id[0], config_id)
-	cursor.execute(sqlQ, params)
-	entries = cursor.fetchone()
-	return entries
-
-def get_queue_id_list_config(connection, config_id):
-	cursor = connection.cursor()
-	sqlQ = 'SELECT queue_id FROM buildqueue WHERE config = %s'
-	cursor.execute(sqlQ,  (config_id,))
-	entries = cursor.fetchall()
-	return entries
-
-def add_new_package_buildqueue(connection, ebuild_id, config_id, iuse_flags_list, use_enable, message):
-  cursor = connection.cursor()
-  sqlQ="SELECT insert_buildqueue( %s, %s, %s, %s, %s )"
-  if not iuse_flags_list:
-    iuse_flags_list=None
-    use_enable=None
-  params = ebuild_id, config_id, iuse_flags_list, use_enable, message
-  cursor.execute(sqlQ, params)
-  connection.commit()
-  
-def get_ebuild_checksum(connection, package_id, ebuild_version_tree):
-  cursor = connection.cursor()
-  sqlQ = 'SELECT ebuild_checksum FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = TRUE'
-  cursor.execute(sqlQ, (package_id, ebuild_version_tree))
-  entries = cursor.fetchone()
-  if entries is None:
-	  return None
- # If entries is not None we need [0]
-  return entries[0]
-
-def cp_all_db(connection):
-  cursor = connection.cursor()
-  sqlQ = "SELECT package_id FROM packages"
-  cursor.execute(sqlQ)
-  return cursor.fetchall()
-
-def add_old_package(connection, old_package_list):
-  cursor = connection.cursor()
-  mark_old_list = []
-  sqlQ = "UPDATE ebuilds SET active = 'FALSE', timestamp = NOW() WHERE package_id = %s AND active = 'TRUE' RETURNING package_id"
-  for old_package in old_package_list:
-    cursor.execute(sqlQ, (old_package[0],))
-    entries = cursor.fetchone()
-    if entries is not None:
-      mark_old_list.append(entries[0])
-  connection.commit()
-  return mark_old_list
-  
-def get_old_categories(connection, categories_line):
-  cursor = connection.cursor()
-  sqlQ = "SELECT package_name FROM packages WHERE category = %s"
-  cursor.execute(sqlQ (categories_line))
-  return cursor.fetchone()
-
-def del_old_categories(connection, real_old_categoriess):
-  cursor = connection.cursor()
-  sqlQ1 = 'DELETE FROM categories_meta WHERE category = %s'
-  sqlQ2 = 'DELETE FROM categories categories_meta WHERE category = %s'
-  cursor.execute(sqlQ1 (real_old_categories))
-  cursor.execute(sqlQ2 (real_old_categories))
-  connection.commit()
-
-def add_old_ebuild(connection, package_id, old_ebuild_list):
-  cursor = connection.cursor()
-  sqlQ1 = "UPDATE ebuilds SET active = 'FALSE' WHERE package_id = %s AND ebuild_version = %s"
-  sqlQ2 = "SELECT id FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = 'TRUE'"
-  sqlQ3 = "SELECT queue_id FROM buildqueue WHERE ebuild_id = %s"
-  sqlQ4 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
-  sqlQ5 = 'DELETE FROM buildqueue WHERE queue_id = %s'
-  for old_ebuild in  old_ebuild_list:
-    cursor.execute(sqlQ2, (package_id, old_ebuild[0]))
-    ebuild_id_list = cursor.fetchall()
-    if ebuild_id_list is not None:
-      for ebuild_id in ebuild_id_list:
-        cursor.execute(sqlQ3, (ebuild_id))
-        queue_id_list = cursor.fetchall()
-        if queue_id_list is not None:
-          for queue_id in queue_id_list:
-            cursor.execute(sqlQ4, (queue_id))
-            cursor.execute(sqlQ5, (queue_id))
-        cursor.execute(sqlQ1, (package_id, old_ebuild[0]))
-  connection.commit()
-  
-def cp_all_old_db(connection, old_package_id_list):
-  cursor = connection.cursor()
-  old_package_list = []
-  for old_package in old_package_id_list:
-    sqlQ = "SELECT package_id FROM ebuilds WHERE package_id = %s AND active = 'FALSE' AND date_part('days', NOW() - timestamp) < 60"
-    cursor.execute(sqlQ, old_package)
-    entries = cursor.fetchone()
-    if entries is None:
-      old_package_list.append(old_package)
-  return old_package_list
-
-def del_old_queue(connection, queue_id):
-	cursor = connection.cursor()
-	sqlQ1 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
-	sqlQ2 = 'DELETE FROM querue_retest WHERE querue_id  = %s'
-	sqlQ3 = 'DELETE FROM buildqueue WHERE queue_id  = %s'
-	cursor.execute(sqlQ1, (queue_id,))
-	cursor.execute(sqlQ2, (queue_id,))
-	cursor.execute(sqlQ3, (queue_id,))
-	connection.commit()
-
-def del_old_ebuild(connection, ebuild_old_list_db):
-	cursor = connection.cursor()
-	sqlQ1 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s'
-	sqlQ2 = 'DELETE FROM qa_problems WHERE build_id = %s'
-	sqlQ3 = 'DELETE FROM repoman_problems WHERE build_id = %s'
-	sqlQ4 = 'DELETE FROM ebuildbuildwithuses WHERE build_id = %s'
-	sqlQ5 = 'DELETE FROM ebuildhaveskeywords WHERE ebuild_id = %s'
-	sqlQ6 = 'DELETE FROM ebuildhavesiuses WHERE ebuild = %s'
-	sqlQ7 = 'DELETE FROM ebuildhavesrestrictions WHERE ebuild_id = %s'
-	sqlQ8 = 'DELETE FROM buildlog WHERE ebuild_id = %s'
-	sqlQ9 = 'SELECT queue_id FROM buildqueue WHERE ebuild_id = %s'
-	sqlQ10 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
-	sqlQ11 = 'DELETE FROM buildqueue WHERE ebuild_id  = %s'
-	sqlQ12 = 'DELETE FROM ebuilds WHERE id  = %s'
-	for ebuild_id in ebuild_old_list_db:
-		cursor.execute(sqlQ1, (ebuild_id[0],))
-		build_id_list = cursor.fetchall()
-		if  build_id_list != []:
-			for build_id in build_id_list:
-				cursor.execute(sqlQ2, (build_id[0],))
-				cursor.execute(sqlQ3, (build_id[0],))
-				cursor.execute(sqlQ4, (build_id[0],))
-		cursor.execute(sqlQ9, (ebuild_id[0],))
-		queue_id_list = cursor.fetchall()
-		if queue_id_list != []:
-			for queue_id in queue_id_list:
-				cursor.execute(sqlQ10, (queue_id[0],))
-		cursor.execute(sqlQ5, (ebuild_id[0],))
-		cursor.execute(sqlQ6, (ebuild_id[0],))
-		cursor.execute(sqlQ7, (ebuild_id[0],))
-		cursor.execute(sqlQ8, (ebuild_id[0],))
-		cursor.execute(sqlQ11, (ebuild_id[0],))
-		cursor.execute(sqlQ12, (ebuild_id[0],))
-	connection.commit()
-  
-def del_old_package(connection, package_id_list):
-  cursor = connection.cursor()
-  sqlQ1 = 'SELECT id FROM ebuilds WHERE package_id = %s'
-  sqlQ2 = 'DELETE FROM ebuilds WHERE package_id = %s'
-  sqlQ3 = 'DELETE FROM manifest WHERE package_id = %s'
-  sqlQ4 = 'DELETE FROM packages_meta WHERE package_id = %s'
-  sqlQ5 = 'DELETE FROM packages WHERE package_id = %s'
-  for package_id in package_id_list:
-    cursor.execute(sqlQ1, package_id)
-    ebuild_id_list = cursor.fetchall()
-    del_old_ebuild(connection, ebuild_id_list)
-    cursor.execute(sqlQ2, (package_id,))
-    cursor.execute(sqlQ3, (package_id,))
-    cursor.execute(sqlQ4, (package_id,))
-    cursor.execute(sqlQ5, (package_id,))
-  connection.commit()
-
-def cp_list_db(connection, package_id):
-  cursor = connection.cursor()
-  sqlQ = "SELECT ebuild_version FROM ebuilds WHERE active = 'TRUE' AND package_id = %s"
-  cursor.execute(sqlQ, (package_id))
-  return cursor.fetchall()
-
-def cp_list_old_db(connection, package_id):
-  cursor = connection.cursor()
-  sqlQ ="SELECT id, ebuild_version FROM ebuilds WHERE active = 'FALSE' AND package_id = %s AND date_part('days', NOW() - timestamp) > 60"
-  cursor.execute(sqlQ, package_id)
-  return cursor.fetchall()
-
-def move_queru_buildlog(connection, queue_id, build_error, summary_error, build_log_dict):
-	cursor = connection.cursor()
-	repoman_error_list = build_log_dict['repoman_error_list']
-	qa_error_list = build_log_dict['qa_error_list']
-	sqlQ = 'SELECT make_buildlog( %s, %s, %s, %s, %s, %s)'
-	cursor.execute(sqlQ, (queue_id, summary_error, build_error, build_log_dict['logfilename'], qa_error_list, repoman_error_list))
-	entries = cursor.fetchone()
-	connection.commit()
-	return entries
-
-def add_new_buildlog(connection, build_dict, use_flags_list, use_enable_list, build_error, summary_error, build_log_dict):
-	cursor = connection.cursor()
-	repoman_error_list = build_log_dict['repoman_error_list']
-	qa_error_list = build_log_dict['qa_error_list']
-	if not use_flags_list:
-		use_flags_list=None
-		use_enable_list=None
-	sqlQ = 'SELECT make_deplog( %s, %s, %s, %s, %s, %s, %s, %s, %s)'
-	params = (build_dict['ebuild_id'], build_dict['config_profile'], use_flags_list, use_enable_list, summary_error, build_error, build_log_dict['logfilename'], qa_error_list, repoman_error_list)
-	cursor.execute(sqlQ, params)
-	entries = cursor.fetchone()
-	connection.commit()
-	if entries is None:
-		return None
-	# If entries is not None we need [0]
-	return entries[0]
-
-def add_qa_repoman(connection, ebuild_id_list, qa_error, packageDict, config_id):
-  cursor = connection.cursor()
-  ebuild_i = 0
-  for k, v in packageDict.iteritems():
-    ebuild_id = ebuild_id_list[ebuild_i]
-    sqlQ = "INSERT INTO buildlog (ebuild_id, config, error_summary, timestamp, hash ) VALUES  ( %s, %s, %s, now(), '1' ) RETURNING build_id"
-    if v['ebuild_error'] != [] or qa_error != []:
-      if v['ebuild_error'] != [] or qa_error == []:
-        summary = "Repoman"
-      elif v['ebuild_error'] == [] or qa_error != []:
-        summary = "QA"
-      else:
-        summary = "QA:Repoman"
-      params = (ebuild_id, config_id, summary)
-      cursor.execute(sqlQ, params)
-      build_id = cursor.fetchone()
-      if v['ebuild_error'] != []:
-        sqlQ = 'INSERT INTO repoman_problems (problem, build_id ) VALUES ( %s, %s )'
-        for x in v['ebuild_error']:
-          params = (x, build_id)
-          cursor.execute(sqlQ, params)
-      if qa_error != []:
-        sqlQ = 'INSERT INTO qa_problems (problem, build_id ) VALUES ( %s, %s )'
-        for x in qa_error:
-          params = (x, build_id)
-          cursor.execute(sqlQ, params)
-    ebuild_i = ebuild_i +1
-  connection.commit()
-
-def update_qa_repoman(connection, build_id, build_log_dict):
-	cursor = connection.cursor()
-	sqlQ1 = 'INSERT INTO repoman_problems (problem, build_id ) VALUES ( %s, %s )'
-	sqlQ2 = 'INSERT INTO qa_problems (problem, build_id ) VALUES ( %s, %s )'
-	if build_log_dict['repoman_error_list'] != []:
-		for x in build_log_dict['repoman_error_list']:
-			params = (x, build_id)
-			cursor.execute(sqlQ, params)
-	if build_log_dict['qa_error_list'] != []:
-		for x in build_log_dict['qa_error_list']:
-			params = (x, build_id)
-			cursor.execute(sqlQ, params)
-	connection.commit()
-
-def get_arch_db(connection):
-  cursor = connection.cursor()
-  sqlQ = "SELECT keyword FROM keywords WHERE keyword = 'amd64'"
-  cursor.execute(sqlQ)
-  return cursor.fetchone()
-
-def add_new_arch_db(connection, arch_list):
-  cursor = connection.cursor()
-  sqlQ = 'INSERT INTO keywords (keyword) VALUES  ( %s )'
-  for arch in arch_list:
-    cursor.execute(sqlQ, (arch,))
-  connection.commit()
-
-def update_fail_times(connection, fail_querue_dict):
-	cursor = connection.cursor()
-	sqlQ1 = 'UPDATE querue_retest SET fail_times = %s WHERE querue_id = %s AND fail_type = %s'
-	sqlQ2 = 'UPDATE buildqueue SET timestamp = NOW() WHERE queue_id = %s'
-	cursor.execute(sqlQ1, (fail_querue_dict['fail_times'], fail_querue_dict['querue_id'], fail_querue_dict['fail_type'],))
-	cursor.execute(sqlQ2, (fail_querue_dict['querue_id'],))
-	connection.commit()
-
-def get_fail_querue_dict(connection, build_dict):
-	cursor = connection.cursor()
-	fail_querue_dict = {}
-	sqlQ = 'SELECT fail_times FROM querue_retest WHERE querue_id = %s AND fail_type = %s'
-	cursor.execute(sqlQ, (build_dict['queue_id'], build_dict['type_fail'],))
-	entries = cursor.fetchone()
-	if entries is None:
-		return None
-	fail_querue_dict['fail_times'] = entries
-	return fail_querue_dict
-
-def add_fail_querue_dict(connection, fail_querue_dict):
-	cursor = connection.cursor()
-	sqlQ1 = 'INSERT INTO querue_retest (querue_id, fail_type, fail_times) VALUES ( %s, %s, %s)'
-	sqlQ2 = 'UPDATE buildqueue SET timestamp = NOW() WHERE queue_id = %s'
-	cursor.execute(sqlQ1, (fail_querue_dict['querue_id'],fail_querue_dict['fail_type'], fail_querue_dict['fail_times']))
-	cursor.execute(sqlQ2, (fail_querue_dict['querue_id'],))
-	connection.commit()
-
-def make_conf_error(connection,config_profile):
-  pass

diff --git a/gobs/pym/readconf.py~ b/gobs/pym/readconf.py~
deleted file mode 100644
index c017561..0000000
--- a/gobs/pym/readconf.py~
+++ /dev/null
@@ -1,46 +0,0 @@
-import os
-import sys
-import re
-
-class get_conf_settings(object):
-# open the /etc/buildhost/buildhost.conf file and get the needed
-# settings for gobs
-	def __init__(self):
-		self.configfile = "/etc/gobs/gobs.conf"
-
-	def read_gobs_settings_all(self):
-	# It will return a dict with options from the configfile
-		try:
-			open_conffile = open(self.configfile, 'r')
-		except:
-			sys.exit("Fail to open config file:" + self.configfile)
-		textlines = open_conffile.readlines()
-		for line in textlines:
-			element = line.split('=')
-			if element[0] == 'SQLBACKEND':		# Databas backend
-				get_sql_backend = element[1]
-			if element[0] == 'SQLDB':			# Database
-				get_sql_db = element[1]
-			if element[0] == 'SQLHOST':			# Host
-				get_sql_host = element[1]
-			if element[0] == 'SQLUSER':			# User
-				get_sql_user = element[1]
-			if element[0] == 'SQLPASSWD':		# Password
-				get_sql_passwd = element[1]
-			# Buildhost root (dir for host/setup on host)
-			if element[0] == 'GOBSROOT':
-				get_gobs_root = element[1]
-			# Buildhost setup (host/setup on guest)
-			if element[0] == 'GOBSCONFIG':
-				get_gobs_config = element[1]
-			
-			open_conffile.close()
-		gobs_settings_dict = {}
-		gobs_settings_dict['sql_backend'] = get_sql_backend.rstrip('\n')
-		gobs_settings_dict['sql_db'] = get_sql_db.rstrip('\n')
-		gobs_settings_dict['sql_host'] = get_sql_host.rstrip('\n')
-		gobs_settings_dict['sql_user'] = get_sql_user.rstrip('\n')
-		gobs_settings_dict['sql_passwd'] = get_sql_passwd.rstrip('\n')
-		gobs_settings_dict['gobs_root'] = get_gobs_root.rstrip('\n')
-		gobs_settings_dict['gobs_config'] = get_gobs_config.rstrip('\n')
-		return gobs_settings_dict

diff --git a/gobs/pym/repoman_gobs.py~ b/gobs/pym/repoman_gobs.py~
deleted file mode 100644
index 2141342..0000000
--- a/gobs/pym/repoman_gobs.py~
+++ /dev/null
@@ -1,48 +0,0 @@
-import sys
-import os
-import portage
-from portage import os, _encodings, _unicode_decode
-from portage import _unicode_encode
-from portage.exception import DigestException, FileNotFound, ParseError, PermissionDenied
-from _emerge.Package import Package
-from _emerge.RootConfig import RootConfig
-from repoman.checks import run_checks
-import codecs
-
-class gobs_repoman(object):
-	
-	def __init__(self, mysettings, myportdb):
-		self._mysettings = mysettings
-		self._myportdb = myportdb
-
-	def check_repoman(self, categories, package, ebuild_version_tree, config_id):
-		# We run repoman run_checks on the ebuild
-		pkgdir = self._mysettings['PORTDIR'] + "/" + categories + "/" + package
-		full_path = pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild"
-		cpv = categories + "/" + package + "-" + ebuild_version_tree
-		root = '/'
-		trees = {
-		root : {'porttree' : portage.portagetree(root, settings=self._mysettings)}
-		}
-		root_config = RootConfig(self._mysettings, trees[root], None)
-		allvars = set(x for x in portage.auxdbkeys if not x.startswith("UNUSED_"))
-		allvars.update(Package.metadata_keys)
-		allvars = sorted(allvars)
-		myaux = dict(zip(allvars, self._myportdb.aux_get(cpv, allvars)))
-		pkg = Package(cpv=cpv, metadata=myaux, root_config=root_config)
-		fails = []
-		try:
-			# All ebuilds should have utf_8 encoding.
-			f = codecs.open(_unicode_encode(full_path,
-			encoding = _encodings['fs'], errors = 'strict'),
-			mode = 'r', encoding = _encodings['repo.content'])
-			try:
-				for check_name, e in run_checks(f, pkg):
-					fails.append(check_name + ": " + e)
-			finally:
-				f.close()
-		except UnicodeDecodeError:
-			# A file.UTF8 failure will have already been recorded above.
-			pass
-		# fails will have a list with repoman errors
-		return fails
\ No newline at end of file

diff --git a/gobs/pym/sync.py~ b/gobs/pym/sync.py~
deleted file mode 100644
index 35833f9..0000000
--- a/gobs/pym/sync.py~
+++ /dev/null
@@ -1,23 +0,0 @@
-from __future__ import print_function
-import portage
-import os
-import errno
-from git import *
-
-def git_pull():
-	repo = Repo("/var/lib/gobs/" + gobs_settings_dict['gobs_gitreponame'] + "/")
-	repo_remote = repo.remotes.origin
-	repo_remote.pull()
-	master = repo.head.reference
-	print(master.log())
-
-def sync_tree()
-	settings, trees, mtimedb = load_emerge_config()
-	portdb = trees[settings["ROOT"]]["porttree"].dbapi
-	tmpcmdline = []
-	tmpcmdline.append("--sync")
-	tmpcmdline.append("--quiet")
-	myaction, myopts, myfiles = parse_opts(tmpcmdline)
-	fail_sync = action_sync(settings, trees, mtimedb, myopts, myaction)
-	print("fail_sync", fail_sync)
-	return fail_sync
\ No newline at end of file

diff --git a/gobs/pym/text.py~ b/gobs/pym/text.py~
deleted file mode 100644
index 7523015..0000000
--- a/gobs/pym/text.py~
+++ /dev/null
@@ -1,48 +0,0 @@
-import sys
-import re
-import os
-import errno
-
-def  get_file_text(filename):
-	# Return the filename contents
-	try:
-		textfile = open(filename)
-	except:
-		return "No file", filename
-	text = ""
-	for line in textfile:
-		text += unicode(line, 'utf-8')
-	textfile.close()
-	return text
-
-def  get_ebuild_text(filename):
-	"""Return the ebuild contents"""
-	try:
-		ebuildfile = open(filename)
-	except:
-		return "No Ebuild file there"
-	text = ""
-	dataLines = ebuildfile.readlines()
-	for i in dataLines:
-		text = text + i + " "
-	line2 = dataLines[2]
-	field = line2.split(" ")
-	ebuildfile.close()
-	try:
-		cvs_revision = field[3]
-	except:
-		cvs_revision = ''
-	return text, cvs_revision
-
-def  get_log_text_list(filename):
-	"""Return the log contents as a list"""
-	print "filename", filename
-	try:
-		logfile = open(filename)
-	except:
-		return None
-	text = []
-	dataLines = logfile.readlines()
-	for i in dataLines:
-		text.append(i)
-	return text