path: root/portato/gui/gui_helper.py

# -*- coding: utf-8 -*-
#
# File: portato/gui/gui_helper.py
# This file is part of the Portato-Project, a graphical portage-frontend.
#
# Copyright (C) 2006-2007 René 'Necoro' Neumann
# This is free software.  You may redistribute copies of it under the terms of
# the GNU General Public License version 2.
# There is NO WARRANTY, to the extent permitted by law.
#
# Written by René 'Necoro' Neumann <necoro@necoro.net>

from __future__ import absolute_import

# some stuff needed
import logging
import os, pty
import signal, threading, time
from subprocess import Popen, PIPE, STDOUT

from gettext import lgettext as _

# some backend things
from .. import backend, plugin
from ..backend import flags, system, set_system
from ..helper import debug, info, send_signal_to_group, set_log_level, unique_array
from ..constants import USE_CATAPULT
from ..waiting_queue import WaitingQueue

# parser
from ..config_parser import ConfigParser

# the wrapper
from .wrapper import Console, Tree

class Config (ConfigParser):
	
	def __init__ (self, cfgFile):
		"""Constructor.

		@param cfgFile: path to config file
		@type cfgFile: string"""

		ConfigParser.__init__(self, cfgFile)
		
		# read config
		self.parse()

		# local configs
		self.local = {}

	def modify_flags_config (self):
		"""Sets the internal config of the L{flags}-module.
		@see: L{flags.set_config()}"""

		flagCfg = {
				"usefile": self.get("useFile"), 
				"usePerVersion" : self.get_boolean("usePerVersion"),
				"maskfile" : self.get("maskFile"),
				"maskPerVersion" : self.get_boolean("maskPerVersion"),
				"testingfile" : self.get("keywordFile"),
				"testingPerVersion" : self.get_boolean("keywordPerVersion")}
		flags.set_config(flagCfg)

	def modify_debug_config (self):
		if self.get_boolean("debug"):
			level = logging.DEBUG
		else:
			level = logging.INFO

		set_log_level(level)

	def modify_system_config (self):
		"""Sets the system config.
		@see: L{backend.set_system()}"""
		if not USE_CATAPULT:
			set_system(self.get("system"))

	def modify_external_configs (self):
		"""Convenience function setting all external configs."""
		self.modify_debug_config()
		self.modify_flags_config()
		self.modify_system_config()

	def set_local(self, cpv, name, val):
		"""Sets some local config.

		@param cpv: the cpv describing the package for which to set this option
		@type cpv: string (cpv)
		@param name: the option's name
		@type name: string
		@param val: the value to set
		@type val: any"""
		
		if not cpv in self.local:
			self.local[cpv] = {}

		self.local[cpv].update({name:val})

	def get_local(self, cpv, name):
		"""Returns something out of the local config.

		@param cpv: the cpv describing the package from which to get this option
		@type cpv: string (cpv)
		@param name: the option's name
		@type name: string
		@return: value stored for the cpv and name or None if not found
		@rtype: any"""

		if not cpv in self.local:
			return None
		if not name in self.local[cpv]:
			return None

		return self.local[cpv][name]

	def write(self):
		"""Writes to the config file and modify any external configs."""
		ConfigParser.write(self)
		self.modify_external_configs()

