[gentoo-commits] dev/zorry:master commit in: gobs/bin/, gobs/pym/

[Magnus Granberg]

commit:     93a89cfd8ee53292632f081909cc0440f5b6052b
Author:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
AuthorDate: Mon Sep 26 23:23:49 2011 +0000
Commit:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
CommitDate: Mon Sep 26 23:23:49 2011 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=dev/zorry.git;a=commit;h=93a89cfd

Add copy of action_build post_emerge emerge_main and fix some code

---
 gobs/bin/gobs_buildquerys |   12 +-
 gobs/pym/build_queru.py   |  701 ++++++++++++++++++++++++++++++++++++++++-----
 gobs/pym/check_setup.py   |   21 +-
 gobs/pym/flags.py         |   37 ---
 gobs/pym/pgsql.py         |   39 ++--
 5 files changed, 664 insertions(+), 146 deletions(-)

diff --git a/gobs/bin/gobs_buildquerys b/gobs/bin/gobs_buildquerys
index 7b8121b..fc2506d 100755
--- a/gobs/bin/gobs_buildquerys
+++ b/gobs/bin/gobs_buildquerys
@@ -17,26 +17,24 @@ import portage
 import sys
 import os
 
-def main_loop(CM, config_profile):
+def main_loop(config_profile):
 	repeat = True
 	#get a connection from the pool
-	conn=CM.getConnection()
 	init_queru = queruaction(config_profile)
-	fail_querue_dict = {}
 	while repeat:
-		if check_configure_guest(conn, config_profile) is not True:
+		#FIXME do a git reop check
+		if check_configure_guest( config_profile) is not True:
 			# time.sleep(60)
 			continue		# retunr to the start of the function
 		else:
-			fail_querue_list = init_queru.procces_qureru(fail_querue_dict)
+			init_queru.procces_qureru()
 			sys.exit()
-		CM.putConnection(conn)
 
 def main():
   # Main
   config_profile = gobs_settings_dict['gobs_config']
   #we provide the main_loop with the ConnectionManager so we can hand out connections from within the loop
-  main_loop(CM, config_profile)
+  main_loop(config_profile)
   connectionManager.closeAllConnections()
 
 if __name__ == "__main__":

diff --git a/gobs/pym/build_queru.py b/gobs/pym/build_queru.py
index 0e481da..7f5e3c1 100644
--- a/gobs/pym/build_queru.py
+++ b/gobs/pym/build_queru.py
@@ -12,10 +12,43 @@ if CM.getName()=='pgsql':
 
 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 _emerge.main import emerge_main
+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 _emerge.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):
 
@@ -24,40 +57,561 @@ class queruaction(object):
 		self._config_profile = config_profile
 		self._myportdb =  portage.portdb
 
-	def log_fail_queru(self, build_dict, fail_querue_dict):
-		fail_times = 0
-		if fail_querue_dict == {}:
-			attDict = {}
-			attDict[build_dict['type_fail']] = 1
-			attDict['build_info'] = build_dict
-			fail_querue_dict[build_dict['querue_id']] = attDict
-			return fail_querue_dict
+	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:
-			# FIXME:If  is 5 remove fail_querue_dict[build_dict['querue_id'] from 
-			# fail_querue_dict and add log to db.
-			if not fail_querue_dict[build_dict['querue_id']] is None:
-				if fail_querue_dict[build_dict['querue_id']][build_dict['type_fail']] is None:
-					fail_querue_dict[build_dict['querue_id']][build_dict['type_fail']] = 1
-					return fail_querue_dict
+			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"))
 				else:
-					fail_times = fail_querue_dict[build_dict['querue_id']][build_dict['type_fail']]
-					fail_times  = fail_times + 1
-					if not fail_times is 5:
-						fail_querue_dict[build_dict['querue_id']][build_dict['type_fail']] = fail_times
-						return fail_querue_dict
-					else:
-						# FIXME:If  is 5 remove fail_querue_dict[build_dict['querue_id']] from
-						# fail_querue_dict and add log to db.
-						return fail_querue_dict
+					build_log_dict['logfilename'] = ""
+				move_queru_buildlog(conn, build_dict['queue_id'], build_error, summary_error, build_log_dict)
+
+	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:
-				attDict = {}
-				attDict[build_dict['type_fail']] = 1
-				attDict['build_info'] = build_dict
-				fail_querue_dict[build_dict['querue_id']] = attDict
-			return fail_querue_dict
+				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):
-		conn=CM.getConnection()
 		cpv = build_dict['category']+'/'+build_dict['package']+'-'+build_dict['ebuild_version']
 		pkgdir = os.path.join(self._mysettings['PORTDIR'], build_dict['category'] + "/" + build_dict['package'])
 		init_manifest =  gobs_manifest(self._mysettings, pkgdir)
