diff --git a/client/cacheTools.py b/client/cacheTools.py index 728a47121..97f9a0b06 100644 --- a/client/cacheTools.py +++ b/client/cacheTools.py @@ -145,7 +145,7 @@ class cacheHelper(TextInterface): self.updateProgress(darkgreen("Resolving name: %s") % ( name ), importance = 0, type = "info", back = True, count = (cnt, maxlen) ) - self.equoTools.atomMatch(name) + self.Equo.atomMatch(name) maxlen = len(keys) cnt = 0 for key in keys: @@ -153,7 +153,7 @@ class cacheHelper(TextInterface): self.updateProgress(darkgreen("Resolving key: %s") % ( key ), importance = 0, type = "info", back = True, count = (cnt, maxlen) ) - self.equoTools.atomMatch(key) + self.Equo.atomMatch(key) maxlen = len(atoms) cnt = 0 for atom in atoms: @@ -161,7 +161,7 @@ class cacheHelper(TextInterface): self.updateProgress(darkgreen("Resolving atom: %s") % ( atom ), importance = 0, type = "info", back = True, count = (cnt, maxlen) ) - self.equoTools.atomMatch(atom) + self.Equo.atomMatch(atom) maxlen = len(depends) cnt = 0 for depend in depends: @@ -169,6 +169,6 @@ class cacheHelper(TextInterface): self.updateProgress(darkgreen("Resolving dependency: %s") % ( depend ), importance = 0, type = "info", back = True, count = (cnt, maxlen) ) - self.equoTools.atomMatch(depend) + self.Equo.atomMatch(depend) self.updateProgress(darkred("Dependencies filled. Flushing to disk."), importance = 2, type = "warning") self.Equo.save_cache() diff --git a/client/equo b/client/equo index 4db45cb36..ff3c647d0 100644 --- a/client/equo +++ b/client/equo @@ -142,7 +142,6 @@ def print_help(): options = sys.argv[1:] -import equoTools import entropyTools from clientConstants import * diff --git a/client/equoTools.py b/client/equoTools.py index f9b14a93c..d83fa7a2a 100644 --- a/client/equoTools.py +++ b/client/equoTools.py @@ -28,8 +28,9 @@ from entropyConstants import * from clientConstants import * from outputTools import * import remoteTools -from entropyTools import compareMd5, bytesIntoHuman, askquestion, getRandomNumber, dep_getkey, entropyCompareVersions, filterDuplicatedEntries, extractDuplicatedEntries, uncompressTarBz2, extractXpak, applicationLockCheck, countdown, isRoot, spliturl, remove_tag, dep_striptag, md5sum, allocateMaskedFile, istextfile, isnumber, extractEdb, getNewerVersion, getNewerVersionTag, unpackXpak, lifobuffer, ebeep, parallelStep -from databaseTools import openRepositoryDatabase, openClientDatabase, openGenericDatabase, fetchRepositoryIfNotAvailable, listAllAvailableBranches +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 import confTools import dumpTools import gc @@ -54,13 +55,20 @@ class Equo(TextInterface): import dumpTools self.dumpTools = dumpTools import databaseTools + self.databaseTools = databaseTools + import entropyTools + self.entropyTools = entropyTools self.indexing = indexing self.noclientdb = noclientdb self.xcache = xcache - self.clientDbconn = databaseTools.openClientDatabase(indexing = self.indexing, - generate = noclientdb, - xcache = self.xcache - ) + try: + self.clientDbconn = self.databaseTools.openClientDatabase(indexing = self.indexing, + generate = 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 load_cache(self): @@ -123,704 +131,646 @@ class Equo(TextInterface): self.dumpTools.dumpobj(dbinfo,{}) -######################################################## -#### -## Dependency handling functions -# + # tell if a new equo release is available, returns True or False + def check_equo_updates(self): + found = False + matches = self.clientDbconn.searchPackages("app-admin/equo") + if matches: + equo_match = "<="+matches[0][0] + equo_unsatisfied,x = self.filterSatisfiedDependencies([equo_match]) + del x + if equo_unsatisfied: + found = True + del matches + del equo_unsatisfied + return found -''' - @description: matches the package that user chose, using dbconnection.atomMatch searching in all available repositories. - @input atom: user choosen package name - @output: the matched selection, list: [package id,repository name] | if nothing found, returns: ( -1,1 ) - @ exit errors: - -1 => repository cannot be fetched online -''' -def atomMatch(atom, caseSentitive = True, matchSlot = None, matchBranches = (), xcache = True): + ''' + @description: matches the package that user chose, using dbconnection.atomMatch searching in all available repositories. + @input atom: user choosen package name + @output: the matched selection, list: [package id,repository name] | if nothing found, returns: ( -1,1 ) + @ exit errors: + -1 => repository cannot be fetched online + ''' + def atomMatch(self, atom, caseSentitive = True, matchSlot = None, matchBranches = ()): - if xcache: - cached = atomMatchCache.get(atom) - if cached: - if (cached['matchSlot'] == matchSlot) and (cached['matchBranches'] == matchBranches) and (cached['etpRepositories'] == etpRepositories): - return cached['result'] + if self.xcache: + cached = atomMatchCache.get(atom) + if cached: + if (cached['matchSlot'] == matchSlot) and (cached['matchBranches'] == matchBranches) and (cached['etpRepositories'] == etpRepositories): + return cached['result'] - repoResults = {} - exitErrors = {} - for repo in etpRepositories: - # sync database if not available - rc = fetchRepositoryIfNotAvailable(repo) - if (rc != 0): - exitErrors[repo] = -1 - continue - # open database - dbconn = openRepositoryDatabase(repo, xcache = xcache) - - # search - query = dbconn.atomMatch(atom, caseSensitive = caseSentitive, matchSlot = matchSlot, matchBranches = matchBranches) - #print "repo:",repo,"atom:",atom,"result:",query - if query[1] == 0: - # package found, add to our dictionary - repoResults[repo] = query[0] - - dbconn.closeDB() - del dbconn - - # handle repoResults - packageInformation = {} - - # nothing found - if not repoResults: - atomMatchCache[atom] = {} - atomMatchCache[atom]['result'] = -1,1 - atomMatchCache[atom]['matchSlot'] = matchSlot - atomMatchCache[atom]['matchBranches'] = matchBranches - atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() - return -1,1 - - elif len(repoResults) == 1: - # one result found - for repo in repoResults: - atomMatchCache[atom] = {} - atomMatchCache[atom]['result'] = repoResults[repo],repo - atomMatchCache[atom]['matchSlot'] = matchSlot - atomMatchCache[atom]['matchBranches'] = matchBranches - atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() - return repoResults[repo],repo - - elif len(repoResults) > 1: - # we have to decide which version should be taken - - # .tbz2 repos have always the precedence, so if we find them, we should second what user wants, installing his tbz2 - tbz2repos = [x for x in repoResults if x.endswith(".tbz2")] - if tbz2repos: - del tbz2repos - newrepos = repoResults.copy() - for x in newrepos: - if not x.endswith(".tbz2"): - del repoResults[x] - - # get package information for all the entries - for repo in repoResults: - - # open database - dbconn = openRepositoryDatabase(repo) - - # search - packageInformation[repo] = {} - packageInformation[repo]['version'] = dbconn.retrieveVersion(repoResults[repo]) - packageInformation[repo]['versiontag'] = dbconn.retrieveVersionTag(repoResults[repo]) - packageInformation[repo]['revision'] = dbconn.retrieveRevision(repoResults[repo]) - dbconn.closeDB() - del dbconn - - versions = [] - repoNames = [] - # compare versions - for repo in packageInformation: - repoNames.append(repo) - versions.append(packageInformation[repo]['version']) - - # found duplicates, this mean that we have to look at the revision and then, at the version tag - # if all this shait fails, get the uppest repository - # if no duplicates, we're done - #print versions - filteredVersions = filterDuplicatedEntries(versions) - if (len(versions) > len(filteredVersions)): - # there are duplicated results, fetch them - # get the newerVersion - #print versions - newerVersion = getNewerVersion(versions) - newerVersion = newerVersion[0] - # is newerVersion, the duplicated one? - duplicatedEntries = extractDuplicatedEntries(versions) - needFiltering = False - if newerVersion in duplicatedEntries: - needFiltering = True - - if (needFiltering): - # we have to decide which one is good - #print "need filtering" - # we have newerVersion - conflictingEntries = {} - for repo in packageInformation: - if packageInformation[repo]['version'] == newerVersion: - conflictingEntries[repo] = {} - #conflictingEntries[repo]['version'] = packageInformation[repo]['version'] - conflictingEntries[repo]['versiontag'] = packageInformation[repo]['versiontag'] - conflictingEntries[repo]['revision'] = packageInformation[repo]['revision'] - - # at this point compare tags - tags = [] - for repo in conflictingEntries: - tags.append(conflictingEntries[repo]['versiontag']) - newerTag = getNewerVersionTag(tags) - newerTag = newerTag[0] - - # is the chosen tag duplicated? - duplicatedTags = extractDuplicatedEntries(tags) - needFiltering = False - if newerTag in duplicatedTags: - needFiltering = True - - if (needFiltering): - #print "also tags match" - # yes, it is. we need to compare revisions - conflictingTags = {} - for repo in conflictingEntries: - if conflictingEntries[repo]['versiontag'] == newerTag: - conflictingTags[repo] = {} - #conflictingTags[repo]['version'] = conflictingEntries[repo]['version'] - #conflictingTags[repo]['versiontag'] = conflictingEntries[repo]['versiontag'] - conflictingTags[repo]['revision'] = conflictingEntries[repo]['revision'] - - #print tags - #print conflictingTags - revisions = [] - for repo in conflictingTags: - revisions.append(str(conflictingTags[repo]['revision'])) - newerRevision = max(revisions) - duplicatedRevisions = extractDuplicatedEntries(revisions) - needFiltering = False - if newerRevision in duplicatedRevisions: - needFiltering = True - - if (needFiltering): - # ok, we must get the repository with the biggest priority - #print "d'oh" - # I'm pissed off, now I get the repository name and quit - myrepoorder = list(etpRepositoriesOrder) - myrepoorder.sort() - for repository in myrepoorder: - for repo in conflictingTags: - if repository[1] == repo: - # found it, WE ARE DOOONE! - atomMatchCache[atom] = {} - atomMatchCache[atom]['result'] = repoResults[repo],repo - atomMatchCache[atom]['matchSlot'] = matchSlot - atomMatchCache[atom]['matchBranches'] = matchBranches - atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() - return repoResults[repo],repo - - else: - # we are done!!! - reponame = '' - #print conflictingTags - for x in conflictingTags: - if str(conflictingTags[x]['revision']) == str(newerRevision): - reponame = x - break - atomMatchCache[atom] = {} - atomMatchCache[atom]['result'] = repoResults[reponame],reponame - atomMatchCache[atom]['matchSlot'] = matchSlot - atomMatchCache[atom]['matchBranches'] = matchBranches - atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() - return repoResults[reponame],reponame - - else: - # we're finally done - reponame = '' - for x in conflictingEntries: - if conflictingEntries[x]['versiontag'] == newerTag: - reponame = x - break - atomMatchCache[atom] = {} - atomMatchCache[atom]['result'] = repoResults[reponame],reponame - atomMatchCache[atom]['matchSlot'] = matchSlot - atomMatchCache[atom]['matchBranches'] = matchBranches - atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() - return repoResults[reponame],reponame - - else: - # we are fine, the newerVersion is not one of the duplicated ones - reponame = '' - for x in packageInformation: - if packageInformation[x]['version'] == newerVersion: - reponame = x - break - atomMatchCache[atom] = {} - atomMatchCache[atom]['result'] = repoResults[reponame],reponame - atomMatchCache[atom]['matchSlot'] = matchSlot - atomMatchCache[atom]['matchBranches'] = matchBranches - atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() - return repoResults[reponame],reponame - - #print versions - - else: - # yeah, we're done, just return the info - #print versions - newerVersion = getNewerVersion(versions) - # get the repository name - newerVersion = newerVersion[0] - reponame = '' - for x in packageInformation: - if packageInformation[x]['version'] == newerVersion: - reponame = x - break - #print reponame - atomMatchCache[atom] = {} - atomMatchCache[atom]['result'] = repoResults[reponame],reponame - atomMatchCache[atom]['matchSlot'] = matchSlot - atomMatchCache[atom]['matchBranches'] = matchBranches - atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() - return repoResults[reponame],reponame - - -''' - @description: generates the dependencies of a [id,repository name] combo. - @input packageInfo: tuple composed by int(id) and str(repository name), if this one is int(0), the client database will be opened. - @output: ordered dependency list -''' -# FIXME: move this to database? -def getDependencies(packageInfo): - - ''' caching ''' - cached = getDependenciesCache.get(tuple(packageInfo)) - if cached: - return cached['result'] - - idpackage = packageInfo[0] - reponame = packageInfo[1] - if reponame == 0: - dbconn = openClientDatabase() - else: - dbconn = openRepositoryDatabase(reponame) - - # retrieve dependencies - depend = dbconn.retrieveDependencies(idpackage) - # and conflicts - conflicts = dbconn.retrieveConflicts(idpackage) - for x in conflicts: - depend.add("!"+x) - dbconn.closeDB() - del dbconn - - ''' caching ''' - getDependenciesCache[tuple(packageInfo)] = {} - getDependenciesCache[tuple(packageInfo)]['result'] = depend - - return depend - -''' - @description: filter the already installed dependencies - @input dependencies: list of dependencies to check - @output: filtered list, aka the needed ones and the ones satisfied -''' -def filterSatisfiedDependencies(dependencies, deepdeps = False): - - unsatisfiedDeps = set() - satisfiedDeps = set() - # now create a list with the unsatisfied ones - # query the installed packages database - #print etpConst['etpdatabaseclientfilepath'] - clientDbconn = openClientDatabase() - for dependency in dependencies: - - depsatisfied = set() - depunsatisfied = set() - - ''' caching ''' - cached = filterSatisfiedDependenciesCache.get(dependency) - if cached: - if (cached['deepdeps'] == deepdeps): - unsatisfiedDeps.update(cached['depunsatisfied']) - satisfiedDeps.update(cached['depsatisfied']) + repoResults = {} + exitErrors = {} + for repo in etpRepositories: + # sync database if not available + rc = self.databaseTools.fetchRepositoryIfNotAvailable(repo) + if (rc != 0): + exitErrors[repo] = -1 continue + # open database + dbconn = self.databaseTools.openRepositoryDatabase(repo, xcache = self.xcache) - ### conflict - if dependency[0] == "!": - testdep = dependency[1:] - xmatch = clientDbconn.atomMatch(testdep) - if xmatch[0] != -1: - unsatisfiedDeps.add(dependency) - else: - satisfiedDeps.add(dependency) - continue + # search + query = dbconn.atomMatch(atom, caseSensitive = caseSentitive, matchSlot = matchSlot, matchBranches = matchBranches) + #print "repo:",repo,"atom:",atom,"result:",query + if query[1] == 0: + # package found, add to our dictionary + repoResults[repo] = query[0] - repoMatch = atomMatch(dependency) - if repoMatch[0] != -1: - dbconn = openRepositoryDatabase(repoMatch[1]) - repo_pkgver = dbconn.retrieveVersion(repoMatch[0]) - repo_pkgtag = dbconn.retrieveVersionTag(repoMatch[0]) - repo_pkgrev = dbconn.retrieveRevision(repoMatch[0]) dbconn.closeDB() del dbconn - else: - # dependency does not exist in our database - unsatisfiedDeps.add(dependency) - continue - clientMatch = clientDbconn.atomMatch(dependency) - if clientMatch[0] != -1: - - installedVer = clientDbconn.retrieveVersion(clientMatch[0]) - installedTag = clientDbconn.retrieveVersionTag(clientMatch[0]) - installedRev = clientDbconn.retrieveRevision(clientMatch[0]) - if installedRev == 9999: # any revision is fine - repo_pkgrev = 9999 - - if (deepdeps): - vcmp = entropyCompareVersions((repo_pkgver,repo_pkgtag,repo_pkgrev),(installedVer,installedTag,installedRev)) - if vcmp != 0: - filterSatisfiedDependenciesCmpResults[dependency] = vcmp - depunsatisfied.add(dependency) + # handle repoResults + packageInformation = {} + + # nothing found + if not repoResults: + atomMatchCache[atom] = {} + atomMatchCache[atom]['result'] = -1,1 + atomMatchCache[atom]['matchSlot'] = matchSlot + atomMatchCache[atom]['matchBranches'] = matchBranches + atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() + return -1,1 + + elif len(repoResults) == 1: + # one result found + for repo in repoResults: + atomMatchCache[atom] = {} + atomMatchCache[atom]['result'] = repoResults[repo],repo + atomMatchCache[atom]['matchSlot'] = matchSlot + atomMatchCache[atom]['matchBranches'] = matchBranches + atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() + return repoResults[repo],repo + + elif len(repoResults) > 1: + # we have to decide which version should be taken + + # .tbz2 repos have always the precedence, so if we find them, we should second what user wants, installing his tbz2 + tbz2repos = [x for x in repoResults if x.endswith(".tbz2")] + if tbz2repos: + del tbz2repos + newrepos = repoResults.copy() + for x in newrepos: + if not x.endswith(".tbz2"): + del repoResults[x] + + # get package information for all the entries + for repo in repoResults: + + # open database + dbconn = self.databaseTools.openRepositoryDatabase(repo, xcache = self.xcache) + # search + packageInformation[repo] = {} + packageInformation[repo]['version'] = dbconn.retrieveVersion(repoResults[repo]) + packageInformation[repo]['versiontag'] = dbconn.retrieveVersionTag(repoResults[repo]) + packageInformation[repo]['revision'] = dbconn.retrieveRevision(repoResults[repo]) + dbconn.closeDB() + del dbconn + + versions = [] + repoNames = [] + # compare versions + for repo in packageInformation: + repoNames.append(repo) + versions.append(packageInformation[repo]['version']) + + # found duplicates, this mean that we have to look at the revision and then, at the version tag + # if all this shait fails, get the uppest repository + # if no duplicates, we're done + #print versions + filteredVersions = self.entropyTools.filterDuplicatedEntries(versions) + if (len(versions) > len(filteredVersions)): + # there are duplicated results, fetch them + # get the newerVersion + #print versions + newerVersion = self.entropyTools.getNewerVersion(versions) + newerVersion = newerVersion[0] + # is newerVersion, the duplicated one? + duplicatedEntries = self.entropyTools.extractDuplicatedEntries(versions) + needFiltering = False + if newerVersion in duplicatedEntries: + needFiltering = True + + if (needFiltering): + # we have to decide which one is good + #print "need filtering" + # we have newerVersion + conflictingEntries = {} + for repo in packageInformation: + if packageInformation[repo]['version'] == newerVersion: + conflictingEntries[repo] = {} + conflictingEntries[repo]['versiontag'] = packageInformation[repo]['versiontag'] + conflictingEntries[repo]['revision'] = packageInformation[repo]['revision'] + + # at this point compare tags + tags = [] + for repo in conflictingEntries: + tags.append(conflictingEntries[repo]['versiontag']) + newerTag = self.entropyTools.getNewerVersionTag(tags) + newerTag = newerTag[0] + + # is the chosen tag duplicated? + duplicatedTags = self.entropyTools.extractDuplicatedEntries(tags) + needFiltering = False + if newerTag in duplicatedTags: + needFiltering = True + + if (needFiltering): + # yes, it is. we need to compare revisions + conflictingTags = {} + for repo in conflictingEntries: + if conflictingEntries[repo]['versiontag'] == newerTag: + conflictingTags[repo] = {} + conflictingTags[repo]['revision'] = conflictingEntries[repo]['revision'] + + revisions = [] + for repo in conflictingTags: + revisions.append(str(conflictingTags[repo]['revision'])) + newerRevision = max(revisions) + duplicatedRevisions = self.entropyTools.extractDuplicatedEntries(revisions) + needFiltering = False + if newerRevision in duplicatedRevisions: + needFiltering = True + + if (needFiltering): + # ok, we must get the repository with the biggest priority + myrepoorder = list(etpRepositoriesOrder) + myrepoorder.sort() + for repository in myrepoorder: + for repo in conflictingTags: + if repository[1] == repo: + # found it, WE ARE DOOONE! + atomMatchCache[atom] = {} + atomMatchCache[atom]['result'] = repoResults[repo],repo + atomMatchCache[atom]['matchSlot'] = matchSlot + atomMatchCache[atom]['matchBranches'] = matchBranches + atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() + return repoResults[repo],repo + else: + # we are done!!! + reponame = '' + #print conflictingTags + for x in conflictingTags: + if str(conflictingTags[x]['revision']) == str(newerRevision): + reponame = x + break + atomMatchCache[atom] = {} + atomMatchCache[atom]['result'] = repoResults[reponame],reponame + atomMatchCache[atom]['matchSlot'] = matchSlot + atomMatchCache[atom]['matchBranches'] = matchBranches + atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() + return repoResults[reponame],reponame + else: + # we're finally done + reponame = '' + for x in conflictingEntries: + if conflictingEntries[x]['versiontag'] == newerTag: + reponame = x + break + atomMatchCache[atom] = {} + atomMatchCache[atom]['result'] = repoResults[reponame],reponame + atomMatchCache[atom]['matchSlot'] = matchSlot + atomMatchCache[atom]['matchBranches'] = matchBranches + atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() + return repoResults[reponame],reponame + else: + # we are fine, the newerVersion is not one of the duplicated ones + reponame = '' + for x in packageInformation: + if packageInformation[x]['version'] == newerVersion: + reponame = x + break + atomMatchCache[atom] = {} + atomMatchCache[atom]['result'] = repoResults[reponame],reponame + atomMatchCache[atom]['matchSlot'] = matchSlot + atomMatchCache[atom]['matchBranches'] = matchBranches + atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() + return repoResults[reponame],reponame + else: + # yeah, we're done, just return the info + newerVersion = self.entropyTools.getNewerVersion(versions) + # get the repository name + newerVersion = newerVersion[0] + reponame = '' + for x in packageInformation: + if packageInformation[x]['version'] == newerVersion: + reponame = x + break + atomMatchCache[atom] = {} + atomMatchCache[atom]['result'] = repoResults[reponame],reponame + atomMatchCache[atom]['matchSlot'] = matchSlot + atomMatchCache[atom]['matchBranches'] = matchBranches + atomMatchCache[atom]['etpRepositories'] = etpRepositories.copy() + return repoResults[reponame],reponame + + ''' + @description: filter the already installed dependencies + @input dependencies: list of dependencies to check + @output: filtered list, aka the needed ones and the ones satisfied + ''' + def filterSatisfiedDependencies(self, dependencies, deepdeps = False): + + unsatisfiedDeps = set() + satisfiedDeps = set() + + for dependency in dependencies: + + depsatisfied = set() + depunsatisfied = set() + + ''' caching ''' + cached = filterSatisfiedDependenciesCache.get(dependency) + if cached: + if (cached['deepdeps'] == deepdeps): + unsatisfiedDeps.update(cached['depunsatisfied']) + satisfiedDeps.update(cached['depsatisfied']) + continue + + ### conflict + if dependency[0] == "!": + testdep = dependency[1:] + xmatch = self.clientDbconn.atomMatch(testdep) + if xmatch[0] != -1: + unsatisfiedDeps.add(dependency) + else: + satisfiedDeps.add(dependency) + continue + + repoMatch = self.atomMatch(dependency) + if repoMatch[0] != -1: + dbconn = self.databaseTools.openRepositoryDatabase(repoMatch[1]) + repo_pkgver = dbconn.retrieveVersion(repoMatch[0]) + repo_pkgtag = dbconn.retrieveVersionTag(repoMatch[0]) + repo_pkgrev = dbconn.retrieveRevision(repoMatch[0]) + dbconn.closeDB() + del dbconn + else: + # dependency does not exist in our database + unsatisfiedDeps.add(dependency) + continue + + clientMatch = self.clientDbconn.atomMatch(dependency) + if clientMatch[0] != -1: + + installedVer = self.clientDbconn.retrieveVersion(clientMatch[0]) + installedTag = self.clientDbconn.retrieveVersionTag(clientMatch[0]) + installedRev = self.clientDbconn.retrieveRevision(clientMatch[0]) + if installedRev == 9999: # any revision is fine + repo_pkgrev = 9999 + + if (deepdeps): + vcmp = self.entropyTools.entropyCompareVersions((repo_pkgver,repo_pkgtag,repo_pkgrev),(installedVer,installedTag,installedRev)) + if vcmp != 0: + filterSatisfiedDependenciesCmpResults[dependency] = vcmp + depunsatisfied.add(dependency) + else: + depsatisfied.add(dependency) else: depsatisfied.add(dependency) else: - depsatisfied.add(dependency) - else: - # not installed - filterSatisfiedDependenciesCmpResults[dependency] = 0 - depunsatisfied.add(dependency) - - - unsatisfiedDeps.update(depunsatisfied) - satisfiedDeps.update(depsatisfied) - + # not installed + filterSatisfiedDependenciesCmpResults[dependency] = 0 + depunsatisfied.add(dependency) + + unsatisfiedDeps.update(depunsatisfied) + satisfiedDeps.update(depsatisfied) + + ''' caching ''' + filterSatisfiedDependenciesCache[dependency] = {} + filterSatisfiedDependenciesCache[dependency]['depunsatisfied'] = depunsatisfied + filterSatisfiedDependenciesCache[dependency]['depsatisfied'] = depsatisfied + filterSatisfiedDependenciesCache[dependency]['deepdeps'] = deepdeps + + return unsatisfiedDeps, satisfiedDeps + + + ''' + @description: generates a dependency tree using unsatisfied dependencies + @input package: atomInfo (idpackage,reponame) + @output: dependency tree dictionary, plus status code + ''' + def generateDependencyTree(self, atomInfo, emptydeps = False, deepdeps = False, usefilter = False): + + if (not usefilter): + matchFilter.clear() + ''' caching ''' - filterSatisfiedDependenciesCache[dependency] = {} - filterSatisfiedDependenciesCache[dependency]['depunsatisfied'] = depunsatisfied - filterSatisfiedDependenciesCache[dependency]['depsatisfied'] = depsatisfied - filterSatisfiedDependenciesCache[dependency]['deepdeps'] = deepdeps + cached = generateDependencyTreeCache.get(tuple(atomInfo)) + if cached: + if (cached['emptydeps'] == emptydeps) and \ + (cached['deepdeps'] == deepdeps) and \ + (cached['usefilter'] == usefilter): + return cached['result'] + + #print atomInfo + mydbconn = self.databaseTools.openRepositoryDatabase(atomInfo[1]) + myatom = mydbconn.retrieveAtom(atomInfo[0]) + mydbconn.closeDB() + del mydbconn + + # caches + treecache = set() + matchcache = set() + keyslotcache = set() + # special events + dependenciesNotFound = set() + conflicts = set() + + mydep = (1,myatom) + mybuffer = lifobuffer() + deptree = set() + if not ((atomInfo in matchFilter) and (usefilter)): + mybuffer.push((1,myatom)) + #mytree.append((1,myatom)) + deptree.add((1,atomInfo)) + + while mydep != None: + + # already analyzed in this call + if mydep[1] in treecache: + mydep = mybuffer.pop() + continue + + # conflicts + if mydep[1][0] == "!": + xmatch = self.clientDbconn.atomMatch(mydep[1][1:]) + if xmatch[0] != -1: + conflicts.add(xmatch[0]) + mydep = mybuffer.pop() + continue + + # atom found? + match = self.atomMatch(mydep[1]) + if match[0] == -1: + dependenciesNotFound.add(mydep[1]) + mydep = mybuffer.pop() + continue + + # check if atom has been already pulled in + matchdb = self.databaseTools.openRepositoryDatabase(match[1]) + matchatom = matchdb.retrieveAtom(match[0]) + matchslot = matchdb.retrieveSlot(match[0]) # used later + matchdb.closeDB() + del matchdb + if matchatom in treecache: + mydep = mybuffer.pop() + continue + else: + treecache.add(matchatom) + + treecache.add(mydep[1]) + + # check if key + slot has been already pulled in + key = self.entropyTools.dep_getkey(matchatom) + if (matchslot,key) in keyslotcache: + mydep = mybuffer.pop() + continue + else: + keyslotcache.add((matchslot,key)) - clientDbconn.closeDB() - del clientDbconn + # 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 - return unsatisfiedDeps, satisfiedDeps + matchdb = self.databaseTools.openRepositoryDatabase(match[1]) + myundeps = matchdb.retrieveDependenciesList(match[0]) + matchdb.closeDB() + del matchdb + # in this way filterSatisfiedDependenciesCmpResults is alway consistent + mytestdeps, xxx = self.filterSatisfiedDependencies(myundeps, deepdeps = deepdeps) + if (not emptydeps): + 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" + i = self.clientDbconn.atomMatch(self.entropyTools.dep_getkey(mydep[1]), matchSlot = matchslot) + if i[0] != -1: + oldneeded = self.clientDbconn.retrieveNeeded(i[0]) + if oldneeded: # if there are needed + ndbconn = self.databaseTools.openRepositoryDatabase(match[1]) + needed = ndbconn.retrieveNeeded(match[0]) + ndbconn.closeDB() + del ndbconn + oldneeded = oldneeded - needed + if oldneeded: + # reverse lookup to find belonging package + for need in oldneeded: + myidpackages = self.clientDbconn.searchNeeded(need) + for myidpackage in myidpackages: + myname = self.clientDbconn.retrieveName(myidpackage) + mycategory = self.clientDbconn.retrieveCategory(myidpackage) + myslot = self.clientDbconn.retrieveSlot(myidpackage) + mykey = mycategory+"/"+myname + mymatch = self.atomMatch(mykey, matchSlot = myslot) # search in our repo + if mymatch[0] != -1: + mydbconn = self.databaseTools.openRepositoryDatabase(mymatch[1]) + mynewatom = mydbconn.retrieveAtom(mymatch[0]) + mydbconn.closeDB() + del mydbconn + if (mymatch not in matchcache) and (mynewatom not in treecache) and (mymatch not in matchFilter): + mybuffer.push((treedepth,mynewatom)) + else: + # we bastardly ignore the missing library for now + continue -''' - @description: generates a dependency tree using unsatisfied dependencies - @input package: atomInfo (idpackage,reponame) - @output: dependency tree dictionary, plus status code -''' -def generateDependencyTree(atomInfo, emptydeps = False, deepdeps = False, usefilter = False): - - if (not usefilter): - matchFilter.clear() - - ''' caching ''' - cached = generateDependencyTreeCache.get(tuple(atomInfo)) - if cached: - if (cached['emptydeps'] == emptydeps) and \ - (cached['deepdeps'] == deepdeps) and \ - (cached['usefilter'] == usefilter): - return cached['result'] - - #print atomInfo - mydbconn = openRepositoryDatabase(atomInfo[1]) - myatom = mydbconn.retrieveAtom(atomInfo[0]) - mydbconn.closeDB() - del mydbconn - - # caches - treecache = set() - matchcache = set() - keyslotcache = set() - # special events - dependenciesNotFound = set() - conflicts = set() - - mydep = (1,myatom) - mybuffer = lifobuffer() - deptree = set() - if not ((atomInfo in matchFilter) and (usefilter)): - mybuffer.push((1,myatom)) - #mytree.append((1,myatom)) - deptree.add((1,atomInfo)) - clientDbconn = openClientDatabase() - - while mydep != None: - - # already analyzed in this call - if mydep[1] in treecache: mydep = mybuffer.pop() - continue + + newdeptree = {} + for x in deptree: + key = x[0] + item = x[1] + try: + newdeptree[key].add(item) + except: + newdeptree[key] = set() + newdeptree[key].add(item) + del deptree + + if (dependenciesNotFound): + # Houston, we've got a problem + flatview = list(dependenciesNotFound) + return flatview,-2 # conflicts - if mydep[1][0] == "!": - xmatch = clientDbconn.atomMatch(mydep[1][1:]) - if xmatch[0] != -1: - conflicts.add(xmatch[0]) - mydep = mybuffer.pop() - continue + newdeptree[0] = conflicts - # atom found? - match = atomMatch(mydep[1]) - if match[0] == -1: - dependenciesNotFound.add(mydep[1]) - mydep = mybuffer.pop() - continue + ''' caching ''' + generateDependencyTreeCache[tuple(atomInfo)] = {} + generateDependencyTreeCache[tuple(atomInfo)]['result'] = newdeptree,0 + generateDependencyTreeCache[tuple(atomInfo)]['emptydeps'] = emptydeps + generateDependencyTreeCache[tuple(atomInfo)]['deepdeps'] = deepdeps + generateDependencyTreeCache[tuple(atomInfo)]['usefilter'] = usefilter + treecache.clear() + matchcache.clear() - # check if atom has been already pulled in - matchdb = openRepositoryDatabase(match[1]) - matchatom = matchdb.retrieveAtom(match[0]) - matchslot = matchdb.retrieveSlot(match[0]) # used later - matchdb.closeDB() - del matchdb - if matchatom in treecache: - mydep = mybuffer.pop() - continue - else: - treecache.add(matchatom) + return newdeptree,0 # note: newtree[0] contains possible conflicts - treecache.add(mydep[1]) + ''' + @description: generates a list cotaining the needed dependencies of a list requested atoms + @input package: list of atoms that would be installed in list form, whose each element is composed by [idpackage,repository name] + @output: list containing, for each element: [idpackage,repository name] + @ if dependencies couldn't be satisfied, the output will be -1 + @note: this is the function that should be used for 3rd party applications after using atomMatch() + ''' + def getRequiredPackages(self, foundAtoms, emptydeps = False, deepdeps = False, spinning = False): - # check if key + slot has been already pulled in - key = dep_getkey(matchatom) - if (matchslot,key) in keyslotcache: - mydep = mybuffer.pop() - continue - else: - keyslotcache.add((matchslot,key)) + deptree = {} + deptree[0] = set() - # already analyzed by the calling function - if (match in matchFilter) and (usefilter): - mydep = mybuffer.pop() - continue - if usefilter: matchFilter.add(match) + if spinning: atomlen = len(foundAtoms); count = 0 + matchFilter.clear() # clear generateDependencyTree global filter - # result already analyzed? - if match in matchcache: - mydep = mybuffer.pop() - continue + for atomInfo in foundAtoms: - treedepth = mydep[0]+1 + if spinning: count += 1; self.updateProgress(":: "+str(round((float(count)/atomlen)*100,1))+"% ::", importance = 0, type = "info", back = True) - # all checks passed, well done - matchcache.add(match) - deptree.add((mydep[0],match)) # add match + newtree, result = self.generateDependencyTree(atomInfo, emptydeps, deepdeps, usefilter = True) - myundeps = getDependencies(match) - # in this way filterSatisfiedDependenciesCmpResults is alway consistent - mytestdeps, xxx = filterSatisfiedDependencies(myundeps, deepdeps = deepdeps) - if (not emptydeps): - myundeps = mytestdeps - for x in myundeps: - mybuffer.push((treedepth,x)) + if (result != 0): + return newtree, result + elif (newtree): + parent_keys = deptree.keys() + # add conflicts + max_parent_key = parent_keys[-1] + deptree[0].update(newtree[0]) + # reverse dict + levelcount = 0 + reversetree = {} + for key in newtree.keys()[::-1]: + if key == 0: + continue + levelcount += 1 + reversetree[levelcount] = newtree[key] + del newtree + for mylevel in reversetree.keys(): + deptree[max_parent_key+mylevel] = reversetree[mylevel].copy() + del reversetree - # 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" - i = clientDbconn.atomMatch(dep_getkey(mydep[1]), matchSlot = matchslot) - if i[0] != -1: - oldneeded = clientDbconn.retrieveNeeded(i[0]) - if oldneeded: # if there are needed - ndbconn = openRepositoryDatabase(match[1]) - needed = ndbconn.retrieveNeeded(match[0]) - ndbconn.closeDB() - del ndbconn - oldneeded = oldneeded - needed - if oldneeded: - # reverse lookup to find belonging package - for need in oldneeded: - myidpackages = clientDbconn.searchNeeded(need) - for myidpackage in myidpackages: - myname = clientDbconn.retrieveName(myidpackage) - mycategory = clientDbconn.retrieveCategory(myidpackage) - myslot = clientDbconn.retrieveSlot(myidpackage) - mykey = mycategory+"/"+myname - mymatch = atomMatch(mykey, matchSlot = myslot) # search in our repo - if mymatch[0] != -1: - mydbconn = openRepositoryDatabase(mymatch[1]) - mynewatom = mydbconn.retrieveAtom(mymatch[0]) - mydbconn.closeDB() - del mydbconn - if (mymatch not in matchcache) and (mynewatom not in treecache) and (mymatch not in matchFilter): - mybuffer.push((treedepth,mynewatom)) - else: - # we bastardly ignore the missing library for now - continue + matchFilter.clear() + return deptree,0 - mydep = mybuffer.pop() + ''' + @description: generates a depends tree using provided idpackages (from client database) + !!! you can see it as the function that generates the removal tree + @input package: idpackages list + @output: depends tree dictionary, plus status code + ''' + def generateDependsTree(self, idpackages, deep = False): - newdeptree = {} - for x in deptree: - key = x[0] - item = x[1] - try: - newdeptree[key].add(item) - except: - newdeptree[key] = set() - newdeptree[key].add(item) - del deptree - - clientDbconn.closeDB() - del clientDbconn - - if (dependenciesNotFound): - # Houston, we've got a problem - flatview = list(dependenciesNotFound) - return flatview,-2 + ''' caching ''' + cached = generateDependsTreeCache.get(tuple(idpackages)) + if cached: + if (cached['deep'] == deep): + return cached['result'] - # conflicts - newdeptree[0] = conflicts + dependscache = {} + dependsOk = False + treeview = set(idpackages) + treelevel = idpackages[:] + tree = {} + treedepth = 0 # I start from level 1 because level 0 is idpackages itself + tree[treedepth] = set(idpackages) + monotree = set(idpackages) # monodimensional tree - ''' caching ''' - generateDependencyTreeCache[tuple(atomInfo)] = {} - generateDependencyTreeCache[tuple(atomInfo)]['result'] = newdeptree,0 - generateDependencyTreeCache[tuple(atomInfo)]['emptydeps'] = emptydeps - generateDependencyTreeCache[tuple(atomInfo)]['deepdeps'] = deepdeps - generateDependencyTreeCache[tuple(atomInfo)]['usefilter'] = usefilter - treecache.clear() - matchcache.clear() - - return newdeptree,0 # note: newtree[0] contains possible conflicts + # check if dependstable is sane before beginning + rx = self.clientDbconn.retrieveDepends(idpackages[0]) + while (not dependsOk): + treedepth += 1 + tree[treedepth] = set() + for idpackage in treelevel: -''' - @description: generates a list cotaining the needed dependencies of a list requested atoms - @input package: list of atoms that would be installed in list form, whose each element is composed by [idpackage,repository name] - @output: list containing, for each element: [idpackage,repository name] - @ if dependencies couldn't be satisfied, the output will be -1 - @note: this is the function that should be used for 3rd party applications after using atomMatch() -''' -def getRequiredPackages(foundAtoms, emptydeps = False, deepdeps = False, spinning = False): - deptree = {} - deptree[0] = set() - - if spinning: atomlen = len(foundAtoms); count = 0 - matchFilter.clear() # clear generateDependencyTree global filter - for atomInfo in foundAtoms: - if spinning: count += 1; print_info(":: "+str(round((float(count)/atomlen)*100,1))+"% ::", back = True) - #print depcount - newtree, result = generateDependencyTree(atomInfo, emptydeps, deepdeps, usefilter = True) - if (result != 0): - return newtree, result - elif (newtree): - parent_keys = deptree.keys() - # add conflicts - max_parent_key = parent_keys[-1] - deptree[0].update(newtree[0]) - - # reverse dict - levelcount = 0 - reversetree = {} - for key in newtree.keys()[::-1]: - if key == 0: + passed = dependscache.get(idpackage,None) + systempkg = self.clientDbconn.isSystemPackage(idpackage) + if passed or systempkg: + try: + while 1: treeview.remove(idpackage) + except: + pass continue - levelcount += 1 - reversetree[levelcount] = newtree[key] - del newtree - - for mylevel in reversetree.keys(): - deptree[max_parent_key+mylevel] = reversetree[mylevel].copy() - del reversetree - matchFilter.clear() - - return deptree,0 + # obtain its depends + depends = self.clientDbconn.retrieveDepends(idpackage) + # filter already satisfied ones + depends = [x for x in depends if x not in list(monotree)] + if (depends): # something depends on idpackage + for x in depends: + if x not in tree[treedepth]: + tree[treedepth].add(x) + monotree.add(x) + treeview.add(x) + elif deep: # if deep, grab its dependencies and check + mydeps = set(self.clientDbconn.retrieveDependencies(idpackage)) + _mydeps = set() + for x in mydeps: + match = self.clientDbconn.atomMatch(x) + if match and match[1] == 0: + _mydeps.add(match[0]) + mydeps = _mydeps + # now filter them + mydeps = [x for x in mydeps if x not in list(monotree)] + for x in mydeps: + #print clientDbconn.retrieveAtom(x) + mydepends = self.clientDbconn.retrieveDepends(x) + mydepends = [y for y in mydepends if y not in list(monotree)] + if (not mydepends): + tree[treedepth].add(x) + monotree.add(x) + treeview.add(x) + dependscache[idpackage] = True + try: + while 1: treeview.remove(idpackage) + except: + pass -''' - @description: generates a depends tree using provided idpackages (from client database) - !!! you can see it as the function that generates the removal tree - @input package: idpackages list - @output: depends tree dictionary, plus status code -''' -def generateDependsTree(idpackages, deep = False): + treelevel = list(treeview)[:] + if (not treelevel): + if not tree[treedepth]: + del tree[treedepth] # probably the last one is empty then + dependsOk = True - ''' caching ''' - cached = generateDependsTreeCache.get(tuple(idpackages)) - if cached: - if (cached['deep'] == deep): - return cached['result'] + newtree = tree.copy() # tree list + if (tree): + # now filter newtree + treelength = len(newtree) + for count in range(treelength)[::-1]: + x = 0 + while x < count: + # remove dups in this list + for z in newtree[count]: + try: + while 1: + newtree[x].remove(z) + #print "removing "+str(z) + except: + pass + x += 1 - dependscache = {} - clientDbconn = openClientDatabase() + del tree - dependsOk = False - treeview = set(idpackages) - treelevel = idpackages[:] - tree = {} - treedepth = 0 # I start from level 1 because level 0 is idpackages itself - tree[treedepth] = set(idpackages) - monotree = set(idpackages) # monodimensional tree - - # check if dependstable is sane before beginning - rx = clientDbconn.retrieveDepends(idpackages[0]) - - while (not dependsOk): - treedepth += 1 - tree[treedepth] = set() - for idpackage in treelevel: - - passed = dependscache.get(idpackage,None) - systempkg = clientDbconn.isSystemPackage(idpackage) - if passed or systempkg: - try: - while 1: treeview.remove(idpackage) - except: - pass - continue - - # obtain its depends - depends = clientDbconn.retrieveDepends(idpackage) - # filter already satisfied ones - depends = [x for x in depends if x not in list(monotree)] - if (depends): # something depends on idpackage - for x in depends: - if x not in tree[treedepth]: - tree[treedepth].add(x) - monotree.add(x) - treeview.add(x) - elif deep: # if deep, grab its dependencies and check - - mydeps = set(clientDbconn.retrieveDependencies(idpackage)) - _mydeps = set() - for x in mydeps: - match = clientDbconn.atomMatch(x) - if match and match[1] == 0: - _mydeps.add(match[0]) - mydeps = _mydeps - # now filter them - mydeps = [x for x in mydeps if x not in list(monotree)] - for x in mydeps: - #print clientDbconn.retrieveAtom(x) - mydepends = clientDbconn.retrieveDepends(x) - mydepends = [y for y in mydepends if y not in list(monotree)] - if (not mydepends): - tree[treedepth].add(x) - monotree.add(x) - treeview.add(x) - - dependscache[idpackage] = True - try: - while 1: treeview.remove(idpackage) - except: - pass - - treelevel = list(treeview)[:] - if (not treelevel): - if not tree[treedepth]: - del tree[treedepth] # probably the last one is empty then - dependsOk = True - - newtree = tree.copy() # tree list - if (tree): - # now filter newtree - treelength = len(newtree) - for count in range(treelength)[::-1]: - x = 0 - while x < count: - # remove dups in this list - for z in newtree[count]: - try: - while 1: - newtree[x].remove(z) - #print "removing "+str(z) - except: - pass - x += 1 - - del tree - - clientDbconn.closeDB() - del clientDbconn - - ''' caching ''' - generateDependsTreeCache[tuple(idpackages)] = {} - generateDependsTreeCache[tuple(idpackages)]['result'] = newtree,0 - generateDependsTreeCache[tuple(idpackages)]['deep'] = deep - return newtree,0 # treeview is used to show deps while tree is used to run the dependency code. + ''' caching ''' + generateDependsTreeCache[tuple(idpackages)] = {} + generateDependsTreeCache[tuple(idpackages)]['result'] = newtree,0 + generateDependsTreeCache[tuple(idpackages)]['deep'] = deep + return newtree,0 # treeview is used to show deps while tree is used to run the dependency code. ######################################################## diff --git a/client/queryTools.py b/client/queryTools.py index 77cf70747..33f8cf2c3 100644 --- a/client/queryTools.py +++ b/client/queryTools.py @@ -478,60 +478,55 @@ def searchOrphans(): def searchRemoval(atoms, idreturn = False, deep = False): - from equoTools import generateDependsTree + import equoTools + Equo = equoTools.Equo() if (not idreturn) and (not etpUi['quiet']): print_info(darkred(" @@ ")+darkgreen("Removal 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 foundAtoms = [] for atom in atoms: - match = clientDbconn.atomMatch(atom) - if match[1] == 0: - foundAtoms.append(match[0]) + match = Equo.clientDbconn.atomMatch(atom) + if match[1] == 0: + foundAtoms.append(match[0]) # are packages in foundAtoms? if (len(foundAtoms) == 0): - print_error(red("No packages found.")) - return 127,-1 + print_error(red("No packages found.")) + return 127,-1 choosenRemovalQueue = [] if (not etpUi['quiet']): print_info(red(" @@ ")+blue("Calculating removal dependencies, please wait..."), back = True) - treeview = generateDependsTree(foundAtoms, deep = deep) + treeview = Equo.generateDependsTree(foundAtoms, deep = deep) treelength = len(treeview[0]) if treelength > 1: - treeview = treeview[0] - for x in range(treelength)[::-1]: - for y in treeview[x]: - choosenRemovalQueue.append(y) - - if (choosenRemovalQueue): - if (not etpUi['quiet']): - print_info(red(" @@ ")+blue("These are the packages that would added to the removal queue:")) - totalatoms = str(len(choosenRemovalQueue)) - atomscounter = 0 - - for idpackage in choosenRemovalQueue: - atomscounter += 1 - rematom = clientDbconn.retrieveAtom(idpackage) - if (not etpUi['quiet']): - installedfrom = clientDbconn.retrievePackageFromInstalledTable(idpackage) - repositoryInfo = bold("[")+red("from: ")+brown(installedfrom)+bold("]") - stratomscounter = str(atomscounter) - while len(stratomscounter) < len(totalatoms): - stratomscounter = " "+stratomscounter - print_info(" # "+red("(")+bold(stratomscounter)+"/"+blue(str(totalatoms))+red(")")+repositoryInfo+" "+blue(rematom)) - else: - print rematom + treeview = treeview[0] + for x in range(treelength)[::-1]: + for y in treeview[x]: + choosenRemovalQueue.append(y) + if (choosenRemovalQueue): + if (not etpUi['quiet']): + print_info(red(" @@ ")+blue("These are the packages that would added to the removal queue:")) + totalatoms = str(len(choosenRemovalQueue)) + atomscounter = 0 + + for idpackage in choosenRemovalQueue: + atomscounter += 1 + rematom = Equo.clientDbconn.retrieveAtom(idpackage) + if (not etpUi['quiet']): + installedfrom = Equo.clientDbconn.retrievePackageFromInstalledTable(idpackage) + repositoryInfo = bold("[")+red("from: ")+brown(installedfrom)+bold("]") + stratomscounter = str(atomscounter) + while len(stratomscounter) < len(totalatoms): + stratomscounter = " "+stratomscounter + print_info(" # "+red("(")+bold(stratomscounter)+"/"+blue(str(totalatoms))+red(")")+repositoryInfo+" "+blue(rematom)) + else: + print rematom if (idreturn): - return treeview - + return treeview + return 0 diff --git a/client/repositoriesTools.py b/client/repositoriesTools.py index 355400466..40a0de272 100644 --- a/client/repositoriesTools.py +++ b/client/repositoriesTools.py @@ -231,10 +231,18 @@ def syncRepositories(reponames = [], forceUpdate = False): return 128 del repoConn - rc = checkEquoUpdates() + rc = False + try: + import equoTools + Equo = equoTools.Equo() + rc = Equo.check_equo_updates() + del Equo + except: + pass + if rc: print_warning(darkred(" !! ")+blue("A new version of ")+bold("equo")+blue(" is available. Please ")+bold("install it")+blue(" before any other package.")) - + return 0 def checkEquoUpdates(): diff --git a/client/rescueTools.py b/client/rescueTools.py index 44ea9307a..3b24b2dd5 100644 --- a/client/rescueTools.py +++ b/client/rescueTools.py @@ -495,7 +495,7 @@ def pythonUpdater(): atomkey = entropyTools.dep_getkey(meta[0]) slot = clientDbconn.retrieveSlot(meta[1]) print_info(brown(" @@ ")+red("Matching ")+bold(atomkey)+red(":")+darkgreen(slot), back = True) - match = equoTools.atomMatch(atomkey, matchSlot = slot) + match = uiTools.Equo.atomMatch(atomkey, matchSlot = slot) if match[0] != -1: matchedAtoms.add((atomkey+":"+slot,match)) del atoms diff --git a/client/uiTools.py b/client/uiTools.py index 31d8b5abb..a3e569e89 100644 --- a/client/uiTools.py +++ b/client/uiTools.py @@ -29,7 +29,7 @@ from entropyConstants import * from clientConstants import * from outputTools import * import equoTools -from databaseTools import openRepositoryDatabase, openClientDatabase, openGenericDatabase, listAllAvailableBranches +from databaseTools import openRepositoryDatabase, openGenericDatabase, listAllAvailableBranches import entropyTools import dumpTools import shutil @@ -137,12 +137,6 @@ def worldUpdate(onlyfetch = False, replay = False, upgradeTo = None, resume = Fa if not (etpUi['quiet'] or returnQueue): print_warning(red("Running with ")+bold("--pretend")+red("...")) etpUi['pretend'] = True - try: - clientDbconn = openClientDatabase() - except: - if not (etpUi['quiet'] or returnQueue): print_error(red("You do not have a client database.")) - return 128,-1 - if not resume: # verify selected release (branch) @@ -164,20 +158,20 @@ def worldUpdate(onlyfetch = False, replay = False, upgradeTo = None, resume = Fa fineList = set() removedList = set() # get all the installed packages - packages = clientDbconn.listAllPackages() + packages = Equo.clientDbconn.listAllPackages() if not (etpUi['quiet'] or returnQueue): print_info(red(" @@ ")+blue("Calculating world packages...")) for package in packages: tainted = False atom = package[0] idpackage = package[1] - name = clientDbconn.retrieveName(idpackage) - category = clientDbconn.retrieveCategory(idpackage) - revision = clientDbconn.retrieveRevision(idpackage) - slot = clientDbconn.retrieveSlot(idpackage) + name = Equo.clientDbconn.retrieveName(idpackage) + category = Equo.clientDbconn.retrieveCategory(idpackage) + revision = Equo.clientDbconn.retrieveRevision(idpackage) + slot = Equo.clientDbconn.retrieveSlot(idpackage) atomkey = category+"/"+name # search in the packages - match = equoTools.atomMatch(atom) + match = Equo.atomMatch(atom) if match[0] == -1: # atom has been changed, or removed? tainted = True else: # not changed, is the revision changed? @@ -193,7 +187,7 @@ def worldUpdate(onlyfetch = False, replay = False, upgradeTo = None, resume = Fa tainted = True if (tainted): # Alice! use the key! ... and the slot - matchresults = equoTools.atomMatch(atomkey, matchSlot = slot, matchBranches = branches) + matchresults = Equo.atomMatch(atomkey, matchSlot = slot, matchBranches = branches) if matchresults[0] != -1: mdbconn = openRepositoryDatabase(matchresults[1]) matchatom = mdbconn.retrieveAtom(matchresults[0]) @@ -203,14 +197,14 @@ def worldUpdate(onlyfetch = False, replay = False, upgradeTo = None, resume = Fa else: removedList.add(idpackage) # look for packages that would match key with any slot (for eg, gcc updates), slot changes handling - matchresults = equoTools.atomMatch(atomkey, matchBranches = branches) + matchresults = Equo.atomMatch(atomkey, matchBranches = branches) if matchresults[0] != -1: mdbconn = openRepositoryDatabase(matchresults[1]) matchatom = mdbconn.retrieveAtom(matchresults[0]) mdbconn.closeDB() del mdbconn # compare versions - unsatisfied, satisfied = equoTools.filterSatisfiedDependencies((matchatom,)) + unsatisfied, satisfied = Equo.filterSatisfiedDependencies((matchatom,)) if unsatisfied: updateList.add((matchatom,matchresults)) else: @@ -275,7 +269,7 @@ def worldUpdate(onlyfetch = False, replay = False, upgradeTo = None, resume = Fa etpConst['collisionprotect'] = oldcollprotect # verify that client database idpackage still exist, validate here before passing removePackage() wrong info - removedList = [x for x in removedList if clientDbconn.isIDPackageAvailable(x)] + removedList = [x for x in removedList if Equo.clientDbconn.isIDPackageAvailable(x)] if (removedList): removedList = list(removedList) @@ -287,8 +281,6 @@ def worldUpdate(onlyfetch = False, replay = False, upgradeTo = None, resume = Fa if human: rc = entropyTools.askquestion(" Would you like to query them ?") if rc == "No": - clientDbconn.closeDB() - del clientDbconn return 0,0 # run removePackages with --nodeps @@ -299,9 +291,6 @@ def worldUpdate(onlyfetch = False, replay = False, upgradeTo = None, resume = Fa else: if not (etpUi['quiet'] or returnQueue): print_info(red(" @@ ")+blue("Nothing to remove.")) - clientDbconn.closeDB() - del clientDbconn - if returnQueue: return worldQueue,0 @@ -322,12 +311,6 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals except: pass - try: - clientDbconn = openClientDatabase() - except: - if not (etpUi['quiet'] or returnQueue): print_error(red("You do not have a client database.")) - return 128,-1 - if not resume: if (atomsdata): @@ -335,7 +318,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals else: foundAtoms = [] for package in packages: - foundAtoms.append([package,equoTools.atomMatch(package)]) + foundAtoms.append([package,Equo.atomMatch(package)]) if tbz2: for pkg in tbz2: # create a repository for each database @@ -422,15 +405,15 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals installedVer = "Not installed" installedTag = "NoTag" installedRev = "NoRev" - pkginstalled = clientDbconn.atomMatch(entropyTools.dep_getkey(pkgatom), matchSlot = pkgslot) + pkginstalled = Equo.clientDbconn.atomMatch(entropyTools.dep_getkey(pkgatom), matchSlot = pkgslot) if (pkginstalled[1] == 0): # found idx = pkginstalled[0] - installedVer = clientDbconn.retrieveVersion(idx) - installedTag = clientDbconn.retrieveVersionTag(idx) + installedVer = Equo.clientDbconn.retrieveVersion(idx) + installedTag = Equo.clientDbconn.retrieveVersionTag(idx) if not installedTag: installedTag = "NoTag" - installedRev = clientDbconn.retrieveRevision(idx) + installedRev = Equo.clientDbconn.retrieveRevision(idx) if not (etpUi['quiet'] or returnQueue): print_info(" # "+red("(")+bold(str(atomscounter))+"/"+blue(str(totalatoms))+red(")")+" "+bold(pkgatom)+" >>> "+red(etpRepositories[reponame]['description'])) if not (etpUi['quiet'] or returnQueue): print_info("\t"+red("Versioning:\t")+" "+blue(installedVer)+" / "+blue(installedTag)+" / "+blue(str(installedRev))+bold(" ===> ")+darkgreen(pkgver)+" / "+darkgreen(pkgtag)+" / "+darkgreen(str(pkgrev))) @@ -471,7 +454,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals if (deps): spinning = False if not (etpUi['quiet'] or returnQueue): spinning = True - treepackages, result = equoTools.getRequiredPackages(foundAtoms, emptydeps, deepdeps, spinning = spinning) + treepackages, result = Equo.getRequiredPackages(foundAtoms, emptydeps, deepdeps, spinning = spinning) # add dependencies, explode them if (result == -2): @@ -566,15 +549,15 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals installedVer = '0' installedTag = '' installedRev = 0 - pkginstalled = clientDbconn.atomMatch(entropyTools.dep_getkey(pkgatom), matchSlot = pkgslot) + pkginstalled = Equo.clientDbconn.atomMatch(entropyTools.dep_getkey(pkgatom), matchSlot = pkgslot) if (pkginstalled[1] == 0): # found idx = pkginstalled[0] - installedVer = clientDbconn.retrieveVersion(idx) - installedTag = clientDbconn.retrieveVersionTag(idx) - installedRev = clientDbconn.retrieveRevision(idx) + installedVer = Equo.clientDbconn.retrieveVersion(idx) + installedTag = Equo.clientDbconn.retrieveVersionTag(idx) + installedRev = Equo.clientDbconn.retrieveRevision(idx) actionQueue[pkgatom]['removeidpackage'] = idx - onDiskFreedSize += clientDbconn.retrieveOnDiskSize(idx) + onDiskFreedSize += Equo.clientDbconn.retrieveOnDiskSize(idx) if not (etpUi['ask'] or etpUi['pretend'] or etpUi['verbose']): continue @@ -626,7 +609,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals #''' if runQueue: myremmatch = {} - [myremmatch.update({(entropyTools.dep_getkey(clientDbconn.retrieveAtom(x)),clientDbconn.retrieveSlot(x)): x}) for x in removalQueue] + [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]) testtuple = (entropyTools.dep_getkey(dbconn.retrieveAtom(packageInfo[0])),dbconn.retrieveSlot(packageInfo[0])) @@ -649,12 +632,12 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals # add depends to removalQueue that are not in runQueue dependQueue = set() for idpackage in removalQueue: - depends = clientDbconn.retrieveDepends(idpackage) + depends = Equo.clientDbconn.retrieveDepends(idpackage) for depend in depends: - dependkey = clientDbconn.retrieveCategory(depend)+"/"+clientDbconn.retrieveName(depend) - dependslot = clientDbconn.retrieveSlot(depend) + dependkey = Equo.clientDbconn.retrieveCategory(depend)+"/"+Equo.clientDbconn.retrieveName(depend) + dependslot = Equo.clientDbconn.retrieveSlot(depend) # match in repositories - match = equoTools.atomMatch(dependkey, matchSlot = dependslot) + match = Equo.atomMatch(dependkey, matchSlot = dependslot) if match[0] != -1: matchdbconn = openRepositoryDatabase(match[1]) matchatom = matchdbconn.retrieveAtom(match[0]) @@ -662,7 +645,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals 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 = equoTools.atomMatch(matchatom) + mymatch = Equo.atomMatch(matchatom) print mymatch #print matchatom dependQueue.add(depend) @@ -675,9 +658,9 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals if not (etpUi['quiet'] or returnQueue): print_info(red(" @@ ")+blue("These are the packages that would be ")+bold("removed")+blue(" (conflicting/substituted):")) for idpackage in removalQueue: - pkgatom = clientDbconn.retrieveAtom(idpackage) - onDiskFreedSize += clientDbconn.retrieveOnDiskSize(idpackage) - installedfrom = clientDbconn.retrievePackageFromInstalledTable(idpackage) + pkgatom = Equo.clientDbconn.retrieveAtom(idpackage) + onDiskFreedSize += Equo.clientDbconn.retrieveOnDiskSize(idpackage) + installedfrom = Equo.clientDbconn.retrievePackageFromInstalledTable(idpackage) repoinfo = red("[")+brown("from: ")+bold(installedfrom)+red("] ") if not (etpUi['quiet'] or returnQueue): print_info(red(" ## ")+"["+red("W")+"] "+repoinfo+enlightenatom(pkgatom)) @@ -747,7 +730,7 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals rdbconn.closeDB() del rdbconn for rconflict in rconflicts: - rmatch = clientDbconn.atomMatch(rconflict) + rmatch = Equo.clientDbconn.atomMatch(rconflict) if rmatch[0] != -1: rconflicts_match.add(rmatch[0]) removalQueue = [x for x in rconflicts_match] @@ -822,8 +805,6 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals for step in steps: rc = equoTools.stepExecutor(step,infoDict,str(fetchqueue)+"/"+totalqueue) if (rc != 0): - clientDbconn.closeDB() - del clientDbconn dirscleanup() return -1,rc @@ -837,15 +818,15 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals for idpackage in removalQueue: currentremovalqueue += 1 infoDict = {} - infoDict['removeatom'] = clientDbconn.retrieveAtom(idpackage) + infoDict['removeatom'] = Equo.clientDbconn.retrieveAtom(idpackage) infoDict['removeidpackage'] = idpackage infoDict['diffremoval'] = False infoDict['removeconfig'] = True # we need to completely wipe configuration of conflicts if not returnQueue: # must be loaded manually - infoDict['removecontent'] = clientDbconn.retrieveContent(idpackage) - etpRemovalTriggers[infoDict['removeatom']] = clientDbconn.getPackageData(idpackage) + infoDict['removecontent'] = Equo.clientDbconn.retrieveContent(idpackage) + etpRemovalTriggers[infoDict['removeatom']] = Equo.clientDbconn.getPackageData(idpackage) etpRemovalTriggers[infoDict['removeatom']]['removecontent'] = infoDict['removecontent'].copy() - etpRemovalTriggers[infoDict['removeatom']]['trigger'] = clientDbconn.retrieveTrigger(idpackage) + etpRemovalTriggers[infoDict['removeatom']]['trigger'] = Equo.clientDbconn.retrieveTrigger(idpackage) steps = [] steps.append("preremove") steps.append("remove") @@ -864,8 +845,6 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals for step in steps: rc = equoTools.stepExecutor(step,infoDict,str(currentremovalqueue)+"/"+totalremovalqueue) if (rc != 0): - clientDbconn.closeDB() - del clientDbconn dirscleanup() return -1,rc @@ -899,18 +878,18 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals # differential remove list if (actionQueue[pkgatom]['removeidpackage'] != -1): # is it still available? - if clientDbconn.isIDPackageAvailable(actionQueue[pkgatom]['removeidpackage']): + if Equo.clientDbconn.isIDPackageAvailable(actionQueue[pkgatom]['removeidpackage']): actionQueue[pkgatom]['diffremoval'] = True - actionQueue[pkgatom]['removeatom'] = clientDbconn.retrieveAtom(actionQueue[pkgatom]['removeidpackage']) + actionQueue[pkgatom]['removeatom'] = Equo.clientDbconn.retrieveAtom(actionQueue[pkgatom]['removeidpackage']) if not returnQueue: # must be loaded manually - oldcontent = clientDbconn.retrieveContent(actionQueue[pkgatom]['removeidpackage']) + oldcontent = Equo.clientDbconn.retrieveContent(actionQueue[pkgatom]['removeidpackage']) newcontent = dbconn.retrieveContent(idpackage) oldcontent = oldcontent - newcontent del newcontent actionQueue[pkgatom]['removecontent'] = oldcontent.copy() - etpRemovalTriggers[actionQueue[pkgatom]['removeatom']] = clientDbconn.getPackageData(actionQueue[pkgatom]['removeidpackage']) + etpRemovalTriggers[actionQueue[pkgatom]['removeatom']] = Equo.clientDbconn.getPackageData(actionQueue[pkgatom]['removeidpackage']) etpRemovalTriggers[actionQueue[pkgatom]['removeatom']]['removecontent'] = actionQueue[pkgatom]['removecontent'].copy() - etpRemovalTriggers[actionQueue[pkgatom]['removeatom']]['trigger'] = clientDbconn.retrieveTrigger(actionQueue[pkgatom]['removeidpackage']) + etpRemovalTriggers[actionQueue[pkgatom]['removeatom']]['trigger'] = Equo.clientDbconn.retrieveTrigger(actionQueue[pkgatom]['removeidpackage']) else: actionQueue[pkgatom]['removeidpackage'] = -1 @@ -981,8 +960,6 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals for step in steps: rc = equoTools.stepExecutor(step,actionQueue[pkgatom],str(currentqueue)+"/"+totalqueue) if (rc != 0): - clientDbconn.closeDB() - del clientDbconn dirscleanup() return -1,rc @@ -1010,8 +987,6 @@ def installPackages(packages = [], atomsdata = [], deps = True, emptydeps = Fals # clear resume information dumpTools.dumpobj(etpCache['install'],{}) - clientDbconn.closeDB() - del clientDbconn dirscleanup() if returnQueue: @@ -1027,21 +1002,15 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys if not (etpUi['quiet'] or returnQueue): print_warning(red("Running with ")+bold("--pretend")+red("...")) etpUi['pretend'] = True - try: - clientDbconn = openClientDatabase() - except: - if not (etpUi['quiet'] or returnQueue): print_error(red("You do not have a client database.")) - return 128,-1 - if not resume: foundAtoms = [] if (atomsdata): for idpackage in atomsdata: - foundAtoms.append([clientDbconn.retrieveAtom(idpackage),(idpackage,0)]) + foundAtoms.append([Equo.clientDbconn.retrieveAtom(idpackage),(idpackage,0)]) else: for package in packages: - foundAtoms.append([package,clientDbconn.atomMatch(package)]) + foundAtoms.append([package,Equo.clientDbconn.atomMatch(package)]) # filter packages not found _foundAtoms = [] @@ -1069,19 +1038,19 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys for atomInfo in foundAtoms: atomscounter += 1 idpackage = atomInfo[0] - systemPackage = clientDbconn.isSystemPackage(idpackage) + systemPackage = Equo.clientDbconn.isSystemPackage(idpackage) # get needed info - pkgatom = clientDbconn.retrieveAtom(idpackage) - installedfrom = clientDbconn.retrievePackageFromInstalledTable(idpackage) + pkgatom = Equo.clientDbconn.retrieveAtom(idpackage) + installedfrom = Equo.clientDbconn.retrievePackageFromInstalledTable(idpackage) if (systemPackage) and (systemPackagesCheck): # check if the package is slotted and exist more than one installed first - sysresults = clientDbconn.atomMatch(entropyTools.dep_getkey(pkgatom), multiMatch = True) + sysresults = Equo.clientDbconn.atomMatch(entropyTools.dep_getkey(pkgatom), multiMatch = True) slots = set() if sysresults[1] == 0: for x in sysresults[0]: - slots.add(clientDbconn.retrieveSlot(x)) + slots.add(Equo.clientDbconn.retrieveSlot(x)) if len(slots) < 2: if not (etpUi['quiet'] or returnQueue): print_warning(darkred(" # !!! ")+red("(")+brown(str(atomscounter))+"/"+blue(str(totalatoms))+red(")")+" "+enlightenatom(pkgatom)+red(" is a vital package. Removal forbidden.")) continue @@ -1107,8 +1076,6 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys if rc == "No": lookForOrphanedPackages = False if (not deps): - clientDbconn.closeDB() - del clientDbconn return 0,0 if (not plainRemovalQueue): @@ -1120,7 +1087,7 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys if (lookForOrphanedPackages): choosenRemovalQueue = [] if not (etpUi['quiet'] or returnQueue): print_info(red(" @@ ")+blue("Calculating...")) - treeview = equoTools.generateDependsTree(plainRemovalQueue, deep = deep) + treeview = Equo.generateDependsTree(plainRemovalQueue, deep = deep) treelength = len(treeview[0]) if treelength > 1: treeview = treeview[0] @@ -1135,8 +1102,8 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys for idpackage in choosenRemovalQueue: atomscounter += 1 - rematom = clientDbconn.retrieveAtom(idpackage) - installedfrom = clientDbconn.retrievePackageFromInstalledTable(idpackage) + rematom = Equo.clientDbconn.retrieveAtom(idpackage) + installedfrom = Equo.clientDbconn.retrievePackageFromInstalledTable(idpackage) repositoryInfo = bold("[")+red("from: ")+brown(installedfrom)+bold("]") stratomscounter = str(atomscounter) while len(stratomscounter) < len(totalatoms): @@ -1154,8 +1121,6 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys question = " Would you like to proceed with a selective removal ?" rc = entropyTools.askquestion(question) if rc == "No": - clientDbconn.closeDB() - del clientDbconn return 0,0 elif (deps): if not (etpUi['quiet'] or returnQueue): entropyTools.countdown(what = red(" @@ ")+blue("Starting removal in "),back = True) @@ -1191,7 +1156,7 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys invalid = set() for idpackage in removalQueue: try: - clientDbconn.retrieveAtom(idpackage) + Equo.clientDbconn.retrieveAtom(idpackage) except TypeError: invalid.add(idpackage) removalQueue = [x for x in removalQueue if x not in invalid] @@ -1208,13 +1173,13 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys infoDict = {} infoDict['removeidpackage'] = idpackage try: - infoDict['removeatom'] = clientDbconn.retrieveAtom(idpackage) + infoDict['removeatom'] = Equo.clientDbconn.retrieveAtom(idpackage) except TypeError: # resume cache issues? try: # force database removal and forget about the rest if not (etpUi['quiet'] or returnQueue): print "DEBUG: attention! entry broken probably due to a resume cache issue, forcing removal from database" - clientDbconn.removePackage(idpackage) - clientDbconn.removePackageFromInstalledTable(idpackage) + Equo.clientDbconn.removePackage(idpackage) + Equo.clientDbconn.removePackageFromInstalledTable(idpackage) except: pass # update resume cache @@ -1226,10 +1191,10 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys infoDict['removeconfig'] = configFiles if not returnQueue: # must be loaded manually - infoDict['removecontent'] = clientDbconn.retrieveContent(idpackage) - etpRemovalTriggers[infoDict['removeatom']] = clientDbconn.getPackageData(idpackage) + infoDict['removecontent'] = Equo.clientDbconn.retrieveContent(idpackage) + etpRemovalTriggers[infoDict['removeatom']] = Equo.clientDbconn.getPackageData(idpackage) etpRemovalTriggers[infoDict['removeatom']]['removecontent'] = infoDict['removecontent'].copy() - etpRemovalTriggers[infoDict['removeatom']]['trigger'] = clientDbconn.retrieveTrigger(idpackage) + etpRemovalTriggers[infoDict['removeatom']]['trigger'] = Equo.clientDbconn.retrieveTrigger(idpackage) steps = [] steps.append("preremove") @@ -1260,8 +1225,6 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys for step in steps: rc = equoTools.stepExecutor(step,infoDict,str(currentqueue)+"/"+str(len(removalQueue))) if (rc != 0): - clientDbconn.closeDB() - del clientDbconn return -1,rc # update resume cache @@ -1274,9 +1237,6 @@ def removePackages(packages = [], atomsdata = [], deps = True, deep = False, sys if not (etpUi['quiet'] or returnQueue): print_info(red(" @@ ")+blue("All done.")) - clientDbconn.closeDB() - del clientDbconn - if returnQueue: return returnActionQueue,0 @@ -1288,10 +1248,8 @@ def dependenciesTest(clientDbconn = None, reagent = False): if (not etpUi['quiet']): print_info(red(" @@ ")+blue("Running dependency test...")) - closedb = True if clientDbconn == None: - closedb = False - clientDbconn = openClientDatabase() + clientDbconn = Equo.clientDbconn # get all the installed packages installedPackages = clientDbconn.listAllIdpackages() @@ -1305,7 +1263,8 @@ def dependenciesTest(clientDbconn = None, reagent = False): if (not etpUi['quiet']): print_info(darkred(" @@ ")+bold("(")+blue(str(count))+"/"+red(length)+bold(")")+darkgreen(" Checking ")+bold(atom), back = True) - xdeps = equoTools.getDependencies((xidpackage,0)) + + xdeps = clientDbconn.retrieveDependenciesList(xidpackage) needed_deps = set() for xdep in xdeps: if xdep[0] == "!": # filter conflicts @@ -1330,7 +1289,7 @@ def dependenciesTest(clientDbconn = None, reagent = False): if reagent: match = clientDbconn.atomMatch(dep) else: - match = equoTools.atomMatch(dep) + match = Equo.atomMatch(dep) if match[0] == -1: # FIXME if (not etpUi['quiet']): @@ -1351,16 +1310,12 @@ def dependenciesTest(clientDbconn = None, reagent = False): packagesNeeded.add((depatom,dep)) if (etpUi['pretend']): - clientDbconn.closeDB() - del clientDbconn 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": - clientDbconn.closeDB() - del clientDbconn return 0,packagesNeeded else: print_info(red(" @@ ")+blue("Installing available packages in ")+red("10 seconds")+blue("...")) @@ -1374,9 +1329,6 @@ def dependenciesTest(clientDbconn = None, reagent = False): installPackages(packages, deps = False) if not etpUi['quiet']: print_info(red(" @@ ")+blue("All done.")) - if closedb: - clientDbconn.closeDB() - del clientDbconn return 0,packagesNeeded def librariesTest(clientDbconn = None, reagent = False, listfiles = False): @@ -1389,10 +1341,8 @@ def librariesTest(clientDbconn = None, reagent = False, listfiles = False): if (not etpUi['quiet']): print_info(red(" @@ ")+blue("Running libraries test...")) - closedb = True if clientDbconn == None: - closedb = False - clientDbconn = openClientDatabase() + clientDbconn = Equo.clientDbconn if (not etpUi['quiet']): print_info(red(" @@ ")+blue("Collecting linker paths...")) @@ -1519,21 +1469,15 @@ def librariesTest(clientDbconn = None, reagent = False, listfiles = False): print myatom dbconn.closeDB() del dbconn - clientDbconn.closeDB() - del clientDbconn return 0,atomsdata if (etpUi['pretend']): - clientDbconn.closeDB() - del clientDbconn return 0,atomsdata if (atomsdata) and (not reagent): if (etpUi['ask']): rc = entropyTools.askquestion(" Would you like to install them?") if rc == "No": - clientDbconn.closeDB() - del clientDbconn return 0,atomsdata else: print_info(red(" @@ ")+blue("Installing found packages in ")+red("10 seconds")+blue("...")) @@ -1542,15 +1486,9 @@ def librariesTest(clientDbconn = None, reagent = False, listfiles = False): entropyTools.applicationLockCheck("install") rc = installPackages(atomsdata = list(atomsdata)) - if closedb: - clientDbconn.closeDB() - del clientDbconn if rc[0] == 0: return 0,atomsdata else: return rc[0],atomsdata - if closedb: - clientDbconn.closeDB() - del clientDbconn return 0,atomsdata diff --git a/libraries/databaseTools.py b/libraries/databaseTools.py index 75176ec27..7ecec7f16 100644 --- a/libraries/databaseTools.py +++ b/libraries/databaseTools.py @@ -2310,6 +2310,20 @@ class etpDatabase: self.storeInfoCache(idpackage,'retrieveProvide',provide) return provide + def retrieveDependenciesList(self, idpackage): + + cache = self.fetchInfoCache(idpackage,'retrieveDependenciesList') + if cache != None: return cache + + deps = self.retrieveDependencies(idpackage) + conflicts = self.retrieveConflicts(idpackage) + for x in conflicts: + deps.add("!"+x) + del conflicts + + self.storeInfoCache(idpackage,'retrieveDependenciesList',deps) + return deps + def retrieveDependencies(self, idpackage): cache = self.fetchInfoCache(idpackage,'retrieveDependencies') diff --git a/libraries/entropyConstants.py b/libraries/entropyConstants.py index a04e556d4..5ffd55a6d 100644 --- a/libraries/entropyConstants.py +++ b/libraries/entropyConstants.py @@ -398,7 +398,6 @@ generateDependsTreeCache = {} idpackageValidatorCache = {} filterSatisfiedDependenciesCache = {} filterSatisfiedDependenciesCmpResults = {} -getDependenciesCache = {} generateDependencyTreeCache = {} ververifyCache = {} isjustnameCache = {} @@ -428,7 +427,6 @@ def const_resetCache(): idpackageValidatorCache.clear() filterSatisfiedDependenciesCache.clear() filterSatisfiedDependenciesCmpResults.clear() - getDependenciesCache.clear() generateDependencyTreeCache.clear() ververifyCache.clear() isjustnameCache.clear() diff --git a/libraries/smartTools.py b/libraries/smartTools.py index cfbb55791..a1d63663c 100644 --- a/libraries/smartTools.py +++ b/libraries/smartTools.py @@ -28,6 +28,7 @@ import entropyTools import equoTools import uiTools from databaseTools import openClientDatabase, openRepositoryDatabase, openGenericDatabase +Equo = equoTools.Equo() def smart(options): @@ -84,10 +85,9 @@ def QuickpkgHandler(mypackages, savedir = None): print_error(darkred(" * ")+red("--savedir ")+savedir+red(" does not exist.")) return 4 - clientDbconn = openClientDatabase() packages = [] for opt in mypackages: - match = clientDbconn.atomMatch(opt) + match = Equo.clientDbconn.atomMatch(opt) if match[0] != -1: packages.append(match) else: @@ -102,9 +102,9 @@ def QuickpkgHandler(mypackages, savedir = None): pkgInfo = {} pkgData = {} for pkg in packages: - atom = clientDbconn.retrieveAtom(pkg[0]) + atom = Equo.clientDbconn.retrieveAtom(pkg[0]) pkgInfo[pkg] = atom - pkgData[pkg] = clientDbconn.getPackageData(pkg[0]) + pkgData[pkg] = Equo.clientDbconn.getPackageData(pkg[0]) print_info(brown("\t[")+red("from:")+bold("installed")+brown("]")+" - "+atom) if (not etpUi['quiet']) or (etpUi['ask']): @@ -112,8 +112,6 @@ def QuickpkgHandler(mypackages, savedir = None): if rc == "No": return 0 - clientDbconn.closeDB() - for pkg in packages: if not etpUi['quiet']: print_info(brown(" * ")+red("Compressing: ")+darkgreen(pkgInfo[pkg])) resultfile = entropyTools.quickpkg(pkgdata = pkgData[pkg], dirpath = savedir) @@ -223,7 +221,7 @@ def smartPackagesHandler(mypackages): packages = [] for opt in mypackages: - match = equoTools.atomMatch(opt) + match = Equo.atomMatch(opt) if match[0] != -1: packages.append(match) else: @@ -358,7 +356,7 @@ def smartappsHandler(mypackages, emptydeps = False): packages = set() for opt in mypackages: - match = equoTools.atomMatch(opt) + match = Equo.atomMatch(opt) if match[0] != -1: packages.add(match) else: @@ -404,7 +402,7 @@ def smartgenerator(atomInfo, emptydeps = False): pkgfilename = os.path.basename(pkgfilepath) pkgname = pkgfilename.split(".tbz2")[0] - pkgdependencies, result = equoTools.getRequiredPackages([atomInfo], emptydeps = emptydeps) + pkgdependencies, result = Equo.getRequiredPackages([atomInfo], emptydeps = emptydeps) # flatten them pkgs = [] if (result == 0): diff --git a/spritz/src/entropyapi.py b/spritz/src/entropyapi.py index 0950e4fc1..6316e265a 100644 --- a/spritz/src/entropyapi.py +++ b/spritz/src/entropyapi.py @@ -31,6 +31,8 @@ import entropyTools import repositoriesTools import remoteTools import cacheTools +import equoTools +Equo = equoTools.Equo() ''' diff --git a/spritz/src/yumex.py b/spritz/src/yumex.py index 5da9d7b8f..d70ed9409 100755 --- a/spritz/src/yumex.py +++ b/spritz/src/yumex.py @@ -42,7 +42,7 @@ from yumgui import * # yumex imports import filters -from entropyapi import GuiRepositoryController, GuiCacheHelper +from entropyapi import GuiRepositoryController, GuiCacheHelper, Equo from gui import YumexGUI from dialogs import * from misc import const, YumexOptions, YumexProfile @@ -425,6 +425,7 @@ class YumexApplication(YumexController,YumexGUI): self.firstTime = True #self.addPackages() self.setPage('repos') + self.Equo = Equo def startWorking(self): self.isWorking = True @@ -579,7 +580,7 @@ class YumexApplication(YumexController,YumexGUI): else: self.progress.set_mainLabel(_('Repositories updated successfully.')) self.progressLog(_('Repositories updated successfully.')) - rc = repositoriesTools.checkEquoUpdates() + rc = self.Equo.check_equo_updates() if rc: self.progressLog(_('A new "equo" release is available. Please update it before any other package.')) else: