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

[Magnus Granberg]

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

major update

---
 ebuild/dev-python/gobs/gobs-9999.ebuild~         |   50 +
 gobs/bin/gobs_buildquerys                        |   12 +-
 gobs/bin/{gobs_buildquerys => gobs_buildquerys~} |    6 +-
 gobs/bin/gobs_portage_hooks~                     |   79 +
 gobs/bin/gobs_setup_profile~                     |   12 +
 gobs/bin/gobs_updatedb                           |   88 +-
 gobs/bin/{gobs_updatedb => gobs_updatedb~}       |   87 +-
 gobs/doc/Setup.txt~                              |    7 +
 gobs/doc/portage/all/bashrc~                     |    7 +
 gobs/doc/portage/base/make.conf                  |   15 +
 gobs/pym/ConnectionManager.py~                   |   56 +
 gobs/pym/Scheduler.py~                           | 1994 ++++++++++++++++++++++
 gobs/pym/arch.py~                                |   25 +
 gobs/pym/build_log.py                            |   20 +-
 gobs/pym/{build_log.py => build_log.py~}         |    0
 gobs/pym/build_queru.py~                         |  708 ++++++++
 gobs/pym/categories.py~                          |   30 +
 gobs/pym/check_setup.py                          |   25 +-
 gobs/pym/{check_setup.py => check_setup.py~}     |   25 +-
 gobs/pym/depclean.py~                            |  632 +++++++
 gobs/pym/flags.py~                               |  219 +++
 gobs/pym/init_setup_profile.py~                  |   86 +
 gobs/pym/manifest.py~                            |  124 ++
 gobs/pym/old_cpv.py~                             |   89 +
 gobs/pym/package.py                              |    9 +-
 gobs/pym/{package.py => package.py~}             |    9 +-
 gobs/pym/pgsql.py                                |   32 +-
 gobs/pym/{pgsql.py => pgsql.py~}                 |   32 +-
 gobs/pym/readconf.py~                            |   46 +
 gobs/pym/repoman_gobs.py~                        |   48 +
 gobs/pym/sync.py                                 |   23 +
 gobs/pym/sync.py~                                |   23 +
 gobs/pym/text.py~                                |   48 +
 33 files changed, 4525 insertions(+), 141 deletions(-)

diff --git a/ebuild/dev-python/gobs/gobs-9999.ebuild~ b/ebuild/dev-python/gobs/gobs-9999.ebuild~
new file mode 100644
index 0000000..22fa1b7
--- /dev/null
+++ b/ebuild/dev-python/gobs/gobs-9999.ebuild~
@@ -0,0 +1,50 @@
+# 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
index e109efc..868d01a 100755
--- a/gobs/bin/gobs_buildquerys
+++ b/gobs/bin/gobs_buildquerys
@@ -8,22 +8,28 @@ gobs_settings_dict=reader.read_gobs_settings_all()
 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
+import time
+from multiprocessing import Process
 
 def main_loop(config_profile):
 	repeat = True
 	#get a connection from the pool
 	init_queru = queruaction(config_profile)
 	while repeat:
-		#FIXME do a git reop check
-		if check_configure_guest( config_profile) is not True:
+		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()
+			p = Process(target=init_queru.procces_qureru)
+			p.start()
+			p.join()
+		time.sleep(10)
 
 def main():
   # Main

diff --git a/gobs/bin/gobs_buildquerys b/gobs/bin/gobs_buildquerys~
similarity index 88%
copy from gobs/bin/gobs_buildquerys
copy to gobs/bin/gobs_buildquerys~
index e109efc..842b324 100755
--- a/gobs/bin/gobs_buildquerys
+++ b/gobs/bin/gobs_buildquerys~
@@ -8,6 +8,7 @@ gobs_settings_dict=reader.read_gobs_settings_all()
 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
@@ -18,12 +19,13 @@ def main_loop(config_profile):
 	#get a connection from the pool
 	init_queru = queruaction(config_profile)
 	while repeat:
