import array

import codecs

from collections import deque

import fcntl

import shutil

import urlparse

class SlotObject(object):

	__slots__ = ("__weakref__",)

	def __init__(self, **kwargs):

		classes = [self.__class__]

		while classes:

			c = classes.pop()

			if c is SlotObject:

				continue

			classes.extend(c.__bases__)

			slots = getattr(c, "__slots__", None)

			if not slots:

				continue

			for myattr in slots:

				myvalue = kwargs.get(myattr, None)

				setattr(self, myattr, myvalue)

	def copy(self):

		"""

		Create a new instance and copy all attributes

		defined from __slots__ (including those from

		inherited classes).

		"""

		obj = self.__class__()

		classes = [self.__class__]

		while classes:

			c = classes.pop()

			if c is SlotObject:

				continue

			classes.extend(c.__bases__)

			slots = getattr(c, "__slots__", None)

			if not slots:

				continue

			for myattr in slots:

				setattr(obj, myattr, getattr(self, myattr))

		return obj

class AbstractDepPriority(SlotObject):

	__slots__ = ("buildtime", "runtime", "runtime_post")

	def __lt__(self, other):

		return self.__int__() < other

	def __le__(self, other):

		return self.__int__() <= other

	def __eq__(self, other):

		return self.__int__() == other

	def __ne__(self, other):

		return self.__int__() != other

	def __gt__(self, other):

		return self.__int__() > other

	def __ge__(self, other):

		return self.__int__() >= other

	def copy(self):

		import copy

		return copy.copy(self)

class DepPriority(AbstractDepPriority):

	__slots__ = ("satisfied", "optional", "rebuild")

	def __int__(self):

		"""

		Note: These priorities are only used for measuring hardness

		in the circular dependency display via digraph.debug_print(),

		and nothing more. For actual merge order calculations, the

		measures defined by the DepPriorityNormalRange and

		DepPrioritySatisfiedRange classes are used.

		Attributes                            Hardness

		buildtime                               0

		runtime                                -1

		runtime_post                           -2

		optional                               -3

		(none of the above)                    -4

		"""

		if self.buildtime:

			return 0

		if self.runtime:

			return -1

		if self.runtime_post:

			return -2

		if self.optional:

			return -3

		return -4

	def __str__(self):

		if self.optional:

			return "optional"

		if self.buildtime:

			return "buildtime"

		if self.runtime:

			return "runtime"

		if self.runtime_post:

			return "runtime_post"

		return "soft"

class BlockerDepPriority(DepPriority):

	__slots__ = ()

	def __int__(self):

		return 0

	def __str__(self):

		return 'blocker'

BlockerDepPriority.instance = BlockerDepPriority()

class UnmergeDepPriority(AbstractDepPriority):

	__slots__ = ("optional", "satisfied",)

	"""

	Combination of properties           Priority  Category

	runtime                                0       HARD

	runtime_post                          -1       HARD

	buildtime                             -2       SOFT

	(none of the above)                   -2       SOFT

	"""

	MAX    =  0

	SOFT   = -2

	MIN    = -2

	def __int__(self):

		if self.runtime:

			return 0

		if self.runtime_post:

			return -1

		if self.buildtime:

			return -2

		return -2

	def __str__(self):

		myvalue = self.__int__()

		if myvalue > self.SOFT:

			return "hard"

		return "soft"

class DepPriorityNormalRange(object):

	"""

	DepPriority properties              Index      Category

	buildtime                                      HARD

	runtime                                3       MEDIUM

	runtime_post                           2       MEDIUM_SOFT

	optional                               1       SOFT

	(none of the above)                    0       NONE

	"""

	MEDIUM      = 3

	MEDIUM_SOFT = 2

	SOFT        = 1

	NONE        = 0

	@classmethod

	def _ignore_optional(cls, priority):

		if priority.__class__ is not DepPriority:

			return False

		return bool(priority.optional)

	@classmethod

	def _ignore_runtime_post(cls, priority):

		if priority.__class__ is not DepPriority:

			return False

		return bool(priority.optional or priority.runtime_post)

	@classmethod

	def _ignore_runtime(cls, priority):

		if priority.__class__ is not DepPriority:

			return False

		return not priority.buildtime

	ignore_medium      = _ignore_runtime

	ignore_medium_soft = _ignore_runtime_post

	ignore_soft        = _ignore_optional

DepPriorityNormalRange.ignore_priority = (

	None,

	DepPriorityNormalRange._ignore_optional,

	DepPriorityNormalRange._ignore_runtime_post,

	DepPriorityNormalRange._ignore_runtime

)

class DepPrioritySatisfiedRange(object):

	"""

	DepPriority                         Index      Category

	not satisfied and buildtime                    HARD

	not satisfied and runtime              7       MEDIUM

	not satisfied and runtime_post         6       MEDIUM_SOFT

	satisfied and buildtime and rebuild    5       SOFT

	satisfied and buildtime                4       SOFT

	satisfied and runtime                  3       SOFT

	satisfied and runtime_post             2       SOFT

	optional                               1       SOFT

	(none of the above)                    0       NONE

	"""

	MEDIUM      = 7

	MEDIUM_SOFT = 6

	SOFT        = 5

	NONE        = 0

	@classmethod

	def _ignore_optional(cls, priority):

		if priority.__class__ is not DepPriority:

			return False

		return bool(priority.optional)

	@classmethod

	def _ignore_satisfied_runtime_post(cls, priority):

		if priority.__class__ is not DepPriority:

			return False

		if priority.optional:

			return True

		if not priority.satisfied:

			return False

		return bool(priority.runtime_post)

	@classmethod

	def _ignore_satisfied_runtime(cls, priority):

		if priority.__class__ is not DepPriority:

			return False

		if priority.optional:

			return True

		if not priority.satisfied:

			return False

		return not priority.buildtime

	@classmethod

	def _ignore_satisfied_buildtime(cls, priority):

		if priority.__class__ is not DepPriority:

			return False

		if priority.optional:

			return True

		if not priority.satisfied:

			return False

		if priority.buildtime:

			return not priority.rebuild

		return True

	@classmethod

	def _ignore_satisfied_buildtime_rebuild(cls, priority):

		if priority.__class__ is not DepPriority:

			return False

		if priority.optional:

			return True

		return bool(priority.satisfied)

	@classmethod

	def _ignore_runtime_post(cls, priority):

		if priority.__class__ is not DepPriority:

			return False

		return bool(priority.optional or \

			priority.satisfied or \

			priority.runtime_post)

	@classmethod

	def _ignore_runtime(cls, priority):

		if priority.__class__ is not DepPriority:

			return False

		return bool(priority.satisfied or \

			not priority.buildtime)

	ignore_medium      = _ignore_runtime

	ignore_medium_soft = _ignore_runtime_post

	ignore_soft        = _ignore_satisfied_buildtime_rebuild

