cdrom.image/updates/findpackageset.py

import rpm
import rhpl.arch
import string
import types
from constants import *

# set DB_PRIVATE to make rpm happy
rpm.addMacro("__dbi_cdb", "create private mpool mp_mmapsize=16Mb mp_size=1Mb")


def dEBUG(str):
    print str

def addNewPackageToUpgSet(pkgDict, pkg):
    """Check to see if there's already a pkg by the name of pkg already
       in our dictionary.  If not, add this one.  If there is, see if
       this one is 'newer' or has a 'better' arch."""
    name = pkg[rpm.RPMTAG_NAME]
    arch = pkg[rpm.RPMTAG_ARCH]
    if not pkgDict.has_key((name, arch)):
        # nope
        pkgDict[(name,arch)] = pkg
    else:
        # first check version
        val = rpm.versionCompare(pkgDict[(name,arch)], pkg)
        if val < 0:
            # we're newer, add this one
            pkgDict[(name,arch)] = pkg

def comparePackageForUpgrade(updDict, h, pkg):
    val = rpm.versionCompare(h, pkg)
    if (val > 0):
#        dEBUG("found older version of %(name)s %(arch)s" % h)
        pass
    elif (val < 0):
#        dEBUG("found newer version of %(name)s %(arch)s" % h)
        # check if we already have this package in our dictionary
        addNewPackageToUpgSet(updDict, pkg)
    else:
#        dEBUG("found same verison of %(name)s %(arch)s" % h)
        pass

def findBestArch(archlist):
    bestarch = None
    for availarch in archlist:
        newscore = rhpl.arch.score(availarch)
        # unsupported
        if newscore <= 0:
            continue
        # If old arch is better or same
        if bestarch and rhpl.arch.score(bestarch) <= newscore:
            continue
                
        # If we get here we're better
        bestarch = availarch
    return bestarch
        
def getAvailPackages(hdrlist):     
    # go through and figure out which packages in the header list are
    # actually applicable for our architecture
    pkgDict = {}
    nameDict = {}
    for h in hdrlist:
        score1 = rhpl.arch.score(h[rpm.RPMTAG_ARCH])
        if (score1):
            name = h[rpm.RPMTAG_NAME]
            arch = h[rpm.RPMTAG_ARCH]
            pkgDict[(name,arch)] = h
            if nameDict.has_key(name):
                nameDict[name].append(arch)
            else:
                nameDict[name] = [ arch ]
    return (pkgDict, nameDict)

def getInstalledPackages(dbPath='/'):
    pkgDict = {}
    nameDict = {}
    ts = rpm.TransactionSet(dbPath)
    ts.setVSFlags(~(rpm.RPMVSF_NORSA|rpm.RPMVSF_NODSA|rpm.RPMVSF_NOMD5))
    mi = ts.dbMatch()
    for h in mi:
        name = h[rpm.RPMTAG_NAME]
        arch = h[rpm.RPMTAG_ARCH]
        pkgDict[(name,arch)] = h
        if nameDict.has_key(name):
            nameDict[name].append(arch)
        else:
            nameDict[name] = [ arch ]
    return (pkgDict, nameDict)

def findpackageset(hdrlist, dbPath='/'):
    instDict = {}
    availDict = {}
    updDict = {}

    # dicts for name : [archlist]
    availNames = {}
    instNames = {}

    ts = rpm.TransactionSet(dbPath)
    ts.setVSFlags(~(rpm.RPMVSF_NORSA|rpm.RPMVSF_NODSA|rpm.RPMVSF_NOMD5))

    (availDict, availNames)  = getAvailPackages(hdrlist)
    (instDict, instNames) =  getInstalledPackages(dbPath=dbPath)

    hdlist = availDict.values()
    
    # loop through packages and find ones which are a newer
    # version than what we have
    for ( name, arch ) in instDict.keys():
        # See if we have a better arch than that installed
        if name in availNames.keys():
            bestarch = findBestArch(availNames[name])
            if not bestarch:
                continue
            if availDict.has_key((name,bestarch)):
                h = instDict[(name,arch)]
                pkg = availDict[(name,bestarch)]
                comparePackageForUpgrade(updDict, h, pkg)
                    
    # handle obsoletes
    for pkg in hdlist:
        if (pkg[rpm.RPMTAG_NAME],pkg[rpm.RPMTAG_ARCH]) in updDict.keys():