@@ -66,36 +620,34 @@ class queruaction(object):
 		except:
 			ebuild_version_checksum_tree = None
 		if ebuild_version_checksum_tree == build_dict['checksum']:
-			if portage.getmaskingstatus(cpv, settings=self._mysettings, portdb=self._myportdb) == []:
-				init_flags = gobs_use_flags(self._mysettings, self._myportdb, 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(self._myportdb, cpv, build_dict, build_use_flags_list)
-				if manifest_error is None:
-					build_dict['check_fail'] = False
-					build_cpv_dict = init_flags.get_needed_dep_useflags(build_use_flags_list)
-					print(build_cpv_dict, build_use_flags_list, cpv)
-					build_use_flags_dict = {}
-					if build_use_flags_list is None:
-						build_use_flags_dict['None'] = None
-					if build_cpv_dict is None:
-						build_cpv_dict = {}
-						build_cpv_dict[cpv] = build_use_flags_dict
-					else:
-						build_cpv_dict[cpv] = build_use_flags_dict
-					print(build_cpv_dict)
-					return build_cpv_dict, build_dict
-				else:
-					build_dict['1'] = 1
+			init_flags = gobs_use_flags(self._mysettings, self._myportdb, 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(self._myportdb, cpv, build_dict, build_use_flags_list)
+			if manifest_error is None:
+				build_dict['check_fail'] = False
+				build_use_flags_dict = {}
+				if build_use_flags_list is None:
+					build_use_flags_dict['None'] = None
+				build_cpv_dict = {}
+				build_cpv_dict[cpv] = build_use_flags_dict
+				print(build_cpv_dict)
+				return build_cpv_dict
 			else:
-				build_dict['2'] = 2
+				build_dict['type_fail'] = "Manifest error"
+				build_dict['check_fail'] = True
 		else:
-			build_dict['3'] = 3
-		build_dict['check_fail'] = True
-		return build_cpv_dict, build_dict
+			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, portage.settings)
+				return None
+		return build_cpv_dict
 
 	def build_procces(self, buildqueru_cpv_dict, build_dict):
 		build_cpv_list = []
+		abs_user_config = os.path.join(self._mysettings["PORTAGE_CONFIGROOT"], USER_CONFIG_PATH)
+		print('abs_user_config', abs_user_config)
 		for k, v in buildqueru_cpv_dict.iteritems():
 				build_use_flags_list = []
 				for x, y in v.iteritems():
@@ -104,13 +656,16 @@ class queruaction(object):
 					if y is False:
 						build_use_flags_list.append("-" + x)
 				print(k, build_use_flags_list)
-				if build_use_flags_list == []:
-					build_cpv_list.append("=" + k)
-				else:
+				build_cpv_list.append("=" + k)
+				if not build_use_flags_list == []:
 					build_use_flags = ""
 					for flags in build_use_flags_list:
-						build_use_flags = build_use_flags + flags + ","
-					build_cpv_list.append("=" + k + "[" + build_use_flags + "]")
+						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']:
@@ -121,37 +676,31 @@ class queruaction(object):
 			argscmd.append(build_cpv)
 		print(argscmd)
 		# Call main_emerge to build the package in build_cpv_list 
-		try: 
-			build_fail = emerge_main(args=argscmd)
-		except:
-			build_fail = False
+		build_fail = self.emerge_main(argscmd, build_dict)
 		# Run depclean
+		print('build_fail', build_fail)
 		if not "nodepclean" in build_dict['post_message']:
 			depclean_fail = main_depclean()
 		if build_fail is False or depclean_fail is False:
 			return False
 		return True
 
-	def procces_qureru(self, fail_querue_dict):
+	def procces_qureru(self):
 		conn=CM.getConnection()
 		build_dict = {}
 		build_dict = get_packages_to_build(conn, self._config_profile)
+		if build_dict is None:
+			return
 		print("build_dict",  build_dict)
-		if build_dict is None and fail_querue_dict == {}:
-			return fail_querue_dict
-		if build_dict is None and fail_querue_dict != {}:
-			return fail_querue_dict
 		if not build_dict['ebuild_id'] is None and build_dict['checksum'] is not None:
-			buildqueru_cpv_dict, build_dict = self.make_build_list(build_dict)
+			buildqueru_cpv_dict = self.make_build_list(build_dict)
 			print('buildqueru_cpv_dict', buildqueru_cpv_dict)
 			if buildqueru_cpv_dict is None:
-				return fail_querue_dict
+				return
 			fail_build_procces = self.build_procces(buildqueru_cpv_dict, build_dict)
-			if build_dict['check_fail'] is True:
-				fail_querue_dict = self.log_fail_queru(build_dict, fail_querue_dict)
-			return fail_querue_dict
+			return
 		if not build_dict['post_message'] is [] and build_dict['ebuild_id'] is None:
-			return fail_querue_dict
+			return
 		if not build_dict['ebuild_id'] is None and build_dict['checksum'] is None:
 			del_old_queue(conn, build_dict['queue_id'])
-		return fail_querue_dict
+		return

diff --git a/gobs/pym/check_setup.py b/gobs/pym/check_setup.py
index 7dcd053..6b52f29 100644
--- a/gobs/pym/check_setup.py
+++ b/gobs/pym/check_setup.py
@@ -14,10 +14,10 @@ CM=connectionManager(gobs_settings_dict)
 if CM.getName()=='pgsql':
 	from gobs.pgsql import *
 
-def check_make_conf(conn):
+def check_make_conf():
   # FIXME: mark any config updating true in the db when updating the configs
   # Get the config list
-  ##selective import the pgsql/mysql queries
+  conn=CM.getConnection()
   config_list_all = get_config_list_all(conn)
   print("Checking configs for changes and errors")
   configsDict = {}
@@ -53,13 +53,17 @@ def check_make_conf(conn):
   update__make_conf(conn,configsDict)
   print("Updated configurtions")
 
-def check_make_conf_guest(connection, config_profile):
-	make_conf_checksum_db = get_profile_checksum(connection,config_profile)[0]
+def check_make_conf_guest(config_profile):
+	conn=CM.getConnection()
+	print('config_profile', config_profile)
+	make_conf_checksum_db = get_profile_checksum(conn,config_profile)
+	print('make_conf_checksum_db', make_conf_checksum_db)
 	if make_conf_checksum_db is None:
 		return "1"
 	make_conf_file = "/etc/portage/make.conf"
 	make_conf_checksum_tree = portage.checksum.sha256hash(make_conf_file)[0]
-	if make_conf_checksum_tree != make_conf_checksum_db:
+	print('make_conf_checksum_tree', make_conf_checksum_tree)
+	if make_conf_checksum_tree != make_conf_checksum_db[0]:
 		return "2"
 	# Check if we can open the file and close it
 	# Check if we have some error in the file (portage.util.getconfig)
@@ -75,8 +79,9 @@ def check_make_conf_guest(connection, config_profile):
 		return "3"
 	return "4"
 
-def check_configure_guest(connection, config_profile):
-	pass_make_conf = check_make_conf_guest(connection, config_profile)
+def check_configure_guest(config_profile):
+	conn=CM.getConnection()
+	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
@@ -86,7 +91,7 @@ def check_configure_guest(connection, config_profile):
 		return False
 	elif pass_make_conf == "3":
 		# set the config as no working
-		make_conf_error(connection,config_profile)
+		make_conf_error(conn, config_profile)
 		return False
 	elif pass_make_conf == "4":
 		# make.conf check OK

diff --git a/gobs/pym/flags.py b/gobs/pym/flags.py
index e01fed3..ef63361 100644
--- a/gobs/pym/flags.py
+++ b/gobs/pym/flags.py
@@ -154,43 +154,6 @@ class gobs_use_flags(object):
 		final_flags = self.filter_flags(final_use, use_expand_hidden, usemasked, useforced)
 		return iuse_flags, final_flags
 
-	def get_needed_dep_useflags(self, build_use_flags_list):
-		cpv = self._cpv
-		tmpcmdline = []
-		tmpcmdline.append("-p")
-		tmpcmdline.append("--autounmask")
-		tmpcmdline.append("=" + self._cpv)
-		print(tmpcmdline)
-		myaction, myopts, myfiles = parse_opts(tmpcmdline, silent=False)
-		print(myaction, myopts, myfiles)
-		myparams = create_depgraph_params(myopts, myaction)
-		print(myparams)
-		settings, trees, mtimedb = load_emerge_config()
-		try:
-			success, mydepgraph, favorites = backtrack_depgraph(
-				settings, trees, myopts, myparams, myaction, myfiles, spinner=None)
-			print("success mydepgraph favorites", success, mydepgraph, favorites)
-		except portage.exception.PackageSetNotFound as e:
-			root_config = trees[settings["ROOT"]]["root_config"]
-			display_missing_pkg_set(root_config, e.value)
-			return 1
-		use_changes = None
-		mydepgraph._show_merge_list()
-		mydepgraph.display_problems()
-		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
-		if use_changes is None:
-			return None
-		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)
-		return iteritems_packages
-							
 	def comper_useflags(self, build_dict):
 		iuse_flags, use_enable = self.get_flags()
 		iuse = []

