Entropy/EquoInterface/etpDatabase:

- removed 'info cache' from etpDatabase, there is no need to have an on-disk cache when sqlite3 is faster
- updated EquoInterface accordingly
- improved reliability when running multiple Entropy instances
Entropy/Spritz:
- fixed some minor bugs


git-svn-id: http://svn.sabayonlinux.org/projects/entropy/trunk@1890 cd1c1023-2f26-0410-ae45-c471fc1f0318

TODO

@@ -1,7 +1,6 @@
 TODO list
   - server-side: expired packages check
   - add i18n support
-  - client: check lock file on repo sync
   - server-side: EAPI-2 don't remove indexes but copy a db over and work on it
   - server-side: improve RDEPEND check output
   - server-side: add libtest to reagent

client/text_rescue.py

@@ -28,6 +28,7 @@
 from entropyConstants import *
 from outputTools import *
 from entropy import EquoInterface
+import exceptionTools
 Equo = EquoInterface(noclientdb = True)
 
 def test_spm():
@@ -39,6 +40,13 @@ def test_spm():
         print_error(darkred(" * ")+bold("Source Package Manager backend")+red(" is not available."))
         return None
 
+def test_clientdb():
+    try:
+        Equo.clientDbconn.validateDatabase()
+    except exceptionTools.SystemDatabaseError:
+        print_error(darkred(" * ")+bold("Installed packages database")+red(" is not available."))
+        return 1
+
 def database(options):
 
     if len(options) < 1:
@@ -293,9 +301,14 @@ def database(options):
         return 0
 
     elif (options[0] == "depends"):
-	print_info(red("  Regenerating depends caching table..."))
-	Equo.clientDbconn.regenerateDependsTable()
-	print_info(red("  Depends caching table regenerated successfully."))
+
+        rc = test_clientdb()
+        if rc != None:
+            return rc
+
+        print_info(red("  Regenerating depends caching table..."))
+        Equo.clientDbconn.regenerateDependsTable()
+        print_info(red("  Depends caching table regenerated successfully."))
         return 0
 
     elif (options[0] == "counters"):
@@ -304,6 +317,10 @@ def database(options):
         if Spm == None:
             return 1
 
+        rc = test_clientdb()
+        if rc != None:
+            return rc
+
         print_info(red("  Regenerating counters table. Please wait..."))
         Equo.clientDbconn.regenerateCountersTable(Spm.get_vdb_path(), output = True)
         print_info(red("  Counters table regenerated. Check above for errors."))
@@ -315,6 +332,10 @@ def database(options):
         if Spm == None:
             return 1
 
+        rc = test_clientdb()
+        if rc != None:
+            return rc
+
         print_info(red(" Scanning Portage and Entropy databases for differences..."))
 
         # make it crash
@@ -375,7 +396,15 @@ def database(options):
             # then exit gracefully
             return 0
 
-        if (toBeRemoved):
+        # check lock file
+        gave_up = Equo.lock_check(Equo._resources_run_check_lock)
+        if gave_up:
+            print_info(red(" Entropy locked, giving up."))
+            return 2
+
+        Equo._resources_run_create_lock()
+
+        if toBeRemoved:
             print_info(brown(" @@ ")+blue("Someone removed these packages. Would be removed from the Entropy database:"))
 
             for x in toBeRemoved:
@@ -393,22 +422,21 @@ def database(options):
                     Equo.clientDbconn.removePackage(x)
                 print_info(brown(" @@ ")+blue("Database removal complete."))
 
-        if (toBeAdded):
+        if toBeAdded:
             print_info(brown(" @@ ")+blue("Someone added these packages. Would be added/updated into the Entropy database:"))
             for x in toBeAdded:
                 print_info(darkgreen("   # ")+red(x[0]))
             rc = "Yes"
             if etpUi['ask']: rc = Equo.askQuestion(">>   Continue with adding?")
             if rc == "No":
+                Equo._resources_run_remove_lock()
                 return 0
             # now analyze
 
             totalqueue = str(len(toBeAdded))
             queue = 0
-            for item in toBeAdded:
+            for atom,counter in toBeAdded:
                 queue += 1
-                counter = item[1]
-                atom = item[0]
                 print_info(red(" ++ ")+bold("(")+blue(str(queue))+"/"+red(totalqueue)+bold(") ")+">>> Adding "+darkgreen(atom))
                 if not os.path.isdir(etpConst['entropyunpackdir']):
                     os.makedirs(etpConst['entropyunpackdir'])
@@ -449,6 +477,7 @@ def database(options):
 
             print_info(brown(" @@ ")+blue("Database update completed."))
 
+        Equo._resources_run_remove_lock()
         return 0
 
     else:
@@ -515,7 +544,6 @@ def pythonUpdater():
         match = Equo.atomMatch(atomkey, matchSlot = slot)
         if match[0] != -1:
             matchedAtoms.add((atomkey+":"+slot,match))
-    del atoms
     del idpackages
 
     # now show, then ask or exit (if pretend)

client/text_ui.py

@@ -316,15 +316,16 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
             print_info(red(" @@ ")+blue("These are the chosen packages:"))
             totalatoms = len(foundAtoms)
             atomscounter = 0
-            for atomInfo in foundAtoms:
+            for idpackage,reponame in foundAtoms:
                 atomscounter += 1
-                idpackage = atomInfo[0]
-                reponame = atomInfo[1]
                 # open database
                 dbconn = Equo.openRepositoryDatabase(reponame)
 
                 # get needed info
                 pkgatom = dbconn.retrieveAtom(idpackage)
+                if not pkgatom:
+                    continue
+
                 pkgver = dbconn.retrieveVersion(idpackage)
                 pkgtag = dbconn.retrieveVersionTag(idpackage)
                 if not pkgtag:
@@ -357,7 +358,10 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
                     installedVer = "0"
                 if installedRev == "NoRev":
                     installedRev = 0
-                pkgcmp = Equo.entropyTools.entropyCompareVersions((pkgver,pkgtag,pkgrev),(installedVer,installedTag,installedRev))
+                pkgcmp = Equo.entropyTools.entropyCompareVersions(
+                    (pkgver,pkgtag,pkgrev),
+                    (installedVer,installedTag,installedRev)
+                )
                 if (pkgcmp == 0):
                     if installedRepo != reponame:
                         action = darkgreen("Reinstall")+" | Switch repo: "+blue(installedRepo)+" ===> "+darkgreen(reponame)
@@ -375,7 +379,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
             if (etpUi['verbose'] or etpUi['ask'] or etpUi['pretend']):
                 print_info(red(" @@ ")+blue("Number of packages: ")+str(totalatoms))
 
-            if (deps):
+            if deps:
                 if (etpUi['ask']):
                     rc = Equo.askQuestion("     Would you like to continue with dependencies calculation ?")
                     if rc == "No":
@@ -437,20 +441,22 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
                 print_info(red(" @@ ")+blue("These are the packages that would be ")+bold("merged:"))
 
             count = 0
-            for packageInfo in runQueue:
+            for idpackage,reponame in runQueue:
                 count += 1
 
