#!/usr/bin/python
'''
    # DESCRIPTION:
    # Entropy Database Interface

    Copyright (C) 2007 Fabio Erculiani

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
'''

# Never do "import portage" here, please use entropyTools binding
# EXIT STATUSES: 300-399

from entropyConstants import *
import entropyTools
from outputTools import *
from pysqlite2 import dbapi2 as sqlite
import os
import sys
import string

# Logging initialization
import logTools
dbLog = logTools.LogFile(level = etpConst['databaseloglevel'],filename = etpConst['databaselogfile'], header = "[DBase]")


def database(options):

    import activatorTools
    import reagentTools
    import mirrorTools

    databaseRequestNoAsk = False
    _options = []
    for opt in options:
	if opt.startswith("--noask"):
	    databaseRequestNoAsk = True
	else:
	    _options.append(opt)
    options = _options

    if len(options) == 0:
	print_error(yellow(" * ")+red("Not enough parameters"))
	sys.exit(301)

    if (options[0] == "--initialize"):
	
	# do some check, print some warnings
	print_info(green(" * ")+red("Initializing Entropy database..."), back = True)
        # database file: etpConst['etpdatabasefilepath']
	revisionsMatch = {}
        if os.path.isfile(etpConst['etpdatabasefilepath']):
	    try:
		dbconn = etpDatabase(readOnly = True, noUpload = True)
		idpackages = dbconn.listAllIdpackages()
		for idpackage in idpackages:
		    package = os.path.basename(dbconn.retrieveDownloadURL(idpackage))
		    branch = dbconn.retrieveBranch(idpackage)
		    revision = dbconn.retrieveRevision(idpackage)
		    revisionsMatch[package] = [branch,revision]
		dbconn.closeDB()
	    except:
		pass
	    print_info(red(" * ")+bold("WARNING")+red(": database file already exists. Overwriting."))
	    rc = entropyTools.askquestion("\n     Do you want to continue ?")
	    if rc == "No":
	        sys.exit(0)
	    os.remove(etpConst['etpdatabasefilepath'])

	# initialize the database
        dbconn = etpDatabase(readOnly = False, noUpload = True)
	dbconn.initializeDatabase()
	
	# sync packages directory
	activatorTools.packages(["sync","--ask"])
	
	# now fill the database
	pkgbranches = os.listdir(etpConst['packagesbindir'])
	pkgbranches = [x for x in pkgbranches if os.path.isdir(etpConst['packagesbindir']+"/"+x)]
	#print revisionsMatch
	for mybranch in pkgbranches:
	
	    pkglist = os.listdir(etpConst['packagesbindir']+"/"+mybranch)
	
	    # filter .md5
	    _pkglist = []
	    for i in pkglist:
	        if not i.endswith(etpConst['packageshashfileext']):
		    _pkglist.append(i)
	    pkglist = _pkglist
	    if (not pkglist):
		continue

	    print_info(green(" * ")+red("Reinitializing Entropy database for branch ")+bold(mybranch)+red(" using Packages in the repository ..."))
	    currCounter = 0
	    atomsnumber = len(pkglist)
	    import reagentTools
	    
	    for pkg in pkglist:
		
	        print_info(darkgreen(" [")+red(mybranch)+darkgreen("] ")+red("Analyzing: ")+bold(pkg), back = True)
	        currCounter += 1
	        print_info(darkgreen(" [")+red(mybranch)+darkgreen("] ")+green("(")+ blue(str(currCounter))+"/"+red(str(atomsnumber))+green(") ")+red("Analyzing ")+bold(pkg)+red(" ..."), back = True)
		
	        etpData = reagentTools.extractPkgData(etpConst['packagesbindir']+"/"+mybranch+"/"+pkg, mybranch)
	        # remove disgregated package
		revisionAvail = revisionsMatch.get(os.path.basename(etpData['download']),None)
		addRevision = 0
		if (revisionAvail):
		    if mybranch == revisionAvail[0]:
			addRevision = revisionAvail[1]+1
	        # fill the db entry
	        idpk, revision, etpDataUpdated, accepted = dbconn.addPackage(etpData, revision = addRevision, wantedBranch = mybranch)
		
		print_info(darkgreen(" [")+red(mybranch)+darkgreen("] ")+green("(")+ blue(str(currCounter))+"/"+red(str(atomsnumber))+green(") ")+red("Analyzing ")+bold(pkg)+red(". Revision: ")+blue(str(addRevision)))
	    
	    dbconn.commitChanges()
	
	# regen dependstable
        reagentTools.dependsTableInitialize(dbconn, False)
	
	dbconn.closeDB()
	print_info(green(" * ")+red("Entropy database has been reinitialized using binary packages available"))

    # used by reagent
    elif (options[0] == "search"):
	mykeywords = options[1:]
	if (len(mykeywords) == 0):
	    print_error(yellow(" * ")+red("Not enough parameters"))
	    sys.exit(302)
	if (not os.path.isfile(etpConst['etpdatabasefilepath'])):
	    print_error(yellow(" * ")+red("Entropy Datbase does not exist"))
	    sys.exit(303)
	# search tool
	print_info(green(" * ")+red("Searching ..."))
	# open read only
	dbconn = etpDatabase(True)
	foundCounter = 0
	for mykeyword in mykeywords:
	    results = dbconn.searchPackages(mykeyword)
	    
	    for result in results:
		foundCounter += 1
		print 
		print_info(green(" * ")+bold(dbconn.retrieveCategory(result[1])+"/"+dbconn.retrieveName(result[1])))   # package atom
		
		print_info(red("\t Atom: ")+blue(result[0]))
		print_info(red("\t Name: ")+blue(dbconn.retrieveName(result[1])))
		print_info(red("\t Version: ")+blue(dbconn.retrieveVersion(result[1])))
		tag = dbconn.retrieveVersionTag(result[1])
		if (tag):
		    print_info(red("\t Tag: ")+blue(tag))
		
		description = dbconn.retrieveDescription(result[1])
		if (description):
		    print_info(red("\t Description: ")+description)
		
		flags = dbconn.retrieveCompileFlags(result[1])
		print_info(red("\t CHOST: ")+blue(flags[0]))
		print_info(red("\t CFLAGS: ")+darkred(flags[1]))
		print_info(red("\t CXXFLAGS: ")+darkred(flags[2]))
		
		website = dbconn.retrieveHomepage(result[1])
		if (website):
		    print_info(red("\t Website: ")+website)
		
		flags = string.join(dbconn.retrieveUseflags(result[1])," ")
		if (flags):
		    print_info(red("\t USE Flags: ")+blue(flags))
		
		print_info(red("\t License: ")+bold(dbconn.retrieveLicense(result[1])))
		keywords = string.join(dbconn.retrieveKeywords(result[1])," ")
		binkeywords = string.join(dbconn.retrieveBinKeywords(result[1])," ")
		print_info(red("\t Source keywords: ")+darkblue(keywords))
		print_info(red("\t Binary keywords: ")+green(binkeywords))
		print_info(red("\t Package branch: ")+dbconn.retrieveBranch(result[1]))
		print_info(red("\t Download relative URL: ")+dbconn.retrieveDownloadURL(result[1]))
		print_info(red("\t Package Checksum: ")+green(dbconn.retrieveDigest(result[1])))
		
		sources = dbconn.retrieveSources(result[1])
		if (sources):
		    print_info(red("\t Sources"))
		    for source in sources:
			print_info(darkred("\t    # Source package: ")+yellow(source))
		
		slot = dbconn.retrieveSlot(result[1])
		if (slot):
		    print_info(red("\t Slot: ")+yellow(slot))
		else:
		    print_info(red("\t Slot: ")+yellow("Not set"))
		
		'''
		mirrornames = []
		for x in sources:
		    if x.startswith("mirror://"):
		        mirrorname = x.split("/")[2]
		        mirrornames.append(mirrorname)
		for mirror in mirrornames:
		    mirrorlinks = dbconn.retrieveMirrorInfo(mirror)
		    print_info(red("\t mirror://"+mirror+" = ")+str(string.join(mirrorlinks," "))) # I don't need to print mirrorlinks
		'''
		
		dependencies = dbconn.retrieveDependencies(result[1])
		if (dependencies):
		    print_info(red("\t Dependencies"))
		    for dep in dependencies:
			print_info(darkred("\t    # Depends on: ")+dep)
		#print_info(red("\t Blah: ")+result[20]) --> it's a dup of [21]
		
		conflicts = dbconn.retrieveConflicts(result[1])
		if (conflicts):
		    print_info(red("\t Conflicts with"))
		    for conflict in conflicts:
			print_info(darkred("\t    # Conflict: ")+conflict)
		
		api = dbconn.retrieveApi(result[1])
		print_info(red("\t Entry API: ")+green(str(api)))
		
		date = dbconn.retrieveDateCreation(result[1])
		print_info(red("\t Package Creation date: ")+str(entropyTools.convertUnixTimeToHumanTime(float(date))))
		
		revision = dbconn.retrieveRevision(result[1])
		print_info(red("\t Entry revision: ")+str(revision))
		#print result
		
	dbconn.closeDB()
	if (foundCounter == 0):
	    print_warning(red(" * ")+red("Nothing found."))
	else:
	    print

    elif (options[0] == "create-empty-database"):
	mypath = options[1:]
	if len(mypath) == 0:
	    print_error(yellow(" * ")+red("Not enough parameters"))
	    sys.exit(303)
	if (os.path.dirname(mypath[0]) != '') and (not os.path.isdir(os.path.dirname(mypath[0]))):
	    print_error(green(" * ")+red("Supplied directory does not exist."))
	    sys.exit(304)
	print_info(green(" * ")+red("Initializing an empty database file with Entropy structure ..."),back = True)
	connection = sqlite.connect(mypath[0])
	cursor = connection.cursor()
	for sql in etpSQLInitDestroyAll.split(";"):
	    if sql:
	        cursor.execute(sql+";")
	del sql
	for sql in etpSQLInit.split(";"):
	    if sql:
		cursor.execute(sql+";")
	connection.commit()
	cursor.close()
	connection.close()
	print_info(green(" * ")+red("Entropy database file ")+bold(mypath[0])+red(" successfully initialized."))

    elif (options[0] == "stabilize") or (options[0] == "unstabilize"): # FIXME: adapt to the new branches structure

	if options[0] == "stabilize":
	    stable = True
	else:
	    stable = False
	
	if (stable):
	    print_info(green(" * ")+red("Collecting packages that would be marked stable ..."), back = True)
	else:
	    print_info(green(" * ")+red("Collecting packages that would be marked unstable ..."), back = True)
	
	myatoms = options[1:]
	if len(myatoms) == 0:
	    print_error(yellow(" * ")+red("Not enough parameters"))
	    sys.exit(303)
	# is world?
	if myatoms[0] == "world":
	    # open db in read only
	    dbconn = etpDatabase(readOnly = True)
	    if (stable):
	        pkglist = dbconn.listUnstablePackages()
	    else:
		pkglist = dbconn.listStablePackages()
	    # This is the list of all the packages available in Entropy
	    dbconn.closeDB()
	else:
	    pkglist = []
	    for atom in myatoms:
		# validate atom
		dbconn = etpDatabase(readOnly = True)
		if (stable):
		    pkg = dbconn.searchPackagesInBranch(atom,"unstable")
		else:
		    pkg = dbconn.searchPackagesInBranch(atom,"stable")
		for x in pkg:
		    pkglist.append(x[0])
	
	# filter dups
	pkglist = list(set(pkglist))
	# check if atoms were found
	if len(pkglist) == 0:
	    print
	    print_error(yellow(" * ")+red("No packages found."))
	    sys.exit(303)
	
	# show what would be done
	if (stable):
	    print_info(green(" * ")+red("These are the packages that would be marked stable:"))
	else:
	    print_info(green(" * ")+red("These are the packages that would be marked unstable:"))

	for pkg in pkglist:
	    print_info(red("\t (*) ")+bold(pkg))
	
	# ask to continue
	rc = entropyTools.askquestion("     Would you like to continue ?")
	if rc == "No":
	    sys.exit(0)
	
	# now mark them as stable
	print_info(green(" * ")+red("Marking selected packages ..."))

	# open db
	dbconn = etpDatabase(readOnly = False, noUpload = True)
	import re
	for pkg in pkglist:
	    print_info(green(" * ")+red("Marking package: ")+bold(pkg)+red(" ..."), back = True)
	    rc, action = dbconn.stabilizePackage(pkg,stable)
	    # @rc: True if updated, False if not
	    # @action: action taken: "stable" for stabilized package, "unstable" for unstabilized package
	    if (rc):
		
		print_info(green(" * ")+red("Package: ")+bold(pkg)+red(" needs to be marked ")+bold(action), back = True)
		
		# change download database parameter name
		download = dbconn.retrievePackageVar(pkg, "download", branch = action)
		# change action with the opposite:
		if action == "stable":
		    # move to unstable
		    oppositeAction = "unstable"
		else:
		    oppositeAction = "stable"
		
		oldpkgfilename = os.path.basename(download)
		download = re.subn("-"+oppositeAction,"-"+action, download)
		
		if download[1]: # if the name has been converted
		
		    newpkgfilename = os.path.basename(download[0])
		
		    # change download parameter in the database entry
		    dbconn.writePackageParameter(pkg, "download", download[0], action)
		
		    print_info(green("   * ")+yellow("Updating local package name"))
		
		    # change filename locally
		    if os.path.isfile(etpConst['packagesbindir']+"/"+oldpkgfilename):
		        os.rename(etpConst['packagesbindir']+"/"+oldpkgfilename,etpConst['packagesbindir']+"/"+newpkgfilename)
		
		    print_info(green("   * ")+yellow("Updating local package checksum"))
		
		    # update md5
		    if os.path.isfile(etpConst['packagesbindir']+"/"+oldpkgfilename+etpConst['packageshashfileext']):
			
		        f = open(etpConst['packagesbindir']+"/"+oldpkgfilename+etpConst['packageshashfileext'])
		        oldMd5 = f.readline().strip()
		        f.close()
		        newMd5 = re.subn(oldpkgfilename, newpkgfilename, oldMd5)
		        if newMd5[1]:
			    f = open(etpConst['packagesbindir']+"/"+newpkgfilename+etpConst['packageshashfileext'],"w")
			    f.write(newMd5[0]+"\n")
			    f.flush()
			    f.close()
		        # remove old
		        os.remove(etpConst['packagesbindir']+"/"+oldpkgfilename+etpConst['packageshashfileext'])
			
		    else: # old md5 does not exist
			
			entropyTools.createHashFile(etpConst['packagesbindir']+"/"+newpkgfilename)
			
		
		    print_info(green("   * ")+yellow("Updating remote package information"))
		
		    # change filename remotely
		    ftp = mirrorTools.handlerFTP(uri)
		    ftp.setCWD(etpConst['binaryurirelativepath'])
		    if (ftp.isFileAvailable(etpConst['packagesbindir']+"/"+oldpkgfilename)):
			# rename tbz2
			ftp.renameFile(oldpkgfilename,newpkgfilename)
			# remove old .md5
			ftp.deleteFile(oldpkgfilename+etpConst['packageshashfileext'])
			# upload new .md5 if found
			if os.path.isfile(etpConst['packagesbindir']+"/"+newpkgfilename+etpConst['packageshashfileext']):
			    ftp.uploadFile(etpConst['packagesbindir']+"/"+newpkgfilename+etpConst['packageshashfileext'],ascii = True)
		

	dbconn.commitChanges()
	print_info(green(" * ")+red("All the selected packages have been marked as requested. Have fun."))
	dbconn.closeDB()

    elif (options[0] == "remove"):

	print_info(green(" * ")+red("Scanning packages that would be removed ..."), back = True)
	
	myopts = options[1:]
	_myopts = []
	branch = ''
	for opt in myopts:
	    if (opt.startswith("--branch=")) and (len(opt.split("=")) == 2):
		
		try:
		    branch = opt.split("=")[1]
		    idx = etpConst['branches'].index(branch)
		    etpConst['branch'] = branch
		except:
		    pass
	    else:
		_myopts.append(opt)
	myopts = _myopts
	
	if len(myopts) == 0:
	    print_error(yellow(" * ")+red("Not enough parameters"))
	    sys.exit(303)

	pkglist = []
	dbconn = etpDatabase(readOnly = True)
	
	for atom in myopts:
	    pkg = dbconn.atomMatch(atom)
	    if pkg[0] != -1:
	        pkglist.append(pkg[0])

	# filter dups
	pkglist = list(set(pkglist))
	# check if atoms were found
	if len(pkglist) == 0:
	    print
	    dbconn.closeDB()
	    print_error(yellow(" * ")+red("No packages found."))
	    sys.exit(303)
	
	print_info(green(" * ")+red("These are the packages that would be removed from the database:"))

	for pkg in pkglist:
	    pkgatom = dbconn.retrieveAtom(pkg)
	    branch = dbconn.retrieveBranch(pkg)
	    print_info(red("\t (*) ")+bold(pkgatom)+blue(" [")+red(branch)+blue("]"))

	dbconn.closeDB()

	# ask to continue
	rc = entropyTools.askquestion("     Would you like to continue ?")
	if rc == "No":
	    sys.exit(0)
	
	# now mark them as stable
	print_info(green(" * ")+red("Removing selected packages ..."))

	# open db
	dbconn = etpDatabase(readOnly = False, noUpload = True)
	for pkg in pkglist:
	    pkgatom = dbconn.retrieveAtom(pkg)
	    print_info(green(" * ")+red("Removing package: ")+bold(pkgatom)+red(" ..."), back = True)
	    dbconn.removePackage(pkg)
	dbconn.commitChanges()
	print_info(green(" * ")+red("All the selected packages have been removed as requested. To remove online binary packages, just run Activator."))
	dbconn.closeDB()

    # used by reagent
    elif (options[0] == "statistics"):
	print_info(green(" [LOCAL DB STATISTIC]\t\t")+red("Information"))
	# fetch total packages
	dbconn = etpDatabase(readOnly = True)
	totalpkgs = len(dbconn.listAllPackages())
	totalstablepkgs = len(dbconn.listStablePackages())
	totalunstablepkgs = len(dbconn.listUnstablePackages())
	print_info(green(" Total Installed Packages\t\t")+red(str(totalpkgs)))
	print_info(green(" Total Stable Packages\t\t")+red(str(totalstablepkgs)))
	print_info(green(" Total Unstable Packages\t\t")+red(str(totalunstablepkgs)))
	activatorTools.syncRemoteDatabases(justStats = True)
	dbconn.closeDB()

    # used by reagent
    # FIXME: complete this with some automated magic
    elif (options[0] == "md5check"):

	print_info(green(" * ")+red("Integrity verification of the selected packages:"))

	mypackages = options[1:]
	dbconn = etpDatabase(readOnly = True)
	
	# statistic vars
	pkgMatch = 0
	pkgNotMatch = 0
	pkgDownloadedSuccessfully = 0
	pkgDownloadedError = 0
	worldSelected = False
	
	if (len(mypackages) == 0):
	    # check world
	    # create packages list
	    worldSelected = True
	    pkgs2check = dbconn.listAllPackages()
	elif (mypackages[0] == "world"):
	    # check world
	    # create packages list
	    worldSelected = True
	    pkgs2check = dbconn.listAllPackages()
	else:
	    # catch the names
	    pkgs2check = []
	    for pkg in mypackages:
		results = dbconn.searchPackages(pkg)
		for i in results:
		    pkgs2check.append(i)

	if (not worldSelected):
	    print_info(red("   This is the list of the packages that would be checked:"))
	else:
	    print_info(red("   All the packages in the Entropy Packages repository will be checked."))
	
	toBeDownloaded = []
	availList = []
	for pkginfo in pkgs2check:
	
	    pkgatom = pkginfo[0]
	    idpackage = pkginfo[1]
	    pkgbranch = pkginfo[2]
	    pkgfile = dbconn.retrieveDownloadURL(idpackage)
	    pkgfile = os.path.basename(pkgfile)
	    if (os.path.isfile(etpConst['packagesbindir']+"/"+pkgbranch+"/"+pkgfile)):
		if (not worldSelected): print_info(green("   - [PKG AVAILABLE] ")+red(pkgatom)+" -> "+bold(pkgfile))
		availList.append(idpackage)
	    elif (os.path.isfile(etpConst['packagessuploaddir']+"/"+pkgbranch+"/"+pkgfile)):
		if (not worldSelected): print_info(green("   - [RUN ACTIVATOR] ")+darkred(pkgatom)+" -> "+bold(pkgfile))
	    else:
		if (not worldSelected): print_info(green("   - [MUST DOWNLOAD] ")+yellow(pkgatom)+" -> "+bold(pkgfile))
		toBeDownloaded.append([idpackage,pkgfile,pkgbranch])
	
	if (not databaseRequestNoAsk):
	    rc = entropyTools.askquestion("     Would you like to continue ?")
	    if rc == "No":
	        sys.exit(0)

	notDownloadedPackages = []
	if (toBeDownloaded != []):
	    print_info(red("   Starting to download missing files..."))
	    for uri in etpConst['activatoruploaduris']:
		
		if (notDownloadedPackages != []):
		    print_info(red("   Trying to search missing or broken files on another mirror ..."))
		    toBeDownloaded = notDownloadedPackages
		    notDownloadedPackages = []
		
		for pkg in toBeDownloaded:
		    rc = activatorTools.downloadPackageFromMirror(uri,pkg[1],pkg[2])
		    if (rc is None):
			notDownloadedPackages.append([pkg[1],pkg[2]])
		    if (rc == False):
			notDownloadedPackages.append([pkg[1],pkg[2]])
		    if (rc == True):
			pkgDownloadedSuccessfully += 1
			availList.append(pkg[0])
		
		if (notDownloadedPackages == []):
		    print_info(red("   All the binary packages have been downloaded successfully."))
		    break
	
	    if (notDownloadedPackages != []):
		print_warning(red("   These are the packages that cannot be found online:"))
		for i in notDownloadedPackages:
		    pkgDownloadedError += 1
		    print_warning(red("    * ")+yellow(i[0])+" in "+blue(i[1]))
		print_warning(red("   They won't be checked."))
	
	brokenPkgsList = []
	totalcounter = str(len(availList))
	currentcounter = 0
	for pkg in availList:
	    currentcounter += 1
	    pkgfile = dbconn.retrieveDownloadURL(pkg)
	    pkgbranch = dbconn.retrieveBranch(pkg)
	    pkgfile = os.path.basename(pkgfile)
	    print_info("  ("+red(str(currentcounter))+"/"+blue(totalcounter)+") "+red("Checking hash of ")+yellow(pkgfile)+red(" in branch: ")+blue(pkgbranch)+red(" ..."), back = True)
	    storedmd5 = dbconn.retrieveDigest(pkg)
	    result = entropyTools.compareMd5(etpConst['packagesbindir']+"/"+pkgbranch+"/"+pkgfile,storedmd5)
	    if (result):
		# match !
		pkgMatch += 1
		#print_info(red("   Package ")+yellow(pkg)+green(" is healthy. Checksum: ")+yellow(storedmd5), back = True)
	    else:
		pkgNotMatch += 1
		print_error(red("   Package ")+yellow(pkgfile)+red(" in branch: ")+blue(pkgbranch)+red(" is _NOT_ healthy !!!! Stored checksum: ")+yellow(storedmd5))
		brokenPkgsList.append([pkgfile,pkgbranch])

	dbconn.closeDB()

	if (brokenPkgsList != []):
	    print_info(blue(" *  This is the list of the BROKEN packages: "))
	    for bp in brokenPkgsList:
		print_info(red("    * Package file: ")+bold(bp[0])+red(" in branch: ")+blue(bp[1]))

	# print stats
	print_info(blue(" *  Statistics: "))
	print_info(yellow("     Number of checked packages:\t\t")+str(pkgMatch+pkgNotMatch))
	print_info(green("     Number of healthy packages:\t\t")+str(pkgMatch))
	print_info(red("     Number of broken packages:\t\t")+str(pkgNotMatch))
	if (pkgDownloadedSuccessfully > 0) or (pkgDownloadedError > 0):
	    print_info(green("     Number of downloaded packages:\t\t")+str(pkgDownloadedSuccessfully+pkgDownloadedError))
	    print_info(green("     Number of happy downloads:\t\t")+str(pkgDownloadedSuccessfully))
	    print_info(red("     Number of failed downloads:\t\t")+str(pkgDownloadedError))