class Database:
	"""An internal database which holds a simple dictionary cat -> [package_list]."""

	ALL = _("ALL")

	def __init__ (self):
		"""Constructor."""
		self.__initialize()

	def __initialize (self):
		self._db = {self.ALL:[]}
		self.inst_cats = set([self.ALL])

	def __sort_key (self, x):
		return x[1].lower()

	def populate (self, category = None):
		"""Populates the database.
		
		@param category: An optional category - so only packages of this category are inserted.
		@type category: string
		"""
		
		# get the lists
		packages = system.find_all_packages(name = category, withVersion = False)
		installed = system.find_all_installed_packages(name = category, withVersion = False)
		
		# cycle through packages
		for p in packages:
			cat, pkg = p.split("/")
			if not cat in self._db: self._db[cat] = []
			inst = p in installed
			t = (cat, pkg, inst)
			self._db[cat].append(t)
			self._db[self.ALL].append(t)

			if inst:
				self.inst_cats.add(cat)

		for key in self._db: # sort alphabetically
			self._db[key].sort(key = self.__sort_key)

	def get_cat (self, cat = None, byName = True):
		"""Returns the packages in the category.
		
		@param cat: category to return the packages from; if None it defaults to "ALL"
		@type cat: string
		@param byName: selects whether to return the list sorted by name or by installation
		@type byName: boolean
		@return: an iterator over a list of tuples: (category, name, is_installed) or []
		@rtype: (string, string, boolean)<iterator>
		"""
		
		if not cat:
			cat = self.ALL

		try:
			if byName:
				for pkg in self._db[cat]:
					yield pkg
			else:
				ninst = []
				for pkg in self._db[cat]:
					if pkg[2]:
						yield pkg
					else:
						ninst.append(pkg)

				for pkg in ninst:
					yield pkg

		except KeyError: # cat is in category list - but not in portage
			info(_("Catched KeyError => %s seems not to be an available category. Have you played with rsync-excludes?"), cat)

	def get_categories (self, installed = False):
		"""Returns all categories.
		
		@param installed: Only return these with at least one installed package.
		@type installed: boolean
		@returns: the list of categories
		@rtype: string<iterator>
		"""

		if installed:
			c = self.inst_cats
		else:
			c = self._db.iterkeys()

		for cat in c:
			yield cat

	def reload (self, cat = None):
		"""Reloads the given category.
		
		@param cat: category
		@type cat: string
		"""

		if cat:
			del self._db[cat]
			self.inst_cats.remove(cat)
			self.populate(cat+"/")
		else:
			self.__initialize()
			self.populate()

class EmergeQueue:
	"""This class manages the emerge queue."""
	
	def __init__ (self, tree = None, console = None, db = None, title_update = None, threadClass = threading.Thread):
		"""Constructor.
		
		@param tree: Tree to append all the items to.
		@type tree: Tree
		@param console: Output is shown here.
		@type console: Console
		@param db: A database instance.
		@type db: Database
		@param title_update: A function, which will be called whenever there is a title update.
		@type title_update: function(string)"""
		
		# the different queues
		self.mergequeue = [] # for emerge
		self.unmergequeue = [] # for emerge -C
		self.oneshotmerge = [] # for emerge --oneshot
		
		# the emerge process
		self.process = None
		self.threadQueue = WaitingQueue(threadClass = threadClass)
		self.pty = None

		# dictionaries with data about the packages in the queue
		self.iters = {} # iterator in the tree
		self.deps = {} # all the deps of the package
		
		# member vars
		self.tree = tree
		if self.tree and not isinstance(self.tree, Tree): raise TypeError, "tree passed is not a Tree-object"
		
		self.console = console
		if self.console and not isinstance(self.console, Console): raise TypeError, "console passed is not a Console-object"
		
		self.db = db
		self.title_update = title_update

		# our iterators pointing at the toplevels; they are set to None if we do not have a tree
		if self.tree: 
			self.emergeIt = self.tree.get_emerge_it()
			self.unmergeIt = self.tree.get_unmerge_it()
		else:
			self.emergeIt = self.unmergeIt = None

	def _get_pkg_from_cpv (self, cpv, unmask = False):
		"""Gets a L{backend.Package}-object from a cpv.

		@param cpv: the cpv to get the package for
		@type cpv: string (cpv)
		@param unmask: if True we will look for masked packages if we cannot find unmasked ones
		@type unmask: boolean
		@return: created package
		@rtype: backend.Package
		
		@raises backend.PackageNotFoundException: If no package could be found - normally it is existing but masked."""

		# for the beginning: let us create a package object - but it is not guaranteed, that it actually exists in portage
		pkg = system.new_package(cpv)
		masked = not (pkg.is_masked() or pkg.is_testing(use_keywords=True)) # we are setting this to True in case we have unmasked it already, but portage does not know this
		
		# and now try to find it in portage
		pkg = system.find_packages("="+cpv, masked = masked)
		
		if pkg: # gotcha
			pkg = pkg[0]

		elif unmask: # no pkg returned, but we are allowed to unmask it
			pkg = system.find_packages("="+cpv, masked = True)

			if not pkg:
				raise backend.PackageNotFoundException(cpv) # also not found
			else:
				pkg =