-                dbconn = Equo.openRepositoryDatabase(packageInfo[1])
-                pkgatom = dbconn.retrieveAtom(packageInfo[0])
-                pkgver = dbconn.retrieveVersion(packageInfo[0])
-                pkgtag = dbconn.retrieveVersionTag(packageInfo[0])
-                pkgrev = dbconn.retrieveRevision(packageInfo[0])
-                pkgslot = dbconn.retrieveSlot(packageInfo[0])
-                pkgfile = dbconn.retrieveDownloadURL(packageInfo[0])
-                onDiskUsedSize += dbconn.retrieveOnDiskSize(packageInfo[0])
+                dbconn = Equo.openRepositoryDatabase(reponame)
+                pkgatom = dbconn.retrieveAtom(idpackage)
+                if not pkgatom:
+                    continue
+                pkgver = dbconn.retrieveVersion(idpackage)
+                pkgtag = dbconn.retrieveVersionTag(idpackage)
+                pkgrev = dbconn.retrieveRevision(idpackage)
+                pkgslot = dbconn.retrieveSlot(idpackage)
+                pkgfile = dbconn.retrieveDownloadURL(idpackage)
+                onDiskUsedSize += dbconn.retrieveOnDiskSize(idpackage)
 
                 dl = Equo.check_needed_package_download(pkgfile, None) # we'll do a good check during installPackage
-                pkgsize = dbconn.retrieveSize(packageInfo[0])
+                pkgsize = dbconn.retrieveSize(idpackage)
                 unpackSize += int(pkgsize)*2
                 if dl < 0:
                     downloadSize += int(pkgsize)
@@ -459,7 +465,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
                         f = open(etpConst['entropyworkdir']+"/"+pkgfile,"r")
                         f.seek(0,2)
                         currsize = f.tell()
-                        pkgsize = dbconn.retrieveSize(packageInfo[0])
+                        pkgsize = dbconn.retrieveSize(idpackage)
                         downloadSize += int(pkgsize)-int(currsize)
                         f.close()
                     except:
@@ -485,7 +491,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
 
                 action = 0
                 repoSwitch = False
-                if packageInfo[1] != installedRepo:
+                if reponame != installedRepo:
                     repoSwitch = True
                 if repoSwitch:
                     flags = darkred(" [")
@@ -514,9 +520,9 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
                     flags += "] "
 
                 if repoSwitch:
-                    repoinfo = "["+brown(installedRepo)+"->"+darkred(packageInfo[1])+"] "
+                    repoinfo = "["+brown(installedRepo)+"->"+darkred(reponame)+"] "
                 else:
-                    repoinfo = "["+brown(packageInfo[1])+"] "
+                    repoinfo = "["+brown(reponame)+"] "
                 oldinfo = ''
                 if action != 0:
                     oldinfo = "   ["+blue(installedVer)+"|"+red(str(installedRev))
@@ -531,13 +537,15 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
         neededSize = deltaSize
         if unpackSize > 0: neededSize += unpackSize
 
-        if (removalQueue):
+        if removalQueue:
 
             if (etpUi['ask'] or etpUi['pretend'] or etpUi['verbose']) and removalQueue:
                 print_info(red(" @@ ")+blue("These are the packages that would be ")+bold("removed")+blue(" (conflicting/substituted):"))
 
                 for idpackage in removalQueue:
                     pkgatom = Equo.clientDbconn.retrieveAtom(idpackage)
+                    if not pkgatom:
+                        continue
                     onDiskFreedSize += Equo.clientDbconn.retrieveOnDiskSize(idpackage)
                     installedfrom = Equo.clientDbconn.retrievePackageFromInstalledTable(idpackage)
                     repoinfo = red("[")+brown("from: ")+bold(installedfrom)+red("] ")
@@ -552,11 +560,11 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
                 print_info(red(" @@ ")+darkgreen("Packages needing reinstall:\t")+darkgreen(str(pkgsToReinstall)))
                 print_info(red(" @@ ")+blue("Packages needing update:\t\t")+blue(str(pkgsToUpdate)))
                 print_info(red(" @@ ")+red("Packages needing downgrade:\t")+red(str(pkgsToDowngrade)))
-            if downloadSize >0:
+            if downloadSize > 0:
                 print_info(red(" @@ ")+blue("Download size:\t\t\t")+bold(str(Equo.entropyTools.bytesIntoHuman(downloadSize))))
             else:
                 print_info(red(" @@ ")+blue("Download size:\t\t\t")+bold("0b"))
-            if (deltaSize > 0):
+            if deltaSize > 0:
                 print_info(red(" @@ ")+blue("Used disk space:\t\t\t")+bold(str(Equo.entropyTools.bytesIntoHuman(deltaSize))))
             else:
                 print_info(red(" @@ ")+blue("Freed disk space:\t\t")+bold(str(Equo.entropyTools.bytesIntoHuman(abs(deltaSize)))))
@@ -626,8 +634,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
                 runQueue, x, status = Equo.retrieveInstallQueue(runQueue[1:], emptydeps, deepdeps)
                 del x # was removalQueue
                 # save new queues
-                resume_cache['runQueue'] = runQueue[:]
-                #resume_cache['removalQueue'] = removalQueue[:]
+                resume_cache['runQueue'] = runQueue
                 try:
                     Equo.dumpTools.dumpobj(etpCache['install'],resume_cache)
                 except (IOError,OSError):
@@ -635,9 +642,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
 
     # running tasks
     totalqueue = str(len(runQueue))
-    #totalremovalqueue = str(len(removalQueue))
     currentqueue = 0
-    #currentremovalqueue = 0
 
     def read_lic_selection():
         print_info(darkred("    Please choose an action"))
@@ -672,11 +677,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals
                 choice = read_lic_selection()
                 try:
                     choice = int(choice)
-                except ValueError:
-                    continue
-                except EOFError:
-                    continue
-                except TypeError:
+                except (ValueError,EOFError,TypeError):
                     continue
                 if choice not in (0,1,2,3):
                     continue
@@ -783,25 +784,20 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys
     if not resume:
 
         foundAtoms = []
-        if (atomsdata):
+        if atomsdata:
             for idpackage in atomsdata:
-                foundAtoms.append([Equo.clientDbconn.retrieveAtom(idpackage),(idpackage,0)])
+                if not Equo.clientDbconn.isIDPackageAvailable(idpackage):
+                    continue
+                foundAtoms.append(idpackage)
         else:
             for package in packages:
-                foundAtoms.append([package,Equo.clientDbconn.atomMatch(package)])
+                idpackage, result = Equo.clientDbconn.atomMatch(package)
+                if idpackage == -1:
+                    print_warning(red("## ATTENTION -> package")+bold(" "+package+" ")+red("is not installed."))
+                    continue
+                foundAtoms.append(idpackage)
 
-        # filter packages not found
-        _foundAtoms = []
-        for result in foundAtoms:
-            exitcode = result[1][0]
-            if (exitcode != -1):
-                _foundAtoms.append(result[1])
-            else:
-                print_warning(red("## ATTENTION -> package")+bold(" "+result[0]+" ")+red("is not installed."))
-        foundAtoms = _foundAtoms
-
-        # are packages in foundAtoms?
-        if (not foundAtoms):
+        if not foundAtoms:
             print_error(red("No packages found"))
             return 125,-1
 