diff --git a/gobs/pym/pgsql.py b/gobs/pym/pgsql.py
index c66f205..9979b1b 100644
--- a/gobs/pym/pgsql.py
+++ b/gobs/pym/pgsql.py
@@ -414,7 +414,7 @@ def cp_all_old_db(connection, old_package_id_list):
 def del_old_queue(connection, queue_id):
 	cursor = connection.cursor()
 	sqlQ1 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
-	sqlQ2 = 'DELETE FROM temp_errors_queue_qa WHERE queue_id  = %s'
+	sqlQ2 = 'DELETE FROM querue_retest WHERE querue_id  = %s'
 	sqlQ3 = 'DELETE FROM buildqueue WHERE queue_id  = %s'
 	cursor.execute(sqlQ1, (queue_id,))
 	cursor.execute(sqlQ2, (queue_id,))
@@ -568,28 +568,31 @@ def add_new_arch_db(connection, arch_list):
     cursor.execute(sqlQ, (arch,))
   connection.commit()
 
-def check_fail_times(connection, logDict):
-	queue_id = logDict['queue_id']
-	qa_error = logDict['qa_error_list'][0]
+def update_fail_times(connection, fail_querue_dict):
 	cursor = connection.cursor()
-	sqlQ = 'SELECT errors FROM temp_errors_queue_qa WHERE queue_id = %s AND what_error = %s'
-	cursor.execute(sqlQ, (queue_id, qa_error,))
-	return cursor.fetchone()
+	sqlQ1 = 'UPDATE querue_retest SET fail_times = %s WHERE querue_id = %s AND fail_type = %s'
+	sqlQ2 = 'UPDATE buildqueue SET timestamp = NOW() WHERE queue_id = %s'
+	cursor.execute(sqlQ1, (fail_querue_dict['fail_times'], fail_querue_dict['querue_id'], fail_querue_dict['fail_type'],))
+	#cursor.execute(sqlQ2, (fail_querue_dict['querue_id'],))
+	connection.commit()
 