#            dEBUG("%(name)s %(arch)s is already selected" % pkg)
            continue

        if pkg[rpm.RPMTAG_OBSOLETENAME] is not None:
            name = pkg[rpm.RPMTAG_NAME]
            arch = pkg[rpm.RPMTAG_ARCH]
            for obs,obsver in zip(pkg[rpm.RPMTAG_OBSOLETENAME],pkg[rpm.RPMTAG_OBSOLETEVERSION]):
                mi = ts.dbMatch('name', obs)
                oevr = strToVersion(obsver)
                for h in mi:
                    if not obsver:
#                    unversioned obsoletes win
                        addNewPackageToUpgSet(updDict, pkg)
#                    dEBUG("adding %(name)s to the upgrade set for obsoletes" % pkg)
                        break
                    else:
                        if h[rpm.RPMTAG_EPOCH] is None:
                            epoch = '0'
                        else:
                            epoch = str(h[rpm.RPMTAG_EPOCH])
                        val = compareEVR(oevr,(epoch,h[rpm.RPMTAG_VERSION],h[rpm.RPMTAG_RELEASE]))
                        if val > 0:
#                    dEBUG("adding %(name)s %(version)s to the upgrade set for obsoletes" % pkg)
                            updDict[(name,arch)] = pkg 
                            break

    return updDict.values()

def rpmOutToStr(arg):
    if type(arg) != types.StringType:
    # and arg is not None:
        arg = str(arg)

    return arg

def compareEVR((e1, v1, r1), (e2, v2, r2)):
    # return 1: a is newer than b
    # 0: a and b are the same version
    # -1: b is newer than a
    e1 = rpmOutToStr(e1)
    v1 = rpmOutToStr(v1)
    r1 = rpmOutToStr(r1)
    e2 = rpmOutToStr(e2)
    v2 = rpmOutToStr(v2)
    r2 = rpmOutToStr(r2)
    rc = rpm.labelCompare((e1, v1, r1), (e2, v2, r2))
    return rc

def strToVersion(str):
    """Parse a string such as in obsoleteversion into evr.
       Gratuitously borrowed from yum str_to_version
       FIXME: should be implemented in and use rpmUtils"""
    i = string.find(str, ':')
    if i != -1:
        epoch = string.atol(str[:i])
    else:
        epoch = '0'
    j = string.find(str, '-')
    if j != -1:
        if str[i + 1:j] == '':
            version = None
        else:             version = str[i + 1:j]
        release = str[j + 1:]     
    else:
        if str[i + 1:] == '':
            version = None
        else:
            version = str[i + 1:]
        release = None
    return (epoch, version, release)


if __name__ == "__main__":
    import sys, os

    if len(sys.argv) < 2:
        print "Usage: %s /path/to/tree [rootpath]" %(sys.argv[0],)
        sys.exit(0)
        
    tree = sys.argv[1]
    if len(sys.argv) >= 3:
        instPath = sys.argv[2]
    else:
        instPath = "/"
    
    fd = os.open("%s/%s/base/hdlist" %(tree, productPath), os.O_RDONLY)
    hdlist = rpm.readHeaderListFromFD(fd)
    os.close(fd)

    
    packages = findpackageset(hdlist, instPath)
    for pkg in packages:
        print pkg[rpm.RPMTAG_NAME]
                   