-		#FIXME do a git reop check
-		if check_configure_guest( config_profile) is not True:
+		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

diff --git a/gobs/bin/gobs_portage_hooks~ b/gobs/bin/gobs_portage_hooks~
new file mode 100755
index 0000000..5432545
--- /dev/null
+++ b/gobs/bin/gobs_portage_hooks~
@@ -0,0 +1,79 @@
+#!/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~
new file mode 100755
index 0000000..cf926fa
--- /dev/null
+++ b/gobs/bin/gobs_setup_profile~
@@ -0,0 +1,12 @@
+#!/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
index a80c270..5beb6b2 100755
--- a/gobs/bin/gobs_updatedb
+++ b/gobs/bin/gobs_updatedb
@@ -7,8 +7,8 @@
 
 import sys
 import os
-from threading import Thread
-from git import *
+import multiprocessing
+
 
 # Get the options from the config file set in gobs.readconf
 from gobs.readconf import get_conf_settings
@@ -27,6 +27,7 @@ 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():
@@ -41,12 +42,6 @@ def init_portage_settings():
 	"""
 	# check config setup
 	#git stuff
-	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()
-
 	conn=CM.getConnection()
 	check_make_conf()
 	print "Check configs done"
@@ -59,6 +54,29 @@ def init_portage_settings():
 	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
@@ -71,51 +89,35 @@ def update_cpv_db(mysettings):
 	print "Checking categories, package, ebuilds"
 	# Setup portdb, gobs_categories, gobs_old_cpv, package
 	myportdb = portage.portdbapi(mysettings=mysettings)
-	init_categories = gobs_categories(mysettings)
-	init_old_cpv = gobs_old_cpv(myportdb, mysettings)
-	init_package = gobs_package(mysettings, myportdb)
 	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()
-	# Run the update package for all package in the list
-	conn=CM.getConnection()
+	# Use all exept 2 cores when multiprocessing
+	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):
-		# split the cp to categories and package
-		element = package_line.split('/')
-		categories = element[0]
-		package = element[1]
-		print "C", categories + "/" + package			# C = Checking
-		# 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
-			package_id = init_package.add_new_package_db(categories, package)
-			# FIXME log some way that package_id was None
-			if not package_id is None:
-				package_id_list_tree.append(package_id)
-		# 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)
-			package_id_list_tree.append(package_id)
-		# Update the metadata for categories
-		init_categories.update_categories_db(categories)
-	CM.putConnection(conn)
-	# Remove any old ebuild, package and categories
-	init_old_cpv.mark_old_ebuild_db(categories, package, package_id)
-	init_old_cpv.mark_old_package_db(sorted(package_id_list_tree))
-	init_old_cpv.mark_old_categories_db()
+		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
-	mysettings =  init_portage_settings()
-	init_arch = gobs_arch()
-	init_arch.update_arch_db()
-	# Update the cpv db
-	update_cpv_db(mysettings)
+	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__":

diff --git a/gobs/bin/gobs_updatedb b/gobs/bin/gobs_updatedb~
similarity index 62%
copy from gobs/bin/gobs_updatedb
copy to gobs/bin/gobs_updatedb~
index a80c270..15271e4 100755
--- a/gobs/bin/gobs_updatedb
+++ b/gobs/bin/gobs_updatedb~
@@ -7,8 +7,8 @@
 
 import sys
 import os
-from threading import Thread
-from git import *
+import multiprocessing
+
 
 # Get the options from the config file set in gobs.readconf
 from gobs.readconf import get_conf_settings
@@ -27,6 +27,7 @@ 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():
@@ -41,12 +42,6 @@ def init_portage_settings():
 	"""
 	# check config setup
 	#git stuff
-	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()
-
 	conn=CM.getConnection()
 	check_make_conf()
 	print "Check configs done"
@@ -59,6 +54,29 @@ def init_portage_settings():
 	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