############
# Functions and Classes
#####################################################################################

# this class simply describes the current database status
class databaseStatus:

    def __init__(self):
	
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus.__init__ called.")
	
	self.databaseBumped = False
	self.databaseInfoCached = False
	self.databaseLock = False
	#self.database
	self.databaseDownloadLock = False
	self.databaseAlreadyTainted = False
	
	if os.path.isfile(etpConst['etpdatabasedir']+"/"+etpConst['etpdatabasetaintfile']):
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus: database tainted.")
	    self.databaseAlreadyTainted = True

    def isDatabaseAlreadyBumped(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus: already bumped? "+str(self.databaseBumped))
	return self.databaseBumped

    def isDatabaseAlreadyTainted(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus: tainted? "+str(self.databaseAlreadyTainted))
	return self.databaseAlreadyTainted

    def setDatabaseTaint(self,bool):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus: setting database taint to: "+str(bool))
	self.databaseAlreadyTainted = bool

    def setDatabaseBump(self,bool):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus: setting database bump to: "+str(bool))
	self.databaseBumped = bool

    def setDatabaseLock(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus: Locking database (upload)")
	self.databaseLock = True

    def unsetDatabaseLock(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus: Unlocking database (upload)")
	self.databaseLock = False

    def getDatabaseLock(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus: getting database lock info (upload), status: "+str(self.databaseLock))
	return self.databaseLock

    def setDatabaseDownloadLock(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus: Locking database (download)")
	self.databaseDownloadLock = True

    def unsetDatabaseDownloadLock(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus: Unlocking database (download)")
	self.databaseDownloadLock = False

    def getDatabaseDownloadLock(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"DatabaseStatus: getting database lock info (download), status: "+str(self.databaseDownloadLock))
	return self.databaseDownloadLock

class etpDatabase:

    def __init__(self, readOnly = False, noUpload = False, dbFile = etpConst['etpdatabasefilepath'], clientDatabase = False, xcache = True):
	
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"etpDatabase.__init__ called.")
	
	self.readOnly = readOnly
	self.noUpload = noUpload
	self.packagesRemoved = False
	self.packagesAdded = False
	self.clientDatabase = clientDatabase
	self.xcache = xcache
	
	# caching dictionaries
	self.databaseCache = {}
	self.matchCache = {} # dependencies resolving
	
	if (self.clientDatabase):
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"etpDatabase: database opened by Entropy client, file: "+str(dbFile))
	    # if the database is opened readonly, we don't need to lock the online status
	    self.connection = sqlite.connect(dbFile)
	    self.cursor = self.connection.cursor()
	    # set the table read only
	    return
	
	if (self.readOnly):
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"etpDatabase: database opened readonly, file: "+str(dbFile))
	    # if the database is opened readonly, we don't need to lock the online status
	    self.connection = sqlite.connect(dbFile)
	    self.cursor = self.connection.cursor()
	    # set the table read only
	    return
	
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"etpDatabase: database opened in read/write mode, file: "+str(dbFile))

	import mirrorTools
	import activatorTools

	# check if the database is locked locally
	if os.path.isfile(etpConst['etpdatabasedir']+"/"+etpConst['etpdatabaselockfile']):
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"etpDatabase: database already locked")
	    print_info(red(" * ")+red("Entropy database is already locked by you :-)"))
	else:
	    # check if the database is locked REMOTELY
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_NORMAL,"etpDatabase: starting to lock and sync database")
	    print_info(red(" * ")+red(" Locking and Syncing Entropy database ..."), back = True)
	    for uri in etpConst['activatoruploaduris']:
		dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"etpDatabase: connecting to "+uri)
	        ftp = mirrorTools.handlerFTP(uri)
	        ftp.setCWD(etpConst['etpurirelativepath'])
	        if (ftp.isFileAvailable(etpConst['etpdatabaselockfile'])) and (not os.path.isfile(etpConst['etpdatabasedir']+"/"+etpConst['etpdatabaselockfile'])):
		    import time
		    print_info(red(" * ")+bold("WARNING")+red(": online database is already locked. Waiting up to 2 minutes..."), back = True)
		    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"etpDatabase: online database already locked. Waiting 2 minutes")
		    unlocked = False
		    for x in range(120):
		        time.sleep(1)
		        if (not ftp.isFileAvailable(etpConst['etpdatabaselockfile'])):
			    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_NORMAL,"etpDatabase: online database has been unlocked !")
			    print_info(red(" * ")+bold("HOORAY")+red(": online database has been unlocked. Locking back and syncing..."))
			    unlocked = True
			    break
		    if (unlocked):
		        break

		    dbLog.log(ETP_LOGPRI_ERROR,ETP_LOGLEVEL_NORMAL,"etpDatabase: online database has not been unlocked in time. Giving up.")
		    # time over
		    print_info(red(" * ")+bold("ERROR")+red(": online database has not been unlocked. Giving up. Who the hell is working on it? Damn, it's so frustrating for me. I'm a piece of python code with a soul dude!"))
		    # FIXME show the lock status

		    print_info(yellow(" * ")+green("Mirrors status table:"))
		    dbstatus = activatorTools.getMirrorsLock()
		    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"etpDatabase: showing mirrors status table:")
		    for db in dbstatus:
		        if (db[1]):
	        	    db[1] = red("Locked")
	    	        else:
	        	    db[1] = green("Unlocked")
	    	        if (db[2]):
	        	    db[2] = red("Locked")
	                else:
	        	    db[2] = green("Unlocked")
			dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"   "+entropyTools.extractFTPHostFromUri(db[0])+": DATABASE: "+db[1]+" | DOWNLOAD: "+db[2])
	    	        print_info(bold("\t"+entropyTools.extractFTPHostFromUri(db[0])+": ")+red("[")+yellow("DATABASE: ")+db[1]+red("] [")+yellow("DOWNLOAD: ")+db[2]+red("]"))
	    
	            ftp.closeConnection()
	            sys.exit(320)

	    # if we arrive here, it is because all the mirrors are unlocked so... damn, LOCK!
	    activatorTools.lockDatabases(True)

	    # ok done... now sync the new db, if needed
	    activatorTools.syncRemoteDatabases(self.noUpload)
	
	self.connection = sqlite.connect(dbFile,timeout=300.0)
	self.cursor = self.connection.cursor()

    def loadMatchCache(self, cache):
	self.matchCache = cache
	
    def getMatchCache(self):
	return self.matchCache

    def closeDB(self):
	
	# if the class is opened readOnly, close and forget
	if (self.readOnly):
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"closeDB: closing database opened in readonly.")
	    #self.connection.rollback()
	    self.cursor.close()
	    self.connection.close()
	    return

	# if it's equo that's calling the function, just save changes and quit
	if (self.clientDatabase):
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"closeDB: closing database opened by Entropy Client.")
	    self.commitChanges()
	    self.cursor.close()
	    self.connection.close()
	    return

	# Cleanups if at least one package has been removed
	# Please NOTE: the client database does not need it
	if (self.packagesRemoved):
	    self.cleanupUseflags()
	    self.cleanupSources()
	    self.cleanupDependencies()

	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"closeDB: closing database opened in read/write.")
	
	# FIXME verify all this shit, for now it works...
	if (entropyTools.dbStatus.isDatabaseAlreadyTainted()) and (not entropyTools.dbStatus.isDatabaseAlreadyBumped()):
	    # bump revision, setting DatabaseBump causes the session to just bump once
	    entropyTools.dbStatus.setDatabaseBump(True)
	    self.revisionBump()
	
	if (not entropyTools.dbStatus.isDatabaseAlreadyTainted()):
	    # we can unlock it, no changes were made
	    import activatorTools
	    activatorTools.lockDatabases(False)
	else:
	    print_info(yellow(" * ")+green("Mirrors have not been unlocked. Run activator."))
	
	self.cursor.close()
	self.connection.close()

    def commitChanges(self):
	if (not self.readOnly):
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"commitChanges: writing changes to database.")
	    try:
	        self.connection.commit()
	    except:
		pass
	    self.taintDatabase()
	else:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_VERBOSE,"commitChanges: discarding changes to database (opened readonly).")
	    self.discardChanges() # is it ok?

    def taintDatabase(self):
	if (self.clientDatabase): # if it's equo to open it, this should be avoided
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"taintDatabase: called by Entropy client, won't do anything.")
	    return
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"taintDatabase: called.")
	# taint the database status
	f = open(etpConst['etpdatabasedir']+"/"+etpConst['etpdatabasetaintfile'],"w")
	f.write(etpConst['currentarch']+" database tainted\n")
	f.flush()
	f.close()
	entropyTools.dbStatus.setDatabaseTaint(True)

    def untaintDatabase(self):
	if (self.clientDatabase): # if it's equo to open it, this should be avoided
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"untaintDatabase: called by Entropy client, won't do anything.")
	    return
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"untaintDatabase: called.")
	entropyTools.dbStatus.setDatabaseTaint(False)
	# untaint the database status
	entropyTools.spawnCommand("rm -f "+etpConst['etpdatabasedir']+"/"+etpConst['etpdatabasetaintfile'])

    def revisionBump(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"revisionBump: called.")
	if (not os.path.isfile(etpConst['etpdatabasedir']+"/"+etpConst['etpdatabaserevisionfile'])):
	    revision = 0
	else:
	    f = open(etpConst['etpdatabasedir']+"/"+etpConst['etpdatabaserevisionfile'],"r")
	    revision = int(f.readline().strip())
	    revision += 1
	    f.close()
	f = open(etpConst['etpdatabasedir']+"/"+etpConst['etpdatabaserevisionfile'],"w")
	f.write(str(revision)+"\n")
	f.flush()
	f.close()

    def isDatabaseTainted(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isDatabaseTainted: called.")
	if os.path.isfile(etpConst['etpdatabasedir']+"/"+etpConst['etpdatabasetaintfile']):
	    return True
	return False

    def discardChanges(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"discardChanges: called.")
	self.connection.rollback()

    # never use this unless you know what you're doing
    def initializeDatabase(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"initializeDatabase: called.")
	for sql in etpSQLInitDestroyAll.split(";"):
	    if sql:
	        self.cursor.execute(sql+";")
	del sql
	for sql in etpSQLInit.split(";"):
	    if sql:
		self.cursor.execute(sql+";")
	self.commitChanges()

    # this function manages the submitted package
    # if it does not exist, it fires up addPackage
    # otherwise it fires up updatePackage
    def handlePackage(self, etpData, forcedRevision = -1, forcedBranch = False):

	if (self.readOnly):
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"handlePackage: Cannot handle this in read only.")
	    raise Exception, "What are you trying to do?"

        # prepare versiontag
	versiontag = ""
	if (etpData['versiontag']):
	    versiontag = "-"+etpData['versiontag']

	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"handlePackage: called.")
	if (not self.isPackageAvailable(etpData['category']+"/"+etpData['name']+"-"+etpData['version']+versiontag)):
	    if (forcedRevision < 0):
		forcedRevision = 0
	    if (forcedBranch):
	        idpk, revision, etpDataUpdated, accepted = self.addPackage(etpData, revision = forcedRevision, wantedBranch = etpData['branch'])
	    else:
		idpk, revision, etpDataUpdated, accepted = self.addPackage(etpData, revision = forcedRevision)
	else:
	    idpk, revision, etpDataUpdated, accepted = self.updatePackage(etpData, forcedRevision) # branch and revision info will be overwritten
	return idpk, revision, etpDataUpdated, accepted


    # FIXME: default add an unstable package ~~ use indexes
    def addPackage(self, etpData, revision = 0, wantedBranch = etpConst['branch']):

	if (self.readOnly):
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addPackage: Cannot handle this in read only.")
	    raise Exception, "What are you trying to do?"

	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addPackage: called.")
	
	self.matchCache = {} # dependencies handling cache tainted
	
	# if a similar package, in the same branch exists, mark for removal
	searchsimilar = self.searchSimilarPackages(etpData['category']+"/"+etpData['name'], branch = wantedBranch)
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_NORMAL,"addPackage: here is the list of similar packages (that will be removed) found for "+etpData['category']+"/"+etpData['name']+": "+str(searchsimilar))
	removelist = []
	for oldpkg in searchsimilar:
	    # get the package slot
	    idpackage = oldpkg[1]
	    slot = self.retrieveSlot(idpackage)
	    if (etpData['slot'] == slot):
		# remove!
		removelist.append(idpackage)
	
	for pkg in removelist:
	    self.removePackage(pkg)
	
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addPackage: inserting: ")
	for ln in etpData:
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"\t "+ln+": "+str(etpData[ln]))

	# create new category if it doesn't exist
	catid = self.isCategoryAvailable(etpData['category'])
	if (catid == -1):
	    # create category
	    catid = self.addCategory(etpData['category'])

	# create new license if it doesn't exist
	licid = self.isLicenseAvailable(etpData['license'])
	if (licid == -1):
	    # create category
	    licid = self.addLicense(etpData['license'])

	# look for configured versiontag
	versiontag = ""
	if (etpData['versiontag']):
	    versiontag = "-"+etpData['versiontag']

	# baseinfo
	self.cursor.execute(
		'INSERT into baseinfo VALUES '
		'(NULL,?,?,?,?,?,?,?,?,?,?)'
		, (	etpData['category']+"/"+etpData['name']+"-"+etpData['version']+versiontag,
			catid,
			etpData['name'],
			etpData['version'],
			etpData['versiontag'],
			revision,
			wantedBranch,
			etpData['slot'],
			licid,
			etpData['etpapi'],
			)
	)
	self.connection.commit()
	idpackage = self.cursor.lastrowid

	# create new idflag if it doesn't exist
	idflags = self.areCompileFlagsAvailable(etpData['chost'],etpData['cflags'],etpData['cxxflags'])
	if (idflags == -1):
	    # create category
	    idflags = self.addCompileFlags(etpData['chost'],etpData['cflags'],etpData['cxxflags'])

	# extrainfo
	self.cursor.execute(
		'INSERT into extrainfo VALUES '
		'(?,?,?,?,?,?,?,?)'
		, (	idpackage,
			etpData['description'],
			etpData['homepage'],
			etpData['download'],
			etpData['size'],
			idflags,
			etpData['digest'],
			etpData['datecreation'],
			)
	)

	# content, a list
	for file in etpData['content']:
	    self.cursor.execute(
		'INSERT into content VALUES '
		'(?,?)'
		, (	idpackage,
			file,
			)
	    )
	
	# counter, if != -1
	try:
	    if etpData['counter'] != -1:
	        self.cursor.execute(
	        'INSERT into counters VALUES '
	        '(?,?)'
	        , (	etpData['counter'],
		    idpackage,
		    )
	        )
	except:
	    pass # FIXME: temp woraround, add check for clientDbconn
	
	# on disk size
	try:
	    self.cursor.execute(
	    'INSERT into sizes VALUES '
	    '(?,?)'
	    , (	idpackage,
		etpData['disksize'],
		)
	    )
	except:
	    # create sizes table, temp hack
	    self.createSizesTable()
	    self.cursor.execute(
	    'INSERT into sizes VALUES '
	    '(?,?)'
	    , (	idpackage,
		etpData['disksize'],
		)
	    )
	
	# dependencies, a list
	for dep in etpData['dependencies']:
	
	    iddep = self.isDependencyAvailable(dep)
	    if (iddep == -1):
	        # create category
	        iddep = self.addDependency(dep)
	
	    self.cursor.execute(
		'INSERT into dependencies VALUES '
		'(?,?)'
		, (	idpackage,
			iddep,
			)
	    )

	# provide
	for atom in etpData['provide']:
	    self.cursor.execute(
		'INSERT into provide VALUES '
		'(?,?)'
		, (	idpackage,
			atom,
			)
	    )

	# compile messages
	try:
	    for message in etpData['messages']:
	        self.cursor.execute(
		'INSERT into messages VALUES '
		'(?,?)'
		, (	idpackage,
			message,
			)
	        )
	except:
	    # FIXME: temp workaround, create messages table
	    self.cursor.execute("CREATE TABLE messages ( idpackage INTEGER, message VARCHAR);")
	    for message in etpData['messages']:
	        self.cursor.execute(
		'INSERT into messages VALUES '
		'(?,?)'
		, (	idpackage,
			message,
			)
	        )
	
	# is it a system package?
	if etpData['systempackage']:
	    self.cursor.execute(
		'INSERT into systempackages VALUES '
		'(?)'
		, (	idpackage,
			)
	    )

	# create new protect if it doesn't exist
	idprotect = self.isProtectAvailable(etpData['config_protect'])
	if (idprotect == -1):
	    # create category
	    idprotect = self.addProtect(etpData['config_protect'])
	# fill configprotect
	self.cursor.execute(
		'INSERT into configprotect VALUES '
		'(?,?)'
		, (	idpackage,
			idprotect,
			)
	)
	
	idprotect = self.isProtectAvailable(etpData['config_protect_mask'])
	if (idprotect == -1):
	    # create category
	    idprotect = self.addProtect(etpData['config_protect_mask'])
	# fill configprotect
	self.cursor.execute(
		'INSERT into configprotectmask VALUES '
		'(?,?)'
		, (	idpackage,
			idprotect,
			)
	)

	# conflicts, a list
	for conflict in etpData['conflicts']:
	    self.cursor.execute(
		'INSERT into conflicts VALUES '
		'(?,?)'
		, (	idpackage,
			conflict,
			)
	    )

	# mirrorlinks, always update the table
	for mirrordata in etpData['mirrorlinks']:
	    mirrorname = mirrordata[0]
	    mirrorlist = mirrordata[1]
	    # remove old
	    self.removeMirrorEntries(mirrorname)
	    # add new
	    self.addMirrors(mirrorname,mirrorlist)

	# sources, a list
	for source in etpData['sources']:
	    
	    idsource = self.isSourceAvailable(source)
	    if (idsource == -1):
	        # create category
	        idsource = self.addSource(source)
	    
	    self.cursor.execute(
		'INSERT into sources VALUES '
		'(?,?)'
		, (	idpackage,
			idsource,
			)
	    )

	# useflags, a list
	for flag in etpData['useflags']:
	    
	    iduseflag = self.isUseflagAvailable(flag)
	    if (iduseflag == -1):
	        # create category
	        iduseflag = self.addUseflag(flag)
	    
	    self.cursor.execute(
		'INSERT into useflags VALUES '
		'(?,?)'
		, (	idpackage,
			iduseflag,
			)
	    )

	# create new keyword if it doesn't exist
	for key in etpData['keywords']:

	    idkeyword = self.isKeywordAvailable(key)
	    if (idkeyword == -1):
	        # create category
	        idkeyword = self.addKeyword(key)

	    self.cursor.execute(
		'INSERT into keywords VALUES '
		'(?,?)'
		, (	idpackage,
			idkeyword,
			)
	    )

	for key in etpData['binkeywords']:

	    idbinkeyword = self.isKeywordAvailable(key)
	    if (idbinkeyword == -1):
	        # create category
	        idbinkeyword = self.addKeyword(key)

	    self.cursor.execute(
		'INSERT into binkeywords VALUES '
		'(?,?)'
		, (	idpackage,
			idbinkeyword,
			)
	    )

	self.packagesAdded = True
	self.commitChanges()
	
	return idpackage, revision, etpData, True

    # Update already available atom in db
    # returns True,revision if the package has been updated
    # returns False,revision if not
    def updatePackage(self, etpData, forcedRevision = -1):

	if (self.readOnly):
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"updatePackage: Cannot handle this in read only.")
	    raise Exception, "What are you trying to do?"

	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"updatePackage: called.")

        # prepare versiontag
	versiontag = ""
	if (etpData['versiontag']):
	    versiontag = "-"+etpData['versiontag']
	# build atom string
	pkgatom = etpData['category'] + "/" + etpData['name'] + "-" + etpData['version']+versiontag

	# if client opened the database, before starting the update, remove previous entries - same atom, all branches
	if (self.clientDatabase):
	    
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"updatePackage: client request. Removing duplicated entries.")
	    atomInfos = self.searchPackages(pkgatom)
	    for atomInfo in atomInfos:
		idpackage = atomInfo[1]
		self.removePackage(idpackage)
	    
	    if (forcedRevision < 0):
		forcedRevision = 0 # FIXME: this shouldn't happen
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_NORMAL,"updatePackage: removal complete. Now spawning addPackage.")
	    x,y,z,accepted = self.addPackage(etpData, revision = forcedRevision, wantedBranch = etpData['branch'])
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_NORMAL,"updatePackage: returned back from addPackage.")
	    return x,y,z,accepted
	    
	else:
	    # update package in etpData['branch']
	    # get its package revision
	    idpackage = self.getIDPackage(pkgatom,etpData['branch'])
	    if (forcedRevision == -1):
	        if (idpackage != -1):
	            curRevision = self.retrieveRevision(idpackage)
	        else:
	            curRevision = 0
	    else:
		curRevision = forcedRevision

	    if (idpackage != -1): # remove old package in branch
	        self.removePackage(idpackage)
		if (forcedRevision == -1):
		    curRevision += 1
	    
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_NORMAL,"updatePackage: current revision set to "+str(curRevision))

	    # add the new one
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_NORMAL,"updatePackage: complete. Now spawning addPackage.")
	    x,y,z,accepted = self.addPackage(etpData, revision = curRevision, wantedBranch = etpData['branch'])
	    return x,y,z,accepted
	

    def removePackage(self,idpackage):

	if (self.readOnly):
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"removePackage: Cannot handle this in read only.")
	    raise Exception, "What are you trying to do?"

	key = self.retrieveAtom(idpackage)
	branch = self.retrieveBranch(idpackage)

	# clean package cache
	xcached = self.databaseCache.get(int(idpackage), None)
	if xcached:
	    try:
	        del self.databaseCache[int(idpackage)]
	    except:
		pass
	self.matchCache = {} # dependencies handling cache tainted

	idpackage = str(idpackage)
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_NORMAL,"removePackage: trying to remove (if exists) -> "+idpackage+":"+str(key)+" | branch: "+branch)
	# baseinfo
	self.cursor.execute('DELETE FROM baseinfo WHERE idpackage = '+idpackage)
	# extrainfo
	self.cursor.execute('DELETE FROM extrainfo WHERE idpackage = '+idpackage)
	# content
	self.cursor.execute('DELETE FROM content WHERE idpackage = '+idpackage)
	# dependencies
	self.cursor.execute('DELETE FROM dependencies WHERE idpackage = '+idpackage)
	# provide
	self.cursor.execute('DELETE FROM provide WHERE idpackage = '+idpackage)
	# conflicts
	self.cursor.execute('DELETE FROM conflicts WHERE idpackage = '+idpackage)
	# protect
	self.cursor.execute('DELETE FROM configprotect WHERE idpackage = '+idpackage)
	# protect_mask
	self.cursor.execute('DELETE FROM configprotectmask WHERE idpackage = '+idpackage)
	# sources
	self.cursor.execute('DELETE FROM sources WHERE idpackage = '+idpackage)
	# useflags
	self.cursor.execute('DELETE FROM useflags WHERE idpackage = '+idpackage)
	# keywords
	self.cursor.execute('DELETE FROM keywords WHERE idpackage = '+idpackage)
	# binkeywords
	self.cursor.execute('DELETE FROM binkeywords WHERE idpackage = '+idpackage)
	try:
	    # messages
	    self.cursor.execute('DELETE FROM messages WHERE idpackage = '+idpackage)
	except:
	    pass # FIXME: temp workaround
	# systempackage
	self.cursor.execute('DELETE FROM systempackages WHERE idpackage = '+idpackage)
	try:
	    # cpunter
	    self.cursor.execute('DELETE FROM counters WHERE idpackage = '+idpackage)
	except:
	    pass
	try:
	    # on disk sizes
	    self.cursor.execute('DELETE FROM sizes WHERE idpackage = '+idpackage)
	except:
	    pass
	
	# Remove from installedtable if exists
	self.removePackageFromInstalledTable(idpackage)
	# Remove from dependstable if exists
	self.removePackageFromDependsTable(idpackage)
	# need a final cleanup
	self.packagesRemoved = True
	
	self.commitChanges()

    def removeMirrorEntries(self,mirrorname):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"removeMirrors: removing entries for mirror -> "+str(mirrorname))
	self.cursor.execute('DELETE FROM mirrorlinks WHERE mirrorname = "'+mirrorname+'"')
	self.commitChanges()

    def addMirrors(self,mirrorname,mirrorlist):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addMirrors: adding Mirror list for "+str(mirrorname)+" -> "+str(mirrorlist))
	for x in mirrorlist:
	    self.cursor.execute(
		'INSERT into mirrorlinks VALUES '
		'(?,?)', (mirrorname,x,)
	    )
	self.commitChanges()

    def addCategory(self,category):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addCategory: adding Package Category -> "+str(category))
	self.cursor.execute(
		'INSERT into categories VALUES '
		'(NULL,?)', (category,)
	)
	# get info about inserted value and return
	cat = self.isCategoryAvailable(category)
	if cat != -1:
	    self.commitChanges()
	    return cat
	raise Exception, "I tried to insert a category but then, fetching it returned -1. There's something broken."

    def addProtect(self,protect):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addProtect: adding CONFIG_PROTECT/CONFIG_PROTECT_MASK -> "+str(protect))
	self.cursor.execute(
		'INSERT into configprotectreference VALUES '
		'(NULL,?)', (protect,)
	)
	# get info about inserted value and return
	prt = self.isProtectAvailable(protect)
	if prt != -1:
	    return prt
	raise Exception, "I tried to insert a protect but then, fetching it returned -1. There's something broken."

    def addSource(self,source):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addSource: adding Package Source -> "+str(source))
	self.cursor.execute(
		'INSERT into sourcesreference VALUES '
		'(NULL,?)', (source,)
	)
	# get info about inserted value and return
	src = self.isSourceAvailable(source)
	if src != -1:
	    return src
	raise Exception, "I tried to insert a source but then, fetching it returned -1. There's something broken."

    def addDependency(self,dependency):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addDependency: adding Package Dependency -> "+str(dependency))
	self.cursor.execute(
		'INSERT into dependenciesreference VALUES '
		'(NULL,?)', (dependency,)
	)
	# get info about inserted value and return
	dep = self.isDependencyAvailable(dependency)
	if dep != -1:
	    return dep
	raise Exception, "I tried to insert a dependency but then, fetching it returned -1. There's something broken."

    def addKeyword(self,keyword):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addKeyword: adding Keyword -> "+str(keyword))
	self.cursor.execute(
		'INSERT into keywordsreference VALUES '
		'(NULL,?)', (keyword,)
	)
	# get info about inserted value and return
	key = self.isKeywordAvailable(keyword)
	if key != -1:
	    return key
	raise Exception, "I tried to insert a keyword but then, fetching it returned -1. There's something broken."

    def addUseflag(self,useflag):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addUseflag: adding Keyword -> "+str(useflag))
	self.cursor.execute(
		'INSERT into useflagsreference VALUES '
		'(NULL,?)', (useflag,)
	)
	# get info about inserted value and return
	use = self.isUseflagAvailable(useflag)
	if use != -1:
	    return use
	raise Exception, "I tried to insert a useflag but then, fetching it returned -1. There's something broken."

    def addLicense(self,license):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addLicense: adding License -> "+str(license))
	self.cursor.execute(
		'INSERT into licenses VALUES '
		'(NULL,?)', (license,)
	)
	# get info about inserted value and return
	lic = self.isLicenseAvailable(license)
	if lic != -1:
	    return lic
	raise Exception, "I tried to insert a license but then, fetching it returned -1. There's something broken."

    #addCompileFlags(etpData['chost'],etpData['cflags'],etpData['cxxflags'])
    def addCompileFlags(self,chost,cflags,cxxflags):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addCompileFlags: adding Flags -> "+chost+"|"+cflags+"|"+cxxflags)
	self.cursor.execute(
		'INSERT into flags VALUES '
		'(NULL,?,?,?)', (chost,cflags,cxxflags,)
	)
	# get info about inserted value and return
	idflag = self.areCompileFlagsAvailable(chost,cflags,cxxflags)
	if idflag != -1:
	    return idflag
	raise Exception, "I tried to insert a flag tuple but then, fetching it returned -1. There's something broken."

    def setDigest(self, idpackage, digest):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"setChecksum: setting new digest for idpackage: "+str(idpackage)+" -> "+str(digest))
	self.cursor.execute('UPDATE extrainfo SET digest = "'+str(digest)+'" WHERE idpackage = "'+str(idpackage)+'"')

    def cleanupUseflags(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"cleanupUseflags: called.")
	self.cursor.execute('SELECT idflag FROM useflagsreference')
	idflags = set([])
	for row in self.cursor:
	    idflags.add(row[0])
	# now parse them into useflags table
	orphanedFlags = idflags.copy()
	for idflag in idflags:
	    self.cursor.execute('SELECT idflag FROM useflags WHERE idflag = '+str(idflag))
	    for row in self.cursor:
		orphanedFlags.remove(row[0])
		break
	# now we have orphans that can be removed safely
	for idoflag in orphanedFlags:
	    self.cursor.execute('DELETE FROM useflagsreference WHERE idflag = '+str(idoflag))
	for row in self.cursor:
	    x = row # really necessary ?

    def cleanupSources(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"cleanupSources: called.")
	self.cursor.execute('SELECT idsource FROM sourcesreference')
	idsources = set([])
	for row in self.cursor:
	    idsources.add(row[0])
	# now parse them into useflags table
	orphanedSources = idsources.copy()
	for idsource in idsources:
	    self.cursor.execute('SELECT idsource FROM sources WHERE idsource = '+str(idsource))
	    for row in self.cursor:
		orphanedSources.remove(row[0])
		break
	# now we have orphans that can be removed safely
	for idosrc in orphanedSources:
	    self.cursor.execute('DELETE FROM sourcesreference WHERE idsource = '+str(idosrc))
	for row in self.cursor:
	    x = row # really necessary ?

    def cleanupDependencies(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"cleanupDependencies: called.")
	self.cursor.execute('SELECT iddependency FROM dependenciesreference')
	iddeps = set([])
	for row in self.cursor:
	    iddeps.add(row[0])
	# now parse them into useflags table
	orphanedDeps = iddeps.copy()
	for iddep in iddeps:
	    self.cursor.execute('SELECT iddependency FROM dependencies WHERE iddependency = '+str(iddep))
	    for row in self.cursor:
		orphanedDeps.remove(row[0])
		break
	# now we have orphans that can be removed safely
	for idodep in orphanedDeps:
	    self.cursor.execute('DELETE FROM dependenciesreference WHERE iddependency = '+str(idodep))
	for row in self.cursor:
	    x = row # really necessary ?

    # WARNING: this function must be kept in sync with Entropy database schema
    # returns True if equal
    # returns False if not
    # FIXME: this must be fixed to work with branches
    def comparePackagesData(self, etpData, pkgAtomToQuery, branchToQuery = "unstable"):
	
	# fill content - get idpackage
	idpackage = self.getIDPackage(pkgAtomToQuery,branchToQuery)
	# get data
	myEtpData = self.getPackageData(idpackage)
	
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"comparePackagesData: called for "+str(etpData['name'])+" and "+str(myEtpData['name'])+" | branch: "+branchToQuery)
	
	for i in etpData:
	    if etpData[i] != myEtpData[i]:
		dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_VERBOSE,"comparePackagesData: they don't match")
		return False
	
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"comparePackagesData: they match")
	return True
    
    def getIDPackage(self, atom, branch = "unstable"):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"getIDPackage: retrieving package ID for "+atom+" | branch: "+branch)
	self.cursor.execute('SELECT "IDPACKAGE" FROM baseinfo WHERE atom = "'+atom+'" AND branch = "'+branch+'"')
	idpackage = -1
	for row in self.cursor:
	    idpackage = int(row[0])
	    break
	return idpackage

    def getIDPackageFromFileInBranch(self, file, branch = "unstable"):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"getIDPackageFromFile: retrieving package ID for file "+file+" | branch: "+branch)
	self.cursor.execute('SELECT idpackage FROM content WHERE file = "'+file+'"')
	idpackages = []
	for row in self.cursor:
	    idpackages.append(row[0])
	result = []
	for pkg in idpackages:
	    self.cursor.execute('SELECT idpackage FROM baseinfo WHERE idpackage = "'+str(pkg)+'" and branch = "'+branch+'"')
	    for row in self.cursor:
		result.append(row[0])
	return result

    def getIDPackagesFromFile(self, file):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"getIDPackageFromFile: retrieving package ID for file "+file)
	self.cursor.execute('SELECT idpackage FROM content WHERE file = "'+file+'"')
	idpackages = []
	for row in self.cursor:
	    idpackages.append(row[0])
	return idpackages

    def getIDCategory(self, category):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"getIDCategory: retrieving category ID for "+str(category))
	self.cursor.execute('SELECT "idcategory" FROM categories WHERE category = "'+str(category)+'"')
	idcat = -1
	for row in self.cursor:
	    idcat = int(row[0])
	    break
	return idcat

    def getIDPackageFromBinaryPackage(self,packageName):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"getIDPackageFromBinaryPackage: retrieving package ID for "+atom+" | branch: "+branch)
	self.cursor.execute('SELECT "IDPACKAGE" FROM baseinfo WHERE download = "'+etpConst['binaryurirelativepath']+packageName+'"')
	idpackage = -1
	for row in self.cursor:
	    idpackage = int(row[0])
	    break
	return idpackage

    def getPackageData(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"getPackageData: retrieving etpData for package ID for "+str(idpackage))
	data = {}
	
	data['name'] = self.retrieveName(idpackage)
	data['version'] = self.retrieveVersion(idpackage)
	data['versiontag'] = self.retrieveVersionTag(idpackage)
	data['description'] = self.retrieveDescription(idpackage)
	data['category'] = self.retrieveCategory(idpackage)
	
	flags = self.retrieveCompileFlags(idpackage)
	data['chost'] = flags[0]
	data['cflags'] = flags[1]
	data['cxxflags'] = flags[2]
	
	data['homepage'] = self.retrieveHomepage(idpackage)
	data['useflags'] = self.retrieveUseflags(idpackage)
	data['license'] = self.retrieveLicense(idpackage)
	
	data['keywords'] = self.retrieveKeywords(idpackage)
	data['binkeywords'] = self.retrieveBinKeywords(idpackage)
	
	data['branch'] = self.retrieveBranch(idpackage)
	data['download'] = self.retrieveDownloadURL(idpackage)
	data['digest'] = self.retrieveDigest(idpackage)
	data['sources'] = self.retrieveSources(idpackage)
	data['counter'] = self.retrieveCounter(idpackage)
	data['messages'] = self.retrieveMessages(idpackage)
	
	if (self.isSystemPackage(idpackage)):
	    data['systempackage'] = 'xxx'
	else:
	    data['systempackage'] = ''
	
	data['config_protect'] = self.retrieveProtect(idpackage)
	data['config_protect_mask'] = self.retrieveProtectMask(idpackage)
	
	mirrornames = []
	for x in data['sources']:
	    if x.startswith("mirror://"):
		mirrorname = x.split("/")[2]
		mirrornames.append(mirrorname)
	data['mirrorlinks'] = []
	for mirror in mirrornames:
	    mirrorlinks = self.retrieveMirrorInfo(mirror)
	    data['mirrorlinks'].append([mirror,mirrorlinks])
	
	data['slot'] = self.retrieveSlot(idpackage)
	data['content'] = self.retrieveContent(idpackage)
	
	data['dependencies'] = self.retrieveDependencies(idpackage)
	data['provide'] = self.retrieveProvide(idpackage)
	data['conflicts'] = self.retrieveConflicts(idpackage)
	
	data['etpapi'] = self.retrieveApi(idpackage)
	data['datecreation'] = self.retrieveDateCreation(idpackage)
	data['size'] = self.retrieveSize(idpackage)
	data['disksize'] = self.retrieveOnDiskSize(idpackage)
	return data

    def retrieveAtom(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveAtom: retrieving Atom for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveAtom',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "atom" FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	atom = ''
	for row in self.cursor:
	    atom = row[0]
	    break
	
	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveAtom'] = atom
	return atom

    def retrieveBranch(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveBranch: retrieving Branch for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveBranch',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "branch" FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	br = ''
	for row in self.cursor:
	    br = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveBranch'] = br
	return br

    def retrieveDownloadURL(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveDownloadURL: retrieving download URL for package ID "+str(idpackage))
	
	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveDownloadURL',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "download" FROM extrainfo WHERE idpackage = "'+str(idpackage)+'"')
	download = ''
	for row in self.cursor:
	    download = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveDownloadURL'] = download
	return download

    def retrieveDescription(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveDescription: retrieving description for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveDescription',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "description" FROM extrainfo WHERE idpackage = "'+str(idpackage)+'"')
	description = ''
	for row in self.cursor:
	    description = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveDescription'] = description
	return description

    def retrieveHomepage(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveHomepage: retrieving Homepage for package ID "+str(idpackage))
	
	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveHomepage',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "homepage" FROM extrainfo WHERE idpackage = "'+str(idpackage)+'"')
	home = ''
	for row in self.cursor:
	    home = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveHomepage'] = home
	return home

    def retrieveCounter(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveCounter: retrieving Counter for package ID "+str(idpackage))
	
	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveCounter',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	counter = -1
	try:
	    self.cursor.execute('SELECT "counter" FROM counters WHERE idpackage = "'+str(idpackage)+'"')
	    for row in self.cursor:
	        counter = row[0]
	        break
	except:
	    pass

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveCounter'] = counter
	return counter

    def retrieveMessages(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveMessages: retrieving messages for package ID "+str(idpackage))
	
	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveMessages',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	messages = []
	try:
	    self.cursor.execute('SELECT "message" FROM messages WHERE idpackage = "'+str(idpackage)+'"')
	    for row in self.cursor:
	        messages.append(row[0])
	except:
	    pass

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveMessages'] = messages
	return messages

    # in bytes
    def retrieveSize(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveSize: retrieving Size for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveSize',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "size" FROM extrainfo WHERE idpackage = "'+str(idpackage)+'"')
	size = 'N/A'
	for row in self.cursor:
	    size = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveSize'] = size
	return size

    # in bytes
    def retrieveOnDiskSize(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveOnDiskSize: retrieving On Disk Size for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveOnDiskSize',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	try:
	    self.cursor.execute('SELECT size FROM sizes WHERE idpackage = "'+str(idpackage)+'"')
	except:
	    # table does not exist?
	    return 0
	size = 0
	for row in self.cursor:
	    size = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveOnDiskSize'] = size
	return size

    def retrieveDigest(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveDigest: retrieving Digest for package ID "+str(idpackage))
	
	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveDigest',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "digest" FROM extrainfo WHERE idpackage = "'+str(idpackage)+'"')
	digest = ''
	for row in self.cursor:
	    digest = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveDigest'] = digest
	return digest

    def retrieveName(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveName: retrieving Name for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveName',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "name" FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	name = ''
	for row in self.cursor:
	    name = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveName'] = name
	return name

    def retrieveVersion(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveVersion: retrieving Version for package ID "+str(idpackage))
	
	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveVersion',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "version" FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	ver = ''
	for row in self.cursor:
	    ver = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveVersion'] = ver
	return ver

    def retrieveRevision(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveRevision: retrieving Revision for package ID "+str(idpackage))
	
	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveRevision',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "revision" FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	rev = ''
	for row in self.cursor:
	    rev = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveRevision'] = rev
	return rev

    def retrieveDateCreation(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveDateCreation: retrieving Creation Date for package ID "+str(idpackage))
	
	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveDateCreation',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "datecreation" FROM extrainfo WHERE idpackage = "'+str(idpackage)+'"')
	date = 'N/A'
	for row in self.cursor:
	    date = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveDateCreation'] = date
	return date

    def retrieveApi(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveApi: retrieving Database API for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveApi',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "etpapi" FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	api = -1
	for row in self.cursor:
	    api = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveApi'] = api
	return api

    def retrieveUseflags(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveUseflags: retrieving USE flags for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveUseflags',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "idflag" FROM useflags WHERE idpackage = "'+str(idpackage)+'"')
	idflgs = []
	for row in self.cursor:
	    idflgs.append(row[0])
	flags = []
	for idflg in idflgs:
	    self.cursor.execute('SELECT "flagname" FROM useflagsreference WHERE idflag = "'+str(idflg)+'"')
	    for row in self.cursor:
	        flags.append(row[0])

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveUseflags'] = flags
	return flags

    def retrieveConflicts(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveConflicts: retrieving Conflicts for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveConflicts',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "conflict" FROM conflicts WHERE idpackage = "'+str(idpackage)+'"')
	confl = []
	for row in self.cursor:
	    confl.append(row[0])

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveConflicts'] = confl
	return confl

    def retrieveProvide(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveProvide: retrieving Provide for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveProvide',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "atom" FROM provide WHERE idpackage = "'+str(idpackage)+'"')
	provide = []
	for row in self.cursor:
	    provide.append(row[0])
	
	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveProvide'] = provide
	return provide

    def retrieveDependencies(self, idpackage):
	self.cursor.execute('SELECT iddependency FROM dependencies WHERE idpackage = "'+str(idpackage)+'"')
	
	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveDependencies',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}
	
	iddeps = []
	for row in self.cursor:
	    iddeps.append(row[0])
	deps = []
	for iddep in iddeps:
	    self.cursor.execute('SELECT dependency FROM dependenciesreference WHERE iddependency = "'+str(iddep)+'"')
	    for row in self.cursor:
		deps.append(row[0])
	
	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveDependencies'] = deps
	return deps

    def retrieveIdDependencies(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveDependencies: retrieving Dependencies for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveIdDependencies',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT iddependency FROM dependencies WHERE idpackage = "'+str(idpackage)+'"')
	iddeps = []
	for row in self.cursor:
	    iddeps.append(row[0])

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveIdDependencies'] = iddeps
	return iddeps

    def retrieveBinKeywords(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveBinKeywords: retrieving Binary Keywords for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveBinKeywords',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "idkeyword" FROM binkeywords WHERE idpackage = "'+str(idpackage)+'"')
	idkws = []
	for row in self.cursor:
	    idkws.append(row[0])
	kw = []
	for idkw in idkws:
	    self.cursor.execute('SELECT "keywordname" FROM keywordsreference WHERE idkeyword = "'+str(idkw)+'"')
	    for row in self.cursor:
	        kw.append(row[0])

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveBinKeywords'] = kw
	return kw

    def retrieveKeywords(self, idpackage):

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveKeywords',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveKeywords: retrieving Keywords for package ID "+str(idpackage))
	self.cursor.execute('SELECT "idkeyword" FROM keywords WHERE idpackage = "'+str(idpackage)+'"')
	idkws = []
	for row in self.cursor:
	    idkws.append(row[0])
	kw = []
	for idkw in idkws:
	    self.cursor.execute('SELECT "keywordname" FROM keywordsreference WHERE idkeyword = "'+str(idkw)+'"')
	    for row in self.cursor:
	        kw.append(row[0])

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveKeywords'] = kw
	return kw

    def retrieveProtect(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveProtect: retrieving CONFIG_PROTECT for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveProtect',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "idprotect" FROM configprotect WHERE idpackage = "'+str(idpackage)+'"')
	idprotect = -1
	for row in self.cursor:
	    idprotect = row[0]
	    break
	protect = ''
	if idprotect == -1:
	    return protect
	self.cursor.execute('SELECT "protect" FROM configprotectreference WHERE idprotect = "'+str(idprotect)+'"')
	for row in self.cursor:
	    protect = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveProtect'] = protect
	return protect

    def retrieveProtectMask(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveProtectMask: retrieving CONFIG_PROTECT_MASK for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveProtectMask',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "idprotect" FROM configprotectmask WHERE idpackage = "'+str(idpackage)+'"')
	idprotect = -1
	for row in self.cursor:
	    idprotect = row[0]
	    break
	protect = ''
	if idprotect == -1:
	    return protect
	self.cursor.execute('SELECT "protect" FROM configprotectreference WHERE idprotect = "'+str(idprotect)+'"')
	for row in self.cursor:
	    protect = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveProtectMask'] = protect
	return protect

    def retrieveSources(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveSources: retrieving Sources for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveSources',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT idsource FROM sources WHERE idpackage = "'+str(idpackage)+'"')
	idsources = []
	for row in self.cursor:
	    idsources.append(row[0])
	sources = []
	for idsource in idsources:
	    self.cursor.execute('SELECT source FROM sourcesreference WHERE idsource = "'+str(idsource)+'"')
	    for row in self.cursor:
		sources.append(row[0])

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveSources'] = sources
	return sources

    def retrieveContent(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveContent: retrieving Content for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveContent',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "file" FROM content WHERE idpackage = "'+str(idpackage)+'"')
	fl = []
	for row in self.cursor:
	    fl.append(row[0])

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveContent'] = fl
	return fl

    def retrieveSlot(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveSlot: retrieving Slot for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveSlot',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "slot" FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	ver = ''
	for row in self.cursor:
	    ver = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveSlot'] = ver
	return ver
    
    def retrieveVersionTag(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveVersionTag: retrieving Version TAG for package ID "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveVersionTag',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "versiontag" FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	ver = ''
	for row in self.cursor:
	    ver = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveVersionTag'] = ver
	return ver
    
    def retrieveMirrorInfo(self, mirrorname):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveMirrorInfo: retrieving Mirror info for mirror name "+str(mirrorname))

	self.cursor.execute('SELECT "mirrorlink" FROM mirrorlinks WHERE mirrorname = "'+str(mirrorname)+'"')
	mirrorlist = []
	for row in self.cursor:
	    mirrorlist.append(row[0])

	return mirrorlist

    def retrieveCategory(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveCategory: retrieving Category for package ID for "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveCategory',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "idcategory" FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	cat = ''
	for row in self.cursor:
	    cat = row[0]
	    break
	# now get the category name
	self.cursor.execute('SELECT "category" FROM categories WHERE idcategory = '+str(cat))
	cat = -1
	for row in self.cursor:
	    cat = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveCategory'] = cat
	return cat

    def retrieveLicense(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveLicense: retrieving License for package ID for "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveLicense',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "idlicense" FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	lic = -1
	for row in self.cursor:
	    lic = row[0]
	    break
	# now get the license name
	self.cursor.execute('SELECT "license" FROM licenses WHERE idlicense = '+str(lic))
	licname = ''
	for row in self.cursor:
	    licname = row[0]
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveLicense'] = licname
	return licname

    def retrieveCompileFlags(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveCompileFlags: retrieving CHOST,CFLAGS,CXXFLAGS for package ID for "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('retrieveCompileFlags',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	self.cursor.execute('SELECT "idflags" FROM extrainfo WHERE idpackage = "'+str(idpackage)+'"')
	idflag = -1
	for row in self.cursor:
	    idflag = row[0]
	    break
	# now get the flags
	self.cursor.execute('SELECT chost,cflags,cxxflags FROM flags WHERE idflags = '+str(idflag))
	flags = ["N/A","N/A","N/A"]
	for row in self.cursor:
	    flags = row
	    break

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['retrieveCompileFlags'] = flags
	return flags

    def retrieveDepends(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrieveDepends: called for idpackage "+str(idpackage))

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('searchDepends',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	# sanity check on the table
	sanity = self.isDependsTableSane() #FIXME: perhaps running this only on a client database?
	if (not sanity):
	    return -2 # table does not exist or is broken, please regenerate and re-run

	iddeps = []
	self.cursor.execute('SELECT iddependency FROM dependstable WHERE idpackage = "'+str(idpackage)+'"')
	for row in self.cursor:
	    iddeps.append(row[0])
	result = []
	for iddep in iddeps:
	    #print iddep
	    self.cursor.execute('SELECT idpackage FROM dependencies WHERE iddependency = "'+str(iddep)+'"')
	    for row in self.cursor:
	        result.append(row[0])

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['searchDepends'] = result

	return result

    # You must provide the full atom to this function
    # WARNING: this function does not support branches !!!
    def isPackageAvailable(self,pkgkey):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isPackageAvailable: called.")
	pkgkey = entropyTools.removePackageOperators(pkgkey)
	result = []
	self.cursor.execute('SELECT idpackage FROM baseinfo WHERE atom = "'+pkgkey+'"')
	for row in self.cursor:
	    result.append(row)
	if result == []:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"isPackageAvailable: "+pkgkey+" not available.")
	    return False
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isPackageAvailable: "+pkgkey+" available.")
	return True

    def isIDPackageAvailable(self,idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isIDPackageAvailable: called.")
	result = []
	self.cursor.execute('SELECT idpackage FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	for row in self.cursor:
	    result.append(row[0])
	if result == []:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"isIDPackageAvailable: "+str(idpackage)+" not available.")
	    return False
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isIDPackageAvailable: "+str(idpackage)+" available.")
	return True

    # This version is more specific and supports branches
    def isSpecificPackageAvailable(self, pkgkey, branch):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isSpecificPackageAvailable: called.")
	pkgkey = entropyTools.removePackageOperators(pkgkey)
	result = []
	self.cursor.execute('SELECT idpackage FROM baseinfo WHERE atom = "'+pkgkey+'" AND branch = "'+branch+'"')
	for row in self.cursor:
	    result.append(row[0])
	if result == []:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"isSpecificPackageAvailable: "+pkgkey+" | branch: "+branch+" -> not found.")
	    return False
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isSpecificPackageAvailable: "+pkgkey+" | branch: "+branch+" -> found !")
	return True

    def isCategoryAvailable(self,category):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isCategoryAvailable: called.")
	result = -1
	self.cursor.execute('SELECT idcategory FROM categories WHERE category = "'+category+'"')
	for row in self.cursor:
	    result = row[0]
	if result == -1:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"isCategoryAvailable: "+category+" not available.")
	    return result
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isCategoryAvailable: "+category+" available.")
	return result

    def isProtectAvailable(self,protect):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isProtectAvailable: called.")
	result = -1
	self.cursor.execute('SELECT idprotect FROM configprotectreference WHERE protect = "'+protect+'"')
	for row in self.cursor:
	    result = row[0]
	if result == -1:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"isProtectAvailable: "+protect+" not available.")
	    return result
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isProtectAvailable: "+protect+" available.")
	return result

    def isSourceAvailable(self,source):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isSourceAvailable: called.")
	result = -1
	self.cursor.execute('SELECT idsource FROM sourcesreference WHERE source = "'+source+'"')
	for row in self.cursor:
	    result = row[0]
	if result == -1:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"isSourceAvailable: "+source+" not available.")
	    return result
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isSourceAvailable: "+source+" available.")
	return result

    def isDependencyAvailable(self,dependency):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isDependencyAvailable: called.")
	result = -1
	self.cursor.execute('SELECT iddependency FROM dependenciesreference WHERE dependency = "'+dependency+'"')
	for row in self.cursor:
	    result = row[0]
	if result == -1:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"isDependencyAvailable: "+dependency+" not available.")
	    return result
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isDependencyAvailable: "+dependency+" available.")
	return result

    def isKeywordAvailable(self,keyword):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isKeywordAvailable: called.")
	result = -1
	self.cursor.execute('SELECT idkeyword FROM keywordsreference WHERE keywordname = "'+keyword+'"')
	for row in self.cursor:
	    result = row[0]
	if result == -1:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"isKeywordAvailable: "+keyword+" not available.")
	    return result
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isKeywordAvailable: "+keyword+" available.")
	return result

    def isUseflagAvailable(self,useflag):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isUseflagAvailable: called.")
	result = -1
	self.cursor.execute('SELECT idflag FROM useflagsreference WHERE flagname = "'+useflag+'"')
	for row in self.cursor:
	    result = row[0]
	if result == -1:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"isUseflagAvailable: "+useflag+" not available.")
	    return result
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isUseflagAvailable: "+useflag+" available.")
	return result

    def isCounterAvailable(self,counter):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isCounterAvailable: called.")
	result = False
	self.cursor.execute('SELECT counter FROM counters WHERE counter = "'+str(counter)+'"')
	for row in self.cursor:
	    result = True
	if (result):
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"isCounterAvailable: "+str(counter)+" not available.")
	else:
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isCounterAvailable: "+str(counter)+" available.")
	return result

    def isLicenseAvailable(self,license):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isLicenseAvailable: called.")
	result = -1
	self.cursor.execute('SELECT idlicense FROM licenses WHERE license = "'+license+'"')
	for row in self.cursor:
	    result = row[0]
	if result == -1:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"isLicenseAvailable: "+license+" not available.")
	    return result
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isLicenseAvailable: "+license+" available.")
	return result

    def isSystemPackage(self,idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isSystemPackage: called.")

	''' caching '''
	if (self.xcache):
	    cached = self.databaseCache.get(int(idpackage), None)
	    if cached:
	        rslt = self.databaseCache[int(idpackage)].get('isSystemPackage',None)
	        if rslt:
		    return rslt
	    else:
	        self.databaseCache[int(idpackage)] = {}

	result = -1
	self.cursor.execute('SELECT idpackage FROM systempackages WHERE idpackage = "'+str(idpackage)+'"')
	for row in self.cursor:
	    result = row[0]
	    break
	rslt = False
	if result != -1:
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isSystemPackage: package is in system.")
	    rslt = True
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"isSystemPackage: package is NOT in system.")

	''' caching '''
	if (self.xcache):
	    self.databaseCache[int(idpackage)]['isSystemPackage'] = rslt
	
	return rslt

    def areCompileFlagsAvailable(self,chost,cflags,cxxflags):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"areCompileFlagsAvailable: called.")
	result = -1
	self.cursor.execute('SELECT idflags FROM flags WHERE chost = "'+chost+'" AND cflags = "'+cflags+'" AND cxxflags = "'+cxxflags+'"')
	for row in self.cursor:
	    result = row[0]
	if result == -1:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"areCompileFlagsAvailable: flags tuple "+chost+"|"+cflags+"|"+cxxflags+" not available.")
	    return result
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"areCompileFlagsAvailable: flags tuple "+chost+"|"+cflags+"|"+cxxflags+" available.")
	return result

    def searchBelongs(self, file, like = False):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchBelongs: called for "+file)
	result = []
	if (like):
	    self.cursor.execute('SELECT idpackage FROM content WHERE file LIKE "'+file+'"')
	else:
	    self.cursor.execute('SELECT idpackage FROM content WHERE file = "'+file+'"')
	for row in self.cursor:
	    result.append(row[0])
	return result

    def searchPackages(self, keyword, sensitive = False):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchPackages: called for "+keyword)
	result = []
	if (sensitive):
	    self.cursor.execute('SELECT atom,idpackage,branch FROM baseinfo WHERE atom LIKE "%'+keyword+'%"')
	else:
	    self.cursor.execute('SELECT atom,idpackage,branch FROM baseinfo WHERE LOWER(atom) LIKE "%'+string.lower(keyword)+'%"')
	for row in self.cursor:
	    result.append(row)
	return result

    def searchProvide(self, keyword):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchProvide: called for "+keyword)

	idpackage = []
	self.cursor.execute('SELECT idpackage FROM provide WHERE atom = "'+keyword+'"')
	for row in self.cursor:
	    idpackage = row[0]
	    break
	self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	result = []
	for row in self.cursor:
	    result = row
	    break

	return result

    def searchProvideInBranch(self, keyword, branch):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchProvideInBranch: called for "+keyword+" and branch: "+branch)
	idpackages = []
	self.cursor.execute('SELECT idpackage FROM provide WHERE atom = "'+keyword+'"')
	for row in self.cursor:
	    idpackages.append(row[0])
	results = []
	for idpackage in idpackages:
	    self.cursor.execute('SELECT atom,idpackage,branch FROM baseinfo WHERE idpackage = "'+str(idpackage)+'"')
	    for row in self.cursor:
	        data = row
		atom = data[0]
	        idpackage = data[1]
	        pkgbranch = data[2]
	        if (branch == pkgbranch):
		    results.append((atom,idpackage))
	return results

    def searchPackagesInBranch(self, keyword, branch, sensitive = False):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchPackagesInBranch: called.")
	result = []
	if (sensitive):
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE atom LIKE "%'+keyword+'%" AND branch = "'+branch+'"')
	else:
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE LOWER(atom) LIKE "%'+string.lower(keyword)+'%" AND branch = "'+branch+'"')
	for row in self.cursor:
	    result.append(row)
	return result

    def searchPackagesByDescription(self, keyword):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchPackagesByDescription: called for "+keyword)
	idpkgs = []
	self.cursor.execute('SELECT idpackage FROM extrainfo WHERE LOWER(description) LIKE "%'+string.lower(keyword)+'%"')
	for row in self.cursor:
	    idpkgs.append(row[0])
	result = []
	for idpk in idpkgs:
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE idpackage = "'+str(idpk)+'"')
	    for row in self.cursor:
	        result.append(row)
	return result

    def searchPackagesByName(self, keyword, sensitive = False):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchPackagesByName: called for "+keyword)
	result = []
	if (sensitive):
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE name = "'+keyword+'"')
	else:
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE LOWER(name) = "'+string.lower(keyword)+'"')
	for row in self.cursor:
	    result.append(row)
	return result

    def searchPackagesByNameAndCategory(self, name, category, sensitive = False):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchPackagesByNameAndCategory: called for name: "+name+" and category: "+category)
	result = []
	# get category id
	idcat = -1
	self.cursor.execute('SELECT idcategory FROM categories WHERE category = "'+category+'"')
	for row in self.cursor:
	    idcat = row[0]
	    break
	if idcat == -1:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"searchPackagesByNameAndCategory: Category "+category+" not available.")
	    return result
	if (sensitive):
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE name = "'+name+'" AND idcategory ='+str(idcat))
	else:
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE LOWER(name) = "'+string.lower(name)+'" AND idcategory ='+str(idcat))
	for row in self.cursor:
	    result.append(row)
	return result

    def searchPackagesInBranchByName(self, keyword, branch, sensitive = False):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchPackagesInBranchByName: called for "+keyword)
	result = []
	if (sensitive):
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE name = "'+keyword+'" AND branch = "'+branch+'"')
	else:
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE LOWER(name) = "'+string.lower(keyword)+'" AND branch = "'+branch+'"')
	for row in self.cursor:
	    result.append(row)
	return result

    def searchPackagesInBranchByNameAndCategory(self, name, category, branch, sensitive = False):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchPackagesInBranchByNameAndCategory: called for "+name+" and category "+category)
	result = []
	# get category id
	idcat = -1
	self.cursor.execute('SELECT idcategory FROM categories WHERE category = "'+category+'"')
	for row in self.cursor:
	    idcat = row[0]
	    break
	if idcat == -1:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"searchPackagesInBranchByNameAndCategory: Category "+category+" not available.")
	    return result
	if (sensitive):
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE name = "'+name+'" AND idcategory = '+str(idcat)+' AND branch = "'+branch+'"')
	else:
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE LOWER(name) = "'+string.lower(name)+'" AND idcategory = '+str(idcat)+' AND branch = "'+branch+'"')
	for row in self.cursor:
	    result.append(row)
	return result

    def searchPackagesInBranchByNameAndVersionAndCategory(self, name, version, category, branch, sensitive = False):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchPackagesInBranchByNameAndVersionAndCategoryAndTag: called for "+name+" and version "+version+" and category "+category+" | branch "+branch)
	result = []
	# get category id
	idcat = -1
	self.cursor.execute('SELECT idcategory FROM categories WHERE category = "'+category+'"')
	for row in self.cursor:
	    idcat = row[0]
	    break
	if idcat == -1:
	    dbLog.log(ETP_LOGPRI_WARNING,ETP_LOGLEVEL_NORMAL,"searchPackagesInBranchByNameAndVersionAndCategoryAndTag: Category "+category+" not available.")
	    return result
	if (sensitive):
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE name = "'+name+'" AND version = "'+version+'" AND idcategory = '+str(idcat)+' AND branch = "'+branch+'"')
	else:
	    self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE LOWER(name) = "'+string.lower(name)+'" AND version = "'+version+'" AND idcategory = '+str(idcat)+' AND branch = "'+branch+'"')
	for row in self.cursor:
	    result.append(row)
	return result

    # this function search packages with the same pkgcat/pkgname
    # you must provide something like: media-sound/amarok
    # optionally, you can add version too.
    def searchSimilarPackages(self, atom, branch = "unstable"):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchSimilarPackages: called for "+atom+" | branch: "+branch)
	category = atom.split("/")[0]
	name = atom.split("/")[1]
	# get category id
	idcategory = self.getIDCategory(category)
	result = []
	self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE idcategory = "'+str(idcategory)+'" AND LOWER(name) = "'+string.lower(name)+'" AND branch = "'+branch+'"')
	for row in self.cursor:
	    result.append(row)
	return result

    def listAllPackages(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listAllPackages: called.")
	self.cursor.execute('SELECT atom,idpackage,branch FROM baseinfo')
	result = []
	for row in self.cursor:
	    result.append(row)
	return result

    def listAllCounters(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listAllCounters: called.")
	self.cursor.execute('SELECT counter,idpackage FROM counters')
	result = []
	for row in self.cursor:
	    result.append(row)
	return result

    def listAllIdpackages(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listAllIdpackages: called.")
	self.cursor.execute('SELECT idpackage FROM baseinfo')
	result = []
	for row in self.cursor:
	    result.append(row[0])
	return result

    def listAllDependencies(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listAllDependencies: called.")
	self.cursor.execute('SELECT * FROM dependenciesreference')
	result = []
	for row in self.cursor:
	    result.append(row)
	return result

    def listIdpackageDependencies(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listIdpackageDependencies: called.")
	self.cursor.execute('SELECT iddependency FROM dependencies where idpackage = "'+str(idpackage)+'"')
	iddeps = []
	for row in self.cursor:
	    iddeps.append(row[0])
	result = []
	for iddep in iddeps:
	    self.cursor.execute('SELECT iddependency,dependency FROM dependenciesreference where iddependency = "'+str(iddep)+'"')
	    for row in self.cursor:
	        result.append(row)
	return result

    #FIXME: DEPRECATED
    def listAllPackagesTbz2(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listAllPackagesTbz2: called.")
        result = []
        pkglist = self.listAllPackages()
        for pkg in pkglist:
	    idpackage = pkg[1]
	    url = self.retrieveDownloadURL(idpackage)
	    if url:
		result.append(url)
        # filter dups?
	if (result):
            result = list(set(result))
	    result.sort()
	return result

    def listBranchPackagesTbz2(self, branch):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listBranchPackagesTbz2: called with "+str(branch))
        result = []
        pkglist = self.listBranchPackages(branch)
        for pkg in pkglist:
	    idpackage = pkg[1]
	    url = self.retrieveDownloadURL(idpackage)
	    if url:
		result.append(os.path.basename(url))
        # filter dups?
	if (result):
            result = list(set(result))
	    result.sort()
	return result

    def listBranchPackages(self, branch):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listBranchPackages: called with "+str(branch))
	result = []
	self.cursor.execute('SELECT atom,idpackage FROM baseinfo WHERE branch = "'+str(branch)+'"')
	for row in self.cursor:
	    result.append(row)
	return result

    def listAllFiles(self, clean = False):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listAllFiles: called.")
	if clean:
	    result = set()
	else:
	    result = []
	self.cursor.execute('SELECT file FROM content')
	for row in self.cursor:
	    if clean:
	        result.add(row[0])
		continue
	    result.append(row[0])
	return result

    def listConfigProtectDirectories(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listConfigProtectDirectories: called.")
	dirs = set()
	idprotects = set()
	self.cursor.execute('SELECT idprotect FROM configprotect')
	for row in self.cursor:
	    idprotects.add(row[0])
	for idprotect in idprotects:
	    self.cursor.execute('SELECT protect FROM configprotectreference WHERE idprotect = "'+str(idprotect)+'"')
	    for row in self.cursor:
	        var = row[0]
	        for x in var.split():
		    dirs.add(x)
	dirs = list(dirs)
	dirs.sort()
	return dirs

    def listConfigProtectMaskDirectories(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listConfigProtectMaskDirectories: called.")
	dirs = set()
	idprotects = set()
	self.cursor.execute('SELECT idprotect FROM configprotectmask')
	for row in self.cursor:
	    idprotects.add(row[0])
	for idprotect in idprotects:
	    self.cursor.execute('SELECT protect FROM configprotectreference WHERE idprotect = "'+str(idprotect)+'"')
	    for row in self.cursor:
	        var = row[0]
	        for x in var.split():
		    dirs.add(x)
	dirs = list(dirs)
	dirs.sort()
	return dirs
    
    # FIXME: get it working with the new branch layout
    def stabilizePackage(self,atom,stable = True):

	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"stabilizePackage: called for "+atom+" | branch stable? -> "+str(stable))

	action = "unstable"
	removeaction = "stable"
	if (stable):
	    action = "stable"
	    removeaction = "unstable"
	
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"stabilizePackage: add action: "+action+" | remove action: "+removeaction)
	
	if (self.isSpecificPackageAvailable(atom, removeaction)):
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"stabilizePackage: there's something old that needs to be removed.")
	    idpackage = self.getIDPackage(atom, branch = removeaction)
	    
	    pkgname = self.retrieveName(idpackage)
	    # get its pkgcat
	    category = self.retrieveCategory(idpackage)
	    # search packages with similar pkgcat/name marked as stable
	    slot = self.retrieveSlot(idpackage)
	    
	    # we need to get rid of them
	    results = self.searchStablePackages(category+"/"+pkgname)
	    
	    removelist = []
	    for result in results:
		myidpackage = result[1]
		# have a look if the slot matches
		#print result
		myslot = self.retrieveSlot(myidpackage)
		if (myslot == slot):
		    removelist.append(result[1])
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"stabilizePackage: removelist: "+str(removelist))
	    for pkg in removelist:
		self.removePackage(pkg)
	    dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"stabilizePackage: updating "+atom+" setting branch: "+action)
	    
	    self.cursor.execute('UPDATE baseinfo SET branch = "'+action+'" WHERE idpackage = "'+idpackage+'"')
	    self.commitChanges()
	    
	    return True,action
	return False,action

########################################################
####
##   Client Database API / but also used by server part
#

    def addPackageToInstalledTable(self, idpackage, repositoryName):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addPackageToInstalledTable: called for "+str(idpackage)+" and repository "+str(repositoryName))
	self.cursor.execute(
		'INSERT into installedtable VALUES '
		'(?,?)'
		, (	idpackage,
			repositoryName,
			)
	)
	self.commitChanges()

    def retrievePackageFromInstalledTable(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"retrievePackageFromInstalledTable: called. ")
	result = 'Not available'
	try:
	    self.cursor.execute('SELECT repositoryname FROM installedtable WHERE idpackage = "'+str(idpackage)+'"')
	    for row in self.cursor:
	        result = row[0]
	        break
	except:
	    pass
	return result

    def removePackageFromInstalledTable(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"removePackageFromInstalledTable: called for "+str(idpackage))
	try:
	    self.cursor.execute('DELETE FROM installedtable WHERE idpackage = '+str(idpackage))
	    self.commitChanges()
	except:
	    self.createInstalledTable()

    def removePackageFromDependsTable(self, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"removePackageFromDependsTable: called for "+str(idpackage))
	try:
	    self.cursor.execute('DELETE FROM dependstable WHERE idpackage = '+str(idpackage))
	    self.commitChanges()
	    return 0
	except:
	    return 1 # need reinit

    def removeDependencyFromDependsTable(self, iddependency):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"removeDependencyFromDependsTable: called for "+str(iddependency))
	try:
	    self.cursor.execute('DELETE FROM dependstable WHERE iddependency = '+str(iddependency))
	    self.commitChanges()
	    return 0
	except:
	    return 1 # need reinit

    # temporary/compat functions
    def createDependsTable(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"createDependsTable: called.")
	self.cursor.execute('DROP TABLE IF EXISTS dependstable;')
	self.cursor.execute('CREATE TABLE dependstable ( iddependency INTEGER PRIMARY KEY, idpackage INTEGER );')
	# this will be removed when dependstable is refilled properly
	self.cursor.execute(
		'INSERT into dependstable VALUES '
		'(?,?)'
		, (	-1,
			-1,
			)
	)
	self.commitChanges()

    def sanitizeDependsTable(self):
	self.cursor.execute('DELETE FROM dependstable where iddependency = -1')
	self.commitChanges()

    def isDependsTableSane(self):
	sane = True
	try:
	    self.cursor.execute('SELECT iddependency FROM dependstable WHERE iddependency = -1')
	except:
	    return False # table does not exist, please regenerate and re-run
	for row in self.cursor:
	    sane = False
	    break
	return sane

    def createSizesTable(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"createSizesTable: called.")
	self.cursor.execute('DROP TABLE IF EXISTS sizes;')
	self.cursor.execute('CREATE TABLE sizes ( idpackage INTEGER, size INTEGER );')
	self.commitChanges()

    def createInstalledTable(self):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"createInstalledTable: called.")
	self.cursor.execute('DROP TABLE IF EXISTS installedtable;')
	self.cursor.execute('CREATE TABLE installedtable ( idpackage INTEGER, repositoryname VARCHAR );')
	self.commitChanges()

    def addDependRelationToDependsTable(self, iddependency, idpackage):
	dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"addDependRelationToDependsTable: called for iddependency "+str(iddependency)+" and idpackage "+str(idpackage))
	self.cursor.execute(
		'INSERT into dependstable VALUES '
		'(?,?)'
		, (	iddependency,
			idpackage,
			)
	)
	self.commitChanges()

    '''
       @description: recreate dependstable table in the chosen database, it's used for caching searchDepends requests
       @input Nothing
       @output: Nothing
    '''
    def regenerateDependsTable(self, output = True):
        self.createDependsTable()
        depends = self.listAllDependencies()
        count = 0
        total = str(len(depends))
        for depend in depends:
	    count += 1
	    atom = depend[1]
	    iddep = depend[0]
	    if output:
	        print_info("  "+bold("(")+darkgreen(str(count))+"/"+blue(total)+bold(")")+red(" Resolving ")+bold(atom), back = True)
	    match = self.atomMatch(atom)
	    if (match[0] != -1):
	        self.addDependRelationToDependsTable(iddep,match[0])

        # now validate dependstable
        self.sanitizeDependsTable()


########################################################
####
##   Dependency handling functions
#

    '''
       @description: matches the user chosen package name+ver, if possibile, in a single repository
       @input atom: string, atom to match
       @input caseSensitive: bool, should the atom be parsed case sensitive?
       @input matchSlot: string, match atoms with the provided slot
       @input multiMatch: bool, return all the available atoms
       @output: the package id, if found, otherwise -1 plus the status, 0 = ok, 1 = not found, 2 = need more info, 3 = cannot use direction without specifying version
    '''
    def atomMatch(self, atom, caseSensitive = True, matchSlot = None, multiMatch = False, matchBranches = []):
    
        if (self.xcache):
            cached = self.matchCache.get(atom)
            if cached:
		# check if matchSlot and multiMatch were the same
		if (matchSlot == cached['matchSlot']) \
			and (multiMatch == cached['multiMatch']) \
			and (caseSensitive == cached['caseSensitive']) \
			and (matchBranches == cached['matchBranches']):
	            return cached['result']
	
        # check for direction
        strippedAtom = entropyTools.dep_getcpv(atom)
        if atom.endswith("*"):
	    strippedAtom += "*"
        direction = atom[0:len(atom)-len(strippedAtom)]
        #print direction
	
        #print strippedAtom
        #print entropyTools.isspecific(strippedAtom)
        #print direction
	
        justname = entropyTools.isjustname(strippedAtom)
        #print justname
        pkgversion = ''
        if (not justname):
	    # strip tag
            if strippedAtom.split("-")[len(strippedAtom.split("-"))-1].startswith("t"):
                strippedAtom = string.join(strippedAtom.split("-t")[:len(strippedAtom.split("-t"))-1],"-t")
	    # get version
	    data = entropyTools.catpkgsplit(strippedAtom)
	    if data == None:
	        return -1,3 # atom is badly formatted
	    pkgversion = data[2]+"-"+data[3]
	    pkgtag = ''
	    if atom.split("-")[len(atom.split("-"))-1].startswith("t"):
	        pkgtag = atom.split("-")[len(atom.split("-"))-1]
	        #print "TAG: "+pkgtag
	    #print data
	    #print pkgversion
	    #print pkgtag
	
        pkgkey = entropyTools.dep_getkey(strippedAtom)
        if len(pkgkey.split("/")) == 2:
            pkgname = pkgkey.split("/")[1]
            pkgcat = pkgkey.split("/")[0]
        else:
            pkgname = pkgkey.split("/")[0]
	    pkgcat = "null"

        #print dep_getkey(strippedAtom)
	if (matchBranches):
	    myBranchIndex = matchBranches
	else:
	    myBranchIndex = [etpConst['branch']]
    
        # IDs found in the database that match our search
        foundIDs = []
	
        for idx in myBranchIndex: # myBranchIndex is ordered by importance
	    #print "Searching into -> "+etpConst['branches'][idx]
	    # search into the less stable, if found, break, otherwise continue
	    results = self.searchPackagesInBranchByName(pkgname, idx, caseSensitive)
	    
	    mypkgcat = pkgcat
	    mypkgname = pkgname
	    
	    # if it's a PROVIDE, search with searchProvide
	    if mypkgcat == "virtual":
	        virtuals = self.searchProvideInBranch(pkgkey,idx)
		if (virtuals):
		    for virtual in virtuals:
			mypkgname = self.retrieveName(virtual[1])
			mypkgcat = self.retrieveCategory(virtual[1])
			break
		    results = virtuals
			
	    # now validate
	    if (not results):
	        #print "results is empty"
	        continue # search into a stabler branch
	
	    elif (len(results) > 1):
	
	        #print "results > 1"
	        # if it's because category differs, it's a problem
	        foundCat = ""
	        cats = []
	        for result in results:
		    idpackage = result[1]
		    cat = self.retrieveCategory(idpackage)
		    cats.append(cat)
		    if (cat == mypkgcat):
		        foundCat = cat
		        break
	        # if categories are the same...
	        if (not foundCat) and (len(cats) > 0):
		    cats = entropyTools.filterDuplicatedEntries(cats)
		    if len(cats) == 1:
		        foundCat = cats[0]
	        if (not foundCat) and (mypkgcat == "null"):
		    # got the issue
		    # gosh, return and complain
		    self.matchCache[atom] = {}
		    self.matchCache[atom]['matchSlot'] = matchSlot
		    self.matchCache[atom]['multiMatch'] = multiMatch
		    self.matchCache[atom]['caseSensitive'] = caseSensitive
		    self.matchCache[atom]['matchBranches'] = matchBranches
		    self.matchCache[atom]['result'] = -1,2
		    return -1,2
	
	        # I can use foundCat
	        mypkgcat = foundCat

	        # we need to search using the category
		if (not multiMatch):
	            results = self.searchPackagesInBranchByNameAndCategory(mypkgname, mypkgcat, idx, caseSensitive)
	        # validate again
	        if (not results):
		    continue  # search into a stabler branch
	
	        # if we get here, we have found the needed IDs
	        foundIDs = results
	        break

	    else:

		# check if category matches
		if mypkgcat != "null":
		    foundCat = self.retrieveCategory(results[0][1])
		    if mypkgcat == foundCat:
			foundIDs.append(results[0])
		    else:
			continue
		else:
	            foundIDs.append(results[0])
	            break

        if (foundIDs):
	    # now we have to handle direction
	    if (direction) or (direction == '' and not justname) or (direction == '' and not justname and strippedAtom.endswith("*")):
	        # check if direction is used with justname, in this case, return an error
	        if (justname):
		    #print "justname"
		    self.matchCache[atom] = {}
		    self.matchCache[atom]['matchSlot'] = matchSlot
		    self.matchCache[atom]['multiMatch'] = multiMatch
		    self.matchCache[atom]['caseSensitive'] = caseSensitive
		    self.matchCache[atom]['matchBranches'] = matchBranches
		    self.matchCache[atom]['result'] = -1,3
		    return -1,3 # error, cannot use directions when not specifying version
	    
	        if (direction == "~") or (direction == "=") or (direction == '' and not justname) or (direction == '' and not justname and strippedAtom.endswith("*")): # any revision within the version specified OR the specified version
		# FIXME: add slot scopes
		
		    if (direction == '' and not justname):
		        direction = "="
		
		    #print direction+" direction"
		    # remove revision (-r0 if none)
		    if (direction == "="):
		        if (pkgversion.split("-")[len(pkgversion.split("-"))-1] == "r0"):
		            pkgversion = string.join(pkgversion.split("-")[:len(pkgversion.split("-"))-1],"-")
		    if (direction == "~"):
		        pkgversion = string.join(pkgversion.split("-")[:len(pkgversion.split("-"))-1],"-")
		
		    #print pkgversion
		    dbpkginfo = []
		    for list in foundIDs:
		        idpackage = list[1]
		        dbver = self.retrieveVersion(idpackage)
		        if (direction == "~"):
		            if dbver.startswith(pkgversion):
			        # found
			        dbpkginfo.append([idpackage,dbver])
		        else:
			    dbtag = self.retrieveVersionTag(idpackage)
			    #print pkgversion
			    # media-libs/test-1.2* support
			    if pkgversion.endswith("*"):
			        testpkgver = pkgversion[:len(pkgversion)-1]
			        #print testpkgver
			        combodb = dbver+dbtag
			        combopkg = testpkgver+pkgtag
			        #print combodb
			        #print combopkg
			        if combodb.startswith(combopkg):
				    dbpkginfo.append([idpackage,dbver])
			    else:
		                if (dbver+dbtag == pkgversion+pkgtag):
			            # found
			            dbpkginfo.append([idpackage,dbver])
		
		    if (not dbpkginfo):
		        # no version available
		        if (direction == "~"): # if the atom with the same version (any rev) is not found, fallback to the first available
			    for list in foundIDs:
			        idpackage = list[1]
			        dbver = self.retrieveVersion(idpackage)
			        dbpkginfo.append([idpackage,dbver])
		
		    if (not dbpkginfo):
		        self.matchCache[atom] = {}
		        self.matchCache[atom]['matchSlot'] = matchSlot
		        self.matchCache[atom]['multiMatch'] = multiMatch
		        self.matchCache[atom]['caseSensitive'] = caseSensitive
		        self.matchCache[atom]['matchBranches'] = matchBranches
		        self.matchCache[atom]['result'] = -1,1
		        return -1,1
		
		    versions = []
		    for x in dbpkginfo:
			if (matchSlot != None):
			    mslot = self.retrieveSlot(x[0])
			    if (str(mslot) != str(matchSlot)):
				continue
		        versions.append(x[1])
		
		    if (not versions):
		        self.matchCache[atom] = {}
		        self.matchCache[atom]['matchSlot'] = matchSlot
		        self.matchCache[atom]['multiMatch'] = multiMatch
		        self.matchCache[atom]['caseSensitive'] = caseSensitive
		        self.matchCache[atom]['matchBranches'] = matchBranches
		        self.matchCache[atom]['result'] = -1,1
			return -1,1
		
		    # who is newer ?
		    versionlist = entropyTools.getNewerVersion(versions)
		    newerPackage = dbpkginfo[versions.index(versionlist[0])]
		
	            # now look if there's another package with the same category, name, version, but different tag
	            newerPkgName = self.retrieveName(newerPackage[0])
	            newerPkgCategory = self.retrieveCategory(newerPackage[0])
	            newerPkgVersion = self.retrieveVersion(newerPackage[0])
		    newerPkgBranch = self.retrieveBranch(newerPackage[0])
	            similarPackages = self.searchPackagesInBranchByNameAndVersionAndCategory(newerPkgName, newerPkgVersion, newerPkgCategory, newerPkgBranch, caseSensitive)
		    
		    if (multiMatch):
		        self.matchCache[atom] = {}
		        self.matchCache[atom]['matchSlot'] = matchSlot
		        self.matchCache[atom]['multiMatch'] = multiMatch
		        self.matchCache[atom]['caseSensitive'] = caseSensitive
		        self.matchCache[atom]['matchBranches'] = matchBranches
		        self.matchCache[atom]['result'] = similarPackages,0
			return similarPackages,0
		    
		    #print newerPackage
		    #print similarPackages
	            if (len(similarPackages) > 1):
		        # gosh, there are packages with the same name, version, category
		        # we need to parse version tag
		        versionTags = []
		        for pkg in similarPackages:
		            versionTags.append(self.retrieveVersionTag(pkg[1]))
		        versiontaglist = entropyTools.getNewerVersionTag(versionTags)
		        newerPackage = similarPackages[versionTags.index(versiontaglist[0])]
		
		    #print newerPackage
		    #print newerPackage[1]
		    self.matchCache[atom] = {}
		    self.matchCache[atom]['matchSlot'] = matchSlot
		    self.matchCache[atom]['multiMatch'] = multiMatch
		    self.matchCache[atom]['caseSensitive'] = caseSensitive
		    self.matchCache[atom]['matchBranches'] = matchBranches
		    self.matchCache[atom]['result'] = newerPackage[0],0
		    return newerPackage[0],0
	
	        elif (direction.find(">") != -1) or (direction.find("<") != -1): # FIXME: add slot scopes
		
		    #print direction+" direction"
		    # remove revision (-r0 if none)
		    if pkgversion.split("-")[len(pkgversion.split("-"))-1] == "r0":
		        # remove
		        pkgversion = string.join(pkgversion.split("-")[:len(pkgversion.split("-"))-1],"-")

		    dbpkginfo = []
		    for list in foundIDs:
		        idpackage = list[1]
		        dbver = self.retrieveVersion(idpackage)
		        cmp = entropyTools.compareVersions(pkgversion,dbver)
		        if direction == ">": # the --deep mode should really act on this
		            if (cmp < 0):
			        # found
			        dbpkginfo.append([idpackage,dbver])
		        elif direction == "<":
		            if (cmp > 0):
			        # found
			        dbpkginfo.append([idpackage,dbver])
		        elif direction == ">=": # the --deep mode should really act on this
		            if (cmp <= 0):
			        # found
			        dbpkginfo.append([idpackage,dbver])
		        elif direction == "<=":
		            if (cmp >= 0):
			        # found
			        dbpkginfo.append([idpackage,dbver])
		
		    if (not dbpkginfo):
		        # this version is not available
		        self.matchCache[atom] = {}
		        self.matchCache[atom]['matchSlot'] = matchSlot
		        self.matchCache[atom]['multiMatch'] = multiMatch
		        self.matchCache[atom]['caseSensitive'] = caseSensitive
		        self.matchCache[atom]['matchBranches'] = matchBranches
		        self.matchCache[atom]['result'] = -1,1
		        return -1,1
		
		    versions = []
		    multiMatchList = []
		    _dbpkginfo = []
		    for x in dbpkginfo:
			if (matchSlot != None):
			    mslot = self.retrieveSlot(x[0])
			    if (str(matchSlot) != str(mslot)):
				continue
			if (multiMatch):
			    multiMatchList.append(x[0])
		        versions.append(x[1])
			_dbpkginfo.append(x)
		    dbpkginfo = _dbpkginfo
		    
		    if (multiMatch):
			return multiMatchList,0

		    if (not versions):
		        self.matchCache[atom] = {}
		        self.matchCache[atom]['matchSlot'] = matchSlot
		        self.matchCache[atom]['multiMatch'] = multiMatch
		        self.matchCache[atom]['caseSensitive'] = caseSensitive
		        self.matchCache[atom]['matchBranches'] = matchBranches
		        self.matchCache[atom]['result'] = -1,1
			return -1,1

		    # who is newer ?
		    versionlist = entropyTools.getNewerVersion(versions)
		    newerPackage = dbpkginfo[versions.index(versionlist[0])]
		
	            # now look if there's another package with the same category, name, version, but different tag
	            newerPkgName = self.retrieveName(newerPackage[0])
	            newerPkgCategory = self.retrieveCategory(newerPackage[0])
	            newerPkgVersion = self.retrieveVersion(newerPackage[0])
		    newerPkgBranch = self.retrieveBranch(newerPackage[0])
	            similarPackages = self.searchPackagesInBranchByNameAndVersionAndCategory(newerPkgName, newerPkgVersion, newerPkgCategory, newerPkgBranch)

		    if (multiMatch):
		        self.matchCache[atom] = {}
		        self.matchCache[atom]['matchSlot'] = matchSlot
		        self.matchCache[atom]['multiMatch'] = multiMatch
		        self.matchCache[atom]['caseSensitive'] = caseSensitive
		        self.matchCache[atom]['matchBranches'] = matchBranches
		        self.matchCache[atom]['result'] = similarPackages,0
			return similarPackages,0

		    #print newerPackage
		    #print similarPackages
	            if (len(similarPackages) > 1):
		        # gosh, there are packages with the same name, version, category
		        # we need to parse version tag
		        versionTags = []
		        for pkg in similarPackages:
		            versionTags.append(self.retrieveVersionTag(pkg[1]))
		        versiontaglist = entropyTools.getNewerVersionTag(versionTags)
		        newerPackage = similarPackages[versionTags.index(versiontaglist[0])]
		
		    #print newerPackage
		    #print newerPackage[1]
		    self.matchCache[atom] = {}
		    self.matchCache[atom]['matchSlot'] = matchSlot
		    self.matchCache[atom]['multiMatch'] = multiMatch
		    self.matchCache[atom]['caseSensitive'] = caseSensitive
		    self.matchCache[atom]['matchBranches'] = matchBranches
		    self.matchCache[atom]['result'] = newerPackage[0],0
		    return newerPackage[0],0

	        else:
		    self.matchCache[atom] = {}
		    self.matchCache[atom]['matchSlot'] = matchSlot
		    self.matchCache[atom]['multiMatch'] = multiMatch
		    self.matchCache[atom]['caseSensitive'] = caseSensitive
		    self.matchCache[atom]['matchBranches'] = matchBranches
		    self.matchCache[atom]['result'] = -1,1
		    return -1,1
		
	    else:
	    
	        #print foundIDs
	    
	        # not set, just get the newer version, matching slot choosen if matchSlot != None
	        versionIDs = []
		#print foundIDs
		multiMatchList = []
		_foundIDs = []
	        for list in foundIDs:
		    if (matchSlot == None):
		        versionIDs.append(self.retrieveVersion(list[1]))
			if (multiMatch):
			    multiMatchList.append(list[1])
		    else:
			foundslot = self.retrieveSlot(list[1])
			if (str(foundslot) != str(matchSlot)):
			    continue
			versionIDs.append(self.retrieveVersion(list[1]))
			if (multiMatch):
			    multiMatchList.append(list[1])
		    _foundIDs.append(list)
		foundIDs = _foundIDs
	    
		if (multiMatch):
		    return multiMatchList,0
		
		if (not versionIDs):
		    self.matchCache[atom] = {}
		    self.matchCache[atom]['matchSlot'] = matchSlot
		    self.matchCache[atom]['multiMatch'] = multiMatch
		    self.matchCache[atom]['caseSensitive'] = caseSensitive
		    self.matchCache[atom]['matchBranches'] = matchBranches
		    self.matchCache[atom]['result'] = -1,1
		    return -1,1
		
	        versionlist = entropyTools.getNewerVersion(versionIDs)
	        newerPackage = foundIDs[versionIDs.index(versionlist[0])]
	    
	        # now look if there's another package with the same category, name, version, tag
	        newerPkgName = self.retrieveName(newerPackage[1])
	        newerPkgCategory = self.retrieveCategory(newerPackage[1])
	        newerPkgVersion = self.retrieveVersion(newerPackage[1])
	        newerPkgBranch = self.retrieveBranch(newerPackage[1])
	        similarPackages = self.searchPackagesInBranchByNameAndVersionAndCategory(newerPkgName, newerPkgVersion, newerPkgCategory, newerPkgBranch)

	        if (len(similarPackages) > 1):
		    # gosh, there are packages with the same name, version, category
		    # we need to parse version tag
		    versionTags = []
		    for pkg in similarPackages:
		        versionTags.append(self.retrieveVersionTag(pkg[1]))
		    versiontaglist = entropyTools.getNewerVersionTag(versionTags)
		    newerPackage = similarPackages[versionTags.index(versiontaglist[0])]
	    
		self.matchCache[atom] = {}
		self.matchCache[atom]['matchSlot'] = matchSlot
		self.matchCache[atom]['multiMatch'] = multiMatch
		self.matchCache[atom]['caseSensitive'] = caseSensitive
		self.matchCache[atom]['matchBranches'] = matchBranches
		self.matchCache[atom]['result'] = newerPackage[1],0
	        return newerPackage[1],0

        else:
	    # package not found in any branch
	    self.matchCache[atom] = {}
	    self.matchCache[atom]['matchSlot'] = matchSlot
	    self.matchCache[atom]['multiMatch'] = multiMatch
	    self.matchCache[atom]['caseSensitive'] = caseSensitive
	    self.matchCache[atom]['matchBranches'] = matchBranches
	    self.matchCache[atom]['result'] = -1,1
	    return -1,1