DepPrioritySatisfiedRange.ignore_priority = (

	None,

	DepPrioritySatisfiedRange._ignore_optional,

	DepPrioritySatisfiedRange._ignore_satisfied_runtime_post,

	DepPrioritySatisfiedRange._ignore_satisfied_runtime,

	DepPrioritySatisfiedRange._ignore_satisfied_buildtime,

	DepPrioritySatisfiedRange._ignore_satisfied_buildtime_rebuild,

	DepPrioritySatisfiedRange._ignore_runtime_post,

	DepPrioritySatisfiedRange._ignore_runtime

)

class Task(SlotObject):

	__slots__ = ("_hash_key", "_hash_value")

	def _get_hash_key(self):

		hash_key = getattr(self, "_hash_key", None)

		if hash_key is None:

			raise NotImplementedError(self)

		return hash_key

	def __eq__(self, other):

		return self._get_hash_key() == other

	def __ne__(self, other):

		return self._get_hash_key() != other

	def __hash__(self):

		hash_value = getattr(self, "_hash_value", None)

		if hash_value is None:

			self._hash_value = hash(self._get_hash_key())

		return self._hash_value

	def __len__(self):

		return len(self._get_hash_key())

	def __getitem__(self, key):

		return self._get_hash_key()[key]

	def __iter__(self):

		return iter(self._get_hash_key())

	def __contains__(self, key):

		return key in self._get_hash_key()

	def __str__(self):

		return str(self._get_hash_key())

class Blocker(Task):

	__hash__ = Task.__hash__

	__slots__ = ("root", "atom", "cp", "eapi", "satisfied")

	def __init__(self, **kwargs):

		Task.__init__(self, **kwargs)

		self.cp = portage.dep_getkey(self.atom)

	def _get_hash_key(self):

		hash_key = getattr(self, "_hash_key", None)

		if hash_key is None:

			self._hash_key = \

				("blocks", self.root, self.atom, self.eapi)

		return self._hash_key

class EbuildFetchonly(SlotObject):

	__slots__ = ("fetch_all", "pkg", "pretend", "settings")

	def execute(self):

		settings = self.settings

		pkg = self.pkg

		portdb = pkg.root_config.trees["porttree"].dbapi

		ebuild_path = portdb.findname(pkg.cpv)

		settings.setcpv(pkg)

		debug = settings.get("PORTAGE_DEBUG") == "1"

		restrict_fetch = 'fetch' in settings['PORTAGE_RESTRICT'].split()

		if restrict_fetch:

			rval = self._execute_with_builddir()

		else:

			rval = portage.doebuild(ebuild_path, "fetch",

				settings["ROOT"], settings, debug=debug,

				listonly=self.pretend, fetchonly=1, fetchall=self.fetch_all,

				mydbapi=portdb, tree="porttree")

			if rval != os.EX_OK:

				msg = "Fetch failed for '%s'" % (pkg.cpv,)

				eerror(msg, phase="unpack", key=pkg.cpv)

		return rval

	def _execute_with_builddir(self):

		# To spawn pkg_nofetch requires PORTAGE_BUILDDIR for

		# ensuring sane $PWD (bug #239560) and storing elog

		# messages. Use a private temp directory, in order

		# to avoid locking the main one.

		settings = self.settings

		global_tmpdir = settings["PORTAGE_TMPDIR"]

		from tempfile import mkdtemp

		try:

			private_tmpdir = mkdtemp("", "._portage_fetch_.", global_tmpdir)

		except OSError, e:

			if e.errno != portage.exception.PermissionDenied.errno:

				raise

			raise portage.exception.PermissionDenied(global_tmpdir)

		settings["PORTAGE_TMPDIR"] = private_tmpdir

		settings.backup_changes("PORTAGE_TMPDIR")

		try:

			retval = self._execute()

		finally:

			settings["PORTAGE_TMPDIR"] = global_tmpdir

			settings.backup_changes("PORTAGE_TMPDIR")

			shutil.rmtree(private_tmpdir)

		return retval

	def _execute(self):

		settings = self.settings

		pkg = self.pkg

		root_config = pkg.root_config

		portdb = root_config.trees["porttree"].dbapi

		ebuild_path = portdb.findname(pkg.cpv)

		debug = settings.get("PORTAGE_DEBUG") == "1"

		retval = portage.doebuild(ebuild_path, "fetch",

			self.settings["ROOT"], self.settings, debug=debug,

			listonly=self.pretend, fetchonly=1, fetchall=self.fetch_all,

			mydbapi=portdb, tree="porttree")

		if retval != os.EX_OK:

			msg = "Fetch failed for '%s'" % (pkg.cpv,)

			eerror(msg, phase="unpack", key=pkg.cpv)

		portage.elog.elog_process(self.pkg.cpv, self.settings)

		return retval