@@ -71,51 +89,34 @@ def update_cpv_db(mysettings):
 	print "Checking categories, package, ebuilds"
 	# Setup portdb, gobs_categories, gobs_old_cpv, package
 	myportdb = portage.portdbapi(mysettings=mysettings)
-	init_categories = gobs_categories(mysettings)
-	init_old_cpv = gobs_old_cpv(myportdb, mysettings)
-	init_package = gobs_package(mysettings, myportdb)
 	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()
-	# Run the update package for all package in the list
-	conn=CM.getConnection()
+	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):
-		# split the cp to categories and package
-		element = package_line.split('/')
-		categories = element[0]
-		package = element[1]
-		print "C", categories + "/" + package			# C = Checking
-		# 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
-			package_id = init_package.add_new_package_db(categories, package)
-			# FIXME log some way that package_id was None
-			if not package_id is None:
-				package_id_list_tree.append(package_id)
-		# 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)
-			package_id_list_tree.append(package_id)
-		# Update the metadata for categories
-		init_categories.update_categories_db(categories)
-	CM.putConnection(conn)
-	# Remove any old ebuild, package and categories
-	init_old_cpv.mark_old_ebuild_db(categories, package, package_id)
-	init_old_cpv.mark_old_package_db(sorted(package_id_list_tree))
-	init_old_cpv.mark_old_categories_db()
+		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
-	mysettings =  init_portage_settings()
-	init_arch = gobs_arch()
-	init_arch.update_arch_db()
-	# Update the cpv db
-	update_cpv_db(mysettings)
+	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__":

diff --git a/gobs/doc/Setup.txt~ b/gobs/doc/Setup.txt~
new file mode 100644
index 0000000..956990f
--- /dev/null
+++ b/gobs/doc/Setup.txt~
@@ -0,0 +1,7 @@
+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~
new file mode 100644
index 0000000..092548e
--- /dev/null
+++ b/gobs/doc/portage/all/bashrc~
@@ -0,0 +1,7 @@
+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/doc/portage/base/make.conf b/gobs/doc/portage/base/make.conf
new file mode 100644
index 0000000..b69dfa9
--- /dev/null
+++ b/gobs/doc/portage/base/make.conf
@@ -0,0 +1,15 @@
+# This is for the base config
+CHOST="x86_64-pc-linux-gnu"
+ACCEPT_KEYWORDS=""
+ARCH="amd64"
+FEATURES="-metadata-transfer -news"
+ACCEPT_LICENSE="*"
+PORTAGE_TMPDIR=/var/tmp
+PORTDIR=/usr/portage
+DISTDIR=/usr/portage/distfiles
+PORT_LOGDIR="/var/log/portage"
+GENTOO_MIRRORS="ftp://ftp.sunet.se/pub/Linux/distributions/gentoo http://distfiles.gentoo.org http://www.ibiblio.org/pub/Linux/distributions/gentoo"
+SYNC="rsync://rsync.europe.gentoo.org/gentoo-portage"
+PORTAGE_TMPFS="/dev/shm"
+PORTAGE_ELOG_CLASSES=""
+PORTAGE_ELOG_SYSTEM=""

diff --git a/gobs/pym/ConnectionManager.py~ b/gobs/pym/ConnectionManager.py~
new file mode 100644
index 0000000..1bbeb35
--- /dev/null
+++ b/gobs/pym/ConnectionManager.py~
@@ -0,0 +1,56 @@
+#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~
new file mode 100644
index 0000000..005f861
--- /dev/null
+++ b/gobs/pym/Scheduler.py~
@@ -0,0 +1,1994 @@
+# 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~
new file mode 100644
index 0000000..ebd0017
--- /dev/null
+++ b/gobs/pym/arch.py~
@@ -0,0 +1,25 @@
+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
index 80a186a..35724c4 100644
--- a/gobs/pym/build_log.py
+++ b/gobs/pym/build_log.py
@@ -110,15 +110,15 @@ class gobs_buildlog(object):
 
 	def search_info(self, textline, error_log_list):
 		if re.search(" * Package:", textline):