-def add_fail_times(connection, logDict):
-	queue_id = logDict['queue_id']
-	qa_error = logDict['qa_error_list'][0]
+def get_fail_querue_dict(connection, build_dict):
 	cursor = connection.cursor()
-	sqlQ = 'INSERT INTO temp_errors_queue_qa (queue_id, what_error) VALUES ( %s, %s)'
-	cursor.execute(sqlQ, (queue_id, qa_error,))
-	connection.commit()
+	fail_querue_dict = {}
+	sqlQ = 'SELECT fail_times FROM querue_retest WHERE querue_id = %s AND fail_type = %s'
+	cursor.execute(sqlQ, (build_dict['queue_id'], build_dict['type_fail'],))
+	entries = cursor.fetchone()
+	if entries is None:
+		return None
+	fail_querue_dict['fail_times'] = entries
+	return fail_querue_dict
 
-def update_fail_times(connection, logDict):
-	queue_id = logDict['queue_id']
-	qa_error = logDict['qa_error_list'][0]
+def add_fail_querue_dict(connection, fail_querue_dict):
 	cursor = connection.cursor()
-	sqlQ1 = 'UPDATE buildqueue SET timestamp = NOW() WHERE queue_id = %s'
-	cursor.execute(sqlQ1, (queue_id,))
+	sqlQ1 = 'INSERT INTO querue_retest (querue_id, fail_type, fail_times) VALUES ( %s, %s, %s)'
+	sqlQ2 = 'UPDATE buildqueue SET timestamp = NOW() WHERE queue_id = %s'
+	cursor.execute(sqlQ1, (fail_querue_dict['querue_id'],fail_querue_dict['fail_type'], fail_querue_dict['fail_times']))
+	#cursor.execute(sqlQ2, (fail_querue_dict['querue_id'],))
 	connection.commit()
 
 def make_conf_error(connection,config_profile):