class PollConstants(object):

	"""

	Provides POLL* constants that are equivalent to those from the

	select module, for use by PollSelectAdapter.

	"""

	names = ("POLLIN", "POLLPRI", "POLLOUT", "POLLERR", "POLLHUP", "POLLNVAL")

	v = 1

	for k in names:

		locals()[k] = getattr(select, k, v)

		v *= 2

	del k, v

class AsynchronousTask(SlotObject):

	"""

	Subclasses override _wait() and _poll() so that calls

	to public methods can be wrapped for implementing

	hooks such as exit listener notification.

	Sublasses should call self.wait() to notify exit listeners after

	the task is complete and self.returncode has been set.

	"""

	__slots__ = ("background", "cancelled", "returncode") + \

		("_exit_listeners", "_exit_listener_stack", "_start_listeners")

	def start(self):

		"""

		Start an asynchronous task and then return as soon as possible.

		"""

		self._start_hook()

		self._start()

	def _start(self):

		raise NotImplementedError(self)

	def isAlive(self):

		return self.returncode is None

	def poll(self):

		self._wait_hook()

		return self._poll()

	def _poll(self):

		return self.returncode

	def wait(self):

		if self.returncode is None:

			self._wait()

		self._wait_hook()

		return self.returncode

	def _wait(self):

		return self.returncode

	def cancel(self):

		self.cancelled = True

		self.wait()

	def addStartListener(self, f):

		"""

		The function will be called with one argument, a reference to self.

		"""

		if self._start_listeners is None:

			self._start_listeners = []

		self._start_listeners.append(f)

	def removeStartListener(self, f):

		if self._start_listeners is None:

			return

		self._start_listeners.remove(f)

	def _start_hook(self):

		if self._start_listeners is not None:

			start_listeners = self._start_listeners

			self._start_listeners = None

			for f in start_listeners:

				f(self)

	def addExitListener(self, f):

		"""

		The function will be called with one argument, a reference to self.

		"""

		if self._exit_listeners is None:

			self._exit_listeners = []

		self._exit_listeners.append(f)

	def removeExitListener(self, f):

		if self._exit_listeners is None:

			if self._exit_listener_stack is not None:

				self._exit_listener_stack.remove(f)

			return

		self._exit_listeners.remove(f)

	def _wait_hook(self):

		"""

		Call this method after the task completes, just before returning

		the returncode from wait() or poll(). This hook is

		used to trigger exit listeners when the returncode first

		becomes available.

		"""

		if self.returncode is not None and \

			self._exit_listeners is not None:

			# This prevents recursion, in case one of the

			# exit handlers triggers this method again by

			# calling wait(). Use a stack that gives

			# removeExitListener() an opportunity to consume

			# listeners from the stack, before they can get

			# called below. This is necessary because a call

			# to one exit listener may result in a call to

			# removeExitListener() for another listener on

			# the stack. That listener needs to be removed

			# from the stack since it would be inconsistent

			# to call it after it has been been passed into

			# removeExitListener().

			self._exit_listener_stack = self._exit_listeners

			self._exit_listeners = None

			self._exit_listener_stack.reverse()

			while self._exit_listener_stack:

				self._exit_listener_stack.pop()(self)

class AbstractPollTask(AsynchronousTask):

	__slots__ = ("scheduler",) + \

		("_registered",)

	_bufsize = 4096

	_exceptional_events = PollConstants.POLLERR | PollConstants.POLLNVAL

	_registered_events = PollConstants.POLLIN | PollConstants.POLLHUP | \

		_exceptional_events

	def _unregister(self):

		raise NotImplementedError(self)

	def _unregister_if_appropriate(self, event):

		if self._registered:

			if event & self._exceptional_events:

				self._unregister()

				self.cancel()

			elif event & PollConstants.POLLHUP:

				self._unregister()

				self.wait()

class PipeReader(AbstractPollTask):

	"""

	Reads output from one or more files and saves it in memory,

	for retrieval via the getvalue() method. This is driven by

	the scheduler's poll() loop, so it runs entirely within the

	current process.

	"""

	__slots__ = ("input_files",) + \

		("_read_data", "_reg_ids")

	def _start(self):

		self._reg_ids = set()

		self._read_data = []

		for k, f in self.input_files.iteritems():

			fcntl.fcntl(f.fileno(), fcntl.F_SETFL,

				fcntl.fcntl(f.fileno(), fcntl.F_GETFL) | os.O_NONBLOCK)

			self._reg_ids.add(self.scheduler.register(f.fileno(),

				self._registered_events, self._output_handler))

		self._registered = True

	def isAlive(self):

		return self._registered

	def cancel(self):

		if self.returncode is None:

			self.returncode = 1

			self.cancelled = True

		self.wait()

	def _wait(self):

		if self.returncode is not None:

			return self.returncode

		if self._registered:

			self.scheduler.schedule(self._reg_ids)

			self._unregister()

		self.returncode = os.EX_OK

		return self.returncode

	def getvalue(self):

		"""Retrieve the entire contents"""

		if sys.hexversion >= 0x3000000:

			return bytes().join(self._read_data)

		return "".join(self._read_data)

	def close(self):

		"""Free the memory buffer."""

		self._read_data = None

	def _output_handler(self, fd, event):

		if event & PollConstants.POLLIN:

			for f in self.input_files.itervalues():

				if fd == f.fileno():

					break

			buf = array.array('B')

			try:

				buf.fromfile(f, self._bufsize)

			except EOFError:

				pass

			if buf:

				self._read_data.append(buf.tostring())

			else:

				self._unregister()

				self.wait()

		self._unregister_if_appropriate(event)

		return self._registered

	def _unregister(self):

		"""

		Unregister from the scheduler and close open files.

		"""

		self._registered = False

		if self._reg_ids is not None:

			for reg_id in self._reg_ids:

				self.scheduler.unregister(reg_id)

			self._reg_ids = None

		if self.input_files is not None:

			for f in self.input_files.itervalues():

				f.close()

			self.input_files = None

