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

[Magnus Granberg]

commit:     dbdc835ba201fb580985101955725e85f1b83586
Author:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
AuthorDate: Thu Nov 29 22:10:06 2012 +0000
Commit:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
CommitDate: Thu Nov 29 22:10:06 2012 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=dev/zorry.git;a=commit;h=dbdc835b

Rework on the db and some code

---
 gobs/bin/gobs_host_jobs       |    3 +-
 gobs/pym/ConnectionManager.py |    3 +-
 gobs/pym/buildquerydb.py      |    2 +-
 gobs/pym/categories.py        |   30 -
 gobs/pym/depgraph.py          | 1637 +++++++++++++++++++++++------------------
 gobs/pym/jobs.py              |  136 ++--
 gobs/pym/old_cpv.py           |   14 +-
 gobs/pym/package.py           |  561 ++++++++-------
 gobs/pym/pgsql.py             |    8 +-
 gobs/pym/pgsql_querys.py      |  308 ++++++++
 gobs/pym/repoman_gobs.py      |   10 +-
 gobs/pym/text.py              |    4 +-
 gobs/pym/updatedb.py          |  129 ++--
 13 files changed, 1673 insertions(+), 1172 deletions(-)

diff --git a/gobs/bin/gobs_host_jobs b/gobs/bin/gobs_host_jobs
index 5ece453..72683c9 100755
--- a/gobs/bin/gobs_host_jobs
+++ b/gobs/bin/gobs_host_jobs
@@ -1,5 +1,4 @@
 #!/usr/bin/python
-# Copyright 2006-2011 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 from __future__ import print_function
@@ -15,7 +14,7 @@ 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.pgsql_querys import add_gobs_logs
 
 import logging
 import time

diff --git a/gobs/pym/ConnectionManager.py b/gobs/pym/ConnectionManager.py
index ff0e07f..5e8a763 100644
--- a/gobs/pym/ConnectionManager.py
+++ b/gobs/pym/ConnectionManager.py
@@ -11,6 +11,7 @@ class connectionManager(object):
         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
+            cls._backend=settings_dict['sql_backend']
             cls._host=settings_dict['sql_host']
             cls._user=settings_dict['sql_user']
             cls._password=settings_dict['sql_passwd']
@@ -21,7 +22,7 @@ class connectionManager(object):
               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'
+              cls._name=cls._backend
             except ImportError:
               print("Please install a recent version of dev-python/psycopg for Python")
               sys.exit(1)

diff --git a/gobs/pym/buildquerydb.py b/gobs/pym/buildquerydb.py
index e0745e2..abd5ea9 100644
--- a/gobs/pym/buildquerydb.py
+++ b/gobs/pym/buildquerydb.py
@@ -68,7 +68,7 @@ def add_buildquery_main(config_id):
 	log_msg = "Check configs done"
 	add_gobs_logs(conn, log_msg, "info", config_profile)
 	# Get default config from the configs table  and default_config=1
-	default_config_root = "/var/lib/gobs/" + gobs_settings_dict['gobs_gitreponame'] + "/" + config_id + "/"
+	default_config_root = "/var/cache/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)

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

diff --git a/gobs/pym/depgraph.py b/gobs/pym/depgraph.py
index 7c46cde..0a6afc8 100644
--- a/gobs/pym/depgraph.py
+++ b/gobs/pym/depgraph.py
@@ -1,6 +1,5 @@
 # Copyright 1999-2012 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
-# Copy of ../pym/_emerge/depgraph.py from Portage
 
 from __future__ import print_function
 
@@ -19,14 +18,19 @@ from portage import os, OrderedDict
 from portage import _unicode_decode, _unicode_encode, _encodings
 from portage.const import PORTAGE_PACKAGE_ATOM, USER_CONFIG_PATH
 from portage.dbapi import dbapi
+from portage.dbapi.dep_expand import dep_expand
 from portage.dep import Atom, best_match_to_list, extract_affecting_use, \
-	check_required_use, human_readable_required_use, _repo_separator, \
-	_RequiredUseBranch, _RequiredUseLeaf
-from portage.eapi import eapi_has_strong_blocks, eapi_has_required_use
-from portage.exception import InvalidAtom, InvalidDependString, PortageException
+	check_required_use, human_readable_required_use, match_from_list, \
+	_repo_separator
+from portage.dep._slot_operator import ignore_built_slot_operator_deps
+from portage.eapi import eapi_has_strong_blocks, eapi_has_required_use, \
+	_get_eapi_attrs
+from portage.exception import (InvalidAtom, InvalidData, InvalidDependString,
+	PackageNotFound, PortageException)
 from portage.output import colorize, create_color_func, \
 	darkgreen, green
 bad = create_color_func("BAD")
+from portage.package.ebuild.config import _get_feature_flags
 from portage.package.ebuild.getmaskingstatus import \
 	_getmaskingstatus, _MaskReason
 from portage._sets import SETPREFIX
@@ -73,6 +77,9 @@ from _emerge.resolver.output import Display
 if sys.hexversion >= 0x3000000:
 	basestring = str
 	long = int
+	_unicode = str
+else:
+	_unicode = unicode
 
 class _scheduler_graph_config(object):
 	def __init__(self, trees, pkg_cache, graph, mergelist):
@@ -85,9 +92,9 @@ def _wildcard_set(atoms):
 	pkgs = InternalPackageSet(allow_wildcard=True)
 	for x in atoms:
 		try:
-			x = Atom(x, allow_wildcard=True)
+			x = Atom(x, allow_wildcard=True, allow_repo=False)
 		except portage.exception.InvalidAtom:
-			x = Atom("*/" + x, allow_wildcard=True)
+			x = Atom("*/" + x, allow_wildcard=True, allow_repo=False)
 		pkgs.add(x)
 	return pkgs
 
@@ -110,6 +117,8 @@ class _frozen_depgraph_config(object):
 		self._pkg_cache = {}
 		self._highest_license_masked = {}
 		dynamic_deps = myopts.get("--dynamic-deps", "y") != "n"
+		ignore_built_slot_operator_deps = myopts.get(
+			"--ignore-built-slot-operator-deps", "n") == "y"
 		for myroot in trees:
 			self.trees[myroot] = {}
 			# Create a RootConfig instance that references
@@ -124,7 +133,8 @@ class _frozen_depgraph_config(object):
 				FakeVartree(trees[myroot]["root_config"],
 					pkg_cache=self._pkg_cache,
 					pkg_root_config=self.roots[myroot],
-					dynamic_deps=dynamic_deps)
+					dynamic_deps=dynamic_deps,
+					ignore_built_slot_operator_deps=ignore_built_slot_operator_deps)
 			self.pkgsettings[myroot] = portage.config(
 				clone=self.trees[myroot]["vartree"].settings)
 
@@ -366,12 +376,15 @@ class _dynamic_depgraph_config(object):
 		# This use used to check if we have accounted for blockers
 		# relevant to a package.
 		self._traversed_pkg_deps = set()
-		self._slot_collision_info = {}
+		# This should be ordered such that the backtracker will
+		# attempt to solve conflicts which occurred earlier first,
+		# since an earlier conflict can be the cause of a conflict
+		# which occurs later.
+		self._slot_collision_info = OrderedDict()
 		# Slot collision nodes are not allowed to block other packages since
 		# blocker validation is only able to account for one package per slot.
 		self._slot_collision_nodes = set()
 		self._parent_atoms = {}
-		self._slot_conflict_parent_atoms = set()
 		self._slot_conflict_handler = None
 		self._circular_dependency_handler = None
 		self._serialized_tasks_cache = None
@@ -400,7 +413,9 @@ class _dynamic_depgraph_config(object):
 		self._needed_p_mask_changes = backtrack_parameters.needed_p_mask_changes
 		self._needed_license_changes = backtrack_parameters.needed_license_changes
 		self._needed_use_config_changes = backtrack_parameters.needed_use_config_changes
+		self._needed_required_use_config_changes = backtrack_parameters.needed_required_use_config_changes
 		self._runtime_pkg_mask = backtrack_parameters.runtime_pkg_mask
+		self._slot_operator_replace_installed = backtrack_parameters.slot_operator_replace_installed
 		self._need_restart = False
 		# For conditions that always require user intervention, such as
 		# unsatisfied REQUIRED_USE (currently has no autounmask support).
@@ -410,6 +425,8 @@ class _dynamic_depgraph_config(object):
 		self._autounmask = depgraph._frozen_config.myopts.get('--autounmask') != 'n'
 		self._success_without_autounmask = False
 		self._traverse_ignored_deps = False
+		self._complete_mode = False
+		self._slot_operator_deps = {}
 
 		for myroot in depgraph._frozen_config.trees:
 			self.sets[myroot] = _depgraph_sets()
@@ -487,8 +504,6 @@ class _dynamic_depgraph_config(object):
 class depgraph(object):
 
 	pkg_tree_map = RootConfig.pkg_tree_map
-
-	_dep_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
 	
 	def __init__(self, settings, trees, myopts, myparams, spinner,
 		frozen_config=None, backtrack_parameters=BacktrackParameter(), allow_backtracking=False):
@@ -521,10 +536,6 @@ class depgraph(object):
 			preload_installed_pkgs = \
 				"--nodeps" not in self._frozen_config.myopts
 
-			if self._frozen_config.myopts.get("--root-deps") is not None and \
-				myroot != self._frozen_config.target_root:
-				continue
-
 			fake_vartree = self._frozen_config.trees[myroot]["vartree"]
 			if not fake_vartree.dbapi:
 				# This needs to be called for the first depgraph, but not for
@@ -599,11 +610,17 @@ class depgraph(object):
 				"due to non matching USE:\n\n", noiselevel=-1)
 
 		for pkg, flags in self._dynamic_config.ignored_binaries.items():
-			writemsg("    =%s" % pkg.cpv, noiselevel=-1)
+			flag_display = []
+			for flag in sorted(flags):
+				if flag not in pkg.use.enabled:
+					flag = "-" + flag
+				flag_display.append(flag)
+			flag_display = " ".join(flag_display)
+			# The user can paste this line into package.use
+			writemsg("    =%s %s" % (pkg.cpv, flag_display), noiselevel=-1)
 			if pkg.root_config.settings["ROOT"] != "/":
-				writemsg(" for %s" % (pkg.root,), noiselevel=-1)
-			writemsg("\n        use flag(s): %s\n" % ", ".join(sorted(flags)),
-				noiselevel=-1)
+				writemsg(" # for %s" % (pkg.root,), noiselevel=-1)
+			writemsg("\n", noiselevel=-1)
 
 		msg = [
 			"",
@@ -615,7 +632,7 @@ class depgraph(object):
 		for line in msg:
 			if line:
 				line = colorize("INFORM", line)
-			writemsg_stdout(line + "\n", noiselevel=-1)
+			writemsg(line + "\n", noiselevel=-1)
 
 	def _show_missed_update(self):
 
@@ -801,37 +818,400 @@ class depgraph(object):
 
 	def _process_slot_conflicts(self):
 		"""
+		If there are any slot conflicts and backtracking is enabled,
+		_complete_graph should complete the graph before this method
+		is called, so that all relevant reverse dependencies are
+		available for use in backtracking decisions.
+		"""
+		for (slot_atom, root), slot_nodes in \
+			self._dynamic_config._slot_collision_info.items():
+			self._process_slot_conflict(root, slot_atom, slot_nodes)
+
+	def _process_slot_conflict(self, root, slot_atom, slot_nodes):
+		"""
 		Process slot conflict data to identify specific atoms which
 		lead to conflict. These atoms only match a subset of the
 		packages that have been pulled into a given slot.
 		"""
-		for (slot_atom, root), slot_nodes \
-			in self._dynamic_config._slot_collision_info.items():
 
-			all_parent_atoms = set()
-			for pkg in slot_nodes:
-				parent_atoms = self._dynamic_config._parent_atoms.get(pkg)
-				if not parent_atoms:
+		debug = "--debug" in self._frozen_config.myopts
+
+		slot_parent_atoms = set()
+		for pkg in slot_nodes:
+			parent_atoms = self._dynamic_config._parent_atoms.get(pkg)
+			if not parent_atoms:
+				continue
+			slot_parent_atoms.update(parent_atoms)
+
+		conflict_pkgs = []
+		conflict_atoms = {}
+		for pkg in slot_nodes:
+
+			if self._dynamic_config._allow_backtracking and \
+				pkg in self._dynamic_config._runtime_pkg_mask:
+				if debug:
+					writemsg_level(
+						"!!! backtracking loop detected: %s %s\n" % \
+						(pkg,
+						self._dynamic_config._runtime_pkg_mask[pkg]),
+						level=logging.DEBUG, noiselevel=-1)
+
+			parent_atoms = self._dynamic_config._parent_atoms.get(pkg)
+			if parent_atoms is None:
+				parent_atoms = set()
+				self._dynamic_config._parent_atoms[pkg] = parent_atoms
+
+			all_match = True
+			for parent_atom in slot_parent_atoms:
+				if parent_atom in parent_atoms:
 					continue
-				all_parent_atoms.update(parent_atoms)
+				# Use package set for matching since it will match via
+				# PROVIDE when necessary, while match_from_list does not.
+				parent, atom = parent_atom
+				atom_set = InternalPackageSet(
+					initial_atoms=(atom,), allow_repo=True)
+				if atom_set.findAtomForPackage(pkg,
+					modified_use=self._pkg_use_enabled(pkg)):
+					parent_atoms.add(parent_atom)
+				else:
+					all_match = False
+					conflict_atoms.setdefault(parent_atom, set()).add(pkg)
 
-			for pkg in slot_nodes:
-				parent_atoms = self._dynamic_config._parent_atoms.get(pkg)
-				if parent_atoms is None:
-					parent_atoms = set()
-					self._dynamic_config._parent_atoms[pkg] = parent_atoms
-				for parent_atom in all_parent_atoms:
-					if parent_atom in parent_atoms:
+			if not all_match:
+				conflict_pkgs.append(pkg)
+
+		if conflict_pkgs and \
+			self._dynamic_config._allow_backtracking and \
+			not self._accept_blocker_conflicts():
+			remaining = []
+			for pkg in conflict_pkgs:
+				if self._slot_conflict_backtrack_abi(pkg,
+					slot_nodes, conflict_atoms):
+					backtrack_infos = self._dynamic_config._backtrack_infos
+					config = backtrack_infos.setdefault("config", {})
+					config.setdefault("slot_conflict_abi", set()).add(pkg)
+				else:
+					remaining.append(pkg)
+			if remaining:
+				self._slot_confict_backtrack(root, slot_atom,
+					slot_parent_atoms, remaining)
+
+	def _slot_confict_backtrack(self, root, slot_atom,
+		all_parents, conflict_pkgs):
+
+		debug = "--debug" in self._frozen_config.myopts
+		existing_node = self._dynamic_config._slot_pkg_map[root][slot_atom]
+		backtrack_data = []
+		# The ordering of backtrack_data can make
+		# a difference here, because both mask actions may lead
+		# to valid, but different, solutions and the one with
+		# 'existing_node' masked is usually the better one. Because
+		# of that, we choose an order such that
+		# the backtracker will first explore the choice with
+		# existing_node masked. The backtracker reverses the
+		# order, so the order it uses is the reverse of the
+		# order shown here. See bug #339606.
+		if existing_node in conflict_pkgs and \
+			existing_node is not conflict_pkgs[-1]:
+			conflict_pkgs.remove(existing_node)
+			conflict_pkgs.append(existing_node)
+		for to_be_masked in conflict_pkgs:
+			# For missed update messages, find out which
+			# atoms matched to_be_selected that did not
+			# match to_be_masked.
+			parent_atoms = \
+				self._dynamic_config._parent_atoms.get(to_be_masked, set())
+			conflict_atoms = set(parent_atom for parent_atom in all_parents \
+				if parent_atom not in parent_atoms)
+			backtrack_data.append((to_be_masked, conflict_atoms))
+
+		if len(backtrack_data) > 1:
+			# NOTE: Generally, we prefer to mask the higher
+			# version since this solves common cases in which a
+			# lower version is needed so that all dependencies
+			# will be satisfied (bug #337178). However, if
+			# existing_node happens to be installed then we
+			# mask that since this is a common case that is
+			# triggered when --update is not enabled.
+			if existing_node.installed:
+				pass
+			elif any(pkg > existing_node for pkg in conflict_pkgs):
+				backtrack_data.reverse()
+
+		to_be_masked = backtrack_data[-1][0]
+
+		self._dynamic_config._backtrack_infos.setdefault(
+			"slot conflict", []).append(backtrack_data)
+		self._dynamic_config._need_restart = True
+		if debug:
+			msg = []
+			msg.append("")
+			msg.append("")
+			msg.append("backtracking due to slot conflict:")
+			msg.append("   first package:  %s" % existing_node)
+			msg.append("  package to mask: %s" % to_be_masked)
+			msg.append("      slot: %s" % slot_atom)
+			msg.append("   parents: %s" % ", ".join( \
+				"(%s, '%s')" % (ppkg, atom) for ppkg, atom in all_parents))
+			msg.append("")
+			writemsg_level("".join("%s\n" % l for l in msg),
+				noiselevel=-1, level=logging.DEBUG)
+
+	def _slot_conflict_backtrack_abi(self, pkg, slot_nodes, conflict_atoms):
+		"""
+		If one or more conflict atoms have a slot/sub-slot dep that can be resolved
+		by rebuilding the parent package, then schedule the rebuild via
+		backtracking, and return True. Otherwise, return False.
+		"""
+
+		found_update = False
+		for parent_atom, conflict_pkgs in conflict_atoms.items():
+			parent, atom = parent_atom
+			if atom.slot_operator != "=" or not parent.built:
+				continue
+
+			if pkg not in conflict_pkgs:
+				continue
+
+			for other_pkg in slot_nodes:
+				if other_pkg in conflict_pkgs:
+					continue
+
+				dep = Dependency(atom=atom, child=other_pkg,
+					parent=parent, root=pkg.root)
+
+				if self._slot_operator_update_probe(dep):
+					self._slot_operator_update_backtrack(dep)
+					found_update = True
+
+		return found_update
+
+	def _slot_operator_update_backtrack(self, dep, new_child_slot=None):
+		if new_child_slot is None:
+			child = dep.child
+		else:
+			child = new_child_slot
+		if "--debug" in self._frozen_config.myopts:
+			msg = []
+			msg.append("")
+			msg.append("")
+			msg.append("backtracking due to missed slot abi update:")
+			msg.append("   child package:  %s" % child)
+			if new_child_slot is not None:
+				msg.append("   new child slot package:  %s" % new_child_slot)
+			msg.append("   parent package: %s" % dep.parent)
+			msg.append("   atom: %s" % dep.atom)
+			msg.append("")
+			writemsg_level("\n".join(msg),
+				noiselevel=-1, level=logging.DEBUG)
+		backtrack_infos = self._dynamic_config._backtrack_infos
+		config = backtrack_infos.setdefault("config", {})
+
+		# mask unwanted binary packages if necessary
+		abi_masks = {}
+		if new_child_slot is None:
+			if not child.installed:
+				abi_masks.setdefault(child, {})["slot_operator_mask_built"] = None
+		if not dep.parent.installed:
+			abi_masks.setdefault(dep.parent, {})["slot_operator_mask_built"] = None
+		if abi_masks:
+			config.setdefault("slot_operator_mask_built", {}).update(abi_masks)
+
+		# trigger replacement of installed packages if necessary
+		abi_reinstalls = set()
+		if dep.parent.installed:
+			abi_reinstalls.add((dep.parent.root, dep.parent.slot_atom))
+		if new_child_slot is None and child.installed:
+			abi_reinstalls.add((child.root, child.slot_atom))
+		if abi_reinstalls:
+			config.setdefault("slot_operator_replace_installed",
+				set()).update(abi_reinstalls)
+
+		self._dynamic_config._need_restart = True
+
+	def _slot_operator_update_probe(self, dep, new_child_slot=False):
+		"""
+		slot/sub-slot := operators tend to prevent updates from getting pulled in,
+		since installed packages pull in packages with the slot/sub-slot that they
+		were built against. Detect this case so that we can schedule rebuilds
+		and reinstalls when appropriate.
+		NOTE: This function only searches for updates that involve upgrades
+			to higher versions, since the logic required to detect when a
+			downgrade would be desirable is not implemented.
+		"""
+
+		if dep.child.installed and \
+			self._frozen_config.excluded_pkgs.findAtomForPackage(dep.child,
+			modified_use=self._pkg_use_enabled(dep.child)):
+			return None
+
+		if dep.parent.installed and \
+			self._frozen_config.excluded_pkgs.findAtomForPackage(dep.parent,
+			modified_use=self._pkg_use_enabled(dep.parent)):
+			return None
+
+		debug = "--debug" in self._frozen_config.myopts
+		want_downgrade = None
+
+		for replacement_parent in self._iter_similar_available(dep.parent,
+			dep.parent.slot_atom):
+
+			for atom in replacement_parent.validated_atoms:
+				if not atom.slot_operator == "=" or \
+					atom.blocker or \
+					atom.cp != dep.atom.cp:
+					continue
+
+				# Discard USE deps, we're only searching for an approximate
+				# pattern, and dealing with USE states is too complex for
+				# this purpose.
+				atom = atom.without_use
+
+				if replacement_parent.built and \
+					portage.dep._match_slot(atom, dep.child):
+					# Our selected replacement_parent appears to be built
+					# for the existing child selection. So, discard this
+					# parent and search for another.
+					break
+
+				for pkg in self._iter_similar_available(
+					dep.child, atom):
+					if pkg.slot == dep.child.slot and \
+						pkg.sub_slot == dep.child.sub_slot:
+						# If slot/sub-slot is identical, then there's
+						# no point in updating.
 						continue
-					# Use package set for matching since it will match via
-					# PROVIDE when necessary, while match_from_list does not.
-					parent, atom = parent_atom
-					atom_set = InternalPackageSet(
-						initial_atoms=(atom,), allow_repo=True)
-					if atom_set.findAtomForPackage(pkg, modified_use=self._pkg_use_enabled(pkg)):
-						parent_atoms.add(parent_atom)
+					if new_child_slot:
+						if pkg.slot == dep.child.slot:
+							continue
+						if pkg < dep.child:
+							# the new slot only matters if the
+							# package version is higher
+							continue
 					else:
-						self._dynamic_config._slot_conflict_parent_atoms.add(parent_atom)
+						if pkg.slot != dep.child.slot:
+							continue
+						if pkg < dep.child:
+							if want_downgrade is None:
+								want_downgrade = self._downgrade_probe(dep.child)
+							# be careful not to trigger a rebuild when
+							# the only version available with a
+							# different slot_operator is an older version
+							if not want_downgrade:
+								continue
+
+					if debug:
+						msg = []
+						msg.append("")
+						msg.append("")
+						msg.append("slot_operator_update_probe:")
+						msg.append("   existing child package:  %s" % dep.child)
+						msg.append("   existing parent package: %s" % dep.parent)
+						msg.append("   new child package:  %s" % pkg)
+						msg.append("   new parent package: %s" % replacement_parent)
+						msg.append("")
+						writemsg_level("\n".join(msg),
+							noiselevel=-1, level=logging.DEBUG)
+
+					return pkg
+
+		if debug:
+			msg = []
+			msg.append("")
+			msg.append("")
+			msg.append("slot_operator_update_probe:")
+			msg.append("   existing child package:  %s" % dep.child)
+			msg.append("   existing parent package: %s" % dep.parent)
+			msg.append("   new child package:  %s" % None)
+			msg.append("   new parent package: %s" % None)
+			msg.append("")
+			writemsg_level("\n".join(msg),
+				noiselevel=-1, level=logging.DEBUG)
+
+		return None
+
+	def _downgrade_probe(self, pkg):
+		"""
+		Detect cases where a downgrade of the given package is considered
+		desirable due to the current version being masked or unavailable.
+		"""
+		available_pkg = None
+		for available_pkg in self._iter_similar_available(pkg,
+			pkg.slot_atom):
+			if available_pkg >= pkg:
+				# There's an available package of the same or higher
+				# version, so downgrade seems undesirable.
+				return False
+
+		return available_pkg is not None
+
+	def _iter_similar_available(self, graph_pkg, atom):
+		"""
+		Given a package that's in the graph, do a rough check to
+		see if a similar package is available to install. The given
+		graph_pkg itself may be yielded only if it's not installed.
+		"""
+
+		usepkgonly = "--usepkgonly" in self._frozen_config.myopts
+		useoldpkg_atoms = self._frozen_config.useoldpkg_atoms
+		use_ebuild_visibility = self._frozen_config.myopts.get(
+			'--use-ebuild-visibility', 'n') != 'n'
+
+		for pkg in self._iter_match_pkgs_any(
+			graph_pkg.root_config, atom):
+			if pkg.cp != graph_pkg.cp:
+				# discard old-style virtual match
+				continue
+			if pkg.installed:
+				continue
+			if pkg in self._dynamic_config._runtime_pkg_mask:
+				continue
+			if self._frozen_config.excluded_pkgs.findAtomForPackage(pkg,
+				modified_use=self._pkg_use_enabled(pkg)):
+				continue
+			if not self._pkg_visibility_check(pkg):
+				continue
+			if pkg.built:
+				if self._equiv_binary_installed(pkg):
+					continue
+				if not (not use_ebuild_visibility and
+					(usepkgonly or useoldpkg_atoms.findAtomForPackage(
+					pkg, modified_use=self._pkg_use_enabled(pkg)))) and \
+					not self._equiv_ebuild_visible(pkg):
+					continue
+			yield pkg
+
+	def _slot_operator_trigger_reinstalls(self):
+		"""
+		Search for packages with slot-operator deps on older slots, and schedule
+		rebuilds if they can link to a newer slot that's in the graph.
+		"""
+
+		rebuild_if_new_slot = self._dynamic_config.myparams.get(
+			"rebuild_if_new_slot", "y") == "y"
+
+		for slot_key, slot_info in self._dynamic_config._slot_operator_deps.items():
+
+			for dep in slot_info:
+				if not (dep.child.built and dep.parent and
+					isinstance(dep.parent, Package) and dep.parent.built):
+					continue
+
+				# Check for slot update first, since we don't want to
+				# trigger reinstall of the child package when a newer
+				# slot will be used instead.
+				if rebuild_if_new_slot:
+					new_child = self._slot_operator_update_probe(dep,
+						new_child_slot=True)
+					if new_child:
+						self._slot_operator_update_backtrack(dep,
+							new_child_slot=new_child)
+						break
+
+				if dep.want_update:
+					if self._slot_operator_update_probe(dep):
+						self._slot_operator_update_backtrack(dep)
+						break
 
 	def _reinstall_for_flags(self, pkg, forced_flags,
 		orig_use, orig_iuse, cur_use, cur_iuse):
@@ -845,18 +1225,22 @@ class depgraph(object):
 			in ("y", "auto"))
 		newuse = "--newuse" in self._frozen_config.myopts
 		changed_use = "changed-use" == self._frozen_config.myopts.get("--reinstall")
+		feature_flags = _get_feature_flags(
+			_get_eapi_attrs(pkg.metadata["EAPI"]))
 
 		if newuse or (binpkg_respect_use and not changed_use):
 			flags = set(orig_iuse.symmetric_difference(
 				cur_iuse).difference(forced_flags))
 			flags.update(orig_iuse.intersection(orig_use).symmetric_difference(
 				cur_iuse.intersection(cur_use)))
+			flags.difference_update(feature_flags)
 			if flags:
 				return flags
 
 		elif changed_use or binpkg_respect_use:
-			flags = orig_iuse.intersection(orig_use).symmetric_difference(
-				cur_iuse.intersection(cur_use))
+			flags = set(orig_iuse.intersection(orig_use).symmetric_difference(
+				cur_iuse.intersection(cur_use)))
+			flags.difference_update(feature_flags)
 			if flags:
 				return flags
 		return None
@@ -1100,12 +1484,13 @@ class depgraph(object):
 		# package selection, since we want to prompt the user
 		# for USE adjustment rather than have REQUIRED_USE
 		# affect package selection and || dep choices.
-		"""if not pkg.built and pkg.metadata.get("REQUIRED_USE") and \
+		if not pkg.built and pkg.metadata.get("REQUIRED_USE") and \
 			eapi_has_required_use(pkg.metadata["EAPI"]):
 			required_use_is_sat = check_required_use(
 				pkg.metadata["REQUIRED_USE"],
 				self._pkg_use_enabled(pkg),
-				pkg.iuse.is_valid_flag)
+				pkg.iuse.is_valid_flag,
+				eapi=pkg.metadata["EAPI"])
 			if not required_use_is_sat:
 				if dep.atom is not None and dep.parent is not None:
 					self._add_parent_atom(pkg, (dep.parent, dep.atom))
@@ -1119,9 +1504,10 @@ class depgraph(object):
 				if atom is None:
 					atom = Atom("=" + pkg.cpv)
 				self._dynamic_config._unsatisfied_deps_for_display.append(
-					((pkg.root, atom), {"myparent":dep.parent}))
+					((pkg.root, atom),
+					{"myparent" : dep.parent, "show_req_use" : pkg}))
 				self._dynamic_config._skip_restart = True
-				return 0"""
+				return 0
 
 		if not pkg.onlydeps:
 
@@ -1150,121 +1536,7 @@ class depgraph(object):
 								(dep.parent, dep.atom))
 					return 1
 				else:
-					# A slot conflict has occurred. 
-					# The existing node should not already be in
-					# runtime_pkg_mask, since that would trigger an
-					# infinite backtracking loop.
-					if self._dynamic_config._allow_backtracking and \
-						existing_node in \
-						self._dynamic_config._runtime_pkg_mask:
-						if "--debug" in self._frozen_config.myopts:
-							writemsg(
-								"!!! backtracking loop detected: %s %s\n" % \
-								(existing_node,
-								self._dynamic_config._runtime_pkg_mask[
-								existing_node]), noiselevel=-1)
-					elif self._dynamic_config._allow_backtracking and \
-						not self._accept_blocker_conflicts() and \
-						not self.need_restart():
-
-						self._add_slot_conflict(pkg)
-						if dep.atom is not None and dep.parent is not None:
-							self._add_parent_atom(pkg, (dep.parent, dep.atom))
-
-						if arg_atoms:
-							for parent_atom in arg_atoms:
-								parent, atom = parent_atom
-								self._add_parent_atom(pkg, parent_atom)
-						self._process_slot_conflicts()
-
-						backtrack_data = []
-						fallback_data = []
-						all_parents = set()
-						# The ordering of backtrack_data can make
-						# a difference here, because both mask actions may lead
-						# to valid, but different, solutions and the one with
-						# 'existing_node' masked is usually the better one. Because
-						# of that, we choose an order such that
-						# the backtracker will first explore the choice with
-						# existing_node masked. The backtracker reverses the
-						# order, so the order it uses is the reverse of the
-						# order shown here. See bug #339606.
-						for to_be_selected, to_be_masked in (existing_node, pkg), (pkg, existing_node):
-							# For missed update messages, find out which
-							# atoms matched to_be_selected that did not
-							# match to_be_masked.
-							parent_atoms = \
-								self._dynamic_config._parent_atoms.get(to_be_selected, set())
-							if parent_atoms:
-								conflict_atoms = self._dynamic_config._slot_conflict_parent_atoms.intersection(parent_atoms)
-								if conflict_atoms:
-									parent_atoms = conflict_atoms
-
-							all_parents.update(parent_atoms)
-
-							all_match = True
-							for parent, atom in parent_atoms:
-								i = InternalPackageSet(initial_atoms=(atom,),
-									allow_repo=True)
-								if not i.findAtomForPackage(to_be_masked):
-									all_match = False
-									break
-
-							fallback_data.append((to_be_masked, parent_atoms))
-
-							if all_match:
-								# 'to_be_masked' does not violate any parent atom, which means
-								# there is no point in masking it.
-								pass
-							else:
-								backtrack_data.append((to_be_masked, parent_atoms))
-
-						if not backtrack_data:
-							# This shouldn't happen, but fall back to the old
-							# behavior if this gets triggered somehow.
-							backtrack_data = fallback_data
-
-						if len(backtrack_data) > 1:
-							# NOTE: Generally, we prefer to mask the higher
-							# version since this solves common cases in which a
-							# lower version is needed so that all dependencies
-							# will be satisfied (bug #337178). However, if
-							# existing_node happens to be installed then we
-							# mask that since this is a common case that is
-							# triggered when --update is not enabled.
-							if existing_node.installed:
-								pass
-							elif pkg > existing_node:
-								backtrack_data.reverse()
-
-						to_be_masked = backtrack_data[-1][0]
-
-						self._dynamic_config._backtrack_infos["slot conflict"] = backtrack_data
-						self._dynamic_config._need_restart = True
-						if "--debug" in self._frozen_config.myopts:
-							msg = []
-							msg.append("")
-							msg.append("")
-							msg.append("backtracking due to slot conflict:")
-							if backtrack_data is fallback_data:
-								msg.append("!!! backtrack_data fallback")
-							msg.append("   first package:  %s" % existing_node)
-							msg.append("   second package: %s" % pkg)
-							msg.append("  package to mask: %s" % to_be_masked)
-							msg.append("      slot: %s" % pkg.slot_atom)
-							msg.append("   parents: %s" % ", ".join( \
-								"(%s, '%s')" % (ppkg, atom) for ppkg, atom in all_parents))
-							msg.append("")
-							writemsg_level("".join("%s\n" % l for l in msg),
-								noiselevel=-1, level=logging.DEBUG)
-						return 0
-
-					# A slot collision has occurred.  Sometimes this coincides
-					# with unresolvable blockers, so the slot collision will be
-					# shown later if there are no unresolvable blockers.
 					self._add_slot_conflict(pkg)
-					slot_collision = True
-
 					if debug:
 						writemsg_level(
 							"%s%s %s\n" % ("Slot Conflict:".ljust(15),
@@ -1273,6 +1545,8 @@ class depgraph(object):
 							modified_use=self._pkg_use_enabled(existing_node))),
 							level=logging.DEBUG, noiselevel=-1)
 
+					slot_collision = True
+
 			if slot_collision:
 				# Now add this node to the graph so that self.display()
 				# can show use flags and --tree portage.output.  This node is
@@ -1329,10 +1603,27 @@ class depgraph(object):
 		# Installing package A, we need to make sure package A's deps are met.
 		# emerge --deep <pkgspec>; we need to recursively check dependencies of pkgspec
 		# If we are in --nodeps (no recursion) mode, we obviously only check 1 level of dependencies.
-		if arg_atoms:
-			depth = 0
+		if arg_atoms and depth > 0:
+			for parent, atom in arg_atoms:
+				if parent.reset_depth:
+					depth = 0
+					break
+
+		if previously_added and pkg.depth is not None:
+			depth = min(pkg.depth, depth)
 		pkg.depth = depth
 		deep = self._dynamic_config.myparams.get("deep", 0)
+		update = "--update" in self._frozen_config.myopts
+
+		dep.want_update = (not self._dynamic_config._complete_mode and
+			(arg_atoms or update) and
+			not (deep is not True and depth > deep))
+
+		dep.child = pkg
+		if (not pkg.onlydeps and pkg.built and
+			dep.atom and dep.atom.slot_operator_built):
+			self._add_slot_operator_dep(dep)
+
 		recurse = deep is True or depth + 1 <= deep
 		dep_stack = self._dynamic_config._dep_stack
 		if "recurse" not in self._dynamic_config.myparams:
@@ -1364,6 +1655,14 @@ class depgraph(object):
 			self._dynamic_config._parent_atoms[pkg] = parent_atoms
 		parent_atoms.add(parent_atom)
 
+	def _add_slot_operator_dep(self, dep):
+		slot_key = (dep.root, dep.child.slot_atom)
+		slot_info = self._dynamic_config._slot_operator_deps.get(slot_key)
+		if slot_info is None:
+			slot_info = []
+			self._dynamic_config._slot_operator_deps[slot_key] = slot_info
+		slot_info.append(dep)
+
 	def _add_slot_conflict(self, pkg):
 		self._dynamic_config._slot_collision_nodes.add(pkg)
 		slot_key = (pkg.slot_atom, pkg.root)
@@ -1379,10 +1678,10 @@ class depgraph(object):
 		myroot = pkg.root
 		metadata = pkg.metadata
 		removal_action = "remove" in self._dynamic_config.myparams
+		eapi_attrs = _get_eapi_attrs(pkg.metadata["EAPI"])
 
 		edepend={}
-		depkeys = ["DEPEND","RDEPEND","PDEPEND"]
-		for k in depkeys:
+		for k in Package._dep_keys:
 			edepend[k] = metadata[k]
 
 		if not pkg.built and \
@@ -1409,31 +1708,44 @@ class depgraph(object):
 			# Removal actions never traverse ignored buildtime
 			# dependencies, so it's safe to discard them early.
 			edepend["DEPEND"] = ""
+			edepend["HDEPEND"] = ""
 			ignore_build_time_deps = True
 
+		ignore_depend_deps = ignore_build_time_deps
+		ignore_hdepend_deps = ignore_build_time_deps
+
 		if removal_action:
 			depend_root = myroot
 		else:
-			depend_root = self._frozen_config._running_root.root
-			root_deps = self._frozen_config.myopts.get("--root-deps")
-			if root_deps is not None:
-				if root_deps is True:
-					depend_root = myroot
-				elif root_deps == "rdeps":
-					ignore_build_time_deps = True
+			if eapi_attrs.hdepend:
+				depend_root = myroot
+			else:
+				depend_root = self._frozen_config._running_root.root
+				root_deps = self._frozen_config.myopts.get("--root-deps")
+				if root_deps is not None:
+					if root_deps is True:
+						depend_root = myroot
+					elif root_deps == "rdeps":
+						ignore_depend_deps = True
 
 		# If rebuild mode is not enabled, it's safe to discard ignored
 		# build-time dependencies. If you want these deps to be traversed
 		# in "complete" mode then you need to specify --with-bdeps=y.
-		if ignore_build_time_deps and \
-			not self._rebuild.rebuild:
-			edepend["DEPEND"] = ""
+		if not self._rebuild.rebuild:
+			if ignore_depend_deps:
+				edepend["DEPEND"] = ""
+			if ignore_hdepend_deps:
+				edepend["HDEPEND"] = ""
 
 		deps = (
 			(depend_root, edepend["DEPEND"],
 				self._priority(buildtime=True,
-				optional=(pkg.built or ignore_build_time_deps),
-				ignored=ignore_build_time_deps)),
+				optional=(pkg.built or ignore_depend_deps),
+				ignored=ignore_depend_deps)),
+			(self._frozen_config._running_root.root, edepend["HDEPEND"],
+				self._priority(buildtime=True,
+				optional=(pkg.built or ignore_hdepend_deps),
+				ignored=ignore_hdepend_deps)),
 			(myroot, edepend["RDEPEND"],
 				self._priority(runtime=True)),
 			(myroot, edepend["PDEPEND"],
@@ -1455,7 +1767,10 @@ class depgraph(object):
 
 				try:
 					dep_string = portage.dep.use_reduce(dep_string,
-						uselist=self._pkg_use_enabled(pkg), is_valid_flag=pkg.iuse.is_valid_flag)
+						uselist=self._pkg_use_enabled(pkg),
+						is_valid_flag=pkg.iuse.is_valid_flag,
+						opconvert=True, token_class=Atom,
+						eapi=pkg.metadata['EAPI'])
 				except portage.exception.InvalidDependString as e:
 					if not pkg.installed:
 						# should have been masked before it was selected
@@ -1467,7 +1782,9 @@ class depgraph(object):
 					# practical to ignore this issue for installed packages.
 					try:
 						dep_string = portage.dep.use_reduce(dep_string,
-							uselist=self._pkg_use_enabled(pkg))
+							uselist=self._pkg_use_enabled(pkg),
+							opconvert=True, token_class=Atom,
+							eapi=pkg.metadata['EAPI'])
 					except portage.exception.InvalidDependString as e:
 						self._dynamic_config._masked_installed.add(pkg)
 						del e
@@ -1488,9 +1805,6 @@ class depgraph(object):
 				if not dep_string:
 					continue
 
-				dep_string = portage.dep.paren_enclose(dep_string,
-					unevaluated_atom=True)
-
 				if not self._add_pkg_dep_string(
 					pkg, dep_root, dep_priority, dep_string,
 					allow_unsatisfied):
@@ -1524,7 +1838,9 @@ class depgraph(object):
 		if debug:
 			writemsg_level("\nParent:    %s\n" % (pkg,),
 				noiselevel=-1, level=logging.DEBUG)
