path: root/portato/gui/queue.py

# -*- coding: utf-8 -*-
#
# File: portato/gui/queue.py
# This file is part of the Portato-Project, a graphical portage-frontend.
#
# Copyright (C) 2006-2010 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_builtins import map, filter, zip

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

# some backend things
from .. import backend, plugin
from ..backend import flags, system
from ..backend.exceptions import BlockedException
from ..helper import debug, info, warning, error
from ..waiting_queue import WaitingQueue
from ..odict import OrderedDict
from .updater import Updater

# the wrapper
from .utils import GtkTree

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: GtkTree
        @param console: Output is shown here.
        @type console: vte.Terminal
        @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 = {"install" : {}, "uninstall" : {}, "update" : {}} # iterator in the tree
        self.deps = {"install" : {}, "update" : {}} # all the deps of the package
        self.blocks = {"install" : OrderedDict(), "update" : OrderedDict()}
        
        # member vars
        self.tree = tree
        if self.tree and not isinstance(self.tree, GtkTree): raise TypeError("tree passed is not a GtkTree-object")
        
        self.console = console
        
        self.db = db
        self.title_update = title_update
        self.threadClass = threadClass
        
        if self.console:
            self.pty = pty.openpty()
            self.console.set_pty(self.pty[0])

    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 = pkg[0]

            if pkg.is_testing(use_keywords = True):
                pkg.set_testing(True)
            if pkg.is_masked():
                pkg.set_masked()
        
        else: # no pkg returned - and we are not allowed to unmask
            raise backend.PackageNotFoundException(cpv)
        
        return pkg
    
    def update_tree (self, it, cpv, unmask = False, oneshot = False, type = "install"):
        """This updates the tree recursivly, or? Isn't it? Bjorn!

        @param it: iterator where to append
        @type it: Iterator
        @param cpv: The package to append.
        @type cpv: string (cat/pkg-ver)
        @param unmask: True if we are allowed to look for masked packages
        @type unmask: boolean
        @param oneshot: True if we want to emerge is oneshot
        @type oneshot: boolean
        @param type: the type of the updating
        @type type: string
        
        @raises backend.BlockedException: When occured during dependency-calculation.
        @raises backend.PackageNotFoundException: If no package could be found - normally it is existing but masked."""
        
        if cpv in self.deps[type]:
            return # in list already and therefore it's already in the tree too    
        
        # try to find an already installed instance
        update = False
        downgrade = False
        uVersion = None
        changedUse = []
        try:
            pkg = self._get_pkg_from_cpv(cpv, unmask)
            if not pkg.is_installed():
                old = system.find_packages(pkg.get_slot_cp(), system.SET_INSTALLED)
                if old:
                    old = old[0] # assume we have only one there
                    cmp = pkg.__cmp__(old)
                    if cmp > 0:
                        update = True
                    elif cmp < 0:
                        downgrade = True

                    uVersion = old.get_version()

                    old_iuse = set(old.get_iuse_flags())
                    new_iuse = set(pkg.get_iuse_flags())

                    for i in old_iuse.difference(new_iuse):
                        changedUse.append("-"+i)

                    for i in new_iuse.difference(old_iuse):
                        changedUse.append("+"+i)
            else:
                old_iuse = set(pkg.get_iuse_flags(installed = True))
                new_iuse = set(pkg.get_iuse_flags(installed = False))

                for i in old_iuse.difference(new_iuse):
                    changedUse.append("-"+i)

                for i in new_iuse.difference(old_iuse):
                    changedUse.append("+"+i)

        except backend.PackageNotFoundException as e: # package not found / package is masked -> delete current tree and re-raise the exception
            if type == "update": # remove complete tree
                self.remove_with_children(self.tree.first_iter(it), removeNewFlags = False)
            
            elif type == "install": # remove only the intentionally added package
                top = self.tree.first_iter(it)
                parent = self.tree.parent_iter(it)
                
                if parent:
                    while not self.tree.iter_equal(top, parent):
                        parent = self.tree.parent_iter(parent)
                        it = self.tree.parent_iter(it)

                    self.remove_with_children(it, removeNewFlags = False)

                if not self.tree.iter_has_children(top): # remove completely if nothing left
                    self.remove(top)
            raise

        # get dependencies
        deps = pkg.get_dep_packages(return_blocks = True)
        self.deps[type][cpv] = deps
        
        # add iter
        subIt = self.tree.append(it, self.tree.build_append_value(cpv, oneshot = oneshot, update = update, downgrade = downgrade, version = uVersion, useChange = changedUse))
        self.iters[type][cpv] = subIt
        
        for d in deps:
            if d[0] == "!": # block
                dep = d[1:]
                if not dep in self.blocks[type]:
                    self.blocks[type][dep] = set()

                self.blocks[type][dep].add(cpv)
            else: # recursive call
                self.update_tree(subIt, d, unmask, type = type)
        
    def append (self, cpv, type = "install", update = False, forceUpdate = False, unmask = False, oneshot = False):
        """Appends a cpv either to the merge queue or to the unmerge-queue.
        Also updates the tree-view.
        
        @param cpv: Package to add
        @type cpv: string (cat/pkg-ver)
        @param type: The type of this append process. Possible values are "install", "uninstall", "update".
        @type type: string        
        @param update: Set to True if a package is going to be updated (e.g. if the use-flags changed).
        @type update: boolean
        @param forceUpdate: Set to True if the update should be forced.
        @type forceUpdate: boolean
        @param unmask: True if we are allowed to look for masked packages
        @type unmask: boolean
        @param oneshot: True if this package should not be added to the world-file.
        @type oneshot: boolean
        
        @raises portato.backend.PackageNotFoundException: if trying to add a package which does not exist"""
        
        if type in ("install", "update"): # emerge
            if update:
                pkg = self._get_pkg_from_cpv(cpv, unmask)
                deps = pkg.get_dep_packages(return_blocks = True)
                
                if not forceUpdate and cpv in self.deps[type] and deps == self.deps[type][cpv]:
                    return # nothing changed - return
                else:
                    hasBeenInQueue = (cpv in self.mergequeue or cpv in self.oneshotmerge)
                    parentIt = self.tree.parent_iter(self.iters[type][cpv])

                    # delete it out of the tree - but NOT the changed flags
                    self.remove_with_children(self.iters[type][cpv], removeNewFlags = False)
                    
                    if hasBeenInQueue: # package has been in queue before
                        self._queue_append(cpv, oneshot)
                    
                    self.update_tree(parentIt, cpv, unmask, oneshot = oneshot,