class CompositeTask(AsynchronousTask):

	__slots__ = ("scheduler",) + ("_current_task",)

	def isAlive(self):

		return self._current_task is not None

	def cancel(self):

		self.cancelled = True

		if self._current_task is not None:

			self._current_task.cancel()

	def _poll(self):

		"""

		This does a loop calling self._current_task.poll()

		repeatedly as long as the value of self._current_task

		keeps changing. It calls poll() a maximum of one time

		for a given self._current_task instance. This is useful

		since calling poll() on a task can trigger advance to

		the next task could eventually lead to the returncode

		being set in cases when polling only a single task would

		not have the same effect.

		"""

		prev = None

		while True:

			task = self._current_task

			if task is None or task is prev:

				# don't poll the same task more than once

				break

			task.poll()

			prev = task

		return self.returncode

	def _wait(self):

		prev = None

		while True:

			task = self._current_task

			if task is None:

				# don't wait for the same task more than once

				break

			if task is prev:

				# Before the task.wait() method returned, an exit

				# listener should have set self._current_task to either

				# a different task or None. Something is wrong.

				raise AssertionError("self._current_task has not " + \

					"changed since calling wait", self, task)

			task.wait()

			prev = task

		return self.returncode

	def _assert_current(self, task):

		"""

		Raises an AssertionError if the given task is not the

		same one as self._current_task. This can be useful

		for detecting bugs.

		"""

		if task is not self._current_task:

			raise AssertionError("Unrecognized task: %s" % (task,))

	def _default_exit(self, task):

		"""

		Calls _assert_current() on the given task and then sets the

		composite returncode attribute if task.returncode != os.EX_OK.

		If the task failed then self._current_task will be set to None.

		Subclasses can use this as a generic task exit callback.

		@rtype: int

		@returns: The task.returncode attribute.

		"""

		self._assert_current(task)

		if task.returncode != os.EX_OK:

			self.returncode = task.returncode

			self._current_task = None

		return task.returncode

	def _final_exit(self, task):

		"""

		Assumes that task is the final task of this composite task.

		Calls _default_exit() and sets self.returncode to the task's

		returncode and sets self._current_task to None.

		"""

		self._default_exit(task)

		self._current_task = None

		self.returncode = task.returncode

		return self.returncode

	def _default_final_exit(self, task):

		"""

		This calls _final_exit() and then wait().

		Subclasses can use this as a generic final task exit callback.

		"""

		self._final_exit(task)

		return self.wait()

	def _start_task(self, task, exit_handler):

		"""

		Register exit handler for the given task, set it

		as self._current_task, and call task.start().

		Subclasses can use this as a generic way to start

		a task.

		"""

		task.addExitListener(exit_handler)

		self._current_task = task

		task.start()

class TaskSequence(CompositeTask):

	"""

	A collection of tasks that executes sequentially. Each task

	must have a addExitListener() method that can be used as

	a means to trigger movement from one task to the next.

	"""

	__slots__ = ("_task_queue",)

	def __init__(self, **kwargs):

		AsynchronousTask.__init__(self, **kwargs)

		self._task_queue = deque()

	def add(self, task):

		self._task_queue.append(task)

	def _start(self):

		self._start_next_task()

	def cancel(self):

		self._task_queue.clear()

		CompositeTask.cancel(self)

	def _start_next_task(self):

		self._start_task(self._task_queue.popleft(),

			self._task_exit_handler)

	def _task_exit_handler(self, task):

		if self._default_exit(task) != os.EX_OK:

			self.wait()

		elif self._task_queue:

			self._start_next_task()

		else:

			self._final_exit(task)

			self.wait()

class SubProcess(AbstractPollTask):

	__slots__ = ("pid",) + \

		("_files", "_reg_id")

	# A file descriptor is required for the scheduler to monitor changes from

	# inside a poll() loop. When logging is not enabled, create a pipe just to

	# serve this purpose alone.

	_dummy_pipe_fd = 9

	def _poll(self):

		if self.returncode is not None:

			return self.returncode

		if self.pid is None:

			return self.returncode

		if self._registered:

			return self.returncode

		try:

			retval = os.waitpid(self.pid, os.WNOHANG)

		except OSError, e:

			if e.errno != errno.ECHILD:

				raise

			del e

			retval = (self.pid, 1)

		if retval == (0, 0):

			return None

		self._set_returncode(retval)

		return self.returncode

	def cancel(self):

		if self.isAlive():

			try:

				os.kill(self.pid, signal.SIGTERM)

			except OSError, e:

				if e.errno != errno.ESRCH:

					raise

				del e

		self.cancelled = True

		if self.pid is not None:

			self.wait()

		return self.returncode

	def isAlive(self):

		return self.pid is not None and \

			self.returncode is None

	def _wait(self):

		if self.returncode is not None:

			return self.returncode

		if self._registered:

			self.scheduler.schedule(self._reg_id)

			self._unregister()

			if self.returncode is not None:

				return self.returncode

		try:

			wait_retval = os.waitpid(self.pid, 0)

		except OSError, e:

			if e.errno != errno.ECHILD:

				raise

			del e

			self._set_returncode((self.pid, 1))

		else:

			self._set_returncode(wait_retval)

		return self.returncode

	def _unregister(self):

		"""

		Unregister from the scheduler and close open files.

		"""

		self._registered = False

		if self._reg_id is not None:

			self.scheduler.unregister(self._reg_id)

			self._reg_id = None

		if self._files is not None:

			for f in self._files.itervalues():

				f.close()

			self._files = None

	def _set_returncode(self, wait_retval):

		retval = wait_retval[1]

		if retval != os.EX_OK:

			if retval & 0xff:

				retval = (retval & 0xff) << 8

			else:

				retval = retval >> 8

		self.returncode = retval

