From 4b60008ffd80a17cfef6d6c8ed14e7546f4f285e Mon Sep 17 00:00:00 2001 From: "(no author)" <(no author)@cd1c1023-2f26-0410-ae45-c471fc1f0318> Date: Mon, 5 Nov 2007 01:49:05 +0000 Subject: [PATCH] some bugfixes git-svn-id: http://svn.sabayonlinux.org/projects/entropy/trunk@610 cd1c1023-2f26-0410-ae45-c471fc1f0318 --- client/confTools.py | 8 ++ client/equoTools.py | 143 ++++++++++++++++----- client/queryTools.py | 2 +- libraries/databaseTools.py | 255 +++++++++++++++++++++++++++---------- libraries/dumpTools.py | 9 +- libraries/remoteTools.py | 7 +- 6 files changed, 317 insertions(+), 107 deletions(-) diff --git a/client/confTools.py b/client/confTools.py index acdaf6b3f..fc7e065fc 100644 --- a/client/confTools.py +++ b/client/confTools.py @@ -402,6 +402,10 @@ def generatedict(filepath): if (not mydict['automerge']): # is it trivial? try: + if os.path.islink(filepath): + # if it's broken, skip diff and automerge + if not os.path.exists(filepath): + return mydict result = commands.getoutput('diff -Nua '+filepath+' '+tofilepath+' | grep "^[+-][^+-]" | grep -v \'# .Header:.*\'') if not result: mydict['automerge'] = True @@ -410,6 +414,10 @@ def generatedict(filepath): # another test if (not mydict['automerge']): try: + if os.path.islink(filepath): + # if it's broken, skip diff and automerge + if not os.path.exists(filepath): + return mydict result = os.system('diff -Bbua '+filepath+' '+tofilepath+' | egrep \'^[+-]\' | egrep -v \'^[+-][\t ]*#|^--- |^\+\+\+ \' | egrep -qv \'^[-+][\t ]*$\'') if result == 1: mydict['automerge'] = True diff --git a/client/equoTools.py b/client/equoTools.py index 0c10c3ce4..676235ef6 100644 --- a/client/equoTools.py +++ b/client/equoTools.py @@ -46,13 +46,23 @@ equoLog = logTools.LogFile(level = etpConst['equologlevel'],filename = etpConst[ def loadCaches(): print_info(darkred(" @@ ")+blue("Loading On-Disk Cache...")) # atomMatch - mycache = dumpTools.loadobj(etpCache['atomMatch']) - if isinstance(mycache, dict): - atomMatchCache = mycache.copy() + try: + mycache = dumpTools.loadobj(etpCache['atomMatch']) + if isinstance(mycache, dict): + atomMatchCache = mycache.copy() + except: + atomMatchCache = {} + dumpTools.dumpobj(etpCache['atomMatch'],{}) + # removal dependencies - mycache3 = dumpTools.loadobj(etpCache['generateDependsTree']) - if isinstance(mycache3, dict): - generateDependsTreeCache = mycache3.copy() + try: + mycache3 = dumpTools.loadobj(etpCache['generateDependsTree']) + if isinstance(mycache3, dict): + generateDependsTreeCache = mycache3.copy() + except: + generateDependsTreeCache = {} + dumpTools.dumpobj(etpCache['generateDependsTree'],{}) + def saveCaches(): dumpTools.dumpobj(etpCache['atomMatch'],atomMatchCache) @@ -708,12 +718,17 @@ def generateDependencyTree(atomInfo, emptydeps = False, deepdeps = False): treecache = {} unsatisfiedDeps = getDependencies(atomInfo) - unsatisfiedDeps, xxx = filterSatisfiedDependencies(unsatisfiedDeps, deepdeps = deepdeps) + if not emptydeps: + unsatisfiedDeps, xxx = filterSatisfiedDependencies(unsatisfiedDeps, deepdeps = deepdeps) dependenciesNotFound = [] treeview = [] tree = {} treedepth = 0 # in tree[0] are the conflicts tree[0] = [] + # tree[1] is for the requested atomInfo + tree[1] = [] + treedepth = 1 + requested = set([atomInfo]) conflicts = set() clientDbconn = openClientDatabase() @@ -733,7 +748,10 @@ def generateDependencyTree(atomInfo, emptydeps = False, deepdeps = False): # Handling conflicts if undep[0] == "!": xmatch = clientDbconn.atomMatch(undep[1:]) - conflicts.add(xmatch[0]) + if xmatch[0] != -1: + conflicts.add(xmatch[0]) + # FIXME: do I have to add its depends? + # depends = generateDependsTree([xmatch[0]) continue atom = atomMatch(undep) @@ -809,8 +827,6 @@ def generateDependencyTree(atomInfo, emptydeps = False, deepdeps = False): newtree[x] = set() for y in tree[x]: newtree[x].add(atomMatch(y)) - if (newtree[x]): - newtree[x] = filterDuplicatedEntries(newtree[x]) # now filter newtree treelength = len(newtree) @@ -832,6 +848,8 @@ def generateDependencyTree(atomInfo, emptydeps = False, deepdeps = False): newtree[0] = list(conflicts) newtree[0].sort() #print newtree[0] + # add requested + newtree[1] = requested ''' caching ''' generateDependencyTreeCache[tuple(atomInfo)] = {} @@ -851,6 +869,65 @@ def generateDependencyTree(atomInfo, emptydeps = False, deepdeps = False): def getRequiredPackages(foundAtoms, emptydeps = False, deepdeps = False, spinning = False): deptree = {} depcount = -1 + + # order foundAtoms + ''' + if len(foundAtoms) > 1: + foundAtoms = list(foundAtoms) + rc = False + + testCache = {} + + while not rc: + swap = False + for x in range(len(foundAtoms)): + pkgA = foundAtoms[x] + try: + pkgB = foundAtoms[x+1] + except: + continue + + cached = testCache.get((pkgA,pkgB)) + if cached: + print "cached" + y,z = cached['result'] + if pkgA != y: + foundAtoms[x] = y + foundAtoms[x+1] = z + swap = True + continue + + + testCache[(pkgA,pkgB)] = {} + odbconn = openRepositoryDatabase(pkgA[1]) + odeps = generateDependencyTree(pkgA, emptydeps = True) + # FIXME: remove conflict ignorance + if odeps[1] != 0: + continue + odeps[0][0] = [] # reset conflicts + for odep in odeps[0]: + br = False + #print odeps[0][0] + dlist = odeps[0][odep] + #print dlist + for y in dlist: + #print y + if y == pkgB: + print str(y)+" reverse -> "+str(pkgA) + foundAtoms[x] = pkgB + foundAtoms[x+1] = pkgA + swap = True + br = True + break + if br: break + if br: break + testCache[(pkgA,pkgB)]['result'] = (foundAtoms[x],foundAtoms[x+1]) + + + odbconn.closeDB() + if (not swap): + rc = True + ''' if spinning: atomlen = len(foundAtoms); count = 0 for atomInfo in foundAtoms: @@ -917,8 +994,8 @@ def generateDependsTree(idpackages, deep = False): treelevel = idpackages[:] tree = {} treedepth = 0 # I start from level 1 because level 0 is idpackages itself - tree[treedepth] = idpackages[:] - monotree = set(idpackages[:]) # monodimensional tree + tree[treedepth] = set(idpackages) + monotree = set(idpackages) # monodimensional tree # check if dependstable is sane before beginning rx = clientDbconn.retrieveDepends(idpackages[0]) @@ -2092,6 +2169,9 @@ def worldUpdate(ask = False, pretend = False, verbose = False, onlyfetch = False print_info(red(" @@ ")+darkred("Packages matching not available:\t\t")+bold(str(len(removedList)))) print_info(red(" @@ ")+blue("Packages matching already up to date:\t")+bold(str(len(fineList)))) + # disable collisions protection, better + etpConst['collisionprotect'] = 0 + if (updateList): print_info(red(" @@ ")+blue("Calculating queue...")) rc = installPackages(atomsdata = updateList, ask = ask, pretend = pretend, verbose = verbose, onlyfetch = onlyfetch) @@ -2154,7 +2234,7 @@ def installPackages(packages = [], atomsdata = [], ask = False, pretend = False, foundAtoms = _foundAtoms # are packages in foundAtoms? - if (len(foundAtoms) == 0): + if (not foundAtoms): print_error(red("No packages found")) return 127,-1 @@ -2254,9 +2334,8 @@ def installPackages(packages = [], atomsdata = [], ask = False, pretend = False, elif (result == -1): # no database connection print_error(red(" @@ ")+blue("Cannot find the Installed Packages Database. It's needed to accomplish dependency resolving. Try to run ")+bold("equo database generate")) return 200, -1 - for x in range(len(treepackages))[::-1]: - for z in treepackages[x]: + for z in range(len(treepackages[x]))[::-1]: if z == 0: # conflicts for a in treepackages[x][z]: @@ -2264,13 +2343,6 @@ def installPackages(packages = [], atomsdata = [], ask = False, pretend = False, else: for a in treepackages[x][z]: runQueue.append(a) - - # remove duplicates - runQueue = [x for x in runQueue if x not in foundAtoms] # needed? - - # add our requested packages at the end - for atomInfo in foundAtoms: - runQueue.append(atomInfo) downloadSize = 0 onDiskUsedSize = 0 @@ -2282,22 +2354,10 @@ def installPackages(packages = [], atomsdata = [], ask = False, pretend = False, pkgsToRemove = len(removalQueue) actionQueue = {} - if (not runQueue): + if (not runQueue) and (not removalQueue): print_error(red("Nothing to do.")) return 127,-1 - if (removalQueue): - if (ask or pretend or verbose): - print_info(red(" @@ ")+blue("These are the packages that would be ")+bold("removed")+blue(":")) - clientDbconn = openClientDatabase() - for idpackage in removalQueue: - pkgatom = clientDbconn.retrieveAtom(idpackage) - onDiskFreedSize += clientDbconn.retrieveOnDiskSize(idpackage) - installedfrom = clientDbconn.retrievePackageFromInstalledTable(idpackage) - repoinfo = red("[")+brown("from: ")+bold(installedfrom)+red("] ") - print_info(red(" ## ")+"["+red("W")+"] "+repoinfo+enlightenatom(pkgatom)) - clientDbconn.closeDB() - if (runQueue): if (ask or pretend): print_info(red(" @@ ")+blue("These are the packages that would be ")+bold("merged:")) @@ -2401,6 +2461,19 @@ def installPackages(packages = [], atomsdata = [], ask = False, pretend = False, print_info(darkred(" ##")+flags+repoinfo+enlightenatom(str(pkgatom))+"/"+str(pkgrev)+oldinfo) dbconn.closeDB() + if (removalQueue): + if (ask or pretend or verbose): + print_info(red(" @@ ")+blue("These are the packages that would be ")+bold("removed")+blue(":")) + clientDbconn = openClientDatabase() + for idpackage in removalQueue: + pkgatom = clientDbconn.retrieveAtom(idpackage) + onDiskFreedSize += clientDbconn.retrieveOnDiskSize(idpackage) + installedfrom = clientDbconn.retrievePackageFromInstalledTable(idpackage) + repoinfo = red("[")+brown("from: ")+bold(installedfrom)+red("] ") + print_info(red(" ## ")+"["+red("W")+"] "+repoinfo+enlightenatom(pkgatom)) + clientDbconn.closeDB() + + if (runQueue) or (removalQueue): # show download info print_info(red(" @@ ")+blue("Packages needing install:\t")+red(str(len(runQueue)))) print_info(red(" @@ ")+blue("Packages needing removal:\t")+red(str(pkgsToRemove))) diff --git a/client/queryTools.py b/client/queryTools.py index c2f0a4ade..207cdb150 100644 --- a/client/queryTools.py +++ b/client/queryTools.py @@ -399,7 +399,7 @@ def searchRemoval(atoms, idreturn = False, quiet = False, deep = False): choosenRemovalQueue = [] if (not quiet): print_info(red(" @@ ")+blue("Calculating removal dependencies, please wait..."), back = True) - treeview = generateDependsTree(foundAtoms,clientDbconn, deep = deep) + treeview = generateDependsTree(foundAtoms, deep = deep) treelength = len(treeview[0]) if treelength > 1: treeview = treeview[0] diff --git a/libraries/databaseTools.py b/libraries/databaseTools.py index ee6e403da..8f88b5811 100644 --- a/libraries/databaseTools.py +++ b/libraries/databaseTools.py @@ -643,19 +643,27 @@ class etpDatabase: broken1 = False dbinfo = dbCacheStore.get(etpCache['dbInfo']+self.dbname) if dbinfo == None: - dbCacheStore[etpCache['dbInfo']+self.dbname] = dumpTools.loadobj(etpCache['dbInfo']+self.dbname) - if dbCacheStore[etpCache['dbInfo']+self.dbname] == None: + try: + dbCacheStore[etpCache['dbInfo']+self.dbname] = dumpTools.loadobj(etpCache['dbInfo']+self.dbname) + if dbCacheStore[etpCache['dbInfo']+self.dbname] == None: + broken1 = True + dbCacheStore[etpCache['dbInfo']+self.dbname] = {} + except: broken1 = True - dbCacheStore[etpCache['dbInfo']+self.dbname] = {} + pass ''' database atom dependencies cache ''' dbmatch = dbCacheStore.get(etpCache['dbMatch']+self.dbname) broken2 = False if dbmatch == None: - dbCacheStore[etpCache['dbMatch']+self.dbname] = dumpTools.loadobj(etpCache['dbMatch']+self.dbname) - if dbCacheStore[etpCache['dbMatch']+self.dbname] == None: + try: + dbCacheStore[etpCache['dbMatch']+self.dbname] = dumpTools.loadobj(etpCache['dbMatch']+self.dbname) + if dbCacheStore[etpCache['dbMatch']+self.dbname] == None: + broken2 = True + dbCacheStore[etpCache['dbMatch']+self.dbname] = {} + except: broken2 = True - dbCacheStore[etpCache['dbMatch']+self.dbname] = {} + pass if (broken1 or broken2): # discard both caches @@ -1549,20 +1557,31 @@ class etpDatabase: # 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 = ' - query = query[:-13] + 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 - self.cursor.execute('SELECT idflag FROM useflags '+query) - orphanedFlags.difference_update(self.fetchall2set(self.cursor.fetchall())) + if (run): + query = query[:-13] + self.cursor.execute('SELECT idflag FROM useflags '+query) + foundflags.update(self.fetchall2set(self.cursor.fetchall())) + orphanedFlags.difference_update(foundflags) - query = 'WHERE idflag = ' for idflag in orphanedFlags: - query += str(idflag)+' OR idflag = ' - query = query[:-13] + self.cursor.execute('DELETE FROM useflagsreference WHERE idflag ='+str(idflag)) - self.cursor.execute('DELETE FROM useflagsreference '+query) # empty cursor x = self.cursor.fetchall() @@ -1572,21 +1591,32 @@ class etpDatabase: 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 = ' - query = query[:-15] + 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 - self.cursor.execute('SELECT idsource FROM sources '+query) - orphanedSources.difference_update(self.fetchall2set(self.cursor.fetchall())) + if (run): + query = query[:-15] + self.cursor.execute('SELECT idsource FROM sources '+query) + foundsources.update(self.fetchall2set(self.cursor.fetchall())) + orphanedSources.difference_update(foundsources) - query = 'WHERE idsource = ' for idsource in orphanedSources: - query += str(idsource)+' OR idsource = ' - query = query[:-15] + self.cursor.execute('DELETE FROM sourcesreference WHERE idsource = '+str(idsource)) - self.cursor.execute('DELETE FROM sourcesreference '+query) # empty cursor x = self.cursor.fetchall() @@ -1596,21 +1626,32 @@ class etpDatabase: 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 = ' - query = query[:-14] + 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 - self.cursor.execute('SELECT idclass FROM eclasses '+query) - orphanedClasses.difference_update(self.fetchall2set(self.cursor.fetchall())) + if (run): + query = query[:-14] + self.cursor.execute('SELECT idclass FROM eclasses '+query) + foundclasses.update(self.fetchall2set(self.cursor.fetchall())) + orphanedClasses.difference_update(foundclasses) - query = 'WHERE idclass = ' for idclass in orphanedClasses: - query += str(idclass)+' OR idclass = ' - query = query[:-14] + self.cursor.execute('DELETE FROM eclassesreference WHERE idclass = '+str(idclass)) - self.cursor.execute('DELETE FROM eclassesreference '+query) # empty cursor x = self.cursor.fetchall() @@ -1620,21 +1661,31 @@ class etpDatabase: 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 = ' - query = query[:-15] + 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 - self.cursor.execute('SELECT idneeded FROM needed '+query) - orphanedNeededs.difference_update(self.fetchall2set(self.cursor.fetchall())) + if (run): + query = query[:-15] + self.cursor.execute('SELECT idneeded FROM needed '+query) + foundneeded.update(self.fetchall2set(self.cursor.fetchall())) + orphanedNeededs.difference_update(foundneeded) - query = 'WHERE idneeded = ' for idneeded in orphanedNeededs: - query += str(idneeded)+' OR idneeded = ' - query = query[:-15] - - self.cursor.execute('DELETE FROM neededreference '+query) + self.cursor.execute('DELETE FROM neededreference WHERE idneeded = '+str(idneeded)) # empty cursor x = self.cursor.fetchall() @@ -1644,21 +1695,31 @@ class etpDatabase: 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 = ' - query = query[:-19] + 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 - self.cursor.execute('SELECT iddependency FROM dependencies '+query) - orphanedDeps.difference_update(self.fetchall2set(self.cursor.fetchall())) - - query = 'WHERE iddependency = ' + 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: - query += str(iddep)+' OR iddependency = ' - query = query[:-19] - - self.cursor.execute('DELETE FROM dependenciesreference '+query) + self.cursor.execute('DELETE FROM dependenciesreference WHERE iddependency = '+str(iddep)) # empty cursor x = self.cursor.fetchall() @@ -1788,11 +1849,19 @@ class etpDatabase: return data def fetchall2set(self, item): - return set(sum(tuple(item), ())) + content = set() + for x in item: + for y in x: + content.add(y) + return content def fetchall2list(self, item): - return list(sum(tuple(item), ())) - + content = [] + for x in item: + for y in x: + content.append(y) + return content + def fetchone2list(self, item): return list(item) @@ -2559,9 +2628,8 @@ class etpDatabase: if (not sanity): return -2 # table does not exist or is broken, please regenerate and re-run - iddeps = [] - self.cursor.execute('SELECT idpackage FROM dependstable,dependencies WHERE dependstable.idpackage = "'+str(idpackage)+'" and dependstable.iddependency = dependencies.iddependency') - result = self.cursor.fetchall() + self.cursor.execute('SELECT dependencies.idpackage FROM dependstable,dependencies WHERE dependstable.idpackage = "'+str(idpackage)+'" and dependstable.iddependency = dependencies.iddependency') + result = self.fetchall2set(self.cursor.fetchall()) ''' caching ''' if (self.xcache): @@ -2841,12 +2909,33 @@ class etpDatabase: idpkgs = self.fetchall2set(self.cursor.fetchall()) if not idpkgs: return () + + result = set() query = 'WHERE idpackage = ' - for idpk in idpkgs: - query += str(idpk)+' OR idpackage = ' - query = query[:-16] - self.cursor.execute('SELECT atom,idpackage FROM baseinfo '+query) - return self.cursor.fetchall() + counter = 0 + run = False + for idpkg in idpkgs: + run = True + counter += 1 + query += str(idpkg)+' OR idpackage = ' + if counter > 25: + counter = 0 + query = query[:-16] + self.cursor.execute('SELECT atom,idpackage FROM baseinfo '+query) + qry = self.cursor.fetchall() + for x in qry: + result.add(x) + query = 'WHERE idpackage = ' + run = False + + if (run): + query = query[:-16] + self.cursor.execute('SELECT atom,idpackage FROM baseinfo '+query) + qry = self.cursor.fetchall() + for x in qry: + result.add(x) + + return result def searchPackagesByName(self, keyword, sensitive = False, branch = None): dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"searchPackagesByName: called for "+keyword) @@ -2946,13 +3035,32 @@ class etpDatabase: if not iddeps: return () + result = set() query = 'WHERE iddependency = ' + counter = 0 + run = False for iddep in iddeps: + run = True + counter += 1 query += str(iddep)+' OR iddependency = ' - query = query[:-19] + if counter > 25: + counter = 0 + query = query[:-19] + self.cursor.execute('SELECT iddependency,dependency FROM dependenciesreference '+query) + qry = self.cursor.fetchall() + for x in qry: + result.add(x) + query = 'WHERE iddependency = ' + run = False - self.cursor.execute('SELECT iddependency,dependency FROM dependenciesreference '+query) - return self.cursor.fetchall() + if (run): + query = query[:-19] + self.cursor.execute('SELECT iddependency,dependency FROM dependenciesreference '+query) + qry = self.cursor.fetchall() + for x in qry: + result.add(x) + + return result def listBranchPackagesTbz2(self, branch): dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listBranchPackagesTbz2: called with "+str(branch)) @@ -2977,7 +3085,8 @@ class etpDatabase: dbLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"listAllFiles: called.") self.cursor.execute('SELECT file FROM content') if clean: - return self.fetchall2set(self.cursor.fetchall()) + x = self.fetchall2set(self.cursor.fetchall()) + return x else: return self.fetchall2list(self.cursor.fetchall()) @@ -2997,13 +3106,27 @@ class etpDatabase: if not idprotects: return () + results = set() query = 'WHERE idprotect = ' + counter = 0 + run = False for idprotect in idprotects: + run = True + counter += 1 query += str(idprotect)+' OR idprotect = ' - query = query[:-16] + if counter > 25: + counter = 0 + query = query[:-16] + self.cursor.execute('SELECT protect FROM configprotectreference '+query) + results.update(self.fetchall2set(self.cursor.fetchall())) + query = 'WHERE idprotect = ' + run = False + + if (run): + query = query[:-16] + self.cursor.execute('SELECT protect FROM configprotectreference '+query) + results.update(self.fetchall2set(self.cursor.fetchall())) - self.cursor.execute('SELECT protect FROM configprotectreference '+query) - results = self.fetchall2set(self.cursor.fetchall()) for result in results: for x in result.split(): dirs.add(x) diff --git a/libraries/dumpTools.py b/libraries/dumpTools.py index 0b48a7f24..af17b0604 100644 --- a/libraries/dumpTools.py +++ b/libraries/dumpTools.py @@ -59,11 +59,12 @@ def dumpobj(name,object): def loadobj(name): dmpfile = etpConst['dumpstoragedir']+"/"+name+".dmp" if os.path.isfile(dmpfile): - xmldoc = minidom.parse(dmpfile) - structure = xmldoc.firstChild - data = structure.childNodes[1] try: + xmldoc = minidom.parse(dmpfile) + structure = xmldoc.firstChild + data = structure.childNodes[1] x = eval(data.firstChild.data.strip()) return x except: - raise SyntaxError,"cannot eval() data" \ No newline at end of file + os.remove(dmpfile) + raise SyntaxError,"cannot load object" \ No newline at end of file diff --git a/libraries/remoteTools.py b/libraries/remoteTools.py index 2c4469119..bc690d267 100644 --- a/libraries/remoteTools.py +++ b/libraries/remoteTools.py @@ -74,9 +74,14 @@ def getRemotePackageChecksum(serverName,filename, branch): # HTTP/FTP equo/download functions ################################################### -def downloadData(url,pathToSave, bufferSize = 8192, checksum = True, showSpeed = True): +def downloadData(url, pathToSave, bufferSize = 8192, checksum = True, showSpeed = True): remoteLog.log(ETP_LOGPRI_INFO,ETP_LOGLEVEL_VERBOSE,"downloadFile: called.") + import re + # substitute tagged filenames with URL encoded code + out = re.subn('#','%23',url) + url = out[0] + # start scheduler if (showSpeed): etpFileTransfer['datatransfer'] = 0