-			error_log_list.append(textline)
+			error_log_list.append(textline + '\n')
 		if re.search(" * Repository:", textline):
-			error_log_list.append(textline)
+			error_log_list.append(textline + '\n')
 		if re.search(" * Maintainer:", textline):
-			error_log_list.append(textline)
+			error_log_list.append(textline + '\n')
 		if re.search(" * USE:", textline):
-			error_log_list.append(textline)
+			error_log_list.append(textline + '\n')
 		if re.search(" * FEATURES:", textline):
-			error_log_list.append(textline)
+			error_log_list.append(textline + '\n')
 		return error_log_list
 
 	def search_error(self, logfile_text, textline, error_log_list, sum_build_log_list, i):
@@ -128,7 +128,7 @@ class gobs_buildlog(object):
 			error_log_list.append(".....\n")
 			while x != i + 3 and endline:
 				try:
-					error_log_list.append(logfile_text[x])
+					error_log_list.append(logfile_text[x] + '\n')
 				except:
 					endline = False
 				else:
@@ -141,7 +141,7 @@ class gobs_buildlog(object):
 			error_log_list.append(".....\n")
 			while x != i + 10 and endline:
 				try:
-					error_log_list.append(logfile_text[x])
+					error_log_list.append(logfile_text[x] + '\n')
 				except:
 					endline = False
 				else:
@@ -152,7 +152,7 @@ class gobs_buildlog(object):
 			error_log_list.append(".....\n")
 			while x != i + 3 and endline:
 				try:
-					error_log_list.append(logfile_text[x])
+					error_log_list.append(logfile_text[x] + '\n')
 				except:
 					endline = False
 				else:
@@ -162,12 +162,12 @@ class gobs_buildlog(object):
 	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])
+			qa_error_list.append(logfile_text[x] + '\n')
 			endline= True
 			error_log_list.append(".....\n")
 			while x != i + 3 and endline:
 				try:
-					error_log_list.append(logfile_text[x])
+					error_log_list.append(logfile_text[x] + '\n')
 				except:
 					endline = False
 				else:

diff --git a/gobs/pym/build_log.py b/gobs/pym/build_log.py~
similarity index 100%
copy from gobs/pym/build_log.py
copy to gobs/pym/build_log.py~

diff --git a/gobs/pym/build_queru.py~ b/gobs/pym/build_queru.py~
new file mode 100644
index 0000000..3f0bde8
--- /dev/null
+++ b/gobs/pym/build_queru.py~
@@ -0,0 +1,708 @@
+# 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~
new file mode 100644
index 0000000..f3b2457
--- /dev/null
+++ b/gobs/pym/categories.py~
@@ -0,0 +1,30 @@
+#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
index 8512470..8b9b883 100644
--- a/gobs/pym/check_setup.py
+++ b/gobs/pym/check_setup.py
@@ -4,6 +4,7 @@ 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()
@@ -68,14 +69,17 @@ def check_make_conf_guest(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 "1"
+		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 "2"
+		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)
@@ -88,22 +92,11 @@ def check_make_conf_guest(config_profile):
 		# With errors we return false
 	except Exception as e:
 		CM.putConnection(conn)
-		return "3"
+		return False
 	CM.putConnection(conn)
-	return "4"
+	return True
 
 def check_configure_guest(config_profile):
 	pass_make_conf = check_make_conf_guest(config_profile)
 	print(pass_make_conf)
-	if pass_make_conf == "1":
-		# profile not active or updatedb is runing
-		return False
-	elif pass_make_conf == "2":
-		#  update make.conf
-		return False
-	elif pass_make_conf == "3":
-		# set the config as no working
-		return False
-	elif pass_make_conf == "4":
-		# make.conf check OK
-		return True
\ No newline at end of file
+	return pass_make_conf
\ No newline at end of file