class SpawnProcess(SubProcess):

	"""

	Constructor keyword args are passed into portage.process.spawn().

	The required "args" keyword argument will be passed as the first

	spawn() argument.

	"""

	_spawn_kwarg_names = ("env", "opt_name", "fd_pipes",

		"uid", "gid", "groups", "umask", "logfile",

		"path_lookup", "pre_exec")

	__slots__ = ("args",) + \

		_spawn_kwarg_names

	_file_names = ("log", "process", "stdout")

	_files_dict = slot_dict_class(_file_names, prefix="")

	def _start(self):

		if self.cancelled:

			return

		if self.fd_pipes is None:

			self.fd_pipes = {}

		fd_pipes = self.fd_pipes

		fd_pipes.setdefault(0, sys.stdin.fileno())

		fd_pipes.setdefault(1, sys.stdout.fileno())

		fd_pipes.setdefault(2, sys.stderr.fileno())

		# flush any pending output

		for fd in fd_pipes.itervalues():

			if fd == sys.stdout.fileno():

				sys.stdout.flush()

			if fd == sys.stderr.fileno():

				sys.stderr.flush()

		logfile = self.logfile

		self._files = self._files_dict()

		files = self._files

		master_fd, slave_fd = self._pipe(fd_pipes)

		fcntl.fcntl(master_fd, fcntl.F_SETFL,

			fcntl.fcntl(master_fd, fcntl.F_GETFL) | os.O_NONBLOCK)

		null_input = None

		fd_pipes_orig = fd_pipes.copy()

		if self.background:

			# TODO: Use job control functions like tcsetpgrp() to control

			# access to stdin. Until then, use /dev/null so that any

			# attempts to read from stdin will immediately return EOF

			# instead of blocking indefinitely.

			null_input = open('/dev/null', 'rb')

			fd_pipes[0] = null_input.fileno()

		else:

			fd_pipes[0] = fd_pipes_orig[0]

		files.process = os.fdopen(master_fd, 'rb')

		if logfile is not None:

			fd_pipes[1] = slave_fd

			fd_pipes[2] = slave_fd

			files.log = open(logfile, mode='ab')

			portage.util.apply_secpass_permissions(logfile,

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

				mode=0660)

			if not self.background:

				files.stdout = os.fdopen(os.dup(fd_pipes_orig[1]), 'wb')

			output_handler = self._output_handler

		else:

			# Create a dummy pipe so the scheduler can monitor

			# the process from inside a poll() loop.

			fd_pipes[self._dummy_pipe_fd] = slave_fd

			if self.background:

				fd_pipes[1] = slave_fd

				fd_pipes[2] = slave_fd

			output_handler = self._dummy_handler

		kwargs = {}

		for k in self._spawn_kwarg_names:

			v = getattr(self, k)

			if v is not None:

				kwargs[k] = v

		kwargs["fd_pipes"] = fd_pipes

		kwargs["returnpid"] = True

		kwargs.pop("logfile", None)

		self._reg_id = self.scheduler.register(files.process.fileno(),

			self._registered_events, output_handler)

		self._registered = True

		retval = self._spawn(self.args, **kwargs)

		os.close(slave_fd)

		if null_input is not None:

			null_input.close()

		if isinstance(retval, int):

			# spawn failed

			self._unregister()

			self.returncode = retval

			self.wait()

			return

		self.pid = retval[0]

		portage.process.spawned_pids.remove(self.pid)

	def _pipe(self, fd_pipes):

		"""

		@type fd_pipes: dict

		@param fd_pipes: pipes from which to copy terminal size if desired.

		"""

		return os.pipe()

	def _spawn(self, args, **kwargs):

		return portage.process.spawn(args, **kwargs)

	def _output_handler(self, fd, event):

		if event & PollConstants.POLLIN:

			files = self._files

			buf = array.array('B')

			try:

				buf.fromfile(files.process, self._bufsize)

			except EOFError:

				pass

			if buf:

				if not self.background:

					write_successful = False

					failures = 0

					while True:

						try:

							if not write_successful:

								buf.tofile(files.stdout)

								write_successful = True

							files.stdout.flush()

							break

						except IOError, e:

							if e.errno != errno.EAGAIN:

								raise

							del e

							failures += 1

							if failures > 50:

								# Avoid a potentially infinite loop. In

								# most cases, the failure count is zero

								# and it's unlikely to exceed 1.

								raise

							# This means that a subprocess has put an inherited

							# stdio file descriptor (typically stdin) into

							# O_NONBLOCK mode. This is not acceptable (see bug

							# #264435), so revert it. We need to use a loop

							# here since there's a race condition due to

							# parallel processes being able to change the

							# flags on the inherited file descriptor.

							# TODO: When possible, avoid having child processes

							# inherit stdio file descriptors from portage

							# (maybe it can't be avoided with

							# PROPERTIES=interactive).

							fcntl.fcntl(files.stdout.fileno(), fcntl.F_SETFL,

								fcntl.fcntl(files.stdout.fileno(),

								fcntl.F_GETFL) ^ os.O_NONBLOCK)

				buf.tofile(files.log)

				files.log.flush()

			else:

				self._unregister()

				self.wait()

		self._unregister_if_appropriate(event)

		return self._registered

	def _dummy_handler(self, fd, event):

		"""

		This method is mainly interested in detecting EOF, since

		the only purpose of the pipe is to allow the scheduler to

		monitor the process from inside a poll() loop.

		"""

		if event & PollConstants.POLLIN:

			buf = array.array('B')

			try:

				buf.fromfile(self._files.process, self._bufsize)

			except EOFError:

				pass

			if buf:

				pass

			else:

				self._unregister()

				self.wait()

		self._unregister_if_appropriate(event)

		return self._registered

