retlist.append(list(node))

				node2 = list(node)

				if len(node2) == 4:

					node2.append(str(slotcount))

				retlist.append(node2)

			graph_key = tuple(x)

			if len(x) > 4:

				graph_key = tuple(x[:-1])

			else:

				graph_key = tuple(x)

			if ordered and graph_key[-1] != "nomerge":

			if len(graph_key) > 4:

				merge_op = graph_key[-2]

			else:

				merge_op = graph_key[-1]

			if ordered and merge_op != "nomerge":

					if x[0] == "ebuild" and ordered and x[-1] != "nomerge":

					if len(x) > 4:

						merge_op = x[-2]

					else:

						merge_op = x[-1]

					if x[0] == "ebuild" and ordered and merge_op != "nomerge":

						if x[-1] == "nomerge" or not ordered:

						if len(x) > 4:

							merge_op = x[-2]

						else:

							merge_op = x[-1]

						if merge_op == "nomerge" or not ordered:

	def merge(self, mylist, favorites, mtimedb):

	def restart_portage(self, x, mergecount, totalcount, mtimedb):

		xterm_titles = "notitles" not in self.settings.features

		# don't really restart if any of these is true

		# XXXXX - seems like redundant check, but what the hell! sky is not falling as yet.

		if "--pretend" in self.myopts or "--fetchonly" in self.myopts or \

			"--fetch-all-uri" in self.myopts or "--buildpkgonly" in self.myopts:

			return

		bad_resume_opts = set(["--ask", "--tree", "--changelog", "--skipfirst",

			"--resume"])

		mysplit=portage.pkgsplit(x[2])

		myver=mysplit[1]+"-"+mysplit[2]

		if myver[-3:]=='-r0':

			myver=myver[:-3]

		if (myver != portage.VERSION) and \

		   "livecvsportage" not in self.settings.features:

			if totalcount > mergecount:

				emergelog(xterm_titles,

					" ::: completed emerge ("+ \

					str(mergecount)+" of "+ \

					str(totalcount)+") "+ \

					x[2]+" to "+x[1])

				emergelog(xterm_titles, " *** RESTARTING " + \

					"emerge via exec() after change of " + \

					"portage version.")

				portage.run_exitfuncs()

				mynewargv=[sys.argv[0],"--resume"]

				resume_opts = self.myopts.copy()

				# For automatic resume, we need to prevent

				# any of bad_resume_opts from leaking in

				# via EMERGE_DEFAULT_OPTS.

				resume_opts["--ignore-default-opts"] = True

				for myopt, myarg in resume_opts.iteritems():

					if myopt not in bad_resume_opts:

						if myarg is True:

							mynewargv.append(myopt)

						else:

							mynewargv.append(myopt +"="+ myarg)

				# priority only needs to be adjusted on the first run

				os.environ["PORTAGE_NICENESS"] = "0"

				os.execv(mynewargv[0], mynewargv)

	def fork_one_emerge(self, x, mergecount, totalcount, mtimedb, favorites, mysysdict):

		xterm_titles = "notitles" not in self.settings.features

		myfeat = self.settings.features[:]

		ldpath_mtimes = mtimedb["ldpath"]

		myroot=x[1]

		pkg_key = x[2]

		pkg_cat = x[2].split("/")[0]

		pkg_pf = x[2].split("/")[1]

		pkgindex=2

		if x[0]=="blocks":

			pkgindex=3

		build_prefix=self.settings["PORTAGE_TMPDIR"]+"/portage"

		portage_util.ensure_dirs(build_prefix, uid=portage.portage_uid, gid=portage.portage_gid, mode=0775)

		logid_path = None

		null_log = 0

		if self.settings.get("PORT_LOGDIR", "") == "":

			while "PORT_LOGDIR" in self.settings:

				del self.settings["PORT_LOGDIR"]

		if "PORT_LOGDIR" in self.settings:

			port_logdir = self.settings["PORT_LOGDIR"]

		else:

			port_logdir = self.settings["ROOT"] + portage.DEF_LOGDIR

		try:

			portage_util.ensure_dirs(port_logdir, uid=portage.portage_uid,

						 gid=portage.portage_gid, mode=02770)

		except portage_exception.PortageException, e:

			writemsg("!!! %s\n" % str(e), noiselevel=-1)

			writemsg("!!! Permission issues with PORT_LOGDIR='%s'\n" % \

				self.settings["PORT_LOGDIR"], noiselevel=-1)

			writemsg("!!! Because 'parallel' feature is enabled, you won't get any logs.\n", noiselevel=-1)

			null_log = 1

		if not null_log:

			logid_path = os.path.join(build_prefix, ".logid.")+pkg_cat+"."+pkg_pf

			if not os.path.exists(logid_path):

				f = open(logid_path, "w")

				f.close()

				del f

			logid_time = time.strftime("%Y%m%d-%H%M%S",

				time.gmtime(os.stat(logid_path).st_mtime))

			logfile = os.path.join(port_logdir, "%s:%s:%s.log" % \

				(pkg_cat, pkg_pf, logid_time))

			del logid_time

		else:

			logfile = "/dev/null"

		if "--pretend" not in self.myopts and "--fetchonly" not in self.myopts:

			print ">>> Emerging (" + \

				colorize("MERGE_LIST_PROGRESS", str(mergecount)) + " of " + \

				colorize("MERGE_LIST_PROGRESS", str(totalcount)) + ") " + \

				colorize("GOOD", x[pkgindex]) + " to " + x[1]

			print ">>> Logfile in " + logfile

			emergelog(xterm_titles, " >>> emerge ("+\

				str(mergecount)+" of "+str(totalcount)+\

				") "+x[pkgindex]+" to "+x[1])

		# need to spawn a --nodeps emerge in a separate process.

		pkg="="+x[2]

		merge_env = os.environ.copy()

		merge_env["PORTAGE_INTERNAL_CALL"] = "1"

		merge_env["FEATURES"] = merge_env.get("FEATURES", "") + " notitles -parallel"

		merge_args = [sys.argv[0], "--nodeps", "--oneshot", "--nospinner", pkg]

		good_nodeps_opts = set(["--buildpkg", "--buildpkgonly", "--fetchonly", "--fetch-all-uri", "--getbinpkg",\

					"--usepkg", "--usepkgonly"])

		fd_pipes = None

		merge_logfd = None

		for myopt, myarg in self.myopts.iteritems():

			# don't clobber the logfile at the same time as parallel fetch is

			# all log of parallel fetch will go /var/log/emerge-fetch.log

			# so, just leave 0,1,2 alone.

			if "parallel-fetch" in myfeat and myopt == "--fetchonly":

				fd_pipes = {0:0, 1:1, 2:2}

			if myopt in good_nodeps_opts:

				if myarg is True:

					merge_args.append(myopt)

				else:

					merge_args.append(myopt +"="+ myarg)

		if not fd_pipes:

			merge_logfd = open(logfile, "w")

			# put in a start message. This also makes sure that this fd is pointing to a good file on disk

			# and hence will be used throughout the other spawns that will happen in the children.

			merge_logfd.write("Package "+x[pkgindex]+" started at "+time.ctime()+"\n\n")

			merge_logfd.flush()

			fd_pipes = {0:0, 1:merge_logfd.fileno(), 2:merge_logfd.fileno()}

			portage_util.apply_secpass_permissions(logfile, uid=portage.portage_uid, gid=portage.portage_gid, mode=0660)

		mypids = portage.portage_exec.spawn(merge_args, env=merge_env, fd_pipes=fd_pipes, returnpid=True)

		if merge_logfd:

			merge_logfd.close() # child has exclusive rights to it now.

		return mypids[0]

	def do_one_emerge(self, x, mergecount, totalcount, mtimedb, favorites, mysysdict):

		xterm_titles = "notitles" not in self.settings.features

		myfeat = self.settings.features[:]

		ldpath_mtimes = mtimedb["ldpath"]

		myroot=x[1]

		pkg_key = x[2]

		pkg_cat = x[2].split("/")[0]

		pkg_pf = x[2].split("/")[1]

		pkgindex=2

		if x[0]=="blocks":

			pkgindex=3

		if "--pretend" not in self.myopts and "--fetchonly" not in self.myopts:

			print "\n>>> Emerging (" + \

				colorize("MERGE_LIST_PROGRESS", str(mergecount)) + " of " + \

				colorize("MERGE_LIST_PROGRESS", str(totalcount)) + ") " + \

				colorize("GOOD", x[pkgindex]) + " to " + x[1]

			emergelog(xterm_titles, " >>> emerge ("+\

				str(mergecount)+" of "+str(totalcount)+\

				") "+x[pkgindex]+" to "+x[1])

		portdb = self.trees[myroot]["porttree"].dbapi

		bindb  = self.trees[myroot]["bintree"].dbapi

		vartree = self.trees[myroot]["vartree"]

		pkgsettings = self.pkgsettings[myroot]

		y = portdb.findname(pkg_key)

		pkgsettings["EMERGE_FROM"] = x[0]

		pkgsettings.backup_changes("EMERGE_FROM")

		pkgsettings.reset()

		#buildsyspkg: Check if we need to _force_ binary package creation

		issyspkg = ("buildsyspkg" in myfeat) \

				and x[0] != "blocks" \

				and mysysdict.has_key(portage.cpv_getkey(x[2])) \

				and "--buildpkg" not in self.myopts

		if x[0] in ["ebuild","blocks"]:

			if x[0] == "blocks" and "--fetchonly" not in self.myopts:

				raise Exception, "Merging a blocker"

			elif "--fetchonly" in self.myopts or \

				"--fetch-all-uri" in self.myopts:

				if "--fetch-all-uri" in self.myopts:

					retval = portage.doebuild(y, "fetch", myroot,

						pkgsettings, self.edebug,

						"--pretend" in self.myopts, fetchonly=1,

						fetchall=1, mydbapi=portdb, tree="porttree")

				else:

					retval = portage.doebuild(y, "fetch", myroot,

						pkgsettings, self.edebug,

						"--pretend" in self.myopts, fetchonly=1,

						mydbapi=portdb, tree="porttree")

				if (retval is None) or retval:

					print

					print "!!! Fetch for",y,"failed, continuing..."

					print

				return retval

			portage.doebuild_environment(y, "setup", myroot,

				pkgsettings, self.edebug, 1, portdb)

			catdir = os.path.dirname(pkgsettings["PORTAGE_BUILDDIR"])

			portage_util.ensure_dirs(os.path.dirname(catdir),

				uid=portage.portage_uid, gid=portage.portage_gid,

				mode=070, mask=0)

			builddir_lock = None

			catdir_lock = None

			try:

				catdir_lock = portage_locks.lockdir(catdir)

				portage_util.ensure_dirs(catdir,

					uid=portage.portage_uid, gid=portage.portage_gid,

					mode=070, mask=0)

				builddir_lock = portage_locks.lockdir(

					pkgsettings["PORTAGE_BUILDDIR"])

				try:

					portage_locks.unlockdir(catdir_lock)

				finally:

					catdir_lock = None

				msg = " === (%s of %s) Cleaning (%s::%s)" % \

					(mergecount, totalcount, pkg_key, y)

				short_msg = "emerge: (%s of %s) %s Clean" % \

					(mergecount, totalcount, pkg_key)

				emergelog(xterm_titles, msg, short_msg=short_msg)

				retval = portage.doebuild(y, "clean", myroot,

					pkgsettings, self.edebug, cleanup=1,

					mydbapi=portdb, tree="porttree")

				if retval != os.EX_OK:

					return retval

				if "--buildpkg" in self.myopts or issyspkg:

					if issyspkg:

						print ">>> This is a system package, " + \

							"let's pack a rescue tarball."

					msg = " === (%s of %s) Compiling/Packaging (%s::%s)" % \

						(mergecount, totalcount, pkg_key, y)

					short_msg = "emerge: (%s of %s) %s Compile" % \

						(mergecount, totalcount, pkg_key)

					emergelog(xterm_titles, msg, short_msg=short_msg)

					self.trees[myroot]["bintree"].prevent_collision(pkg_key)

					retval = portage.doebuild(y, "package", myroot,

						pkgsettings, self.edebug, mydbapi=portdb,

						tree="porttree")

					if retval != os.EX_OK:

						return retval

					bintree = self.trees[myroot]["bintree"]

					if bintree.populated:

						bintree.inject(pkg_key)

					if "--buildpkgonly" not in self.myopts:

						msg = " === (%s of %s) Merging (%s::%s)" % \

							(mergecount, totalcount, pkg_key, y)

						short_msg = "emerge: (%s of %s) %s Merge" % \

							(mergecount, totalcount, pkg_key)

						emergelog(xterm_titles, msg, short_msg=short_msg)

						retval = portage.merge(pkgsettings["CATEGORY"],

							pkgsettings["PF"], pkgsettings["D"],

							os.path.join(pkgsettings["PORTAGE_BUILDDIR"],

							"build-info"), myroot, pkgsettings,

							myebuild=pkgsettings["EBUILD"],

							mytree="porttree", mydbapi=portdb,

							vartree=vartree, prev_mtimes=ldpath_mtimes)

						if retval != os.EX_OK:

							return retval

					elif "noclean" not in pkgsettings.features:

						portage.doebuild(y, "clean", myroot,

							pkgsettings, self.edebug, mydbapi=portdb,

							tree="porttree")

				else:

					msg = " === (%s of %s) Compiling/Merging (%s::%s)" % \

						(mergecount, totalcount, pkg_key, y)

					short_msg = "emerge: (%s of %s) %s Compile" % \

						(mergecount, totalcount, pkg_key)

					emergelog(xterm_titles, msg, short_msg=short_msg)

					retval = portage.doebuild(y, "merge", myroot,

						pkgsettings, self.edebug, vartree=vartree,

						mydbapi=portdb, tree="porttree",

						prev_mtimes=ldpath_mtimes)

					if retval != os.EX_OK:

						return retval

			finally:

				if builddir_lock:

					portage_locks.unlockdir(builddir_lock)

				try:

					if not catdir_lock:

						# Lock catdir for removal if empty.

						catdir_lock = portage_locks.lockdir(catdir)

				finally:

					if catdir_lock:

						try:

							os.rmdir(catdir)

						except OSError, e:

							if e.errno not in (errno.ENOENT,

								errno.ENOTEMPTY, errno.EEXIST):

								raise

							del e

						portage_locks.unlockdir(catdir_lock)

		elif x[0]=="binary":

			#merge the tbz2

			mytbz2 = self.trees[myroot]["bintree"].getname(pkg_key)

			if "--getbinpkg" in self.myopts:

				tbz2_lock = None

				try:

					if "distlocks" in pkgsettings.features and \

						os.access(pkgsettings["PKGDIR"], os.W_OK):

						portage_util.ensure_dirs(os.path.dirname(mytbz2))

						tbz2_lock = portage_locks.lockfile(mytbz2,

							wantnewlockfile=1)

					if self.trees[myroot]["bintree"].isremote(pkg_key):

						msg = " --- (%s of %s) Fetching Binary (%s::%s)" %\

							(mergecount, totalcount, pkg_key, mytbz2)

						short_msg = "emerge: (%s of %s) %s Fetch" % \

							(mergecount, totalcount, pkg_key)

						emergelog(xterm_titles, msg, short_msg=short_msg)

						if not self.trees[myroot]["bintree"].gettbz2(

							pkg_key):

							return 1

				finally:

					if tbz2_lock:

						portage_locks.unlockfile(tbz2_lock)

			if "--fetchonly" in self.myopts or \

				"--fetch-all-uri" in self.myopts:

				return os.EX_OK

			short_msg = "emerge: ("+str(mergecount)+" of "+str(totalcount)+") "+x[pkgindex]+" Merge Binary"

			emergelog(xterm_titles, " === ("+str(mergecount)+\

				" of "+str(totalcount)+") Merging Binary ("+\

				x[pkgindex]+"::"+mytbz2+")", short_msg=short_msg)

			retval = portage.pkgmerge(mytbz2, x[1], pkgsettings,

				mydbapi=bindb,

				vartree=self.trees[myroot]["vartree"],

				prev_mtimes=ldpath_mtimes)

			if retval != os.EX_OK:

				return retval

			#need to check for errors

		# clean up the older version which emerged on top of

		if "--buildpkgonly" not in self.myopts and \

			"--pretend" not in self.myopts and \

			"--fetchonly" not in self.myopts and \

			"--fetch-all-uri" not in self.myopts:

			# Clean the old package that we have merged over top of it.

			if pkgsettings.get("AUTOCLEAN", "yes") == "yes":

				xsplit=portage.pkgsplit(x[2])

				emergelog(xterm_titles, " >>> AUTOCLEAN: " + xsplit[0])

				retval = unmerge(pkgsettings, self.myopts, vartree,

					"clean", [xsplit[0]], ldpath_mtimes, autoclean=1)

				if not retval:

					emergelog(xterm_titles,

						" --- AUTOCLEAN: Nothing unmerged.")

			else:

				portage.writemsg_stdout(colorize("WARN", "WARNING:")

					+ " AUTOCLEAN is disabled.  This can cause serious"

					+ " problems due to overlapping packages.\n")

		if "--pretend" not in self.myopts and \

			"--fetchonly" not in self.myopts and \

			"--fetch-all-uri" not in self.myopts:

			if "noclean" not in self.settings.features:

				short_msg = "emerge: (%s of %s) %s Clean Post" % \

					(mergecount, totalcount, x[pkgindex])

				emergelog(xterm_titles, (" === (%s of %s) " + \

					"Post-Build Cleaning (%s::%s)") % \

					(mergecount, totalcount, x[pkgindex], y),

					short_msg=short_msg)

			emergelog(xterm_titles, " ::: completed emerge ("+\

				str(mergecount)+" of "+str(totalcount)+") "+\

				x[2]+" to "+x[1])

		return os.EX_OK

	def add_one_emerge_to_world(self, x, mergecount, totalcount, favorites, mysysdict):

		xterm_titles = "notitles" not in self.settings.features

		pkgindex=2

		if x[0]=="blocks":

			pkgindex=3

		if "--buildpkgonly" not in self.myopts:

			self.trees[x[1]]["vartree"].inject(x[2])

			myfavkey=portage.cpv_getkey(x[2])

			if "--fetchonly" not in self.myopts and \

				"--fetch-all-uri" not in self.myopts and \

				myfavkey in favorites:

				myfavs = portage.grabfile(os.path.join(x[1], portage.WORLD_FILE))

				myfavdict=genericdict(myfavs)

				#don't record if already in system profile or already recorded

				if (not mysysdict.has_key(myfavkey)) and (not myfavdict.has_key(myfavkey)):

					#we don't have a favorites entry for this package yet; add one

					myfavdict[myfavkey]=myfavkey

					print ">>> Recording",myfavkey,"in \"world\" favorites file..."

					emergelog(xterm_titles, " === ("+\

						str(mergecount)+" of "+\

						str(totalcount)+\

						") Updating world file ("+x[pkgindex]+")")

					portage.write_atomic(

					os.path.join(x[1], portage.WORLD_FILE),

					"\n".join(myfavdict.values()))

	def print_status(self, totalcount, donec, qsize, failedc, spawnd_pkg, failed):

		smsg = ""

		fmsg = ""

		if spawnd_pkg:

			for pkgs in spawnd_pkg.values():

				smsg = smsg+" "+pkgs[0][2]

		if failed:

			for pkgs in failed:

				fmsg = fmsg+" "+pkgs

		print ">>> Jobs [Total = "+colorize("blue", str(totalcount))+"] [Done = "+\

			colorize("GOOD", str(donec))+"] [Running = "+colorize("WARN", str(qsize)+smsg)+\

			"] [Failed = "+colorize("BAD", str(failedc)+fmsg)+"]"

		xtermTitle("Jobs [Total="+str(totalcount)+"] [Done="+str(donec)+"] [Running="+str(qsize)+"] [Failed="+str(failedc)+"]")

	def wait_one_emerge(self, spawnd_pids, spawnd_pkg, mergecount, totalcount, mymergelist, mtimedb):

		build_prefix=self.settings["PORTAGE_TMPDIR"]+"/portage"

		# let's wait for one of the jobs to finish

		onepid = -1

		while onepid not in spawnd_pids:

			onepid , retval = os.waitpid(-1, 0)

		spawnd_pids.remove(onepid)

		pkg_compl = spawnd_pkg[onepid][0]

		pkg_slot = spawnd_pkg[onepid][1]

		del spawnd_pkg[onepid]

		if not retval:

			# unlink the logid_path

			logid_path = os.path.join(build_prefix, ".logid.")+pkg_compl[2].split("/")[0]+"."+pkg_compl[2].split("/")[1]

			if os.path.exists(logid_path):

				os.unlink(logid_path)

			index = 0

			print ">>> Package "+colorize("GOOD", pkg_compl[2])+" finished emerging."

			# we need to remove this pkg from resume DB

			# this is the dirtiest shit I have ever written

			for pkgs in mymergelist:

				if pkgs[2] == pkg_compl[2]:

					if len(mymergelist) > 1:

						del mtimedb["resume"]["mergelist"][index]

						mtimedb.commit()

					del mymergelist[index]

					# check if we need to restart portage

					mysplit=portage.pkgsplit(pkg_compl[2])

					if mysplit[0] == "sys-apps/portage" and pkgs[1] == "/":

						self.restart_portage(pkgs, mergecount, totalcount, mtimedb)

					break

				index += 1

		return (retval, pkg_compl)

	def merge(self, mylist, favorites, mtimedb, m_slots):

				mytype, myroot, mycpv, mystatus = x

				mytype, myroot, mycpv, mystatus, slott = x

			mtimedb["resume"]["mergelist"]=mymergelist[:]

			if "--nodeps" not in self.myopts or len(mymergelist) > 1:

			mtimedb.commit()

				mtimedb["resume"]["mergelist"]=mymergelist[:]

				mtimedb.commit()

		totalcount = len(mymergelist)

		mergecount=1

		if "--resume" in self.myopts and "--fetchonly" not in self.myopts:

			# We're resuming.

			print colorize("GOOD", "*** Resuming merge...")

			emergelog(xterm_titles, " *** Resuming merge...")

				fd_pipes = {1:logfile.fileno(), 2:logfile.fileno()}

				fd_pipes = {0:0, 1:logfile.fileno(), 2:logfile.fileno()}

				fetch_env["FEATURES"] = fetch_env.get("FEATURES", "") + " -cvs"

				fetch_env["FEATURES"] = fetch_env.get("FEATURES", "") + " -cvs -parallel"

		mergecount=0

		if not parallel:

		for x in mymergelist:

			failed_fetches = []

			mergecount+=1

			for x in mymergelist:

			myroot=x[1]

				retcode = self.do_one_emerge(x, mergecount, totalcount, mtimedb, favorites, mysysdict)

			pkg_key = x[2]

				mergecount += 1

			pkgindex=2

			portdb = self.trees[myroot]["porttree"].dbapi

				# need to short circuit the spawn with --nodeps

			bindb  = self.trees[myroot]["bintree"].dbapi

				if os.environ.get("PORTAGE_INTERNAL_CALL", "0") != "1":

			vartree = self.trees[myroot]["vartree"]

					if "--fetchonly" in self.myopts or "--fetch-all-uri" in self.myopts:

			pkgsettings = self.pkgsettings[myroot]

						continue

			if x[0]=="blocks":

					if retcode != os.EX_OK:

				pkgindex=3

						if "--fetchonly" in self.myopts or "--fetch-all-uri" in self.myopts:

			y = portdb.findname(pkg_key)

							failed_fetches.append(x[2])

							continue

						else:

							return retcode

					# Unsafe for parallel merges

					del mtimedb["resume"]["mergelist"][0]

					# Commit after each merge so that --resume may still work in

					# in the event that portage is not allowed to exit normally

					# due to power failure, SIGKILL, etc...

					mtimedb.commit()

					# unlink the logid_path if any exists

					logid_path = os.path.join(build_prefix, ".logid.")+x[2].split("/")[0]+"."+x[2].split("/")[1]

					if os.path.exists(logid_path):

						os.unlink(logid_path)

					del logid_path

					# check if we need to restart portage

					mysplit=portage.pkgsplit(x[2])

					if mysplit[0] == "sys-apps/portage" and x[1] == "/":

							self.restart_portage(x, mergecount, totalcount, mtimedb)

				else:

					if retcode != os.EX_OK:

						sys.exit(1)

  					else:

						sys.exit(0)

				print "\n>>> Emerging (" + \

				emergelog(xterm_titles, " *** Finished. Cleaning up...")

					colorize("MERGE_LIST_PROGRESS", str(mergecount)) + " of " + \

					colorize("MERGE_LIST_PROGRESS", str(len(mymergelist))) + ") " + \

			# We're out of the loop... We're done. Delete the resume data.

					colorize("GOOD", x[pkgindex]) + " to " + x[1]

			if mtimedb.has_key("resume"):

				emergelog(xterm_titles, " >>> emerge ("+\

				del mtimedb["resume"]

					str(mergecount)+" of "+str(len(mymergelist))+\

			mtimedb.commit()

					") "+x[pkgindex]+" to "+x[1])

			#by doing an exit this way, --fetchonly can continue to try to

			pkgsettings["EMERGE_FROM"] = x[0]

			#fetch everything even if a particular download fails.

			pkgsettings.backup_changes("EMERGE_FROM")

			if "--fetchonly" in self.myopts or "--fetch-all-uri" in self.myopts:

			pkgsettings.reset()

				if failed_fetches:

					sys.stderr.write("\n\n!!! Some fetch errors were " + \

			#buildsyspkg: Check if we need to _force_ binary package creation

						"encountered.  Please see above for details.\n\n")

			issyspkg = ("buildsyspkg" in myfeat) \

					for cpv in failed_fetches:

					and x[0] != "blocks" \

						sys.stderr.write("   ")

					and mysysdict.has_key(portage.cpv_getkey(x[2])) \

						sys.stderr.write(cpv)

					and "--buildpkg" not in self.myopts

						sys.stderr.write("\n")

			if x[0] in ["ebuild","blocks"]:

					sys.stderr.write("\n")

				if x[0] == "blocks" and "--fetchonly" not in self.myopts:

					sys.exit(1)

					raise Exception, "Merging a blocker"

				else:

				elif "--fetchonly" in self.myopts or \

					sys.exit(0)

					"--fetch-all-uri" in self.myopts:

			return os.EX_OK

					if "--fetch-all-uri" in self.myopts:

						retval = portage.doebuild(y, "fetch", myroot,

		# parallel code - dirty starts here...;-)

							pkgsettings, self.edebug,

		one_in_slot_failed=0

							"--pretend" in self.myopts, fetchonly=1,

		spawnd_pids=[]

							fetchall=1, mydbapi=portdb, tree="porttree")

					else:

		# dirty little trick to get number of cpus from the system

						retval = portage.doebuild(y, "fetch", myroot,

		fd_cpuinfo = os.popen("cat /proc/cpuinfo","r")

							pkgsettings, self.edebug,

		cpu_count = 0

							"--pretend" in self.myopts, fetchonly=1,

		for data_cpuinfo in fd_cpuinfo.readlines():

							mydbapi=portdb, tree="porttree")

			if data_cpuinfo.find("cpu MHz") > -1 :

					if (retval is None) or retval:

				cpu_count += 1

						print

		fd_cpuinfo.close()

						print "!!! Fetch for",y,"failed, continuing..."

						print

		# if someone really screwed with /proc/cpuinfo output, we should not suffer

						failed_fetches.append(pkg_key)

		if cpu_count == 0:

					continue

			cpu_count = 1

				portage.doebuild_environment(y, "setup", myroot,

		spawnd_pkg = {}

					pkgsettings, self.edebug, 1, portdb)

		donec = 0

				catdir = os.path.dirname(pkgsettings["PORTAGE_BUILDDIR"])

		failedc = 0

				portage_util.ensure_dirs(os.path.dirname(catdir),

		failedPkgs = []

					uid=portage.portage_uid, gid=portage.portage_gid,

		logid_path = None

					mode=070, mask=0)

		mylist = m_slots.keys()

				builddir_lock = None

		mylist.sort()

				catdir_lock = None

		for x in mylist:

				try:

			# if slot is empty, go on

					catdir_lock = portage_locks.lockdir(catdir)

			if not m_slots[x]:

					portage_util.ensure_dirs(catdir,

				continue

						uid=portage.portage_uid, gid=portage.portage_gid,

						mode=070, mask=0)

					builddir_lock = portage_locks.lockdir(

						pkgsettings["PORTAGE_BUILDDIR"])

					try:

						portage_locks.unlockdir(catdir_lock)

					finally:

						catdir_lock = None

					msg = " === (%s of %s) Cleaning (%s::%s)" % \

						(mergecount, len(mymergelist), pkg_key, y)

					short_msg = "emerge: (%s of %s) %s Clean" % \

						(mergecount, len(mymergelist), pkg_key)

					emergelog(xterm_titles, msg, short_msg=short_msg)

					retval = portage.doebuild(y, "clean", myroot,

						pkgsettings, self.edebug, cleanup=1,

						mydbapi=portdb, tree="porttree")

					if retval != os.EX_OK:

						return retval

					if "--buildpkg" in self.myopts or issyspkg:

						if issyspkg:

							print ">>> This is a system package, " + \

								"let's pack a rescue tarball."

						msg = " === (%s of %s) Compiling/Packaging (%s::%s)" % \

							(mergecount, len(mymergelist), pkg_key, y)

						short_msg = "emerge: (%s of %s) %s Compile" % \

							(mergecount, len(mymergelist), pkg_key)

						emergelog(xterm_titles, msg, short_msg=short_msg)

						self.trees[myroot]["bintree"].prevent_collision(pkg_key)

						retval = portage.doebuild(y, "package", myroot,

							pkgsettings, self.edebug, mydbapi=portdb,

							tree="porttree")

						if retval != os.EX_OK:

							return retval

						bintree = self.trees[myroot]["bintree"]

						if bintree.populated:

							bintree.inject(pkg_key)

						if "--buildpkgonly" not in self.myopts:

							msg = " === (%s of %s) Merging (%s::%s)" % \

								(mergecount, len(mymergelist), pkg_key, y)

							short_msg = "emerge: (%s of %s) %s Merge" % \

								(mergecount, len(mymergelist), pkg_key)

							emergelog(xterm_titles, msg, short_msg=short_msg)

							retval = portage.merge(pkgsettings["CATEGORY"],

								pkgsettings["PF"], pkgsettings["D"],

								os.path.join(pkgsettings["PORTAGE_BUILDDIR"],

								"build-info"), myroot, pkgsettings,

								myebuild=pkgsettings["EBUILD"],

								mytree="porttree", mydbapi=portdb,

								vartree=vartree, prev_mtimes=ldpath_mtimes)

							if retval != os.EX_OK:

								return retval

						elif "noclean" not in pkgsettings.features:

							portage.doebuild(y, "clean", myroot,

								pkgsettings, self.edebug, mydbapi=portdb,

								tree="porttree")

					else:

						msg = " === (%s of %s) Compiling/Merging (%s::%s)" % \

							(mergecount, len(mymergelist), pkg_key, y)

						short_msg = "emerge: (%s of %s) %s Compile" % \

							(mergecount, len(mymergelist), pkg_key)

						emergelog(xterm_titles, msg, short_msg=short_msg)

						retval = portage.doebuild(y, "merge", myroot,

							pkgsettings, self.edebug, vartree=vartree,

							mydbapi=portdb, tree="porttree",

							prev_mtimes=ldpath_mtimes)

						if retval != os.EX_OK:

							return retval

				finally:

					if builddir_lock:

						portage_locks.unlockdir(builddir_lock)

					try:

						if not catdir_lock:

							# Lock catdir for removal if empty.

							catdir_lock = portage_locks.lockdir(catdir)

					finally:

						if catdir_lock:

							try:

								os.rmdir(catdir)

							except OSError, e:

								if e.errno not in (errno.ENOENT,

									errno.ENOTEMPTY, errno.EEXIST):

									raise

								del e

							portage_locks.unlockdir(catdir_lock)

			elif x[0]=="binary":

				#merge the tbz2

				mytbz2 = self.trees[myroot]["bintree"].getname(pkg_key)

				if "--getbinpkg" in self.myopts:

					tbz2_lock = None

					try:

						if "distlocks" in pkgsettings.features and \

							os.access(pkgsettings["PKGDIR"], os.W_OK):

							portage_util.ensure_dirs(os.path.dirname(mytbz2))

							tbz2_lock = portage_locks.lockfile(mytbz2,

								wantnewlockfile=1)

						if self.trees[myroot]["bintree"].isremote(pkg_key):

							msg = " --- (%s of %s) Fetching Binary (%s::%s)" %\

								(mergecount, len(mymergelist), pkg_key, mytbz2)

							short_msg = "emerge: (%s of %s) %s Fetch" % \

								(mergecount, len(mymergelist), pkg_key)

							emergelog(xterm_titles, msg, short_msg=short_msg)

							if not self.trees[myroot]["bintree"].gettbz2(

								pkg_key):

								return 1

					finally:

						if tbz2_lock:

							portage_locks.unlockfile(tbz2_lock)

				if "--fetchonly" in self.myopts or \

					"--fetch-all-uri" in self.myopts:

					continue

				short_msg = "emerge: ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" Merge Binary"

			# if previous slot failed, discontinue the emerge

				emergelog(xterm_titles, " === ("+str(mergecount)+\

			if one_in_slot_failed and not ("--fetchonly" in self.myopts or "--fetch-all-uri" in self.myopts):

					" of "+str(len(mymergelist))+") Merging Binary ("+\

				break

					x[pkgindex]+"::"+mytbz2+")", short_msg=short_msg)

				retval = portage.pkgmerge(mytbz2, x[1], pkgsettings,

					mydbapi=bindb,

					vartree=self.trees[myroot]["vartree"],

					prev_mtimes=ldpath_mtimes)

				if retval != os.EX_OK:

					return retval

				#need to check for errors

			if "--buildpkgonly" not in self.myopts:

				self.trees[x[1]]["vartree"].inject(x[2])

				myfavkey=portage.cpv_getkey(x[2])

				if "--fetchonly" not in self.myopts and \

					"--fetch-all-uri" not in self.myopts and \

					myfavkey in favorites:

					myfavs = portage.grabfile(os.path.join(myroot, portage.WORLD_FILE))

					myfavdict=genericdict(myfavs)

					#don't record if already in system profile or already recorded

					if (not mysysdict.has_key(myfavkey)) and (not myfavdict.has_key(myfavkey)):

						#we don't have a favorites entry for this package yet; add one

						myfavdict[myfavkey]=myfavkey

						print ">>> Recording",myfavkey,"in \"world\" favorites file..."

						emergelog(xterm_titles, " === ("+\

							str(mergecount)+" of "+\

							str(len(mymergelist))+\

							") Updating world file ("+x[pkgindex]+")")

						portage.write_atomic(

						os.path.join(myroot, portage.WORLD_FILE),

						"\n".join(myfavdict.values()))

				if "--pretend" not in self.myopts and \

					"--fetchonly" not in self.myopts and \

					"--fetch-all-uri" not in self.myopts:

					# Clean the old package that we have merged over top of it.

					if pkgsettings.get("AUTOCLEAN", "yes") == "yes":

						xsplit=portage.pkgsplit(x[2])

						emergelog(xterm_titles, " >>> AUTOCLEAN: " + xsplit[0])

						retval = unmerge(pkgsettings, self.myopts, vartree,

							"clean", [xsplit[0]], ldpath_mtimes, autoclean=1)

						if not retval:

							emergelog(xterm_titles,

								" --- AUTOCLEAN: Nothing unmerged.")

					else:

						portage.writemsg_stdout(colorize("WARN", "WARNING:")

							+ " AUTOCLEAN is disabled.  This can cause serious"

							+ " problems due to overlapping packages.\n")

					# Figure out if we need a restart.

			# start multiple merges in parallel mode

					mysplit=portage.pkgsplit(x[2])

			num_at_atime = cpu_count + 1

					if mysplit[0] == "sys-apps/portage" and x[1] == "/":

						myver=mysplit[1]+"-"+mysplit[2]

						if myver[-3:]=='-r0':

							myver=myver[:-3]

						if (myver != portage.VERSION) and \

						   "livecvsportage" not in self.settings.features:

							if len(mymergelist) > mergecount:

								emergelog(xterm_titles,

									" ::: completed emerge ("+ \

									str(mergecount)+" of "+ \

									str(len(mymergelist))+") "+ \

									x[2]+" to "+x[1])

								emergelog(xterm_titles, " *** RESTARTING " + \

									"emerge via exec() after change of " + \

									"portage version.")

								del mtimedb["resume"]["mergelist"][0]

								mtimedb.commit()

								portage.run_exitfuncs()

								mynewargv=[sys.argv[0],"--resume"]

								resume_opts = self.myopts.copy()

								# For automatic resume, we need to prevent

								# any of bad_resume_opts from leaking in

								# via EMERGE_DEFAULT_OPTS.

								resume_opts["--ignore-default-opts"] = True

								for myopt, myarg in resume_opts.iteritems():

									if myopt not in bad_resume_opts:

										if myarg is True:

											mynewargv.append(myopt)

										else:

											mynewargv.append(myopt +"="+ myarg)

								# priority only needs to be adjusted on the first run

								os.environ["PORTAGE_NICENESS"] = "0"

								os.execv(mynewargv[0], mynewargv)

			if "--pretend" not in self.myopts and \

				"--fetchonly" not in self.myopts and \

				"--fetch-all-uri" not in self.myopts:

				if "noclean" not in self.settings.features:

					short_msg = "emerge: (%s of %s) %s Clean Post" % \

						(mergecount, len(mymergelist), x[pkgindex])

					emergelog(xterm_titles, (" === (%s of %s) " + \

						"Post-Build Cleaning (%s::%s)") % \

						(mergecount, len(mymergelist), x[pkgindex], y),

						short_msg=short_msg)

				emergelog(xterm_titles, " ::: completed emerge ("+\

					str(mergecount)+" of "+str(len(mymergelist))+") "+\

					x[2]+" to "+x[1])

			# Unsafe for parallel merges

			qsize = 0

			del mtimedb["resume"]["mergelist"][0]

			for y in m_slots[x]:

			# Commit after each merge so that --resume may still work in

				# these all can go in parallel, so fork one after the other

			# in the event that portage is not allowed to exit normally

				# but num_at_atime at most

			# due to power failure, SIGKILL, etc...

				if num_at_atime:

			mtimedb.commit()

					onepid = self.fork_one_emerge(y, mergecount, totalcount, mtimedb, favorites, mysysdict)

					spawnd_pids.append(onepid)

					spawnd_pkg[onepid] = (y, x)

					num_at_atime -= 1

					mergecount += 1

					qsize += 1

				else:

					self.print_status(totalcount, donec, qsize, failedc, spawnd_pkg, failedPkgs)

					# let's wait for one of the jobs to finish

					(retval, pkg_compl) = self.wait_one_emerge(spawnd_pids, spawnd_pkg, mergecount, totalcount, mymergelist, mtimedb)

					# if it failed, I need to fail next slot but continue to merge all in this slot

					if retval:

						one_in_slot_failed = retval

						failedc += 1

						failedPkgs.append(pkg_compl[2])

  					else:

						donec += 1

						self.add_one_emerge_to_world(pkg_compl, mergecount, totalcount, favorites, mysysdict)

					onepid = self.fork_one_emerge(y, mergecount, totalcount, mtimedb, favorites, mysysdict)

					spawnd_pids.append(onepid)

					spawnd_pkg[onepid] = (y, x)

					mergecount += 1

			# this slot is exhausted, so wait for all of the forks to finish

			while spawnd_pids:

				self.print_status(totalcount, donec, qsize, failedc, spawnd_pkg, failedPkgs)

				# let's wait for one of the jobs to finish

				(retval, pkg_compl) = self.wait_one_emerge(spawnd_pids, spawnd_pkg, mergecount, totalcount, mymergelist, mtimedb)

				qsize -= 1

				if retval:

					one_in_slot_failed = retval

					failedc += 1

					failedPkgs.append(pkg_compl[2])

				else:

					donec += 1

					self.add_one_emerge_to_world(pkg_compl, mergecount, totalcount, favorites, mysysdict)

		if totalcount:

			self.print_status(totalcount, donec, qsize, failedc, None, failedPkgs)

		if one_in_slot_failed:

			portage.writemsg_stdout(red("\nSome packages failed to emerge, summary follows:\n"))

		for pkgs in failedPkgs:

			if "--fetchonly" in self.myopts or "--fetch-all-uri" in self.myopts:

				print "\n\n!!! Some fetch errors were encountered.  Please see above for details.\n\n"

				sys.exit(1)

			if failed_fetches:

			sys.exit(0)

				sys.stderr.write("\n\n!!! Some fetch errors were " + \

					"encountered.  Please see above for details.\n\n")

				for cpv in failed_fetches:

					sys.stderr.write("   ")

					sys.stderr.write(cpv)

					sys.stderr.write("\n")

				sys.stderr.write("\n")

				sys.exit(1)

			else:

				sys.exit(0)

	for (pkg_type, myroot, pkg_key, action) in mergelist:

	for (pkg_type, myroot, pkg_key, action, merge_slot) in mergelist:

	if "--quiet" not in myopts:

	if "--quiet" not in myopts and "--nodeps" not in myopts:

			mydepgraph.display(

			mymergelist = mydepgraph.altlist(reversed=("--tree" in myopts))

				mydepgraph.altlist(reversed=("--tree" in myopts)))

			mergelist_to_merge_slot(mymergelist, myopts, True, "parallel" in settings.features)

			mydepgraph.display(mymergelist)

			for x in mydepgraph.altlist():

			for x in mymergelist:

			mydepgraph.display(

			# mydepgraph.digraph.debug_print()

				mydepgraph.altlist(reversed=("--tree" in myopts)))

			mymergelist = mydepgraph.altlist(reversed=("--tree" in myopts))

			mergelist_to_merge_slot(mymergelist, myopts, True, "parallel" in settings.features)

			mydepgraph.display(mymergelist)

			retval = mergetask.merge(

			retval = mergetask.merge(mymergelist, favorites, mtimedb, merge_slots)

				mtimedb["resume"]["mergelist"], favorites, mtimedb)

			if "resume" in mtimedb and \

			mymergelist = mydepgraph.altlist()

			"mergelist" in mtimedb["resume"] and \

			merge_slots = mergelist_to_merge_slot(mymergelist, myopts, False, False)

			len(mtimedb["resume"]["mergelist"]) > 1:

			if "--nodeps" not in myopts or len(mymergelist) > 1:

				mtimedb["resume_backup"] = mtimedb["resume"]

				if "resume" in mtimedb and \

				del mtimedb["resume"]

				"mergelist" in mtimedb["resume"] and \

				mtimedb.commit()

				len(mtimedb["resume"]["mergelist"]) > 1:

			mtimedb["resume"]={}

					mtimedb["resume_backup"] = mtimedb["resume"]

			# XXX: Stored as a list for backward compatibility.

					del mtimedb["resume"]

			mtimedb["resume"]["myopts"] = \

					mtimedb.commit()

				[k for k in myopts if myopts[k] is True]

				mtimedb["resume"]={}

			mtimedb["resume"]["favorites"]=favorites

				# XXX: Stored as a list for backward compatibility.

				mtimedb["resume"]["myopts"] = \

					[k for k in myopts if myopts[k] is True]

				mtimedb["resume"]["favorites"]=favorites

				for pkg in mydepgraph.altlist():

				for pkg in mymergelist:

				pkglist = mydepgraph.altlist()

				pkglist = mymergelist

			retval = mergetask.merge(pkglist, favorites, mtimedb)

			retval = mergetask.merge(pkglist, favorites, mtimedb, merge_slots)

		if mtimedb.has_key("resume"):

		if mtimedb.has_key("resume") and ("--nodeps" not in myopts or len(mymergelist) > 1):

	from portage_const import VDB_PATH, PRIVATE_PATH, CACHE_PATH, DEPCACHE_PATH, \

	from portage_const import VDB_PATH, PRIVATE_PATH, DEF_LOGDIR, CACHE_PATH, DEPCACHE_PATH, \

		del keywords["logfile"]

		tee_good = 1

		pr, pw = os.pipe()

		try:

		mypids.extend(portage_exec.spawn(('tee', '-i', '-a', logfile),

			statinfo1 = os.stat(logfile)

			 returnpid=True, fd_pipes={0:pr, 1:fd_pipes[1], 2:fd_pipes[2]}))

			statinfo2 = os.fstat(fd_pipes[1])

		os.close(pr)

			statinfo3 = os.fstat(fd_pipes[2])

		fd_pipes[1] = pw

			# if they are pointing to same file as logfile, no 'tee' is required.

		fd_pipes[2] = pw

			if statinfo1 == statinfo2 and statinfo2 == statinfo3:

		keywords["fd_pipes"] = fd_pipes

				tee_good = 0

		except:

			tee_good = 1

		if tee_good:

			del keywords["logfile"]

			pr, pw = os.pipe()

			mypids.extend(portage_exec.spawn(('tee', '-i', '-a', logfile),

			 	returnpid=True, fd_pipes={0:pr, 1:fd_pipes[1], 2:fd_pipes[2]}))

			os.close(pr)

			fd_pipes[1] = pw

			fd_pipes[2] = pw

			keywords["fd_pipes"] = fd_pipes

		logid_path = os.path.join(mysettings["PORTAGE_BUILDDIR"], ".logid")

		logid_path = os.path.join(mysettings["BUILD_PREFIX"], ".logid.")+mysettings["CATEGORY"]+"."+ mysettings["PF"]

		# Create a pipe

		tee_good = 1

		(pr, pw) = os.pipe()

		try:

			statinfo1 = os.stat(logfile)

		# Create a tee process, giving it our stdout and stderr

			statinfo2 = os.fstat(fd_pipes[1])

		# as well as the read end of the pipe.

			statinfo3 = os.fstat(fd_pipes[2])

		mypids.extend(spawn(('tee', '-i', '-a', logfile),

			# if they are pointing to same file as logfile, no 'tee' is required.

		              returnpid=True, fd_pipes={0:pr,

			if statinfo1 == statinfo2 and statinfo2 == statinfo3:

		              1:fd_pipes[1], 2:fd_pipes[2]}))

				tee_good = 0

		except:

		# We don't need the read end of the pipe, so close it.

			tee_good = 1

		os.close(pr)

		if tee_good:

		# Assign the write end of the pipe to our stdout and stderr.

		fd_pipes[1] = pw

			# Create a pipe

		fd_pipes[2] = pw

			(pr, pw) = os.pipe()

			# Create a tee process, giving it our stdout and stderr

			# as well as the read end of the pipe.

			mypids.extend(spawn(('tee', '-i', '-a', logfile),

					returnpid=True, fd_pipes={0:pr,

					1:fd_pipes[1], 2:fd_pipes[2]}))

			# We don't need the read end of the pipe, so close it.

			os.close(pr)

			# Assign the write end of the pipe to our stdout and stderr.

			fd_pipes[1] = pw

			fd_pipes[2] = pw

	if logfile:

	if logfile and pw: