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":

				block_parents = self.blocker_parents[tuple(x)]

				block_parents = self.blocker_parents[pkg_node]

			if len(x) != 4:

			if len(x) != 5:

			pkg_type, myroot, pkg_key, action = x

			pkg_type, myroot, pkg_key, action, slott = x

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

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

			return self._merge(mylist, favorites, mtimedb)

			return self._merge(mylist, favorites, mtimedb, m_slots)

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

	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

				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:

			pkg_type = x[0]

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

			myroot=x[1]

				mergecount += 1

			pkg_key = x[2]

			pkgindex=2

				# need to short circuit the spawn with --nodeps

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

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

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

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

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

						continue

			pkgsettings = self.pkgsettings[myroot]

					if retcode != os.EX_OK:

			metadata = {}

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

			if pkg_type == "blocks":

							failed_fetches.append(x[2])

				pass

							continue

			elif pkg_type == "ebuild":

						else:

				mydbapi = portdb

							return retcode

				metadata.update(izip(metadata_keys,

					# Unsafe for parallel merges

					mydbapi.aux_get(pkg_key, metadata_keys)))

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

				pkgsettings.setcpv(pkg_key, mydb=mydbapi)

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

				metadata["USE"] = pkgsettings["USE"]

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

			else:

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

				if pkg_type == "binary":

					mtimedb.commit()

					mydbapi = bindb

					self.curval += 1

					self._poll_child_processes()

					# 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)

					raise AssertionError("Package type: '%s'" % pkg_type)

					if retcode != os.EX_OK:

				metadata.update(izip(metadata_keys,

						sys.exit(1)

					mydbapi.aux_get(pkg_key, metadata_keys)))

  					else:

			if x[0]=="blocks":

						sys.exit(0)

				pkgindex=3

			y = portdb.findname(pkg_key)

				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

			#fetch everything even if a particular download fails.

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

				if failed_fetches:

					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)

			return os.EX_OK

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

		one_in_slot_failed=0

		spawnd_pids=[]

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

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

		cpu_count = 0

		for data_cpuinfo in fd_cpuinfo.readlines():

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

				cpu_count += 1

		fd_cpuinfo.close()

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

		if cpu_count == 0:

			cpu_count = 1

		spawnd_pkg = {}

		donec = 0

		failedc = 0

		failedPkgs = []

		logid_path = None

		mylist = m_slots.keys()

		mylist.sort()

		for x in mylist:

			# if slot is empty, go on

			if not m_slots[x]:

				continue

			pkgsettings["EMERGE_FROM"] = x[0]

			# if previous slot failed, discontinue the emerge

			pkgsettings.backup_changes("EMERGE_FROM")

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

			pkgsettings.reset()

				break

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

			# start multiple merges in parallel mode

			issyspkg = ("buildsyspkg" in myfeat) \

			num_at_atime = cpu_count + 1

					and x[0] != "blocks" \

					and system_set.findAtomForPackage(pkg_key, metadata) \

			qsize = 0

					and "--buildpkg" not in self.myopts

			for y in m_slots[x]:

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

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

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

				# but num_at_atime at most

					raise Exception, "Merging a blocker"

				if num_at_atime:

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

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

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

					spawnd_pids.append(onepid)

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

					spawnd_pkg[onepid] = (y, x)

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

					num_at_atime -= 1

							pkgsettings, self.edebug,

					mergecount += 1

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

					qsize += 1

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

				else:

					else:

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

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

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

							pkgsettings, self.edebug,

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

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

							mydbapi=portdb, tree="porttree")

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

					if (retval is None) or retval:

					if retval:

						print

						one_in_slot_failed = retval

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

						failedc += 1

						print

						failedPkgs.append(pkg_compl[2])

						failed_fetches.append(pkg_key)

  					else:

						donec += 1

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

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

					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, metadata_keys)

		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)

			portage.writemsg_stdout(red("\nPackage "+pkgs+" failed to emerge\n"))

			logfile = None

			if "PORT_LOGDIR" in self.settings:

				port_logdir = self.settings["PORT_LOGDIR"]

			else:

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

			pkg_cat = pkgs.split("/")[0]

			pkg_pf = pkgs.split("/")[1]

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

			if os.path.exists(logid_path):

				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

			if logfile and os.path.exists(logfile):

				portage.portage_exec.spawn(('tail', '-n', '20', logfile), returnpid=False)

			if logfile and os.path.exists(logfile):

				portage.writemsg_stdout(red("Please take a look at the file "+logfile+"\n"))

				os.unlink(logid_path)

		if one_in_slot_failed:

			sys.exit(1)

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

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

		# see if there are any extraneous files in build_prefix, which we might have leftover

		import glob

		for fnames in glob.glob(os.path.join(build_prefix, ".logid.")+"*"):

			os.unlink(fnames)

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

		if mtimedb.has_key("resume"):

			del mtimedb["resume"]

		mtimedb.commit()

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

			sys.exit(0)

		return os.EX_OK

	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()

					continue

					self._poll_child_processes()

					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 fork_one_emerge(self, x, mergecount, totalcount, mtimedb, favorites, metadata_keys):

		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 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])

		if "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 do_one_emerge(self, x, mergecount, totalcount, mtimedb, favorites, metadata_keys):

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

		myfeat = self.settings.features[:]

		ldpath_mtimes = mtimedb["ldpath"]

		pkg_type = x[0]

		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]

		metadata = {}

		if pkg_type == "blocks":

			pass

		elif pkg_type == "ebuild":

			mydbapi = portdb

			metadata.update(izip(metadata_keys,

				mydbapi.aux_get(pkg_key, metadata_keys)))

			pkgsettings.setcpv(pkg_key, mydb=mydbapi)

			metadata["USE"] = pkgsettings["USE"]

		else:

			if pkg_type == "binary":

				mydbapi = bindb

			else:

				raise AssertionError("Package type: '%s'" % pkg_type)

			metadata.update(izip(metadata_keys,

				mydbapi.aux_get(pkg_key, metadata_keys)))

		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 system_set.findAtomForPackage(pkg_key, metadata) \

				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

				self.curval += 1

				return retval

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

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

					pkgsettings, self.edebug, 1, portdb)

				pkgsettings, self.edebug, 1, portdb)

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

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

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

			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,

				builddir_lock = None

				builddir_lock = portage_locks.lockdir(

				catdir_lock = None

					pkgsettings["PORTAGE_BUILDDIR"])

					catdir_lock = portage_locks.lockdir(catdir)

					portage_locks.unlockdir(catdir_lock)

					portage_util.ensure_dirs(catdir,

				finally:

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

					catdir_lock = None

						mode=070, mask=0)

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

					builddir_lock = portage_locks.lockdir(

					(mergecount, totalcount, pkg_key, y)

						pkgsettings["PORTAGE_BUILDDIR"])

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

					try:

					(mergecount, totalcount, pkg_key)

						portage_locks.unlockdir(catdir_lock)

				emergelog(xterm_titles, msg, short_msg=short_msg)

					finally:

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

						catdir_lock = None

					pkgsettings, self.edebug, cleanup=1,

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

					mydbapi=portdb, tree="porttree")

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

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

				if retval != os.EX_OK:

						(mergecount, len(mymergelist), pkg_key)

					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)

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

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

						pkgsettings, self.edebug, cleanup=1,

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

						mydbapi=portdb, tree="porttree")

						pkgsettings, self.edebug, mydbapi=portdb,

						tree="porttree")

					if retval != os.EX_OK or \

						"--buildpkgonly" in self.myopts:

						portage.elog_process(pkg_key, pkgsettings)

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

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

						if issyspkg:

					if bintree.populated:

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

						bintree.inject(pkg_key)

								"let's pack a rescue tarball."

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

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

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

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

							(mergecount, totalcount, pkg_key, y)

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

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

							(mergecount, len(mymergelist), pkg_key)

							(mergecount, totalcount, pkg_key)

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

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

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

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

							pkgsettings, self.edebug, mydbapi=portdb,

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

							tree="porttree")

							"build-info"), myroot, pkgsettings,

						if retval != os.EX_OK or \

							myebuild=pkgsettings["EBUILD"],

							"--buildpkgonly" in self.myopts:

							mytree="porttree", mydbapi=portdb,

							portage.elog_process(pkg_key, pkgsettings)

							vartree=vartree, prev_mtimes=ldpath_mtimes)

						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 builddir_lock:

					if catdir_lock:

						portage_locks.unlockdir(builddir_lock)

						try:

					try:

							os.rmdir(catdir)

						if not catdir_lock:

						except OSError, e:

							# Lock catdir for removal if empty.

							if e.errno not in (errno.ENOENT,

							catdir_lock = portage_locks.lockdir(catdir)

								errno.ENOTEMPTY, errno.EEXIST):

					finally:

								raise

						if catdir_lock:

							del e

							try:

						portage_locks.unlockdir(catdir_lock)

								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)

							try:

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

							except portage_exception.FileNotFound:

								writemsg("!!! Fetching Binary failed " + \

									"for '%s'\n" % pkg_key, noiselevel=-1)

								if not fetchonly:

									return 1

								failed_fetches.append(pkg_key)

							except portage_exception.DigestException, e:

								writemsg("\n!!! Digest verification failed:\n",

									noiselevel=-1)

								writemsg("!!! %s\n" % e.value[0],

									noiselevel=-1)

								writemsg("!!! Reason: %s\n" % e.value[1],

									noiselevel=-1)

								writemsg("!!! Got: %s\n" % e.value[2],

									noiselevel=-1)

								writemsg("!!! Expected: %s\n" % e.value[3],

									noiselevel=-1)

								os.unlink(mytbz2)

								if not fetchonly:

									return 1

								failed_fetches.append(pkg_key)

					finally:

						if tbz2_lock:

							portage_locks.unlockfile(tbz2_lock)

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

		elif x[0]=="binary":

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

			#merge the tbz2

					self.curval += 1

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

					continue

			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)

						try:

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

						except portage_exception.FileNotFound:

							writemsg("!!! Fetching Binary failed " + \

								"for '%s'\n" % pkg_key, noiselevel=-1)

							if not fetchonly:

								return 1

						except portage_exception.DigestException, e:

							writemsg("\n!!! Digest verification failed:\n",

								noiselevel=-1)

							writemsg("!!! %s\n" % e.value[0],

								noiselevel=-1)

							writemsg("!!! Reason: %s\n" % e.value[1],

								noiselevel=-1)

							writemsg("!!! Got: %s\n" % e.value[2],

								noiselevel=-1)

							writemsg("!!! Expected: %s\n" % e.value[3],

								noiselevel=-1)

							os.unlink(mytbz2)

							if not fetchonly:

								return 1

				finally:

					if tbz2_lock:

						portage_locks.unlockfile(tbz2_lock)

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

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

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

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

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

				self.curval += 1

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

				return os.EX_OK

				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 not fetchonly and not pretend and \

					args_set.findAtomForPackage(pkg_key, metadata):

					world_set.lock()

					world_set.load()

					myfavkey = create_world_atom(pkg_key, metadata,

						args_set, root_config)

					if myfavkey:

						world_set.add(myfavkey)

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

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

							str(mergecount)+" of "+\

							str(len(mymergelist))+\

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

						world_set.save()

					world_set.unlock()

				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.

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

					mysplit=portage.pkgsplit(x[2])

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

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

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

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

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

							if len(mymergelist) > mergecount:

								emergelog(xterm_titles,

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

									" ::: completed emerge ("+ \

				mydbapi=bindb,

									str(mergecount)+" of "+ \

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

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

				prev_mtimes=ldpath_mtimes)

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

			if retval != os.EX_OK:

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

				return retval

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

			#need to check for errors

									"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

		# clean up the older version which emerged on top of

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

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

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

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

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

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

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

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

			mtimedb.commit()

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

			self.curval += 1

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

			self._poll_child_processes()

				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:

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

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

			"--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])

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

		return os.EX_OK

		if mtimedb.has_key("resume"):

			del mtimedb["resume"]

		mtimedb.commit()

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

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

		#fetch everything even if a particular download fails.

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

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

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

			if failed_fetches:

		pretend = "--pretend" in self.myopts

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

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

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

		pkg_type = x[0]

				for cpv in failed_fetches:

		myroot=x[1]

					sys.stderr.write("   ")

		pkg_key = x[2]

					sys.stderr.write(cpv)

		pkgindex=2

					sys.stderr.write("\n")

		if x[0]=="blocks":

				sys.stderr.write("\n")

			pkgindex=3

				sys.exit(1)

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

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

		pkgsettings = self.pkgsettings[myroot]

		root_config = RootConfig(self.trees[self.target_root])

		system_set = root_config.sets["system"]

		args_set = AtomSet(favorites)

		world_set = root_config.sets["world"]

		metadata = {}

		if pkg_type == "blocks":

			pass

		elif pkg_type == "ebuild":

			mydbapi = portdb

			metadata.update(izip(metadata_keys,

				mydbapi.aux_get(pkg_key, metadata_keys)))

			pkgsettings.setcpv(pkg_key, mydb=mydbapi)

			metadata["USE"] = pkgsettings["USE"]

		else:

			if pkg_type == "binary":

				mydbapi = bindb

				sys.exit(0)

				raise AssertionError("Package type: '%s'" % pkg_type)

		return os.EX_OK

			metadata.update(izip(metadata_keys,

				mydbapi.aux_get(pkg_key, metadata_keys)))

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

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

			myfavkey = portage.cpv_getkey(x[2])

			if not fetchonly and not pretend and \

				args_set.findAtomForPackage(pkg_key, metadata):

				world_set.lock()

				world_set.load()

				myfavkey = create_world_atom(pkg_key, metadata,

					args_set, root_config)

				if myfavkey:

					world_set.add(myfavkey)

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

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

						str(mergecount)+" of "+\

						str(totalcount)+\

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

					world_set.save()

				world_set.unlock()

	if "--quiet" not in myopts:

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

			retval = 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)

				favorites=favorites)

			retval = mydepgraph.display(mymergelist, favorites=favorites)

			for x in mydepgraph.altlist():

			for x in mymergelist:

			retval = 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)

				favorites=favorites)

			retval = mydepgraph.display(mymergelist, favorites=favorites)

			retval = mergetask.merge(

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

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

			if "resume" in mtimedb and \

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

			"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

			pkglist = mydepgraph.altlist()

			pkglist = mymergelist

					retval = mydepgraph.display(mydepgraph.altlist(

					retval = mydepgraph.display(mymergelist, favorites=favorites)

						reversed=("--tree" in myopts)),

						favorites=favorites)

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

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

			mtimedb.pop("resume", None)

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

				mtimedb.pop("resume", None)

	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, \

		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:

		if e.errno == errno.EAGAIN:

		if (e.errno == errno.EAGAIN or e.errno == errno.EPERM):