class MiscFunctionsProcess(SpawnProcess):

	"""

	Spawns misc-functions.sh with an existing ebuild environment.

	"""

	__slots__ = ("commands", "phase", "pkg", "settings")

	def _start(self):

		settings = self.settings

		settings.pop("EBUILD_PHASE", None)

		portage_bin_path = settings["PORTAGE_BIN_PATH"]

		misc_sh_binary = os.path.join(portage_bin_path,

			os.path.basename(portage.const.MISC_SH_BINARY))

		self.args = [portage._shell_quote(misc_sh_binary)] + self.commands

		self.logfile = settings.get("PORTAGE_LOG_FILE")

		portage._doebuild_exit_status_unlink(

			settings.get("EBUILD_EXIT_STATUS_FILE"))

		SpawnProcess._start(self)

	def _spawn(self, args, **kwargs):

		settings = self.settings

		debug = settings.get("PORTAGE_DEBUG") == "1"

		return portage.spawn(" ".join(args), settings,

			debug=debug, **kwargs)

	def _set_returncode(self, wait_retval):

		SpawnProcess._set_returncode(self, wait_retval)

		self.returncode = portage._doebuild_exit_status_check_and_log(

			self.settings, self.phase, self.returncode)

class EbuildFetcher(SpawnProcess):

	__slots__ = ("config_pool", "fetchonly", "fetchall", "pkg", "prefetch") + \

		("_build_dir",)

	def _start(self):

		root_config = self.pkg.root_config

		portdb = root_config.trees["porttree"].dbapi

		ebuild_path = portdb.findname(self.pkg.cpv)

		settings = self.config_pool.allocate()

		settings.setcpv(self.pkg)

		# In prefetch mode, logging goes to emerge-fetch.log and the builddir

		# should not be touched since otherwise it could interfere with

		# another instance of the same cpv concurrently being built for a

		# different $ROOT (currently, builds only cooperate with prefetchers

		# that are spawned for the same $ROOT).

		if not self.prefetch:

			self._build_dir = EbuildBuildDir(pkg=self.pkg, settings=settings)

			self._build_dir.lock()

			self._build_dir.clean_log()

			portage.prepare_build_dirs(self.pkg.root, self._build_dir.settings, 0)

			if self.logfile is None:

				self.logfile = settings.get("PORTAGE_LOG_FILE")

		phase = "fetch"

		if self.fetchall:

			phase = "fetchall"

		# If any incremental variables have been overridden

		# via the environment, those values need to be passed

		# along here so that they are correctly considered by

		# the config instance in the subproccess.

		fetch_env = os.environ.copy()

		nocolor = settings.get("NOCOLOR")

		if nocolor is not None:

			fetch_env["NOCOLOR"] = nocolor

		fetch_env["PORTAGE_NICENESS"] = "0"

		if self.prefetch:

			fetch_env["PORTAGE_PARALLEL_FETCHONLY"] = "1"

		ebuild_binary = os.path.join(

			settings["PORTAGE_BIN_PATH"], "ebuild")

		fetch_args = [ebuild_binary, ebuild_path, phase]

		debug = settings.get("PORTAGE_DEBUG") == "1"

		if debug:

			fetch_args.append("--debug")

		self.args = fetch_args

		self.env = fetch_env

		SpawnProcess._start(self)

	def _pipe(self, fd_pipes):

		"""When appropriate, use a pty so that fetcher progress bars,

		like wget has, will work properly."""

		if self.background or not sys.stdout.isatty():

			# When the output only goes to a log file,

			# there's no point in creating a pty.

			return os.pipe()

		stdout_pipe = fd_pipes.get(1)

		got_pty, master_fd, slave_fd = \

			portage._create_pty_or_pipe(copy_term_size=stdout_pipe)

		return (master_fd, slave_fd)

	def _set_returncode(self, wait_retval):

		SpawnProcess._set_returncode(self, wait_retval)

		# Collect elog messages that might have been

		# created by the pkg_nofetch phase.

		if self._build_dir is not None:

			# Skip elog messages for prefetch, in order to avoid duplicates.

			if not self.prefetch and self.returncode != os.EX_OK:

				elog_out = None

				if self.logfile is not None:

					if self.background:

						elog_out = open(self.logfile, 'a')

				msg = "Fetch failed for '%s'" % (self.pkg.cpv,)

				if self.logfile is not None:

					msg += ", Log file:"

				eerror(msg, phase="unpack", key=self.pkg.cpv, out=elog_out)

				if self.logfile is not None:

					eerror(" '%s'" % (self.logfile,),

						phase="unpack", key=self.pkg.cpv, out=elog_out)

				if elog_out is not None:

					elog_out.close()

			if not self.prefetch:

				portage.elog.elog_process(self.pkg.cpv, self._build_dir.settings)

			features = self._build_dir.settings.features

			if self.returncode == os.EX_OK:

				self._build_dir.clean_log()

			self._build_dir.unlock()

			self.config_pool.deallocate(self._build_dir.settings)

			self._build_dir = None

