From 8d43fe6dea115e19f5a0b8d33c97c871812cc2cf Mon Sep 17 00:00:00 2001 From: "(no author)" <(no author)@cd1c1023-2f26-0410-ae45-c471fc1f0318> Date: Mon, 31 Dec 2007 10:49:16 +0000 Subject: [PATCH] more work on the new EquoInterface class git-svn-id: http://svn.sabayonlinux.org/projects/entropy/trunk@971 cd1c1023-2f26-0410-ae45-c471fc1f0318 --- client/cacheTools.py | 2 +- client/confTools.py | 10 +- client/equo | 10 +- client/equoTools.py | 72 +- client/queryTools.py | 792 +++++++++---------- client/repositoriesTools.py | 27 +- client/rescueTools.py | 102 +-- client/uiTools.py | 208 +++-- libraries/clientConstants.py | 2 - libraries/databaseTools.py | 1378 +++++++++++++++++----------------- libraries/entropyTools.py | 10 +- libraries/smartTools.py | 77 +- spritz/src/entropyapi.py | 2 +- 13 files changed, 1268 insertions(+), 1424 deletions(-) diff --git a/client/cacheTools.py b/client/cacheTools.py index 97f9a0b06..cf02b7f62 100644 --- a/client/cacheTools.py +++ b/client/cacheTools.py @@ -73,7 +73,7 @@ class cacheHelper(TextInterface): import equoTools self.equoTools = equoTools # instantiate Equo handling class - self.Equo = self.equoTools.Equo() + self.Equo = self.equoTools.EquoInterface() import entropyTools self.entropyTools = entropyTools from databaseTools import openRepositoryDatabase diff --git a/client/confTools.py b/client/confTools.py index 1d04b5a1f..7370a3cd7 100644 --- a/client/confTools.py +++ b/client/confTools.py @@ -21,13 +21,12 @@ ''' from commands import getoutput +import shutil from entropyConstants import * from clientConstants import * from outputTools import * import entropyTools import dumpTools -import equoTools -import shutil import exceptionTools # test if diff is installed @@ -310,13 +309,6 @@ def scanfs(dcache = True): except: pass - # load etpConst['dbconfigprotect'] - try: - clientDbconn = equoTools.openClientDatabase() - clientDbconn.closeDB() - except exceptionTools.SystemDatabaseError: - if (not etpUi['quiet']): print_error(darkred("System database error. Does it exist?")) - return # etpConst['dbconfigprotect'] if (not etpUi['quiet']): print_info(yellow(" @@ ")+darkgreen("Scanning filesystem...")) scandata = {} diff --git a/client/equo b/client/equo index ff3c647d0..6e8bfc399 100644 --- a/client/equo +++ b/client/equo @@ -144,6 +144,7 @@ options = sys.argv[1:] import entropyTools from clientConstants import * +import exceptionTools # preliminary options parsing _options = [] @@ -304,6 +305,9 @@ try: if thread.getName() == "download": # equo current download speed thread thread.kill() sys.exit(rc) +except exceptionTools.SystemDatabaseError: + print_error(darkred(" * ")+red("Installed Packages Database not found. Please generate it (at least!)")) + sys.exit(100) except SystemExit: pass except KeyboardInterrupt: @@ -336,7 +340,6 @@ except Exception: f = open("/tmp/equoerror.txt","r") errorText = f.readlines() f.close() - errorText = ' '.join(errorText) except Exception, e: print print_error(darkred("Oh well, I cannot even write to /tmp. So, please copy the error and mail lxnay@sabayonlinux.org.")) @@ -362,8 +365,9 @@ except Exception: print_error(darkgreen("If you want to be contacted back (and actively supported), also answer the questions below:")) fullname = readtext("Your Full name: ") mail = readtext("Your E-Mail address: ") - errorText += "\n\nFull name: "+str(fullname)+"\n" - errorText += "E-mail: "+str(mail)+"\n" + errorText.insert(0,"Full name: "+str(fullname)+"\n") + errorText.insert(1,"E-mail: "+str(mail)+"\n\n") + errorText = ' '.join(errorText) # ok, come on! result = reportApplicationError(errorText) diff --git a/client/equoTools.py b/client/equoTools.py index d83fa7a2a..b2ade1100 100644 --- a/client/equoTools.py +++ b/client/equoTools.py @@ -30,7 +30,7 @@ from outputTools import * import remoteTools import exceptionTools from entropyTools import compareMd5, bytesIntoHuman, askquestion, getRandomNumber, dep_getkey, uncompressTarBz2, extractXpak, applicationLockCheck, countdown, isRoot, spliturl, remove_tag, dep_striptag, md5sum, allocateMaskedFile, istextfile, isnumber, extractEdb, unpackXpak, lifobuffer, ebeep, parallelStep -from databaseTools import openRepositoryDatabase, openClientDatabase, openGenericDatabase, listAllAvailableBranches +from databaseTools import openRepositoryDatabase, openClientDatabase, openGenericDatabase import confTools import dumpTools import gc @@ -43,7 +43,7 @@ equoLog = logTools.LogFile(level = etpConst['equologlevel'],filename = etpConst[ ''' Main Entropy (client side) package management class ''' -class Equo(TextInterface): +class EquoInterface(TextInterface): ''' @input indexing(bool): enable/disable database tables indexing @@ -61,14 +61,39 @@ class Equo(TextInterface): self.indexing = indexing self.noclientdb = noclientdb self.xcache = xcache - try: - self.clientDbconn = self.databaseTools.openClientDatabase(indexing = self.indexing, - generate = noclientdb, + self.openClientDatatabase() + self.repoDbCache = {} + + def reopenClientDbconn(self): + self.clientDbconn.closeDB() + self.openClientDatatabase() + + def closeAllRepositoryDatabases(self): + for item in self.repoDbCache: + self.repoDbCache[item].closeDB() + del self.repoDbCache[item] + self.repoDbCache.clear() + + def openClientDatatabase(self): + self.clientDbconn = self.databaseTools.openClientDatabase(indexing = self.indexing, + generate = self.noclientdb, xcache = self.xcache ) - except exceptionTools.SystemDatabaseError: - self.updateProgress(darkred("Installed Packages Database not found. Please generate it (at least!)"), importance = 2, type = "error") - raise + + def openRepositoryDatabase(self, repoid): + if not self.repoDbCache.has_key((repoid,etpConst['systemroot'])): + dbconn = self.databaseTools.openRepositoryDatabase(repoid, xcache = self.xcache, indexing = self.indexing) + self.repoDbCache[(repoid,etpConst['systemroot'])] = dbconn + return dbconn + else: + return self.repoDbCache.get((repoid,etpConst['systemroot'])) + + def listAllAvailableBranches(self): + branches = set() + for repo in etpRepositories: + dbconn = self.openRepositoryDatabase(repo) + branches.update(dbconn.listAllBranches()) + return branches def load_cache(self): @@ -528,20 +553,20 @@ class Equo(TextInterface): continue else: keyslotcache.add((matchslot,key)) - + # already analyzed by the calling function if (match in matchFilter) and (usefilter): mydep = mybuffer.pop() continue if usefilter: matchFilter.add(match) - + # result already analyzed? if match in matchcache: mydep = mybuffer.pop() continue - + treedepth = mydep[0]+1 - + # all checks passed, well done matchcache.add(match) deptree.add((mydep[0],match)) # add match @@ -556,7 +581,7 @@ class Equo(TextInterface): myundeps = mytestdeps for x in myundeps: mybuffer.push((treedepth,x)) - + # handle possible library breakage action = filterSatisfiedDependenciesCmpResults.get(mydep[1]) if action and ((action < 0) or (action > 0)): # do not use != 0 since action can be "None" @@ -773,6 +798,7 @@ class Equo(TextInterface): return newtree,0 # treeview is used to show deps while tree is used to run the dependency code. + ######################################################## #### ## Files handling @@ -786,17 +812,17 @@ class Equo(TextInterface): def checkNeededDownload(filepath,checksum = None): # is the file available if os.path.isfile(etpConst['entropyworkdir']+"/"+filepath): - if checksum is None: - return 0 - else: - # check digest - md5res = compareMd5(etpConst['entropyworkdir']+"/"+filepath,checksum) - if (md5res): - return 0 - else: - return -2 + if checksum is None: + return 0 + else: + # check digest + md5res = compareMd5(etpConst['entropyworkdir']+"/"+filepath,checksum) + if (md5res): + return 0 + else: + return -2 else: - return -1 + return -1 def addFailingMirror(mirrorname,increment = 1): diff --git a/client/queryTools.py b/client/queryTools.py index 33f8cf2c3..170286b81 100644 --- a/client/queryTools.py +++ b/client/queryTools.py @@ -24,8 +24,8 @@ import os from entropyConstants import * from clientConstants import * from outputTools import * -from databaseTools import etpDatabase, openClientDatabase, openRepositoryDatabase -from entropyTools import dep_getkey, dep_getslot, remove_slot, dep_gettag, remove_tag, convertUnixTimeToHumanTime, bytesIntoHuman +import equoTools +Equo = equoTools.EquoInterface() ######################################################## #### @@ -37,53 +37,53 @@ def query(options): rc = 0 if len(options) < 1: - return -10 + return -10 equoRequestDeep = False myopts = [] for opt in options: - if (opt == "--deep"): - equoRequestDeep = True - else: - if not opt.startswith("-"): - myopts.append(opt) + if (opt == "--deep"): + equoRequestDeep = True + else: + if not opt.startswith("-"): + myopts.append(opt) if myopts[0] == "installed": - rc = searchInstalledPackages(myopts[1:]) + rc = searchInstalledPackages(myopts[1:]) elif myopts[0] == "belongs": - rc = searchBelongs(myopts[1:]) + rc = searchBelongs(myopts[1:]) elif myopts[0] == "depends": - rc = searchDepends(myopts[1:]) + rc = searchDepends(myopts[1:]) elif myopts[0] == "files": - rc = searchFiles(myopts[1:]) + rc = searchFiles(myopts[1:]) elif myopts[0] == "needed": - rc = searchNeeded(myopts[1:]) + rc = searchNeeded(myopts[1:]) elif myopts[0] == "removal": - rc = searchRemoval(myopts[1:],deep = equoRequestDeep) + rc = searchRemoval(myopts[1:],deep = equoRequestDeep) elif myopts[0] == "tags": - if (len(myopts) > 1): - rc = searchTaggedPackages(myopts[1:]) + if (len(myopts) > 1): + rc = searchTaggedPackages(myopts[1:]) elif myopts[0] == "slot": - if (len(myopts) > 1): - rc = searchSlottedPackages(myopts[1:]) + if (len(myopts) > 1): + rc = searchSlottedPackages(myopts[1:]) elif myopts[0] == "orphans": - rc = searchOrphans() + rc = searchOrphans() elif myopts[0] == "list": - mylistopts = options[1:] - if len(mylistopts) > 0: - if mylistopts[0] == "installed": - rc = searchInstalled() + mylistopts = options[1:] + if len(mylistopts) > 0: + if mylistopts[0] == "installed": + rc = searchInstalled() elif myopts[0] == "description": - rc = searchDescription(myopts[1:]) + rc = searchDescription(myopts[1:]) else: rc = -10 @@ -92,243 +92,191 @@ def query(options): def searchInstalledPackages(packages, idreturn = False, dbconn = None): - + if (not idreturn) and (not etpUi['quiet']): print_info(brown(" @@ ")+darkgreen("Searching...")) - dbclose = True if not dbconn: - try: - clientDbconn = openClientDatabase() - except Exception: - print_info(bold("\tAttention: ")+red("client database does not exist. Run ")+bold("equo database generate")+red(" or ")+bold("equo database resurrect")) - return 128 + clientDbconn = Equo.clientDbconn else: - dbclose = False clientDbconn = dbconn - - dataInfo = set() # when idreturn is True - - for package in packages: - slot = dep_getslot(package) - tag = dep_gettag(package) - package = remove_slot(package) - package = remove_tag(package) - - result = clientDbconn.searchPackages(package, slot = slot, tag = tag) - if (result): - for pkg in result: - idpackage = pkg[1] - atom = pkg[0] - branch = clientDbconn.retrieveBranch(idpackage) - if (idreturn): - dataInfo.add(idpackage) - else: - printPackageInfo(idpackage, clientDbconn, clientSearch = True) - # print info - if (not idreturn) and (not etpUi['quiet']): - print_info(blue(" Keyword: ")+bold("\t"+package)) - print_info(blue(" Found: ")+bold("\t"+str(len(result)))+red(" entries")) - if dbclose: - clientDbconn.closeDB() - del clientDbconn + dataInfo = set() # when idreturn is True + for package in packages: + slot = Equo.entropyTools.dep_getslot(package) + tag = Equo.entropyTools.dep_gettag(package) + package = Equo.entropyTools.remove_slot(package) + package = Equo.entropyTools.remove_tag(package) + + result = clientDbconn.searchPackages(package, slot = slot, tag = tag) + if (result): + for pkg in result: + idpackage = pkg[1] + atom = pkg[0] + branch = clientDbconn.retrieveBranch(idpackage) + if (idreturn): + dataInfo.add(idpackage) + else: + printPackageInfo(idpackage, clientDbconn, clientSearch = True) + # print info + if (not idreturn) and (not etpUi['quiet']): + print_info(blue(" Keyword: ")+bold("\t"+package)) + print_info(blue(" Found: ")+bold("\t"+str(len(result)))+red(" entries")) if (idreturn): - return dataInfo - + return dataInfo return 0 def searchBelongs(files, idreturn = False, dbconn = None): - + if (not idreturn) and (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Belong Search...")) - dbclose = True if not dbconn: - try: - clientDbconn = openClientDatabase() - except Exception: - print_info(bold("\tAttention: ")+red("client database does not exist. Run ")+bold("equo database generate")+red(" or ")+bold("equo database resurrect")) - return 128 + clientDbconn = Equo.clientDbconn else: - dbclose = False clientDbconn = dbconn - + dataInfo = set() # when idreturn is True results = {} flatresults = {} for file in files: - like = False - if file.find("*") != -1: - import re - out = re.subn("\*","%",file) - file = out[0] - like = True - results[file] = set() - idpackages = clientDbconn.searchBelongs(file, like) - for idpackage in idpackages: - if not flatresults.get(idpackage): - results[file].add(idpackage) - flatresults[idpackage] = True - - if (results): - for result in results: - # print info - file = result - result = results[result] - for idpackage in result: - if (idreturn): - dataInfo.add(idpackage) - elif (etpUi['quiet']): - print clientDbconn.retrieveAtom(idpackage) - else: - printPackageInfo(idpackage, clientDbconn, clientSearch = True) - if (not idreturn) and (not etpUi['quiet']): - print_info(blue(" Keyword: ")+bold("\t"+file)) - print_info(blue(" Found: ")+bold("\t"+str(len(result)))+red(" entries")) + like = False + if file.find("*") != -1: + import re + out = re.subn("\*","%",file) + file = out[0] + like = True + results[file] = set() + idpackages = clientDbconn.searchBelongs(file, like) + for idpackage in idpackages: + if not flatresults.get(idpackage): + results[file].add(idpackage) + flatresults[idpackage] = True - if dbclose: - clientDbconn.closeDB() - del clientDbconn + if (results): + for result in results: + # print info + file = result + result = results[result] + for idpackage in result: + if (idreturn): + dataInfo.add(idpackage) + elif (etpUi['quiet']): + print clientDbconn.retrieveAtom(idpackage) + else: + printPackageInfo(idpackage, clientDbconn, clientSearch = True) + if (not idreturn) and (not etpUi['quiet']): + print_info(blue(" Keyword: ")+bold("\t"+file)) + print_info(blue(" Found: ")+bold("\t"+str(len(result)))+red(" entries")) if (idreturn): - return dataInfo - + return dataInfo return 0 def searchDepends(atoms, idreturn = False, dbconn = None): - + if (not idreturn) and (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Depends Search...")) - dbclose = True if not dbconn: - from equoTools import atomMatch - try: - clientDbconn = openClientDatabase() - except Exception: - print_info(bold("\tAttention: ")+red("client database does not exist. Run ")+bold("equo database generate")+red(" or ")+bold("equo database resurrect")) - return 128 + clientDbconn = Equo.clientDbconn else: - dbclose = False clientDbconn = dbconn dataInfo = set() # when idreturn is True for atom in atoms: - result = clientDbconn.atomMatch(atom) - matchInRepo = False - if (result[0] == -1) and dbclose: - matchInRepo = True - result = atomMatch(atom) - if (result[0] != -1): - if (matchInRepo): - dbconn = openRepositoryDatabase(result[1]) - else: - dbconn = clientDbconn - searchResults = dbconn.retrieveDepends(result[0]) - for idpackage in searchResults: - if (idreturn): - dataInfo.add(idpackage) - else: - if (etpUi['verbose']): - printPackageInfo(idpackage, dbconn, clientSearch = True) - else: - printPackageInfo(idpackage, dbconn, clientSearch = True, strictOutput = True) - # print info - if (not idreturn) and (not etpUi['quiet']): - print_info(blue(" Keyword: ")+bold("\t"+atom)) - if (matchInRepo): - where = " from repository "+str(result[1]) - else: - where = " from installed packages database" - print_info(blue(" Found: ")+bold("\t"+str(len(searchResults)))+red(" entries")+where) - else: - continue - if (matchInRepo): - dbconn.closeDB() + result = clientDbconn.atomMatch(atom) + matchInRepo = False + if (result[0] == -1) and dbclose: + matchInRepo = True + result = atomMatch(atom) + if (result[0] != -1): + if (matchInRepo): + dbconn = Equo.openRepositoryDatabase(result[1]) + else: + dbconn = clientDbconn + searchResults = dbconn.retrieveDepends(result[0]) + for idpackage in searchResults: + if (idreturn): + dataInfo.add(idpackage) + else: + if (etpUi['verbose']): + printPackageInfo(idpackage, dbconn, clientSearch = True) + else: + printPackageInfo(idpackage, dbconn, clientSearch = True, strictOutput = True) + # print info + if (not idreturn) and (not etpUi['quiet']): + print_info(blue(" Keyword: ")+bold("\t"+atom)) + if (matchInRepo): + where = " from repository "+str(result[1]) + else: + where = " from installed packages database" + print_info(blue(" Found: ")+bold("\t"+str(len(searchResults)))+red(" entries")+where) + else: + continue + if (matchInRepo): + dbconn.closeDB() del dbconn - if dbclose: - clientDbconn.closeDB() - del clientDbconn - if (idreturn): - return dataInfo - + return dataInfo return 0 def searchNeeded(atoms, idreturn = False, dbconn = None): - + if (not idreturn) and (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Needed Search...")) - dbclose = True + dataInfo = set() if not dbconn: - try: - clientDbconn = openClientDatabase() - except Exception: - print_info(bold("\tAttention: ")+red("client database does not exist. Run ")+bold("equo database generate")+red(" or ")+bold("equo database resurrect")) - return 128 - dataInfo = set() # when idreturn is True + clientDbconn = Equo.clientDbconn else: - dbclose = False clientDbconn = dbconn - - for atom in atoms: - match = clientDbconn.atomMatch(atom) - if (match[0] != -1): - # print info - myatom = clientDbconn.retrieveAtom(match[0]) - myneeded = clientDbconn.retrieveNeeded(match[0]) - for needed in myneeded: - if (idreturn): - dataInfo.add(needed) - elif (etpUi['quiet']): - print needed - else: - print_info(blue(" # ")+red(str(needed))) - if (not idreturn) and (not etpUi['quiet']): - print_info(blue(" Atom: ")+bold("\t"+myatom)) - print_info(blue(" Found: ")+bold("\t"+str(len(myneeded)))+red(" libraries")) - if dbclose: - clientDbconn.closeDB() - del clientDbconn + for atom in atoms: + match = clientDbconn.atomMatch(atom) + if (match[0] != -1): + # print info + myatom = clientDbconn.retrieveAtom(match[0]) + myneeded = clientDbconn.retrieveNeeded(match[0]) + for needed in myneeded: + if (idreturn): + dataInfo.add(needed) + elif (etpUi['quiet']): + print needed + else: + print_info(blue(" # ")+red(str(needed))) + if (not idreturn) and (not etpUi['quiet']): + print_info(blue(" Atom: ")+bold("\t"+myatom)) + print_info(blue(" Found: ")+bold("\t"+str(len(myneeded)))+red(" libraries")) if (idreturn): - return dataInfo - + return dataInfo return 0 def searchEclass(eclasses, idreturn = False, dbconn = None): - + if (not idreturn) and (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Eclass Search...")) - dbclose = True - dataInfo = set() # when idreturn is True if not dbconn: - try: - clientDbconn = openClientDatabase() - except Exception: - print_info(bold("\tAttention: ")+red("client database does not exist. Run ")+bold("equo database generate")+red(" or ")+bold("equo database resurrect")) - return 128 + clientDbconn = Equo.clientDbconn else: - dbclose = False clientDbconn = dbconn - + + dataInfo = set() for eclass in eclasses: - matches = clientDbconn.searchEclassedPackages(eclass, atoms = True) + matches = clientDbconn.searchEclassedPackages(eclass, atoms = True) for match in matches: if (idreturn): dataInfo.add(match) continue - # print info - myatom = match[0] + # print info + myatom = match[0] idpackage = match[1] if (etpUi['quiet']): print myatom @@ -340,61 +288,45 @@ def searchEclass(eclasses, idreturn = False, dbconn = None): if (not etpUi['quiet']): print_info(blue(" Found: ")+bold("\t"+str(len(matches)))+red(" packages")) - if dbclose: - clientDbconn.closeDB() - del clientDbconn - if (idreturn): - return dataInfo - + return dataInfo return 0 def searchFiles(atoms, idreturn = False, dbconn = None): - + if (not idreturn) and (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Files Search...")) - dbclose = True if not dbconn: results = searchInstalledPackages(atoms, idreturn = True) - try: - clientDbconn = openClientDatabase() - except Exception: - print_info(bold("\tAttention: ")+red("client database does not exist. Run ")+bold("equo database generate")+red(" or ")+bold("equo database resurrect")) - return 128 + clientDbconn = Equo.clientDbconn else: - dbclose = False results = searchInstalledPackages(atoms, idreturn = True, dbconn = dbconn) clientDbconn = dbconn - + dataInfo = set() # when idreturn is True for result in results: - if (result != -1): - files = clientDbconn.retrieveContent(result) - atom = clientDbconn.retrieveAtom(result) + if (result != -1): + files = clientDbconn.retrieveContent(result) + atom = clientDbconn.retrieveAtom(result) files = list(files) files.sort() - # print info - if (idreturn): - dataInfo.add((result,files)) - else: - if etpUi['quiet']: - for file in files: - print file - else: - for file in files: - print_info(blue(" ### ")+red(file)) - if (not idreturn) and (not etpUi['quiet']): - print_info(blue(" Package: ")+bold("\t"+atom)) - print_info(blue(" Found: ")+bold("\t"+str(len(files)))+red(" files")) - - if dbclose: - clientDbconn.closeDB() - del clientDbconn + # print info + if (idreturn): + dataInfo.add((result,files)) + else: + if etpUi['quiet']: + for file in files: + print file + else: + for file in files: + print_info(blue(" ### ")+red(file)) + if (not idreturn) and (not etpUi['quiet']): + print_info(blue(" Package: ")+bold("\t"+atom)) + print_info(blue(" Found: ")+bold("\t"+str(len(files)))+red(" files")) if (idreturn): - return dataInfo - + return dataInfo return 0 @@ -404,31 +336,27 @@ def searchOrphans(): if (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Orphans Search...")) - try: - clientDbconn = openClientDatabase() - except Exception: - print_info(bold("\tAttention: ")+red("client database does not exist. Run ")+bold("equo database generate")+red(" or ")+bold("equo database resurrect")) - return 128 + clientDbconn = Equo.clientDbconn # start to list all files on the system: dirs = etpConst['filesystemdirs'] foundFiles = set() for dir in dirs: - for currentdir,subdirs,files in os.walk(dir): - for filename in files: - file = currentdir+"/"+filename - # filter python compiled objects? - if filename.endswith(".pyo") or filename.startswith(".pyc") or filename == '.keep': - continue - mask = [x for x in etpConst['filesystemdirsmask'] if file.startswith(x)] - if (not mask): - if (not etpUi['quiet']): - print_info(red(" @@ ")+blue("Looking: ")+bold(file[:50]+"..."), back = True) - foundFiles.add(file) + for currentdir,subdirs,files in os.walk(dir): + for filename in files: + file = currentdir+"/"+filename + # filter python compiled objects? + if filename.endswith(".pyo") or filename.startswith(".pyc") or filename == '.keep': + continue + mask = [x for x in etpConst['filesystemdirsmask'] if file.startswith(x)] + if (not mask): + if (not etpUi['quiet']): + print_info(red(" @@ ")+blue("Looking: ")+bold(file[:50]+"..."), back = True) + foundFiles.add(file) totalfiles = len(foundFiles) if (not etpUi['quiet']): - print_info(red(" @@ ")+blue("Analyzed directories: ")+' '.join(etpConst['filesystemdirs'])) - print_info(red(" @@ ")+blue("Masked directories: ")+' '.join(etpConst['filesystemdirsmask'])) + print_info(red(" @@ ")+blue("Analyzed directories: ")+' '.join(etpConst['filesystemdirs'])) + print_info(red(" @@ ")+blue("Masked directories: ")+' '.join(etpConst['filesystemdirsmask'])) print_info(red(" @@ ")+blue("Number of files collected on the filesystem: ")+bold(str(totalfiles))) print_info(red(" @@ ")+blue("Now looking into Installed Packages database...")) @@ -438,54 +366,53 @@ def searchOrphans(): length = str(len(idpackages)) count = 0 for idpackage in idpackages: - if (not etpUi['quiet']): - count += 1 - atom = clientDbconn.retrieveAtom(idpackage) - txt = "["+str(count)+"/"+length+"] " - print_info(red(" @@ ")+blue("Intersecting content of package: ")+txt+bold(atom), back = True) - content = clientDbconn.retrieveContent(idpackage) - _content = set() - for x in content: - if x.startswith("/usr/lib64"): - x = "/usr/lib"+x[len("/usr/lib64"):] - _content.add(x) - # remove from foundFiles - del content - foundFiles.difference_update(_content) + if (not etpUi['quiet']): + count += 1 + atom = clientDbconn.retrieveAtom(idpackage) + txt = "["+str(count)+"/"+length+"] " + print_info(red(" @@ ")+blue("Intersecting content of package: ")+txt+bold(atom), back = True) + content = clientDbconn.retrieveContent(idpackage) + _content = set() + for x in content: + if x.startswith("/usr/lib64"): + x = "/usr/lib"+x[len("/usr/lib64"):] + _content.add(x) + # remove from foundFiles + del content + foundFiles.difference_update(_content) if (not etpUi['quiet']): print_info(red(" @@ ")+blue("Intersection completed. Showing statistics: ")) - print_info(red(" @@ ")+blue("Number of total files: ")+bold(str(totalfiles))) - print_info(red(" @@ ")+blue("Number of matching files: ")+bold(str(totalfiles - len(foundFiles)))) - print_info(red(" @@ ")+blue("Number of orphaned files: ")+bold(str(len(foundFiles)))) + print_info(red(" @@ ")+blue("Number of total files: ")+bold(str(totalfiles))) + print_info(red(" @@ ")+blue("Number of matching files: ")+bold(str(totalfiles - len(foundFiles)))) + print_info(red(" @@ ")+blue("Number of orphaned files: ")+bold(str(len(foundFiles)))) # order foundFiles = list(foundFiles) foundFiles.sort() if (not etpUi['quiet']): - print_info(red(" @@ ")+blue("Writing file to disk: ")+bold("/tmp/equo-orphans.txt")) + print_info(red(" @@ ")+blue("Writing file to disk: ")+bold("/tmp/equo-orphans.txt")) f = open("/tmp/equo-orphans.txt","w") for x in foundFiles: - f.write(x+"\n") + f.write(x+"\n") f.flush() f.close() - return 0 + return 0 else: - for x in foundFiles: - print x - + for x in foundFiles: + print x return 0 def searchRemoval(atoms, idreturn = False, deep = False): - - import equoTools - Equo = equoTools.Equo() + + clientDbconn = Equo.clientDbconn + if (not idreturn) and (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Removal Search...")) foundAtoms = [] for atom in atoms: - match = Equo.clientDbconn.atomMatch(atom) + match = clientDbconn.atomMatch(atom) if match[1] == 0: foundAtoms.append(match[0]) @@ -513,9 +440,9 @@ def searchRemoval(atoms, idreturn = False, deep = False): for idpackage in choosenRemovalQueue: atomscounter += 1 - rematom = Equo.clientDbconn.retrieveAtom(idpackage) + rematom = clientDbconn.retrieveAtom(idpackage) if (not etpUi['quiet']): - installedfrom = Equo.clientDbconn.retrievePackageFromInstalledTable(idpackage) + installedfrom = clientDbconn.retrievePackageFromInstalledTable(idpackage) repositoryInfo = bold("[")+red("from: ")+brown(installedfrom)+bold("]") stratomscounter = str(atomscounter) while len(stratomscounter) < len(totalatoms): @@ -526,206 +453,181 @@ def searchRemoval(atoms, idreturn = False, deep = False): if (idreturn): return treeview - return 0 def searchInstalled(idreturn = False): - + if (not idreturn) and (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Installed Search...")) - try: - clientDbconn = openClientDatabase() - except Exception: - print_info(bold("\tAttention: ")+red("client database does not exist. Run ")+bold("equo database generate")+red(" or ")+bold("equo database resurrect")) - return 128 + clientDbconn = Equo.clientDbconn + installedPackages = clientDbconn.listAllPackages() installedPackages.sort() if (not idreturn): if (not etpUi['quiet']): - print_info(red(" @@ ")+blue("These are the installed packages:")) + print_info(red(" @@ ")+blue("These are the installed packages:")) for package in installedPackages: - if (not etpUi['verbose']): - atom = dep_getkey(package[0]) - else: - atom = package[0] - branchinfo = "" - if (etpUi['verbose']): - branchinfo = darkgreen(" [")+red(package[2])+darkgreen("]") - if (not etpUi['quiet']): - print_info(red(" #")+blue(str(package[1]))+branchinfo+" "+atom) - else: - print atom - clientDbconn.closeDB() - del clientDbconn - return 0 + if (not etpUi['verbose']): + atom = Equo.entropyTools.dep_getkey(package[0]) + else: + atom = package[0] + branchinfo = "" + if (etpUi['verbose']): + branchinfo = darkgreen(" [")+red(package[2])+darkgreen("]") + if (not etpUi['quiet']): + print_info(red(" #")+blue(str(package[1]))+branchinfo+" "+atom) + else: + print atom + return 0 else: - idpackages = set() - for x in installedPackages: - idpackages.add(package[1]) - clientDbconn.closeDB() - del clientDbconn + idpackages = set() + for x in installedPackages: + idpackages.add(package[1]) return list(idpackages) def searchPackage(packages, idreturn = False): - + foundPackages = {} dataInfo = set() # when idreturn is True - + if (not idreturn) or (etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Searching...")) # search inside each available database repoNumber = 0 searchError = False for repo in etpRepositories: - foundPackages[repo] = {} - repoNumber += 1 - - if (not idreturn) and (not etpUi['quiet']): - print_info(blue(" #"+str(repoNumber))+bold(" "+etpRepositories[repo]['description'])) - - dbconn = openRepositoryDatabase(repo) - for package in packages: - slot = dep_getslot(package) - tag = dep_gettag(package) - package = remove_slot(package) - package = remove_tag(package) - result = dbconn.searchPackages(package, slot = slot, tag = tag) - - if (not result): # look for provide - result = dbconn.searchProvide(package, slot = slot, tag = tag) - - if (result): - foundPackages[repo][package] = result - # print info - for pkg in foundPackages[repo][package]: - idpackage = pkg[1] - atom = pkg[0] - branch = dbconn.retrieveBranch(idpackage) - if (idreturn): - dataInfo.add((idpackage,repo)) - else: - printPackageInfo(idpackage,dbconn) - if (not idreturn) and (not etpUi['quiet']): - print_info(blue(" Keyword: ")+bold("\t"+package)) - print_info(blue(" Found: ")+bold("\t"+str(len(foundPackages[repo][package])))+red(" entries")) - - dbconn.closeDB() - del dbconn + foundPackages[repo] = {} + repoNumber += 1 + + if (not idreturn) and (not etpUi['quiet']): + print_info(blue(" #"+str(repoNumber))+bold(" "+etpRepositories[repo]['description'])) + + dbconn = Equo.openRepositoryDatabase(repo) + for package in packages: + slot = Equo.entropyTools.dep_getslot(package) + tag = Equo.entropyTools.dep_gettag(package) + package = Equo.entropyTools.remove_slot(package) + package = Equo.entropyTools.remove_tag(package) + result = dbconn.searchPackages(package, slot = slot, tag = tag) + + if (not result): # look for provide + result = dbconn.searchProvide(package, slot = slot, tag = tag) + + if (result): + foundPackages[repo][package] = result + # print info + for pkg in foundPackages[repo][package]: + idpackage = pkg[1] + atom = pkg[0] + branch = dbconn.retrieveBranch(idpackage) + if (idreturn): + dataInfo.add((idpackage,repo)) + else: + printPackageInfo(idpackage,dbconn) + if (not idreturn) and (not etpUi['quiet']): + print_info(blue(" Keyword: ")+bold("\t"+package)) + print_info(blue(" Found: ")+bold("\t"+str(len(foundPackages[repo][package])))+red(" entries")) + if (idreturn): - return dataInfo - + return dataInfo return 0 def searchSlottedPackages(slots, datareturn = False, dbconn = None): - + foundPackages = {} dbclose = True if dbconn: dbclose = False - + if (not datareturn) and (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Slot Search...")) # search inside each available database repoNumber = 0 for repo in etpRepositories: - foundPackages[repo] = {} - repoNumber += 1 - - if (not datareturn) and (not etpUi['quiet']): - print_info(blue(" #"+str(repoNumber))+bold(" "+etpRepositories[repo]['description'])) - - if dbclose: - dbconn = openRepositoryDatabase(repo) - for slot in slots: - results = dbconn.searchSlottedPackages(slot, atoms = True) - for result in results: - foundPackages[repo][result[1]] = result[0] - # print info - if (not datareturn): - printPackageInfo(result[1],dbconn) - if (not datareturn) and (not etpUi['quiet']): - print_info(blue(" Keyword: ")+bold("\t"+slot)) - print_info(blue(" Found: ")+bold("\t"+str(len(results)))+red(" entries")) + foundPackages[repo] = {} + repoNumber += 1 + + if (not datareturn) and (not etpUi['quiet']): + print_info(blue(" #"+str(repoNumber))+bold(" "+etpRepositories[repo]['description'])) if dbclose: - dbconn.closeDB() - del dbconn + dbconn = Equo.openRepositoryDatabase(repo) + for slot in slots: + results = dbconn.searchSlottedPackages(slot, atoms = True) + for result in results: + foundPackages[repo][result[1]] = result[0] + # print info + if (not datareturn): + printPackageInfo(result[1],dbconn) + if (not datareturn) and (not etpUi['quiet']): + print_info(blue(" Keyword: ")+bold("\t"+slot)) + print_info(blue(" Found: ")+bold("\t"+str(len(results)))+red(" entries")) if (datareturn): - return foundPackages - + return foundPackages return 0 def searchTaggedPackages(tags, datareturn = False, dbconn = None): - + foundPackages = {} dbclose = True if dbconn: dbclose = False - + if (not datareturn) and (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Tag Search...")) # search inside each available database repoNumber = 0 for repo in etpRepositories: - foundPackages[repo] = {} - repoNumber += 1 - - if (not datareturn) and (not etpUi['quiet']): - print_info(blue(" #"+str(repoNumber))+bold(" "+etpRepositories[repo]['description'])) - - if dbclose: - dbconn = openRepositoryDatabase(repo) - for tag in tags: - results = dbconn.searchTaggedPackages(tag, atoms = True) - for result in results: - foundPackages[repo][result[1]] = result[0] - # print info - if (not datareturn): - printPackageInfo(result[1],dbconn) - if (not datareturn) and (not etpUi['quiet']): - print_info(blue(" Keyword: ")+bold("\t"+tag)) - print_info(blue(" Found: ")+bold("\t"+str(len(results)))+red(" entries")) + foundPackages[repo] = {} + repoNumber += 1 + + if (not datareturn) and (not etpUi['quiet']): + print_info(blue(" #"+str(repoNumber))+bold(" "+etpRepositories[repo]['description'])) if dbclose: - dbconn.closeDB() - del dbconn + dbconn = Equo.openRepositoryDatabase(repo) + for tag in tags: + results = dbconn.searchTaggedPackages(tag, atoms = True) + for result in results: + foundPackages[repo][result[1]] = result[0] + # print info + if (not datareturn): + printPackageInfo(result[1],dbconn) + if (not datareturn) and (not etpUi['quiet']): + print_info(blue(" Keyword: ")+bold("\t"+tag)) + print_info(blue(" Found: ")+bold("\t"+str(len(results)))+red(" entries")) if (datareturn): - return foundPackages - + return foundPackages return 0 def searchDescription(descriptions, idreturn = False): - + foundPackages = {} - + if (not idreturn) and (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Description Search...")) # search inside each available database repoNumber = 0 for repo in etpRepositories: - foundPackages[repo] = {} - repoNumber += 1 - - if (not idreturn) and (not etpUi['quiet']): - print_info(blue(" #"+str(repoNumber))+bold(" "+etpRepositories[repo]['description'])) - - dbconn = openRepositoryDatabase(repo) + foundPackages[repo] = {} + repoNumber += 1 + + if (not idreturn) and (not etpUi['quiet']): + print_info(blue(" #"+str(repoNumber))+bold(" "+etpRepositories[repo]['description'])) + + dbconn = Equo.openRepositoryDatabase(repo) dataInfo, descdata = __searchDescriptions(descriptions, dbconn, idreturn) foundPackages[repo].update(descdata) - - dbconn.closeDB() - del dbconn if (idreturn): - return dataInfo - + return dataInfo return 0 ''' @@ -734,7 +636,7 @@ def searchDescription(descriptions, idreturn = False): def __searchDescriptions(descriptions, dbconn, idreturn = False): dataInfo = [] # when idreturn is True mydescdata = {} - + for desc in descriptions: result = dbconn.searchPackagesByDescription(desc) if (result): @@ -758,9 +660,9 @@ def printPackageInfo(idpackage, dbconn, clientSearch = False, strictOutput = Fal # now fetch essential info pkgatom = dbconn.retrieveAtom(idpackage) if (etpUi['quiet']): - print pkgatom - return - + print pkgatom + return + if (not strictOutput): pkgname = dbconn.retrieveName(idpackage) pkgcat = dbconn.retrieveCategory(idpackage) @@ -770,10 +672,10 @@ def printPackageInfo(idpackage, dbconn, clientSearch = False, strictOutput = Fal pkgflags = dbconn.retrieveCompileFlags(idpackage) pkgkeywords = dbconn.retrieveKeywords(idpackage) pkgdigest = dbconn.retrieveDigest(idpackage) - pkgcreatedate = convertUnixTimeToHumanTime(float(dbconn.retrieveDateCreation(idpackage))) - pkgsize = bytesIntoHuman(pkgsize) - pkgdeps = dbconn.retrieveDependencies(idpackage) - pkgconflicts = dbconn.retrieveConflicts(idpackage) + pkgcreatedate = Equo.entropyTools.convertUnixTimeToHumanTime(float(dbconn.retrieveDateCreation(idpackage))) + pkgsize = Equo.entropyTools.bytesIntoHuman(pkgsize) + pkgdeps = dbconn.retrieveDependencies(idpackage) + pkgconflicts = dbconn.retrieveConflicts(idpackage) pkghome = dbconn.retrieveHomepage(idpackage) pkgslot = dbconn.retrieveSlot(idpackage) @@ -790,23 +692,15 @@ def printPackageInfo(idpackage, dbconn, clientSearch = False, strictOutput = Fal installedVer = "Not installed" installedTag = "N/A" installedRev = "N/A" - try: - clientDbconn = openClientDatabase() - except Exception: - clientDbconn = -1 - if (clientDbconn != -1): - pkginstalled = clientDbconn.atomMatch(dep_getkey(pkgatom), matchSlot = pkgslot) - if (pkginstalled[1] == 0): - idx = pkginstalled[0] - # found - installedVer = clientDbconn.retrieveVersion(idx) - installedTag = clientDbconn.retrieveVersionTag(idx) - if not installedTag: - installedTag = "NoTag" - installedRev = clientDbconn.retrieveRevision(idx) - clientDbconn.closeDB() - del clientDbconn - + pkginstalled = Equo.clientDbconn.atomMatch(Equo.entropyTools.dep_getkey(pkgatom), matchSlot = pkgslot) + if (pkginstalled[1] == 0): + idx = pkginstalled[0] + # found + installedVer = Equo.clientDbconn.retrieveVersion(idx) + installedTag = Equo.clientDbconn.retrieveVersionTag(idx) + if not installedTag: + installedTag = "NoTag" + installedRev = Equo.clientDbconn.retrieveRevision(idx) print_info(red(" @@ Package: ")+bold(pkgatom)+"\t\t"+blue("branch: ")+bold(pkgbranch)) if (not strictOutput): @@ -820,32 +714,32 @@ def printPackageInfo(idpackage, dbconn, clientSearch = False, strictOutput = Fal print_info(darkgreen(" Size:\t\t\t")+blue(str(pkgsize))) print_info(darkgreen(" Download:\t\t")+brown(str(pkgbin))) print_info(darkgreen(" Checksum:\t\t")+brown(str(pkgdigest))) - if (pkgdeps): - print_info(darkred(" ##")+darkgreen(" Dependencies:")) - for pdep in pkgdeps: - print_info(darkred(" ## \t\t\t")+brown(pdep)) - if (pkgconflicts): - print_info(darkred(" ##")+darkgreen(" Conflicts:")) - for conflict in pkgconflicts: - print_info(darkred(" ## \t\t\t")+brown(conflict)) + if (pkgdeps): + print_info(darkred(" ##")+darkgreen(" Dependencies:")) + for pdep in pkgdeps: + print_info(darkred(" ## \t\t\t")+brown(pdep)) + if (pkgconflicts): + print_info(darkred(" ##")+darkgreen(" Conflicts:")) + for conflict in pkgconflicts: + print_info(darkred(" ## \t\t\t")+brown(conflict)) print_info(darkgreen(" Homepage:\t\t")+red(pkghome)) print_info(darkgreen(" Description:\t\t")+pkgdesc) if (not strictOutput): - if (extended): - print_info(darkgreen(" CHOST:\t\t")+blue(pkgflags[0])) - print_info(darkgreen(" CFLAGS:\t\t")+red(pkgflags[1])) - print_info(darkgreen(" CXXFLAGS:\t\t")+blue(pkgflags[2])) - sources = dbconn.retrieveSources(idpackage) + if (extended): + print_info(darkgreen(" CHOST:\t\t")+blue(pkgflags[0])) + print_info(darkgreen(" CFLAGS:\t\t")+red(pkgflags[1])) + print_info(darkgreen(" CXXFLAGS:\t\t")+blue(pkgflags[2])) + sources = dbconn.retrieveSources(idpackage) eclasses = dbconn.retrieveEclasses(idpackage) - etpapi = dbconn.retrieveApi(idpackage) + etpapi = dbconn.retrieveApi(idpackage) print_info(darkgreen(" Gentoo eclasses:\t")+red(' '.join(eclasses))) - if (sources): - print_info(darkgreen(" Sources:")) - for source in sources: - print_info(darkred(" # Source: ")+blue(source)) - print_info(darkgreen(" Entry API:\t\t")+red(str(etpapi))) - else: - print_info(darkgreen(" Compiled with:\t")+blue(pkgflags[1])) + if (sources): + print_info(darkgreen(" Sources:")) + for source in sources: + print_info(darkred(" # Source: ")+blue(source)) + print_info(darkgreen(" Entry API:\t\t")+red(str(etpapi))) + else: + print_info(darkgreen(" Compiled with:\t")+blue(pkgflags[1])) print_info(darkgreen(" Keywords:\t\t")+red(' '.join(pkgkeywords))) print_info(darkgreen(" Created:\t\t")+pkgcreatedate) print_info(darkgreen(" License:\t\t")+red(pkglic)) diff --git a/client/repositoriesTools.py b/client/repositoriesTools.py index 40a0de272..3a1c9ed8e 100644 --- a/client/repositoriesTools.py +++ b/client/repositoriesTools.py @@ -234,7 +234,7 @@ def syncRepositories(reponames = [], forceUpdate = False): rc = False try: import equoTools - Equo = equoTools.Equo() + Equo = equoTools.EquoInterface() rc = Equo.check_equo_updates() del Equo except: @@ -245,31 +245,6 @@ def syncRepositories(reponames = [], forceUpdate = False): return 0 -def checkEquoUpdates(): - # tell if a new equo release is available - import equoTools - from databaseTools import openClientDatabase - try: - clientDbconn = openClientDatabase(xcache = False) - except exceptionTools.SystemDatabaseError: - del repoConn - return False - - found = False - matches = clientDbconn.searchPackages("app-admin/equo") - if matches: - equo_match = "<="+matches[0][0] - equo_unsatisfied,x = equoTools.filterSatisfiedDependencies([equo_match]) - del x - if equo_unsatisfied: - found = True - del matches - del equo_unsatisfied - - clientDbconn.closeDB() - del clientDbconn - return found - # # repository control class, that's it # diff --git a/client/rescueTools.py b/client/rescueTools.py index 3b24b2dd5..e9202a845 100644 --- a/client/rescueTools.py +++ b/client/rescueTools.py @@ -28,7 +28,7 @@ from entropyConstants import * from clientConstants import * from outputTools import * -from databaseTools import etpDatabase, openRepositoryDatabase, openClientDatabase, backupClientDatabase +from databaseTools import backupClientDatabase import entropyTools import equoTools import exceptionTools @@ -43,6 +43,8 @@ def database(options): print_error(red("You are not ")+bold("root")+red(".")) return 1 + Equo = equoTools.EquoInterface(noclientdb = True) + if (options[0] == "generate"): # test if portage is available @@ -74,14 +76,11 @@ def database(options): # try to collect current installed revisions if possible revisionsMatch = {} try: - clientDbconn = openClientDatabase() - myids = clientDbconn.listAllIdpackages() + myids = Equo.clientDbconn.listAllIdpackages() for myid in myids: - myatom = clientDbconn.retrieveAtom(myid) - myrevision = clientDbconn.retrieveRevision(myid) + myatom = Equo.clientDbconn.retrieveAtom(myid) + myrevision = Equo.clientDbconn.retrieveRevision(myid) revisionsMatch[myatom] = myrevision - clientDbconn.closeDB() - del clientDbconn except: pass @@ -94,8 +93,8 @@ def database(options): # Now reinitialize it print_info(darkred(" Initializing the new database at "+bold(etpConst['etpdatabaseclientfilepath'])), back = True) - clientDbconn = openClientDatabase(generate = True) - clientDbconn.initializeDatabase() + Equo.reopenClientDbconn() + Equo.clientDbconn.initializeDatabase() print_info(darkgreen(" Database reinitialized correctly at "+bold(etpConst['etpdatabaseclientfilepath']))) # now collect packages in the system @@ -144,17 +143,15 @@ def database(options): except: pass - idpk, rev, xx, status = clientDbconn.addPackage(etpData = mydata, revision = mydata['revision']) - clientDbconn.addPackageToInstalledTable(idpk,"gentoo-db") + idpk, rev, xx, status = Equo.clientDbconn.addPackage(etpData = mydata, revision = mydata['revision']) + Equo.clientDbconn.addPackageToInstalledTable(idpk,"gentoo-db") os.remove(temptbz2) print_info(red(" All the Gentoo packages have been injected into Entropy database.")) print_info(red(" Now generating depends caching table...")) - clientDbconn.regenerateDependsTable() + Equo.clientDbconn.regenerateDependsTable() print_info(red(" Database reinitialized successfully.")) - clientDbconn.closeDB() - del clientDbconn return 0 elif (options[0] == "resurrect"): @@ -185,8 +182,7 @@ def database(options): # Now reinitialize it print_info(darkred(" Initializing the new database at "+bold(etpConst['etpdatabaseclientfilepath'])), back = True) - clientDbconn = openClientDatabase() - clientDbconn.initializeDatabase() + Equo.clientDbconn.initializeDatabase() print_info(darkgreen(" Database reinitialized correctly at "+bold(etpConst['etpdatabaseclientfilepath']))) print_info(red(" Collecting installed files. Writing: "+etpConst['packagestmpfile']+" Please wait..."), back = True) @@ -221,7 +217,7 @@ def database(options): for repo in etpRepositories: print_info(red(" Matching in repository: ")+etpRepositories[repo]['description']) # get all idpackages - dbconn = openRepositoryDatabase(repo) + dbconn = Equo.openRepositoryDatabase(repo) idpackages = dbconn.listAllIdpackages(branch = etpConst['branch']) count = str(len(idpackages)) cnt = 0 @@ -237,8 +233,6 @@ def database(options): atoms[(idpackage,repo)] = idpackageatom filelist.difference_update(set([etpConst['systemroot']+x for x in content])) break - dbconn.closeDB() - del clientDbconn print_info(red(" Found "+str(len(pkgsfound))+" packages. Filling database...")) count = str(len(pkgsfound)) @@ -256,10 +250,7 @@ def database(options): elif (options[0] == "depends"): print_info(red(" Regenerating depends caching table...")) - clientDbconn = openClientDatabase() - clientDbconn.regenerateDependsTable() - clientDbconn.closeDB() - del clientDbconn + Equo.clientDbconn.regenerateDependsTable() print_info(red(" Depends caching table regenerated successfully.")) return 0 @@ -272,10 +263,7 @@ def database(options): return 1 print_info(red(" Regenerating counters table. Please wait...")) - clientDbconn = openClientDatabase() - clientDbconn.regenerateCountersTable(output = True) - clientDbconn.closeDB() - del clientDbconn + Equo.clientDbconn.regenerateCountersTable(output = True) print_info(red(" Counters table regenerated. Check above for errors.")) return 0 @@ -289,19 +277,14 @@ def database(options): print_info(red(" Scanning Portage and Entropy databases for differences...")) - try: - clientDbconn = openClientDatabase() - except exceptionTools.SystemDatabaseError: - # damn - print_error(darkred(" * ")+bold("Entropy database")+red(" does not exist. So, you can't run this unless you run '")+bold("equo database generate")+red("' first. Sorry.")) - return 1 + # make it crash + Equo.noclientdb = False + Equo.reopenClientDbconn() # test if counters table exists, because if not, it's useless to run the diff scan try: - clientDbconn.isCounterAvailable(1) + Equo.clientDbconn.isCounterAvailable(1) except: - clientDbconn.closeDB() - del clientDbconn print_error(darkred(" * ")+bold("Entropy database")+red(" has never been in sync with Portage one. So, you can't run this unless you run '")+bold("equo database generate")+red("' first. Sorry.")) return 1 @@ -318,12 +301,12 @@ def database(options): # packages to be added/updated (handle add/update later) for x in installedPackages[0]: installedCounters.add(x[1]) - counter = clientDbconn.isCounterAvailable(x[1]) + counter = Equo.clientDbconn.isCounterAvailable(x[1]) if (not counter): toBeAdded.add(tuple(x)) # packages to be removed from the database - databaseCounters = clientDbconn.listAllCounters() + databaseCounters = Equo.clientDbconn.listAllCounters() for x in databaseCounters: if x[0] < 0: # skip packages without valid counter continue @@ -331,7 +314,7 @@ def database(options): # check if the package is in toBeAdded if (toBeAdded): atomkey = entropyTools.dep_getkey(clientDbconn.retrieveAtom(x[1])) - atomslot = clientDbconn.retrieveSlot(x[1]) + atomslot = Equo.clientDbconn.retrieveSlot(x[1]) add = True for pkgdata in toBeAdded: addslot = getPackageSlot(pkgdata[0]) @@ -351,15 +334,13 @@ def database(options): if (not toBeRemoved) and (not toBeAdded): print_info(red(" Databases already synced.")) # then exit gracefully - clientDbconn.closeDB() - del clientDbconn return 0 if (toBeRemoved): print_info(brown(" @@ ")+blue("Someone removed these packages. Would be removed from the Entropy database:")) for x in toBeRemoved: - atom = clientDbconn.retrieveAtom(x) + atom = Equo.clientDbconn.retrieveAtom(x) print_info(brown(" # ")+red(atom)) rc = "Yes" if etpUi['ask']: rc = entropyTools.askquestion(">> Continue with removal?") @@ -368,9 +349,9 @@ def database(options): totalqueue = str(len(toBeRemoved)) for x in toBeRemoved: queue += 1 - atom = clientDbconn.retrieveAtom(x) + atom = Equo.clientDbconn.retrieveAtom(x) print_info(red(" ++ ")+bold("(")+blue(str(queue))+"/"+red(totalqueue)+bold(") ")+">>> Removing "+darkgreen(atom)) - clientDbconn.removePackage(x) + Equo.clientDbconn.removePackage(x) print_info(brown(" @@ ")+blue("Database removal complete.")) if (toBeAdded): @@ -415,21 +396,19 @@ def database(options): myatom += "#"+mydata['versiontag'] # look for atom in client database - oldidpackage = clientDbconn.getIDPackage(myatom) + oldidpackage = Equo.clientDbconn.getIDPackage(myatom) if oldidpackage != -1: - mydata['revision'] = clientDbconn.retrieveRevision(oldidpackage) + mydata['revision'] = Equo.clientDbconn.retrieveRevision(oldidpackage) else: mydata['revision'] = 9999 # can't do much more - idpk, rev, xx, status = clientDbconn.handlePackage(etpData = mydata, forcedRevision = mydata['revision']) - clientDbconn.removePackageFromInstalledTable(idpk) - clientDbconn.addPackageToInstalledTable(idpk,"gentoo-db") + idpk, rev, xx, status = Equo.clientDbconn.handlePackage(etpData = mydata, forcedRevision = mydata['revision']) + Equo.clientDbconn.removePackageFromInstalledTable(idpk) + Equo.clientDbconn.addPackageToInstalledTable(idpk,"gentoo-db") os.remove(temptbz2) - + print_info(brown(" @@ ")+blue("Database update completed.")) - - clientDbconn.closeDB() - del clientDbconn + return 0 else: @@ -473,9 +452,8 @@ def pythonUpdater(): old_pdir = os.path.join("/usr/lib/",dirs[0]) print_info(brown(" @@ ")+blue("Scanning: %s" % (red(old_pdir),))) - clientDbconn = openClientDatabase() old_pdir = old_pdir.replace("/usr/lib","/usr/lib*") - idpackages = queryTools.searchBelongs(files = [old_pdir], idreturn = True, dbconn = clientDbconn) + idpackages = queryTools.searchBelongs(files = [old_pdir], idreturn = True, dbconn = Equo.clientDbconn) if not idpackages: print_info(brown(" @@ ")+blue("There are no files in %s whose belong to your old Python." % (old_pdir,))) return 0 @@ -483,7 +461,7 @@ def pythonUpdater(): atoms = set() for idpackage in idpackages: - atom = clientDbconn.retrieveAtom(idpackage) + atom = Equo.clientDbconn.retrieveAtom(idpackage) atoms.add((atom, idpackage)) print_info(red(" # ")+atom) @@ -493,9 +471,9 @@ def pythonUpdater(): matchedAtoms = set() for meta in atoms: atomkey = entropyTools.dep_getkey(meta[0]) - slot = clientDbconn.retrieveSlot(meta[1]) + slot = Equo.clientDbconn.retrieveSlot(meta[1]) print_info(brown(" @@ ")+red("Matching ")+bold(atomkey)+red(":")+darkgreen(slot), back = True) - match = uiTools.Equo.atomMatch(atomkey, matchSlot = slot) + match = Equo.atomMatch(atomkey, matchSlot = slot) if match[0] != -1: matchedAtoms.add((atomkey+":"+slot,match)) del atoms @@ -551,7 +529,7 @@ def getinfo(dict = False): # client database info conn = False try: - clientDbconn = openClientDatabase() + Equo.clientDbconn.listAllIdPackages() conn = True except: pass @@ -561,8 +539,6 @@ def getinfo(dict = False): info['Removal internal protected directories'] = clientDbconn.listConfigProtectDirectories() info['Removal internal protected directory masks'] = clientDbconn.listConfigProtectDirectories(mask = True) info['Total installed packages'] = len(clientDbconn.listAllIdpackages()) - clientDbconn.closeDB() - del clientDbconn # repository databases info (if found on the system) info['Repository databases'] = {} @@ -570,15 +546,13 @@ def getinfo(dict = False): dbfile = etpRepositories[x]['dbpath']+"/"+etpConst['etpdatabasefile'] if os.path.isfile(dbfile): # print info about this database - dbconn = openRepositoryDatabase(x) + dbconn = Equo.openRepositoryDatabase(x) info['Repository databases'][x] = {} info['Repository databases'][x]['Installation internal protected directories'] = dbconn.listConfigProtectDirectories() info['Repository databases'][x]['Installation internal protected directory masks'] = dbconn.listConfigProtectDirectories(mask = True) info['Repository databases'][x]['Total available packages'] = len(dbconn.listAllIdpackages()) info['Repository databases'][x]['Database revision'] = repositoriesTools.getRepositoryRevision(x) info['Repository databases'][x]['Database hash'] = repositoriesTools.getRepositoryDbFileHash(x) - dbconn.closeDB() - del dbconn if (dict): return info diff --git a/client/uiTools.py b/client/uiTools.py index a3e569e89..c75f70b59 100644 --- a/client/uiTools.py +++ b/client/uiTools.py @@ -29,14 +29,14 @@ from entropyConstants import * from clientConstants import * from outputTools import * import equoTools -from databaseTools import openRepositoryDatabase, openGenericDatabase, listAllAvailableBranches +from databaseTools import openGenericDatabase import entropyTools import dumpTools import shutil import logTools equoLog = logTools.LogFile(level = etpConst['equologlevel'],filename = etpConst['equologfile'], header = "[Equo]") -Equo = equoTools.Equo() +Equo = equoTools.EquoInterface() def package(options): @@ -141,7 +141,7 @@ def worldUpdate(onlyfetch = False, replay = False, upgradeTo = None, resume = Fa # verify selected release (branch) if (upgradeTo): - availbranches = listAllAvailableBranches() + availbranches = Equo.listAllAvailableBranches() if (upgradeTo not in availbranches) or (upgradeTo == None): if not (etpUi['quiet'] or returnQueue): print_error(red("Selected release: ")+bold(str(upgradeTo))+red(" is not available.")) return 1,-2 @@ -175,12 +175,10 @@ def worldUpdate(onlyfetch = False, replay = False, upgradeTo = None, resume = Fa if match[0] == -1: # atom has been changed, or removed? tainted = True else: # not changed, is the revision changed? - adbconn = openRepositoryDatabase(match[1]) + adbconn = Equo.openRepositoryDatabase(match[1]) arevision = adbconn.retrieveRevision(match[0]) # if revision is 9999, then any revision is fine if revision == 9999: arevision = 9999 - adbconn.closeDB() - del adbconn if revision != arevision: tainted = True elif (replay): @@ -189,20 +187,16 @@ def worldUpdate(onlyfetch = False, replay = False, upgradeTo = None, resume = Fa # Alice! use the key! ... and the slot matchresults = Equo.atomMatch(atomkey, matchSlot = slot, matchBranches = branches) if matchresults[0] != -1: - mdbconn = openRepositoryDatabase(matchresults[1]) + mdbconn = Equo.openRepositoryDatabase(matchresults[1]) matchatom = mdbconn.retrieveAtom(matchresults[0]) - mdbconn.closeDB() - del mdbconn updateList.add((matchatom,matchresults)) else: removedList.add(idpackage) # look for packages that would match key with any slot (for eg, gcc updates), slot changes handling matchresults = Equo.atomMatch(atomkey, matchBranches = branches) if matchresults[0] != -1: - mdbconn = openRepositoryDatabase(matchresults[1]) + mdbconn = Equo.openRepositoryDatabase(matchresults[1]) matchatom = mdbconn.retrieveAtom(matchresults[0]) - mdbconn.closeDB() - del mdbconn # compare versions unsatisfied, satisfied = Equo.filterSatisfiedDependencies((matchatom,)) if unsatisfied: @@ -390,8 +384,8 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals idpackage = atomInfo[0] reponame = atomInfo[1] # open database - dbconn = openRepositoryDatabase(reponame) - + dbconn = Equo.openRepositoryDatabase(reponame) + # get needed info pkgatom = dbconn.retrieveAtom(idpackage) pkgver = dbconn.retrieveVersion(idpackage) @@ -400,7 +394,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals pkgtag = "NoTag" pkgrev = dbconn.retrieveRevision(idpackage) pkgslot = dbconn.retrieveSlot(idpackage) - + # client info installedVer = "Not installed" installedTag = "NoTag" @@ -433,10 +427,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals else: action = red("Downgrade") if not (etpUi['quiet'] or returnQueue): print_info("\t"+red("Action:\t\t")+" "+action) - - dbconn.closeDB() - del dbconn - + if (etpUi['verbose'] or etpUi['ask'] or etpUi['pretend']): if not (etpUi['quiet'] or returnQueue): print_info(red(" @@ ")+blue("Number of packages: ")+str(totalatoms)) @@ -462,15 +453,13 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals crying_atoms = set() for atom in treepackages: for repo in etpRepositories: - rdbconn = openRepositoryDatabase(repo) + rdbconn = Equo.openRepositoryDatabase(repo) riddep = rdbconn.searchDependency(atom) if riddep != -1: ridpackages = rdbconn.searchIdpackageFromIddependency(riddep) for i in ridpackages: iatom = rdbconn.retrieveAtom(i) crying_atoms.add((iatom,repo)) - rdbconn.closeDB() - del rdbconn if crying_atoms: if not (etpUi['quiet'] or returnQueue): print_error(red(" @@ ")+blue("Dependency found and probably needed by:")) for crying_atomdata in crying_atoms: @@ -523,7 +512,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals if not (etpUi['quiet'] or returnQueue): if not (etpUi['ask'] or etpUi['pretend']): print_info(":: Collecting data: "+str(round((float(count)/atomlen)*100,1))+"% ::", back = True) - dbconn = openRepositoryDatabase(packageInfo[1]) + dbconn = Equo.openRepositoryDatabase(packageInfo[1]) mydata = dbconn.getBaseData(packageInfo[0]) pkgatom = mydata[0] pkgver = mydata[2] @@ -599,8 +588,6 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals oldinfo += oldtag if not (etpUi['quiet'] or returnQueue): print_info(darkred(" ##")+flags+repoinfo+enlightenatom(str(pkgatom))+"/"+str(pkgrev)+oldinfo) - dbconn.closeDB() - del dbconn if (removalQueue): @@ -611,7 +598,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals myremmatch = {} [myremmatch.update({(entropyTools.dep_getkey(Equo.clientDbconn.retrieveAtom(x)),Equo.clientDbconn.retrieveSlot(x)): x}) for x in removalQueue] for packageInfo in runQueue: - dbconn = openRepositoryDatabase(packageInfo[1]) + dbconn = Equo.openRepositoryDatabase(packageInfo[1]) testtuple = (entropyTools.dep_getkey(dbconn.retrieveAtom(packageInfo[0])),dbconn.retrieveSlot(packageInfo[0])) if testtuple in myremmatch: # remove from removalQueue @@ -621,14 +608,14 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals del myremmatch # update pkgsToRemove = len(removalQueue) - + #''' - + ''' - + FIXME: it's broken, on equo world it pulls in depends that shouldn't be removed fix, or remove and forget - + # add depends to removalQueue that are not in runQueue dependQueue = set() for idpackage in removalQueue: @@ -639,10 +626,8 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals # match in repositories match = Equo.atomMatch(dependkey, matchSlot = dependslot) if match[0] != -1: - matchdbconn = openRepositoryDatabase(match[1]) + matchdbconn = Equo.openRepositoryDatabase(match[1]) matchatom = matchdbconn.retrieveAtom(match[0]) - matchdbconn.closeDB() - del matchdbconn if (matchatom not in actionQueue) and (depend not in removalQueue): # if the atom hasn't been pulled in, we need to remove depend # check if the atom is already up to date mymatch = Equo.atomMatch(matchatom) @@ -725,10 +710,8 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals rconflicts_match = set() # now look for the rest for item in runQueue: - rdbconn = openRepositoryDatabase(item[1]) + rdbconn = Equo.openRepositoryDatabase(item[1]) rconflicts = rdbconn.retrieveConflicts(item[0]) - rdbconn.closeDB() - del rdbconn for rconflict in rconflicts: rmatch = Equo.clientDbconn.atomMatch(rconflict) if rmatch[0] != -1: @@ -739,7 +722,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals resume_cache['runQueue'] = runQueue[:] resume_cache['removalQueue'] = removalQueue[:] dumpTools.dumpobj(etpCache['install'],resume_cache) - + if returnQueue: # prepare return dictionary @@ -770,44 +753,41 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals if not returnQueue: fetchqueue = 0 for packageInfo in runQueue: - + fetchqueue += 1 idpackage = packageInfo[0] repository = packageInfo[1] - dbconn = openRepositoryDatabase(repository) + dbconn = Equo.openRepositoryDatabase(repository) pkgatom = dbconn.retrieveAtom(idpackage) - + infoDict = actionQueue[pkgatom].copy() - + infoDict['repository'] = packageInfo[1] infoDict['idpackage'] = packageInfo[0] infoDict['checksum'] = dbconn.retrieveDigest(idpackage) infoDict['download'] = dbconn.retrieveDownloadURL(idpackage) infoDict['verified'] = False - - dbconn.closeDB() - del dbconn - + steps = [] - + if not repository.endswith(".tbz2"): if (actionQueue[pkgatom]['fetch'] < 0): steps.append("fetch") if dochecksum: steps.append("checksum") - + # if file exists, first checksum then fetch if os.path.isfile(os.path.join(etpConst['entropyworkdir'],infoDict['download'])): steps.reverse() - + if not (etpUi['quiet'] or returnQueue): print_info(red(" :: ")+bold("(")+blue(str(fetchqueue))+"/"+red(totalqueue)+bold(") ")+">>> "+darkgreen(pkgatom)) - + for step in steps: rc = equoTools.stepExecutor(step,infoDict,str(fetchqueue)+"/"+totalqueue) if (rc != 0): dirscleanup() return -1,rc - + # disable fetch now, file fetched # also taint actionQueue[pkgatom]['fetch'] so resume won't re-fetch all again actionQueue[pkgatom]['fetch'] = 1 @@ -858,25 +838,25 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals del etpRemovalTriggers[infoDict['removeatom']] for packageInfo in runQueue: - - currentqueue += 1 - idpackage = packageInfo[0] - repository = packageInfo[1] - # get package atom - dbconn = openRepositoryDatabase(repository) - pkgatom = dbconn.retrieveAtom(idpackage) - - steps = [] - - # setup download stuff + + currentqueue += 1 + idpackage = packageInfo[0] + repository = packageInfo[1] + # get package atom + dbconn = Equo.openRepositoryDatabase(repository) + pkgatom = dbconn.retrieveAtom(idpackage) + + steps = [] + + # setup download stuff if returnQueue: if not repository.endswith(".tbz2"): if (actionQueue[pkgatom]['fetch'] < 0): steps.append("fetch") steps.append("checksum") - # differential remove list - if (actionQueue[pkgatom]['removeidpackage'] != -1): + # differential remove list + if (actionQueue[pkgatom]['removeidpackage'] != -1): # is it still available? if Equo.clientDbconn.isIDPackageAvailable(actionQueue[pkgatom]['removeidpackage']): actionQueue[pkgatom]['diffremoval'] = True @@ -902,14 +882,13 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals actionQueue[pkgatom]['name'] = dbconn.retrieveName(idpackage) actionQueue[pkgatom]['repository'] = packageInfo[1] actionQueue[pkgatom]['idpackage'] = packageInfo[0] - + actionQueue[pkgatom]['messages'] = dbconn.retrieveMessages(idpackage) actionQueue[pkgatom]['checksum'] = dbconn.retrieveDigest(idpackage) # get data for triggerring tool etpInstallTriggers[pkgatom] = dbconn.getPackageData(idpackage) etpInstallTriggers[pkgatom]['trigger'] = dbconn.retrieveTrigger(idpackage) - - + # set unpack dir and image dir if actionQueue[pkgatom]['repository'].endswith(".tbz2"): actionQueue[pkgatom]['pkgpath'] = etpRepositories[actionQueue[pkgatom]['repository']]['pkgpath'] @@ -930,24 +909,21 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals etpInstallTriggers[pkgatom]['xpakdir'] = actionQueue[pkgatom]['xpakpath']+"/"+etpConst['entropyxpakdatarelativepath'] etpInstallTriggers[pkgatom]['unpackdir'] = actionQueue[pkgatom]['unpackdir'] - dbconn.closeDB() - del dbconn - - if (not onlyfetch): - # install - if (actionQueue[pkgatom]['removeidpackage'] != -1): - steps.append("preremove") + if (not onlyfetch): + # install + if (actionQueue[pkgatom]['removeidpackage'] != -1): + steps.append("preremove") steps.append("unpack") - steps.append("preinstall") - steps.append("install") - if (actionQueue[pkgatom]['removeidpackage'] != -1): - steps.append("postremove") - steps.append("postinstall") + steps.append("preinstall") + steps.append("install") + if (actionQueue[pkgatom]['removeidpackage'] != -1): + steps.append("postremove") + steps.append("postinstall") if not etpConst['gentoo-compat']: # otherwise gentoo triggers will show that steps.append("showmessages") steps.append("cleanup") - - if not (etpUi['quiet'] or returnQueue): print_info(red(" ++ ")+bold("(")+blue(str(currentqueue))+"/"+red(totalqueue)+bold(") ")+">>> "+darkgreen(pkgatom)) + + if not (etpUi['quiet'] or returnQueue): print_info(red(" ++ ")+bold("(")+blue(str(currentqueue))+"/"+red(totalqueue)+bold(") ")+">>> "+darkgreen(pkgatom)) if returnQueue: @@ -967,7 +943,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals if not tbz2: # tbz2 caching not supported resume_cache['runQueue'].remove(packageInfo) dumpTools.dumpobj(etpCache['install'],resume_cache) - + # unload dict try: del etpRemovalTriggers[actionQueue[pkgatom]['removeatom']] @@ -976,22 +952,18 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals del actionQueue[pkgatom] if not returnQueue: del etpInstallTriggers[pkgatom] - if (onlyfetch): - if not (etpUi['quiet'] or returnQueue): print_info(red(" @@ ")+blue("Fetch Complete.")) + if not (etpUi['quiet'] or returnQueue): print_info(red(" @@ ")+blue("Fetch Complete.")) else: - if not (etpUi['quiet'] or returnQueue): print_info(red(" @@ ")+blue("Install Complete.")) + if not (etpUi['quiet'] or returnQueue): print_info(red(" @@ ")+blue("Install Complete.")) # clear resume information dumpTools.dumpobj(etpCache['install'],{}) - dirscleanup() - if returnQueue: return returnActionQueue,0 - return 0,0 @@ -1281,11 +1253,11 @@ def dependenciesTest(clientDbconn = None, reagent = False): if (depsNotSatisfied): if (not etpUi['quiet']): print_info(red(" @@ ")+blue("These are the packages that lack dependencies: ")) - for xidpackage in depsNotSatisfied: - pkgatom = clientDbconn.retrieveAtom(xidpackage) - if (not etpUi['quiet']): - print_info(darkred(" ### ")+blue(pkgatom)) - for dep in depsNotSatisfied[xidpackage]: + for xidpackage in depsNotSatisfied: + pkgatom = clientDbconn.retrieveAtom(xidpackage) + if (not etpUi['quiet']): + print_info(darkred(" ### ")+blue(pkgatom)) + for dep in depsNotSatisfied[xidpackage]: if reagent: match = clientDbconn.atomMatch(dep) else: @@ -1297,36 +1269,34 @@ def dependenciesTest(clientDbconn = None, reagent = False): else: print dep,"--" continue - iddep = match[0] - repo = match[1] - dbconn = openRepositoryDatabase(repo) - depatom = dbconn.retrieveAtom(iddep) - dbconn.closeDB() - del dbconn - if (not etpUi['quiet']): - print_info(bold(" :o: ")+red(depatom)) - else: - print pkgatom+" -> "+depatom - packagesNeeded.add((depatom,dep)) + iddep = match[0] + repo = match[1] + dbconn = Equo.openRepositoryDatabase(repo) + depatom = dbconn.retrieveAtom(iddep) + if (not etpUi['quiet']): + print_info(bold(" :o: ")+red(depatom)) + else: + print pkgatom+" -> "+depatom + packagesNeeded.add((depatom,dep)) if (etpUi['pretend']): - return 0, packagesNeeded + return 0, packagesNeeded if (packagesNeeded) and (not etpUi['quiet']) and (not reagent): if (etpUi['ask']): rc = entropyTools.askquestion(" Would you like to install the available packages?") if rc == "No": - return 0,packagesNeeded - else: - print_info(red(" @@ ")+blue("Installing available packages in ")+red("10 seconds")+blue("...")) - import time - time.sleep(10) - + return 0,packagesNeeded + else: + print_info(red(" @@ ")+blue("Installing available packages in ")+red("10 seconds")+blue("...")) + import time + time.sleep(10) + # organize packages = set([x[0] for x in packagesNeeded]) - - entropyTools.applicationLockCheck("install") - installPackages(packages, deps = False) + + entropyTools.applicationLockCheck("install") + installPackages(packages, deps = False) if not etpUi['quiet']: print_info(red(" @@ ")+blue("All done.")) return 0,packagesNeeded @@ -1420,7 +1390,7 @@ def librariesTest(clientDbconn = None, reagent = False, listfiles = False): orderedRepos.sort() for repodata in orderedRepos: if not etpUi['quiet']: print_info(red(" @@ ")+blue("Repository: ")+darkgreen(etpRepositories[repodata[1]]['description'])+" ["+red(repodata[1])+"]") - dbconn = openRepositoryDatabase(repodata[1]) + dbconn = Equo.openRepositoryDatabase(repodata[1]) libsfound = set() for lib in brokenlibs: packages = dbconn.searchBelongs(file = "%"+lib, like = True, branch = etpConst['branch']) @@ -1433,8 +1403,6 @@ def librariesTest(clientDbconn = None, reagent = False, listfiles = False): if matching_libs: packagesMatched.add((idpackage,repodata[1],lib)) brokenlibs.difference_update(libsfound) - dbconn.closeDB() - del dbconn if listfiles: etpUi['quiet'] = qstat @@ -1455,20 +1423,16 @@ def librariesTest(clientDbconn = None, reagent = False, listfiles = False): print_info(darkred(" => ")+red(lib)) print_info(darkgreen(" ## ")+red("Matched:")) for packagedata in packagesMatched: - dbconn = openRepositoryDatabase(packagedata[1]) + dbconn = Equo.openRepositoryDatabase(packagedata[1]) myatom = dbconn.retrieveAtom(packagedata[0]) atomsdata.add((myatom,(packagedata[0],packagedata[1]))) print_info(" "+red(packagedata[2])+" => "+brown(myatom)+" ["+red(packagedata[1])+"]") - dbconn.closeDB() - del dbconn else: for packagedata in packagesMatched: - dbconn = openRepositoryDatabase(packagedata[1]) + dbconn = Equo.openRepositoryDatabase(packagedata[1]) myatom = dbconn.retrieveAtom(packagedata[0]) atomsdata.add((myatom,(packagedata[0],packagedata[1]))) print myatom - dbconn.closeDB() - del dbconn return 0,atomsdata if (etpUi['pretend']): diff --git a/libraries/clientConstants.py b/libraries/clientConstants.py index 17bfc42a5..ff9ea31ae 100644 --- a/libraries/clientConstants.py +++ b/libraries/clientConstants.py @@ -20,8 +20,6 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ''' -import os -import sys from entropyConstants import * ### Equo triggering functions for pre/post-install scripts diff --git a/libraries/databaseTools.py b/libraries/databaseTools.py index 7ecec7f16..308c61034 100644 --- a/libraries/databaseTools.py +++ b/libraries/databaseTools.py @@ -123,26 +123,17 @@ def openGenericDatabase(dbfile, dbname = None, xcache = False, indexing = True, def backupClientDatabase(): import shutil if os.path.isfile(etpConst['etpdatabaseclientfilepath']): - rnd = entropyTools.getRandomNumber() - source = etpConst['etpdatabaseclientfilepath'] - dest = etpConst['etpdatabaseclientfilepath']+".backup."+str(rnd) - shutil.copy2(source,dest) - user = os.stat(source)[4] - group = os.stat(source)[5] - os.chown(dest,user,group) - shutil.copystat(source,dest) - return dest + rnd = entropyTools.getRandomNumber() + source = etpConst['etpdatabaseclientfilepath'] + dest = etpConst['etpdatabaseclientfilepath']+".backup."+str(rnd) + shutil.copy2(source,dest) + user = os.stat(source)[4] + group = os.stat(source)[5] + os.chown(dest,user,group) + shutil.copystat(source,dest) + return dest return "" -def listAllAvailableBranches(): - branches = set() - for repo in etpRepositories: - dbconn = openRepositoryDatabase(repo) - branches.update(dbconn.listAllBranches()) - dbconn.closeDB() - del dbconn - return branches - def doServerDatabaseSyncLock(noUpload): import mirrorTools @@ -761,39 +752,39 @@ class etpDatabase: # otherwise it fires up updatePackage def handlePackage(self, etpData, forcedRevision = -1): - self.checkReadOnly() + self.checkReadOnly() - # build atom string - versiontag = '' - if etpData['versiontag']: - versiontag = '#'+etpData['versiontag'] + # build atom string + versiontag = '' + if etpData['versiontag']: + versiontag = '#'+etpData['versiontag'] - foundid = self.isPackageAvailable(etpData['category']+"/"+etpData['name']+"-"+etpData['version']+versiontag) - if (foundid < 0): # same atom doesn't exist - idpk, revision, etpDataUpdated, accepted = self.addPackage(etpData, revision = forcedRevision) - else: - idpk, revision, etpDataUpdated, accepted = self.updatePackage(etpData, forcedRevision) # only when the same atom exists - return idpk, revision, etpDataUpdated, accepted + foundid = self.isPackageAvailable(etpData['category']+"/"+etpData['name']+"-"+etpData['version']+versiontag) + if (foundid < 0): # same atom doesn't exist + idpk, revision, etpDataUpdated, accepted = self.addPackage(etpData, revision = forcedRevision) + else: + idpk, revision, etpDataUpdated, accepted = self.updatePackage(etpData, forcedRevision) # only when the same atom exists + return idpk, revision, etpDataUpdated, accepted def addPackage(self, etpData, revision = -1): - self.checkReadOnly() - - if revision == -1: + self.checkReadOnly() + + if revision == -1: try: - revision = etpData['revision'] + revision = etpData['revision'] except: etpData['revision'] = 0 # revision not specified revision = 0 - # we need to find other packages with the same key and slot, and remove them - if (self.clientDatabase): # client database can't care about branch - searchsimilar = self.searchPackagesByNameAndCategory(name = etpData['name'], category = etpData['category'], sensitive = True) - else: # server supports multiple branches inside a db - searchsimilar = self.searchPackagesByNameAndCategory(name = etpData['name'], category = etpData['category'], sensitive = True, branch = etpData['branch']) - - removelist = set() + # we need to find other packages with the same key and slot, and remove them + if (self.clientDatabase): # client database can't care about branch + searchsimilar = self.searchPackagesByNameAndCategory(name = etpData['name'], category = etpData['category'], sensitive = True) + else: # server supports multiple branches inside a db + searchsimilar = self.searchPackagesByNameAndCategory(name = etpData['name'], category = etpData['category'], sensitive = True, branch = etpData['branch']) + + removelist = set() if not etpData['injected']: # read: if package has been injected, we'll skip the removal of packages in the same slot, usually used server side btw for oldpkg in searchsimilar: # get the package slot @@ -805,32 +796,32 @@ class etpDatabase: if (etpData['slot'] == slot): # remove! removelist.add(idpackage) - - for pkg in removelist: - self.removePackage(pkg) - - # create new category if it doesn't exist - catid = self.isCategoryAvailable(etpData['category']) - if (catid == -1): - # create category - catid = self.addCategory(etpData['category']) - # create new license if it doesn't exist - licid = self.isLicenseAvailable(etpData['license']) - if (licid == -1): - # create category - licid = self.addLicense(etpData['license']) + for pkg in removelist: + self.removePackage(pkg) + + # create new category if it doesn't exist + catid = self.isCategoryAvailable(etpData['category']) + if (catid == -1): + # create category + catid = self.addCategory(etpData['category']) + + # create new license if it doesn't exist + licid = self.isLicenseAvailable(etpData['license']) + if (licid == -1): + # create category + licid = self.addLicense(etpData['license']) + + # look for configured versiontag + versiontag = "" + if (etpData['versiontag']): + versiontag = "#"+etpData['versiontag'] - # look for configured versiontag - versiontag = "" - if (etpData['versiontag']): - versiontag = "#"+etpData['versiontag'] - trigger = 0 if etpData['trigger']: trigger = 1 - - # baseinfo + + # baseinfo pkgatom = etpData['category']+"/"+etpData['name']+"-"+etpData['version']+versiontag try: self.cursor.execute( @@ -867,9 +858,9 @@ class etpDatabase: trigger, ) ) - - self.connection.commit() - idpackage = self.cursor.lastrowid + + self.connection.commit() + idpackage = self.cursor.lastrowid ### RSS Atom support ### dictionary will be elaborated by activator @@ -888,29 +879,29 @@ class etpDatabase: # save dumpTools.dumpobj(etpConst['rss-dump-name'],etpRSSMessages) - # create new idflag if it doesn't exist - idflags = self.areCompileFlagsAvailable(etpData['chost'],etpData['cflags'],etpData['cxxflags']) - if (idflags == -1): - # create category - idflags = self.addCompileFlags(etpData['chost'],etpData['cflags'],etpData['cxxflags']) + # create new idflag if it doesn't exist + idflags = self.areCompileFlagsAvailable(etpData['chost'],etpData['cflags'],etpData['cxxflags']) + if (idflags == -1): + # create category + idflags = self.addCompileFlags(etpData['chost'],etpData['cflags'],etpData['cxxflags']) - # extrainfo - self.cursor.execute( - 'INSERT into extrainfo VALUES ' - '(?,?,?,?,?,?,?,?)' - , ( idpackage, - etpData['description'], - etpData['homepage'], - etpData['download'], - etpData['size'], - idflags, - etpData['digest'], - etpData['datecreation'], - ) - ) + # extrainfo + self.cursor.execute( + 'INSERT into extrainfo VALUES ' + '(?,?,?,?,?,?,?,?)' + , ( idpackage, + etpData['description'], + etpData['homepage'], + etpData['download'], + etpData['size'], + idflags, + etpData['digest'], + etpData['datecreation'], + ) + ) - # content, a list - for xfile in etpData['content']: + # content, a list + for xfile in etpData['content']: contenttype = etpData['content'][xfile] try: self.cursor.execute( @@ -933,11 +924,11 @@ class etpDatabase: ) etpData['counter'] = int(etpData['counter']) # cast to integer - if etpData['counter'] != -1 and not (etpData['injected']): - + if etpData['counter'] != -1 and not (etpData['injected']): + if etpData['counter'] <= -2: # special cases - + try: mycounters = list(self.listAllCounters(onlycounters = True)) mycounter = min(mycounters) @@ -947,7 +938,7 @@ class etpDatabase: etpData['counter'] = mycounter-1 except: etpData['counter'] = -2 - + try: self.cursor.execute( 'INSERT into counters VALUES ' @@ -968,112 +959,112 @@ class etpDatabase: ) elif self.dbname == "etpdb": raise - - # on disk size - try: - self.cursor.execute( - 'INSERT into sizes VALUES ' - '(?,?)' - , ( idpackage, - etpData['disksize'], - ) - ) - except: - # create sizes table, temp hack - self.createSizesTable() - self.cursor.execute( - 'INSERT into sizes VALUES ' - '(?,?)' - , ( idpackage, - etpData['disksize'], - ) - ) + + # on disk size + try: + self.cursor.execute( + 'INSERT into sizes VALUES ' + '(?,?)' + , ( idpackage, + etpData['disksize'], + ) + ) + except: + # create sizes table, temp hack + self.createSizesTable() + self.cursor.execute( + 'INSERT into sizes VALUES ' + '(?,?)' + , ( idpackage, + etpData['disksize'], + ) + ) # trigger blob try: - self.cursor.execute( - 'INSERT into triggers VALUES ' - '(?,?)' - , ( idpackage, - buffer(etpData['trigger']), - )) + self.cursor.execute( + 'INSERT into triggers VALUES ' + '(?,?)' + , ( idpackage, + buffer(etpData['trigger']), + )) except: - # create trigggers table, temp hack - self.createTriggerTable() - self.cursor.execute( - 'INSERT into triggers VALUES ' - '(?,?)' - , ( idpackage, - buffer(etpData['trigger']), - )) + # create trigggers table, temp hack + self.createTriggerTable() + self.cursor.execute( + 'INSERT into triggers VALUES ' + '(?,?)' + , ( idpackage, + buffer(etpData['trigger']), + )) - # eclasses table - for var in etpData['eclasses']: - - try: - idclass = self.isEclassAvailable(var) - except: - self.createEclassesTable() - idclass = self.isEclassAvailable(var) - - if (idclass == -1): - # create eclass - idclass = self.addEclass(var) - - self.cursor.execute( - 'INSERT into eclasses VALUES ' - '(?,?)' - , ( idpackage, - idclass, - ) - ) + # eclasses table + for var in etpData['eclasses']: - # needed table - for var in etpData['needed']: - - try: - idneeded = self.isNeededAvailable(var) - except: - self.createNeededTable() - idneeded = self.isNeededAvailable(var) - - if (idneeded == -1): - # create eclass - idneeded = self.addNeeded(var) - - self.cursor.execute( - 'INSERT into needed VALUES ' - '(?,?)' - , ( idpackage, - idneeded, - ) - ) - - # dependencies, a list - for dep in etpData['dependencies']: - - iddep = self.isDependencyAvailable(dep) - if (iddep == -1): - # create category - iddep = self.addDependency(dep) - - self.cursor.execute( - 'INSERT into dependencies VALUES ' - '(?,?)' - , ( idpackage, - iddep, - ) - ) + try: + idclass = self.isEclassAvailable(var) + except: + self.createEclassesTable() + idclass = self.isEclassAvailable(var) - # provide - for atom in etpData['provide']: - self.cursor.execute( - 'INSERT into provide VALUES ' - '(?,?)' - , ( idpackage, - atom, - ) - ) + if (idclass == -1): + # create eclass + idclass = self.addEclass(var) + + self.cursor.execute( + 'INSERT into eclasses VALUES ' + '(?,?)' + , ( idpackage, + idclass, + ) + ) + + # needed table + for var in etpData['needed']: + + try: + idneeded = self.isNeededAvailable(var) + except: + self.createNeededTable() + idneeded = self.isNeededAvailable(var) + + if (idneeded == -1): + # create eclass + idneeded = self.addNeeded(var) + + self.cursor.execute( + 'INSERT into needed VALUES ' + '(?,?)' + , ( idpackage, + idneeded, + ) + ) + + # dependencies, a list + for dep in etpData['dependencies']: + + iddep = self.isDependencyAvailable(dep) + if (iddep == -1): + # create category + iddep = self.addDependency(dep) + + self.cursor.execute( + 'INSERT into dependencies VALUES ' + '(?,?)' + , ( idpackage, + iddep, + ) + ) + + # provide + for atom in etpData['provide']: + self.cursor.execute( + 'INSERT into provide VALUES ' + '(?,?)' + , ( idpackage, + atom, + ) + ) # injected? if etpData['injected']: @@ -1091,28 +1082,28 @@ class etpDatabase: , ( idpackage, ) ) - # compile messages - try: - for message in etpData['messages']: - self.cursor.execute( - 'INSERT into messages VALUES ' - '(?,?)' - , ( idpackage, - message, - ) - ) - except: - # FIXME: temp workaround, create messages table - self.cursor.execute("CREATE TABLE messages ( idpackage INTEGER, message VARCHAR);") - for message in etpData['messages']: - self.cursor.execute( - 'INSERT into messages VALUES ' - '(?,?)' - , ( idpackage, - message, - ) - ) - + # compile messages + try: + for message in etpData['messages']: + self.cursor.execute( + 'INSERT into messages VALUES ' + '(?,?)' + , ( idpackage, + message, + ) + ) + except: + # FIXME: temp workaround, create messages table + self.cursor.execute("CREATE TABLE messages ( idpackage INTEGER, message VARCHAR);") + for message in etpData['messages']: + self.cursor.execute( + 'INSERT into messages VALUES ' + '(?,?)' + , ( idpackage, + message, + ) + ) + try: # is it a system package? if etpData['systempackage']: @@ -1134,165 +1125,167 @@ class etpDatabase: ) ) - # create new protect if it doesn't exist - try: - idprotect = self.isProtectAvailable(etpData['config_protect']) - except: - self.createProtectTable() - idprotect = self.isProtectAvailable(etpData['config_protect']) - if (idprotect == -1): - # create category - idprotect = self.addProtect(etpData['config_protect']) - # fill configprotect - self.cursor.execute( - 'INSERT into configprotect VALUES ' - '(?,?)' - , ( idpackage, - idprotect, - ) - ) - - idprotect = self.isProtectAvailable(etpData['config_protect_mask']) - if (idprotect == -1): - # create category - idprotect = self.addProtect(etpData['config_protect_mask']) - # fill configprotect - self.cursor.execute( - 'INSERT into configprotectmask VALUES ' - '(?,?)' - , ( idpackage, - idprotect, - ) - ) + # create new protect if it doesn't exist + try: + idprotect = self.isProtectAvailable(etpData['config_protect']) + except: + self.createProtectTable() + idprotect = self.isProtectAvailable(etpData['config_protect']) + if (idprotect == -1): + # create category + idprotect = self.addProtect(etpData['config_protect']) + # fill configprotect + self.cursor.execute( + 'INSERT into configprotect VALUES ' + '(?,?)' + , ( idpackage, + idprotect, + ) + ) - # conflicts, a list - for conflict in etpData['conflicts']: - self.cursor.execute( - 'INSERT into conflicts VALUES ' - '(?,?)' - , ( idpackage, - conflict, - ) - ) + idprotect = self.isProtectAvailable(etpData['config_protect_mask']) + if (idprotect == -1): + # create category + idprotect = self.addProtect(etpData['config_protect_mask']) + # fill configprotect + self.cursor.execute( + 'INSERT into configprotectmask VALUES ' + '(?,?)' + , ( idpackage, + idprotect, + ) + ) - # mirrorlinks, always update the table - for mirrordata in etpData['mirrorlinks']: - mirrorname = mirrordata[0] - mirrorlist = mirrordata[1] - # remove old - self.removeMirrorEntries(mirrorname) - # add new - self.addMirrors(mirrorname,mirrorlist) + # conflicts, a list + for conflict in etpData['conflicts']: + self.cursor.execute( + 'INSERT into conflicts VALUES ' + '(?,?)' + , ( idpackage, + conflict, + ) + ) - # sources, a list - for source in etpData['sources']: - - idsource = self.isSourceAvailable(source) - if (idsource == -1): - # create category - idsource = self.addSource(source) - - self.cursor.execute( - 'INSERT into sources VALUES ' - '(?,?)' - , ( idpackage, - idsource, - ) - ) + # mirrorlinks, always update the table + for mirrordata in etpData['mirrorlinks']: + mirrorname = mirrordata[0] + mirrorlist = mirrordata[1] + # remove old + self.removeMirrorEntries(mirrorname) + # add new + self.addMirrors(mirrorname,mirrorlist) - # useflags, a list - for flag in etpData['useflags']: - - iduseflag = self.isUseflagAvailable(flag) - if (iduseflag == -1): - # create category - iduseflag = self.addUseflag(flag) - - self.cursor.execute( - 'INSERT into useflags VALUES ' - '(?,?)' - , ( idpackage, - iduseflag, - ) - ) + # sources, a list + for source in etpData['sources']: - # create new keyword if it doesn't exist - for key in etpData['keywords']: + idsource = self.isSourceAvailable(source) + if (idsource == -1): + # create category + idsource = self.addSource(source) - idkeyword = self.isKeywordAvailable(key) - if (idkeyword == -1): - # create category - idkeyword = self.addKeyword(key) + self.cursor.execute( + 'INSERT into sources VALUES ' + '(?,?)' + , ( idpackage, + idsource, + ) + ) - self.cursor.execute( - 'INSERT into keywords VALUES ' - '(?,?)' - , ( idpackage, - idkeyword, - ) - ) + # useflags, a list + for flag in etpData['useflags']: - # clear caches - dbCacheStore[etpCache['dbMatch']+self.dbname] = {} - dbCacheStore[etpCache['dbSearch']+self.dbname] = {} - # dump to be sure - dumpTools.dumpobj(etpCache['dbMatch']+self.dbname,{}) - dumpTools.dumpobj(etpCache['dbSearch']+self.dbname,{}) + iduseflag = self.isUseflagAvailable(flag) + if (iduseflag == -1): + # create category + iduseflag = self.addUseflag(flag) + + self.cursor.execute( + 'INSERT into useflags VALUES ' + '(?,?)' + , ( idpackage, + iduseflag, + ) + ) + + # create new keyword if it doesn't exist + for key in etpData['keywords']: + + idkeyword = self.isKeywordAvailable(key) + if (idkeyword == -1): + # create category + idkeyword = self.addKeyword(key) + + self.cursor.execute( + 'INSERT into keywords VALUES ' + '(?,?)' + , ( idpackage, + idkeyword, + ) + ) + + # clear caches + dbCacheStore[etpCache['dbMatch']+self.dbname] = {} + dbCacheStore[etpCache['dbSearch']+self.dbname] = {} + # dump to be sure + dumpTools.dumpobj(etpCache['dbMatch']+self.dbname,{}) + dumpTools.dumpobj(etpCache['dbSearch']+self.dbname,{}) self.clearInfoCache() - self.packagesAdded = True - self.commitChanges() - - return idpackage, revision, etpData, True + self.packagesAdded = True + self.commitChanges() + + return idpackage, revision, etpData, True # Update already available atom in db # returns True,revision if the package has been updated # returns False,revision if not def updatePackage(self, etpData, forcedRevision = -1): - self.checkReadOnly() + self.checkReadOnly() - # build atom string - versiontag = '' - if etpData['versiontag']: - versiontag = '#'+etpData['versiontag'] - pkgatom = etpData['category'] + "/" + etpData['name'] + "-" + etpData['version']+versiontag + # build atom string + versiontag = '' + if etpData['versiontag']: + versiontag = '#'+etpData['versiontag'] + pkgatom = etpData['category'] + "/" + etpData['name'] + "-" + etpData['version']+versiontag - # for client database - the atom if present, must be overwritten with the new one regardless its branch - if (self.clientDatabase): - - atomid = self.isPackageAvailable(pkgatom) - if atomid > -1: - self.removePackage(atomid) - - x,y,z,accepted = self.addPackage(etpData, revision = forcedRevision) - return x,y,z,accepted - - else: - # update package in etpData['branch'] - # get its package revision - idpackage = self.getIDPackage(pkgatom,etpData['branch']) - if (forcedRevision == -1): - if (idpackage != -1): - curRevision = self.retrieveRevision(idpackage) - else: - curRevision = 0 - else: - curRevision = forcedRevision + # for client database - the atom if present, must be overwritten with the new one regardless its branch + if (self.clientDatabase): + + atomid = self.isPackageAvailable(pkgatom) + if atomid > -1: + self.removePackage(atomid) + + x,y,z,accepted = self.addPackage(etpData, revision = forcedRevision) + self.commitChanges() + return x,y,z,accepted + + else: + # update package in etpData['branch'] + # get its package revision + idpackage = self.getIDPackage(pkgatom,etpData['branch']) + if (forcedRevision == -1): + if (idpackage != -1): + curRevision = self.retrieveRevision(idpackage) + else: + curRevision = 0 + else: + curRevision = forcedRevision + + if (idpackage != -1): # remove old package in branch + self.removePackage(idpackage) + if (forcedRevision == -1): + curRevision += 1 + + # add the new one + x,y,z,accepted = self.addPackage(etpData, revision = curRevision) + self.commitChanges() + return x,y,z,accepted - if (idpackage != -1): # remove old package in branch - self.removePackage(idpackage) - if (forcedRevision == -1): - curRevision += 1 - - # add the new one - x,y,z,accepted = self.addPackage(etpData, revision = curRevision) - return x,y,z,accepted - def removePackage(self,idpackage): - self.checkReadOnly() + self.checkReadOnly() ### RSS Atom support ### dictionary will be elaborated by activator @@ -1319,218 +1312,227 @@ class etpDatabase: # save dumpTools.dumpobj(etpConst['rss-dump-name'],etpRSSMessages) - idpackage = str(idpackage) - # baseinfo - self.cursor.execute('DELETE FROM baseinfo WHERE idpackage = '+idpackage) - # extrainfo - self.cursor.execute('DELETE FROM extrainfo WHERE idpackage = '+idpackage) - # content - self.cursor.execute('DELETE FROM content WHERE idpackage = '+idpackage) - # dependencies - self.cursor.execute('DELETE FROM dependencies WHERE idpackage = '+idpackage) - # provide - self.cursor.execute('DELETE FROM provide WHERE idpackage = '+idpackage) - # conflicts - self.cursor.execute('DELETE FROM conflicts WHERE idpackage = '+idpackage) - # protect - self.cursor.execute('DELETE FROM configprotect WHERE idpackage = '+idpackage) - # protect_mask - self.cursor.execute('DELETE FROM configprotectmask WHERE idpackage = '+idpackage) - # sources - self.cursor.execute('DELETE FROM sources WHERE idpackage = '+idpackage) - # useflags - self.cursor.execute('DELETE FROM useflags WHERE idpackage = '+idpackage) - # keywords - self.cursor.execute('DELETE FROM keywords WHERE idpackage = '+idpackage) - - # - # WARNING: exception won't be handled anymore with 1.0 - # - - try: - # messages - self.cursor.execute('DELETE FROM messages WHERE idpackage = '+idpackage) - except: - pass + idpackage = str(idpackage) + # baseinfo + self.cursor.execute('DELETE FROM baseinfo WHERE idpackage = '+idpackage) + # extrainfo + self.cursor.execute('DELETE FROM extrainfo WHERE idpackage = '+idpackage) + # content + self.cursor.execute('DELETE FROM content WHERE idpackage = '+idpackage) + # dependencies + self.cursor.execute('DELETE FROM dependencies WHERE idpackage = '+idpackage) + # provide + self.cursor.execute('DELETE FROM provide WHERE idpackage = '+idpackage) + # conflicts + self.cursor.execute('DELETE FROM conflicts WHERE idpackage = '+idpackage) + # protect + self.cursor.execute('DELETE FROM configprotect WHERE idpackage = '+idpackage) + # protect_mask + self.cursor.execute('DELETE FROM configprotectmask WHERE idpackage = '+idpackage) + # sources + self.cursor.execute('DELETE FROM sources WHERE idpackage = '+idpackage) + # useflags + self.cursor.execute('DELETE FROM useflags WHERE idpackage = '+idpackage) + # keywords + self.cursor.execute('DELETE FROM keywords WHERE idpackage = '+idpackage) + + # + # WARNING: exception won't be handled anymore with 1.0 + # + try: - # systempackage - self.cursor.execute('DELETE FROM systempackages WHERE idpackage = '+idpackage) + # messages + self.cursor.execute('DELETE FROM messages WHERE idpackage = '+idpackage) except: pass - try: - # counter - self.cursor.execute('DELETE FROM counters WHERE idpackage = '+idpackage) - except: + try: + # systempackage + self.cursor.execute('DELETE FROM systempackages WHERE idpackage = '+idpackage) + except: + pass + try: + # counter + self.cursor.execute('DELETE FROM counters WHERE idpackage = '+idpackage) + except: if self.dbname == "client": self.createCountersTable() - try: - # on disk sizes - self.cursor.execute('DELETE FROM sizes WHERE idpackage = '+idpackage) - except: - pass - try: - # eclasses - self.cursor.execute('DELETE FROM eclasses WHERE idpackage = '+idpackage) - except: - pass - try: - # needed - self.cursor.execute('DELETE FROM needed WHERE idpackage = '+idpackage) - except: - pass - try: - # triggers - self.cursor.execute('DELETE FROM triggers WHERE idpackage = '+idpackage) - except: - pass - try: - # inject table - self.cursor.execute('DELETE FROM injected WHERE idpackage = '+idpackage) - except: - pass - - # Remove from installedtable if exists - self.removePackageFromInstalledTable(idpackage) - # Remove from dependstable if exists - self.removePackageFromDependsTable(idpackage) - # need a final cleanup - self.packagesRemoved = True + try: + # on disk sizes + self.cursor.execute('DELETE FROM sizes WHERE idpackage = '+idpackage) + except: + pass + try: + # eclasses + self.cursor.execute('DELETE FROM eclasses WHERE idpackage = '+idpackage) + except: + pass + try: + # needed + self.cursor.execute('DELETE FROM needed WHERE idpackage = '+idpackage) + except: + pass + try: + # triggers + self.cursor.execute('DELETE FROM triggers WHERE idpackage = '+idpackage) + except: + pass + try: + # inject table + self.cursor.execute('DELETE FROM injected WHERE idpackage = '+idpackage) + except: + pass - # clear caches - dbCacheStore[etpCache['dbMatch']+self.dbname] = {} - dbCacheStore[etpCache['dbSearch']+self.dbname] = {} - # dump to be sure - dumpTools.dumpobj(etpCache['dbMatch']+self.dbname,{}) - dumpTools.dumpobj(etpCache['dbSearch']+self.dbname,{}) + # Remove from installedtable if exists + self.removePackageFromInstalledTable(idpackage) + # Remove from dependstable if exists + self.removePackageFromDependsTable(idpackage) + # need a final cleanup + self.packagesRemoved = True + + # clear caches + dbCacheStore[etpCache['dbMatch']+self.dbname] = {} + dbCacheStore[etpCache['dbSearch']+self.dbname] = {} + # dump to be sure + dumpTools.dumpobj(etpCache['dbMatch']+self.dbname,{}) + dumpTools.dumpobj(etpCache['dbSearch']+self.dbname,{}) self.clearInfoCache() - self.commitChanges() + self.commitChanges() def removeMirrorEntries(self,mirrorname): - self.cursor.execute('DELETE FROM mirrorlinks WHERE mirrorname = "'+mirrorname+'"') - self.commitChanges() + self.cursor.execute('DELETE FROM mirrorlinks WHERE mirrorname = "'+mirrorname+'"') + self.commitChanges() def addMirrors(self,mirrorname,mirrorlist): - for x in mirrorlist: - self.cursor.execute( - 'INSERT into mirrorlinks VALUES ' - '(?,?)', (mirrorname,x,) - ) - self.commitChanges() + for x in mirrorlist: + self.cursor.execute( + 'INSERT into mirrorlinks VALUES ' + '(?,?)', (mirrorname,x,) + ) + self.commitChanges() def addCategory(self,category): - self.cursor.execute( - 'INSERT into categories VALUES ' - '(NULL,?)', (category,) - ) - # get info about inserted value and return - cat = self.isCategoryAvailable(category) - if cat != -1: - self.commitChanges() - return cat + self.cursor.execute( + 'INSERT into categories VALUES ' + '(NULL,?)', (category,) + ) + # get info about inserted value and return + cat = self.isCategoryAvailable(category) + if cat != -1: + self.commitChanges() + return cat raise exceptionTools.CorruptionError("CorruptionError: I tried to insert a category but then, fetching it returned -1. There's something broken.") + self.commitChanges() def addProtect(self,protect): - self.cursor.execute( - 'INSERT into configprotectreference VALUES ' - '(NULL,?)', (protect,) - ) - # get info about inserted value and return - try: - prt = self.isProtectAvailable(protect) - except: - self.createProtectTable() - prt = self.isProtectAvailable(protect) - if prt != -1: - return prt + self.cursor.execute( + 'INSERT into configprotectreference VALUES ' + '(NULL,?)', (protect,) + ) + # get info about inserted value and return + try: + prt = self.isProtectAvailable(protect) + except: + self.createProtectTable() + prt = self.isProtectAvailable(protect) + if prt != -1: + return prt raise exceptionTools.CorruptionError("CorruptionError: I tried to insert a protect but then, fetching it returned -1. There's something broken.") + self.commitChanges() def addSource(self,source): - self.cursor.execute( - 'INSERT into sourcesreference VALUES ' - '(NULL,?)', (source,) - ) - # get info about inserted value and return - src = self.isSourceAvailable(source) - if src != -1: - return src + self.cursor.execute( + 'INSERT into sourcesreference VALUES ' + '(NULL,?)', (source,) + ) + # get info about inserted value and return + src = self.isSourceAvailable(source) + if src != -1: + return src raise exceptionTools.CorruptionError("CorruptionError: I tried to insert a source but then, fetching it returned -1. There's something broken.") + self.commitChanges() def addDependency(self,dependency): - self.cursor.execute( - 'INSERT into dependenciesreference VALUES ' - '(NULL,?)', (dependency,) - ) - # get info about inserted value and return - dep = self.isDependencyAvailable(dependency) - if dep != -1: - return dep + self.cursor.execute( + 'INSERT into dependenciesreference VALUES ' + '(NULL,?)', (dependency,) + ) + # get info about inserted value and return + dep = self.isDependencyAvailable(dependency) + if dep != -1: + return dep raise exceptionTools.CorruptionError("CorruptionError: I tried to insert a dependency but then, fetching it returned -1. There's something broken.") + self.commitChanges() def addKeyword(self,keyword): - self.cursor.execute( - 'INSERT into keywordsreference VALUES ' - '(NULL,?)', (keyword,) - ) - # get info about inserted value and return - key = self.isKeywordAvailable(keyword) - if key != -1: - return key + self.cursor.execute( + 'INSERT into keywordsreference VALUES ' + '(NULL,?)', (keyword,) + ) + # get info about inserted value and return + key = self.isKeywordAvailable(keyword) + if key != -1: + return key raise exceptionTools.CorruptionError("CorruptionError: I tried to insert a keyword but then, fetching it returned -1. There's something broken.") + self.commitChanges() def addUseflag(self,useflag): - self.cursor.execute( - 'INSERT into useflagsreference VALUES ' - '(NULL,?)', (useflag,) - ) - # get info about inserted value and return - use = self.isUseflagAvailable(useflag) - if use != -1: - return use + self.cursor.execute( + 'INSERT into useflagsreference VALUES ' + '(NULL,?)', (useflag,) + ) + # get info about inserted value and return + use = self.isUseflagAvailable(useflag) + if use != -1: + return use raise exceptionTools.CorruptionError("CorruptionError: I tried to insert a use flag but then, fetching it returned -1. There's something broken.") + self.commitChanges() def addEclass(self,eclass): - self.cursor.execute( - 'INSERT into eclassesreference VALUES ' - '(NULL,?)', (eclass,) - ) - # get info about inserted value and return - try: - myclass = self.isEclassAvailable(eclass) - except: - self.createEclassesTable() - myclass = self.isEclassAvailable(eclass) - if myclass != -1: - return myclass + self.cursor.execute( + 'INSERT into eclassesreference VALUES ' + '(NULL,?)', (eclass,) + ) + # get info about inserted value and return + try: + myclass = self.isEclassAvailable(eclass) + except: + self.createEclassesTable() + myclass = self.isEclassAvailable(eclass) + if myclass != -1: + return myclass raise exceptionTools.CorruptionError("CorruptionError: I tried to insert an eclass but then, fetching it returned -1. There's something broken.") + self.commitChanges() def addNeeded(self,needed): - self.cursor.execute( - 'INSERT into neededreference VALUES ' - '(NULL,?)', (needed,) - ) - # get info about inserted value and return - try: - myneeded = self.isNeededAvailable(needed) - except: - self.createNeededTable() - myneeded = self.isNeededAvailable(needed) - if myneeded != -1: - return myneeded + self.cursor.execute( + 'INSERT into neededreference VALUES ' + '(NULL,?)', (needed,) + ) + # get info about inserted value and return + try: + myneeded = self.isNeededAvailable(needed) + except: + self.createNeededTable() + myneeded = self.isNeededAvailable(needed) + if myneeded != -1: + return myneeded raise exceptionTools.CorruptionError("CorruptionError: I tried to insert a needed library but then, fetching it returned -1. There's something broken.") + self.commitChanges() def addLicense(self,pkglicense): if not pkglicense: pkglicense = ' ' # workaround for broken license entries - self.cursor.execute( - 'INSERT into licenses VALUES ' - '(NULL,?)', (pkglicense,) - ) - # get info about inserted value and return - lic = self.isLicenseAvailable(pkglicense) - if lic != -1: - return lic + self.cursor.execute( + 'INSERT into licenses VALUES ' + '(NULL,?)', (pkglicense,) + ) + # get info about inserted value and return + lic = self.isLicenseAvailable(pkglicense) + if lic != -1: + return lic raise exceptionTools.CorruptionError("CorruptionError: I tried to insert a license but then, fetching it returned -1. There's something broken.") + self.commitChanges() #addCompileFlags(etpData['chost'],etpData['cflags'],etpData['cxxflags']) def addCompileFlags(self,chost,cflags,cxxflags): @@ -1544,12 +1546,15 @@ class etpDatabase: if idflag != -1: return idflag raise exceptionTools.CorruptionError("CorruptionError: I tried to insert compile flags but then, fetching it returned -1. There's something broken.") + self.commitChanges() def setDigest(self, idpackage, digest): self.cursor.execute('UPDATE extrainfo SET digest = (?) WHERE idpackage = (?)', (digest,idpackage,)) - + self.commitChanges() + def setDownloadURL(self, idpackage, url): self.cursor.execute('UPDATE extrainfo SET download = (?) WHERE idpackage = (?)', (url,idpackage,)) + self.commitChanges() def setCategory(self, idpackage, category): # create new category if it doesn't exist @@ -1561,19 +1566,19 @@ class etpDatabase: self.commitChanges() def setName(self, idpackage, name): - self.cursor.execute('UPDATE baseinfo SET name = (?) WHERE idpackage = (?)', (name,idpackage,)) + self.cursor.execute('UPDATE baseinfo SET name = (?) WHERE idpackage = (?)', (name,idpackage,)) self.commitChanges() def setDependency(self, iddependency, dependency): - self.cursor.execute('UPDATE dependenciesreference SET dependency = (?) WHERE iddependency = (?)', (dependency,iddependency,)) + self.cursor.execute('UPDATE dependenciesreference SET dependency = (?) WHERE iddependency = (?)', (dependency,iddependency,)) self.commitChanges() def setAtom(self, idpackage, atom): - self.cursor.execute('UPDATE baseinfo SET atom = (?) WHERE idpackage = (?)', (atom,idpackage,)) + self.cursor.execute('UPDATE baseinfo SET atom = (?) WHERE idpackage = (?)', (atom,idpackage,)) self.commitChanges() def setSlot(self, idpackage, slot): - self.cursor.execute('UPDATE baseinfo SET slot = (?) WHERE idpackage = (?)', (slot,idpackage,)) + self.cursor.execute('UPDATE baseinfo SET slot = (?) WHERE idpackage = (?)', (slot,idpackage,)) self.commitChanges() def setCounter(self, idpackage, counter): @@ -1586,184 +1591,189 @@ class etpDatabase: 'INSERT into counters VALUES ' '(?,?)', (counter,idpackage,) ) + self.commitChanges() def cleanupUseflags(self): - self.cursor.execute('SELECT idflag FROM useflagsreference') - idflags = self.fetchall2set(self.cursor.fetchall()) - # now parse them into useflags table - orphanedFlags = idflags.copy() - - foundflags = set() - query = 'WHERE idflag = ' - counter = 0 - run = False - for idflag in idflags: - run = True - counter += 1 - query += str(idflag)+' OR idflag = ' - if counter > 25: - counter = 0 - query = query[:-13] - self.cursor.execute('SELECT idflag FROM useflags '+query) - foundflags.update(self.fetchall2set(self.cursor.fetchall())) - query = 'WHERE idflag = ' - run = False - - if (run): - query = query[:-13] - self.cursor.execute('SELECT idflag FROM useflags '+query) - foundflags.update(self.fetchall2set(self.cursor.fetchall())) - orphanedFlags.difference_update(foundflags) - - for idflag in orphanedFlags: - self.cursor.execute('DELETE FROM useflagsreference WHERE idflag ='+str(idflag)) + self.cursor.execute('SELECT idflag FROM useflagsreference') + idflags = self.fetchall2set(self.cursor.fetchall()) + # now parse them into useflags table + orphanedFlags = idflags.copy() + + foundflags = set() + query = 'WHERE idflag = ' + counter = 0 + run = False + for idflag in idflags: + run = True + counter += 1 + query += str(idflag)+' OR idflag = ' + if counter > 25: + counter = 0 + query = query[:-13] + self.cursor.execute('SELECT idflag FROM useflags '+query) + foundflags.update(self.fetchall2set(self.cursor.fetchall())) + query = 'WHERE idflag = ' + run = False + + if (run): + query = query[:-13] + self.cursor.execute('SELECT idflag FROM useflags '+query) + foundflags.update(self.fetchall2set(self.cursor.fetchall())) + orphanedFlags.difference_update(foundflags) + + for idflag in orphanedFlags: + self.cursor.execute('DELETE FROM useflagsreference WHERE idflag ='+str(idflag)) + self.commitChanges() def cleanupSources(self): - self.cursor.execute('SELECT idsource FROM sourcesreference') - idsources = self.fetchall2set(self.cursor.fetchall()) - # now parse them into useflags table - orphanedSources = idsources.copy() + self.cursor.execute('SELECT idsource FROM sourcesreference') + idsources = self.fetchall2set(self.cursor.fetchall()) + # now parse them into useflags table + orphanedSources = idsources.copy() - foundsources = set() - query = 'WHERE idsource = ' - counter = 0 - run = False - for idsource in idsources: - run = True - counter += 1 - query += str(idsource)+' OR idsource = ' - if counter > 25: - counter = 0 - query = query[:-15] - self.cursor.execute('SELECT idsource FROM sources '+query) - foundsources.update(self.fetchall2set(self.cursor.fetchall())) - query = 'WHERE idsource = ' - run = False - - if (run): - query = query[:-15] - self.cursor.execute('SELECT idsource FROM sources '+query) - foundsources.update(self.fetchall2set(self.cursor.fetchall())) - orphanedSources.difference_update(foundsources) - - for idsource in orphanedSources: - self.cursor.execute('DELETE FROM sourcesreference WHERE idsource = '+str(idsource)) + foundsources = set() + query = 'WHERE idsource = ' + counter = 0 + run = False + for idsource in idsources: + run = True + counter += 1 + query += str(idsource)+' OR idsource = ' + if counter > 25: + counter = 0 + query = query[:-15] + self.cursor.execute('SELECT idsource FROM sources '+query) + foundsources.update(self.fetchall2set(self.cursor.fetchall())) + query = 'WHERE idsource = ' + run = False + + if (run): + query = query[:-15] + self.cursor.execute('SELECT idsource FROM sources '+query) + foundsources.update(self.fetchall2set(self.cursor.fetchall())) + orphanedSources.difference_update(foundsources) + + for idsource in orphanedSources: + self.cursor.execute('DELETE FROM sourcesreference WHERE idsource = '+str(idsource)) + self.commitChanges() def cleanupEclasses(self): - self.cursor.execute('SELECT idclass FROM eclassesreference') - idclasses = self.fetchall2set(self.cursor.fetchall()) - # now parse them into useflags table - orphanedClasses = idclasses.copy() + self.cursor.execute('SELECT idclass FROM eclassesreference') + idclasses = self.fetchall2set(self.cursor.fetchall()) + # now parse them into useflags table + orphanedClasses = idclasses.copy() - foundclasses = set() - query = 'WHERE idclass = ' - counter = 0 - run = False - for idclass in idclasses: - run = True - counter += 1 - query += str(idclass)+' OR idclass = ' - if counter > 25: - counter = 0 - query = query[:-14] - self.cursor.execute('SELECT idclass FROM eclasses '+query) - foundclasses.update(self.fetchall2set(self.cursor.fetchall())) - query = 'WHERE idclass = ' - run = False - - if (run): - query = query[:-14] - self.cursor.execute('SELECT idclass FROM eclasses '+query) - foundclasses.update(self.fetchall2set(self.cursor.fetchall())) - orphanedClasses.difference_update(foundclasses) - - for idclass in orphanedClasses: - self.cursor.execute('DELETE FROM eclassesreference WHERE idclass = '+str(idclass)) + foundclasses = set() + query = 'WHERE idclass = ' + counter = 0 + run = False + for idclass in idclasses: + run = True + counter += 1 + query += str(idclass)+' OR idclass = ' + if counter > 25: + counter = 0 + query = query[:-14] + self.cursor.execute('SELECT idclass FROM eclasses '+query) + foundclasses.update(self.fetchall2set(self.cursor.fetchall())) + query = 'WHERE idclass = ' + run = False + + if (run): + query = query[:-14] + self.cursor.execute('SELECT idclass FROM eclasses '+query) + foundclasses.update(self.fetchall2set(self.cursor.fetchall())) + orphanedClasses.difference_update(foundclasses) + + for idclass in orphanedClasses: + self.cursor.execute('DELETE FROM eclassesreference WHERE idclass = '+str(idclass)) + self.commitChanges() def cleanupNeeded(self): - self.cursor.execute('SELECT idneeded FROM neededreference') - idneededs = self.fetchall2set(self.cursor.fetchall()) - # now parse them into useflags table - orphanedNeededs = idneededs.copy() + self.cursor.execute('SELECT idneeded FROM neededreference') + idneededs = self.fetchall2set(self.cursor.fetchall()) + # now parse them into useflags table + orphanedNeededs = idneededs.copy() - foundneeded = set() - query = 'WHERE idneeded = ' - counter = 0 - run = False - for idneeded in idneededs: - run = True - counter += 1 - query += str(idneeded)+' OR idneeded = ' - if counter > 25: - counter = 0 - query = query[:-15] - self.cursor.execute('SELECT idneeded FROM needed '+query) - foundneeded.update(self.fetchall2set(self.cursor.fetchall())) - query = 'WHERE idneeded = ' - run = False - - if (run): - query = query[:-15] - self.cursor.execute('SELECT idneeded FROM needed '+query) - foundneeded.update(self.fetchall2set(self.cursor.fetchall())) - orphanedNeededs.difference_update(foundneeded) - - for idneeded in orphanedNeededs: - self.cursor.execute('DELETE FROM neededreference WHERE idneeded = '+str(idneeded)) + foundneeded = set() + query = 'WHERE idneeded = ' + counter = 0 + run = False + for idneeded in idneededs: + run = True + counter += 1 + query += str(idneeded)+' OR idneeded = ' + if counter > 25: + counter = 0 + query = query[:-15] + self.cursor.execute('SELECT idneeded FROM needed '+query) + foundneeded.update(self.fetchall2set(self.cursor.fetchall())) + query = 'WHERE idneeded = ' + run = False + if (run): + query = query[:-15] + self.cursor.execute('SELECT idneeded FROM needed '+query) + foundneeded.update(self.fetchall2set(self.cursor.fetchall())) + orphanedNeededs.difference_update(foundneeded) + + for idneeded in orphanedNeededs: + self.cursor.execute('DELETE FROM neededreference WHERE idneeded = '+str(idneeded)) + self.commitChanges() def cleanupDependencies(self): - self.cursor.execute('SELECT iddependency FROM dependenciesreference') - iddeps = self.fetchall2set(self.cursor.fetchall()) - # now parse them into useflags table - orphanedDeps = iddeps.copy() + self.cursor.execute('SELECT iddependency FROM dependenciesreference') + iddeps = self.fetchall2set(self.cursor.fetchall()) + # now parse them into useflags table + orphanedDeps = iddeps.copy() - founddeps = set() - query = 'WHERE iddependency = ' - counter = 0 - run = False - for iddep in iddeps: - run = True - counter += 1 - query += str(iddep)+' OR iddependency = ' - if counter > 25: - counter = 0 - query = query[:-19] - self.cursor.execute('SELECT iddependency FROM dependencies '+query) - founddeps.update(self.fetchall2set(self.cursor.fetchall())) - query = 'WHERE iddependency = ' - run = False - - if (run): - query = query[:-19] - self.cursor.execute('SELECT iddependency FROM dependencies '+query) - founddeps.update(self.fetchall2set(self.cursor.fetchall())) - orphanedDeps.difference_update(founddeps) + founddeps = set() + query = 'WHERE iddependency = ' + counter = 0 + run = False + for iddep in iddeps: + run = True + counter += 1 + query += str(iddep)+' OR iddependency = ' + if counter > 25: + counter = 0 + query = query[:-19] + self.cursor.execute('SELECT iddependency FROM dependencies '+query) + founddeps.update(self.fetchall2set(self.cursor.fetchall())) + query = 'WHERE iddependency = ' + run = False - for iddep in orphanedDeps: - self.cursor.execute('DELETE FROM dependenciesreference WHERE iddependency = '+str(iddep)) + if (run): + query = query[:-19] + self.cursor.execute('SELECT iddependency FROM dependencies '+query) + founddeps.update(self.fetchall2set(self.cursor.fetchall())) + orphanedDeps.difference_update(founddeps) + + for iddep in orphanedDeps: + self.cursor.execute('DELETE FROM dependenciesreference WHERE iddependency = '+str(iddep)) + self.commitChanges() def getIDPackage(self, atom, branch = etpConst['branch']): - self.cursor.execute('SELECT "IDPACKAGE" FROM baseinfo WHERE atom = "'+atom+'" AND branch = "'+branch+'"') - idpackage = -1 + self.cursor.execute('SELECT "IDPACKAGE" FROM baseinfo WHERE atom = "'+atom+'" AND branch = "'+branch+'"') + idpackage = -1 idpackage = self.cursor.fetchone() if idpackage: idpackage = idpackage[0] else: idpackage = -1 - return idpackage + return idpackage def getIDPackageFromFileInBranch(self, file, branch = "unstable"): - self.cursor.execute('SELECT idpackage FROM content WHERE file = "'+file+'"') - idpackages = [] - for row in self.cursor: - idpackages.append(row[0]) - result = [] - for pkg in idpackages: - self.cursor.execute('SELECT idpackage FROM baseinfo WHERE idpackage = "'+str(pkg)+'" and branch = "'+branch+'"') - for row in self.cursor: - result.append(row[0]) - return result + self.cursor.execute('SELECT idpackage FROM content WHERE file = "'+file+'"') + idpackages = [] + for row in self.cursor: + idpackages.append(row[0]) + result = [] + for pkg in idpackages: + self.cursor.execute('SELECT idpackage FROM baseinfo WHERE idpackage = "'+str(pkg)+'" and branch = "'+branch+'"') + for row in self.cursor: + result.append(row[0]) + return result def getIDPackagesFromFile(self, file): self.cursor.execute('SELECT idpackage FROM content WHERE file = "'+file+'"') @@ -2034,6 +2044,7 @@ class etpDatabase: except: self.createTreeupdatesTable() self.cursor.execute('INSERT INTO treeupdates VALUES (?,?)', (repository,digest,)) + self.commitChanges() def addRepositoryUpdatesActions(self, repository, actions): for command in actions: @@ -3280,19 +3291,23 @@ class etpDatabase: def createContentIndex(self): if self.dbname != "etpdb" and self.indexing: self.cursor.execute('CREATE INDEX IF NOT EXISTS contentindex ON content ( file )') + self.commitChanges() def createBaseinfoIndex(self): if self.dbname != "etpdb" and self.indexing: self.cursor.execute('CREATE INDEX IF NOT EXISTS baseindex ON baseinfo ( idpackage, atom, name, version, slot, branch, revision )') + self.commitChanges() def createDependenciesIndex(self): if self.dbname != "etpdb" and self.indexing: self.cursor.execute('CREATE INDEX IF NOT EXISTS dependenciesindex ON dependencies ( idpackage, iddependency )') self.cursor.execute('CREATE INDEX IF NOT EXISTS dependenciesreferenceindex ON dependenciesreference ( iddependency, dependency )') + self.commitChanges() def createExtrainfoIndex(self): if self.dbname != "etpdb" and self.indexing: self.cursor.execute('CREATE INDEX IF NOT EXISTS extrainfoindex ON extrainfo ( idpackage, description, homepage, download, digest, datecreation, size )') + self.commitChanges() def regenerateCountersTable(self, output = False): self.createCountersTable() @@ -3325,6 +3340,7 @@ class etpDatabase: except: if output: print "Attention: counter for atom "+str(myatom)+" is duplicated. Ignoring." continue # don't trust counters, they might not be unique + self.commitChanges() def clearTreeupdatesEntries(self, repository): # treeupdates @@ -3332,6 +3348,7 @@ class etpDatabase: self.cursor.execute("DELETE FROM treeupdates WHERE repository = (?)", (repository,)) except: self.createTreeupdatesTable() + self.commitChanges() # # FIXME: remove these when 1.0 will be out @@ -3437,7 +3454,6 @@ class etpDatabase: if (match[0] != -1): self.addDependRelationToDependsTable(iddep,match[0]) del depends - # now validate dependstable self.sanitizeDependsTable() @@ -3480,6 +3496,8 @@ class etpDatabase: # check if package.mask need it masked for atom in etpConst['packagemasking']['mask']: matches = self.atomMatch(atom, multiMatch = True, packagesFilter = False) + if matches[1] != 0: + continue if idpackage in matches[0]: # sorry, masked idpackageValidatorCache[(idpackage,reponame)] = -1 @@ -3500,6 +3518,8 @@ class etpDatabase: # see if we can unmask by just lookin into package.unmask stuff -> etpConst['packagemasking']['unmask'] for atom in etpConst['packagemasking']['unmask']: matches = self.atomMatch(atom, multiMatch = True, packagesFilter = False) + if matches[1] != 0: + continue if idpackage in matches[0]: idpackageValidatorCache[(idpackage,reponame)] = idpackage return idpackage @@ -3514,6 +3534,8 @@ class etpDatabase: if atom == "*": # all packages in this repo with keyword "keyword" are ok return idpackage matches = self.atomMatch(atom, multiMatch = True, packagesFilter = False) + if matches[1] != 0: + continue if idpackage in matches[0]: idpackageValidatorCache[(idpackage,reponame)] = idpackage return idpackage @@ -3529,6 +3551,8 @@ class etpDatabase: for atom in keyword_data: # match atom matches = self.atomMatch(atom, multiMatch = True, packagesFilter = False) + if matches[1] != 0: + continue if idpackage in matches[0]: # valid! idpackageValidatorCache[(idpackage,reponame)] = idpackage diff --git a/libraries/entropyTools.py b/libraries/entropyTools.py index 79dfc6cc3..e1305e341 100644 --- a/libraries/entropyTools.py +++ b/libraries/entropyTools.py @@ -1462,7 +1462,7 @@ def quickpkg(pkgdata, dirpath, edb = True, portdbPath = None, fake = False, comp # convert path into utf8 path = string_to_utf8(path) if path == None: - path.decode("utf8") # will raise the exception + path.decode("utf-8") # will raise the exception # otherwise, force it raise Exception, "something is broken here!" try: @@ -2126,7 +2126,7 @@ def string_to_utf8(string): # try utf8 try: - newstring = string.decode("utf8").encode(sys.getfilesystemencoding()) + newstring = string.decode("utf-8").encode(sys.getfilesystemencoding()) done = True except: pass @@ -2134,7 +2134,7 @@ def string_to_utf8(string): return newstring try: - newstring = string.encode("utf8").decode(sys.getfilesystemencoding()) + newstring = string.encode("utf-8").decode(sys.getfilesystemencoding()) done = True except: pass @@ -2167,10 +2167,10 @@ def listToUtf8(mylist): mynewlist = [] for item in mylist: try: - mynewlist.append(item.decode("utf8")) + mynewlist.append(item.decode("utf-8")) except UnicodeDecodeError: try: - mynewlist.append(item.decode("latin1").decode("utf8")) + mynewlist.append(item.decode("latin1").decode("utf-8")) except: raise return mynewlist diff --git a/libraries/smartTools.py b/libraries/smartTools.py index a1d63663c..10dcdce46 100644 --- a/libraries/smartTools.py +++ b/libraries/smartTools.py @@ -24,16 +24,15 @@ import shutil from entropyConstants import * from clientConstants import * from outputTools import * -import entropyTools import equoTools import uiTools -from databaseTools import openClientDatabase, openRepositoryDatabase, openGenericDatabase -Equo = equoTools.Equo() +from databaseTools import openGenericDatabase +Equo = equoTools.EquoInterface() def smart(options): # check if I am root - if (not entropyTools.isRoot()): + if (not Equo.entropyTools.isRoot()): print_error(red("You are not ")+bold("root")+red(".")) return 1 @@ -92,7 +91,7 @@ def QuickpkgHandler(mypackages, savedir = None): packages.append(match) else: if not etpUi['quiet']: print_warning(darkred(" * ")+red("Cannot find: ")+bold(opt)) - packages = entropyTools.filterDuplicatedEntries(packages) + packages = Equo.entropyTools.filterDuplicatedEntries(packages) if (not packages): print_error(darkred(" * ")+red("No valid packages specified.")) return 2 @@ -108,13 +107,13 @@ def QuickpkgHandler(mypackages, savedir = None): print_info(brown("\t[")+red("from:")+bold("installed")+brown("]")+" - "+atom) if (not etpUi['quiet']) or (etpUi['ask']): - rc = entropyTools.askquestion(">> Would you like to recompose the selected packages ?") + rc = Equo.entropyTools.askquestion(">> Would you like to recompose the selected packages ?") if rc == "No": return 0 for pkg in packages: if not etpUi['quiet']: print_info(brown(" * ")+red("Compressing: ")+darkgreen(pkgInfo[pkg])) - resultfile = entropyTools.quickpkg(pkgdata = pkgData[pkg], dirpath = savedir) + resultfile = Equo.entropyTools.quickpkg(pkgdata = pkgData[pkg], dirpath = savedir) if resultfile == None: if not etpUi['quiet']: print_error(darkred(" * ")+red("Error creating package for: ")+bold(pkgInfo[pkg])+darkred(". Cannot continue.")) return 3 @@ -143,7 +142,7 @@ def CommonFlate(mytbz2s, action, savedir = None): for tbz2 in mytbz2s: #print_info(brown(" * ")+darkred("Analyzing: ")+tbz2) - if not (os.path.isfile(tbz2) and tbz2.endswith(".tbz2") and entropyTools.isEntropyTbz2(tbz2)): + if not (os.path.isfile(tbz2) and tbz2.endswith(".tbz2") and Equo.entropyTools.isEntropyTbz2(tbz2)): print_error(darkred(" * ")+bold(tbz2)+red(" is not a valid tbz2")) return 1 @@ -168,19 +167,19 @@ def InflateHandler(mytbz2s, savedir): etptbz2path = savedir+"/"+os.path.basename(tbz2) if os.path.realpath(tbz2) != os.path.realpath(etptbz2path): # can convert a file without copying shutil.copy2(tbz2,etptbz2path) - mydata = entropyTools.extractPkgData(etptbz2path) + mydata = Equo.entropyTools.extractPkgData(etptbz2path) # append arbitrary revision mydata['revision'] = 9999 # create temp database - dbpath = etpConst['packagestmpdir']+"/"+str(entropyTools.getRandomNumber()) + dbpath = etpConst['packagestmpdir']+"/"+str(Equo.entropyTools.getRandomNumber()) while os.path.isfile(dbpath): - dbpath = etpConst['packagestmpdir']+"/"+str(entropyTools.getRandomNumber()) + dbpath = etpConst['packagestmpdir']+"/"+str(Equo.entropyTools.getRandomNumber()) # create mydbconn = openGenericDatabase(dbpath) mydbconn.initializeDatabase() mydbconn.addPackage(mydata, revision = mydata['revision']) mydbconn.closeDB() - entropyTools.aggregateEdb(tbz2file = etptbz2path, dbfile = dbpath) + Equo.entropyTools.aggregateEdb(tbz2file = etptbz2path, dbfile = dbpath) os.remove(dbpath) print_info(darkgreen(" * ")+darkred("Inflated package: ")+etptbz2path) @@ -191,9 +190,9 @@ def DeflateHandler(mytbz2s, savedir): # analyze files for tbz2 in mytbz2s: print_info(darkgreen(" * ")+darkred("Deflating: ")+tbz2, back = True) - mytbz2 = entropyTools.removeEdb(tbz2,savedir) + mytbz2 = Equo.entropyTools.removeEdb(tbz2,savedir) tbz2name = os.path.basename(mytbz2)[:-5] # remove .tbz2 - tbz2name = entropyTools.remove_tag(tbz2name)+".tbz2" + tbz2name = Equo.entropyTools.remove_tag(tbz2name)+".tbz2" newtbz2 = os.path.dirname(mytbz2)+"/"+tbz2name print_info(darkgreen(" * ")+darkred("Deflated package: ")+newtbz2) @@ -208,7 +207,7 @@ def ExtractHandler(mytbz2s, savedir): if os.path.isfile(dbpath): os.remove(dbpath) # extract - out = entropyTools.extractEdb(tbz2,dbpath = dbpath) + out = Equo.entropyTools.extractEdb(tbz2,dbpath = dbpath) print_info(darkgreen(" * ")+darkred("Extracted Entropy metadata from: ")+out) return 0 @@ -226,7 +225,7 @@ def smartPackagesHandler(mypackages): packages.append(match) else: print_warning(darkred(" * ")+red("Cannot find: ")+bold(opt)) - packages = entropyTools.filterDuplicatedEntries(packages) + packages = Equo.entropyTools.filterDuplicatedEntries(packages) if (not packages): print_error(darkred(" * ")+red("No valid packages specified.")) return 2 @@ -235,13 +234,12 @@ def smartPackagesHandler(mypackages): print_info(darkgreen(" * ")+red("This is the list of the packages that would be merged into a single one:")) pkgInfo = {} for pkg in packages: - dbconn = openRepositoryDatabase(pkg[1]) + dbconn = Equo.openRepositoryDatabase(pkg[1]) atom = dbconn.retrieveAtom(pkg[0]) pkgInfo[pkg] = atom print_info(brown("\t[")+red("from:")+pkg[1]+brown("]")+" - "+atom) - dbconn.closeDB() - rc = entropyTools.askquestion(">> Would you like to create the packages above ?") + rc = Equo.entropyTools.askquestion(">> Would you like to create the packages above ?") if rc == "No": return 0 @@ -259,7 +257,7 @@ def smartpackagegenerator(matchedPackages): fetchdata = [] matchedAtoms = {} for x in matchedPackages: - xdbconn = openRepositoryDatabase(x[1]) + xdbconn = Equo.openRepositoryDatabase(x[1]) matchedAtoms[x] = {} xatom = xdbconn.retrieveAtom(x[0]) xdownload = xdbconn.retrieveDownloadURL(x[0]) @@ -268,16 +266,15 @@ def smartpackagegenerator(matchedPackages): matchedAtoms[x]['download'] = xdownload matchedAtoms[x]['revision'] = xrevision fetchdata.append([xatom,x]) - xdbconn.closeDB() # run installPackages with onlyfetch rc = uiTools.installPackages(atomsdata = fetchdata, deps = False, onlyfetch = True) if rc[1] != 0: return rc[0] # create unpack dir and unpack all packages - unpackdir = etpConst['entropyunpackdir']+"/smartpackage-"+str(entropyTools.getRandomNumber()) + unpackdir = etpConst['entropyunpackdir']+"/smartpackage-"+str(Equo.entropyTools.getRandomNumber()) while os.path.isdir(unpackdir): - unpackdir = etpConst['entropyunpackdir']+"/smartpackage-"+str(entropyTools.getRandomNumber()) + unpackdir = etpConst['entropyunpackdir']+"/smartpackage-"+str(Equo.entropyTools.getRandomNumber()) if os.path.isdir(unpackdir): shutil.rmtree(unpackdir) os.makedirs(unpackdir) @@ -291,7 +288,7 @@ def smartpackagegenerator(matchedPackages): tmpdbfile = dbfile+"--readingdata" for package in matchedPackages: print_info(darkgreen(" * ")+brown(matchedAtoms[package]['atom'])+": "+red("collecting Entropy metadata")) - entropyTools.extractEdb(etpConst['entropyworkdir']+"/"+matchedAtoms[package]['download'],tmpdbfile) + Equo.entropyTools.extractEdb(etpConst['entropyworkdir']+"/"+matchedAtoms[package]['download'],tmpdbfile) # read db and add data to mergeDbconn mydbconn = openGenericDatabase(tmpdbfile) idpackages = mydbconn.listAllIdpackages() @@ -300,7 +297,7 @@ def smartpackagegenerator(matchedPackages): data = mydbconn.getPackageData(myidpackage) if len(idpackages) == 1: # just a plain package that would like to become smart - xpakdata = entropyTools.readXpak(etpConst['entropyworkdir']+"/"+matchedAtoms[package]['download']) + xpakdata = Equo.entropyTools.readXpak(etpConst['entropyworkdir']+"/"+matchedAtoms[package]['download']) else: xpakdata = mydbconn.retrieveXpakMetadata(myidpackage) # already a smart package # add @@ -316,7 +313,7 @@ def smartpackagegenerator(matchedPackages): # merge packages for package in matchedPackages: print_info(darkgreen(" * ")+brown(matchedAtoms[package]['atom'])+": "+red("unpacking content")) - rc = entropyTools.uncompressTarBz2(etpConst['entropyworkdir']+"/"+matchedAtoms[x]['download'], extractPath = unpackdir+"/content") + rc = Equo.entropyTools.uncompressTarBz2(etpConst['entropyworkdir']+"/"+matchedAtoms[x]['download'], extractPath = unpackdir+"/content") if rc != 0: print_error(darkred(" * ")+red("Unpack failed due to unknown reasons.")) return rc @@ -328,7 +325,7 @@ def smartpackagegenerator(matchedPackages): for x in matchedAtoms: atoms.append(matchedAtoms[x]['atom'].split("/")[1]) atoms = '+'.join(atoms) - rc = entropyTools.compressTarBz2(etpConst['smartpackagesdir']+"/"+atoms+".tbz2",unpackdir+"/content") + rc = Equo.entropyTools.compressTarBz2(etpConst['smartpackagesdir']+"/"+atoms+".tbz2",unpackdir+"/content") if rc != 0: print_error(darkred(" * ")+red("Compress failed due to unknown reasons.")) return rc @@ -337,7 +334,7 @@ def smartpackagegenerator(matchedPackages): print_error(darkred(" * ")+red("Compressed file does not exist.")) return 1 - entropyTools.aggregateEdb(etpConst['smartpackagesdir']+"/"+atoms+".tbz2",dbfile) + Equo.entropyTools.aggregateEdb(etpConst['smartpackagesdir']+"/"+atoms+".tbz2",dbfile) print_info("\t"+etpConst['smartpackagesdir']+"/"+atoms+".tbz2") shutil.rmtree(unpackdir,True) return 0 @@ -370,13 +367,12 @@ def smartappsHandler(mypackages, emptydeps = False): print_info(darkgreen(" * ")+red("This is the list of the packages that would be worked out:")) pkgInfo = {} for pkg in packages: - dbconn = openRepositoryDatabase(pkg[1]) + dbconn = Equo.openRepositoryDatabase(pkg[1]) atom = dbconn.retrieveAtom(pkg[0]) pkgInfo[pkg] = atom print_info(brown("\t[")+red("from:")+pkg[1]+red("|SMART")+brown("]")+" - "+atom) - dbconn.closeDB() - rc = entropyTools.askquestion(">> Would you like to create the packages above ?") + rc = Equo.entropyTools.askquestion(">> Would you like to create the packages above ?") if rc == "No": return 0 @@ -391,7 +387,7 @@ def smartappsHandler(mypackages, emptydeps = False): # tool that generates .tar.bz2 packages with all the binary dependencies included def smartgenerator(atomInfo, emptydeps = False): - dbconn = openRepositoryDatabase(atomInfo[1]) + dbconn = Equo.openRepositoryDatabase(atomInfo[1]) idpackage = atomInfo[0] atom = dbconn.retrieveAtom(idpackage) @@ -420,18 +416,16 @@ def smartgenerator(atomInfo, emptydeps = False): if pkgs: print_info(darkgreen(" * ")+red("This is the list of the dependencies that would be included:")) for i in pkgs: - mydbconn = openRepositoryDatabase(i[1]) + mydbconn = Equo.openRepositoryDatabase(i[1]) atom = mydbconn.retrieveAtom(i[0]) print_info(darkgreen(" (x) ")+red(atom)) - mydbconn.closeDB() fetchdata = [] fetchdata.append([atom,atomInfo]) for x in pkgs: - xdbconn = openRepositoryDatabase(x[1]) + xdbconn = Equo.openRepositoryDatabase(x[1]) xatom = xdbconn.retrieveAtom(x[0]) fetchdata.append([xatom,x]) - xdbconn.closeDB() # run installPackages with onlyfetch rc = uiTools.installPackages(atomsdata = fetchdata, deps = False, onlyfetch = True) if rc[1] != 0: @@ -445,7 +439,7 @@ def smartgenerator(atomInfo, emptydeps = False): os.makedirs(pkgtmpdir) mainBinaryPath = etpConst['packagesbindir']+"/"+pkgbranch+"/"+pkgfilename print_info(darkgreen(" * ")+red("Unpacking main package ")+bold(str(pkgfilename))) - entropyTools.uncompressTarBz2(mainBinaryPath,pkgtmpdir) # first unpack + Equo.entropyTools.uncompressTarBz2(mainBinaryPath,pkgtmpdir) # first unpack binaryExecs = [] for item in pkgcontent: @@ -461,14 +455,13 @@ def smartgenerator(atomInfo, emptydeps = False): # now uncompress all the rest for dep in pkgs: - mydbconn = openRepositoryDatabase(dep[1]) + mydbconn = Equo.openRepositoryDatabase(dep[1]) download = os.path.basename(mydbconn.retrieveDownloadURL(dep[0])) depbranch = mydbconn.retrieveBranch(dep[0]) depatom = mydbconn.retrieveAtom(dep[0]) print_info(darkgreen(" * ")+red("Unpacking dependency package ")+bold(depatom)) deppath = etpConst['packagesbindir']+"/"+depbranch+"/"+download - entropyTools.uncompressTarBz2(deppath,pkgtmpdir) # first unpack - mydbconn.closeDB() + Equo.entropyTools.uncompressTarBz2(deppath,pkgtmpdir) # first unpack # remove unwanted files (header files) @@ -560,13 +553,13 @@ def smartgenerator(atomInfo, emptydeps = False): f.flush() f.close() # now compile - entropyTools.spawnCommand("cd "+pkgtmpdir+"/ ; g++ -Wall "+item+".cc -o "+item+".exe") + Equo.entropyTools.spawnCommand("cd "+pkgtmpdir+"/ ; g++ -Wall "+item+".cc -o "+item+".exe") os.remove(pkgtmpdir+"/"+item+".cc") smartpath = etpConst['smartappsdir']+"/"+pkgname+"-"+etpConst['currentarch']+".tbz2" print_info(darkgreen(" * ")+red("Compressing smart application: ")+bold(atom)) print_info("\t"+smartpath) - entropyTools.compressTarBz2(smartpath,pkgtmpdir+"/") + Equo.entropyTools.compressTarBz2(smartpath,pkgtmpdir+"/") shutil.rmtree(pkgtmpdir,True) return 0 \ No newline at end of file diff --git a/spritz/src/entropyapi.py b/spritz/src/entropyapi.py index 6316e265a..b27bbced7 100644 --- a/spritz/src/entropyapi.py +++ b/spritz/src/entropyapi.py @@ -32,7 +32,7 @@ import repositoriesTools import remoteTools import cacheTools import equoTools -Equo = equoTools.Equo() +Equo = equoTools.EquoInterface() '''