-			writemsg_level("Depstring: %s\n" % (dep_string,),
+			dep_repr = portage.dep.paren_enclose(dep_string,
+				unevaluated_atom=True, opconvert=True)
+			writemsg_level("Depstring: %s\n" % (dep_repr,),
 				noiselevel=-1, level=logging.DEBUG)
 			writemsg_level("Priority:  %s\n" % (dep_priority,),
 				noiselevel=-1, level=logging.DEBUG)
@@ -1602,16 +1918,11 @@ class depgraph(object):
 				self._dynamic_config._slot_pkg_map[dep.child.root].get(
 				dep.child.slot_atom) is None:
 				myarg = None
-				if dep.root == self._frozen_config.target_root:
-					try:
-						myarg = next(self._iter_atoms_for_pkg(dep.child))
-					except StopIteration:
-						pass
-					except InvalidDependString:
-						if not dep.child.installed:
-							# This shouldn't happen since the package
-							# should have been masked.
-							raise
+				try:
+					myarg = next(self._iter_atoms_for_pkg(dep.child), None)
+				except InvalidDependString:
+					if not dep.child.installed:
+						raise
 
 				if myarg is None:
 					# Existing child selection may not be valid unless
@@ -1717,14 +2028,11 @@ class depgraph(object):
 					self._dynamic_config._slot_pkg_map[dep.child.root].get(
 					dep.child.slot_atom) is None:
 					myarg = None
-					if dep.root == self._frozen_config.target_root:
-						try:
-							myarg = next(self._iter_atoms_for_pkg(dep.child))
-						except StopIteration:
-							pass
-						except InvalidDependString:
-							if not dep.child.installed:
-								raise
+					try:
+						myarg = next(self._iter_atoms_for_pkg(dep.child), None)
+					except InvalidDependString:
+						if not dep.child.installed:
+							raise
 
 					if myarg is None:
 						ignored = True
@@ -1818,9 +2126,14 @@ class depgraph(object):
 			# Yield ~, =*, < and <= atoms first, since those are more likely to
 			# cause slot conflicts, and we want those atoms to be displayed
 			# in the resulting slot conflict message (see bug #291142).
+			# Give similar treatment to slot/sub-slot atoms.
 			conflict_atoms = []
 			normal_atoms = []
+			abi_atoms = []
 			for atom in cp_atoms:
+				if atom.slot_operator_built:
+					abi_atoms.append(atom)
+					continue
 				conflict = False
 				for child_pkg in atom_pkg_graph.child_nodes(atom):
 					existing_node, matches = \
@@ -1833,7 +2146,7 @@ class depgraph(object):
 				else:
 					normal_atoms.append(atom)
 
-			for atom in chain(conflict_atoms, normal_atoms):
+			for atom in chain(abi_atoms, conflict_atoms, normal_atoms):
 				child_pkgs = atom_pkg_graph.child_nodes(atom)
 				# if more than one child, yield highest version
 				if len(child_pkgs) > 1:
@@ -1846,34 +2159,22 @@ class depgraph(object):
 		Yields non-disjunctive deps. Raises InvalidDependString when 
 		necessary.
 		"""
-		i = 0
-		while i < len(dep_struct):
-			x = dep_struct[i]
+		for x in dep_struct:
 			if isinstance(x, list):
-				for y in self._queue_disjunctive_deps(
-					pkg, dep_root, dep_priority, x):
-					yield y
-			elif x == "||":
-				self._queue_disjunction(pkg, dep_root, dep_priority,
-					[ x, dep_struct[ i + 1 ] ] )
-				i += 1
+				if x and x[0] == "||":
+					self._queue_disjunction(pkg, dep_root, dep_priority, [x])
+				else:
+					for y in self._queue_disjunctive_deps(
+						pkg, dep_root, dep_priority, x):
+						yield y
 			else:
-				try:
-					x = portage.dep.Atom(x, eapi=pkg.metadata["EAPI"])
-				except portage.exception.InvalidAtom:
-					if not pkg.installed:
-						raise portage.exception.InvalidDependString(
-							"invalid atom: '%s'" % x)
+				# Note: Eventually this will check for PROPERTIES=virtual
+				# or whatever other metadata gets implemented for this
+				# purpose.
+				if x.cp.startswith('virtual/'):
+					self._queue_disjunction(pkg, dep_root, dep_priority, [x])
 				else:
-					# Note: Eventually this will check for PROPERTIES=virtual
-					# or whatever other metadata gets implemented for this
-					# purpose.
-					if x.cp.startswith('virtual/'):
-						self._queue_disjunction( pkg, dep_root,
-							dep_priority, [ str(x) ] )
-					else:
-						yield str(x)
-			i += 1
+					yield x
 
 	def _queue_disjunction(self, pkg, dep_root, dep_priority, dep_struct):
 		self._dynamic_config._dep_disjunctive_stack.append(
@@ -1886,10 +2187,8 @@ class depgraph(object):
 		"""
 		pkg, dep_root, dep_priority, dep_struct = \
 			self._dynamic_config._dep_disjunctive_stack.pop()
-		dep_string = portage.dep.paren_enclose(dep_struct,
-			unevaluated_atom=True)
 		if not self._add_pkg_dep_string(
-			pkg, dep_root, dep_priority, dep_string, allow_unsatisfied):
+			pkg, dep_root, dep_priority, dep_struct, allow_unsatisfied):
 			return 0
 		return 1
 
@@ -1999,8 +2298,18 @@ class depgraph(object):
 						writemsg("!!! Please ensure the tbz2 exists as specified.\n\n", noiselevel=-1)
 						return 0, myfavorites
 				mytbz2=portage.xpak.tbz2(x)
-				mykey=mytbz2.getelements("CATEGORY")[0]+"/"+os.path.splitext(os.path.basename(x))[0]
-				if os.path.realpath(x) != \
+				mykey = None
+				cat = mytbz2.getfile("CATEGORY")
+				if cat is not None:
+					cat = _unicode_decode(cat.strip(),
+						encoding=_encodings['repo.content'])
+					mykey = cat + "/" + os.path.basename(x)[:-5]
+
+				if mykey is None:
+					writemsg(colorize("BAD", "\n*** Package is missing CATEGORY metadata: %s.\n\n" % x), noiselevel=-1)
+					self._dynamic_config._skip_restart = True
+					return 0, myfavorites
+				elif os.path.realpath(x) != \
 					os.path.realpath(bindb.bintree.getname(mykey)):
 					writemsg(colorize("BAD", "\n*** You need to adjust PKGDIR to emerge this package.\n\n"), noiselevel=-1)
 					self._dynamic_config._skip_restart = True
@@ -2193,13 +2502,8 @@ class depgraph(object):
 				return 0, []
 
 			for cpv in owners:
-				slot = vardb.aux_get(cpv, ["SLOT"])[0]
-				if not slot:
-					# portage now masks packages with missing slot, but it's
-					# possible that one was installed by an older version
-					atom = Atom(portage.cpv_getkey(cpv))
-				else:
-					atom = Atom("%s:%s" % (portage.cpv_getkey(cpv), slot))
+				pkg = vardb._pkg_str(cpv, None)
+				atom = Atom("%s:%s" % (pkg.cp, pkg.slot))
 				args.append(AtomArg(arg=atom, atom=atom,
 					root_config=root_config))
 
@@ -2247,6 +2551,7 @@ class depgraph(object):
 			args = revised_greedy_args
 			del revised_greedy_args
 
+		args.extend(self._gen_reinstall_sets())
 		self._set_args(args)
 
 		myfavorites = set(myfavorites)
@@ -2254,7 +2559,8 @@ class depgraph(object):
 			if isinstance(arg, (AtomArg, PackageArg)):
 				myfavorites.add(arg.atom)
 			elif isinstance(arg, SetArg):
-				myfavorites.add(arg.arg)
+				if not arg.internal:
+					myfavorites.add(arg.arg)
 		myfavorites = list(myfavorites)
 
 		if debug:
@@ -2264,7 +2570,33 @@ class depgraph(object):
 		self._dynamic_config._initial_arg_list = args[:]
 	
 		return self._resolve(myfavorites)
-	
+
+	def _gen_reinstall_sets(self):
+
+		atom_list = []
+		for root, atom in self._rebuild.rebuild_list:
+			atom_list.append((root, '__auto_rebuild__', atom))
+		for root, atom in self._rebuild.reinstall_list:
+			atom_list.append((root, '__auto_reinstall__', atom))
+		for root, atom in self._dynamic_config._slot_operator_replace_installed:
+			atom_list.append((root, '__auto_slot_operator_replace_installed__', atom))
+
+		set_dict = {}
+		for root, set_name, atom in atom_list:
+			set_dict.setdefault((root, set_name), []).append(atom)
+
+		for (root, set_name), atoms in set_dict.items():
+			yield SetArg(arg=(SETPREFIX + set_name),
+				# Set reset_depth=False here, since we don't want these
+				# special sets to interact with depth calculations (see
+				# the emerge --deep=DEPTH option), though we want them
+				# to behave like normal arguments in most other respects.
+				pset=InternalPackageSet(initial_atoms=atoms),
+				force_reinstall=True,
+				internal=True,
+				reset_depth=False,
+				root_config=self._frozen_config.roots[root])
+
 	def _resolve(self, myfavorites):
 		"""Given self._dynamic_config._initial_arg_list, pull in the root nodes, 
 		call self._creategraph to process theier deps and return 
@@ -2276,10 +2608,7 @@ class depgraph(object):
 		pprovideddict = pkgsettings.pprovideddict
 		virtuals = pkgsettings.getvirtuals()
 		args = self._dynamic_config._initial_arg_list[:]
-		for root, atom in chain(self._rebuild.rebuild_list,
-			self._rebuild.reinstall_list):
-			args.append(AtomArg(arg=atom, atom=atom,
-				root_config=self._frozen_config.roots[root]))
+
 		for arg in self._expand_set_args(args, add_to_digraph=True):
 			for atom in arg.pset.getAtoms():
 				self._spinner_update()
@@ -2389,22 +2718,12 @@ class depgraph(object):
 		except self._unknown_internal_error:
 			return False, myfavorites
 
-		digraph_set = frozenset(self._dynamic_config.digraph)
-
-		if digraph_set.intersection(
-			self._dynamic_config._needed_unstable_keywords) or \
-			digraph_set.intersection(
-			self._dynamic_config._needed_p_mask_changes) or \
-			digraph_set.intersection(
-			self._dynamic_config._needed_use_config_changes) or \
-			digraph_set.intersection(
-			self._dynamic_config._needed_license_changes) :
-			#We failed if the user needs to change the configuration
-			self._dynamic_config._success_without_autounmask = True
+		if (self._dynamic_config._slot_collision_info and
+			not self._accept_blocker_conflicts()) or \
+			(self._dynamic_config._allow_backtracking and
+			"slot conflict" in self._dynamic_config._backtrack_infos):
 			return False, myfavorites
 
-		digraph_set = None
-
 		if self._rebuild.trigger_rebuilds():
 			backtrack_infos = self._dynamic_config._backtrack_infos
 			config = backtrack_infos.setdefault("config", {})
@@ -2413,6 +2732,32 @@ class depgraph(object):
 			self._dynamic_config._need_restart = True
 			return False, myfavorites
 
+		if "config" in self._dynamic_config._backtrack_infos and \
+			("slot_operator_mask_built" in self._dynamic_config._backtrack_infos["config"] or
+			"slot_operator_replace_installed" in self._dynamic_config._backtrack_infos["config"]) and \
+			self.need_restart():
+			return False, myfavorites
+
+		# Any failures except those due to autounmask *alone* should return
+		# before this point, since the success_without_autounmask flag that's
+		# set below is reserved for cases where there are *zero* other
+		# problems. For reference, see backtrack_depgraph, where it skips the
+		# get_best_run() call when success_without_autounmask is True.
+
+		digraph_nodes = self._dynamic_config.digraph.nodes
+
+		if any(x in digraph_nodes for x in
+			self._dynamic_config._needed_unstable_keywords) or \
+			any(x in digraph_nodes for x in
+			self._dynamic_config._needed_p_mask_changes) or \
+			any(x in digraph_nodes for x in
+			self._dynamic_config._needed_use_config_changes) or \
+			any(x in digraph_nodes for x in
+			self._dynamic_config._needed_license_changes) :
+			#We failed if the user needs to change the configuration
+			self._dynamic_config._success_without_autounmask = True
+			return False, myfavorites
+
 		# We're true here unless we are missing binaries.
 		return (True, myfavorites)
 
@@ -2485,14 +2830,15 @@ class depgraph(object):
 		slots = set()
 		for cpv in vardb.match(atom):
 			# don't mix new virtuals with old virtuals
-			if portage.cpv_getkey(cpv) == highest_pkg.cp:
-				slots.add(vardb.aux_get(cpv, ["SLOT"])[0])
+			pkg = vardb._pkg_str(cpv, None)
+			if pkg.cp == highest_pkg.cp:
+				slots.add(pkg.slot)
 
-		slots.add(highest_pkg.metadata["SLOT"])
+		slots.add(highest_pkg.slot)
 		if len(slots) == 1:
 			return []
 		greedy_pkgs = []
-		slots.remove(highest_pkg.metadata["SLOT"])
+		slots.remove(highest_pkg.slot)
 		while slots:
 			slot = slots.pop()
 			slot_atom = portage.dep.Atom("%s:%s" % (highest_pkg.cp, slot))
@@ -2506,7 +2852,7 @@ class depgraph(object):
 			return [pkg.slot_atom for pkg in greedy_pkgs]
 
 		blockers = {}
-		blocker_dep_keys = ["DEPEND", "PDEPEND", "RDEPEND"]
+		blocker_dep_keys = Package._dep_keys
 		for pkg in greedy_pkgs + [highest_pkg]:
 			dep_str = " ".join(pkg.metadata[k] for k in blocker_dep_keys)
 			try:
@@ -2567,6 +2913,22 @@ class depgraph(object):
 		"""This will raise InvalidDependString if necessary. If trees is
 		None then self._dynamic_config._filtered_trees is used."""
 
+		if not isinstance(depstring, list):
+			eapi = None
+			is_valid_flag = None
+			if parent is not None:
+				eapi = parent.metadata['EAPI']
+				if not parent.installed:
+					is_valid_flag = parent.iuse.is_valid_flag
+			depstring = portage.dep.use_reduce(depstring,
+				uselist=myuse, opconvert=True, token_class=Atom,
+				is_valid_flag=is_valid_flag, eapi=eapi)
+
+		if (self._dynamic_config.myparams.get(
+			"ignore_built_slot_operator_deps", "n") == "y" and
+			parent and parent.built):
+			ignore_built_slot_operator_deps(depstring)
+
 		pkgsettings = self._frozen_config.pkgsettings[root]
 		if trees is None:
 			trees = self._dynamic_config._filtered_trees
@@ -2751,7 +3113,7 @@ class depgraph(object):
 
 		if target_atom is not None and isinstance(node, Package):
 			affecting_use = set()
-			for dep_str in "DEPEND", "RDEPEND", "PDEPEND":
+			for dep_str in Package._dep_keys:
 				try:
 					affecting_use.update(extract_affecting_use(
 						node.metadata[dep_str], target_atom,
@@ -2832,13 +3194,13 @@ class depgraph(object):
 				if priorities is None:
 					# This edge comes from _parent_atoms and was not added to
 					# the graph, and _parent_atoms does not contain priorities.
-					dep_strings.add(node.metadata["DEPEND"])
-					dep_strings.add(node.metadata["RDEPEND"])
-					dep_strings.add(node.metadata["PDEPEND"])
+					for k in Package._dep_keys:
+						dep_strings.add(node.metadata[k])
 				else:
 					for priority in priorities:
 						if priority.buildtime:
-							dep_strings.add(node.metadata["DEPEND"])
+							for k in Package._buildtime_keys:
+								dep_strings.add(node.metadata[k])
 						if priority.runtime:
 							dep_strings.add(node.metadata["RDEPEND"])
 						if priority.runtime_post:
@@ -2930,7 +3292,7 @@ class depgraph(object):
 
 
 	def _show_unsatisfied_dep(self, root, atom, myparent=None, arg=None,
-		check_backtrack=False, check_autounmask_breakage=False):
+		check_backtrack=False, check_autounmask_breakage=False, show_req_use=None):
 		"""
 		When check_backtrack=True, no output is produced and
 		the method either returns or raises _backtrack_mask if
@@ -3037,7 +3399,8 @@ class depgraph(object):
 							if not check_required_use(
 								pkg.metadata["REQUIRED_USE"],
 								self._pkg_use_enabled(pkg),
-								pkg.iuse.is_valid_flag):
+								pkg.iuse.is_valid_flag,
+								eapi=pkg.metadata["EAPI"]):
 								required_use_unsatisfied.append(pkg)
 								continue
 						root_slot = (pkg.root, pkg.slot_atom)
@@ -3082,7 +3445,7 @@ class depgraph(object):
 
 				untouchable_flags = \
 					frozenset(chain(pkg.use.mask, pkg.use.force))