diff --git a/gobs/pym/check_setup.py b/gobs/pym/check_setup.py~
similarity index 92%
copy from gobs/pym/check_setup.py
copy to gobs/pym/check_setup.py~
index 8512470..8b9b883 100644
--- a/gobs/pym/check_setup.py
+++ b/gobs/pym/check_setup.py~
@@ -4,6 +4,7 @@ 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()
@@ -68,14 +69,17 @@ def check_make_conf_guest(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 "1"
+		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 "2"
+		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)
@@ -88,22 +92,11 @@ def check_make_conf_guest(config_profile):
 		# With errors we return false
 	except Exception as e:
 		CM.putConnection(conn)
-		return "3"
+		return False
 	CM.putConnection(conn)
-	return "4"
+	return True
 
 def check_configure_guest(config_profile):
 	pass_make_conf = check_make_conf_guest(config_profile)
 	print(pass_make_conf)
-	if pass_make_conf == "1":
-		# profile not active or updatedb is runing
-		return False
-	elif pass_make_conf == "2":
-		#  update make.conf
-		return False
-	elif pass_make_conf == "3":
-		# set the config as no working
-		return False
-	elif pass_make_conf == "4":
-		# make.conf check OK
-		return True
\ No newline at end of file
+	return pass_make_conf
\ No newline at end of file

diff --git a/gobs/pym/depclean.py~ b/gobs/pym/depclean.py~
new file mode 100644
index 0000000..b6096b6
--- /dev/null
+++ b/gobs/pym/depclean.py~
@@ -0,0 +1,632 @@
+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/flags.py~ b/gobs/pym/flags.py~
new file mode 100644
index 0000000..7ccf90b
--- /dev/null
+++ b/gobs/pym/flags.py~
@@ -0,0 +1,219 @@
+from __future__ import print_function
+from _emerge.main import parse_opts
+from _emerge.depgraph import backtrack_depgraph, depgraph, resume_depgraph
+from _emerge.create_depgraph_params import create_depgraph_params
+from _emerge.actions import load_emerge_config
+import portage
+import os
+
+class gobs_use_flags(object):
+	
+	def __init__(self, mysettings, myportdb, cpv):
+		self._mysettings = mysettings
+		self._myportdb = myportdb
+		self._cpv = cpv
+	
+	def get_iuse(self):
+		"""Gets the current IUSE flags from the tree
+		To be used when a gentoolkit package object is not needed
+		@type: cpv: string 
+		@param cpv: cat/pkg-ver
+		@rtype list
+		@returns [] or the list of IUSE flags
+		"""
+		return self._myportdb.aux_get(self._cpv, ["IUSE"])[0].split()
+		
+	def reduce_flag(self, flag):
+		"""Absolute value function for a USE flag
+		@type flag: string
+		@param flag: the use flag to absolute.
+		@rtype: string
+		@return absolute USE flag
+		"""
+		if flag[0] in ["+","-"]:
+			return flag[1:]
+		else:
+			return flag
+
+	def reduce_flags(self, the_list):
+		"""Absolute value function for a USE flag list
+		@type the_list: list
+		@param the_list: the use flags to absolute.
+		@rtype: list
+		@return absolute USE flags
+		"""
+		r=[]
+		for member in the_list:
+			r.append(self.reduce_flag(member))
+		return r
+
+	def filter_flags(self, use, use_expand_hidden, usemasked, useforced):
+		"""Filter function to remove hidden or otherwise not normally
+		visible USE flags from a list.
+		@type use: list
+		@param use: the USE flag list to be filtered.
+		@type use_expand_hidden: list
+		@param  use_expand_hidden: list of flags hidden.
+		@type usemasked: list
+		@param usemasked: list of masked USE flags.
+		@type useforced: list
+		@param useforced: the forced USE flags.
+		@rtype: list
+		@return the filtered USE flags.
+		"""
+		# clean out some environment flags, since they will most probably
+		# be confusing for the user
+		for f in use_expand_hidden:
+			f=f.lower() + "_"
+			for x in use:
+				if f in x:
+					use.remove(x)
+		# clean out any arch's
+		archlist = self._mysettings["PORTAGE_ARCHLIST"].split()
+		for a in use[:]:
+			if a in archlist:
+				use.remove(a)
+		# dbl check if any from usemasked  or useforced are still there
+		masked = usemasked + useforced
+		for a in use[:]:
+			if a in masked:
+				use.remove(a)
+		return use
+
+	def get_all_cpv_use(self):
+		"""Uses portage to determine final USE flags and settings for an emerge
+		@type cpv: string
+		@param cpv: eg cat/pkg-ver
+		@rtype: lists
+		@return  use, use_expand_hidden, usemask, useforce
+		"""
+		use = None
+		self._mysettings.unlock()
+		try:
+			self._mysettings.setcpv(self._cpv, use_cache=None, mydb=self._myportdb)
+			use = self._mysettings['PORTAGE_USE'].split()
+			use_expand_hidden = self._mysettings["USE_EXPAND_HIDDEN"].split()
+			usemask = list(self._mysettings.usemask)
+			useforce =  list(self._mysettings.useforce)
+		except KeyError:
+			self._mysettings.reset()
+			self._mysettings.lock()
+			return [], [], [], []
+		# reset cpv filter
+		self._mysettings.reset()
+		self._mysettings.lock()
+		return use, use_expand_hidden, usemask, useforce
+
+	def get_all_cpv_use_looked(self):
+		"""Uses portage to determine final USE flags and settings for an emerge
+		@type cpv: string
+		@param cpv: eg cat/pkg-ver
+		@rtype: lists
+		@return  use, use_expand_hidden, usemask, useforce
+		"""
+		# use = self._mysettings['PORTAGE_USE'].split()
+		use = os.environ['USE'].split()
+		use_expand_hidden = self._mysettings["USE_EXPAND_HIDDEN"].split()
+		usemask = list(self._mysettings.usemask)
+		useforce = list(self._mysettings.useforce)
+		return use, use_expand_hidden, usemask, useforce
+
+	def get_all_cpv_use_pkg(self, pkg, settings):
+		"""Uses portage to determine final USE flags and settings for an emerge
+		@type cpv: string
+		@param cpv: eg cat/pkg-ver
+		@rtype: lists
+		@return  use, use_expand_hidden, usemask, useforce
+		"""
+		# use = self._mysettings['PORTAGE_USE'].split()
+		use_list = list(pkg.use.enabled)
+		use_expand_hidden = settings["USE_EXPAND_HIDDEN"].split()
+		usemask = list(settings.usemask)
+		useforced = list(settings.useforce)
+		return use_list, use_expand_hidden, usemask, useforced
+
+	def get_flags(self):
+		"""Retrieves all information needed to filter out hidden, masked, etc.
+		USE flags for a given package.
+
+		@type cpv: string
+		@param cpv: eg. cat/pkg-ver
+		@type final_setting: boolean
+		@param final_setting: used to also determine the final
+		enviroment USE flag settings and return them as well.
+		@rtype: list or list, list
+		@return IUSE or IUSE, final_flags
+		"""
+		final_use, use_expand_hidden, usemasked, useforced = self.get_all_cpv_use()
+		iuse_flags = self.filter_flags(self.get_iuse(), use_expand_hidden, usemasked, useforced)
+		#flags = filter_flags(use_flags, use_expand_hidden, usemasked, useforced)
+		final_flags = self.filter_flags(final_use, use_expand_hidden, usemasked, useforced)
+		return iuse_flags, final_flags
+
+	def get_flags_looked(self):
+		"""Retrieves all information needed to filter out hidden, masked, etc.
+		USE flags for a given package.
+
+		@type cpv: string
+		@param cpv: eg. cat/pkg-ver
+		@type final_setting: boolean
+		@param final_setting: used to also determine the final
+		enviroment USE flag settings and return them as well.
+		@rtype: list or list, list
+		@return IUSE or IUSE, final_flags
+		"""
+		final_use, use_expand_hidden, usemasked, useforced = self.get_all_cpv_use_looked()
+		iuse_flags = self.filter_flags(self.get_iuse(), use_expand_hidden, usemasked, useforced)
+		#flags = filter_flags(use_flags, use_expand_hidden, usemasked, useforced)
+		final_flags = self.filter_flags(final_use, use_expand_hidden, usemasked, useforced)
+		return iuse_flags, final_flags
+
+	def get_flags_pkg(self, pkg, settings):
+		"""Retrieves all information needed to filter out hidden, masked, etc.
+		USE flags for a given package.
+		@type cpv: string
+		@param cpv: eg. cat/pkg-ver
+		@type final_setting: boolean
+		@param final_setting: used to also determine the final
+		enviroment USE flag settings and return them as well.
+		@rtype: list or list, list
+		@return IUSE or IUSE, final_flags
+		"""
+		final_use, use_expand_hidden, usemasked, useforced = self.get_all_cpv_use_pkg(pkg, settings)
+		iuse_flags = self.filter_flags(list(pkg.iuse.all), use_expand_hidden, usemasked, useforced)
+		#flags = filter_flags(use_flags, use_expand_hidden, usemasked, useforced)
+		final_flags = self.filter_flags(final_use, use_expand_hidden, usemasked, useforced)
+		return iuse_flags, final_flags
+
+	def comper_useflags(self, build_dict):
+		iuse_flags, use_enable = self.get_flags()
+		iuse = []
+		print("use_enable", use_enable)
+		build_use_flags_dict = build_dict['build_useflags']
+		print("build_use_flags_dict", build_use_flags_dict)
+		build_use_flags_list = []
+		if use_enable == []:
+			if build_use_flags_dict is None:
+				return None
+		for iuse_line in iuse_flags:
+			iuse.append(self.reduce_flag(iuse_line))
+		iuse_flags_list = list(set(iuse))
+		use_disable = list(set(iuse_flags_list).difference(set(use_enable)))
+		use_flagsDict = {}
+		for x in use_enable:
+			use_flagsDict[x] = True
+		for x in use_disable:
+			use_flagsDict[x] = False
+		print("use_flagsDict", use_flagsDict)
+		for k, v in use_flagsDict.iteritems():
+			print("tree use flags", k, v)
+			print("db use flags", k, build_use_flags_dict[k])
+		if build_use_flags_dict[k] != v:
+			if build_use_flags_dict[k] is True:
+				build_use_flags_list.append(k)
+			if build_use_flags_dict[k] is False:
+				build_use_flags_list.append("-" + k)
+		if build_use_flags_list == []:
+			build_use_flags_list = None
+		print(build_use_flags_list)
+		return build_use_flags_list