1	import rpm
2	import rhpl.arch
3	import string
4	import types
5	from constants import *
6
7	# set DB_PRIVATE to make rpm happy
8	rpm.addMacro("__dbi_cdb", "create private mpool mp_mmapsize=16Mb mp_size=1Mb")
9
10
11	def dEBUG(str):
12	print str
13
14	def addNewPackageToUpgSet(pkgDict, pkg):
15	"""Check to see if there's already a pkg by the name of pkg already
16	in our dictionary. If not, add this one. If there is, see if
17	this one is 'newer' or has a 'better' arch."""
18	name = pkg[rpm.RPMTAG_NAME]
19	arch = pkg[rpm.RPMTAG_ARCH]
20	if not pkgDict.has_key((name, arch)):
21	# nope
22	pkgDict[(name,arch)] = pkg
23	else:
24	# first check version
25	val = rpm.versionCompare(pkgDict[(name,arch)], pkg)
26	if val < 0:
27	# we're newer, add this one
28	pkgDict[(name,arch)] = pkg
29
30	def comparePackageForUpgrade(updDict, h, pkg):
31	val = rpm.versionCompare(h, pkg)
32	if (val > 0):
33	# dEBUG("found older version of %(name)s %(arch)s" % h)
34	pass
35	elif (val < 0):
36	# dEBUG("found newer version of %(name)s %(arch)s" % h)
37	# check if we already have this package in our dictionary
38	addNewPackageToUpgSet(updDict, pkg)
39	else:
40	# dEBUG("found same verison of %(name)s %(arch)s" % h)
41	pass
42
43	def findBestArch(archlist):
44	bestarch = None
45	for availarch in archlist:
46	newscore = rhpl.arch.score(availarch)
47	# unsupported
48	if newscore <= 0:
49	continue
50	# If old arch is better or same
51	if bestarch and rhpl.arch.score(bestarch) <= newscore:
52	continue
53
54	# If we get here we're better
55	bestarch = availarch
56	return bestarch
57
58	def getAvailPackages(hdrlist):
59	# go through and figure out which packages in the header list are
60	# actually applicable for our architecture
61	pkgDict = {}
62	nameDict = {}
63	for h in hdrlist:
64	score1 = rhpl.arch.score(h[rpm.RPMTAG_ARCH])
65	if (score1):
66	name = h[rpm.RPMTAG_NAME]
67	arch = h[rpm.RPMTAG_ARCH]
68	pkgDict[(name,arch)] = h
69	if nameDict.has_key(name):
70	nameDict[name].append(arch)
71	else:
72	nameDict[name] = [ arch ]
73	return (pkgDict, nameDict)
74
75	def getInstalledPackages(dbPath='/'):
76	pkgDict = {}
77	nameDict = {}
78	ts = rpm.TransactionSet(dbPath)
79	ts.setVSFlags(~(rpm.RPMVSF_NORSA\|rpm.RPMVSF_NODSA\|rpm.RPMVSF_NOMD5))
80	mi = ts.dbMatch()
81	for h in mi:
82	name = h[rpm.RPMTAG_NAME]
83	arch = h[rpm.RPMTAG_ARCH]
84	pkgDict[(name,arch)] = h
85	if nameDict.has_key(name):
86	nameDict[name].append(arch)
87	else:
88	nameDict[name] = [ arch ]
89	return (pkgDict, nameDict)
90
91	def findpackageset(hdrlist, dbPath='/'):
92	instDict = {}
93	availDict = {}
94	updDict = {}
95
96	# dicts for name : [archlist]
97	availNames = {}
98	instNames = {}
99
100	ts = rpm.TransactionSet(dbPath)
101	ts.setVSFlags(~(rpm.RPMVSF_NORSA\|rpm.RPMVSF_NODSA\|rpm.RPMVSF_NOMD5))
102
103	(availDict, availNames) = getAvailPackages(hdrlist)
104	(instDict, instNames) = getInstalledPackages(dbPath=dbPath)
105
106	hdlist = availDict.values()
107
108	# loop through packages and find ones which are a newer
109	# version than what we have
110	for ( name, arch ) in instDict.keys():
111	# See if we have a better arch than that installed
112	if name in availNames.keys():
113	bestarch = findBestArch(availNames[name])
114	if not bestarch:
115	continue
116	if availDict.has_key((name,bestarch)):
117	h = instDict[(name,arch)]
118	pkg = availDict[(name,bestarch)]
119	comparePackageForUpgrade(updDict, h, pkg)
120
121	# handle obsoletes
122	for pkg in hdlist:
123	if (pkg[rpm.RPMTAG_NAME],pkg[rpm.RPMTAG_ARCH]) in updDict.keys():
124	# dEBUG("%(name)s %(arch)s is already selected" % pkg)
125	continue
126
127	if pkg[rpm.RPMTAG_OBSOLETENAME] is not None:
128	name = pkg[rpm.RPMTAG_NAME]
129	arch = pkg[rpm.RPMTAG_ARCH]
130	for obs,obsver in zip(pkg[rpm.RPMTAG_OBSOLETENAME],pkg[rpm.RPMTAG_OBSOLETEVERSION]):
131	mi = ts.dbMatch('name', obs)
132	oevr = strToVersion(obsver)
133	for h in mi:
134	if not obsver:
135	# unversioned obsoletes win
136	addNewPackageToUpgSet(updDict, pkg)
137	# dEBUG("adding %(name)s to the upgrade set for obsoletes" % pkg)
138	break
139	else:
140	if h[rpm.RPMTAG_EPOCH] is None:
141	epoch = '0'
142	else:
143	epoch = str(h[rpm.RPMTAG_EPOCH])
144	val = compareEVR(oevr,(epoch,h[rpm.RPMTAG_VERSION],h[rpm.RPMTAG_RELEASE]))
145	if val > 0:
146	# dEBUG("adding %(name)s %(version)s to the upgrade set for obsoletes" % pkg)
147	updDict[(name,arch)] = pkg
148	break
149
150	return updDict.values()
151
152	def rpmOutToStr(arg):
153	if type(arg) != types.StringType:
154	# and arg is not None:
155	arg = str(arg)
156
157	return arg
158
159	def compareEVR((e1, v1, r1), (e2, v2, r2)):
160	# return 1: a is newer than b
161	# 0: a and b are the same version
162	# -1: b is newer than a
163	e1 = rpmOutToStr(e1)
164	v1 = rpmOutToStr(v1)
165	r1 = rpmOutToStr(r1)
166	e2 = rpmOutToStr(e2)
167	v2 = rpmOutToStr(v2)
168	r2 = rpmOutToStr(r2)
169	rc = rpm.labelCompare((e1, v1, r1), (e2, v2, r2))
170	return rc
171
172	def strToVersion(str):
173	"""Parse a string such as in obsoleteversion into evr.
174	Gratuitously borrowed from yum str_to_version
175	FIXME: should be implemented in and use rpmUtils"""
176	i = string.find(str, ':')
177	if i != -1:
178	epoch = string.atol(str[:i])
179	else:
180	epoch = '0'
181	j = string.find(str, '-')
182	if j != -1:
183	if str[i + 1:j] == '':
184	version = None
185	else: version = str[i + 1:j]
186	release = str[j + 1:]
187	else:
188	if str[i + 1:] == '':
189	version = None
190	else:
191	version = str[i + 1:]
192	release = None
193	return (epoch, version, release)
194
195
196	if __name__ == "__main__":
197	import sys, os
198
199	if len(sys.argv) < 2:
200	print "Usage: %s /path/to/tree [rootpath]" %(sys.argv[0],)
201	sys.exit(0)
202
203	tree = sys.argv[1]
204	if len(sys.argv) >= 3:
205	instPath = sys.argv[2]
206	else:
207	instPath = "/"
208
209	fd = os.open("%s/%s/base/hdlist" %(tree, productPath), os.O_RDONLY)
210	hdlist = rpm.readHeaderListFromFD(fd)
211	os.close(fd)
212
213
214	packages = findpackageset(hdlist, instPath)
215	for pkg in packages:
216	print pkg[rpm.RPMTAG_NAME]
217