-				if untouchable_flags.intersection(
+				if any(x in untouchable_flags for x in
 					chain(need_enable, need_disable)):
 					continue
 
@@ -3096,8 +3459,10 @@ class depgraph(object):
 						new_use.add(flag)
 					for flag in need_disable:
 						new_use.discard(flag)
-					if check_required_use(required_use, old_use, pkg.iuse.is_valid_flag) and \
-						not check_required_use(required_use, new_use, pkg.iuse.is_valid_flag):
+					if check_required_use(required_use, old_use,
+						pkg.iuse.is_valid_flag, eapi=pkg.metadata["EAPI"]) \
+						and not check_required_use(required_use, new_use,
+						pkg.iuse.is_valid_flag, eapi=pkg.metadata["EAPI"]):
 							required_use_warning = ", this change violates use flag constraints " + \
 								"defined by %s: '%s'" % (pkg.cpv, human_readable_required_use(required_use))
 
@@ -3132,7 +3497,7 @@ class depgraph(object):
 
 					untouchable_flags = \
 						frozenset(chain(myparent.use.mask, myparent.use.force))
-					if untouchable_flags.intersection(involved_flags):
+					if any(x in untouchable_flags for x in involved_flags):
 						continue
 
 					required_use = myparent.metadata.get("REQUIRED_USE")
@@ -3145,8 +3510,12 @@ class depgraph(object):
 								new_use.discard(flag)
 							else:
 								new_use.add(flag)
-						if check_required_use(required_use, old_use, myparent.iuse.is_valid_flag) and \
-							not check_required_use(required_use, new_use, myparent.iuse.is_valid_flag):
+						if check_required_use(required_use, old_use,
+							myparent.iuse.is_valid_flag,
+							eapi=myparent.metadata["EAPI"]) and \
+							not check_required_use(required_use, new_use,
+							myparent.iuse.is_valid_flag,
+							eapi=myparent.metadata["EAPI"]):
 								required_use_warning = ", this change violates use flag constraints " + \
 									"defined by %s: '%s'" % (myparent.cpv, \
 									human_readable_required_use(required_use))
@@ -3211,62 +3580,72 @@ class depgraph(object):
 
 		mask_docs = False
 
-		if required_use_unsatisfied:
+		if show_req_use is None and required_use_unsatisfied:
 			# We have an unmasked package that only requires USE adjustment
 			# in order to satisfy REQUIRED_USE, and nothing more. We assume
 			# that the user wants the latest version, so only the first
 			# instance is displayed.
-			pkg = required_use_unsatisfied[0]
+			show_req_use = required_use_unsatisfied[0]
+			self._dynamic_config._needed_required_use_config_changesuse_config_changes[pkg] = (new_use, new_changes)
+			backtrack_infos = self._dynamic_config._backtrack_infos
+			backtrack_infos.setdefault("config", {})
+			backtrack_infos["config"].setdefault("needed_required_use_config_changes", [])
+			backtrack_infos["config"]["needed_required_use_config_changes"].append((pkg, (new_use, new_changes)))
+
+		if show_req_use is not None:
+
+			pkg = show_req_use
 			output_cpv = pkg.cpv + _repo_separator + pkg.repo
-			writemsg_stdout("\n!!! " + \
+			writemsg("\n!!! " + \
 				colorize("BAD", "The ebuild selected to satisfy ") + \
 				colorize("INFORM", xinfo) + \
 				colorize("BAD", " has unmet requirements.") + "\n",
 				noiselevel=-1)
 			use_display = pkg_use_display(pkg, self._frozen_config.myopts)
-			writemsg_stdout("- %s %s\n" % (output_cpv, use_display),
+			writemsg("- %s %s\n" % (output_cpv, use_display),
 				noiselevel=-1)
-			writemsg_stdout("\n  The following REQUIRED_USE flag constraints " + \
+			writemsg("\n  The following REQUIRED_USE flag constraints " + \
 				"are unsatisfied:\n", noiselevel=-1)
 			reduced_noise = check_required_use(
 				pkg.metadata["REQUIRED_USE"],
 				self._pkg_use_enabled(pkg),
-				pkg.iuse.is_valid_flag).tounicode()
-			writemsg_stdout("    %s\n" % \
+				pkg.iuse.is_valid_flag,
+				eapi=pkg.metadata["EAPI"]).tounicode()
+			writemsg("    %s\n" % \
 				human_readable_required_use(reduced_noise),
 				noiselevel=-1)
 			normalized_required_use = \
 				" ".join(pkg.metadata["REQUIRED_USE"].split())
 			if reduced_noise != normalized_required_use:
-				writemsg_stdout("\n  The above constraints " + \
+				writemsg("\n  The above constraints " + \
 					"are a subset of the following complete expression:\n",
 					noiselevel=-1)
-				writemsg_stdout("    %s\n" % \
+				writemsg("    %s\n" % \
 					human_readable_required_use(normalized_required_use),
 					noiselevel=-1)
-			writemsg_stdout("\n", noiselevel=-1)
+			writemsg("\n", noiselevel=-1)
 
 		elif show_missing_use:
-			writemsg_stdout("\nemerge: there are no ebuilds built with USE flags to satisfy "+green(xinfo)+".\n", noiselevel=-1)
-			writemsg_stdout("!!! One of the following packages is required to complete your request:\n", noiselevel=-1)
+			writemsg("\nemerge: there are no ebuilds built with USE flags to satisfy "+green(xinfo)+".\n", noiselevel=-1)
+			writemsg("!!! One of the following packages is required to complete your request:\n", noiselevel=-1)
 			for pkg, mreasons in show_missing_use:
-				writemsg_stdout("- "+pkg.cpv+_repo_separator+pkg.repo+" ("+", ".join(mreasons)+")\n", noiselevel=-1)
+				writemsg("- "+pkg.cpv+_repo_separator+pkg.repo+" ("+", ".join(mreasons)+")\n", noiselevel=-1)
 
 		elif masked_packages:
-			writemsg_stdout("\n!!! " + \
+			writemsg("\n!!! " + \
 				colorize("BAD", "All ebuilds that could satisfy ") + \
 				colorize("INFORM", xinfo) + \
 				colorize("BAD", " have been masked.") + "\n", noiselevel=-1)
-			writemsg_stdout("!!! One of the following masked packages is required to complete your request:\n", noiselevel=-1)
+			writemsg("!!! One of the following masked packages is required to complete your request:\n", noiselevel=-1)
 			have_eapi_mask = show_masked_packages(masked_packages)
 			if have_eapi_mask:
-				writemsg_stdout("\n", noiselevel=-1)
+				writemsg("\n", noiselevel=-1)
 				msg = ("The current version of portage supports " + \
 					"EAPI '%s'. You must upgrade to a newer version" + \
 					" of portage before EAPI masked packages can" + \
 					" be installed.") % portage.const.EAPI
-				writemsg_stdout("\n".join(textwrap.wrap(msg, 75)), noiselevel=-1)
-			writemsg_stdout("\n", noiselevel=-1)
+				writemsg("\n".join(textwrap.wrap(msg, 75)), noiselevel=-1)
+			writemsg("\n", noiselevel=-1)
 			mask_docs = True
 		else:
 			cp_exists = False
@@ -3276,7 +3655,7 @@ class depgraph(object):
 					cp_exists = True
 					break
 
-			writemsg_stdout("\nemerge: there are no ebuilds to satisfy "+green(xinfo)+".\n", noiselevel=-1)
+			writemsg("\nemerge: there are no ebuilds to satisfy "+green(xinfo)+".\n", noiselevel=-1)
 			if isinstance(myparent, AtomArg) and \
 				not cp_exists and \
 				self._frozen_config.myopts.get(
@@ -3286,7 +3665,7 @@ class depgraph(object):
 				if cat == "null":
 					cat = None
 
-				writemsg_stdout("\nemerge: searching for similar names..."
+				writemsg("\nemerge: searching for similar names..."
 					, noiselevel=-1)
 
 				all_cp = set()
@@ -3334,16 +3713,16 @@ class depgraph(object):
 				matches = matches_orig_case
 
 				if len(matches) == 1:
-					writemsg_stdout("\nemerge: Maybe you meant " + matches[0] + "?\n"
+					writemsg("\nemerge: Maybe you meant " + matches[0] + "?\n"
 						, noiselevel=-1)
 				elif len(matches) > 1:
-					writemsg_stdout(
+					writemsg(
 						"\nemerge: Maybe you meant any of these: %s?\n" % \
 						(", ".join(matches),), noiselevel=-1)
 				else:
 					# Generally, this would only happen if
 					# all dbapis are empty.
-					writemsg_stdout(" nothing similar found.\n"
+					writemsg(" nothing similar found.\n"
 						, noiselevel=-1)
 		msg = []
 		if not isinstance(myparent, AtomArg):
@@ -3356,12 +3735,12 @@ class depgraph(object):
 						(node)), node_type))
 
 		if msg:
-			writemsg_stdout("\n".join(msg), noiselevel=-1)
-			writemsg_stdout("\n", noiselevel=-1)
+			writemsg("\n".join(msg), noiselevel=-1)
+			writemsg("\n", noiselevel=-1)
 
 		if mask_docs:
 			show_mask_docs()
-			writemsg_stdout("\n", noiselevel=-1)
+			writemsg("\n", noiselevel=-1)
 
 	def _iter_match_pkgs_any(self, root_config, atom, onlydeps=False):
 		for db, pkg_type, built, installed, db_keys in \
@@ -3379,60 +3758,12 @@ class depgraph(object):
 		"""
 
 		db = root_config.trees[self.pkg_tree_map[pkg_type]].dbapi
-
-		if hasattr(db, "xmatch"):
-			# For portdbapi we match only against the cpv, in order
-			# to bypass unnecessary cache access for things like IUSE
-			# and SLOT. Later, we cache the metadata in a Package
-			# instance, and use that for further matching. This
-			# optimization is especially relevant since
-			# pordbapi.aux_get() does not cache calls that have
-			# myrepo or mytree arguments.
-			cpv_list = db.xmatch("match-all-cpv-only", atom)
-		else:
-			cpv_list = db.match(atom)
-
-		# USE=multislot can make an installed package appear as if
-		# it doesn't satisfy a slot dependency. Rebuilding the ebuild
-		# won't do any good as long as USE=multislot is enabled since
-		# the newly built package still won't have the expected slot.
-		# Therefore, assume that such SLOT dependencies are already
-		# satisfied rather than forcing a rebuild.
+		atom_exp = dep_expand(atom, mydb=db, settings=root_config.settings)
+		cp_list = db.cp_list(atom_exp.cp)
+		matched_something = False
 		installed = pkg_type == 'installed'
-		if installed and not cpv_list and atom.slot:
-
-			if "remove" in self._dynamic_config.myparams:
-				# We need to search the portdbapi, which is not in our
-				# normal dbs list, in order to find the real SLOT.
-				portdb = self._frozen_config.trees[root_config.root]["porttree"].dbapi
-				db_keys = list(portdb._aux_cache_keys)
-				dbs = [(portdb, "ebuild", False, False, db_keys)]
-			else:
-				dbs = self._dynamic_config._filtered_trees[root_config.root]["dbs"]
 
-			for cpv in db.match(atom.cp):
-				slot_available = False
-				for other_db, other_type, other_built, \
-					other_installed, other_keys in dbs:
-					try:
-						if atom.slot == \
-							other_db.aux_get(cpv, ["SLOT"])[0]:
-							slot_available = True
-							break
-					except KeyError:
-						pass
-				if not slot_available:
-					continue
-				inst_pkg = self._pkg(cpv, "installed",
-					root_config, installed=installed, myrepo = atom.repo)
-				# Remove the slot from the atom and verify that
-				# the package matches the resulting atom.
-				if portage.match_from_list(
-					atom.without_slot, [inst_pkg]):
-					yield inst_pkg
-					return
-
-		if cpv_list:
+		if cp_list:
 			atom_set = InternalPackageSet(initial_atoms=(atom,),
 				allow_repo=True)
 			if atom.repo is None and hasattr(db, "getRepositories"):
@@ -3441,8 +3772,13 @@ class depgraph(object):
 				repo_list = [atom.repo]
 
 			# descending order
-			cpv_list.reverse()
-			for cpv in cpv_list:
+			cp_list.reverse()
+			for cpv in cp_list:
+				# Call match_from_list on one cpv at a time, in order
+				# to avoid unnecessary match_from_list comparisons on
+				# versions that are never yielded from this method.
+				if not match_from_list(atom_exp, [cpv]):
+					continue
 				for repo in repo_list:
 
 					try:
@@ -3459,26 +3795,65 @@ class depgraph(object):
 						# Make sure that cpv from the current repo satisfies the atom.
 						# This might not be the case if there are several repos with
 						# the same cpv, but different metadata keys, like SLOT.
-						# Also, for portdbapi, parts of the match that require
-						# metadata access are deferred until we have cached the
-						# metadata in a Package instance.
+						# Also, parts of the match that require metadata access
+						# are deferred until we have cached the metadata in a
+						# Package instance.
 						if not atom_set.findAtomForPackage(pkg,
 							modified_use=self._pkg_use_enabled(pkg)):
 							continue
+						matched_something = True
 						yield pkg
 
+		# USE=multislot can make an installed package appear as if
+		# it doesn't satisfy a slot dependency. Rebuilding the ebuild
+		# won't do any good as long as USE=multislot is enabled since
+		# the newly built package still won't have the expected slot.
+		# Therefore, assume that such SLOT dependencies are already
+		# satisfied rather than forcing a rebuild.
+		if not matched_something and installed and atom.slot is not None:
+
+			if "remove" in self._dynamic_config.myparams:
+				# We need to search the portdbapi, which is not in our
+				# normal dbs list, in order to find the real SLOT.
+				portdb = self._frozen_config.trees[root_config.root]["porttree"].dbapi
+				db_keys = list(portdb._aux_cache_keys)
+				dbs = [(portdb, "ebuild", False, False, db_keys)]
+			else:
+				dbs = self._dynamic_config._filtered_trees[root_config.root]["dbs"]
+
+			cp_list = db.cp_list(atom_exp.cp)
+			if cp_list:
+				atom_set = InternalPackageSet(
+					initial_atoms=(atom.without_slot,), allow_repo=True)
+				atom_exp_without_slot = atom_exp.without_slot
+				cp_list.reverse()
+				for cpv in cp_list:
+					if not match_from_list(atom_exp_without_slot, [cpv]):
+						continue
+					slot_available = False
+					for other_db, other_type, other_built, \
+						other_installed, other_keys in dbs:
+						try:
+							if atom.slot == \
+								other_db._pkg_str(_unicode(cpv), None).slot:
+								slot_available = True
+								break
+						except (KeyError, InvalidData):
+							pass
+					if not slot_available:
+						continue
+					inst_pkg = self._pkg(cpv, "installed",
+						root_config, installed=installed, myrepo=atom.repo)
+					# Remove the slot from the atom and verify that
+					# the package matches the resulting atom.
+					if atom_set.findAtomForPackage(inst_pkg):
+						yield inst_pkg
+						return
+
 	def _select_pkg_highest_available(self, root, atom, onlydeps=False):
-		cache_key = (root, atom, atom.unevaluated_atom, onlydeps)
+		cache_key = (root, atom, atom.unevaluated_atom, onlydeps, self._dynamic_config._autounmask)
 		ret = self._dynamic_config._highest_pkg_cache.get(cache_key)
 		if ret is not None:
-			pkg, existing = ret
-			if pkg and not existing:
-				existing = self._dynamic_config._slot_pkg_map[root].get(pkg.slot_atom)
-				if existing and existing == pkg:
-					# Update the cache to reflect that the
-					# package has been added to the graph.
-					ret = pkg, pkg
-					self._dynamic_config._highest_pkg_cache[cache_key] = ret
 			return ret
 		ret = self._select_pkg_highest_available_imp(root, atom, onlydeps=onlydeps)
 		self._dynamic_config._highest_pkg_cache[cache_key] = ret
@@ -3495,21 +3870,55 @@ class depgraph(object):
 		True if the user has not explicitly requested for this package
 		to be replaced (typically via an atom on the command line).
 		"""
-		if "selective" not in self._dynamic_config.myparams and \
-			pkg.root == self._frozen_config.target_root:
-			if self._frozen_config.excluded_pkgs.findAtomForPackage(pkg,
-				modified_use=self._pkg_use_enabled(pkg)):
-				return True
-			try:
-				next(self._iter_atoms_for_pkg(pkg))
-			except StopIteration:
-				pass
-			except portage.exception.InvalidDependString:
-				pass
-			else:
+		if self._frozen_config.excluded_pkgs.findAtomForPackage(pkg,
+			modified_use=self._pkg_use_enabled(pkg)):
+			return True
+
+		arg = False
+		try:
+			for arg, atom in self._iter_atoms_for_pkg(pkg):
+				if arg.force_reinstall:
+					return False
+		except InvalidDependString:
+			pass
+
+		if "selective" in self._dynamic_config.myparams:
+			return True
+
+		return not arg
+
+	def _equiv_ebuild_visible(self, pkg, autounmask_level=None):
+		try:
+			pkg_eb = self._pkg(
+				pkg.cpv, "ebuild", pkg.root_config, myrepo=pkg.repo)
+		except portage.exception.PackageNotFound:
+			pkg_eb_visible = False
+			for pkg_eb in self._iter_match_pkgs(pkg.root_config,
+				"ebuild", Atom("=%s" % (pkg.cpv,))):
+				if self._pkg_visibility_check(pkg_eb, autounmask_level):
+					pkg_eb_visible = True
+					break
+			if not pkg_eb_visible:
 				return False
+		else:
+			if not self._pkg_visibility_check(pkg_eb, autounmask_level):
+				return False
+
 		return True
 
+	def _equiv_binary_installed(self, pkg):
+		build_time = pkg.metadata.get('BUILD_TIME')
+		if not build_time:
+			return False
+
+		try:
+			inst_pkg = self._pkg(pkg.cpv, "installed",
+				pkg.root_config, installed=True)
+		except PackageNotFound:
+			return False
+
+		return build_time == inst_pkg.metadata.get('BUILD_TIME')
+
 	class _AutounmaskLevel(object):
 		__slots__ = ("allow_use_changes", "allow_unstable_keywords", "allow_license_changes", \
 			"allow_missing_keywords", "allow_unmasks")
@@ -3525,7 +3934,8 @@ class depgraph(object):
 		"""
 		Iterate over the different allowed things to unmask.
 
-		1. USE
+		0. USE
+		1. USE + license
 		2. USE + ~arch + license
 		3. USE + ~arch + license + missing keywords
 		4. USE + ~arch + license + masks
@@ -3544,8 +3954,12 @@ class depgraph(object):
 		autounmask_level = self._AutounmaskLevel()
 
 		autounmask_level.allow_use_changes = True
+		yield autounmask_level
 
-		for only_use_changes in (True, False):
+		autounmask_level.allow_license_changes = True
+		yield autounmask_level
+
+		for only_use_changes in (False,):
 
 			autounmask_level.allow_unstable_keywords = (not only_use_changes)
 			autounmask_level.allow_license_changes = (not only_use_changes)
@@ -3573,7 +3987,7 @@ class depgraph(object):
 				pkg = None
 
 		if self._dynamic_config._autounmask is True:
-			pkg = None
+			reset_pkg(pkg)
 
 			for autounmask_level in self._autounmask_levels():
 				if pkg is not None:
@@ -3734,7 +4148,7 @@ class depgraph(object):
 			if pkg not in self._dynamic_config.digraph.nodes:
 				return False
 
-			for key in "DEPEND", "RDEPEND", "PDEPEND", "LICENSE":
+			for key in Package._dep_keys + ("LICENSE",):
 				dep = pkg.metadata[key]
 				old_val = set(portage.dep.use_reduce(dep, pkg.use.enabled, is_valid_flag=pkg.iuse.is_valid_flag, flat=True))
 				new_val = set(portage.dep.use_reduce(dep, new_use, is_valid_flag=pkg.iuse.is_valid_flag, flat=True))
@@ -3749,7 +4163,7 @@ class depgraph(object):
 			new_use, changes = self._dynamic_config._needed_use_config_changes.get(pkg)
 			for ppkg, atom in parent_atoms:
 				if not atom.use or \
-					not atom.use.required.intersection(changes):
+					not any(x in atom.use.required for x in changes):
 					continue
 				else:
 					return True
@@ -3759,12 +4173,14 @@ class depgraph(object):
 		if new_changes != old_changes:
 			#Don't do the change if it violates REQUIRED_USE.
 			required_use = pkg.metadata.get("REQUIRED_USE")
-			if required_use and check_required_use(required_use, old_use, pkg.iuse.is_valid_flag) and \
-				not check_required_use(required_use, new_use, pkg.iuse.is_valid_flag):
+			if required_use and check_required_use(required_use, old_use,
+				pkg.iuse.is_valid_flag, eapi=pkg.metadata["EAPI"]) and \
+				not check_required_use(required_use, new_use,
+				pkg.iuse.is_valid_flag, eapi=pkg.metadata["EAPI"]):
 				return old_use
 
-			if pkg.use.mask.intersection(new_changes) or \
-				pkg.use.force.intersection(new_changes):
+			if any(x in pkg.use.mask for x in new_changes) or \
+				any(x in pkg.use.force for x in new_changes):
 				return old_use
 
 			self._dynamic_config._needed_use_config_changes[pkg] = (new_use, new_changes)
@@ -3776,199 +4192,6 @@ class depgraph(object):
 				self._dynamic_config._need_restart = True
 		return new_use
 
-	def change_required_use(self, pkg):
-		"""
-		Checks if the use flags listed in 'use' satisfy all
-		constraints specified in 'constraints'.
-
-		@param required_use: REQUIRED_USE string
-		@type required_use: String
-		@param use: Enabled use flags
-		@param use: List
-		@param iuse_match: Callable that takes a single flag argument and returns
-			True if the flag is matched, false otherwise,
-		@param iuse_match: Callable
-		@rtype: Bool
-		@return: Indicates if REQUIRED_USE constraints are satisfied
-		"""
-
-		required_use = pkg.metadata["REQUIRED_USE"]
-		use =self._pkg_use_enabled(pkg)
-		iuse_match = pkg.iuse.is_valid_flag
-
-		def is_active(token):
-			if token.startswith("!"):
-				flag = token[1:]
-				is_negated = True
-			else:
-				flag = token
-				is_negated = False
-
-			if not flag or not iuse_match(flag):
-				msg = _("USE flag '%s' is not in IUSE") \
-					% (flag,)
-				e = InvalidData(msg, category='IUSE.missing')
-				raise InvalidDependString(msg, errors=(e,))
-
-			return (flag in use and not is_negated) or \
-				(flag not in use and is_negated)
-	
-		def is_satisfied(operator, argument):
-			if not argument:
-				#|| ( ) -> True
-				return True
-
-			if operator == "||":
-				return (True in argument)
-			elif operator == "^^":
-				return (argument.count(True) == 1)
-			elif operator[-1] == "?":
-				return (False not in argument)
-
-		mysplit = required_use.split()
-		level = 0
-		stack = [[]]
-		tree = portage.dep._RequiredUseBranch()
-		node = tree
-		need_bracket = False
-		target_use = {}
-
-		for token in mysplit:
-			if token == "(":
-				if not need_bracket:
-					child = portage.dep._RequiredUseBranch(parent=node)
-					node._children.append(child)
-					node = child
-
-				need_bracket = False
-				stack.append([])
-				level += 1
-			elif token == ")":
-				if need_bracket:
-					raise InvalidDependString(
-						_("malformed syntax: '%s'") % required_use)
-				if level > 0:
-					level -= 1
-					l = stack.pop()
-					op = None
-					if stack[level]:
-						if stack[level][-1] in ("||", "^^"):
-							op = stack[level].pop()
-							satisfied = is_satisfied(op, l)
-							stack[level].append(satisfied)
-							node._satisfied = satisfied
-
-						elif not isinstance(stack[level][-1], bool) and \
-							stack[level][-1][-1] == "?":
-							op = stack[level].pop()
-							if is_active(op[:-1]):
-								satisfied = is_satisfied(op, l)
-								stack[level].append(satisfied)
-								node._satisfied = satisfied
-							else:
-								node._satisfied = True
-								last_node = node._parent._children.pop()
-								if last_node is not node:
-									raise AssertionError(
-										"node is not last child of parent")
-								node = node._parent
-								continue
-
-					if op is None:
-						satisfied = False not in l
-						node._satisfied = satisfied
-						if l:
-							stack[level].append(satisfied)
-
-						if len(node._children) <= 1 or \
-							node._parent._operator not in ("||", "^^"):
-							last_node = node._parent._children.pop()
-							if last_node is not node:
-								raise AssertionError(
-									"node is not last child of parent")
-							for child in node._children:
-								node._parent._children.append(child)
-								if isinstance(child, portage.dep._RequiredUseBranch):
-									child._parent = node._parent
-
-					elif not node._children:
-						last_node = node._parent._children.pop()
-						if last_node is not node:
-							raise AssertionError(
-								"node is not last child of parent")
-
-					elif len(node._children) == 1 and op in ("||", "^^"):
-						last_node = node._parent._children.pop()
-						if last_node is not node:
-							raise AssertionError(
-								"node is not last child of parent")
-						node._parent._children.append(node._children[0])
-						if isinstance(node._children[0], portage.dep._RequiredUseBranch):
-							node._children[0]._parent = node._parent
-							node = node._children[0]
-							if node._operator is None and \
-								node._parent._operator not in ("||", "^^"):
-								last_node = node._parent._children.pop()
-								if last_node is not node:
-									raise AssertionError(
-										"node is not last child of parent")
-								for child in node._children:
-									node._parent._children.append(child)
-									if isinstance(child, portage.dep._RequiredUseBranch):
-										child._parent = node._parent
-
-					node = node._parent
-				else:
-					raise InvalidDependString(
-						_("malformed syntax: '%s'") % required_use)
-			elif token in ("||", "^^"):
-				if need_bracket:
-					raise InvalidDependString(
-						_("malformed syntax: '%s'") % required_use)
-				need_bracket = True
-				stack[level].append(token)
-				child = portage.dep._RequiredUseBranch(operator=token, parent=node)
-				node._children.append(child)
-				node = child
-			else:
-				if need_bracket or "(" in token or ")" in token or \
-					"|" in token or "^" in token:
-					raise InvalidDependString(
-						_("malformed syntax: '%s'") % required_use)
-
-				if token[-1] == "?":
-					need_bracket = True
-					stack[level].append(token)
-					child = portage.dep._RequiredUseBranch(operator=token, parent=node)
-					node._children.append(child)
-					node = child
-				else:
-					satisfied = is_active(token)
-					stack[level].append(satisfied)
-					node._children.append(portage.dep._RequiredUseLeaf(token, satisfied))
-					print("satisfied:", satisfied)
-					if satisfied is False:
-						new_changes = {}
-						new_changes[token] = True
-						print("new_changes:", new_changes)
-						if pkg.use.mask.intersection(new_changes) or \
-						pkg.use.force.intersection(new_changes):
-							print("mask or force")
-						else:
-							print("new_changes2:", new_changes)
-							if token in pkg.use.enabled:
-								target_use[token] = False
-							elif not token in pkg.use.enabled:
-									target_use[token] = True
-							return target_use
-
-		if level != 0 or need_bracket:
-			raise InvalidDependString(
-				_("malformed syntax: '%s'") % required_use)
-
-		tree._satisfied = False not in stack[0]
-		return target_use
-
 	def _wrapped_select_pkg_highest_available_imp(self, root, atom, onlydeps=False, autounmask_level=None):
 		root_config = self._frozen_config.roots[root]
 		pkgsettings = self._frozen_config.pkgsettings[root]
@@ -4128,37 +4351,24 @@ class depgraph(object):
 								if not use_ebuild_visibility and (usepkgonly or useoldpkg):
 									if pkg.installed and pkg.masks:
 										continue
-								else:
-									try:
-										pkg_eb = self._pkg(
-											pkg.cpv, "ebuild", root_config, myrepo=pkg.repo)
-									except portage.exception.PackageNotFound:
-										pkg_eb_visible = False
-										for pkg_eb in self._iter_match_pkgs(pkg.root_config,
-											"ebuild", Atom("=%s" % (pkg.cpv,))):
-											if self._pkg_visibility_check(pkg_eb, autounmask_level):
-												pkg_eb_visible = True
-												break
-										if not pkg_eb_visible:
-											continue
-									else:
-										if not self._pkg_visibility_check(pkg_eb, autounmask_level):
-											continue
+								elif not self._equiv_ebuild_visible(pkg,
+									autounmask_level=autounmask_level):
+									continue
 
 					# Calculation of USE for unbuilt ebuilds is relatively
 					# expensive, so it is only performed lazily, after the
 					# above visibility checks are complete.
 
 					myarg = None
-					if root == self._frozen_config.target_root:
-						try:
-							myarg = next(self._iter_atoms_for_pkg(pkg))
-						except StopIteration:
-							pass
-						except portage.exception.InvalidDependString:
-							if not installed:
-								# masked by corruption
-								continue
+					try:
+						for myarg, myarg_atom in self._iter_atoms_for_pkg(pkg):
+							if myarg.force_reinstall:
+								reinstall = True
+								break
+					except InvalidDependString:
+						if not installed:
+							# masked by corruption
+							continue
 					if not installed and myarg:
 						found_available_arg = True
 
@@ -4169,17 +4379,8 @@ class depgraph(object):
 							# since IUSE cannot be adjusted by the user.
 							continue
 
-					if pkg.metadata.get("REQUIRED_USE") and eapi_has_required_use(pkg.metadata["EAPI"]):
-						required_use_is_sat = check_required_use(pkg.metadata["REQUIRED_USE"],
-							self._pkg_use_enabled(pkg), pkg.iuse.is_valid_flag)
-						if not required_use_is_sat:
-							if autounmask_level and autounmask_level.allow_use_changes \
-								and not pkg.built:
-								target_use = self.change_required_use(pkg)
-								if not target_use is None:
-									use = self._pkg_use_enabled(pkg, target_use)					
-
 					if atom.use:
+
 						matched_pkgs_ignore_use.append(pkg)
 						if autounmask_level and autounmask_level.allow_use_changes and not pkg.built:
 							target_use = {}
@@ -4197,7 +4398,7 @@ class depgraph(object):
 						missing_disabled = atom.use.missing_disabled.difference(pkg.iuse.all)
 
 						if atom.use.enabled:
-							if atom.use.enabled.intersection(missing_disabled):
+							if any(x in atom.use.enabled for x in missing_disabled):
 								use_match = False
 								can_adjust_use = False
 							need_enabled = atom.use.enabled.difference(use)
@@ -4206,11 +4407,11 @@ class depgraph(object):
 								if need_enabled:
 									use_match = False
 									if can_adjust_use:
-										if pkg.use.mask.intersection(need_enabled):
+										if any(x in pkg.use.mask for x in need_enabled):
 											can_adjust_use = False
 
 						if atom.use.disabled:
-							if atom.use.disabled.intersection(missing_enabled):
+							if any(x in atom.use.disabled for x in missing_enabled):
 								use_match = False
 								can_adjust_use = False
 							need_disabled = atom.use.disabled.intersection(use)
@@ -4219,8 +4420,8 @@ class depgraph(object):
 								if need_disabled:
 									use_match = False
 									if can_adjust_use:
-										if pkg.use.force.difference(
-											pkg.use.mask).intersection(need_disabled):
+										if any(x in pkg.use.force and x not in
+											pkg.use.mask for x in need_disabled):
 											can_adjust_use = False
 
 						if not use_match:
@@ -4486,9 +4687,19 @@ class depgraph(object):
 			"recurse" not in self._dynamic_config.myparams:
 			return 1
 
+		complete_if_new_use = self._dynamic_config.myparams.get(
+			"complete_if_new_use", "y") == "y"
+		complete_if_new_ver = self._dynamic_config.myparams.get(
+			"complete_if_new_ver", "y") == "y"
+		rebuild_if_new_slot = self._dynamic_config.myparams.get(
+			"rebuild_if_new_slot", "y") == "y"
+		complete_if_new_slot = rebuild_if_new_slot
+
 		if "complete" not in self._dynamic_config.myparams and \
-			self._dynamic_config.myparams.get("complete_if_new_ver", "y") == "y":
-			# Enable complete mode if an installed package version will change.
+			(complete_if_new_use or
+			complete_if_new_ver or complete_if_new_slot):
+			# Enable complete mode if an installed package will change somehow.
+			use_change = False
 			version_change = False
 			for node in self._dynamic_config.digraph:
 				if not isinstance(node, Package) or \
@@ -4496,12 +4707,35 @@ class depgraph(object):
 					continue
 				vardb = self._frozen_config.roots[
 					node.root].trees["vartree"].dbapi
-				inst_pkg = vardb.match_pkgs(node.slot_atom)
-				if inst_pkg and (inst_pkg[0] > node or inst_pkg[0] < node):
-					version_change = True
-					break
 
-			if version_change:
+				if complete_if_new_use or complete_if_new_ver:
+					inst_pkg = vardb.match_pkgs(node.slot_atom)
+					if inst_pkg and inst_pkg[0].cp == node.cp:
+						inst_pkg = inst_pkg[0]
+						if complete_if_new_ver and \
+							(inst_pkg < node or node < inst_pkg):
+							version_change = True
+							break
+
+						# Intersect enabled USE with IUSE, in order to
+						# ignore forced USE from implicit IUSE flags, since
+						# they're probably irrelevant and they are sensitive
+						# to use.mask/force changes in the profile.
+						if complete_if_new_use and \
+							(node.iuse.all != inst_pkg.iuse.all or
+							self._pkg_use_enabled(node).intersection(node.iuse.all) !=
+							self._pkg_use_enabled(inst_pkg).intersection(inst_pkg.iuse.all)):
+							use_change = True
+							break
+
+				if complete_if_new_slot:
+					cp_list = vardb.match_pkgs(Atom(node.cp))
+					if (cp_list and cp_list[0].cp == node.cp and
+						not any(node.slot == pkg.slot for pkg in cp_list)):
+						version_change = True
+						break
+
+			if use_change or version_change:
 				self._dynamic_config.myparams["complete"] = True
 
 		if "complete" not in self._dynamic_config.myparams:
@@ -4515,6 +4749,7 @@ class depgraph(object):
 		# scheduled for replacement. Also, toggle the "deep"
 		# parameter so that all dependencies are traversed and
 		# accounted for.
+		self._dynamic_config._complete_mode = True
 		self._select_atoms = self._select_atoms_from_graph
 		if "remove" in self._dynamic_config.myparams:
 			self._select_package = self._select_pkg_from_installed
@@ -4673,7 +4908,7 @@ class depgraph(object):
 			# For installed packages, always ignore blockers from DEPEND since
 			# only runtime dependencies should be relevant for packages that
 			# are already built.
-			dep_keys = ["RDEPEND", "PDEPEND"]
+			dep_keys = Package._runtime_keys
 			for myroot in self._frozen_config.trees:
 
 				if self._frozen_config.myopts.get("--root-deps") is not None and \
@@ -5130,16 +5365,24 @@ class depgraph(object):
 				root_config.root]["root_config"] = root_config
 
 	def _resolve_conflicts(self):
+
+		if "complete" not in self._dynamic_config.myparams and \
+			self._dynamic_config._allow_backtracking and \
+			self._dynamic_config._slot_collision_nodes and \
+			not self._accept_blocker_conflicts():
+			self._dynamic_config.myparams["complete"] = True
+
 		if not self._complete_graph():
 			raise self._unknown_internal_error()
 
+		self._process_slot_conflicts()
+
+		self._slot_operator_trigger_reinstalls()
+
 		if not self._validate_blockers():
 			self._dynamic_config._skip_restart = True
 			raise self._unknown_internal_error()
 
-		if self._dynamic_config._slot_collision_info:
-			self._process_slot_conflicts()
-
 	def _serialize_tasks(self):
 
 		debug = "--debug" in self._frozen_config.myopts
@@ -5434,7 +5677,7 @@ class depgraph(object):
 									for node in nodes:
 										parents = mygraph.parent_nodes(node,
 											ignore_priority=DepPrioritySatisfiedRange.ignore_soft)
-										if parents and set(parents).intersection(asap_nodes):
+										if any(x in asap_nodes for x in parents):
 											selected_nodes = [node]
 											break
 								else:
@@ -6119,7 +6362,7 @@ class depgraph(object):
 							if is_latest:
 								unstable_keyword_msg[root].append(">=%s %s\n" % (pkg.cpv, keyword))
 							elif is_latest_in_slot:
-								unstable_keyword_msg[root].append(">=%s:%s %s\n" % (pkg.cpv, pkg.metadata["SLOT"], keyword))
+								unstable_keyword_msg[root].append(">=%s:%s %s\n" % (pkg.cpv, pkg.slot, keyword))
 							else:
 								unstable_keyword_msg[root].append("=%s %s\n" % (pkg.cpv, keyword))
 						else:
@@ -6159,7 +6402,7 @@ class depgraph(object):
 							if is_latest:
 								p_mask_change_msg[root].append(">=%s\n" % pkg.cpv)
 							elif is_latest_in_slot:
-								p_mask_change_msg[root].append(">=%s:%s\n" % (pkg.cpv, pkg.metadata["SLOT"]))
+								p_mask_change_msg[root].append(">=%s:%s\n" % (pkg.cpv, pkg.slot))
 							else:
 								p_mask_change_msg[root].append("=%s\n" % pkg.cpv)
 						else:
@@ -6184,7 +6427,7 @@ class depgraph(object):
 				if is_latest:
 					use_changes_msg[root].append(">=%s %s\n" % (pkg.cpv, " ".join(adjustments)))
 				elif is_latest_in_slot:
-					use_changes_msg[root].append(">=%s:%s %s\n" % (pkg.cpv, pkg.metadata["SLOT"], " ".join(adjustments)))
+					use_changes_msg[root].append(">=%s:%s %s\n" % (pkg.cpv, pkg.slot, " ".join(adjustments)))
 				else:
 					use_changes_msg[root].append("=%s %s\n" % (pkg.cpv, " ".join(adjustments)))
 
@@ -6201,7 +6444,7 @@ class depgraph(object):
 				if is_latest:
 					license_msg[root].append(">=%s %s\n" % (pkg.cpv, " ".join(sorted(missing_licenses))))
 				elif is_latest_in_slot:
-					license_msg[root].append(">=%s:%s %s\n" % (pkg.cpv, pkg.metadata["SLOT"], " ".join(sorted(missing_licenses))))
+					license_msg[root].append(">=%s:%s %s\n" % (pkg.cpv, pkg.slot, " ".join(sorted(missing_licenses))))
 				else:
 					license_msg[root].append("=%s %s\n" % (pkg.cpv, " ".join(sorted(missing_licenses))))
 
@@ -6308,27 +6551,27 @@ class depgraph(object):
 				settings["PORTAGE_CONFIGROOT"], USER_CONFIG_PATH)
 
 			if len(roots) > 1:
-				writemsg_stdout("\nFor %s:\n" % abs_user_config, noiselevel=-1)
+				writemsg("\nFor %s:\n" % abs_user_config, noiselevel=-1)
 
 			if root in unstable_keyword_msg:
-				writemsg_stdout("\nThe following " + colorize("BAD", "keyword changes") + \
+				writemsg("\nThe following " + colorize("BAD", "keyword changes") + \
 					" are necessary to proceed:\n", noiselevel=-1)
-				writemsg_stdout(format_msg(unstable_keyword_msg[root]), noiselevel=-1)
+				writemsg(format_msg(unstable_keyword_msg[root]), noiselevel=-1)
 
 			if root in p_mask_change_msg:
-				writemsg_stdout("\nThe following " + colorize("BAD", "mask changes") + \
+				writemsg("\nThe following " + colorize("BAD", "mask changes") + \
 					" are necessary to proceed:\n", noiselevel=-1)
-				writemsg_stdout(format_msg(p_mask_change_msg[root]), noiselevel=-1)
+				writemsg(format_msg(p_mask_change_msg[root]), noiselevel=-1)
 
 			if root in use_changes_msg:
-				writemsg_stdout("\nThe following " + colorize("BAD", "USE changes") + \
+				writemsg("\nThe following " + colorize("BAD", "USE changes") + \
 					" are necessary to proceed:\n", noiselevel=-1)
-				writemsg_stdout(format_msg(use_changes_msg[root]), noiselevel=-1)
+				writemsg(format_msg(use_changes_msg[root]), noiselevel=-1)
 
 			if root in license_msg:
-				writemsg_stdout("\nThe following " + colorize("BAD", "license changes") + \
+				writemsg("\nThe following " + colorize("BAD", "license changes") + \
 					" are necessary to proceed:\n", noiselevel=-1)
-				writemsg_stdout(format_msg(license_msg[root]), noiselevel=-1)
+				writemsg(format_msg(license_msg[root]), noiselevel=-1)
 
 		protect_obj = {}
 		if write_to_file:
@@ -6375,7 +6618,7 @@ class depgraph(object):
 			for line in msg:
 				if line:
 					line = colorize("INFORM", line)
-				writemsg_stdout(line + "\n", noiselevel=-1)
+				writemsg(line + "\n", noiselevel=-1)
 
 		if ask and write_to_file and file_to_write_to:
 			prompt = "\nWould you like to add these " + \
@@ -6407,14 +6650,14 @@ class depgraph(object):
 						file_to_write_to.get((abs_user_config, "package.license")))
 
 		if problems:
-			writemsg_stdout("\nThe following problems occurred while writing autounmask changes:\n", \
+			writemsg("\nThe following problems occurred while writing autounmask changes:\n", \
 				noiselevel=-1)
-			writemsg_stdout("".join(problems), noiselevel=-1)
+			writemsg("".join(problems), noiselevel=-1)
 		elif write_to_file and roots:
-			writemsg_stdout("\nAutounmask changes successfully written. Remember to run dispatch-conf.\n", \
+			writemsg("\nAutounmask changes successfully written. Remember to run dispatch-conf.\n", \
 				noiselevel=-1)
 		elif not pretend and not autounmask_write and roots:
-			writemsg_stdout("\nUse --autounmask-write to write changes to config files (honoring CONFIG_PROTECT).\n", \
+			writemsg("\nUse --autounmask-write to write changes to config files (honoring CONFIG_PROTECT).\n", \
 				noiselevel=-1)
 
 
@@ -6425,35 +6668,8 @@ class depgraph(object):
 		the merge list where it is most likely to be seen, but if display()
 		is not going to be called then this method should be called explicitly
 		to ensure that the user is notified of problems with the graph.
-
-		All output goes to stderr, except for unsatisfied dependencies which
-		go to stdout for parsing by programs such as autounmask.
 		"""
 
-		# Note that show_masked_packages() sends its output to
-		# stdout, and some programs such as autounmask parse the
-		# output in cases when emerge bails out. However, when
-		# show_masked_packages() is called for installed packages
-		# here, the message is a warning that is more appropriate
-		# to send to stderr, so temporarily redirect stdout to
-		# stderr. TODO: Fix output code so there's a cleaner way
-		# to redirect everything to stderr.
-		sys.stdout.flush()
-		sys.stderr.flush()
-		stdout = sys.stdout
-		try:
-			sys.stdout = sys.stderr
-			self._display_problems()
-		finally:
-			sys.stdout = stdout
-			sys.stdout.flush()
-			sys.stderr.flush()
-
-		# This goes to stdout for parsing by programs like autounmask.
-		for pargs, kwargs in self._dynamic_config._unsatisfied_deps_for_display:
-			self._show_unsatisfied_dep(*pargs, **kwargs)
-
-	def _display_problems(self):
 		if self._dynamic_config._circular_deps_for_display is not None:
 			self._show_circular_deps(
 				self._dynamic_config._circular_deps_for_display)
@@ -6572,6 +6788,9 @@ class depgraph(object):
 			show_mask_docs()
 			writemsg("\n", noiselevel=-1)
 
+		for pargs, kwargs in self._dynamic_config._unsatisfied_deps_for_display:
+			self._show_unsatisfied_dep(*pargs, **kwargs)
+
 	def saveNomergeFavorites(self):
 		"""Find atoms in favorites that are not in the mergelist and add them
 		to the world file if necessary."""
@@ -6618,6 +6837,9 @@ class depgraph(object):
 				continue
 			if arg.root_config.root != root_config.root:
 				continue
+			if arg.internal:
+				# __auto_* sets
+				continue
 			k = arg.name
 			if k in ("selected", "world") or \
 				not root_config.sets[k].world_candidate:
@@ -6629,9 +6851,13 @@ class depgraph(object):
 		all_added.extend(added_favorites)
 		all_added.sort()
 		for a in all_added:
+			if a.startswith(SETPREFIX):
+				filename = "world_sets"
+			else:
+				filename = "world"
 			writemsg_stdout(
-				">>> Recording %s in \"world\" favorites file...\n" % \
-				colorize("INFORM", str(a)), noiselevel=-1)
+				">>> Recording %s in \"%s\" favorites file...\n" %
+				(colorize("INFORM", _unicode(a)), filename), noiselevel=-1)
 		if all_added:
 			world_set.update(all_added)
 
@@ -7010,13 +7236,8 @@ class _dep_check_composite_db(dbapi):
 		return ret[:]
 
 	def _visible(self, pkg):
-		if pkg.installed and "selective" not in self._depgraph._dynamic_config.myparams:
-			try:
-				arg = next(self._depgraph._iter_atoms_for_pkg(pkg))
-			except (StopIteration, portage.exception.InvalidDependString):
-				arg = None
-			if arg:
-				return False
+		if pkg.installed and not self._depgraph._want_installed_pkg(pkg):
+			return False
 		if pkg.installed and \
 			(pkg.masks or not self._depgraph._pkg_visibility_check(pkg)):
 			# Account for packages with masks (like KEYWORDS masks)
@@ -7032,24 +7253,8 @@ class _dep_check_composite_db(dbapi):
 			if not avoid_update:
 				if not use_ebuild_visibility and usepkgonly:
 					return False
-				else:
-					try:
-						pkg_eb = self._depgraph._pkg(
-							pkg.cpv, "ebuild", pkg.root_config,
-							myrepo=pkg.repo)
-					except portage.exception.PackageNotFound:
-						pkg_eb_visible = False
-						for pkg_eb in self._depgraph._iter_match_pkgs(
-							pkg.root_config, "ebuild",
-							Atom("=%s" % (pkg.cpv,))):
-							if self._depgraph._pkg_visibility_check(pkg_eb):
-								pkg_eb_visible = True
-								break
-						if not pkg_eb_visible:
-							return False
-					else:
-						if not self._depgraph._pkg_visibility_check(pkg_eb):
-							return False
+				elif not self._depgraph._equiv_ebuild_visible(pkg):
+					return False
 
 		in_graph = self._depgraph._dynamic_config._slot_pkg_map[
 			self._root].get(pkg.slot_atom)
@@ -7329,8 +7534,6 @@ def get_mask_info(root_config, cpv, pkgsettings,
 		mreasons = ["corruption"]
 	else:
 		eapi = metadata['EAPI']
-		if eapi[:1] == '-':
-			eapi = eapi[1:]
 		if not portage.eapi_is_supported(eapi):
 			mreasons = ['EAPI %s' % eapi]
 		else:
@@ -7387,10 +7590,11 @@ def show_masked_packages(masked_packages):
 				# above via mreasons.
 				pass
 
-		writemsg_stdout("- "+output_cpv+" (masked by: "+", ".join(mreasons)+")\n", noiselevel=-1)
+		writemsg("- "+output_cpv+" (masked by: "+", ".join(mreasons)+")\n",
+			noiselevel=-1)
 
 		if comment and comment not in shown_comments:
-			writemsg_stdout(filename + ":\n" + comment + "\n",
+			writemsg(filename + ":\n" + comment + "\n",
 				noiselevel=-1)
 			shown_comments.add(comment)
 		portdb = root_config.trees["porttree"].dbapi
@@ -7400,13 +7604,14 @@ def show_masked_packages(masked_packages):
 				continue
 			msg = ("A copy of the '%s' license" + \
 			" is located at '%s'.\n\n") % (l, l_path)
-			writemsg_stdout(msg, noiselevel=-1)
+			writemsg(msg, noiselevel=-1)
 			shown_licenses.add(l)
 	return have_eapi_mask
 
 def show_mask_docs():
-	writemsg_stdout("For more information, see the MASKED PACKAGES section in the emerge\n", noiselevel=-1)
-	writemsg_stdout("man page or refer to the Gentoo Handbook.\n", noiselevel=-1)
+	writemsg("For more information, see the MASKED PACKAGES "
+		"section in the emerge\n", noiselevel=-1)
+	writemsg("man page or refer to the Gentoo Handbook.\n", noiselevel=-1)
 
 def show_blocker_docs_link():
 	writemsg("\nFor more information about " + bad("Blocked Packages") + ", please refer to the following\n", noiselevel=-1)

diff --git a/gobs/pym/jobs.py b/gobs/pym/jobs.py
index 292d57d..6b5340b 100644
--- a/gobs/pym/jobs.py
+++ b/gobs/pym/jobs.py
@@ -9,7 +9,7 @@ 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.pgsql_querys import *
 
 from gobs.sync import git_pull, sync_tree
 from gobs.buildquerydb import add_buildquery_main, del_buildquery_main
@@ -17,75 +17,77 @@ from gobs.updatedb import update_db_main
 
 def jobs_main(config_profile):
 	conn = CM.getConnection()
-	job = check_job_list(conn, config_profile)
-	if job is None:
+	jobs_id = get_jobs_id(conn, config_profile)
+	if jobs_id is None:
 		CM.putConnection(conn)
-		return
-	log_msg = "Job: %s Type: %s" % (job[1], job[0],)
-	add_gobs_logs(conn, log_msg, "info", config_profile)
-	if job[0] == "addbuildquery":
-		update_job_list(conn, "Runing", job[1])
-		log_msg = "Job %s is runing." % (job[1],)
-		add_gobs_logs(conn, log_msg, "info", config_profile)
-		result =  add_buildquery_main(config_profile)
-		if result is True:
-			update_job_list(conn, "Done", job[1])
-			log_msg = "Job %s is done.." % (job[1],)
+ 		return
+	for job_id in jobs_id:
+		job = get_job(conn, job_id)
+		log_msg = "Job: %s Type: %s" % (job_id, job,)
+                add_gobs_logs(conn, log_msg, "info", config_profile)
+		if job == "addbuildquery":
+			update_job_list(conn, "Runing", job_id)
+			log_msg = "Job %s is runing." % (job_id,)
 			add_gobs_logs(conn, log_msg, "info", config_profile)
-		else:
-			update_job_list(conn, "Fail", job[1])
-			log_msg = "Job %s did fail." % (job[1],)
+			result =  add_buildquery_main(config_profile)
+			if result is True:
+				update_job_list(conn, "Done", job_id)
+				log_msg = "Job %s is done.." % (job_id,)
+				add_gobs_logs(conn, log_msg, "info", config_profile)
+			else:
+				update_job_list(conn, "Fail", job_id)
+				log_msg = "Job %s did fail." % (job_id,)
+				add_gobs_logs(conn, log_msg, "info", config_profile)
+		elif job == "delbuildquery":
+			update_job_list(conn, "Runing", job_id)
+			log_msg = "Job %s is runing." % (job_id,)
 			add_gobs_logs(conn, log_msg, "info", config_profile)
-	elif job[0] == "delbuildquery":
-		update_job_list(conn, "Runing", job[1])
-		log_msg = "Job %s is runing." % (job[1],)
-		add_gobs_logs(conn, log_msg, "info", config_profile)
-		result =  del_buildquery_main(config_profile)
-		if result is True:
-			update_job_list(conn, "Done", job[1])
-			log_msg = "Job %s is done.." % (job[1],)
+			result =  del_buildquery_main(config_profile)
+			if result is True:
+				update_job_list(conn, "Done", job_id)
+				log_msg = "Job %s is done.." % (job_id,)
+				add_gobs_logs(conn, log_msg, "info", config_profile)
+			else:
+				update_job_list(conn, "Fail", job_id)
+				log_msg = "Job %s did fail." % (job_id,)
+				add_gobs_logs(conn, log_msg, "info", config_profile)
+		elif job == "gitsync":
+			update_job_list(conn, "Runing", job_id)
+			log_msg = "Job %s is runing." % (job_id,)
 			add_gobs_logs(conn, log_msg, "info", config_profile)
-		else:
-			update_job_list(conn, "Fail", job[1])
-			log_msg = "Job %s did fail." % (job[1],)
+			result =  git_pull()
+			if result is True:
+				update_job_list(conn, "Done", job_id)
+				log_msg = "Job %s is done.." % (job[1],)
+				add_gobs_logs(conn, log_msg, "info", config_profile)
+			else:
+				update_job_list(conn, "Fail", job_id)
+				log_msg = "Job %s did fail." % (job_id,)
+				add_gobs_logs(conn, log_msg, "info", config_profile)
+		elif job == "emergesync":
+			update_job_list(conn, "Runing", job_id)
+			log_msg = "Job %s is runing." % (job_id,)
 			add_gobs_logs(conn, log_msg, "info", config_profile)
-	elif job[0] == "gitsync":
-		update_job_list(conn, "Runing", job[1])
-		log_msg = "Job %s is runing." % (job[1],)
-		add_gobs_logs(conn, log_msg, "info", config_profile)
-		result =  git_pull()
-		if result is True:
-			update_job_list(conn, "Done", job[1])
-			log_msg = "Job %s is done.." % (job[1],)
+			result =  sync_tree()
+			if result is True:
+				update_job_list(conn, "Done", job_id)
+				log_msg = "Job %s is done.." % (job_id,)
+				add_gobs_logs(conn, log_msg, "info", config_profile)
+			else:
+				update_job_list(conn, "Fail", job_id)
+				log_msg = "Job %s did fail." % (job_id,)
+				add_gobs_logs(conn, log_msg, "info", config_profile)
+		elif job == "updatedb":
+			update_job_list(conn, "Runing", job_id)
+			log_msg = "Job %s is runing." % (job_id,)
 			add_gobs_logs(conn, log_msg, "info", config_profile)
-		else:
-			update_job_list(conn, "Fail", job[1])
-			log_msg = "Job %s did fail." % (job[1],)
-			add_gobs_logs(conn, log_msg, "info", config_profile)
-	elif job[0] == "emergesync":
-		update_job_list(conn, "Runing", job[1])
-		log_msg = "Job %s is runing." % (job[1],)
-		add_gobs_logs(conn, log_msg, "info", config_profile)
-		result =  sync_tree()
-		if result is True:
-			update_job_list(conn, "Done", job[1])
-			log_msg = "Job %s is done.." % (job[1],)
-			add_gobs_logs(conn, log_msg, "info", config_profile)
-		else:
-			update_job_list(conn, "Fail", job[1])
-			log_msg = "Job %s did fail." % (job[1],)
-			add_gobs_logs(conn, log_msg, "info", config_profile)
-	elif job[0] == "updatedb":
-		update_job_list(conn, "Runing", job[1])
-		log_msg = "Job %s is runing." % (job[1],)
-		add_gobs_logs(conn, log_msg, "info", config_profile)
-		result = update_db_main()
-		if result is True:
-			update_job_list(conn, "Done", job[1])
-			log_msg = "Job %s is done.." % (job[1],)
-			add_gobs_logs(conn, log_msg, "info", config_profile)
-		else:
-			update_job_list(conn, "Fail", job[1])
-			log_msg = "Job %s did fail." % (job[1],)
-			add_gobs_logs(conn, log_msg, "info", config_profile)
-	return
\ No newline at end of file
+			result = update_db_main()
+			if result is True:
+				update_job_list(conn, "Done", job_id)
+				log_msg = "Job %s is done.." % (job_id,)
+				add_gobs_logs(conn, log_msg, "info", config_profile)
+			else:
+				update_job_list(conn, "Fail", job_id)
+				log_msg = "Job %s did fail." % (job_id,)
+				add_gobs_logs(conn, log_msg, "info", config_profile)
+		return
\ No newline at end of file

diff --git a/gobs/pym/old_cpv.py b/gobs/pym/old_cpv.py
index 93af29f..3d47c50 100644
--- a/gobs/pym/old_cpv.py
+++ b/gobs/pym/old_cpv.py
@@ -16,17 +16,21 @@ class gobs_old_cpv(object):
 		self._mysettings = mysettings
 		self._myportdb = myportdb
 
-	def mark_old_ebuild_db(self, categories, package, package_id):
+	def mark_old_ebuild_db(self, package_id):
 		conn=CM.getConnection()
-		ebuild_list_tree = sorted(self._myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None))
+		# Get the ebuild list for cp
+		cp, repo = get_cp_repo_from_package_id(conn, package_id)
+		mytree = []
+		mytree.append(self._myportdb.getRepositoryPath(repo))
+		ebuild_list_tree = self._myportdb.cp_list((cp, use_cache=1, mytree=mytree)
 		# Get ebuild list on categories, package in the db
-		ebuild_list_db = cp_list_db(conn,package_id)
+		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:
+			cpv_db = cp + "-" + ebuild_line[0]
+			if not cpv_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 != []:

diff --git a/gobs/pym/package.py b/gobs/pym/package.py
index 771572f..cb6a1f1 100644
--- a/gobs/pym/package.py
+++ b/gobs/pym/package.py
@@ -14,8 +14,10 @@ config_profile = gobs_settings_dict['gobs_config']
 from gobs.ConnectionManager import connectionManager
 CM=connectionManager(gobs_settings_dict)
 #selectively import the pgsql/mysql querys
-if CM.getName()=='pgsql':
-	from gobs.pgsql import *
+iif CM.getName()=='pgsql':
+        from gobs.pgsql_querys import *
+if CM.getName()=='mysql':
+        from gobs.mysql_querys import *
 
 class gobs_package(object):
 
@@ -23,113 +25,123 @@ class gobs_package(object):
 		self._mysettings = mysettings
 		self._myportdb = myportdb
 
-	def change_config(self, config_id):
-		# Change config_root  config_id = table configs.id
-		my_new_setup = "/var/cache/gobs/" + gobs_settings_dict['gobs_gitreponame'] + "/" + config_id + "/"
-		mysettings_setup = portage.config(config_root = my_new_setup)
-		return mysettings_setup
+	def change_config(self, config_setup):
+		# Change config_root  config_setup = table config
+                my_new_setup = "/var/cache/gobs/" + gobs_settings_dict['gobs_gitreponame'] + "/" + config_setup + "/"
+                mysettings_setup = portage.config(config_root = my_new_setup)
+                return mysettings_setup
 
-	def config_match_ebuild(self, categories, package, config_list):
+	def config_match_ebuild(self, cp, config_id_list):
 		config_cpv_listDict ={}
-		if config_list == []:
-			return config_cpv_listDict
-		for config_id in config_list:
+                if config_id_list == []:
+                        return config_cpv_listDict
+                conn=CM.getConnection()
+                for config_id in config_id_list:
 			# Change config/setup
-			mysettings_setup = self.change_config(config_id)
-			myportdb_setup = portage.portdbapi(mysettings=mysettings_setup)
-			# Get latest cpv from portage with the config
-			latest_ebuild = myportdb_setup.xmatch('bestmatch-visible', categories + "/" + package)
-			latest_ebuild_version = unicode("")
-			# Check if could get cpv from portage
-			if latest_ebuild != "":
-				# Get the version of cpv
-				latest_ebuild_version = portage.versions.cpv_getversion(latest_ebuild)
-				# Get the iuse and use flags for that config/setup
-				init_useflags = gobs_use_flags(mysettings_setup, myportdb_setup, latest_ebuild)
-				iuse_flags_list, final_use_list = init_useflags.get_flags()
-				iuse_flags_list2 = []
-				for iuse_line in iuse_flags_list:
-					iuse_flags_list2.append( init_useflags.reduce_flag(iuse_line))
-					# Dic the needed info
-				attDict = {}
-				attDict['ebuild_version'] = latest_ebuild_version
-				attDict['useflags'] = final_use_list
-				attDict['iuse'] = iuse_flags_list2
-				attDict['package'] = package
-				attDict['categories'] = categories
-				config_cpv_listDict[config_id] = attDict
-			# Clean some cache
-			myportdb_setup.close_caches()
-			portage.portdbapi.portdbapi_instances.remove(myportdb_setup)
-		return config_cpv_listDict
-
-	def get_ebuild_metadata(self, ebuild_line):
-		# Get the auxdbkeys infos for the ebuild
-		try:
-			ebuild_auxdb_list = self._myportdb.aux_get(ebuild_line, portage.auxdbkeys)
-		except:
-			ebuild_auxdb_list = []
-		else:
-			for i in range(len(ebuild_auxdb_list)):
-				if ebuild_auxdb_list[i] == '':
-					ebuild_auxdb_list[i] = ''
-		return ebuild_auxdb_list
-
-	def get_packageDict(self, pkgdir, ebuild_line, categories, package, config_id):
-		attDict = {}
-		ebuild_version_tree = portage.versions.cpv_getversion(ebuild_line)
-		ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")[0]
-		ebuild_version_text = get_ebuild_text(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")
-		init_repoman = gobs_repoman(self._mysettings, self._myportdb)
-		repoman_error = init_repoman.check_repoman(categories, package, ebuild_version_tree, config_id)
-		ebuild_version_metadata_tree = self.get_ebuild_metadata(ebuild_line)
-		# if there some error to get the metadata we add rubish to the 
-		# ebuild_version_metadata_tree and set ebuild_version_checksum_tree to 0
-		# so it can be updated next time we update the db
-		if ebuild_version_metadata_tree  == []:
-			log_msg = " QA: %s Have broken metadata" % (ebuild_line,)
-			add_gobs_logs(conn, log_msg, "info", config_profile)
-			ebuild_version_metadata_tree = ['','','','','','','','','','','','','','','','','','','','','','','','','']
-			ebuild_version_checksum_tree = ['0']
-		# add the ebuild to the dict packages
-		attDict['categories'] = categories
-		attDict['package'] = package
-		attDict['ebuild_version_tree'] = ebuild_version_tree
-		attDict['ebuild_version_checksum_tree']= ebuild_version_checksum_tree
-		attDict['ebuild_version_metadata_tree'] = ebuild_version_metadata_tree
-		attDict['ebuild_version_text'] = ebuild_version_text[0]
-		attDict['ebuild_version_revision'] = ebuild_version_text[1]
-		attDict['ebuild_error'] = repoman_error
-		return attDict
-
-	def get_metadataDict(self, packageDict, ebuild_id_list):
-		# Make the metadataDict from packageDict
-		ebuild_i = 0
-		metadataDict ={}
-		for k, v in packageDict.iteritems():
-			attDict = {}
-			metadata_restrictions = []
-			for i in v['ebuild_version_metadata_tree'][4].split():
-				metadata_restrictions.append(i)
-			metadata_keyword = []
-			for i in v['ebuild_version_metadata_tree'][8].split():
-				metadata_keyword.append(i)
-			metadata_iuse = []
-			for i in v['ebuild_version_metadata_tree'][10].split():
-				metadata_iuse.append(i)
-			attDict['restrictions'] = metadata_restrictions
-			attDict['keyword'] = metadata_keyword
-			attDict['iuse'] =  metadata_iuse
-			metadataDict[ebuild_id_list[ebuild_i]] = attDict
-			ebuild_i = ebuild_i +1
-		return metadataDict
+			for config_id in config_id_list:
+
+                        # Change config/setup
+                        config_setup = get_config_db(conn, config_id)
+                        mysettings_setup = self.change_config(config_setup)
+                        myportdb_setup = portage.portdbapi(mysettings=mysettings_setup)
+
+                        # Get the latest cpv from portage with the config that we can build
+                        build_cpv = myportdb_setup.xmatch('bestmatch-visible', cp)
+
+                        # Check if could get cpv from portage and add it to the config_cpv_listDict.
+                        if build_cpv != "":
+
+                                # Get the iuse and use flags for that config/setup and cpv
+                                init_useflags = gobs_use_flags(mysettings_setup, myportdb_setup, build_cpv)
+                                iuse_flags_list, final_use_list = init_useflags.get_flags()
+                                iuse_flags_list2 = []
+                                for iuse_line in iuse_flags_list:
+                                        iuse_flags_list2.append( init_useflags.reduce_flag(iuse_line))
+
+                                # Dict the needed info
+                                attDict = {}
+                                attDict['cpv'] = build_cpv
+                                attDict['useflags'] = final_use_list
+                                attDict['iuse'] = iuse_flags_list2
+                                config_cpv_listDict[config_id] = attDict
+
+                        # Clean some cache
+                        myportdb_setup.close_caches()
+                        portage.portdbapi.portdbapi_instances.remove(myportdb_setup)
+                CM.putConnection(conn)
+                return config_cpv_listDict
+
+	def get_ebuild_metadata(self, cpv, repo):
+                # Get the auxdbkeys infos for the ebuild
+                try:
+                        ebuild_auxdb_list = self._myportdb.aux_get(cpv, portage.auxdbkeys, myrepo=repo)
+                except:
+                        ebuild_auxdb_list = []
+                else:
+                        for i in range(len(ebuild_auxdb_list)):
+                                if ebuild_auxdb_list[i] == '':
+                                        ebuild_auxdb_list[i] = ''
+                return ebuild_auxdb_list
+
+	def get_packageDict(self, pkgdir, cpv, repo, config_id):
+                attDict = {}
+                conn=CM.getConnection()
+
+                #Get categories, package and version from cpv
+                ebuild_version_tree = portage.versions.cpv_getversion(cpv)
+                element = portage.versions.cpv_getkey(cpv).split('/')
+                categories = element[0]
+                package = element[1]
+
+                # Make a checksum of the ebuild
+                try:
+                        ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")[0]
+                except:
+                        ebuild_version_checksum_tree = "0"
+                        log_msg = "QA: Can't checksum the ebuild file. %s on repo %s" % (cpv, repo,)
+                        add_gobs_logs(conn, log_msg, "info", config_profile)
+                        log_msg = "C %s:%s ... Fail." % (cpv, repo)
+                        add_gobs_logs(conn, log_msg, "info", config_profile)
+                        ebuild_version_text_tree = '0'
+                else:
+                        ebuild_version_text_tree = get_ebuild_text(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")
+
+                # run repoman on the ebuild
+                #init_repoman = gobs_repoman(self._mysettings, self._myportdb)
+                #repoman_error = init_repoman.check_repoman(pkgdir, cpv, config_id)
+                #if repoman_error != []:
+                #       log_msg = "Repoman: %s have errors on repo %s" % (cpv, repo,)
+                #        add_gobs_logs(conn, log_msg, "info", config_profile)
+                repoman_error = []
+
+                # Get the ebuild metadata
+                ebuild_version_metadata_tree = self.get_ebuild_metadata(cpv, repo)
+                # if there some error to get the metadata we add rubish to the
+                # ebuild_version_metadata_tree and set ebuild_version_checksum_tree to 0
+                # so it can be updated next time we update the db
+                if ebuild_version_metadata_tree  == []:
+                        log_msg = " QA: %s have broken metadata on repo %s" % (cpv, repo)
+                        add_gobs_logs(conn, log_msg, "info", config_profile)
+                        ebuild_version_metadata_tree = ['','','','','','','','','','','','','','','','','','','','','','','','','']
+                        ebuild_version_checksum_tree = '0'
+
+		# add the ebuild info to the dict packages
+                attDict['repo'] = repo
+                attDict['ebuild_version_tree'] = ebuild_version_tree
+                attDict['ebuild_version_checksum_tree']= ebuild_version_checksum_tree
+                attDict['ebuild_version_metadata_tree'] = ebuild_version_metadata_tree
+                #attDict['ebuild_version_text_tree'] = ebuild_version_text_tree[0]
+                attDict['ebuild_version_revision_tree'] = ebuild_version_text_tree[1]
+                attDict['ebuild_error'] = repoman_error
+                CM.putConnection(conn)
+                return attDict
 
 	def add_new_ebuild_buildquery_db(self, ebuild_id_list, packageDict, config_cpv_listDict):
 		conn=CM.getConnection()
 		# Get the needed info from packageDict and config_cpv_listDict and put that in buildqueue
 		# Only add it if ebuild_version in packageDict and config_cpv_listDict match
 		if config_cpv_listDict is not None:
-			message = None
+			message = []
 			# Unpack config_cpv_listDict
 			for k, v in config_cpv_listDict.iteritems():
 				config_id = k
@@ -147,183 +159,198 @@ class gobs_package(object):
 				i = 0
 				for k, v in packageDict.iteritems():
 					ebuild_id = ebuild_id_list[i]
-					use_flags_list = []
-					use_enable_list = []
-					for u, s in  use_flagsDict.iteritems():
-						use_flags_list.append(u)
-						use_enable_list.append(s)
-					# Comper ebuild_version and add the ebuild_version to buildqueue
-					if portage.vercmp(v['ebuild_version_tree'], latest_ebuild_version) == 0:
-						add_new_package_buildqueue(conn,ebuild_id, config_id, use_flags_list, use_enable_list, message)
-						# B = Build cpv use-flags config
-						log_msg = "B %s/%s-%s USE: %s %s" %  \
-							(v['categories'], v['package'], latest_ebuild_version, use_enable, config_id,)
-						add_gobs_logs(conn, log_msg, "info", config_profile)
+
+                                        # Comper and add the cpv to buildqueue
+                                        if build_cpv == k:
+                                                add_new_package_buildqueue(conn, ebuild_id, config_id, use_flagsDict, messages)
+
+                                                # B = Build cpv use-flags config
+                                                config_setup = get_config_db(conn, config_id)
+
+                                                # FIXME log_msg need a fix to log the use flags corect.
+                                                log_msg = "B %s:%s USE: %s %s" %  \
+                                                        (k, v['repo'], use_enable, config_setup,)
+                                                add_gobs_logs(conn, log_msg, "info", config_profile)
 					i = i +1
 		CM.putConnection(conn)
 
 	def get_package_metadataDict(self, pkgdir, package):
-		# Make package_metadataDict
-		attDict = {}
-		package_metadataDict = {}
-		changelog_checksum_tree = portage.checksum.sha256hash(pkgdir + "/ChangeLog")
-		changelog_text_tree = get_file_text(pkgdir + "/ChangeLog")
-		metadata_xml_checksum_tree = portage.checksum.sha256hash(pkgdir + "/metadata.xml")
-		metadata_xml_text_tree = get_file_text(pkgdir + "/metadata.xml")
-		attDict['changelog_checksum'] =  changelog_checksum_tree[0]
-		attDict['changelog_text'] =  changelog_text_tree
-		attDict['metadata_xml_checksum'] =  metadata_xml_checksum_tree[0]
-		attDict[' metadata_xml_text'] =  metadata_xml_text_tree
-		package_metadataDict[package] = attDict
-		return package_metadataDict
-
-	def add_new_package_db(self, categories, package):
+                # Make package_metadataDict
+                attDict = {}
+                package_metadataDict = {}
+                changelog_checksum_tree = portage.checksum.sha256hash(pkgdir + "/ChangeLog")
+                changelog_text_tree = get_file_text(pkgdir + "/ChangeLog")
+                metadata_xml_checksum_tree = portage.checksum.sha256hash(pkgdir + "/metadata.xml")
+                metadata_xml_text_tree = get_file_text(pkgdir + "/metadata.xml")
+                attDict['changelog_checksum'] =  changelog_checksum_tree[0]
+                attDict['changelog_text'] =  changelog_text_tree
+                attDict['metadata_xml_checksum'] =  metadata_xml_checksum_tree[0]
+                attDict['metadata_xml_text'] =  metadata_xml_text_tree
+                package_metadataDict[package] = attDict
+                return package_metadataDict
+
+	def add_new_package_db(self, categories, package, repo):
 		conn=CM.getConnection()
-		# add new categories package ebuild to tables package and ebuilds
-		# C = Checking
-		# N = New Package
-		log_msg = "C %s/%s" % (categories, package,)
-		add_gobs_logs(conn, log_msg, "info", config_profile)
-		log_msg = "N %s/%s" % (categories, package,)
-		add_gobs_logs(conn, log_msg, "info", config_profile)
-		pkgdir = self._mysettings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR + cp
-		categories_dir = self._mysettings['PORTDIR'] + "/" + categories + "/"
-		# Get the ebuild list for cp
-		ebuild_list_tree = self._myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
-		if ebuild_list_tree == []:
-			CM.putConnection(conn)
-			return
-		config_list  = get_config_list(conn)
-		config_cpv_listDict = self.config_match_ebuild(categories, package, config_list)
-		config_id  = get_default_config(conn)
-		packageDict ={}
-		for ebuild_line in sorted(ebuild_list_tree):
-			# Make the needed packageDict
-			packageDict[ebuild_line] = self.get_packageDict(pkgdir, ebuild_line, categories, package, config_id)
-			# Add the ebuild to db
-			return_id = add_new_package_sql(conn,packageDict)
-			ebuild_id_list = return_id[0]
-			package_id_list = return_id[1]
-			package_id = package_id_list[0]
-			# Add metadataDict to db
-			metadataDict = self.get_metadataDict(packageDict, ebuild_id_list)
-			add_new_metadata(conn,metadataDict)
-			# Add any qa and repoman erro for the ebuild to buildlog
-			qa_error = []
-			init_manifest =  gobs_manifest(self._mysettings, pkgdir)
-			manifest_error = init_manifest.digestcheck()
-			if manifest_error is not None:
-				qa_error.append(manifest_error)
-				log_msg = "QA: %s/%s %s" % (categories, package, qa_error,)
-				add_gobs_logs(conn, log_msg, "info", config_profile)
-			add_qa_repoman(conn,ebuild_id_list, qa_error, packageDict, config_id)
-			# Add the ebuild to the buildqueru table if needed
-			self.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config_cpv_listDict)
-			# Add some checksum on some files
-			package_metadataDict = self.get_package_metadataDict(pkgdir, package)
-			add_new_package_metadata(conn,package_id, package_metadataDict)
-			# Add the manifest file to db
-			try:
-				manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
-			except:
-				manifest_checksum_tree = "0"
-				get_manifest_text = "0"
-				log_msg = "QA: Can't checksum the Manifest file. %c/%s" % (categories, package,)
-				add_gobs_logs(conn, log_msg, "info", config_profile)
-			else:
-				get_manifest_text = get_file_text(pkgdir + "/Manifest")
-			add_new_manifest_sql(conn,package_id, get_manifest_text, manifest_checksum_tree)
-		log_msg = "C %s/%s ... Done." % (categories, package)
-		add_gobs_logs(conn, log_msg, "info", config_profile)
-		CM.putConnection(conn)
+		# Add new categories package ebuild to tables package and ebuilds
+                # C = Checking
+                # N = New Package
+                log_msg = "C %s/%s:%s" % (categories, package, repo)
+                add_gobs_logs(conn, log_msg, "info", config_profile)
+                log_msg = "N %s/%s:%s" % (categories, package, repo)
+                add_gobs_logs(conn, log_msg, "info", config_profile)
+                pkgdir = self._myportdb.getRepositoryPath(repo) + "/" + categories + "/" + package # Get RepoDIR + cp
+
+		# Get the cp manifest file checksum.
+                try:
+                        manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
+                except:
+                        manifest_checksum_tree = "0"
+                        log_msg = "QA: Can't checksum the Manifest file. %s/%s:%s" % (categories, package, repo,)
+                        add_gobs_logs(conn, log_msg, "info", config_profile)
+                        log_msg = "C %s/%s:%s ... Fail." % (categories, package, repo)
+                        add_gobs_logs(conn, log_msg, "info", config_profile)
+                        CM.putConnection(conn)
+                        return
+                package_id = add_new_manifest_sql(conn, categories, package, repo, manifest_checksum_tree)
+
+                # Get the ebuild list for cp
+                mytree = []
+                mytree.append(self._myportdb.getRepositoryPath(repo))
+                ebuild_list_tree = self._myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=mytree)
+                if ebuild_list_tree == []:
+                        log_msg = "QA: Can't get the ebuilds list. %s/%s:%s" % (categories, package, repo,)
+                        add_gobs_logs(conn, log_msg, "info", config_profile)
+                        log_msg = "C %s/%s:%s ... Fail." % (categories, package, repo)
+                        add_gobs_logs(conn, log_msg, "info", config_profile)
+                        CM.putConnection(conn)
+                        return
+
+		# set config to default config
+                default_config = get_default_config(conn)
 
-	def update_package_db(self, categories, package, package_id):
+                # Make the needed packageDict with ebuild infos so we can add it later to the db.
+                packageDict ={}
+                ebuild_id_list = []
+                for cpv in sorted(ebuild_list_tree):
+                        packageDict[cpv] = self.get_packageDict(pkgdir, cpv, repo, default_config)
+
+                # Add new ebuilds to the db
+                ebuild_id_list = add_new_ebuild_sql(conn, package_id, packageDict)
+
+                # Get the best cpv for the configs and add it to config_cpv_listDict
+                configs_id_list  = get_config_id_list(conn)
+                config_cpv_listDict = self.config_match_ebuild(categories + "/" + package, configs_id_list)
+
+                # Add the ebuild to the buildquery table if needed
+                self.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config_cpv_listDict)
+
+                log_msg = "C %s/%s:%s ... Done." % (categories, package, repo)
+                add_gobs_logs(conn, log_msg, "info", config_profile)
+                print(categories, package, repo)
+                CM.putConnection(conn)
+
+	def update_package_db(self, package_id):
 		conn=CM.getConnection()
 		# Update the categories and package with new info
-		# C = Checking
-		log_msg = "C %s/%s" % (categories, package,)
-		add_gobs_logs(conn, log_msg, "info", config_profile)
-		pkgdir = self._mysettings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR with cp
-		# Get the checksum from the Manifest file.
-		try:
-			manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
-		except:
-			# We did't fine any Manifest file
-			manifest_checksum_tree = '0'
-			ebuild_list_tree = self._myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
-			if ebuild_list_tree == []:
-				CM.putConnection(conn)
-				log_msg = "QA: No Manifest file or ebuilds in %s/%s." % (categories, package,)
-				add_gobs_logs(conn, log_msg, "info", config_profile)
-				log_msg = "C %s/%s ... Done." % (categories, package,)
-				add_gobs_logs(conn, log_msg, "info", config_profile)
-				return
+                # C = Checking
+                cp, repo = get_cp_repo_from_package_id(conn, package_id)
+                element = cp.split('/')
+                package = element[1]
+                log_msg = "C %s:%s" % (cp, repo)
+                add_gobs_logs(conn, log_msg, "info", config_profile)
+                pkgdir = self._myportdb.getRepositoryPath(repo) + "/" + cp # Get RepoDIR + cp
+
+                # Get the cp mainfest file checksum
+                try:
+                        manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
+                except:
+                        manifest_checksum_tree = "0"
+                        log_msg = "QA: Can't checksum the Manifest file. %s:%s" % (cp, repo,)
+                        add_gobs_logs(conn, log_msg, "info", config_profile)
+                        log_msg = "C %s:%s ... Fail." % (cp, repo)
+                        add_gobs_logs(conn, log_msg, "info", config_profile)
+                        CM.putConnection(conn)
+                        return
+
 		# Get the checksum from the db in package table
-		manifest_checksum_db = get_manifest_db(conn,package_id)
-		# if we have the same checksum return else update the package
-		ebuild_list_tree = self._myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
-		if manifest_checksum_tree != manifest_checksum_db:
+                manifest_checksum_db = get_manifest_db(conn, package_id)
+
+                # if we have the same checksum return else update the package
+                if manifest_checksum_tree != manifest_checksum_db:
+
 			# U = Update
-			log_msg = "U %s/%s" % (categories, package)
-			add_gobs_logs(conn, log_msg, "info", config_profile)
-			# Get package_metadataDict and update the db with it
-			package_metadataDict = self.get_package_metadataDict(pkgdir, package)
-			update_new_package_metadata(conn,package_id, package_metadataDict)
-			# Get config_cpv_listDict
-			config_list  = get_config_list(conn)
-			config_cpv_listDict = self.config_match_ebuild(categories, package, config_list)
-			config_id  = get_default_config(conn)
-			packageDict ={}
-			for ebuild_line in sorted(ebuild_list_tree):
-				old_ebuild_list = []
-				# split out ebuild version
-				ebuild_version_tree = portage.versions.cpv_getversion(ebuild_line)
-				# Get the checksum of the ebuild in tree and db
-				ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")[0]
-				ebuild_version_manifest_checksum_db = get_ebuild_checksum(conn,package_id, ebuild_version_tree)
-				# Check if the checksum have change
-				if ebuild_version_manifest_checksum_db is None or ebuild_version_checksum_tree != ebuild_version_manifest_checksum_db:
-					# Get packageDict for ebuild
-					packageDict[ebuild_line] = self.get_packageDict(pkgdir, ebuild_line, categories, package, config_id)
-					if ebuild_version_manifest_checksum_db is None:
-						# N = New ebuild
-						log_msg = "N %s/%s-%s" % (categories, package, ebuild_version_tree,)
-						add_gobs_logs(conn, log_msg, "info", config_profile)
-					else:
-						# U = Updated ebuild
-						log_msg = "U %s/%s-%s" % (categories, package, ebuild_version_tree,)
-						add_gobs_logs(conn, log_msg, "info", config_profile)
-						# Fix so we can use add_new_package_sql(packageDict) to update the ebuilds
-						old_ebuild_list.append(ebuild_version_tree)
-						add_old_ebuild(conn,package_id, old_ebuild_list)
-						update_active_ebuild(conn,package_id, ebuild_version_tree)
-			# Use packageDictand and metadataDict to update the db
-			return_id = add_new_package_sql(conn,packageDict)
-			ebuild_id_list = return_id[0]
-			metadataDict = self.get_metadataDict(packageDict, ebuild_id_list)
-			add_new_metadata(conn,metadataDict)
-			# Get the text in Manifest and update it
-			try:
-				get_manifest_text = get_file_text(pkgdir + "/Manifest")
-			except:
-				get_manifest_text = "0"
-			update_manifest_sql(conn,package_id, get_manifest_text, manifest_checksum_tree)
-			# Add any qa and repoman erros to buildlog
-			qa_error = []
-			init_manifest =  gobs_manifest(self._mysettings, pkgdir)
-			manifest_error = init_manifest.digestcheck()
-			if manifest_error is not None:
-				qa_error.append(manifest_error)
-				log_msg = "QA: %s/%s %s" % (categories, package, qa_error,)
-				add_gobs_logs(conn, log_msg, "info", config_profile)
-			add_qa_repoman(conn,ebuild_id_list, qa_error, packageDict, config_id)
-			# Add the ebuild to the buildqueru table if needed
-			self.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config_cpv_listDict)
-			# Mark or remove any old ebuilds
-			init_old_cpv = gobs_old_cpv(self._myportdb, self._mysettings)
-			init_old_cpv.mark_old_ebuild_db(categories, package, package_id)
-		log_msg = "C %s/%s ... Done." % (categories, package)
-		add_gobs_logs(conn, log_msg, "info", config_profile)
+                        log_msg = "U %s:%s" % (cp, repo)
+                        add_gobs_logs(conn, log_msg, "info", config_profile)
+
+                        # Get the ebuild list for cp
+                        mytree = []
+                        mytree.append(self._myportdb.getRepositoryPath(repo))
+                        ebuild_list_tree = self._myportdb.cp_list(cp, use_cache=1, mytree=mytree)
+                        if ebuild_list_tree == []:
+                                log_msg = "QA: Can't get the ebuilds list. %s:%s" % (cp, repo,)
+                                add_gobs_logs(conn, log_msg, "info", config_profile)
+                                log_msg = "C %s:%s ... Fail." % (cp, repo)
+                                add_gobs_logs(conn, log_msg, "info", config_profile)
+                                CM.putConnection(conn)
+                                return
+                        packageDict ={}
+                        for cpv in sorted(ebuild_list_tree):
+                                old_ebuild_list = []
+
+                                # split out ebuild version
+                                ebuild_version_tree = portage.versions.cpv_getversion(cpv)
+
+                                # Get the checksum of the ebuild in tree and db
+                                # Make a checksum of the ebuild
+                                try:
+                                        ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")[0]
+                                except:
+                                        ebuild_version_checksum_tree = '0'
+                                        manifest_checksum_tree = '0'
+                                        log_msg = "QA: Can't checksum the ebuild file. %s on repo %s" % (cpv, repo,)
+                                        add_gobs_logs(conn, log_msg, "info", config_profile)
+                                        log_msg = "C %s:%s ... Fail." % (cpv, repo)
+                                        add_gobs_logs(conn, log_msg, "info", config_profile)
+                                ebuild_version_manifest_checksum_db = get_ebuild_checksum(conn, package_id, ebuild_version_tree)
+
+
+                                # Check if the checksum have change
+                                if ebuild_version_manifest_checksum_db is None or ebuild_version_checksum_tree != ebuild_version_manifest_checksum_db:
+
+                                        # set config to default config
+                                        default_config = get_default_config(conn)
+
+                                        # Get packageDict for ebuild
+                                        packageDict[cpv] = self.get_packageDict(pkgdir, cpv, repo, default_config)
+                                        if ebuild_version_manifest_checksum_db is None:
+                                                # N = New ebuild
+                                                log_msg = "N %s:%s" % (cpv, repo,)
+                                                add_gobs_logs(conn, log_msg, "info", config_profile)
+                                        else:
+                                                # U = Updated ebuild
+                                                log_msg = "U %s:%s" % (cpv, repo,)
+                                                add_gobs_logs(conn, log_msg, "info", config_profile)
+
+                                                # Fix so we can use add_new_ebuild_sql() to update the ebuilds
+                                                old_ebuild_list.append(ebuild_version_tree)
+                                                add_old_ebuild(conn, package_id, old_ebuild_list)
+                                                update_active_ebuild_to_fales(conn, package_id, ebuild_version_tree)
+			# Use packageDictand to update the db
+                        # Add new ebuilds to the db
+                        ebuild_id_list = add_new_ebuild_sql(conn, package_id, packageDict)
+
+                        # update the cp manifest checksum
+                        update_manifest_sql(conn, package_id, manifest_checksum_tree)
+
+                        # Get the best cpv for the configs and add it to config_cpv_listDict
+                        configs_id_list  = get_config_id_list(conn)
+                        config_cpv_listDict = self.config_match_ebuild(cp, configs_id_list)
+
+                        # Add the ebuild to the buildqueru table if needed
+                        self.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config_cpv_listDict)
+
+                log_msg = "C %s:%s ... Done." % (cp, repo)
+                add_gobs_logs(conn, log_msg, "info", config_profile)
 		CM.putConnection(conn)
 
 	def update_ebuild_db(self, build_dict):

diff --git a/gobs/pym/pgsql.py b/gobs/pym/pgsql.py
index be557d2..f8de5ff 100644
--- a/gobs/pym/pgsql.py
+++ b/gobs/pym/pgsql.py
@@ -225,7 +225,7 @@ def add_new_metadata(connection, metadataDict):
 def add_new_package_sql(connection, packageDict):
   #lets have a new cursor for each metod as per best practice
   cursor = connection.cursor()
-  sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
+  sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
   ebuild_id_list = []
   package_id_list = []
   for k, v in packageDict.iteritems():
@@ -235,7 +235,7 @@ def add_new_package_sql(connection, packageDict):
     v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
     v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
     v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
-    v['ebuild_version_metadata_tree'][16]]
+    v['ebuild_version_metadata_tree'][16], v['ebuild_version_metadata_tree'][4]]
     cursor.execute(sqlQ, params)
     mid = cursor.fetchone()
     mid=mid[0]
@@ -248,7 +248,7 @@ def add_new_package_sql(connection, packageDict):
 def add_new_ebuild_sql(connection, packageDict, new_ebuild_list):
   #lets have a new cursor for each metod as per best practice
   cursor = connection.cursor()
-  sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
+  sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
   ebuild_id_list = []
   package_id_list = []
   for k, v in packageDict.iteritems():
@@ -260,7 +260,7 @@ def add_new_ebuild_sql(connection, packageDict, new_ebuild_list):
         v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
         v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
         v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
-        v['ebuild_version_metadata_tree'][16]]
+        v['ebuild_version_metadata_tree'][16], v['ebuild_version_metadata_tree'][4]]
         cursor.execute(sqlQ, params)
         mid = cursor.fetchone()
         mid=mid[0]

diff --git a/gobs/pym/pgsql_querys.py b/gobs/pym/pgsql_querys.py
new file mode 100644
index 0000000..9184a20
--- /dev/null
+++ b/gobs/pym/pgsql_querys.py
@@ -0,0 +1,308 @@
+#every function takes a connection as a parameter that is provided by the CM
+from __future__ import print_function
+
+# Queryes to add the logs
+def add_gobs_logs(connection, log_msg, log_type, config):
+	cursor = connection.cursor()
+	sqlQ = 'INSERT INTO logs (config_id, type, msg) VALUES ( (SELECT config_id FROM configs WHERE config = %s), %s, %s )'
+	cursor.execute(sqlQ, (config, log_type, log_msg))
+	connection.commit()
+	
+	# Queryes to handel the jobs table
+	def get_jobs_id(connection, config_profile):
+		cursor = connection.cursor()
+		sqlQ = "SELECT job_id FROM jobs WHERE status = 'Waiting' AND config_id = (SELECT config_id FROM configs WHERE config = %s)"
+		cursor.execute(sqlQ, (config_profile,))
+		entries = cursor.fetchall()
+		if entries is None:
+			return None
+			jobs_id = []
+			for job_id in entries:
+				jobs_id.append(job_id[0])
+				return sorted(jobs_id)
+			
+			def get_job(connection, job_id):
+				cursor = connection.cursor()
+				sqlQ ='SELECT job FROM jobs WHERE job_id = %s'
+				cursor.execute(sqlQ, (job_id,))
+				job = cursor.fetchone()
+				return job[0]
+			
+			def update_job_list(connection, status, job_id):
+				cursor = connection.cursor()
+				sqlQ = 'UPDATE  jobs SET status = %s WHERE job_id = %s'
+				cursor.execute(sqlQ, (status, job_id,))
+				connection.commit()
+				
+				# Queryes to handel the configs* tables
+				def get_config_list_all(connection):
+					cursor = connection.cursor()
+					sqlQ = 'SELECT config FROM configs'
+					cursor.execute(sqlQ)
+					entries = cursor.fetchall()
+					return entries
+				def update_make_conf(connection, configsDict):
+					cursor = connection.cursor()
+					sqlQ1 = 'UPDATE configs_metadata SET checksum = %s, make_conf_text = %s, active = %s, config_error = %s WHERE config_id = (SELECT config_id FROM configs WHERE config = %s)'
+					for k, v in configsDict.iteritems():
+						params = [v['make_conf_checksum_tree'], v['make_conf_text'], v['active'], v['config_error'], k]
+						cursor.execute(sqlQ1, params)
+						connection.commit()
+						
+						def get_default_config(connection):
+							cursor = connection.cursor()
+							sqlQ = "SELECT config FROM configs WHERE default_config = 'True'"
+							cursor.execute(sqlQ)
+							entries = cursor.fetchone()
+							return entries
+						
+						def update_repo_db(connection, repo_list):
+							cursor = connection.cursor()
+							sqlQ1 = 'SELECT repo_id FROM repos WHERE repo = %s'
+							sqlQ2 = 'INSERT INTO repos (repo) VALUES ( %s )'
+							for repo in repo_list:
+								cursor.execute(sqlQ1, (repo,))
+								entries = cursor.fetchone()
+								if entries is None:
+									cursor.execute(sqlQ2, (repo,))
+									connection.commit()
+									return
+def get_package_id(connection, categories, package, repo):
+  cursor = connection.cursor()
+  sqlQ ='SELECT package_id FROM packages WHERE category = %s AND package = %s AND repo_id = (SELECT repo_id FROM repos WHERE repo = %s)'
+  params = categories, package, repo
+  cursor.execute(sqlQ, params)
+  entries = cursor.fetchone()
+  if entries is None:
+    return None
+  return entries[0]
+
+# Add new info to the packages table
+
+def get_repo_id(connection, repo):
+  cursor = connection.cursor()
+  sqlQ ='SELECT repo_id FROM repos WHERE repo = %s'
+  cursor.execute(sqlQ, (repo,))
+  entries = cursor.fetchone()
+  if entries is None:
+    return None
+  return entries[0]
+
+def add_new_manifest_sql(connection, categories, package, repo, manifest_checksum_tree):
+  cursor = connection.cursor()
+  sqlQ = "INSERT INTO packages (category, package, repo_id, checksum, active) VALUES (%s, %s, %s, %s, 'True') RETURNING package_id"
+  repo_id = get_repo_id(connection, repo)
+  cursor.execute(sqlQ, (categories, package, repo_id, manifest_checksum_tree,))
+  package_id = cursor.fetchone()[0]
+  connection.commit()
+  return package_id
+
+def get_restriction_id(connection, restriction):
+  cursor = connection.cursor()
+  sqlQ ='SELECT restriction_id FROM restrictions WHERE restriction = %s'
+  cursor.execute(sqlQ, (restriction,))
+  entries = cursor.fetchone()
+  if entries is None:
+    return None
+  return entries[0]
+
+def get_use_id(connection, use_flag):
+  cursor = connection.cursor()
+  sqlQ ='SELECT use_id FROM uses WHERE flag = %s'
+  cursor.execute(sqlQ, (use_flag,))
+  entries = cursor.fetchone()
+  if entries is None:
+    return None
+  return entries[0]
+
+def get_keyword_id(connection, keyword):
+  cursor = connection.cursor()
+  sqlQ ='SELECT keyword_id FROM keywords WHERE keyword = %s'
+  cursor.execute(sqlQ, (keyword,))
+  entries = cursor.fetchone()
+  if entries is None:
+    return None
+  return entries[0]
+
+def add_new_ebuild_metadata_sql(connection, ebuild_id, keywords, restrictions, iuse_list):
+  cursor = connection.cursor()
+  sqlQ1 = 'INSERT INTO keywords (keyword) VALUES ( %s ) RETURNING keyword_id'
+  sqlQ3 = 'INSERT INTO restrictions (restriction) VALUES ( %s ) RETURNING restriction_id'
+  sqlQ4 = 'INSERT INTO ebuilds_restrictions (ebuild_id, restriction_id) VALUES ( %s, %s )'
+  sqlQ5 = 'INSERT INTO uses (flag) VALUES ( %s ) RETURNING use_id'
+  sqlQ6 = 'INSERT INTO ebuilds_iuse (ebuild_id, use_id, status) VALUES ( %s, %s, %s)'
+  sqlQ7 = 'INSERT INTO ebuilds_keywords (ebuild_id, keyword_id, status) VALUES ( %s, %s, %s)'
+  # FIXME restriction need some filter as iuse and keyword have.
+  for restriction in restrictions:
+    restriction_id = get_restriction_id(connection, restriction)
+    if restriction_id is None:
+      cursor.execute(sqlQ3, (restriction,))
+      restriction_id = cursor.fetchone()[0]
+    cursor.execute(sqlQ4, (ebuild_id, restriction_id,))
+  for iuse in iuse_list:
+    set_iuse = 'disable'
+    if iuse[0] in ["+"]:
+      iuse = iuse[1:]
+      set_iuse = 'enable'
+    elif iuse[0] in ["-"]:
+      iuse = iuse[1:]
+    use_id = get_use_id(connection, iuse)
+    if use_id is None:
+      cursor.execute(sqlQ5, (iuse,))
+      use_id = cursor.fetchone()[0]
+    for keyword in keywords:
+    set_keyword = 'stable'
+    if keyword[0] in ["~"]:
+      keyword = keyword[1:]
+      set_keyword = 'unstable'
+    elif keyword[0] in ["-"]:
+      keyword = keyword[1:]
+      set_keyword = 'testing'
+    keyword_id = get_keyword_id(connection, keyword)
+    if keyword_id is None:
+      cursor.execute(sqlQ1, (keyword,))
+      keyword_id = cursor.fetchone()[0]
+    cursor.execute(sqlQ7, (ebuild_id, keyword_id, set_keyword,))
+  connection.commit()cursor.execute(sqlQ6, (ebuild_id, use_id, set_iuse,))
+
+def add_new_ebuild_sql(connection, package_id, ebuildDict):
+  cursor = connection.cursor()
+  sqlQ1 = 'SELECT repo_id FROM packages WHERE package_id = %s'
+  sqlQ2 = "INSERT INTO ebuilds (package_id, version, checksum, active) VALUES (%s, %s, %s, 'True') RETURNING ebuild_id"
+  sqlQ4 = "INSERT INTO ebuilds_metadata (ebuild_id, revision) VALUES (%s, %s)"
+  ebuild_id_list = []
+  cursor.execute(sqlQ1, (package_id,))
+  repo_id = cursor.fetchone()[0]
+  for k, v in ebuildDict.iteritems():
+    cursor.execute(sqlQ2, (package_id, v['ebuild_version_tree'], v['ebuild_version_checksum_tree'],))
+    ebuild_id = cursor.fetchone()[0]
+    cursor.execute(sqlQ4, (ebuild_id, v['ebuild_version_revision_tree'],))
+    ebuild_id_list.append(ebuild_id)
+    restrictions = []
+    keywords = []
+    iuse = []
+    for i in v['ebuild_version_metadata_tree'][4].split():
+      restrictions.append(i)
+    for i in v['ebuild_version_metadata_tree'][8].split():
+      keywords.append(i)
+    for i in v['ebuild_version_metadata_tree'][10].split():
+      iuse.append(i)
+    add_new_ebuild_metadata_sql(connection, ebuild_id, keywords, restrictions, iuse)
+  connection.commit()
+  return ebuild_id_list
+
+def get_config_id_list(connection):
+  cursor = connection.cursor()
+  sqlQ = "SELECT configs.config_id FROM configs, configs_metadata WHERE configs.default_config = 'False' AND configs_metadata.active = 'True' AND configs.config_id = configs_metadata.config_id"
+  cursor.execute(sqlQ)
+  entries = cursor.fetchall()
+  if entries == ():
+    return None
+  else:
+    config_id_list = []
+    for config_id in entries:
+      config_id_list.append(config_id[0])
+    return config_id_list
+
+def get_config_db(connection, config_id):
+  cursor = connection.cursor()
+  sqlQ = 'SELECT config FROM configs WHERE config_id = %s'
+  cursor.execute(sqlQ,(config_id,))
+  entries = cursor.fetchone()
+  if entries is None:
+    return None
+  return entries[0]
+
+def add_new_package_buildqueue(connection, ebuild_id, config_id, use_flagsDict, messages):
+  cursor = connection.cursor()
+  sqlQ1 = 'INSERT INTO build_jobs (ebuild_id, config_id) VALUES (%s, %s) RETURNING build_job_id'
+  sqlQ3 = 'INSERT INTO build_jobs_use (build_job_id, use_id, status) VALUES (%s, (SELECT use_id FROM uses WHERE flag = %s), %s)'
+  cursor.execute(sqlQ1, (ebuild_id, config_id,))
+  build_job_id = cursor.fetchone()[0]
+  for k, v in use_flagsDict.iteritems():
+    cursor.execute(sqlQ3, (build_job_id, k, v,))
+  connection.commit()
+
+def get_manifest_db(connection, package_id):
+  cursor = connection.cursor()
+  sqlQ = 'SELECT checksum FROM packages WHERE package_id = %s'
+  cursor.execute(sqlQ, (package_id,))
+  entries = cursor.fetchone()
+  if entries is None:
+          return None
+  # If entries is not None we need [0]
+  return entries[0]
+
+def get_cp_from_package_id(connection, package_id):
+  cursor = connection.cursor()
+  sqlQ = "SELECT ARRAY_TO_STRING(ARRAY[category, package] , '/') AS cp FROM packages WHERE package_id = %s"
+  cursor.execute(sqlQ, (package_id,))
+  return cursor.fetchone()
+
+def get_cp_repo_from_package_id(connection, package_id):
+  cursor =connection.cursor()
+  sqlQ = 'SELECT repos.repo FROM repos, packages WHERE repos.repo_id = packages.repo_id AND packages.package_id = %s'
+  cp = get_cp_from_package_id(connection, package_id)
+  cursor.execute(sqlQ, (package_id,))
+  repo = cursor.fetchone()
+  return cp[0], repo[0]
+
+def get_ebuild_checksum(connection, package_id, ebuild_version_tree):
+  cursor = connection.cursor()
+  sqlQ = "SELECT checksum FROM ebuilds WHERE package_id = %s AND version = %s AND active = 'True'"
+  cursor.execute(sqlQ, (package_id, ebuild_version_tree))
+  entries = cursor.fetchone()
+  if entries is None:
+    return None
+ # If entries is not None we need [0]
+  return entries[0]
+
+def add_old_ebuild(connection, package_id, old_ebuild_list):
+  cursor = connection.cursor()
+  sqlQ1 = "UPDATE ebuilds SET active = 'False' WHERE package_id = %s AND version = %s"
+  sqlQ2 = "SELECT ebuild_id FROM ebuilds WHERE package_id = %s AND version = %s AND active = 'True'"
+  sqlQ3 = "SELECT build_job_id FROM build_jobs WHERE ebuild_id = %s"
+  sqlQ4 = 'DELETE FROM build_jobs_use WHERE build_job_id = %s'
+  sqlQ5 = 'DELETE FROM build_jobs WHERE build_job_id = %s'
+  for old_ebuild in  old_ebuild_list:
+    cursor.execute(sqlQ2, (package_id, old_ebuild[0]))
+    ebuild_id_list = cursor.fetchall()
+    if ebuild_id_list is not None:
+      for ebuild_id in ebuild_id_list:
+        cursor.execute(sqlQ3, (ebuild_id))
+        build_job_id_list = cursor.fetchall()
+        if build_job_id_list is not None:
+          for build_job_id in build_job_id_list:
+            cursor.execute(sqlQ4, (build_job_id))
+            cursor.execute(sqlQ5, (build_job_id))
+        cursor.execute(sqlQ1, (package_id, old_ebuild[0]))
+  connection.commit()
+
+def update_active_ebuild_to_fales(connection, package_id, ebuild_version_tree):
+  cursor = connection.cursor()
+  sqlQ ="UPDATE ebuilds SET active = 'False' WHERE package_id = %s AND version = %s AND active = 'True'"
+  cursor.execute(sqlQ, (package_id, ebuild_version_tree))
+  connection.commit()
+
+def update_manifest_sql(connection, package_id, manifest_checksum_tree):
+  cursor = connection.cursor()
+  sqlQ = 'UPDATE packages SET checksum = %s WHERE package_id = %s'
+  cursor.execute(sqlQ, (manifest_checksum_tree, package_id,))
+  connection.commit()
+
+def get_build_jobs_id_list_config(connection, config_id):
+        cursor = connection.cursor()
+        sqlQ = 'SELECT build_job_id FROM build_jobs WHERE config_id = %s'
+        cursor.execute(sqlQ,  (config_id,))
+        entries = cursor.fetchall()
+        return entries
+
+def del_old_build_jobs(connection, queue_id):
+        cursor = connection.cursor()
+        sqlQ1 = 'DELETE FROM build_jobs_use WHERE build_job_id = %s'
+        sqlQ2 = 'DELETE FROM build_jobs_retest WHERE build_job_id  = %s'
+        sqlQ3 = 'DELETE FROM build_jobs WHERE build_job_id  = %s'
+        cursor.execute(sqlQ1, (build_job_id,))
+        cursor.execute(sqlQ2, (build_job_id,))
+        cursor.execute(sqlQ3, (build_job_id,))
+        connection.commit()

diff --git a/gobs/pym/repoman_gobs.py b/gobs/pym/repoman_gobs.py
index ef10f9c..adb4466 100644
--- a/gobs/pym/repoman_gobs.py
+++ b/gobs/pym/repoman_gobs.py
@@ -15,11 +15,13 @@ class gobs_repoman(object):
 		self._mysettings = mysettings
 		self._myportdb = myportdb
 
-	def check_repoman(self, categories, package, ebuild_version_tree, config_id):
+	def check_repoman(self, pkgdir, cpv, repo, config_id):
 		# We run repoman run_checks on the ebuild
-		pkgdir = self._mysettings['PORTDIR'] + "/" + categories + "/" + package
+		ebuild_version_tree = portage.versions.cpv_getversion(cpv)
+		element = portage.versions.cpv_getkey(cpv).split('/')
+		categories = element[0]
+		package = element[1]
 		full_path = pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild"
-		cpv = categories + "/" + package + "-" + ebuild_version_tree
 		root = '/'
 		trees = {
 		root : {'porttree' : portage.portagetree(root, settings=self._mysettings)}
@@ -28,7 +30,7 @@ class gobs_repoman(object):
 		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)))
+		myaux = dict(zip(allvars, self._myportdb.aux_get(cpv, allvars, myrepo=repo)))
 		pkg = Package(cpv=cpv, metadata=myaux, root_config=root_config, type_name='ebuild')
 		fails = []
 		try:

diff --git a/gobs/pym/text.py b/gobs/pym/text.py
index 2f1f689..3f7b040 100644
--- a/gobs/pym/text.py
+++ b/gobs/pym/text.py
@@ -16,7 +16,7 @@ def  get_file_text(filename):
 	textfile.close()
 	return text
 
-def  get_ebuild_text(filename):
+def  get_ebuild_cvs_revision(filename):
 	"""Return the ebuild contents"""
 	try:
 		ebuildfile = open(filename)
@@ -33,7 +33,7 @@ def  get_ebuild_text(filename):
 		cvs_revision = field[3]
 	except:
 		cvs_revision = ''
-	return text, cvs_revision
+	return cvs_revision
 
 def  get_log_text_list(filename):
 	"""Return the log contents as a list"""

diff --git a/gobs/pym/updatedb.py b/gobs/pym/updatedb.py
index e643fc8..fb185d2 100755
--- a/gobs/pym/updatedb.py
+++ b/gobs/pym/updatedb.py
@@ -18,35 +18,25 @@ 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.pgsql_querys import *
+if CM.getName()=='mysql':
+  from gobs.mysql_querys import *
 
 from gobs.check_setup import check_make_conf
-from gobs.arch import gobs_arch
 from gobs.package import gobs_package
-from gobs.categories import gobs_categories
-from gobs.old_cpv import gobs_old_cpv
-from gobs.categories import gobs_categories
-from gobs.sync import git_pull, sync_tree
 import portage
 
 def init_portage_settings():
-	
-	""" Get the BASE Setup/Config for portage.settings
-	@type: module
-	@module: The SQL Backend
-	@type: dict
-	@parms: config options from the config file (host_setup_root)
-	@rtype: settings
-	@returns new settings
-	"""
 	# check config setup
 	conn=CM.getConnection()
 	check_make_conf()
 	log_msg = "Check configs done"
 	add_gobs_logs(conn, log_msg, "info", config_profile)
+	
 	# Get default config from the configs table  and default_config=1
 	config_id = get_default_config(conn)			# HostConfigDir = table configs id
 	default_config_root = "/var/cache/gobs/" + gobs_settings_dict['gobs_gitreponame'] + "/" + config_id[0] + "/"
+
 	# Set config_root (PORTAGE_CONFIGROOT)  to default_config_root
 	mysettings = portage.config(config_root = default_config_root)
 	log_msg = "Setting default config to: %s" % (config_id[0],)
@@ -54,59 +44,67 @@ def init_portage_settings():
 	CM.putConnection(conn)
 	return mysettings
 
-def update_cpv_db_pool(mysettings, myportdb, init_package, package_line):
+def update_cpv_db_pool(mysettings, myportdb, init_package, package_line, repo):
 	conn=CM.getConnection()
 	# 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)
+	package_id = get_package_id(conn, categories, package, repo)
 	CM.putConnection(conn)
 	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 = gobs_categories(mysettings)
-	init_categories.update_categories_db(categories)
+		init_package.update_package_db(package_id)
+	return
 
 def update_cpv_db():
-	"""Code to update the cpv in the database.
-	@type:settings
-	@parms: portage.settings
-	@type: module
-	@module: The SQL Backend
-	@type: dict
-	@parms: config options from the config file
-	"""
 	conn=CM.getConnection()
 	mysettings =  init_portage_settings()
 	log_msg = "Checking categories, package, ebuilds"
 	add_gobs_logs(conn, log_msg, "info", config_profile)
-	CM.putConnection(conn)
+	
 	# Setup portdb, package
 	myportdb = portage.portdbapi(mysettings=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()
-	# 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):
-		#update_cpv_db_pool(mysettings, package_line)
-		pool.apply_async(update_cpv_db_pool, (mysettings, myportdb, init_package, package_line,))
+	repo_list = ()
+        repos_trees_list = []
+
+        # Use all cores when multiprocessing
+        pool_cores= multiprocessing.cpu_count()
+        pool = multiprocessing.Pool(processes=pool_cores)
+
+        # Will run some update checks and update package if needed
+        # Get categories/package list from portage and repos
+        
+        # Get the repos and update the repos db
+        repo_list = myportdb.getRepositories()
+        update_repo_db(conn, repo_list)
+        CM.putConnection(conn)
+        
+	# Get the rootdirs for the repos
+        repo_trees_list = myportdb.porttrees
+        for repo_dir in repo_trees_list:
+                repo = myportdb.getRepositoryName(repo_dir)
+                repo_dir_list = []
+                repo_dir_list.append(repo_dir)
+
+                # Get the package list from the repo
+                package_id_list_tree = []
+                package_list_tree = myportdb.cp_all(trees=repo_dir_list)
+
+                # Run the update package for all package in the list and in a multiprocessing pool
+                for package_line in sorted(package_list_tree):
+                        pool.apply_async(update_cpv_db_pool, (mysettings, myportdb, init_package, package_line, repo,))
+                        # update_cpv_db_pool(mysettings, myportdb, init_package, package_line, repo)
 	pool.close()
 	pool.join()
 	conn=CM.getConnection()
@@ -116,30 +114,15 @@ def update_cpv_db():
 
 def update_db_main():
 	# Main
-	conn=CM.getConnection()
-	# Logging
-	log_msg = "Update db started."
-	add_gobs_logs(conn, log_msg, "info", config_profile)
-	# Sync portage and profile/settings
-	resutalt = git_pull()
-	if resutalt is False:
-		log_msg = "Update db ... Fail."
-		add_gobs_logs(conn, log_msg, "info", config_profile)
-		CM.putConnection(conn)
-		return False
-	resutalt = sync_tree()
-	if resutalt is False:
-		log_msg = "Update db ... Fail."
-		add_gobs_logs(conn, log_msg, "info", config_profile)
-		CM.putConnection(conn)
-		return False
-	# 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()
-	log_msg = "Update db ... Done."
-	add_gobs_logs(conn, log_msg, "info", config_profile)
-	CM.putConnection(conn)
-	return True
\ No newline at end of file
+        conn=CM.getConnection()
+
+        # Logging
+        log_msg = "Update db started."
+        add_gobs_logs(conn, log_msg, "info", config_profile)
+
+        # Update the cpv db
+        update_cpv_db()
+        log_msg = "Update db ... Done."
+        add_gobs_logs(conn, log_msg, "info", config_profile)
+        CM.putConnection(conn)
+        return True