@@ -812,14 +808,15 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys
         print_info(red(" @@ ")+blue("These are the chosen packages:"))
         totalatoms = len(foundAtoms)
         atomscounter = 0
-        for atomInfo in foundAtoms:
+        for idpackage in foundAtoms:
             atomscounter += 1
-            idpackage = atomInfo[0]
 
             # get needed info
             pkgatom = Equo.clientDbconn.retrieveAtom(idpackage)
+            if not pkgatom:
+                continue
 
-            if (systemPackagesCheck):
+            if systemPackagesCheck:
                 valid = Equo.validatePackageRemoval(idpackage)
                 if not valid:
                     print_warning(darkred("   # !!! ")+red("(")+brown(str(atomscounter))+"/"+blue(str(totalatoms))+red(")")+" "+enlightenatom(pkgatom)+red(" is a vital package. Removal forbidden."))
@@ -855,7 +852,7 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys
 
         removalQueue = []
 
-        if (lookForOrphanedPackages):
+        if lookForOrphanedPackages:
             choosenRemovalQueue = []
             choosenRemovalQueue = Equo.retrieveRemovalQueue(plainRemovalQueue, deep = deep)
             if choosenRemovalQueue:
@@ -866,6 +863,8 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys
                 for idpackage in choosenRemovalQueue:
                     atomscounter += 1
                     rematom = Equo.clientDbconn.retrieveAtom(idpackage)
+                    if not rematom:
+                        continue
                     installedfrom = Equo.clientDbconn.retrievePackageFromInstalledTable(idpackage)
                     disksize = Equo.clientDbconn.retrieveOnDiskSize(idpackage)
                     disksize = Equo.entropyTools.bytesIntoHuman(disksize)
@@ -907,9 +906,9 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys
             # store resume information
             resume_cache = {}
             resume_cache['doSelectiveRemoval'] = doSelectiveRemoval
-            resume_cache['removalQueue'] = removalQueue[:]
+            resume_cache['removalQueue'] = removalQueue
             Equo.dumpTools.dumpobj(etpCache['remove'],resume_cache)
-        except (OSError, IOError):
+        except (OSError, IOError, EOFError):
             pass
 
     else: # if resume, load cache if possible
@@ -950,6 +949,8 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys
         for idpackage in removalQueue:
             currentqueue += 1
             atom = Equo.clientDbconn.retrieveAtom(idpackage)
+            if not atom:
+                continue
             print_info(red(" -- ")+bold("(")+blue(str(currentqueue))+"/"+red(totalqueue)+bold(") ")+">>> "+darkgreen(atom))
             if doSelectiveRemoval:
                 rc = Equo.askQuestion("     Remove this one ?")
@@ -967,19 +968,21 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys
         metaopts['removeconfig'] = configFiles
         Package = Equo.Package()
         Package.prepare((idpackage,),"remove", metaopts)
+        if not Package.infoDict.has_key('remove_installed_vanished'):
 
-        xterm_header = "Equo (remove) :: "+str(currentqueue)+" of "+totalqueue+" ::"
-        print_info(red(" -- ")+bold("(")+blue(str(currentqueue))+"/"+red(totalqueue)+bold(") ")+">>> "+darkgreen(Package.infoDict['removeatom']))
+            xterm_header = "Equo (remove) :: "+str(currentqueue)+" of "+totalqueue+" ::"
+            print_info(red(" -- ")+bold("(")+blue(str(currentqueue))+"/"+red(totalqueue)+bold(") ")+">>> "+darkgreen(Package.infoDict['removeatom']))
 
-        rc = Package.run(xterm_header = xterm_header)
-        if rc != 0:
-            return -1,rc
+            rc = Package.run(xterm_header = xterm_header)
+            if rc != 0:
+                return -1,rc
 
         # update resume cache
-        resume_cache['removalQueue'].remove(Package.infoDict['removeidpackage'])
+        if idpackage in resume_cache['removalQueue']:
+            resume_cache['removalQueue'].remove(idpackage)
         try:
             Equo.dumpTools.dumpobj(etpCache['remove'],resume_cache)
-        except (OSError,IOError):
+        except (OSError,IOError,EOFError):
             pass
 
         Package.kill()

libraries/databaseTools.py

@@ -413,7 +413,7 @@ class etpDatabase:
             clientDbconn.setRepositoryUpdatesDigest(repository, stored_digest)
 
             # clear client cache
-            clientDbconn.clearCache(all = True)
+            clientDbconn.clearCache()
 
     # this functions will filter either data from /usr/portage/profiles/updates/*
     # or repository database returning only the needed actions
@@ -493,7 +493,7 @@ class etpDatabase:
             self.commitChanges()
 
         # discard cache
-        self.clearCache(all = True)
+        self.clearCache()
 
 
     # -- move action:
@@ -1624,11 +1624,16 @@ class etpDatabase:
 
     def getApi(self):
         self.cursor.execute('SELECT max(etpapi) FROM baseinfo')
-        return self.cursor.fetchone()[0]
+        api = self.cursor.fetchone()
+        if api: api = api[0]
+        else: api = -1
+        return api
 
     def getCategory(self, idcategory):
         self.cursor.execute('SELECT category from categories WHERE idcategory = (?)', (idcategory,))
-        return self.cursor.fetchone()[0]
+        cat = self.cursor.fetchone()
+        if cat: cat = cat[0]
+        return cat
 
     def get_category_description_from_disk(self, category):
         if not self.ServiceInterface:
@@ -1847,7 +1852,7 @@ class etpDatabase:
     def fetchone2set(self, item):
         return set(item)
 
-    def clearCache(self, all = False, depends = False):
+    def clearCache(self, depends = False):
         self.live_cache.clear()
         def do_clear(name):
             dump_path = os.path.join(etpConst['dumpstoragedir'],name)
@@ -1857,8 +1862,6 @@ class etpDatabase:
                     item = os.path.join(dump_dir,item)
                     if os.path.isfile(item):
                         os.remove(item)
-        if all:
-            do_clear(etpCache['dbInfo']+"/"+self.dbname+"/")
         do_clear(etpCache['dbMatch']+"/"+self.dbname+"/")
         do_clear(etpCache['dbSearch']+"/"+self.dbname+"/")
         if depends:
@@ -1866,33 +1869,6 @@ class etpDatabase:
             do_clear(etpCache['dep_tree'])
             do_clear(etpCache['filter_satisfied_deps'])
 
-    def fetchInfoCache(self, idpackage, function, extra_hash = 0):
-        if self.xcache:
-
-            c_hash = str(hash(function)) + str(extra_hash)
-            c_match = str(idpackage)
-            try:
-                cached = dumpTools.loadobj(etpCache['dbInfo']+"/"+self.dbname+"/"+c_match+"/"+c_hash)
-                if cached != None:
-                    return cached
-            except EOFError:
-                pass
-
-
-    def storeInfoCache(self, idpackage, function, info_cache_data, extra_hash = 0):
-        if self.xcache:
-            c_hash = str(hash(function)) + str(extra_hash)
-            c_match = str(idpackage)
-            try:
-                sperms = False
-                if not os.path.isdir(os.path.join(etpConst['dumpstoragedir'],etpCache['dbInfo']+"/"+self.dbname)):
-                    sperms = True
-                dumpTools.dumpobj(etpCache['dbInfo']+"/"+self.dbname+"/"+c_match+"/"+c_hash,info_cache_data)
-                if sperms:
-                    const_setup_perms(etpConst['dumpstoragedir'],etpConst['entropygid'])
-            except (IOError, OSError):
-                pass
-
     def fetchSearchCache(self, key, function, extra_hash = 0):
         if self.xcache:
 