class EbuildBuildDir(SlotObject):

	__slots__ = ("dir_path", "pkg", "settings",

		"locked", "_catdir", "_lock_obj")

	def __init__(self, **kwargs):

		SlotObject.__init__(self, **kwargs)

		self.locked = False

	def lock(self):

		"""

		This raises an AlreadyLocked exception if lock() is called

		while a lock is already held. In order to avoid this, call

		unlock() or check whether the "locked" attribute is True

		or False before calling lock().

		"""

		if self._lock_obj is not None:

			raise self.AlreadyLocked((self._lock_obj,))

		dir_path = self.dir_path

		if dir_path is None:

			root_config = self.pkg.root_config

			portdb = root_config.trees["porttree"].dbapi

			ebuild_path = portdb.findname(self.pkg.cpv)

			settings = self.settings

			settings.setcpv(self.pkg)

			debug = settings.get("PORTAGE_DEBUG") == "1"

			use_cache = 1 # always true

			portage.doebuild_environment(ebuild_path, "setup", root_config.root,

				self.settings, debug, use_cache, portdb)

			dir_path = self.settings["PORTAGE_BUILDDIR"]

		catdir = os.path.dirname(dir_path)

		self._catdir = catdir

		portage.util.ensure_dirs(os.path.dirname(catdir),

			gid=portage.portage_gid,

			mode=070, mask=0)

		catdir_lock = None

		try:

			catdir_lock = portage.locks.lockdir(catdir)

			portage.util.ensure_dirs(catdir,

				gid=portage.portage_gid,

				mode=070, mask=0)

			self._lock_obj = portage.locks.lockdir(dir_path)

		finally:

			self.locked = self._lock_obj is not None

			if catdir_lock is not None:

				portage.locks.unlockdir(catdir_lock)

	def clean_log(self):

		"""Discard existing log."""

		settings = self.settings

		for x in ('.logid', 'temp/build.log'):

			try:

				os.unlink(os.path.join(settings["PORTAGE_BUILDDIR"], x))

			except OSError:

				pass

	def unlock(self):

		if self._lock_obj is None:

			return

		portage.locks.unlockdir(self._lock_obj)

		self._lock_obj = None

		self.locked = False

		catdir = self._catdir

		catdir_lock = None

		try:

			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)

	class AlreadyLocked(portage.exception.PortageException):

		pass

class EbuildBuild(CompositeTask):

	__slots__ = ("args_set", "config_pool", "find_blockers",

		"ldpath_mtimes", "logger", "opts", "pkg", "pkg_count",

		"prefetcher", "settings", "world_atom") + \

		("_build_dir", "_buildpkg", "_ebuild_path", "_issyspkg", "_tree")

	def _start(self):

		logger = self.logger

		opts = self.opts

		pkg = self.pkg

		settings = self.settings

		world_atom = self.world_atom

		root_config = pkg.root_config

		tree = "porttree"

		self._tree = tree

		portdb = root_config.trees[tree].dbapi

		settings.setcpv(pkg)

		settings.configdict["pkg"]["EMERGE_FROM"] = pkg.type_name

		ebuild_path = portdb.findname(self.pkg.cpv)

		self._ebuild_path = ebuild_path

		prefetcher = self.prefetcher

		if prefetcher is None:

			pass

		elif not prefetcher.isAlive():

			prefetcher.cancel()

		elif prefetcher.poll() is None:

			waiting_msg = "Fetching files " + \

				"in the background. " + \

				"To view fetch progress, run `tail -f " + \

				"/var/log/emerge-fetch.log` in another " + \

				"terminal."

			msg_prefix = colorize("GOOD", " * ")

			from textwrap import wrap

			waiting_msg = "".join("%s%s\n" % (msg_prefix, line) \

				for line in wrap(waiting_msg, 65))

			if not self.background:

				writemsg(waiting_msg, noiselevel=-1)

			self._current_task = prefetcher

			prefetcher.addExitListener(self._prefetch_exit)

			return

		self._prefetch_exit(prefetcher)

	def _prefetch_exit(self, prefetcher):

		opts = self.opts

		pkg = self.pkg

		settings = self.settings

		if opts.fetchonly:

				fetcher = EbuildFetchonly(

					fetch_all=opts.fetch_all_uri,

					pkg=pkg, pretend=opts.pretend,

					settings=settings)

				retval = fetcher.execute()

				self.returncode = retval

				self.wait()

				return

		fetcher = EbuildFetcher(config_pool=self.config_pool,

			fetchall=opts.fetch_all_uri,

			fetchonly=opts.fetchonly,

			background=self.background,

			pkg=pkg, scheduler=self.scheduler)

		self._start_task(fetcher, self._fetch_exit)

	def _fetch_exit(self, fetcher):

		opts = self.opts

		pkg = self.pkg

		fetch_failed = False

		if opts.fetchonly:

			fetch_failed = self._final_exit(fetcher) != os.EX_OK

		else:

			fetch_failed = self._default_exit(fetcher) != os.EX_OK

		if fetch_failed and fetcher.logfile is not None and \

			os.path.exists(fetcher.logfile):

			self.settings["PORTAGE_LOG_FILE"] = fetcher.logfile

		if not fetch_failed and fetcher.logfile is not None:

			# Fetch was successful, so remove the fetch log.

			try:

				os.unlink(fetcher.logfile)

			except OSError:

				pass

		if fetch_failed or opts.fetchonly:

			self.wait()

			return

		logger = self.logger

		opts = self.opts

		pkg_count = self.pkg_count

		scheduler = self.scheduler

		settings = self.settings

		features = settings.features

		ebuild_path = self._ebuild_path

		system_set = pkg.root_config.sets["system"]

		self._build_dir = EbuildBuildDir(pkg=pkg, settings=settings)

		self._build_dir.lock()

		# Cleaning is triggered before the setup

		# phase, in portage.doebuild().

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

			(pkg_count.curval, pkg_count.maxval, pkg.cpv, ebuild_path)

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

			(pkg_count.curval, pkg_count.maxval, pkg.cpv)

		logger.log(msg, short_msg=short_msg)

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

		self._issyspkg = "buildsyspkg" in features and \

				system_set.findAtomForPackage(pkg) and \

				not opts.buildpkg

		if opts.buildpkg or self._issyspkg:

			self._buildpkg = True

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

				(pkg_count.curval, pkg_count.maxval, pkg.cpv, ebuild_path)

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

				(pkg_count.curval, pkg_count.maxval, pkg.cpv)

			logger.log(msg, short_msg=short_msg)

		else:

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

				(pkg_count.curval, pkg_count.maxval, pkg.cpv, ebuild_path)

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

				(pkg_count.curval, pkg_count.maxval, pkg.cpv)

			logger.log(msg, short_msg=short_msg)

		build = EbuildExecuter(background=self.background, pkg=pkg,

			scheduler=scheduler, settings=settings)

		self._start_task(build, self._build_exit)

	def _unlock_builddir(self):

		portage.elog.elog_process(self.pkg.cpv, self.settings)

		self._build_dir.unlock()

	def _build_exit(self, build):

		if self._default_exit(build) != os.EX_OK:

			self._unlock_builddir()

			self.wait()

			return

		opts = self.opts

		buildpkg = self._buildpkg

		if not buildpkg:

			self._final_exit(build)

			self.wait()

			return

		if self._issyspkg:

			msg = ">>> This is a system package, " + \

				"let's pack a rescue tarball.\n"

			log_path = self.settings.get("PORTAGE_LOG_FILE")

			if log_path is not None:

				log_file = open(log_path, 'a')

				try:

					log_file.write(msg)

				finally:

					log_file.close()

			if not self.background:

				portage.writemsg_stdout(msg, noiselevel=-1)

		packager = EbuildBinpkg(background=self.background, pkg=self.pkg,

			scheduler=self.scheduler, settings=self.settings)

		self._start_task(packager, self._buildpkg_exit)

	def _buildpkg_exit(self, packager):

		"""

		Released build dir lock when there is a failure or

		when in buildpkgonly mode. Otherwise, the lock will

		be released when merge() is called.

		"""

		if self._default_exit(packager) != os.EX_OK:

			self._unlock_builddir()

			self.wait()

			return

		if self.opts.buildpkgonly:

			# Need to call "clean" phase for buildpkgonly mode

			portage.elog.elog_process(self.pkg.cpv, self.settings)

			phase = "clean"

			clean_phase = EbuildPhase(background=self.background,

				pkg=self.pkg, phase=phase,

				scheduler=self.scheduler, settings=self.settings,

				tree=self._tree)

			self._start_task(clean_phase, self._clean_exit)

			return

		# Continue holding the builddir lock until

		# after the package has been installed.

		self._current_task = None

		self.returncode = packager.returncode

		self.wait()

	def _clean_exit(self, clean_phase):

		if self._final_exit(clean_phase) != os.EX_OK or \

			self.opts.buildpkgonly:

			self._unlock_builddir()

		self.wait()

	def install(self):

		"""

		Install the package and then clean up and release locks.

		Only call this after the build has completed successfully

		and neither fetchonly nor buildpkgonly mode are enabled.

		"""

		find_blockers = self.find_blockers

		ldpath_mtimes = self.ldpath_mtimes

		logger = self.logger

		pkg = self.pkg

		pkg_count = self.pkg_count

		settings = self.settings

		world_atom = self.world_atom

		ebuild_path = self._ebuild_path

		tree = self._tree

		merge = EbuildMerge(find_blockers=self.find_blockers,

			ldpath_mtimes=ldpath_mtimes, logger=logger, pkg=pkg,

			pkg_count=pkg_count, pkg_path=ebuild_path,

			scheduler=self.scheduler,

			settings=settings, tree=tree, world_atom=world_atom)

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

			(pkg_count.curval, pkg_count.maxval,

			pkg.cpv, ebuild_path)

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

			(pkg_count.curval, pkg_count.maxval, pkg.cpv)

		logger.log(msg, short_msg=short_msg)

		try:

			rval = merge.execute()

		finally:

			self._unlock_builddir()

		return rval