diff --git a/gobs/pym/init_setup_profile.py~ b/gobs/pym/init_setup_profile.py~
new file mode 100644
index 0000000..e647e1f
--- /dev/null
+++ b/gobs/pym/init_setup_profile.py~
@@ -0,0 +1,86 @@
+#!/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~
new file mode 100644
index 0000000..fb29f0a
--- /dev/null
+++ b/gobs/pym/manifest.py~
@@ -0,0 +1,124 @@
+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~
new file mode 100644
index 0000000..4923bf7
--- /dev/null
+++ b/gobs/pym/old_cpv.py~
@@ -0,0 +1,89 @@
+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
index 1f592ee..9ae6c57 100644
--- a/gobs/pym/package.py
+++ b/gobs/pym/package.py
@@ -176,14 +176,15 @@ class gobs_package(object):
 	def add_new_package_db(self, categories, package):
 		conn=CM.getConnection()
 		# add new categories package ebuild to tables package and ebuilds
-		print("N", categories + "/" + package)				# N = New Package
+		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 None
+			return
 		config_list  = get_config_list(conn)
 		config_cpv_listDict = self.config_match_ebuild(categories, package, config_list)
 		config_id  = get_default_config(conn)
@@ -217,7 +218,7 @@ class gobs_package(object):
 			get_manifest_text = get_file_text(pkgdir + "/Manifest")
 			add_new_manifest_sql(conn,package_id, get_manifest_text, manifest_checksum_tree)
 		CM.putConnection(conn)
-		return package_id
+		print("C", categories + "/" + package + " ... Done.")
 
 	def update_package_db(self, categories, package, package_id):
 		conn=CM.getConnection()
@@ -229,6 +230,7 @@ class gobs_package(object):
 		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
@@ -280,6 +282,7 @@ class gobs_package(object):
 			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()

diff --git a/gobs/pym/package.py b/gobs/pym/package.py~
similarity index 97%
copy from gobs/pym/package.py
copy to gobs/pym/package.py~
index 1f592ee..9ae6c57 100644
--- a/gobs/pym/package.py
+++ b/gobs/pym/package.py~
@@ -176,14 +176,15 @@ class gobs_package(object):
 	def add_new_package_db(self, categories, package):
 		conn=CM.getConnection()
 		# add new categories package ebuild to tables package and ebuilds
-		print("N", categories + "/" + package)				# N = New Package
+		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 None
+			return
 		config_list  = get_config_list(conn)
 		config_cpv_listDict = self.config_match_ebuild(categories, package, config_list)
 		config_id  = get_default_config(conn)
@@ -217,7 +218,7 @@ class gobs_package(object):
 			get_manifest_text = get_file_text(pkgdir + "/Manifest")
 			add_new_manifest_sql(conn,package_id, get_manifest_text, manifest_checksum_tree)
 		CM.putConnection(conn)
-		return package_id
+		print("C", categories + "/" + package + " ... Done.")
 
 	def update_package_db(self, categories, package, package_id):
 		conn=CM.getConnection()
@@ -229,6 +230,7 @@ class gobs_package(object):
 		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
@@ -280,6 +282,7 @@ class gobs_package(object):
 			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()

diff --git a/gobs/pym/pgsql.py b/gobs/pym/pgsql.py
index b0a6c83..db70f6c 100644
--- a/gobs/pym/pgsql.py
+++ b/gobs/pym/pgsql.py
@@ -9,10 +9,40 @@ def get_default_config(connection):
 
 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'"
+    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 = 'True' 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

diff --git a/gobs/pym/pgsql.py b/gobs/pym/pgsql.py~
similarity index 95%
copy from gobs/pym/pgsql.py
copy to gobs/pym/pgsql.py~
index b0a6c83..ea1f1f1 100644
--- a/gobs/pym/pgsql.py
+++ b/gobs/pym/pgsql.py~
@@ -9,10 +9,40 @@ def get_default_config(connection):
 
 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'"
+    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

diff --git a/gobs/pym/readconf.py~ b/gobs/pym/readconf.py~
new file mode 100644
index 0000000..c017561
--- /dev/null
+++ b/gobs/pym/readconf.py~
@@ -0,0 +1,46 @@
+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~
new file mode 100644
index 0000000..2141342
--- /dev/null
+++ b/gobs/pym/repoman_gobs.py~
@@ -0,0 +1,48 @@
+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
new file mode 100644
index 0000000..35833f9
--- /dev/null
+++ b/gobs/pym/sync.py
@@ -0,0 +1,23 @@
+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/sync.py~ b/gobs/pym/sync.py~
new file mode 100644
index 0000000..35833f9
--- /dev/null
+++ b/gobs/pym/sync.py~
@@ -0,0 +1,23 @@
+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~
new file mode 100644
index 0000000..7523015
--- /dev/null
+++ b/gobs/pym/text.py~
@@ -0,0 +1,48 @@
+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