@@ -1976,234 +1952,128 @@ class etpDatabase:
         self.commitChanges()
 
     def retrieveAtom(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveAtom')
-        #if cache != None: return cache
-
         self.cursor.execute('SELECT atom FROM baseinfo WHERE idpackage = (?)', (idpackage,))
-        atom = self.cursor.fetchone()[0]
-
-        #self.storeInfoCache(idpackage,'retrieveAtom',atom)
-        return atom
+        atom = self.cursor.fetchone()
+        if atom:
+            return atom[0]
 
     def retrieveBranch(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveBranch')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT branch FROM baseinfo WHERE idpackage = (?)', (idpackage,))
-        br = self.cursor.fetchone()[0]
-
-        self.storeInfoCache(idpackage,'retrieveBranch',br)
-        return br
+        br = self.cursor.fetchone()
+        if br:
+            return br[0]
 
     def retrieveTrigger(self, idpackage):
-
         self.cursor.execute('SELECT data FROM triggers WHERE idpackage = (?)', (idpackage,))
         trigger = self.cursor.fetchone()
         if trigger:
             trigger = trigger[0]
         else:
             trigger = ''
-
         return trigger
 
     def retrieveDownloadURL(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveDownloadURL')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT download FROM extrainfo WHERE idpackage = (?)', (idpackage,))
-        download = self.cursor.fetchone()[0]
-
-        self.storeInfoCache(idpackage,'retrieveDownloadURL',download)
-        return download
+        download = self.cursor.fetchone()
+        if download:
+            return download[0]
 
     def retrieveDescription(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveDescription')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT description FROM extrainfo WHERE idpackage = (?)', (idpackage,))
-        description = self.cursor.fetchone()[0]
-
-        self.storeInfoCache(idpackage,'retrieveDescription',description)
-        return description
+        description = self.cursor.fetchone()
+        if description:
+            return description[0]
 
     def retrieveHomepage(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveHomepage')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT homepage FROM extrainfo WHERE idpackage = (?)', (idpackage,))
-        home = self.cursor.fetchone()[0]
-
-        self.storeInfoCache(idpackage,'retrieveHomepage',home)
-        return home
+        home = self.cursor.fetchone()
+        if home:
+            return home[0]
 
     def retrieveCounter(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveCounter')
-        #if cache != None: return cache
-
         counter = -1
         self.cursor.execute('SELECT counter FROM counters WHERE idpackage = (?)', (idpackage,))
         mycounter = self.cursor.fetchone()
         if mycounter:
-            counter = mycounter[0]
-
-        #self.storeInfoCache(idpackage,'retrieveCounter',int(counter))
-        return int(counter)
+            return mycounter[0]
+        return counter
 
     def retrieveMessages(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveMessages')
-        if cache != None: return cache
-
         messages = []
         try:
             self.cursor.execute('SELECT message FROM messages WHERE idpackage = (?)', (idpackage,))
             messages = self.fetchall2list(self.cursor.fetchall())
         except:
             pass
-
-        self.storeInfoCache(idpackage,'retrieveMessages',messages)
         return messages
 
     # in bytes
     def retrieveSize(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveSize')
-        #if cache != None: return cache
-
         self.cursor.execute('SELECT size FROM extrainfo WHERE idpackage = (?)', (idpackage,))
-        size = self.cursor.fetchone()[0]
-
-        #self.storeInfoCache(idpackage,'retrieveSize',size)
-        return size
+        size = self.cursor.fetchone()
+        if size:
+            return size[0]
 
     # in bytes
     def retrieveOnDiskSize(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveOnDiskSize')
-        #if cache != None: return cache
-
         self.cursor.execute('SELECT size FROM sizes WHERE idpackage = (?)', (idpackage,))
         size = self.cursor.fetchone() # do not use [0]!
         if not size:
             size = 0
         else:
             size = size[0]
-
-        #self.storeInfoCache(idpackage,'retrieveOnDiskSize',size)
         return size
 
     def retrieveDigest(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveDigest')
-        #if cache != None: return cache
-
         self.cursor.execute('SELECT digest FROM extrainfo WHERE idpackage = (?)', (idpackage,))
-        digest = self.cursor.fetchone()[0]
-
-        #self.storeInfoCache(idpackage,'retrieveDigest',digest)
-        return digest
+        digest = self.cursor.fetchone()
+        if digest:
+            return digest[0]
 
     def retrieveName(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveName')
-        #if cache != None: return cache
-
         self.cursor.execute('SELECT name FROM baseinfo WHERE idpackage = (?)', (idpackage,))
-        name = self.cursor.fetchone()[0]
-
-        #self.storeInfoCache(idpackage,'retrieveName',name)
-        return name
+        name = self.cursor.fetchone()
+        if name:
+            return name[0]
 
     def retrieveKeySlot(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveKey')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT categories.category || "/" || baseinfo.name,baseinfo.slot FROM baseinfo,categories WHERE baseinfo.idpackage = (?) and baseinfo.idcategory = categories.idcategory', (idpackage,))
         data = self.cursor.fetchone()
-
-        self.storeInfoCache(idpackage,'retrieveKey',data)
         return data
 
     def retrieveVersion(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveVersion')
-        #if cache != None: return cache
-
         self.cursor.execute('SELECT version FROM baseinfo WHERE idpackage = (?)', (idpackage,))
-        ver = self.cursor.fetchone()[0]
-
-        #self.storeInfoCache(idpackage,'retrieveVersion',ver)
-        return ver
+        ver = self.cursor.fetchone()
+        if ver:
+            return ver[0]
 
     def retrieveRevision(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveRevision')
-        #if cache != None: return cache
-
         self.cursor.execute('SELECT revision FROM baseinfo WHERE idpackage = (?)', (idpackage,))
-        rev = self.cursor.fetchone()[0]
-
-        #self.storeInfoCache(idpackage,'retrieveRevision',rev)
-        return rev
+        rev = self.cursor.fetchone()
+        if rev:
+            return rev[0]
 
     def retrieveDateCreation(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveDateCreation')
-        #if cache != None: return cache
-
-        self.cursor.execute('SELECT "datecreation" FROM extrainfo WHERE idpackage = (?)', (idpackage,))
-        date = self.cursor.fetchone()[0]
-        if not date:
-            date = "N/A" #FIXME: to be removed?
-
-        #self.storeInfoCache(idpackage,'retrieveDateCreation',date)
-        return date
+        self.cursor.execute('SELECT datecreation FROM extrainfo WHERE idpackage = (?)', (idpackage,))
+        date = self.cursor.fetchone()
+        if date:
+            return date[0]
 
     def retrieveApi(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveApi')
-        #if cache != None: return cache
-
-        self.cursor.execute('SELECT "etpapi" FROM baseinfo WHERE idpackage = (?)', (idpackage,))
-        api = self.cursor.fetchone()[0]
-
-        #self.storeInfoCache(idpackage,'retrieveApi',api)
-        return api
+        self.cursor.execute('SELECT etpapi FROM baseinfo WHERE idpackage = (?)', (idpackage,))
+        api = self.cursor.fetchone()
+        if api:
+            return api[0]
 
     def retrieveUseflags(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveUseflags')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT flagname FROM useflags,useflagsreference WHERE useflags.idpackage = (?) and useflags.idflag = useflagsreference.idflag', (idpackage,))
-        flags = self.fetchall2set(self.cursor.fetchall())
-
-        self.storeInfoCache(idpackage,'retrieveUseflags',flags)
-        return flags
+        return self.fetchall2set(self.cursor.fetchall())
 
     def retrieveEclasses(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveEclasses')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT classname FROM eclasses,eclassesreference WHERE eclasses.idpackage = (?) and eclasses.idclass = eclassesreference.idclass', (idpackage,))
-        classes = self.fetchall2set(self.cursor.fetchall())
-
-        self.storeInfoCache(idpackage,'retrieveEclasses',classes)
-        return classes
+        return self.fetchall2set(self.cursor.fetchall())
 
     def retrieveNeeded(self, idpackage, extended = False, format = False):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveNeeded')
-        #if cache != None: return cache
-
         if extended:
             self.cursor.execute('SELECT library,elfclass FROM needed,neededreference WHERE needed.idpackage = (?) and needed.idneeded = neededreference.idneeded', (idpackage,))
             needed = self.cursor.fetchall()
@@ -2217,56 +2087,27 @@ class etpDatabase:
                 data[lib] = elfclass
             needed = data
 
-        #self.storeInfoCache(idpackage,'retrieveNeeded',needed)
         return needed
 
     def retrieveConflicts(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveConflicts')
-        if cache != None: return cache
-
-        self.cursor.execute('SELECT "conflict" FROM conflicts WHERE idpackage = (?)', (idpackage,))
-        confl = self.fetchall2set(self.cursor.fetchall())
-
-        self.storeInfoCache(idpackage,'retrieveConflicts',confl)
-        return confl
+        self.cursor.execute('SELECT conflict FROM conflicts WHERE idpackage = (?)', (idpackage,))
+        return self.fetchall2set(self.cursor.fetchall())
 
     def retrieveProvide(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveProvide')
-        #if cache != None: return cache
-
         self.cursor.execute('SELECT atom FROM provide WHERE idpackage = (?)', (idpackage,))
-        provide = self.fetchall2set(self.cursor.fetchall())
-
-        #self.storeInfoCache(idpackage,'retrieveProvide',provide)
-        return provide
+        return self.fetchall2set(self.cursor.fetchall())
 
     def retrieveDependenciesList(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveDependenciesList')
-        if cache != None: return cache
-
         deps = self.retrieveDependencies(idpackage)
         conflicts = self.retrieveConflicts(idpackage)
         for x in conflicts:
             if x[0] != "!":
                 x = "!"+x
             deps.add(x)
-        del conflicts
-
-        self.storeInfoCache(idpackage,'retrieveDependenciesList',deps)
         return deps
 
     def retrieveDependencies(self, idpackage, extended = False, deptype = None):
 
-        cache = self.fetchInfoCache(
-                        idpackage,
-                        'retrieveDependencies',
-                        extra_hash = hash(str(hash(extended))+str(hash(deptype)))
-        )
-        if cache != None: return cache
-
         searchdata = [idpackage]
 
         depstring = ''
@@ -2281,85 +2122,46 @@ class etpDatabase:
             self.cursor.execute('SELECT dependenciesreference.dependency FROM dependencies,dependenciesreference WHERE dependencies.idpackage = (?) and dependencies.iddependency = dependenciesreference.iddependency'+depstring, searchdata)
             deps = self.fetchall2set(self.cursor.fetchall())
 
-        self.storeInfoCache(idpackage,'retrieveDependencies',deps)
         return deps
 
     def retrieveIdDependencies(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveIdDependencies')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT iddependency FROM dependencies WHERE idpackage = (?)', (idpackage,))
-        iddeps = self.fetchall2set(self.cursor.fetchall())
-
-        self.storeInfoCache(idpackage,'retrieveIdDependencies',iddeps)
-        return iddeps
+        return self.fetchall2set(self.cursor.fetchall())
 
     def retrieveDependencyFromIddependency(self, iddependency):
         self.cursor.execute('SELECT dependency FROM dependenciesreference WHERE iddependency = (?)', (iddependency,))
-        return self.cursor.fetchone()[0]
+        dep = self.cursor.fetchone()
+        if dep: dep = dep[0]
+        return dep
 
     def retrieveKeywords(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveKeywords')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT keywordname FROM keywords,keywordsreference WHERE keywords.idpackage = (?) and keywords.idkeyword = keywordsreference.idkeyword', (idpackage,))
-        kw = self.fetchall2set(self.cursor.fetchall())
-
-        self.storeInfoCache(idpackage,'retrieveKeywords',kw)
-        return kw
+        return self.fetchall2set(self.cursor.fetchall())
 
     def retrieveProtect(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveProtect')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT protect FROM configprotect,configprotectreference WHERE configprotect.idpackage = (?) and configprotect.idprotect = configprotectreference.idprotect', (idpackage,))
         protect = self.cursor.fetchone()
         if not protect:
             protect = ''
         else:
             protect = protect[0]
-
-	self.storeInfoCache(idpackage,'retrieveProtect',protect)
-	return protect
+        return protect
 
     def retrieveProtectMask(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveProtectMask')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT protect FROM configprotectmask,configprotectreference WHERE idpackage = (?) and configprotectmask.idprotect= configprotectreference.idprotect', (idpackage,))
         protect = self.cursor.fetchone()
         if not protect:
             protect = ''
         else:
             protect = protect[0]
-
-        self.storeInfoCache(idpackage,'retrieveProtectMask',protect)
         return protect
 
     def retrieveSources(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveSources')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT sourcesreference.source FROM sources,sourcesreference WHERE idpackage = (?) and sources.idsource = sourcesreference.idsource', (idpackage,))
-        sources = self.fetchall2set(self.cursor.fetchall())
-
-        self.storeInfoCache(idpackage,'retrieveSources',sources)
-        return sources
+        return self.fetchall2set(self.cursor.fetchall())
 
     def retrieveContent(self, idpackage, extended = False, contentType = None):
 
-        c_hash = -4
-        if extended:
-            c_hash += 2
-        c_hash += hash(contentType)
-        cache = self.fetchInfoCache(idpackage,'retrieveContent', extra_hash = c_hash)
-        if cache != None: return cache
-
         # like portage does
         self.connection.text_factory = lambda x: unicode(x, "raw_unicode_escape")
 
@@ -2380,30 +2182,19 @@ class etpDatabase:
         else:
             fl = self.fetchall2set(self.cursor.fetchall())
 
-        self.storeInfoCache(idpackage,'retrieveContent',fl, extra_hash = c_hash)
         return fl
 
     def retrieveSlot(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveSlot')
-        #if cache != None: return cache
-
         self.cursor.execute('SELECT slot FROM baseinfo WHERE idpackage = (?)', (idpackage,))
-        ver = self.cursor.fetchone()[0]
-
-        #self.storeInfoCache(idpackage,'retrieveSlot',ver)
-        return ver
+        slot = self.cursor.fetchone()
+        if slot:
+            return slot[0]
 
     def retrieveVersionTag(self, idpackage):
-
-        #cache = self.fetchInfoCache(idpackage,'retrieveVersionTag')
-        #if cache != None: return cache
-
         self.cursor.execute('SELECT versiontag FROM baseinfo WHERE idpackage = (?)', (idpackage,))
-        vtag = self.cursor.fetchone()[0]
-
-        #self.storeInfoCache(idpackage,'retrieveVersionTag',ver)
-        return vtag
+        vtag = self.cursor.fetchone()
+        if vtag:
+            return vtag[0]
 
     def retrieveMirrorInfo(self, mirrorname):
         self.cursor.execute('SELECT mirrorlink FROM mirrorlinks WHERE mirrorname = (?)', (mirrorname,))
@@ -2411,15 +2202,10 @@ class etpDatabase:
         return mirrorlist
 
     def retrieveCategory(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveCategory')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT category FROM baseinfo,categories WHERE baseinfo.idpackage = (?) and baseinfo.idcategory = categories.idcategory', (idpackage,))
-        cat = self.cursor.fetchone()[0]
-
-        self.storeInfoCache(idpackage,'retrieveCategory',cat)
-        return cat
+        cat = self.cursor.fetchone()
+        if cat:
+            return cat[0]
 
     def retrieveCategoryDescription(self, category):
         data = {}
@@ -2434,9 +2220,6 @@ class etpDatabase:
 
     def retrieveLicensedata(self, idpackage):
 
-        cache = self.fetchInfoCache(idpackage,'retrieveLicensedata')
-        if cache != None: return cache
-
         # insert license information
         if not self.doesTableExist("licensedata"):
             return {}
@@ -2453,17 +2236,12 @@ class etpDatabase:
             self.cursor.execute('SELECT text FROM licensedata WHERE licensename = (?)', (licname,))
             lictext = self.cursor.fetchone()
             if lictext != None:
-                #licdata[licname] = unicode(lictext[0],'raw_unicode_escape','replace')
                 licdata[licname] = str(lictext[0])
 
-        self.storeInfoCache(idpackage,'retrieveLicensedata',licdata)
         return licdata
 
     def retrieveLicensedataKeys(self, idpackage):
 
-        cache = self.fetchInfoCache(idpackage,'retrieveLicensedataKeys')
-        if cache != None: return cache
-
         if not self.doesTableExist("licensedata"):
             return set()
         licenses = self.retrieveLicense(idpackage)
@@ -2478,10 +2256,10 @@ class etpDatabase:
             if licidentifier:
                 licdata.add(licidentifier[0])
 
-        self.storeInfoCache(idpackage,'retrieveLicensedataKeys',licdata)
         return licdata
 
     def retrieveLicenseText(self, license_name):
+
         if not self.doesTableExist("licensedata"):
             return None
 
@@ -2491,34 +2269,19 @@ class etpDatabase:
         text = self.cursor.fetchone()
         if not text:
             return None
-	#return unicode(text[0],'raw_unicode_escape','replace')
-	return str(text[0])
+        return str(text[0])
 
     def retrieveLicense(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveLicense')
-        if cache != None: return cache
-
         self.cursor.execute('SELECT license FROM baseinfo,licenses WHERE baseinfo.idpackage = (?) and baseinfo.idlicense = licenses.idlicense', (idpackage,))
-        licname = self.cursor.fetchone()[0]
-
-        self.storeInfoCache(idpackage,'retrieveLicense',licname)
-        return licname
+        licname = self.cursor.fetchone()
+        if licname:
+            return licname[0]
 
     def retrieveCompileFlags(self, idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'retrieveCompileFlags')
-        if cache != None: return cache
-
-        self.cursor.execute('SELECT "idflags" FROM extrainfo WHERE idpackage = (?)', (idpackage,))
-        idflag = self.cursor.fetchone()[0]
-        # now get the flags
-        self.cursor.execute('SELECT chost,cflags,cxxflags FROM flags WHERE idflags = (?)', (idflag,))
+        self.cursor.execute('SELECT chost,cflags,cxxflags FROM flags,extrainfo WHERE extrainfo.idpackage = (?) and extrainfo.idflags = flags.idflags', (idpackage,))
         flags = self.cursor.fetchone()
         if not flags:
             flags = ("N/A","N/A","N/A")
-
-        self.storeInfoCache(idpackage,'retrieveCompileFlags',flags)
         return flags
 
     def retrieveDepends(self, idpackage, atoms = False, key_slot = False):
@@ -2732,55 +2495,50 @@ class etpDatabase:
         return False
 
     def isInjected(self,idpackage):
-
-        cache = self.fetchInfoCache(idpackage,'isInjected')
-        if cache != None: return cache
-
         try:
             self.cursor.execute('SELECT idpackage FROM injected WHERE idpackage = (?)', (idpackage,))
         except:
             # readonly database?
             return False
-
         result = self.cursor.fetchone()
         rslt = False
         if result:
             rslt = True
-
-        self.storeInfoCache(idpackage,'isInjected',rslt)
         return rslt
 
     def areCompileFlagsAvailable(self,chost,cflags,cxxflags):
 
-	self.cursor.execute('SELECT idflags FROM flags WHERE chost = (?) AND cflags = (?) AND cxxflags = (?)', (chost,cflags,cxxflags,))
+        self.cursor.execute('SELECT idflags FROM flags WHERE chost = (?) AND cflags = (?) AND cxxflags = (?)', 
+            (chost,cflags,cxxflags,)
+        )
         result = self.cursor.fetchone()
-	if not result:
-	    return -1
-	return result[0]
+        if not result:
+            return -1
+        return result[0]
 
     def searchBelongs(self, file, like = False, branch = None, branch_operator = "="):
-	
-	branchstring = ''
+
+        branchstring = ''
         searchkeywords = [file]
-	if branch:
+        if branch:
             searchkeywords.append(branch)
-	    branchstring = ' and baseinfo.branch '+branch_operator+' (?)'
+            branchstring = ' and baseinfo.branch '+branch_operator+' (?)'
 
-	if (like):
-	    self.cursor.execute('SELECT content.idpackage FROM content,baseinfo WHERE file LIKE (?) and content.idpackage = baseinfo.idpackage '+branchstring, searchkeywords)
-	else:
-	    self.cursor.execute('SELECT content.idpackage FROM content,baseinfo WHERE file = (?) and content.idpackage = baseinfo.idpackage '+branchstring, searchkeywords)
+        if like:
+            self.cursor.execute('SELECT content.idpackage FROM content,baseinfo WHERE file LIKE (?) and content.idpackage = baseinfo.idpackage '+branchstring, searchkeywords)
+        else:
+            self.cursor.execute('SELECT content.idpackage FROM content,baseinfo WHERE file = (?) and content.idpackage = baseinfo.idpackage '+branchstring, searchkeywords)
 
-	return self.fetchall2set(self.cursor.fetchall())
+        return self.fetchall2set(self.cursor.fetchall())
 
     ''' search packages that uses the eclass provided '''
     def searchEclassedPackages(self, eclass, atoms = False): # atoms = return atoms directly
-	if atoms:
-	    self.cursor.execute('SELECT baseinfo.atom,eclasses.idpackage FROM baseinfo,eclasses,eclassesreference WHERE eclassesreference.classname = (?) and eclassesreference.idclass = eclasses.idclass and eclasses.idpackage = baseinfo.idpackage', (eclass,))
-	    return self.cursor.fetchall()
-	else:
-	    self.cursor.execute('SELECT idpackage FROM baseinfo WHERE versiontag = (?)', (eclass,))
-	    return self.fetchall2set(self.cursor.fetchall())
+        if atoms:
+            self.cursor.execute('SELECT baseinfo.atom,eclasses.idpackage FROM baseinfo,eclasses,eclassesreference WHERE eclassesreference.classname = (?) and eclassesreference.idclass = eclasses.idclass and eclasses.idpackage = baseinfo.idpackage', (eclass,))
+            return self.cursor.fetchall()
+        else:
+            self.cursor.execute('SELECT idpackage FROM baseinfo WHERE versiontag = (?)', (eclass,))
+            return self.fetchall2set(self.cursor.fetchall())
 
     ''' search packages whose versiontag matches the one provided '''
     def searchTaggedPackages(self, tag, atoms = False): # atoms = return atoms directly
@@ -2867,26 +2625,26 @@ class etpDatabase:
         return self.fetchall2set(self.cursor.fetchall())
 
     def searchPackages(self, keyword, sensitive = False, slot = None, tag = None, branch = None):
-	
+
         searchkeywords = ["%"+keyword+"%"]
         slotstring = ''
-	if slot:
+        if slot:
             searchkeywords.append(slot)
-	    slotstring = ' and slot = (?)'
-	tagstring = ''
-	if tag:
+            slotstring = ' and slot = (?)'
+        tagstring = ''
+        if tag:
             searchkeywords.append(tag)
-	    tagstring = ' and versiontag = (?)'
-	branchstring = ''
-	if branch:
+            tagstring = ' and versiontag = (?)'
+        branchstring = ''
+        if branch:
             searchkeywords.append(branch)
-	    branchstring = ' and branch = (?)'
-	
-	if (sensitive):
-	    self.cursor.execute('SELECT atom,idpackage,branch FROM baseinfo WHERE atom LIKE (?)'+slotstring+tagstring+branchstring, searchkeywords)
-	else:
-	    self.cursor.execute('SELECT atom,idpackage,branch FROM baseinfo WHERE LOWER(atom) LIKE (?)'+slotstring+tagstring+branchstring, searchkeywords)
-	return self.cursor.fetchall()
+            branchstring = ' and branch = (?)'
+
+        if (sensitive):
+            self.cursor.execute('SELECT atom,idpackage,branch FROM baseinfo WHERE atom LIKE (?)'+slotstring+tagstring+branchstring, searchkeywords)
+        else:
+            self.cursor.execute('SELECT atom,idpackage,branch FROM baseinfo WHERE LOWER(atom) LIKE (?)'+slotstring+tagstring+branchstring, searchkeywords)
+        return self.cursor.fetchall()
 
     def searchProvide(self, keyword, slot = None, tag = None, branch = None, justid = False):
 
@@ -2946,21 +2704,21 @@ class etpDatabase:
 
 
     def searchPackagesByCategory(self, keyword, like = False, branch = None):
-	
+
         searchkeywords = [keyword]
-	branchstring = ''
-	if branch:
+        branchstring = ''
+        if branch:
             searchkeywords.append(branch)
-	    branchstring = ' and branch = (?)'
-	
+            branchstring = ' and branch = (?)'
+
         if like:
             self.cursor.execute('SELECT baseinfo.atom,baseinfo.idpackage FROM baseinfo,categories WHERE categories.category LIKE (?) and baseinfo.idcategory = categories.idcategory '+branchstring, searchkeywords)
         else:
             self.cursor.execute('SELECT baseinfo.atom,baseinfo.idpackage FROM baseinfo,categories WHERE categories.category = (?) and baseinfo.idcategory = categories.idcategory '+branchstring, searchkeywords)
-	
-	results = self.cursor.fetchall()
 
-	return results
+        results = self.cursor.fetchall()
+
+        return results
 
     def searchPackagesByNameAndCategory(self, name, category, sensitive = False, branch = None, justid = False):
 
@@ -3046,11 +2804,6 @@ class etpDatabase:
 
     def listAllIdpackages(self, branch = None, branch_operator = "=", order_by = None):
 
-        # XXX if you will decide to re-enable this, consider that you have to clean this cache
-        # each time a package is updated/installed/removed
-        #cache = self.fetchInfoCache(hash(branch),'listAllIdpackages')
-        #if cache != None: return cache
-
         branchstring = ''
         orderbystring = ''
         searchkeywords = []
@@ -3066,7 +2819,6 @@ class etpDatabase:
             results = self.fetchall2list(self.cursor.fetchall())
         else:
             results = self.fetchall2set(self.cursor.fetchall())
-        #self.storeInfoCache(hash(branch),'listAllIdpackages',results)
         return results
 
     def listAllDependencies(self, only_deps = False):
@@ -3354,7 +3106,7 @@ class etpDatabase:
         self.setForcedAtomsUpdateId(etpConst['misc_counters']['forced_atoms_update_ids']['kde'])
         self.commitChanges()
         # drop all cache
-        self.clearCache(all = True, depends = True)
+        self.clearCache(depends = True)
 
 
     def getForcedAtomsUpdateId(self):
@@ -3941,10 +3693,8 @@ class etpDatabase:
         depends = self.listAllDependencies()
         count = 0
         total = len(depends)
-        for depend in depends:
+        for iddep,atom in depends:
             count += 1
-            atom = depend[1]
-            iddep = depend[0]
             if output:
                 self.updateProgress(
                                         red("Resolving %s") % (darkgreen(atom),),
@@ -4094,7 +3844,6 @@ class etpDatabase:
                     if keyword_data:
                         if "*" in keyword_data: # all packages in this repo with keyword "keyword" are ok
                             idpackageValidatorCache[(idpackage,reponame)] = idpackage,4
-                            #self.storeInfoCache(idpackage,'idpackageValidator',(idpackage,4))
                             return idpackage,4
                         keyword_data_ids = etpConst['packagemasking']['keywords']['repositories'][reponame].get(keyword+"_ids")
                         if keyword_data_ids == None:

libraries/entropy.py

@@ -191,7 +191,7 @@ class EquoInterface(TextInterface):
         f.flush()
         f.close()
 
-    def sync_loop_check(self, check_function):
+    def lock_check(self, check_function):
 
         lock_count = 0
         max_lock_count = 600
@@ -231,7 +231,7 @@ class EquoInterface(TextInterface):
         if cached == None:
             # invalidate matching cache
             try:
-                self.repository_move_clear_cache(all = True)
+                self.repository_move_clear_cache()
             except IOError:
                 pass
         elif type(cached) is tuple:
@@ -243,7 +243,7 @@ class EquoInterface(TextInterface):
                 difflist = cached - myrepolist # before minus now
                 for repoid in difflist:
                     try:
-                        self.repository_move_clear_cache(repoid, all = True)
+                        self.repository_move_clear_cache(repoid)
                     except IOError:
                         pass
         try:
@@ -471,7 +471,6 @@ class EquoInterface(TextInterface):
         if self.entropyTools.is_user_in_entropy_group():
             skip = set()
             if not client_purge:
-                skip.add("/"+etpCache['dbInfo']+"/"+etpConst['clientdbid']) # it's ok this way
                 skip.add("/"+etpCache['dbMatch']+"/"+etpConst['clientdbid']) # it's ok this way
                 skip.add("/"+etpCache['dbSearch']+"/"+etpConst['clientdbid']) # it's ok this way
             for key in etpCache:
@@ -1261,7 +1260,7 @@ class EquoInterface(TextInterface):
         return dbpkginfo
 
 
-    def repository_move_clear_cache(self, repoid = None, all = False):
+    def repository_move_clear_cache(self, repoid = None):
         self.clear_dump_cache(etpCache['world_available'])
         self.clear_dump_cache(etpCache['world_update'])
         self.clear_dump_cache(etpCache['check_package_update'])
@@ -1270,8 +1269,6 @@ class EquoInterface(TextInterface):
         self.clear_dump_cache(etpCache['dep_tree'])
         if repoid != None:
             self.clear_dump_cache(etpCache['dbMatch']+"/"+repoid+"/")
-            if all:
-                self.clear_dump_cache(etpCache['dbInfo']+"/"+repoid+"/")
             self.clear_dump_cache(etpCache['dbSearch']+"/"+repoid+"/")
 
 
@@ -1335,7 +1332,7 @@ class EquoInterface(TextInterface):
             if repoid in etpRepositoriesOrder:
                 etpRepositoriesOrder.remove(repoid)
 
-            self.repository_move_clear_cache(repoid, all = True)
+            self.repository_move_clear_cache(repoid)
             # save new etpRepositories to file
             repodata = {}
             repodata['repoid'] = repoid
@@ -1357,7 +1354,7 @@ class EquoInterface(TextInterface):
         self.validate_repositories()
 
     def enableRepository(self, repoid):
-        self.repository_move_clear_cache(repoid, all = True)
+        self.repository_move_clear_cache(repoid)
         # save new etpRepositories to file
         repodata = {}
         repodata['repoid'] = repoid
@@ -2027,8 +2024,7 @@ class EquoInterface(TextInterface):
         # client digest not needed, cache is kept updated
         c_hash = str(hash(repo_digest)) + \
                  str(hash(branch)) + \
-                 str(hash(tuple(self.validRepositories))) + \
-                 str(hash(tuple(etpRepositoriesOrder)))
+                 str(hash(tuple(self.validRepositories)))
         c_hash = str(hash(c_hash))
         return c_hash
 
@@ -2049,8 +2045,8 @@ class EquoInterface(TextInterface):
                     pass
 
         available = []
-        self.setTotalCycles(len(etpRepositoriesOrder))
-        for repo in etpRepositoriesOrder:
+        self.setTotalCycles(len(self.validRepositories))
+        for repo in self.validRepositories:
             try:
                 dbconn = self.openRepositoryDatabase(repo)
             except exceptionTools.RepositoryError:
@@ -4852,7 +4848,7 @@ class PackageInterface:
     def run(self, xterm_header = None):
         self.error_on_not_prepared()
 
-        gave_up = self.Entropy.sync_loop_check(self.Entropy._resources_run_check_lock)
+        gave_up = self.Entropy.lock_check(self.Entropy._resources_run_check_lock)
         if gave_up:
             return 20
 
@@ -5586,10 +5582,8 @@ class RepoInterface:
 
     def clear_repository_cache(self, repo):
         self.__validate_repository_id(repo)
-        # there is no need to remove dbInfo because
         # idpackages are PRIMARY KEY AUTOINCREMENT, so
         # an idpackage won't be used more than once
-        #self.Entropy.clear_dump_cache(etpCache['dbInfo']+"/"+repo+"/")
         self.Entropy.clear_dump_cache(etpCache['dbMatch']+repo+"/")
         self.Entropy.clear_dump_cache(etpCache['dbSearch']+repo+"/")
 
@@ -5948,7 +5942,7 @@ class RepoInterface:
                                         header = darkred(" @@ ")
                             )
 
-        gave_up = self.Entropy.sync_loop_check(self.Entropy._resources_run_check_lock)
+        gave_up = self.Entropy.lock_check(self.Entropy._resources_run_check_lock)
         if gave_up:
             return 3
 
@@ -8510,10 +8504,10 @@ class PackageMaskingParser:
     def __removeRepoCache(self, repoid = None):
         if os.path.isdir(etpConst['dumpstoragedir']):
             if repoid:
-                self.Entropy.repository_move_clear_cache(repoid, all = True)
+                self.Entropy.repository_move_clear_cache(repoid)
             else:
                 for repoid in etpRepositoriesOrder:
-                    self.Entropy.repository_move_clear_cache(repoid, all = True)
+                    self.Entropy.repository_move_clear_cache(repoid)
         else:
             os.makedirs(etpConst['dumpstoragedir'])
 
@@ -9193,7 +9187,7 @@ class SecurityInterface:
                                 footer = red(" ...")
                             )
 
-        gave_up = self.Entropy.sync_loop_check(self.Entropy._resources_run_check_lock)
+        gave_up = self.Entropy.lock_check(self.Entropy._resources_run_check_lock)
         if gave_up:
             return 7
 

libraries/entropyConstants.py

@@ -383,7 +383,6 @@ ETP_LOGPRI_ERROR = "[ ERROR ]"
 etpCache = {
     'configfiles': 'conf/scanfs', # used to store information about files that should be merged using "equo conf merge"
     'dbMatch': 'match/db', # db atom match cache
-    'dbInfo': 'info/db', # db data retrieval cache
     'dbSearch': 'search/db', # db search cache
     'atomMatch': 'atom_match/atom_match_', # used to store info about repository dependencies solving
     'install': 'resume/resume_install', # resume cache (install)

spritz/src/etpgui/packages.py

@@ -188,7 +188,8 @@ class EntropyPackage:
         return self.dbconn.retrieveNeeded(self.matched_atom[0])
 
     def getCompileFlags(self):
-        return self.dbconn.retrieveCompileFlags(self.matched_atom[0])
+        flags = self.dbconn.retrieveCompileFlags(self.matched_atom[0])
+        return flags
 
     def getSources(self):
         return self.dbconn.retrieveSources(self.matched_atom[0])

spritz/src/i18n.py

@@ -22,6 +22,7 @@ Author: Vladimir Bormotov <bor@vb.dn.ua>
 # This file is a copy of the yum i18n.py file, modified to use
 # yumex as translation domain.
 
+_LOCALE = None
 try:
     import gettext
     import sys, os
@@ -39,7 +40,6 @@ try:
     if _LOCALE_FULL == None:
         _LOCALE_FULL = os.getenv('LANGUANGE')
 
-    _LOCALE = None
     if _LOCALE_FULL:
         _LOCALE = _LOCALE_FULL.split('.')[0]
         _LOCALE = _LOCALE.split('_')[0]