class EbuildExecuter(CompositeTask):

	__slots__ = ("pkg", "scheduler", "settings") + ("_tree",)

	_phases = ("prepare", "configure", "compile", "test", "install")

	_live_eclasses = frozenset([

		"bzr",

		"cvs",

		"darcs",

		"git",

		"mercurial",

		"subversion"

	])

	def _start(self):

		self._tree = "porttree"

		pkg = self.pkg

		phase = "clean"

		clean_phase = EbuildPhase(background=self.background, pkg=pkg, phase=phase,

			scheduler=self.scheduler, settings=self.settings, tree=self._tree)

		self._start_task(clean_phase, self._clean_phase_exit)

	def _clean_phase_exit(self, clean_phase):

		if self._default_exit(clean_phase) != os.EX_OK:

			self.wait()

			return

		pkg = self.pkg

		scheduler = self.scheduler

		settings = self.settings

		cleanup = 1

		# This initializes PORTAGE_LOG_FILE.

		portage.prepare_build_dirs(pkg.root, settings, cleanup)

		setup_phase = EbuildPhase(background=self.background,

			pkg=pkg, phase="setup", scheduler=scheduler,

			settings=settings, tree=self._tree)

		setup_phase.addExitListener(self._setup_exit)

		self._current_task = setup_phase

		self.scheduler.scheduleSetup(setup_phase)

	def _setup_exit(self, setup_phase):

		if self._default_exit(setup_phase) != os.EX_OK:

			self.wait()

			return

		unpack_phase = EbuildPhase(background=self.background,

			pkg=self.pkg, phase="unpack", scheduler=self.scheduler,

			settings=self.settings, tree=self._tree)

		if self._live_eclasses.intersection(self.pkg.inherited):

			# Serialize $DISTDIR access for live ebuilds since

			# otherwise they can interfere with eachother.

			unpack_phase.addExitListener(self._unpack_exit)

			self._current_task = unpack_phase

			self.scheduler.scheduleUnpack(unpack_phase)

		else:

			self._start_task(unpack_phase, self._unpack_exit)

	def _unpack_exit(self, unpack_phase):

		if self._default_exit(unpack_phase) != os.EX_OK:

			self.wait()

			return

		ebuild_phases = TaskSequence(scheduler=self.scheduler)

		pkg = self.pkg

		phases = self._phases

		eapi = pkg.metadata["EAPI"]

		if eapi in ("0", "1"):

			# skip src_prepare and src_configure

			phases = phases[2:]

		for phase in phases: