From b5e98a0b8ebcdcfee88a0562a50caf1f0ae7de56 Mon Sep 17 00:00:00 2001 From: lxnay Date: Thu, 1 May 2008 00:01:29 +0000 Subject: [PATCH] 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 - client/text_rescue.py | 46 +++- client/text_ui.py | 121 +++++---- libraries/databaseTools.py | 497 +++++++++------------------------- libraries/entropy.py | 34 +-- libraries/entropyConstants.py | 1 - spritz/src/etpgui/packages.py | 3 +- spritz/src/i18n.py | 2 +- 8 files changed, 239 insertions(+), 466 deletions(-) diff --git a/TODO b/TODO index fcea5b076..a5fce9417 100644 --- a/TODO +++ b/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 diff --git a/client/text_rescue.py b/client/text_rescue.py index f84cca3d8..1dd73ba81 100644 --- a/client/text_rescue.py +++ b/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) diff --git a/client/text_ui.py b/client/text_ui.py index 9bdb1b310..691573355 100644 --- a/client/text_ui.py +++ b/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() diff --git a/libraries/databaseTools.py b/libraries/databaseTools.py index a1d59c361..8aeefa635 100644 --- a/libraries/databaseTools.py +++ b/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: diff --git a/libraries/entropy.py b/libraries/entropy.py index d04394936..4e65a30e2 100644 --- a/libraries/entropy.py +++ b/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 diff --git a/libraries/entropyConstants.py b/libraries/entropyConstants.py index 7d06aad21..2b0bde846 100644 --- a/libraries/entropyConstants.py +++ b/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) diff --git a/spritz/src/etpgui/packages.py b/spritz/src/etpgui/packages.py index ae5bb5ccb..429cd5703 100644 --- a/spritz/src/etpgui/packages.py +++ b/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]) diff --git a/spritz/src/i18n.py b/spritz/src/i18n.py index 262852954..8c80cdff4 100644 --- a/spritz/src/i18n.py +++ b/spritz/src/i18n.py @@ -22,6 +22,7 @@ Author: Vladimir Bormotov # 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]