Viewing file:  repomdRepo.py (12.66 KB) -rwxr-xr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
#!/usr/bin/python
import os
import sys
import time
import glob
import gzip
import string
import urllib
import xmlrpclib
import cStringIO
import time
import rpm
import yumBaseRepo
#sys.path.append("/usr/share/rhn/")
from up2date_client import rpmSource
from up2date_client import rpmSourceUtils
from up2date_client import rhnChannel
from up2date_client import repoDirector
from up2date_client import rpmUtils
from up2date_client import config
from up2date_client import rpcServer
from up2date_client import up2dateUtils
from up2date_client import up2dateLog
import genericRepo
import urlUtils
import genericSolveDep
import urlgrabber
class YumBaseWrapper:
def __init__(self, arches=None):
# singleton of yumBase
self.yb = yumBaseRepo.YumBaseRepo()
self.yb.doConfigSetup()
self.yb.doRepoSetup()
# FIXME, figure this out on the fly
self.yb.doSackSetup()
self.log = up2dateLog.initLog()
self.yb.up2date_log = self.log.log_me
class RepomdSolveDep(genericSolveDep.GenericSolveDep, YumBaseWrapper):
def __init__(self):
genericSolveDep.GenericSolveDep.__init__(self)
self.type = "repomd"
self.repoCreated = None
def initRepo(self):
if not self.repoCreated:
YumBaseWrapper.__init__(self)
self.repoCreated = 1
# insert code to actually solve the dep by looking
# though the package sack code to see what packags
# solve a given dep
def getSolutions(self, unknowns, msgCallback=None, progressCallback=None):
self.initRepo()
channels = rhnChannel.getChannels()
repoChannels = channels.getByType(self.type)
channelNames = []
repoPackages = []
for channel in repoChannels:
channelNames.append(channel['label'])
for pkg in self.availList:
if pkg[6] in channelNames:
repoPackages.append(pkg)
solutions = {}
unknownsCopy = unknowns[:]
for unknown in unknowns:
provs = self.yb.pkgSack.searchProvides(unknown)
for prov in provs:
if not solutions.has_key(unknown):
solutions[unknown] = []
nevra = prov.returnNevraTuple()
epoch = nevra[1]
if epoch == '0':
epoch = ""
solutions[unknown] = [ [nevra[0], nevra[2], nevra[3], epoch, nevra[4], prov.returnSimple("packagesize"), prov.repoid ]]
try:
unknownsCopy.remove(unknown)
except ValueError:
# already removed from list
pass
if len(unknownsCopy) == 0:
break
self.retDict = solutions
def process(current, total, name):
# sys.stdout.write('\r' + ' ' * 80)
sys.stdout.write('\rNode %d of %d %s' % (current, total, name))
sys.stdout.flush()
class RepomdRepoSource(rpmSource.PackageSource, YumBaseWrapper):
def __init__(self, proxyHost=None,
loginInfo=None, cacheObject=None,
register=None):
self.cfg = config.initUp2dateConfig()
rpmSource.PackageSource.__init__(self, cacheObject = cacheObject)
self._loginInfo=loginInfo
self.headerCache = cacheObject
self.pkglists = {}
self.repoCreated = None
def initRepo(self):
print "initRepo"
log = up2dateLog.initLog()
log.trace_me()
if not self.repoCreated:
YumBaseWrapper.__init__(self)
self.repoCreated = 1
def listPackages(self, channel,
msgCallback = None, progressCallback = None):
# change config to read yum configs,
# create approriate channels,
# then sparse down the big lsit into
# up2date style channels
self.initRepo()
repos = self.yb.repos.listEnabled()
#FIXME
self.yb.doSackSetup()
pkgs = self.yb.pkgSack.returnPackages()
pkglist = []
for pkg in pkgs:
pkglist.append([pkg.name, pkg.version, pkg.release, pkg.epoch, pkg.arch, 0, pkg.repoid])
self.pkglists[channel['label']] = pkglist
return pkglist
def genObsoleteTupleFromPackageObject(self, packageObject):
pkg = packageObject
epoch = pkg.epoch or ""
name = pkg.name
version = pkg.name
release = pkg.release
arch = pkg.arch
obs = []
for obsTup in pkg.prco['obsoletes']:
obsName = obsTup[0]
obsVers = obsTup[2]
obsFlags = obsTup[1]
obs.append([name, version, release, epoch, arch,
obsName, obsVers, obsFlags])
# print "obs: %s" % obs
return obs
def getObsoletes(self, channel, msgCallback = None,
progressCallback = None):
self.initRepo()
if msgCallback:
msgCallback("Fetching obsoletes list for %s" % channel['url'])
obsList = []
total = len(self.yb.pkgSack.nevra)
count = 0
for key in self.yb.pkgSack.obsoletes.keys():
pkgs = self.yb.pkgSack.obsoletes[key]
for pkg in pkgs:
obs = self.genObsoleteTupleFromPackageObject(pkg)
if obs:
obsList = obsList + obs
return []
def getHeader(self, package, msgCallback = None,
progressCallback = None):
self.initRepo()
# print "package: %s" % (package,)
remoteFilename = "%s-%s-%s.%s.rpm" % (package[0], package[1], package[2],
package[4])
if msgCallback:
msgCallback(filename)
channels = rhnChannel.getChannels()
channel = channels.getByLabel(package[6])
#url = "%s/RPMS/%s" % (channel['url'],remoteFilename )
if msgCallback:
msgCallback("Fetching %s" % url)
#print package[0], package[3], package[1], package[2], package[4]
epoch = "%s" % package[3]
if package[3] == '':
epoch = '0'
pkgs = self.yb.pkgSack.searchNevra(name = package[0],
epoch = epoch,
ver = package[1],
rel = package[2],
arch = package[4])
# er...?
pkg = pkgs[0]
start = pkg.simple['hdrstart']
end = pkg.simple['hdrend']
relPath = pkg.simple['relativepath']
url = "%s/%s" % (channel['url'], relPath)
(buffer, lmtime) = urlUtils.fetchUrl(url,
progressCallback = progressCallback,
agent = "Up2date %s/Yum" % up2dateUtils.version(),
start=start, end=end)
#tmp name to write out the raw header
localFilename = "%s-%s-%s.%s.hdr" % (package[0], package[1], package[2],
package[4])
tmpfilename = "%s/%s" % (self.cfg['storageDir'], localFilename)
fd = open(tmpfilename, "w+")
fd.write(buffer)
fd.close()
hdr = rpm.readHeaderListFromFile(tmpfilename)[0]
rpmSourceUtils.saveHeader(hdr)
self.headerCache["%s-%s-%s" % (hdr['name'],
hdr['version'],
hdr['release'])] = hdr
return hdr
def getPackage(self, pkg, msgCallback = None, progressCallback = None):
self.initRepo()
filename = "%s-%s-%s.%s.rpm" % (pkg[0], pkg[1], pkg[2],
pkg[4])
channels = rhnChannel.getChannels()
channel = channels.getByLabel(pkg[6])
#print "stored rpmpath: %s" % self.pkgNamePath[(pkg[0], pkg[1], pkg[2], pkg[3], pkg[4])]
filePath = "%s/%s" % (self.cfg["storageDir"], filename)
#rpmPath = self.pkgNamePath[(pkg[0], pkg[1], pkg[2], pkg[3], pkg[4])]
epoch = "%s" % pkg[3]
if epoch == '':
epoch = '0'
label = channel['label']
pkgs = self.yb.pkgSack.searchNevra(pkg[0], epoch, pkg[1], pkg[2], pkg[4])
# er...?
pkg = pkgs[0]
relPath = pkg.simple['relativepath']
url = "%s/%s" % (channel['url'], relPath)
#print "url: %s" % url
if msgCallback:
# for now, makes it easier to debug
#msgCallback(url)
msgCallback(filename)
fd = open(filePath, "w+")
(lmtime) = urlUtils.fetchUrlAndWriteFD(url, fd,
progressCallback = progressCallback,
agent = "Up2date %s/Yum" % up2dateUtils.version())
fd.close()
buffer = open(filePath, "r").read()
return buffer
# for key in self.pkgSack.nevra.keys():
# pkgs
# since we use the diskcache secondary in yum/apt, and
# we dont know the version till after we look at the
# file, we glob for it, and use it
class RepomdDiskCache(rpmSource.PackageSource):
def __init__(self, cacheObject = None):
self.cfg = config.initUp2dateConfig()
rpmSource.PackageSource.__init__(self, cacheObject = cacheObject)
def listAllPackages(self):
pass
def getObsoletes(self):
pass
def getHeader(self):
pass
def getPackage(self):
pass
def getPackageSource(self):
pass
def listPackages(self, channel,
msgCallback = None, progressCallback = None):
globPattern = "%s/%s.*" % (self.cfg["storageDir"], channel['label'])
lists = glob.glob(globPattern)
# FIXME?
# we could sort and find the oldest, but there should
# only be one
if len(lists):
localFilename = lists[0]
else:
# for now, fix PackageSourceChain to not freak
# when everything returns None
return 0
# FIXME error handling and what not
f = open(localFilename, "r")
filecontents = f.read()
# bump it full
if progressCallback:
progressCallback(100,100)
tmp_args, tmp_method = xmlrpclib.loads(filecontents)
# tmp_args[0] is the list of packages
return tmp_args[0]
class RepomdRepo(genericRepo.GenericRepo):
def __init__(self):
self.login = None
genericRepo.GenericRepo.__init__(self)
self.rmdrs = RepomdRepoSource()
self.rmdss = RepomdDiskCache()
localHeaderCache = rpmSource.HeaderCache()
self.hcs = rpmSource.HeaderMemoryCache(cacheObject = localHeaderCache)
self.hds = rpmSource.DiskCache()
self.hldc = rpmSource.LocalDisk()
self.psc.headerCache = localHeaderCache
# FIXME: we can probably get rid of some of these cache layers
self.sources = {'listPackages':[{'name':'repomd', 'object': self.rmdrs},
{'name':'repomddiskcache', 'object':self.rmdss}],
'listAllPackages':[{'name':'diskcache', 'object':self.hds},
{'name':'repomd', 'object': self.rmdss}],
'getObsoletes':[{'name':'diskcache', 'object':self.hds},
{'name':'repomd', 'object': self.rmdrs}],
'getHeader':[{'name':'memcache', 'object': self.hcs},
{'name':'repomd-diskcache', 'object':self.hds},
{'name':'repomd-localdisk', 'object':self.hldc},
{'name':'repomd', 'object': self.rmdrs}],
'getPackage':[{'name':'localdisk','object':self.hldc},
{'name':'diskcache', 'object':self.hds},
{'name':'repomd', 'object': self.rmdrs}
],
# 'getPackageSource':[{'name':'localdisk','object':self.hldc},
# {'name':'diskcache', 'object':self.hds},
# {'name':'rpmmd', 'object': self.rmdrs}
# ]
}
# print "self.sources: %s" % self.sources
def updateAuthInfo(self):
pass
def register(rd):
repomdRepo = RepomdRepo()
rd.handlers['repomd'] = repomdRepo
repomdSolveDep = RepomdSolveDep()
rd.depSolveHandlers['repomd'] = repomdSolveDep
|