/[smeserver]/cdrom.image/sme9/updates/yuminstall.py
ViewVC logotype

Annotation of /cdrom.image/sme9/updates/yuminstall.py

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph


Revision 1.2 - (hide annotations) (download) (as text)
Sun Dec 22 04:27:50 2013 UTC (10 years, 10 months ago) by wellsi
Branch: MAIN
CVS Tags: HEAD
Changes since 1.1: +0 -0 lines
Content type: text/x-python
FILE REMOVED
anaconda updates now handled via patches

1 slords 1.1 #
2     # yuminstall.py
3     #
4     # Copyright (C) 2005, 2006, 2007 Red Hat, Inc. All rights reserved.
5     #
6     # This program is free software; you can redistribute it and/or modify
7     # it under the terms of the GNU General Public License as published by
8     # the Free Software Foundation; either version 2 of the License, or
9     # (at your option) any later version.
10     #
11     # This program is distributed in the hope that it will be useful,
12     # but WITHOUT ANY WARRANTY; without even the implied warranty of
13     # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14     # GNU General Public License for more details.
15     #
16     # You should have received a copy of the GNU General Public License
17     # along with this program. If not, see <http://www.gnu.org/licenses/>.
18     #
19    
20     from flags import flags
21     from errors import *
22    
23     from ConfigParser import ConfigParser
24     import sys
25     import os
26     import os.path
27     import shutil
28     import time
29     import warnings
30     import types
31     import locale
32     import glob
33     import tempfile
34     import itertools
35     import re
36    
37    
38     import anaconda_log
39     import rpm
40     import rpmUtils
41     import urlgrabber.progress
42     import urlgrabber.grabber
43     from urlgrabber.grabber import URLGrabber, URLGrabError
44     import yum
45     import iniparse
46     from yum.constants import *
47     from yum.Errors import *
48     from yum.misc import to_unicode
49     from yum.yumRepo import YumRepository
50     from backend import AnacondaBackend
51     from product import *
52     from sortedtransaction import SplitMediaTransactionData
53     from constants import *
54     from image import *
55     from compssort import *
56     import packages
57     import iutil
58    
59     import gettext
60     _ = lambda x: gettext.ldgettext("anaconda", x)
61     P_ = lambda x, y, z: gettext.ldngettext("anaconda", x, y, z)
62    
63     import network
64    
65     # specspo stuff
66     rpm.addMacro("_i18ndomains", "redhat-dist")
67    
68     import logging
69     log = logging.getLogger("anaconda")
70    
71     import urlparse
72     urlparse.uses_fragment.append('media')
73    
74     urlgrabber.grabber.default_grabber.opts.user_agent = "%s (anaconda)/%s" %(productName, productVersion)
75    
76     import iutil
77     import isys
78    
79     def size_string (size):
80     def number_format(s):
81     return locale.format("%s", s, 1)
82    
83     retval = None
84    
85     if size > 1024 * 1024:
86     size = size / (1024*1024)
87     retval = _("%s MB") %(number_format(size),)
88     elif size > 1024:
89     size = size / 1024
90     retval = _("%s KB") %(number_format(size),)
91     else:
92     retval = P_("%s Byte", "%s Bytes", size) % (number_format(size),)
93    
94     return to_unicode(retval)
95    
96     class AnacondaCallback:
97    
98     def __init__(self, ayum, anaconda, instLog, modeText):
99     self.repos = ayum.repos
100     self.ts = ayum.ts
101     self.ayum = ayum
102    
103     self.messageWindow = anaconda.intf.messageWindow
104     self.pulseWindow = anaconda.intf.progressWindow
105     self.progress = anaconda.id.instProgress
106     self.progressWindowClass = anaconda.intf.progressWindow
107     self.rootPath = anaconda.rootPath
108    
109     self.initWindow = None
110    
111     self.progressWindow = None
112     self.lastprogress = 0
113     self.incr = 20
114    
115     self.instLog = instLog
116     self.modeText = modeText
117    
118     self.openfile = None
119     self.inProgressPo = None
120    
121     def setSizes(self, numpkgs, totalSize, totalFiles):
122     self.numpkgs = numpkgs
123     self.totalSize = totalSize
124     self.totalFiles = totalFiles
125    
126     self.donepkgs = 0
127     self.doneSize = 0
128     self.doneFiles = 0
129    
130    
131     def callback(self, what, amount, total, h, user):
132     if what == rpm.RPMCALLBACK_TRANS_START:
133     # step 6 is the bulk of the ts processing time
134     if amount == 6:
135     self.progressWindow = \
136     self.progressWindowClass (_("Preparing to install"),
137     _("Preparing transaction from installation source"),
138     total)
139     self.incr = total / 10
140    
141     if what == rpm.RPMCALLBACK_TRANS_PROGRESS:
142     if self.progressWindow and amount > self.lastprogress + self.incr:
143     self.progressWindow.set(amount)
144     self.lastprogress = amount
145    
146     if what == rpm.RPMCALLBACK_TRANS_STOP and self.progressWindow:
147     self.progressWindow.pop()
148    
149     if what == rpm.RPMCALLBACK_INST_OPEN_FILE:
150     (hdr, rpmloc) = h
151     # hate hate hate at epochs...
152     epoch = hdr['epoch']
153     if epoch is not None:
154     epoch = str(epoch)
155     txmbrs = self.ayum.tsInfo.matchNaevr(hdr['name'], hdr['arch'],
156     epoch, hdr['version'],
157     hdr['release'])
158     if len(txmbrs) == 0:
159     raise RuntimeError, "Unable to find package %s-%s-%s.%s" %(hdr['name'], hdr['version'], hdr['release'], hdr['arch'])
160     po = txmbrs[0].po
161    
162     repo = self.repos.getRepo(po.repoid)
163    
164     pkgStr = "%s-%s-%s.%s" % (po.name, po.version, po.release, po.arch)
165     s = to_unicode(_("<b>Installing %(pkgStr)s</b> (%(size)s)\n")) \
166     % {'pkgStr': pkgStr, 'size': size_string(hdr['size'])}
167     summary = to_unicode(gettext.ldgettext("redhat-dist", hdr['summary'] or ""))
168     s += summary.strip()
169     self.progress.set_label(s)
170    
171     self.instLog.write(self.modeText % str(pkgStr))
172    
173     self.instLog.flush()
174     self.openfile = None
175    
176     trynumber = 0
177     while self.openfile is None:
178     trynumber += 1
179     try:
180     # checkfunc gets passed to yum's use of URLGrabber which
181     # then calls it with the file being fetched. verifyPkg
182     # makes sure the checksum matches the one in the metadata.
183     #
184     # From the URLGrab documents:
185     # checkfunc=(function, ('arg1', 2), {'kwarg': 3})
186     # results in a callback like:
187     # function(obj, 'arg1', 2, kwarg=3)
188     # obj.filename = '/tmp/stuff'
189     # obj.url = 'http://foo.com/stuff'
190     checkfunc = (self.ayum.verifyPkg, (po, 1), {})
191     fn = repo.getPackage(po, checkfunc=checkfunc)
192    
193     f = open(fn, 'r')
194     self.openfile = f
195     except yum.Errors.NoMoreMirrorsRepoError:
196     self.ayum._handleFailure(po, trynumber)
197     except IOError:
198     self.ayum._handleFailure(po, trynumber)
199     except URLGrabError as e:
200     log.error("URLGrabError: %s" % (e,))
201     self.ayum._handleFailure(po, trynumber)
202     except yum.Errors.RepoError, e:
203     continue
204     self.inProgressPo = po
205    
206     return self.openfile.fileno()
207    
208     elif what == rpm.RPMCALLBACK_INST_CLOSE_FILE:
209     if self.initWindow:
210     self.initWindow.pop()
211     self.initWindow = None
212    
213     (hdr, rpmloc) = h
214    
215     fn = self.openfile.name
216     self.openfile.close()
217     self.openfile = None
218    
219     if os.path.dirname(fn).startswith("%s/var/cache/yum/" % self.rootPath):
220     try:
221     os.unlink(fn)
222     except OSError as e:
223     log.debug("unable to remove file %s" %(e.strerror,))
224    
225     self.donepkgs += 1
226     self.doneSize += self.inProgressPo.returnSimple("installedsize") / 1024.0
227     self.doneFiles += len(hdr[rpm.RPMTAG_BASENAMES])
228    
229     if self.donepkgs <= self.numpkgs:
230     self.progress.set_text(P_("Packages completed: "
231     "%(donepkgs)d of %(numpkgs)d",
232     "Packages completed: "
233     "%(donepkgs)d of %(numpkgs)d",
234     self.numpkgs)
235     % {'donepkgs': self.donepkgs,
236     'numpkgs': self.numpkgs})
237     if self.totalSize > 0:
238     self.progress.set_fraction(float(self.doneSize / self.totalSize))
239     else:
240     self.progress.set_fraction(0.0)
241     self.progress.processEvents()
242    
243     self.inProgressPo = None
244    
245     elif what in (rpm.RPMCALLBACK_UNINST_START,
246     rpm.RPMCALLBACK_UNINST_STOP):
247     if self.initWindow is None:
248     self.initWindow = self.pulseWindow(_("Finishing upgrade"),
249     _("Finishing upgrade process. This may take a little while."),
250     0, pulse=True)
251     else:
252     self.initWindow.pulse()
253    
254     elif what in (rpm.RPMCALLBACK_CPIO_ERROR,
255     rpm.RPMCALLBACK_UNPACK_ERROR,
256     rpm.RPMCALLBACK_SCRIPT_ERROR):
257     if not isinstance(h, types.TupleType):
258     h = (h, None)
259    
260     (hdr, rpmloc) = h
261    
262     # Script errors store whether or not they're fatal in "total". So,
263     # we should only error out for fatal script errors or the cpio and
264     # unpack problems.
265     if what != rpm.RPMCALLBACK_SCRIPT_ERROR or total:
266     self.messageWindow(_("Error Installing Package"),
267     _("A fatal error occurred when installing the %s "
268     "package. This could indicate errors when reading "
269     "the installation media. Installation cannot "
270     "continue.") % hdr['name'],
271     type="custom", custom_icon="error",
272     custom_buttons=[_("_Exit installer")])
273     sys.exit(1)
274    
275     if self.initWindow is None:
276     self.progress.processEvents()
277    
278     class AnacondaYumRepo(YumRepository):
279     def __init__(self, *args, **kwargs):
280     YumRepository.__init__(self, *args, **kwargs)
281     self.enablegroups = True
282     self.sslverify = True
283     self._anacondaBaseURLs = []
284     self.proxy_url = None
285    
286     def needsNetwork(self):
287     def _isURL(s):
288     return s.startswith("http") or s.startswith("ftp")
289    
290     if len(self.baseurl) > 0:
291     return len(filter(lambda s: _isURL(s), self.baseurl)) > 0
292     elif self.mirrorlist:
293     return _isURL(self.mirrorlist)
294     else:
295     return False
296    
297     def dirCleanup(self, upgrade=False):
298     cachedir = self.getAttribute('cachedir')
299    
300     if os.path.isdir(cachedir):
301     if upgrade:
302     log.debug("Removing contents of %s" % (cachedir))
303     for f in filter(os.path.isfile, glob.glob("%s/*" % (cachedir))):
304     try:
305     os.unlink(f)
306     except Exception, e:
307     log.debug("error %s removing: %s" %(e,f))
308     elif not self.needsNetwork() or self.name == "Installation Repo" or self.id.startswith("anaconda-"):
309     log.debug("Removing cachedir: %s" % (cachedir))
310     shutil.rmtree(cachedir)
311     else:
312     log.debug("Removing headers and packages from %s" % (cachedir))
313     if os.path.exists("%s/headers" % cachedir):
314     shutil.rmtree("%s/headers" % cachedir)
315     if os.path.exists("%s/packages" % cachedir):
316     shutil.rmtree("%s/packages" % cachedir)
317    
318     # needed to store nfs: repo url that yum doesn't know
319     def _getAnacondaBaseURLs(self):
320     return self._anacondaBaseURLs or self.baseurl or [self.mirrorlist]
321    
322     def _setAnacondaBaseURLs(self, value):
323     self._anacondaBaseURLs = value
324    
325     anacondaBaseURLs = property(_getAnacondaBaseURLs, _setAnacondaBaseURLs,
326     doc="Extends AnacondaYum.baseurl to store non-yum urls:")
327    
328     class YumSorter(yum.YumBase):
329     def _transactionDataFactory(self):
330     return SplitMediaTransactionData()
331    
332     class AnacondaYum(YumSorter):
333     def __init__(self, anaconda):
334     YumSorter.__init__(self)
335     self.anaconda = anaconda
336     self._timestamp = None
337    
338     self.repoIDcounter = itertools.count()
339    
340     # Only needed for hard drive and nfsiso installs.
341     self._discImages = {}
342     self.isodir = None
343    
344     # Only needed for media installs.
345     self.currentMedia = None
346     self.mediagrabber = None
347    
348     # Where is the source media mounted? This is the directory
349     # where Packages/ is located.
350     self.tree = "/mnt/source"
351    
352     self.macros = {}
353    
354     if flags.selinux:
355     for directory in ("/tmp/updates",
356     "/etc/selinux/targeted/contexts/files",
357     "/etc/security/selinux/src/policy/file_contexts",
358     "/etc/security/selinux"):
359     fn = "%s/file_contexts" %(directory,)
360     if os.access(fn, os.R_OK):
361     break
362     self.macros["__file_context_path"] = fn
363     else:
364     self.macros["__file_context_path"] = "%{nil}"
365    
366     self.updates = []
367     self.localPackages = []
368    
369     # Parse proxy values from anaconda
370     self.proxy = None
371     self.proxy_url = None
372     self.proxy_username = None
373     self.proxy_password = None
374     if self.anaconda.proxy:
375     self.setProxy(self.anaconda, self)
376    
377     def setup(self):
378     # yum doesn't understand all our method URLs, so use this for all
379     # except FTP and HTTP installs.
380     self._baseRepoURL = "file://%s" % self.tree
381    
382     while True:
383     try:
384     self.configBaseURL()
385     break
386     except SystemError as exception:
387     self.anaconda.methodstr = self.anaconda.intf.methodstrRepoWindow(self.anaconda.methodstr or "cdrom:",
388     exception)
389    
390     self.doConfigSetup(root=self.anaconda.rootPath)
391     if not self.anaconda.id.getUpgrade():
392     self.conf.installonlypkgs = []
393    
394     def _switchCD(self, discnum):
395     if os.access("%s/.discinfo" % self.tree, os.R_OK):
396     f = open("%s/.discinfo" % self.tree)
397     self._timestamp = f.readline().strip()
398     f.close()
399    
400     dev = self.anaconda.id.storage.devicetree.getDeviceByName(self.anaconda.mediaDevice)
401     dev.format.mountpoint = self.tree
402    
403     # If self.currentMedia is None, then there shouldn't be anything
404     # mounted. Before going further, see if the correct disc is already
405     # in the drive. This saves a useless eject and insert if the user
406     # has for some reason already put the disc in the drive.
407     if self.currentMedia is None:
408     try:
409     dev.format.mount()
410    
411     if verifyMedia(self.tree, discnum, None):
412     self.currentMedia = discnum
413     return
414    
415     dev.format.unmount()
416     except:
417     pass
418     else:
419     unmountCD(dev, self.anaconda.intf.messageWindow)
420     self.currentMedia = None
421    
422     dev.eject()
423    
424     while True:
425     if self.anaconda.intf:
426     self.anaconda.intf.beep()
427    
428     self.anaconda.intf.messageWindow(_("Change Disc"),
429     _("Please insert %(productName)s disc %(discnum)d to continue.")
430     % {'productName': productName, 'discnum': discnum})
431    
432     try:
433     dev.format.mount()
434    
435     if verifyMedia(self.tree, discnum, self._timestamp):
436     self.currentMedia = discnum
437     break
438    
439     self.anaconda.intf.messageWindow(_("Wrong Disc"),
440     _("That's not the correct %s disc.")
441     % (productName,))
442    
443     dev.format.unmount()
444     dev.eject()
445     except:
446     self.anaconda.intf.messageWindow(_("Error"),
447     _("Unable to access the disc."))
448    
449     def _switchImage(self, discnum):
450     umountImage(self.tree, self.currentMedia)
451     self.currentMedia = None
452    
453     # mountDirectory checks before doing anything, so it's safe to
454     # call this repeatedly.
455     mountDirectory(self.anaconda.methodstr,
456     self.anaconda.intf.messageWindow)
457    
458     self._discImages = mountImage(self.isodir, self.tree, discnum,
459     self.anaconda.intf.messageWindow,
460     discImages=self._discImages)
461     self.currentMedia = discnum
462    
463     def configBaseURL(self):
464     # We only have a methodstr if method= or repo= was passed to
465     # anaconda. No source for this base repo (the CD media, NFS,
466     # whatever) is mounted yet since loader only mounts the source
467     # for the stage2 image. We need to set up the source mount
468     # now.
469     if flags.cmdline.has_key("preupgrade"):
470     path = "/var/cache/yum/preupgrade"
471     self.anaconda.methodstr = "hd::%s" % path
472     self._baseRepoURL = "file:///mnt/sysimage/%s" % path
473     elif self.anaconda.methodstr:
474     m = self.anaconda.methodstr
475    
476     if m.startswith("hd:"):
477     if m.count(":") == 2:
478     (device, path) = m[3:].split(":")
479     else:
480     (device, fstype, path) = m[3:].split(":")
481    
482     self.isodir = "/mnt/isodir/%s" % path
483    
484     # This takes care of mounting /mnt/isodir first.
485     self._switchImage(1)
486     self.mediagrabber = self.mediaHandler
487     elif m.startswith("nfsiso:"):
488     self.isodir = "/mnt/isodir"
489    
490     # Calling _switchImage takes care of mounting /mnt/isodir first.
491     if not network.hasActiveNetDev():
492     if not self.anaconda.intf.enableNetwork():
493     self._baseRepoURL = None
494     return
495    
496     urlgrabber.grabber.reset_curl_obj()
497    
498     self._switchImage(1)
499     self.mediagrabber = self.mediaHandler
500     elif m.startswith("http") or m.startswith("ftp:"):
501     self._baseRepoURL = m
502     elif m.startswith("nfs:"):
503     if not network.hasActiveNetDev():
504     if not self.anaconda.intf.enableNetwork():
505     self._baseRepoURL = None
506    
507     urlgrabber.grabber.reset_curl_obj()
508    
509     (opts, server, path) = iutil.parseNfsUrl(m)
510     isys.mount(server+":"+path, self.tree, "nfs", options=opts)
511    
512     # This really should be fixed in loader instead but for now see
513     # if there's images and if so go with this being an NFSISO
514     # install instead.
515     images = findIsoImages(self.tree, self.anaconda.intf.messageWindow)
516     if images != {}:
517     isys.umount(self.tree, removeDir=False)
518     self.anaconda.methodstr = "nfsiso:%s" % m[4:]
519     self.configBaseURL()
520     return
521     elif m.startswith("cdrom:"):
522     self._switchCD(1)
523     self.mediagrabber = self.mediaHandler
524     self._baseRepoURL = "file://%s" % self.tree
525     else:
526     # No methodstr was given. In order to find an installation source,
527     # we should first check to see if there's a CD/DVD with packages
528     # on it, and then default to the mirrorlist URL. The user can
529     # always change the repo with the repo editor later.
530     cdr = scanForMedia(self.tree, self.anaconda.id.storage)
531     if cdr:
532     self.mediagrabber = self.mediaHandler
533     self.anaconda.mediaDevice = cdr
534     self.currentMedia = 1
535     log.info("found installation media on %s" % cdr)
536     else:
537     # No CD with media on it and no repo=/method= parameter, so
538     # default to using whatever's enabled in /etc/yum.repos.d/
539     self._baseRepoURL = None
540    
541     def configBaseRepo(self, root='/'):
542     # Create the "base" repo object, assuming there is one. Otherwise we
543     # just skip all this and use the defaults from /etc/yum.repos.d.
544     if not self._baseRepoURL:
545     return
546    
547     # add default repos
548     anacondabaseurl = (self.anaconda.methodstr or
549     "cdrom:%s" % (self.anaconda.mediaDevice))
550     anacondabasepaths = self.anaconda.id.instClass.getPackagePaths(anacondabaseurl)
551     for (name, uri) in self.anaconda.id.instClass.getPackagePaths(self._baseRepoURL).items():
552     rid = name.replace(" ", "")
553    
554     repo = AnacondaYumRepo("anaconda-%s-%s" % (rid, productStamp))
555     repo.baseurl = uri
556     repo.anacondaBaseURLs = anacondabasepaths[name]
557    
558     repo.name = name
559     repo.cost = 100
560    
561     if self.anaconda.mediaDevice or self.isodir:
562     repo.mediaid = getMediaId(self.tree)
563     log.info("set mediaid of repo %s to: %s" % (rid, repo.mediaid))
564    
565     if self.anaconda.proxy:
566     self.setProxy(self.anaconda, repo)
567    
568     if flags.noverifyssl:
569     repo.sslverify = False
570    
571     repo.enable()
572     self.repos.add(repo)
573    
574     def mediaHandler(self, *args, **kwargs):
575     mediaid = kwargs["mediaid"]
576     discnum = kwargs["discnum"]
577     relative = kwargs["relative"]
578    
579     # The package exists on media other than what's mounted right now.
580     if discnum != self.currentMedia:
581     log.info("switching from media #%s to #%s for %s" %
582     (self.currentMedia, discnum, relative))
583    
584     # Unmount any currently mounted ISO images and mount the one
585     # containing the requested packages.
586     if self.isodir:
587     self._switchImage(discnum)
588     else:
589     self._switchCD(discnum)
590    
591     ug = URLGrabber(checkfunc=kwargs["checkfunc"])
592     ug.urlgrab("%s/%s" % (self.tree, kwargs["relative"]), kwargs["local"],
593     text=kwargs["text"], range=kwargs["range"], copy_local=1)
594     return kwargs["local"]
595    
596     # XXX: This is straight out of yum, but we need to override it here in
597     # order to use our own repo class.
598     def readRepoConfig(self, parser, section):
599     '''Parse an INI file section for a repository.
600    
601     @param parser: ConfParser or similar to read INI file values from.
602     @param section: INI file section to read.
603     @return: YumRepository instance.
604     '''
605     repo = AnacondaYumRepo(section)
606     repo.populate(parser, section, self.conf)
607    
608     # Ensure that the repo name is set
609     if not repo.name:
610     repo.name = section
611     self.logger.error(_('Repository %r is missing name in configuration, '
612     'using id') % section)
613    
614     # Set attributes not from the config file
615     repo.yumvar.update(self.conf.yumvar)
616     repo.cfg = parser
617    
618     if "-source" in repo.id or "-debuginfo" in repo.id:
619     name = repo.name
620     del(repo)
621     raise RepoError, "Repo %s contains -source or -debuginfo, excluding" % name
622    
623     # this is a little hard-coded, but it's effective
624     if productIsFinal and ("rawhide" in repo.id or "development" in repo.id):
625     name = repo.name
626     del(repo)
627     raise RepoError, "Excluding devel repo %s for non-devel anaconda" % name
628    
629     if not productIsFinal and not repo.enabled:
630     name = repo.name
631     del(repo)
632     raise RepoError, "Excluding disabled repo %s for prerelease" % name
633    
634     # If repo=/method= was passed in, we want to default these extra
635     # repos to off.
636     if self._baseRepoURL:
637     repo.enabled = False
638    
639     return repo
640    
641     def setProxy(self, src, dest):
642     """
643     Set the proxy settings from a string in src.proxy
644     If the string includes un/pw use those, otherwise set the un/pw from
645     src.proxyUsername and src.proxyPassword
646    
647     dest has dest.proxy set to the host and port (no un/pw)
648     dest.proxy_username and dest.proxy_password are set if present in src
649     """
650     # This is the same pattern as from loader/urls.c:splitProxyParam
651     # except that the POSIX classes have been replaced with character
652     # ranges
653     # NOTE: If this changes, update tests/regex/proxy.py
654     #
655     # proxy=[protocol://][username[:password]@]host[:port][path]
656     pattern = re.compile("([A-Za-z]+://)?(([A-Za-z0-9]+)(:[^:@]+)?@)?([^:/]+)(:[0-9]+)?(/.*)?")
657    
658     m = pattern.match(src.proxy)
659    
660     if m and m.group(3):
661     dest.proxy_username = m.group(3)
662     elif getattr(src, "proxyUsername", None):
663     dest.proxy_username = src.proxyUsername
664    
665     if m and m.group(4):
666     # Skip the leading colon.
667     dest.proxy_password = m.group(4)[1:]
668     elif getattr(src, "proxyPassword", None):
669     dest.proxy_password = src.proxyPassword
670    
671     if dest.proxy_username or dest.proxy_password:
672     proxy_auth = "%s:%s@" % (dest.proxy_username or '',
673     dest.proxy_password or '')
674     else:
675     proxy_auth = ""
676    
677     if m and m.group(5):
678     # If both a host and port was found, just paste them
679     # together using the colon at the beginning of the port
680     # match as a separator. Otherwise, just use the host.
681     if m.group(6):
682     proxy = m.group(5) + m.group(6)
683     else:
684     proxy = m.group(5)
685    
686     # yum also requires a protocol. If none was given,
687     # default to http.
688     if m.group(1):
689     dest.proxy_url = m.group(1) + proxy_auth + proxy
690     proxy = m.group(1) + proxy
691     else:
692     dest.proxy_url = "http://" + proxy_auth + proxy
693     proxy = "http://" + proxy
694    
695     # Set the repo proxy. NOTE: yum immediately parses this and
696     # raises an error if it isn't correct
697     dest.proxy = proxy
698    
699     def _getAddons(self, repo):
700     """
701     Check the baseurl or mirrorlist for a repository, see if it has any
702     valid addon repos and if so, return a list of (repo name, repo URL).
703     """
704     baseurl = repo.mirrorlist or repo.baseurl[0]
705     retval = []
706     c = ConfigParser()
707    
708     # If there's no .treeinfo for this repo, don't bother looking for addons.
709     treeinfo = self._getTreeinfo(baseurl, repo.proxy_url, repo.sslverify)
710     if not treeinfo:
711     return retval
712    
713     # We need to know which variant is being installed so we know what addons
714     # are valid options.
715     try:
716     ConfigParser.read(c, treeinfo)
717     variant = c.get("general", "variant")
718     except:
719     return retval
720    
721     section = "variant-%s" % variant
722     if c.has_section(section) and c.has_option(section, "addons"):
723     validAddons = c.get(section, "addons").split(",")
724     else:
725     return retval
726    
727     for addon in validAddons:
728     addonSection = "addon-%s" % addon
729     if not c.has_section(addonSection) or not c.has_option(addonSection, "repository"):
730     continue
731    
732     url = "%s/%s" % (baseurl, c.get(addonSection, "repository"))
733     retval.append((addon, c.get(addonSection, "name"), url))
734    
735     return retval
736    
737     def _getTreeinfo(self, baseurl, proxy_url, sslverify):
738     """
739     Try to get .treeinfo file from baseurl, optionally using proxy_url
740     Saves the file into /tmp/.treeinfo
741     """
742     if not baseurl:
743     return None
744     if baseurl.startswith("http") or baseurl.startswith("ftp"):
745     if not network.hasActiveNetDev():
746     if not self.anaconda.intf.enableNetwork():
747     log.error("Error downloading %s/.treeinfo: network enablement failed" % (baseurl))
748     return None
749     urlgrabber.grabber.reset_curl_obj()
750    
751     ug = URLGrabber()
752     ugopts = {
753     "ssl_verify_peer" : sslverify,
754     "ssl_verify_host" : sslverify
755     }
756    
757     if proxy_url and proxy_url.startswith("http"):
758     proxies = { 'http' : proxy_url,
759     'https' : proxy_url }
760     elif proxy_url and proxy_url.startswith("ftp"):
761     proxies = { 'ftp' : proxy_url }
762     else:
763     proxies = {}
764    
765     try:
766     ug.urlgrab("%s/.treeinfo" % baseurl, "/tmp/.treeinfo",
767     copy_local=1, proxies=proxies, **ugopts)
768     except Exception as e:
769     try:
770     ug.urlgrab("%s/treeinfo" % baseurl, "/tmp/.treeinfo",
771     copy_local=1, proxies=proxies)
772     except Exception as e:
773     log.error("Error downloading treeinfo file: %s" % e)
774     return None
775    
776     return "/tmp/.treeinfo"
777    
778     def _getReleasever(self):
779     """
780     We need to make sure $releasever gets set up before .repo files are
781     read. Since there's no redhat-release package in /mnt/sysimage (and
782     won't be for quite a while), we need to do our own substutition.
783     """
784     c = ConfigParser()
785    
786     treeinfo = self._getTreeinfo(self._baseRepoURL,
787     self.proxy_url,
788     not flags.noverifyssl)
789     if not treeinfo:
790     return productVersion
791    
792     ConfigParser.read(c, treeinfo)
793     try:
794     return c.get("general", "version")
795     except:
796     return productVersion
797    
798     # Override this method so yum doesn't nuke our existing logging config.
799     def doLoggingSetup(self, *args, **kwargs):
800    
801     import yum.logginglevels
802    
803     file_handler = logging.FileHandler("/tmp/yum.log")
804     file_formatter = logging.Formatter("[%(asctime)s] %(levelname)-8s: %(message)s")
805     file_handler.setFormatter(file_formatter)
806    
807     tty3_handler = logging.FileHandler("/dev/tty3")
808     tty3_formatter = logging.Formatter("%(asctime)s %(levelname)-8s: %(name)s: %(message)s", "%H:%M:%S")
809     tty3_handler.setFormatter(tty3_formatter)
810    
811     verbose = logging.getLogger("yum.verbose")
812     verbose.setLevel(logging.DEBUG)
813     verbose.propagate = False
814     verbose.addHandler(file_handler)
815    
816     logger = logging.getLogger("yum")
817     logger.propagate = False
818     logger.setLevel(yum.logginglevels.INFO_2)
819     logger.addHandler(file_handler)
820     anaconda_log.autoSetLevel(tty3_handler, True)
821     tty3_handler.setLevel(anaconda_log.logger.loglevel)
822     logger.addHandler(tty3_handler)
823    
824     # XXX filelogger is set in setFileLog - do we or user want it?
825     filelogger = logging.getLogger("yum.filelogging")
826     filelogger.setLevel(logging.INFO)
827     filelogger.propagate = False
828    
829    
830     def doConfigSetup(self, fn='/tmp/anaconda-yum.conf', root='/'):
831     if hasattr(self, "preconf"):
832     self.preconf.fn = fn
833     self.preconf.root = root
834     self.preconf.releasever = self._getReleasever()
835     self.preconf.enabled_plugins = ["whiteout", "blacklist", "pidplugin"]
836     YumSorter._getConfig(self)
837     else:
838     YumSorter._getConfig(self, fn=fn, root=root,
839     enabled_plugins=["whiteout", "blacklist", "pidplugin"])
840     self.configBaseRepo(root=root)
841    
842     extraRepos = []
843    
844     ddArch = os.uname()[4]
845    
846     #Add the Driver disc repos to Yum
847     for d in glob.glob(DD_RPMS):
848     dirname = os.path.basename(d)
849     rid = "anaconda-%s" % dirname
850    
851     repo = AnacondaYumRepo(rid)
852     repo.baseurl = [ "file://%s" % d ]
853     repo.name = "Driver Disk %s" % dirname.split("-")[1]
854     repo.enable()
855     extraRepos.append(repo)
856    
857     if self.anaconda.isKickstart:
858     for ksrepo in self.anaconda.id.ksdata.repo.repoList:
859     anacondaBaseURLs = [ksrepo.baseurl]
860    
861     # yum doesn't understand nfs:// and doesn't want to. We need
862     # to first do the mount, then translate it into a file:// that
863     # yum does understand.
864     # "nfs:" and "nfs://" prefixes are accepted in ks repo --baseurl
865     if ksrepo.baseurl and ksrepo.baseurl.startswith("nfs:"):
866     dest = tempfile.mkdtemp("", ksrepo.name.replace(" ", ""), "/mnt")
867    
868     # handle "nfs://" prefix
869     if ksrepo.baseurl[4:6] == '//':
870     ksrepo.baseurl = ksrepo.baseurl.replace('//', '', 1)
871     anacondaBaseURLs = [ksrepo.baseurl]
872     try:
873     isys.mount(ksrepo.baseurl[4:], dest, "nfs")
874     except Exception as e:
875     log.error("error mounting NFS repo: %s" % e)
876    
877     ksrepo.baseurl = "file://%s" % dest
878    
879     repo = AnacondaYumRepo(ksrepo.name)
880     repo.mirrorlist = ksrepo.mirrorlist
881     repo.name = ksrepo.name
882    
883     if not ksrepo.baseurl:
884     repo.baseurl = []
885     else:
886     repo.baseurl = [ ksrepo.baseurl ]
887     repo.anacondaBaseURLs = anacondaBaseURLs
888    
889     if ksrepo.cost:
890     repo.cost = ksrepo.cost
891    
892     if ksrepo.excludepkgs:
893     repo.exclude = ksrepo.excludepkgs
894    
895     if ksrepo.includepkgs:
896     repo.includepkgs = ksrepo.includepkgs
897    
898     if ksrepo.noverifyssl:
899     repo.sslverify = False
900    
901     if ksrepo.proxy:
902     self.setProxy(ksrepo, repo)
903     elif self.anaconda.proxy:
904     log.debug("%s will use the global proxy configuration", repo.name)
905     self.setProxy(self.anaconda, repo)
906    
907     repo.enable()
908     extraRepos.append(repo)
909    
910     initialRepos = self.repos.repos.values() + extraRepos
911     for repo in initialRepos:
912     addons = self._getAddons(repo)
913     for addon in addons:
914     addonRepo = AnacondaYumRepo(addon[0])
915     addonRepo.name = addon[1]
916     addonRepo.baseurl = [ addon[2] ]
917    
918     if self.anaconda.proxy:
919     self.setProxy(self.anaconda, addonRepo)
920    
921     extraRepos.append(addonRepo)
922    
923     for repo in extraRepos:
924     try:
925     self.repos.add(repo)
926     log.info("added repository %s with URL %s" % (repo.name, repo.mirrorlist or repo.baseurl[0]))
927     except:
928     log.warning("ignoring duplicate repository %s with URL %s" % (repo.name, repo.mirrorlist or repo.baseurl[0]))
929    
930     self.repos.setCacheDir(self.conf.cachedir)
931    
932     # When upgrading cleanup the yum cache and enable the addons
933     # This has to be called after setCacheDir
934     if self.anaconda.id.getUpgrade():
935     for repo in extraRepos:
936     repo.dirCleanup(upgrade=True)
937     repo.enable()
938     log.info("enabled %s for upgrade" % (repo.name))
939    
940     if os.path.exists("%s/boot/upgrade/install.img" % self.anaconda.rootPath):
941     log.info("REMOVING stage2 image from %s /boot/upgrade" % self.anaconda.rootPath )
942     try:
943     os.unlink("%s/boot/upgrade/install.img" % self.anaconda.rootPath)
944     except:
945     log.warning("failed to clean /boot/upgrade")
946    
947     def downloadHeader(self, po):
948     trynumber = 0
949     while True:
950     # retrying version of download header
951     trynumber += 1
952     try:
953     YumSorter.downloadHeader(self, po)
954     break
955     except yum.Errors.NoMoreMirrorsRepoError:
956     self._handleFailure(po, trynumber)
957     except IOError:
958     self._handleFailure(po, trynumber)
959     except yum.Errors.RepoError, e:
960     continue
961    
962     def _handleFailure(self, package, trynumber=YUM_DOWNLOAD_RETRIES):
963     if not self.isodir and self.currentMedia:
964     buttons = [_("Re_boot"), _("_Eject")]
965     else:
966     buttons = [_("Re_boot"), _("_Retry")]
967    
968     pkgFile = to_unicode(os.path.basename(package.remote_path))
969    
970     if package.repo.needsNetwork() and not network.hasActiveNetDev():
971     if not self.anaconda.intf.enableNetwork():
972     return
973    
974     urlgrabber.grabber.reset_curl_obj()
975    
976     # only show the retry window after 3 tries
977     if trynumber < YUM_DOWNLOAD_RETRIES:
978     log.warning('package download failure, retrying automatically')
979     time.sleep(YUM_DOWNLOAD_DELAY * trynumber)
980     rc = 1
981     else:
982     rc = self.anaconda.intf.messageWindow(_("Error"),
983     _("The file %s cannot be opened. This is due to a missing "
984     "file, a corrupt package or corrupt media. Please "
985     "verify your installation source.\n\n"
986     "If you exit, your system will be left in an inconsistent "
987     "state that will likely require reinstallation.\n\n") %
988     (pkgFile,),
989     type="custom", custom_icon="error",
990     custom_buttons=buttons)
991    
992     if rc == 0:
993     sys.exit(0)
994     else:
995     if os.path.exists(package.localPkg()):
996     os.unlink(package.localPkg())
997    
998     if not self.isodir and self.currentMedia:
999     self._switchCD(self.currentMedia)
1000     else:
1001     return
1002    
1003     def mirrorFailureCB (self, obj, *args, **kwargs):
1004     # This gets called when a mirror fails, but it cannot know whether
1005     # or not there are other mirrors left to try, since it cannot know
1006     # which mirror we were on when we started this particular download.
1007     # Whenever we have run out of mirrors the grabber's get/open/retrieve
1008     # method will raise a URLGrabError exception with errno 256.
1009     grab = self.repos.getRepo(kwargs["repo"]).grab
1010     log.warning("Failed to get %s from mirror %d/%d, "
1011     "or downloaded file is corrupt" % (obj.url, grab._next + 1,
1012     len(grab.mirrors)))
1013    
1014     if self.currentMedia:
1015     dev = self.anaconda.id.storage.devicetree.getDeviceByName(self.anaconda.mediaDevice)
1016     dev.format.mountpoint = self.tree
1017     unmountCD(dev, self.anaconda.intf.messageWindow)
1018     self.currentMedia = None
1019    
1020     def urlgrabberFailureCB (self, obj, *args, **kwargs):
1021     if hasattr(obj, "exception"):
1022     log.warning("Try %s/%s for %s failed: %s" % (obj.tries, obj.retry, obj.url, obj.exception))
1023     else:
1024     log.warning("Try %s/%s for %s failed" % (obj.tries, obj.retry, obj.url))
1025    
1026     if obj.tries == obj.retry:
1027     return
1028    
1029     delay = 0.25*(2**(obj.tries-1))
1030     if delay > 1:
1031     w = self.anaconda.intf.waitWindow(_("Retrying"), _("Retrying download."))
1032     time.sleep(delay)
1033     w.pop()
1034     else:
1035     time.sleep(delay)
1036    
1037     def getDownloadPkgs(self):
1038     downloadpkgs = []
1039     totalSize = 0
1040     totalFiles = 0
1041     for txmbr in self.tsInfo.getMembersWithState(output_states=TS_INSTALL_STATES):
1042     if txmbr.po:
1043     totalSize += int(txmbr.po.returnSimple("installedsize")) / 1024
1044     for filetype in txmbr.po.returnFileTypes():
1045     totalFiles += len(txmbr.po.returnFileEntries(ftype=filetype))
1046     downloadpkgs.append(txmbr.po)
1047    
1048     return (downloadpkgs, totalSize, totalFiles)
1049    
1050     def setColor(self):
1051     if rpmUtils.arch.isMultiLibArch():
1052     self.ts.ts.setColor(3)
1053    
1054     def run(self, instLog, cb, intf, id):
1055     def mediasort(a, b):
1056     # sort so that first CD comes first, etc. -99 is a magic number
1057     # to tell us that the cd should be last
1058     if a == -99:
1059     return 1
1060     elif b == -99:
1061     return -1
1062     if a < b:
1063     return -1
1064     elif a > b:
1065     return 1
1066     return 0
1067    
1068     self.initActionTs()
1069     if id.getUpgrade():
1070     self.ts.ts.setProbFilter(~rpm.RPMPROB_FILTER_DISKSPACE)
1071     self.setColor()
1072    
1073     # If we don't have any required media assume single disc
1074     if self.tsInfo.reqmedia == {}:
1075     self.tsInfo.reqmedia[0] = None
1076     mkeys = self.tsInfo.reqmedia.keys()
1077     mkeys.sort(mediasort)
1078    
1079     if os.path.ismount("/mnt/stage2"):
1080     isys.umount("/mnt/stage2")
1081    
1082     for i in mkeys:
1083     self.tsInfo.curmedia = i
1084     if i > 0:
1085     pkgtup = self.tsInfo.reqmedia[i][0]
1086    
1087     try:
1088     self.dsCallback = DownloadHeaderProgress(intf, self)
1089     self.populateTs(keepold=0)
1090     self.dsCallback.pop()
1091     self.dsCallback = None
1092     except RepoError, e:
1093     msg = _("There was an error running your transaction for "
1094     "the following reason: %s\n") % str(e)
1095    
1096     if self.anaconda.id.upgrade or self.anaconda.isKickstart:
1097     rc = intf.messageWindow(_("Error"), msg, type="custom",
1098     custom_icon="error",
1099     custom_buttons=[_("_Exit installer")])
1100     sys.exit(1)
1101     else:
1102     rc = intf.messageWindow(_("Error"), msg,
1103     type="custom", custom_icon="error",
1104     custom_buttons=[_("_Back"), _("_Exit installer")])
1105    
1106     if rc == 1:
1107     sys.exit(1)
1108     else:
1109     self.tsInfo.curmedia = None
1110     return DISPATCH_BACK
1111    
1112     self.ts.check()
1113     self.ts.order()
1114    
1115     self.anaconda.id.bootloader.trusted_boot = self.isPackageInstalled(name="tboot") and not iutil.inXen()
1116    
1117     if self._run(instLog, cb, intf) == DISPATCH_BACK:
1118     self.tsInfo.curmedia = None
1119     return DISPATCH_BACK
1120    
1121     self.ts.close()
1122    
1123     def _run(self, instLog, cb, intf):
1124     # set log fd. FIXME: this is ugly. see changelog entry from 2005-09-13
1125     self.ts.ts.scriptFd = instLog.fileno()
1126     rpm.setLogFile(instLog)
1127    
1128     uniqueProbs = {}
1129     spaceneeded = {}
1130     spaceprob = ""
1131     fileConflicts = []
1132     fileprob = ""
1133    
1134     try:
1135     self.runTransaction(cb=cb)
1136     except YumBaseError, probs:
1137     # FIXME: we need to actually look at these problems...
1138     probTypes = { rpm.RPMPROB_NEW_FILE_CONFLICT : _('file conflicts'),
1139     rpm.RPMPROB_FILE_CONFLICT : _('file conflicts'),
1140     rpm.RPMPROB_OLDPACKAGE: _('older package(s)'),
1141     rpm.RPMPROB_DISKSPACE: _('insufficient disk space'),
1142     rpm.RPMPROB_DISKNODES: _('insufficient disk inodes'),
1143     rpm.RPMPROB_CONFLICT: _('package conflicts'),
1144     rpm.RPMPROB_PKG_INSTALLED: _('package already installed'),
1145     rpm.RPMPROB_REQUIRES: _('required package'),
1146     rpm.RPMPROB_BADARCH: _('package for incorrect arch'),
1147     rpm.RPMPROB_BADOS: _('package for incorrect os'),
1148     }
1149    
1150     for (descr, (ty, mount, need)) in probs.value: # FIXME: probs.value???
1151     log.error("%s: %s" %(probTypes[ty], descr))
1152     if not uniqueProbs.has_key(ty) and probTypes.has_key(ty):
1153     uniqueProbs[ty] = probTypes[ty]
1154    
1155     if ty == rpm.RPMPROB_DISKSPACE:
1156     spaceneeded[mount] = need
1157     elif ty in [rpm.RPMPROB_NEW_FILE_CONFLICT, rpm.RPMPROB_FILE_CONFLICT]:
1158     fileConflicts.append(descr)
1159    
1160     if spaceneeded:
1161     spaceprob = _("You need more space on the following "
1162     "file systems:\n")
1163    
1164     for (mount, need) in spaceneeded.items():
1165     log.info("(%s, %s)" %(mount, need))
1166    
1167     if mount.startswith("/mnt/sysimage/"):
1168     mount.replace("/mnt/sysimage", "")
1169     elif mount.startswith("/mnt/sysimage"):
1170     mount = "/" + mount.replace("/mnt/sysimage", "")
1171    
1172     spaceprob += "%d M on %s\n" % (need / (1024*1024), mount)
1173     elif fileConflicts:
1174     fileprob = _("There were file conflicts when checking the "
1175     "packages to be installed:\n%s\n") % ("\n".join(fileConflicts),)
1176    
1177     msg = _("There was an error running your transaction for "
1178     "the following reason(s): %s.\n") % ', '.join(uniqueProbs.values())
1179    
1180     spaceprob = to_unicode(spaceprob)
1181     fileprob = to_unicode(fileprob)
1182    
1183     if len(self.anaconda.backend.getRequiredMedia()) > 1 or \
1184     self.anaconda.id.upgrade or self.anaconda.isKickstart:
1185     intf.detailedMessageWindow(_("Error Running Transaction"),
1186     msg, spaceprob + "\n" + fileprob, type="custom",
1187     custom_icon="error", custom_buttons=[_("_Exit installer")])
1188     sys.exit(1)
1189     else:
1190     rc = intf.detailedMessageWindow(_("Error Running Transaction"),
1191     msg, spaceprob + "\n" + fileprob, type="custom",
1192     custom_icon="error",
1193     custom_buttons=[_("_Back"), _("_Exit installer")])
1194    
1195     if rc == 1:
1196     sys.exit(1)
1197     else:
1198     self._undoDepInstalls()
1199     return DISPATCH_BACK
1200    
1201     def doMacros(self):
1202     for (key, val) in self.macros.items():
1203     rpm.addMacro(key, val)
1204    
1205     def simpleDBInstalled(self, name, arch=None):
1206     # FIXME: doing this directly instead of using self.rpmdb.installed()
1207     # speeds things up by 400%
1208     mi = self.ts.ts.dbMatch('name', name)
1209     if mi.count() == 0:
1210     return False
1211     if arch is None:
1212     return True
1213     if arch in map(lambda h: h['arch'], mi):
1214     return True
1215     return False
1216    
1217     def isPackageInstalled(self, name = None, epoch = None, version = None,
1218     release = None, arch = None, po = None):
1219     # FIXME: this sucks. we should probably suck it into yum proper
1220     # but it'll need a bit of cleanup first.
1221     if po is not None:
1222     (name, epoch, version, release, arch) = po.returnNevraTuple()
1223    
1224     installed = False
1225     if name and not (epoch or version or release or arch):
1226     installed = self.simpleDBInstalled(name)
1227     elif self.rpmdb.installed(name = name, epoch = epoch, ver = version,
1228     rel = release, arch = arch):
1229     installed = True
1230    
1231     lst = self.tsInfo.matchNaevr(name = name, epoch = epoch,
1232     ver = version, rel = release,
1233     arch = arch)
1234     for txmbr in lst:
1235     if txmbr.output_state in TS_INSTALL_STATES:
1236     return True
1237     if installed and len(lst) > 0:
1238     # if we get here, then it was installed, but it's in the tsInfo
1239     # for an erase or obsoleted --> not going to be installed at end
1240     return False
1241     return installed
1242    
1243     def isGroupInstalled(self, grp):
1244     if grp.selected:
1245     return True
1246     elif grp.installed and not grp.toremove:
1247     return True
1248     return False
1249    
1250     def _pkgExists(self, pkg):
1251     """Whether or not a given package exists in our universe."""
1252     try:
1253     pkgs = self.pkgSack.returnNewestByName(pkg)
1254     return True
1255     except yum.Errors.PackageSackError:
1256     pass
1257     try:
1258     pkgs = self.rpmdb.returnNewestByName(pkg)
1259     return True
1260     except (IndexError, yum.Errors.PackageSackError):
1261     pass
1262     return False
1263    
1264     def _groupHasPackages(self, grp):
1265     # this checks to see if the given group has any packages available
1266     # (ie, already installed or in the sack of available packages)
1267     # so that we don't show empty groups. also, if there are mandatory
1268     # packages and we have none of them, don't show
1269     for pkg in grp.mandatory_packages.keys():
1270     if self._pkgExists(pkg):
1271     return True
1272     if len(grp.mandatory_packages) > 0:
1273     return False
1274     for pkg in grp.default_packages.keys() + grp.optional_packages.keys() + \
1275     grp.conditional_packages.keys():
1276     if self._pkgExists(pkg):
1277     return True
1278     return False
1279    
1280     class YumBackend(AnacondaBackend):
1281     def __init__ (self, anaconda):
1282     AnacondaBackend.__init__(self, anaconda)
1283     self.supportsPackageSelection = True
1284    
1285     buf = """
1286     [main]
1287     installroot=%s
1288     cachedir=/var/cache/yum
1289     keepcache=0
1290     logfile=/tmp/yum.log
1291     metadata_expire=0
1292     obsoletes=True
1293     pluginpath=/usr/lib/yum-plugins,/tmp/updates/yum-plugins
1294     pluginconfpath=/etc/yum/pluginconf.d,/tmp/updates/pluginconf.d
1295     plugins=1
1296     reposdir=/etc/anaconda.repos.d,/tmp/updates/anaconda.repos.d,/tmp/product/anaconda.repos.d
1297     debuglevel=6
1298     """ % (anaconda.rootPath)
1299    
1300     if anaconda.proxy:
1301     buf += "proxy=%s\n" % anaconda.proxy
1302    
1303     if anaconda.proxyUsername:
1304     buf += "proxy_username=%s\n" % anaconda.proxyUsername
1305    
1306     if anaconda.proxyPassword:
1307     buf += "proxy_password=%s\n" % anaconda.proxyPassword
1308    
1309     fd = open("/tmp/anaconda-yum.conf", "w")
1310     fd.write(buf)
1311     fd.close()
1312    
1313     def complete(self, anaconda):
1314     if not anaconda.mediaDevice and os.path.ismount(self.ayum.tree):
1315     isys.umount(self.ayum.tree)
1316    
1317     # clean up rpmdb locks so that kickstart %post scripts aren't
1318     # unhappy (#496961)
1319     iutil.resetRpmDb(anaconda.rootPath)
1320    
1321     def doBackendSetup(self, anaconda):
1322     if anaconda.dir == DISPATCH_BACK:
1323     return DISPATCH_BACK
1324    
1325     if anaconda.id.getUpgrade():
1326     # FIXME: make sure that the rpmdb doesn't have stale locks :/
1327     iutil.resetRpmDb(anaconda.rootPath)
1328    
1329     iutil.writeRpmPlatform()
1330     self.ayum = AnacondaYum(anaconda)
1331     self.ayum.setup()
1332     self.ayum.doMacros()
1333    
1334     # If any enabled repositories require networking, go ahead and bring
1335     # it up now. No need to have people wait for the timeout when we
1336     # know this in advance.
1337     if len(filter(lambda r: r.needsNetwork(), self.ayum.repos.listEnabled())) > 0 and \
1338     not network.hasActiveNetDev():
1339     if not anaconda.intf.enableNetwork():
1340     anaconda.intf.messageWindow(_("No Network Available"),
1341     _("Some of your software repositories require "
1342     "networking, but there was an error enabling the "
1343     "network on your system."),
1344     type="custom", custom_icon="error",
1345     custom_buttons=[_("_Exit installer")])
1346     sys.exit(1)
1347    
1348     urlgrabber.grabber.reset_curl_obj()
1349    
1350     self.doRepoSetup(anaconda)
1351     self.doSackSetup(anaconda)
1352     self.doGroupSetup(anaconda)
1353    
1354     self.ayum.doMacros()
1355    
1356     def doGroupSetup(self, anaconda):
1357     while True:
1358     try:
1359     # FIXME: this is a pretty ugly hack to make it so that we don't lose
1360     # groups being selected (#237708)
1361     sel = filter(lambda g: g.selected, self.ayum.comps.get_groups())
1362     self.ayum.doGroupSetup()
1363     # now we'll actually reselect groups..
1364     map(lambda g: self.selectGroup(g.groupid), sel)
1365    
1366     # and now, to add to the hacks, we'll make sure that packages don't
1367     # have groups double-listed. this avoids problems with deselecting
1368     # groups later
1369     for txmbr in self.ayum.tsInfo.getMembers():
1370     txmbr.groups = yum.misc.unique(txmbr.groups)
1371     except (GroupsError, NoSuchGroup, RepoError), e:
1372     buttons = [_("_Exit installer"), _("_Retry")]
1373     else:
1374     break # success
1375    
1376     rc = anaconda.intf.messageWindow(_("Error"),
1377     _("Unable to read group information "
1378     "from repositories. This is "
1379     "a problem with the generation "
1380     "of your install tree."),
1381     type="custom", custom_icon="error",
1382     custom_buttons = buttons)
1383     if rc == 0:
1384     sys.exit(0)
1385     else:
1386     self.ayum._setGroups(None)
1387     continue
1388    
1389     def doRepoSetup(self, anaconda, thisrepo = None, fatalerrors = True):
1390     self.__withFuncDo(anaconda, lambda r: self.ayum.doRepoSetup(thisrepo=r.id),
1391     thisrepo=thisrepo, fatalerrors=fatalerrors,
1392     callback=RepoSetupPulseProgress(anaconda.intf))
1393    
1394     def doSackSetup(self, anaconda, thisrepo = None, fatalerrors = True):
1395     self.__withFuncDo(anaconda, lambda r: self.ayum.doSackSetup(thisrepo=r.id),
1396     thisrepo=thisrepo, fatalerrors=fatalerrors,
1397     callback=SackSetupProgress(anaconda.intf))
1398    
1399     def __withFuncDo(self, anaconda, fn, thisrepo=None, fatalerrors=True,
1400     callback=None):
1401     # Don't do this if we're being called as a dispatcher step (instead
1402     # of being called when a repo is added via the UI) and we're going
1403     # back.
1404     if thisrepo is None and anaconda.dir == DISPATCH_BACK:
1405     return
1406    
1407     # We want to call the function one repo at a time so we have some
1408     # concept of which repo didn't set up correctly.
1409     if thisrepo is not None:
1410     repos = [self.ayum.repos.getRepo(thisrepo)]
1411     else:
1412     repos = self.ayum.repos.listEnabled()
1413    
1414     for repo in repos:
1415     if callback:
1416     callback.connect(repo)
1417    
1418     while True:
1419     try:
1420     fn(repo)
1421     if callback:
1422     callback.disconnect()
1423     except RepoError, e:
1424     if callback:
1425     callback.disconnect()
1426     if repo.needsNetwork() and not network.hasActiveNetDev():
1427     if anaconda.intf.enableNetwork():
1428     repo.mirrorlistparsed = False
1429     continue
1430    
1431     urlgrabber.grabber.reset_curl_obj()
1432    
1433     buttons = [_("_Exit installer"), _("Edit"), _("_Retry")]
1434     else:
1435     break # success
1436    
1437     if anaconda.isKickstart:
1438     buttons.append(_("_Continue"))
1439    
1440     if not fatalerrors:
1441     raise RepoError, e
1442    
1443     rc = anaconda.intf.messageWindow(_("Error"),
1444     _("Unable to read package metadata. This may be "
1445     "due to a missing repodata directory. Please "
1446     "ensure that your install tree has been "
1447     "correctly generated.\n\n%s" % e),
1448     type="custom", custom_icon="error",
1449     custom_buttons=buttons)
1450     if rc == 0:
1451     # abort
1452     sys.exit(0)
1453     elif rc == 1:
1454     # edit
1455     anaconda.intf.editRepoWindow(repo)
1456     break
1457     elif rc == 2:
1458     # retry, but only if button is present
1459     continue
1460     else:
1461     # continue, but only if button is present
1462     self.ayum.repos.delete(repo.id)
1463     break
1464    
1465     # if we're in kickstart the repo may have been deleted just above
1466     try:
1467     self.ayum.repos.getRepo(repo.id)
1468     except RepoError:
1469     log.debug("repo %s has been removed" % (repo.id,))
1470     continue
1471    
1472     repo.setFailureObj(self.ayum.urlgrabberFailureCB)
1473     repo.setMirrorFailureObj((self.ayum.mirrorFailureCB, (),
1474     {"repo": repo.id}))
1475    
1476     self.ayum.repos.callback = None
1477    
1478     def getDefaultGroups(self, anaconda):
1479     langs = anaconda.id.instLanguage.getCurrentLangSearchList()
1480     rc = map(lambda x: x.groupid,
1481     filter(lambda x: x.default, self.ayum.comps.groups))
1482     for g in self.ayum.comps.groups:
1483     if g.langonly in langs:
1484     rc.append(g.groupid)
1485     return rc
1486    
1487     def resetPackageSelections(self):
1488     """Reset the package selection to an empty state."""
1489     for txmbr in self.ayum.tsInfo:
1490     self.ayum.tsInfo.remove(txmbr.pkgtup)
1491     self.ayum.tsInfo.conditionals.clear()
1492     for grp in self.ayum.comps.groups:
1493     grp.selected = False
1494    
1495     def selectModulePackages(self, anaconda, kernelPkgName):
1496     (base, sep, ext) = kernelPkgName.partition("-")
1497    
1498     moduleProvides = []
1499    
1500     for (path, name) in anaconda.id.extraModules:
1501     if ext != "":
1502     moduleProvides.append("dud-%s-%s" % (name, ext))
1503     else:
1504     moduleProvides.append("dud-%s" % name)
1505    
1506     #We need to install the packages which contain modules from DriverDiscs
1507     for modPath in isys.modulesWithPaths():
1508     log.debug("Checking for DUD module "+modPath)
1509     match = DD_EXTRACTED.match(modPath)
1510     if match:
1511     log.info("Requesting install of kmod-%s" % (match.group("modulename")))
1512     moduleProvides.append("kmod-"+match.group("modulename"))
1513     else:
1514     continue
1515    
1516     for module in moduleProvides:
1517     pkgs = self.ayum.returnPackagesByDep(module)
1518    
1519     if not pkgs:
1520     log.warning("Didn't find any package providing %s" % module)
1521    
1522     for pkg in pkgs:
1523     log.info("selecting package %s for %s" % (pkg.name, module))
1524     self.ayum.install(po=pkg)
1525    
1526     def selectBestKernel(self, anaconda):
1527     """Find the best kernel package which is available and select it."""
1528    
1529     def getBestKernelByArch(pkgname, ayum):
1530     """Convenience func to find the best arch of a kernel by name"""
1531     try:
1532     pkgs = ayum.pkgSack.returnNewestByName(pkgname)
1533     except yum.Errors.PackageSackError:
1534     return None
1535    
1536     pkgs = self.ayum.bestPackagesFromList(pkgs)
1537     if len(pkgs) == 0:
1538     return None
1539     return pkgs[0]
1540    
1541     def selectKernel(pkgname):
1542     try:
1543     pkg = getBestKernelByArch(pkgname, self.ayum)
1544     except PackageSackError:
1545     log.debug("no %s package" % pkgname)
1546     return False
1547    
1548     if not pkg:
1549     return False
1550    
1551     log.info("selected %s package for kernel" % pkg.name)
1552     self.ayum.install(po=pkg)
1553     self.selectModulePackages(anaconda, pkg.name)
1554    
1555     if len(self.ayum.tsInfo.matchNaevr(name="gcc")) > 0:
1556     log.debug("selecting %s-devel" % pkg.name)
1557     self.selectPackage("%s-devel.%s" % (pkg.name, pkg.arch))
1558    
1559     return True
1560    
1561     foundkernel = False
1562    
1563     if not foundkernel and isys.isPaeAvailable():
1564     if selectKernel("kernel-PAE"):
1565     foundkernel = True
1566    
1567     if not foundkernel:
1568     selectKernel("kernel")
1569    
1570     def selectFSPackages(self, storage):
1571     for device in storage.fsset.devices:
1572     # this takes care of device and filesystem packages
1573     map(self.selectPackage, device.packages)
1574    
1575     # anaconda requires several programs on the installed system to complete
1576     # installation, but we have no guarantees that some of these will be
1577     # installed (they could have been removed in kickstart). So we'll force
1578     # it.
1579     def selectAnacondaNeeds(self):
1580     for pkg in ['authconfig', 'chkconfig', 'system-config-firewall-base']:
1581     self.selectPackage(pkg)
1582    
1583     def doPostSelection(self, anaconda):
1584     # Only solve dependencies on the way through the installer, not the way back.
1585     if anaconda.dir == DISPATCH_BACK:
1586     return
1587    
1588     dscb = YumDepSolveProgress(anaconda.intf, self.ayum)
1589     self.ayum.dsCallback = dscb
1590    
1591     # do some sanity checks for kernel and bootloader
1592     if not anaconda.id.getUpgrade():
1593     # New installs only - upgrades will already have all this stuff.
1594     self.selectBestKernel(anaconda)
1595     map(self.selectPackage, anaconda.platform.packages)
1596     self.selectFSPackages(anaconda.id.storage)
1597     if anaconda.id.network.hasActiveIPoIBDevice():
1598     self.selectPackage("rdma")
1599     self.selectAnacondaNeeds()
1600     else:
1601     self.ayum.update()
1602    
1603     while True:
1604     try:
1605     (code, msgs) = self.ayum.buildTransaction()
1606    
1607     # If %packages --ignoremissing was given, don't bother
1608     # prompting for missing dependencies.
1609     if anaconda.isKickstart and anaconda.id.ksdata.packages.handleMissing == KS_MISSING_IGNORE:
1610     break
1611    
1612     if code == 1 and not anaconda.id.upgrade:
1613     # resolveDeps returns 0 if empty transaction, 1 if error,
1614     # 2 if success
1615     depprob = "\n".join(msgs)
1616    
1617     custom_buttons = [_("_Exit installer"), _("_Continue")]
1618     if not anaconda.isKickstart:
1619     custom_buttons.insert(1, _("_Back"))
1620    
1621     rc = anaconda.intf.detailedMessageWindow(_("Warning"),
1622     _("Some of the packages you have selected for "
1623     "install are missing dependencies. You can "
1624     "exit the installation, go back and change "
1625     "your package selections, or continue "
1626     "installing these packages without their "
1627     "dependencies."),
1628     depprob + "\n", type="custom", custom_icon="error",
1629     custom_buttons=custom_buttons)
1630     dscb.pop()
1631    
1632     if rc == 0:
1633     sys.exit(1)
1634     elif rc == 1 and not anaconda.isKickstart:
1635     self.ayum._undoDepInstalls()
1636     return DISPATCH_BACK
1637    
1638     break
1639     except RepoError, e:
1640     # FIXME: would be nice to be able to recover here
1641     rc = anaconda.intf.messageWindow(_("Error"),
1642     _("Unable to read package metadata. This may be "
1643     "due to a missing repodata directory. Please "
1644     "ensure that your install tree has been "
1645     "correctly generated.\n\n%s" % e),
1646     type="custom", custom_icon="error",
1647     custom_buttons=[_("_Exit installer"), _("_Retry")])
1648     dscb.pop()
1649    
1650     if rc == 0:
1651     sys.exit(0)
1652     else:
1653     continue
1654     else:
1655     break
1656    
1657     (self.dlpkgs, self.totalSize, self.totalFiles) = self.ayum.getDownloadPkgs()
1658    
1659     if not anaconda.id.upgrade:
1660     largePart = anaconda.id.storage.mountpoints.get("/usr", anaconda.id.storage.rootDevice)
1661    
1662     if largePart and largePart.size < self.totalSize / 1024:
1663     rc = anaconda.intf.messageWindow(_("Error"),
1664     _("Your selected packages require %d MB "
1665     "of free space for installation, but "
1666     "you do not have enough available. "
1667     "You can change your selections or "
1668     "exit the installer." % (self.totalSize / 1024)),
1669     type="custom", custom_icon="error",
1670     custom_buttons=[_("_Back"), _("_Exit installer")])
1671    
1672     dscb.pop()
1673    
1674     if rc == 1:
1675     sys.exit(1)
1676     else:
1677     self.ayum._undoDepInstalls()
1678     return DISPATCH_BACK
1679    
1680     dscb.pop()
1681    
1682     if anaconda.mediaDevice and not anaconda.isKickstart:
1683     rc = presentRequiredMediaMessage(anaconda)
1684     if rc == 0:
1685     rc2 = anaconda.intf.messageWindow(_("Reboot?"),
1686     _("The system will be rebooted now."),
1687     type="custom", custom_icon="warning",
1688     custom_buttons=[_("_Back"), _("_Reboot")])
1689     if rc2 == 1:
1690     sys.exit(0)
1691     else:
1692     return DISPATCH_BACK
1693     elif rc == 1: # they asked to go back
1694     return DISPATCH_BACK
1695    
1696     self.ayum.dsCallback = None
1697    
1698     def doPreInstall(self, anaconda):
1699     if anaconda.dir == DISPATCH_BACK:
1700     for d in ("/selinux", "/dev", "/proc/bus/usb"):
1701     try:
1702     isys.umount(anaconda.rootPath + d, removeDir = False)
1703     except Exception, e:
1704     log.error("unable to unmount %s: %s" %(d, e))
1705     return
1706    
1707     # shorthand
1708     upgrade = anaconda.id.getUpgrade()
1709    
1710     if upgrade:
1711     # An old mtab can cause confusion (esp if loop devices are
1712     # in it). Be extra special careful and delete any mtab first,
1713     # in case the user has done something funny like make it into
1714     # a symlink.
1715     if os.access(anaconda.rootPath + "/etc/mtab", os.F_OK):
1716     os.remove(anaconda.rootPath + "/etc/mtab")
1717    
1718     f = open(anaconda.rootPath + "/etc/mtab", "w+")
1719     f.close()
1720    
1721     # we really started writing modprobe.conf out before things were
1722     # all completely ready. so now we need to nuke old modprobe.conf's
1723     # if you're upgrading from a 2.4 dist so that we can get the
1724     # transition right
1725     if (os.path.exists(anaconda.rootPath + "/etc/modules.conf") and
1726     os.path.exists(anaconda.rootPath + "/etc/modprobe.conf") and
1727     not os.path.exists(anaconda.rootPath + "/etc/modprobe.conf.anacbak")):
1728     log.info("renaming old modprobe.conf -> modprobe.conf.anacbak")
1729     os.rename(anaconda.rootPath + "/etc/modprobe.conf",
1730     anaconda.rootPath + "/etc/modprobe.conf.anacbak")
1731    
1732     dirList = ['/var', '/var/lib', '/var/lib/rpm', '/tmp', '/dev', '/etc',
1733     '/etc/sysconfig', '/etc/sysconfig/network-scripts',
1734     '/etc/X11', '/root', '/var/tmp', '/etc/rpm', '/var/cache',
1735     '/var/cache/yum', '/etc/modprobe.d']
1736    
1737     # If there are any protected partitions we want to mount, create their
1738     # mount points now.
1739     for protected in anaconda.id.storage.protectedDevices:
1740     if getattr(protected.format, "mountpoint", None):
1741     dirList.append(protected.format.mountpoint)
1742    
1743     for i in dirList:
1744     try:
1745     os.mkdir(anaconda.rootPath + i)
1746     except os.error, (errno, msg):
1747     pass
1748     # log.error("Error making directory %s: %s" % (i, msg))
1749    
1750     self.initLog(anaconda.id, anaconda.rootPath)
1751    
1752     # setup /etc/rpm/ for the post-install environment
1753     iutil.writeRpmPlatform(anaconda.rootPath)
1754    
1755     try:
1756     # FIXME: making the /var/lib/rpm symlink here is a hack to
1757     # workaround db->close() errors from rpm
1758     iutil.mkdirChain("/var/lib")
1759     for path in ("/var/tmp", "/var/lib/rpm"):
1760     if os.path.exists(path) and not os.path.islink(path):
1761     shutil.rmtree(path)
1762     if not os.path.islink(path):
1763     os.symlink("%s/%s" %(anaconda.rootPath, path), "%s" %(path,))
1764     else:
1765     log.warning("%s already exists as a symlink to %s" %(path, os.readlink(path),))
1766     except Exception, e:
1767     # how this could happen isn't entirely clear; log it in case
1768     # it does and causes problems later
1769     log.error("error creating symlink, continuing anyway: %s" %(e,))
1770    
1771     # SELinux hackery (#121369)
1772     if flags.selinux:
1773     try:
1774     os.mkdir(anaconda.rootPath + "/selinux")
1775     except Exception, e:
1776     pass
1777     try:
1778     isys.mount("/selinux", anaconda.rootPath + "/selinux", "selinuxfs")
1779     except Exception, e:
1780     log.error("error mounting selinuxfs: %s" %(e,))
1781    
1782     # For usbfs
1783     try:
1784     isys.mount("/proc/bus/usb", anaconda.rootPath + "/proc/bus/usb", "usbfs")
1785     except Exception, e:
1786     log.error("error mounting usbfs: %s" %(e,))
1787    
1788     # write out the fstab
1789     if not upgrade:
1790     anaconda.id.storage.fsset.write(anaconda.rootPath)
1791     if os.access("/etc/modprobe.d/anaconda.conf", os.R_OK):
1792     shutil.copyfile("/etc/modprobe.d/anaconda.conf",
1793     anaconda.rootPath + "/etc/modprobe.d/anaconda.conf")
1794     anaconda.id.network.write()
1795     anaconda.id.network.copyConfigToPath(instPath=anaconda.rootPath)
1796     anaconda.id.storage.write(anaconda.rootPath)
1797     if not anaconda.id.isHeadless:
1798     anaconda.id.keyboard.write(anaconda.rootPath)
1799    
1800     # make a /etc/mtab so mkinitrd can handle certain hw (usb) correctly
1801     f = open(anaconda.rootPath + "/etc/mtab", "w+")
1802     f.write(anaconda.id.storage.mtab)
1803     f.close()
1804    
1805     def checkSupportedUpgrade(self, anaconda):
1806     if anaconda.dir == DISPATCH_BACK:
1807     return
1808     self._checkUpgradeVersion(anaconda)
1809     self._checkUpgradeArch(anaconda)
1810    
1811     def _checkUpgradeVersion(self, anaconda):
1812     # Figure out current version for upgrade nag and for determining weird
1813     # upgrade cases
1814     supportedUpgradeVersion = -1
1815     for pkgtup in self.ayum.rpmdb.whatProvides('redhat-release', None, None):
1816     n, a, e, v, r = pkgtup
1817     if supportedUpgradeVersion <= 0:
1818     val = rpmUtils.miscutils.compareEVR((None, '9.0', '1'),
1819     (e, v,r))
1820     if val > 0:
1821     supportedUpgradeVersion = 0
1822     else:
1823     supportedUpgradeVersion = 1
1824     break
1825    
1826     if "SME Server" not in productName:
1827     supportedUpgradeVersion = 1
1828    
1829     if supportedUpgradeVersion == 0:
1830     rc = anaconda.intf.messageWindow(_("Warning"),
1831     _("You appear to be upgrading from a system "
1832     "which is too old to upgrade to this "
1833     "version of %s. Are you sure you wish to "
1834     "continue the upgrade "
1835     "process?") %(productName,),
1836     type = "yesno")
1837     if rc == 0:
1838     iutil.resetRpmDb(anaconda.rootPath)
1839     sys.exit(0)
1840    
1841     def _checkUpgradeArch(self, anaconda):
1842     def compareArch(a, b):
1843     if re.match("i.86", a) and re.match("i.86", b):
1844     return True
1845     else:
1846     return a == b
1847    
1848     # get the arch of the initscripts package
1849     try:
1850     pkgs = self.ayum.pkgSack.returnNewestByName('initscripts')
1851     except yum.Errors.PackageSackError:
1852     log.info("no packages named initscripts")
1853     return None
1854    
1855     pkgs = self.ayum.bestPackagesFromList(pkgs)
1856     if len(pkgs) == 0:
1857     log.info("no best package")
1858     return
1859     myarch = pkgs[0].arch
1860    
1861     log.info("initscripts is arch: %s" %(myarch,))
1862     for po in self.ayum.rpmdb.getProvides('initscripts'):
1863     log.info("po.arch is arch: %s" %(po.arch,))
1864     if not compareArch(po.arch, myarch):
1865     rc = anaconda.intf.messageWindow(_("Warning"),
1866     _("The arch of the release of %(productName)s you "
1867     "are upgrading to appears to be %(myarch)s which "
1868     "does not match your previously installed arch of "
1869     "%(arch)s. This is likely to not succeed. Are "
1870     "you sure you wish to continue the upgrade "
1871     "process?")
1872     % {'productName': productName,
1873     'myarch': myarch,
1874     'arch': po.arch},
1875     type="yesno")
1876     if rc == 0:
1877     iutil.resetRpmDb(anaconda.rootPath)
1878     sys.exit(0)
1879     else:
1880     log.warning("upgrade between possibly incompatible "
1881     "arches %s -> %s" %(po.arch, myarch))
1882     break
1883    
1884     def doInstall(self, anaconda):
1885     log.info("Preparing to install packages")
1886    
1887     if not anaconda.id.upgrade:
1888     rpm.addMacro("__dbi_htconfig",
1889     "hash nofsync %{__dbi_other} %{__dbi_perms}")
1890    
1891     if anaconda.isKickstart and anaconda.id.ksdata.packages.excludeDocs:
1892     rpm.addMacro("_excludedocs", "1")
1893    
1894     cb = AnacondaCallback(self.ayum, anaconda,
1895     self.instLog, self.modeText)
1896     cb.setSizes(len(self.dlpkgs), self.totalSize, self.totalFiles)
1897    
1898     rc = self.ayum.run(self.instLog, cb, anaconda.intf, anaconda.id)
1899    
1900     if cb.initWindow is not None:
1901     cb.initWindow.pop()
1902    
1903     self.instLog.write("*** FINISHED INSTALLING PACKAGES ***")
1904     self.instLog.close ()
1905    
1906     anaconda.id.instProgress = None
1907    
1908     if rc == DISPATCH_BACK:
1909     return DISPATCH_BACK
1910    
1911     def doPostInstall(self, anaconda):
1912     if anaconda.id.getUpgrade():
1913     w = anaconda.intf.waitWindow(_("Post Upgrade"),
1914     _("Performing post-upgrade configuration"))
1915     else:
1916     w = anaconda.intf.waitWindow(_("Post Installation"),
1917     _("Performing post-installation configuration"))
1918    
1919     packages.rpmSetupGraphicalSystem(anaconda)
1920    
1921     for repo in self.ayum.repos.listEnabled():
1922     repo.dirCleanup()
1923    
1924     # expire yum caches on upgrade
1925     if (flags.cmdline.has_key("preupgrade") or anaconda.id.getUpgrade()) and os.path.exists("%s/var/cache/yum" %(anaconda.rootPath,)):
1926     log.info("Expiring yum caches")
1927     try:
1928     iutil.execWithRedirect("yum", ["clean", "all"],
1929     stdout="/dev/tty5", stderr="/dev/tty5",
1930     root = anaconda.rootPath)
1931     except:
1932     pass
1933    
1934     # nuke preupgrade
1935     if flags.cmdline.has_key("preupgrade") and os.path.exists("%s/var/cache/yum/anaconda-upgrade" %(anaconda.rootPath,)):
1936     try:
1937     shutil.rmtree("%s/var/cache/yum/anaconda-upgrade" %(anaconda.rootPath,))
1938     except:
1939     pass
1940    
1941     # XXX: write proper lvm config
1942    
1943     AnacondaBackend.doPostInstall(self, anaconda)
1944     w.pop()
1945    
1946     def kernelVersionList(self, rootPath="/"):
1947     # FIXME: using rpm here is a little lame, but otherwise, we'd
1948     # be pulling in filelists
1949     return packages.rpmKernelVersionList(rootPath)
1950    
1951     def __getGroupId(self, group):
1952     """Get the groupid for the given name (english or translated)."""
1953     for g in self.ayum.comps.groups:
1954     if group == g.name:
1955     return g.groupid
1956     for trans in g.translated_name.values():
1957     if group == trans:
1958     return g.groupid
1959    
1960     def isGroupSelected(self, group):
1961     try:
1962     grp = self.ayum.comps.return_group(group)
1963     if grp.selected: return True
1964     except yum.Errors.GroupsError, e:
1965     pass
1966     return False
1967    
1968     def selectGroup(self, group, *args):
1969     if not self.ayum.comps.has_group(group):
1970     log.debug("no such group %s" % group)
1971     raise NoSuchGroup, group
1972    
1973     types = ["mandatory"]
1974    
1975     if args:
1976     if args[0][0]:
1977     types.append("default")
1978     if args[0][1]:
1979     types.append("optional")
1980     else:
1981     types.append("default")
1982    
1983     try:
1984     mbrs = self.ayum.selectGroup(group, group_package_types=types)
1985     if len(mbrs) == 0 and self.isGroupSelected(group):
1986     return
1987     except yum.Errors.GroupsError, e:
1988     # try to find out if it's the name or translated name
1989     gid = self.__getGroupId(group)
1990     if gid is not None:
1991     mbrs = self.ayum.selectGroup(gid, group_package_types=types)
1992     if len(mbrs) == 0 and self.isGroupSelected(gid):
1993     return
1994     else:
1995     log.debug("no such group %s" %(group,))
1996     raise NoSuchGroup, group
1997    
1998     def deselectGroup(self, group, *args):
1999     try:
2000     self.ayum.deselectGroup(group, force=True)
2001     except yum.Errors.GroupsError, e:
2002     # try to find out if it's the name or translated name
2003     gid = self.__getGroupId(group)
2004     if gid is not None:
2005     self.ayum.deselectGroup(gid, force=True)
2006     else:
2007     log.debug("no such group %s" %(group,))
2008    
2009     def selectPackage(self, pkg, *args):
2010     try:
2011     mbrs = self.ayum.install(pattern=pkg)
2012     return len(mbrs)
2013     except yum.Errors.InstallError:
2014     log.debug("no package matching %s" %(pkg,))
2015     return 0
2016    
2017     def deselectPackage(self, pkg, *args):
2018     sp = pkg.rsplit(".", 2)
2019     txmbrs = []
2020     if len(sp) == 2:
2021     txmbrs = self.ayum.tsInfo.matchNaevr(name=sp[0], arch=sp[1])
2022    
2023     if len(txmbrs) == 0:
2024     exact, match, unmatch = yum.packages.parsePackages(self.ayum.pkgSack.returnPackages(), [pkg], casematch=1)
2025     for p in exact + match:
2026     txmbrs.append(p)
2027    
2028     if len(txmbrs) > 0:
2029     for x in txmbrs:
2030     self.ayum.tsInfo.remove(x.pkgtup)
2031     # we also need to remove from the conditionals
2032     # dict so that things don't get pulled back in as a result
2033     # of them. yes, this is ugly. conditionals should die.
2034     for req, pkgs in self.ayum.tsInfo.conditionals.iteritems():
2035     if x in pkgs:
2036     pkgs.remove(x)
2037     self.ayum.tsInfo.conditionals[req] = pkgs
2038     return len(txmbrs)
2039     else:
2040     log.debug("no such package %s to remove" %(pkg,))
2041     return 0
2042    
2043     def groupListExists(self, grps):
2044     """Returns bool of whether all of the given groups exist."""
2045     for gid in grps:
2046     g = self.ayum.comps.return_group(gid)
2047     if not g:
2048     log.debug("no such group %s" % (gid,))
2049     return False
2050     return True
2051    
2052     def groupListDefault(self, grps):
2053     """Returns bool of whether all of the given groups are default"""
2054     rc = False
2055     for gid in grps:
2056     g = self.ayum.comps.return_group(gid)
2057     if g and not g.default:
2058     return False
2059     elif g:
2060     rc = True
2061     return rc
2062    
2063     def writeKS(self, f):
2064     for repo in self.ayum.repos.listEnabled():
2065     if repo.name == "Installation Repo":
2066     continue
2067     if repo.name == "Red Hat Enterprise Linux":
2068     continue
2069     # ignore addon repos from media
2070     if repo.anacondaBaseURLs[0].startswith("file://"):
2071     continue
2072    
2073     line = "repo --name=\"%s\" " % (repo.name or repo.repoid)
2074    
2075     if repo.baseurl:
2076     line += " --baseurl=%s" % repo.anacondaBaseURLs[0]
2077     else:
2078     line += " --mirrorlist=%s" % repo.mirrorlist
2079    
2080     if repo.proxy:
2081     line += " --proxy=\"%s\"" % repo.proxy_dict['http']
2082    
2083     if repo.cost:
2084     line += " --cost=%s" % repo.cost
2085    
2086     if repo.includepkgs:
2087     line += " --includepkgs=\"%s\"" % ",".join(repo.includepkgs)
2088    
2089     if repo.exclude:
2090     line += " --excludepkgs=\"%s\"" % ",".join(repo.exclude)
2091    
2092     if not repo.sslverify:
2093     line += " --noverifyssl"
2094    
2095     line += "\n"
2096    
2097     f.write(line)
2098    
2099     def writePackagesKS(self, f, anaconda):
2100     if anaconda.isKickstart:
2101     f.write(anaconda.id.ksdata.packages.__str__())
2102     return
2103    
2104     groups = []
2105     installed = []
2106     removed = []
2107    
2108     # Faster to grab all the package names up front rather than call
2109     # searchNevra in the loop below.
2110     allPkgNames = map(lambda pkg: pkg.name, self.ayum.pkgSack.returnPackages())
2111     allPkgNames.sort()
2112    
2113     # On CD/DVD installs, we have one transaction per CD and will end up
2114     # checking allPkgNames against a very short list of packages. So we
2115     # have to reset to media #0, which is an all packages transaction.
2116     old = self.ayum.tsInfo.curmedia
2117     self.ayum.tsInfo.curmedia = 0
2118    
2119     self.ayum.tsInfo.makelists()
2120     txmbrNames = map (lambda x: x.name, self.ayum.tsInfo.getMembers())
2121    
2122     self.ayum.tsInfo.curmedia = old
2123    
2124     if len(self.ayum.tsInfo.instgroups) == 0 and len(txmbrNames) == 0:
2125     return
2126    
2127     for grp in filter(lambda x: x.selected, self.ayum.comps.groups):
2128     groups.append(grp.groupid)
2129    
2130     defaults = grp.default_packages.keys() + grp.mandatory_packages.keys()
2131     optionals = grp.optional_packages.keys()
2132    
2133     for pkg in filter(lambda x: x in defaults and (not x in txmbrNames and x in allPkgNames), grp.packages):
2134     removed.append(pkg)
2135    
2136     for pkg in filter(lambda x: x in txmbrNames, optionals):
2137     installed.append(pkg)
2138    
2139     if len(groups) == 1 and groups[0].lower() == "core":
2140     f.write("\n%packages --nobase\n")
2141     else:
2142     f.write("\n%packages\n")
2143    
2144     for grp in groups:
2145     f.write("@%s\n" % grp)
2146    
2147     for pkg in installed:
2148     f.write("%s\n" % pkg)
2149    
2150     for pkg in removed:
2151     f.write("-%s\n" % pkg)
2152    
2153     f.write("%end")
2154    
2155     def writeConfiguration(self):
2156     return
2157    
2158     def getRequiredMedia(self):
2159     return self.ayum.tsInfo.reqmedia.keys()
2160    
2161     class DownloadHeaderProgress:
2162     def __init__(self, intf, ayum=None):
2163     window = intf.progressWindow(_("Installation Starting"),
2164     _("Starting installation process"),
2165     1.0, 0.01)
2166     self.window = window
2167     self.ayum = ayum
2168     self.current = self.loopstart = 0
2169     self.incr = 1
2170    
2171     if self.ayum is not None and self.ayum.tsInfo is not None:
2172     self.numpkgs = len(self.ayum.tsInfo.getMembers())
2173     if self.numpkgs != 0:
2174     self.incr = (1.0 / self.numpkgs) * (1.0 - self.loopstart)
2175     else:
2176     self.numpkgs = 0
2177    
2178     self.refresh()
2179    
2180     self.restartLoop = self.downloadHeader = self.transactionPopulation = self.refresh
2181     self.procReq = self.procConflict = self.unresolved = self.noop
2182    
2183     def noop(self, *args, **kwargs):
2184     pass
2185    
2186     def pkgAdded(self, *args):
2187     if self.numpkgs:
2188     self.set(self.current + self.incr)
2189    
2190     def pop(self):
2191     self.window.pop()
2192    
2193     def refresh(self, *args):
2194     self.window.refresh()
2195    
2196     def set(self, value):
2197     self.current = value
2198     self.window.set(self.current)
2199    
2200     class YumDepSolveProgress:
2201     def __init__(self, intf, ayum = None):
2202     window = intf.progressWindow(_("Dependency Check"),
2203     _("Checking dependencies in packages selected for installation"),
2204     1.0, 0.01)
2205     self.window = window
2206    
2207     self.numpkgs = None
2208     self.loopstart = None
2209     self.incr = None
2210     self.ayum = ayum
2211     self.current = 0
2212    
2213     self.restartLoop = self.downloadHeader = self.transactionPopulation = self.refresh
2214     self.procReq = self.procConflict = self.unresolved = self.noop
2215    
2216     def tscheck(self, num = None):
2217     self.refresh()
2218     if num is None and self.ayum is not None and self.ayum.tsInfo is not None:
2219     num = len(self.ayum.tsInfo.getMembers())
2220    
2221     if num:
2222     self.numpkgs = num
2223     self.loopstart = self.current
2224     self.incr = (1.0 / num) * ((1.0 - self.loopstart) / 2)
2225    
2226     def pkgAdded(self, *args):
2227     if self.numpkgs:
2228     self.set(self.current + self.incr)
2229    
2230     def noop(self, *args, **kwargs):
2231     pass
2232    
2233     def refresh(self, *args):
2234     self.window.refresh()
2235    
2236     def set(self, value):
2237     self.current = value
2238     self.window.set(self.current)
2239    
2240     def start(self):
2241     self.set(0.0)
2242     self.refresh()
2243    
2244     def end(self):
2245     self.window.set(1.0)
2246     self.window.refresh()
2247    
2248     def pop(self):
2249     self.window.pop()
2250    
2251     # We don't have reasonable hook for sackSetup, and it
2252     # is fairly fast, so we use just waitWindow here
2253     class SackSetupProgress:
2254     def __init__(self, intf):
2255     self.intf = intf
2256    
2257     def connect(self, repo):
2258     if repo.name is None:
2259     txt = _("Retrieving installation information.")
2260     else:
2261     txt = _("Retrieving installation information for %s.")%(repo.name)
2262     self.window = self.intf.waitWindow(_("Installation Progress"), txt)
2263    
2264     def disconnect(self):
2265     self.window.pop()
2266    
2267     class RepoSetupPulseProgress:
2268     def __init__(self, intf):
2269     self.intf = intf
2270     self.repo = None
2271    
2272     def connect(self, repo):
2273     self.repo = repo
2274     if repo.name is None:
2275     txt = _("Retrieving installation information.")
2276     else:
2277     txt = _("Retrieving installation information for %s.")%(repo.name)
2278     self.window = self.intf.progressWindow(_("Installation Progress"),
2279     txt,
2280     1.0, pulse=True)
2281     repo.setCallback(self)
2282    
2283     def disconnect(self):
2284     self.window.pop()
2285     self.repo.setCallback(None)
2286    
2287     def refresh(self, *args):
2288     self.window.refresh()
2289    
2290     def set(self):
2291     self.window.pulse()
2292    
2293     def start(self, filename, url, basename, size, text):
2294     log.debug("Grabbing %s" % url)
2295     self.set()
2296     self.refresh()
2297    
2298     def update(self, read):
2299     self.set()
2300     self.refresh()
2301    
2302     def end(self, read):
2303     self.set()
2304     self.window.refresh()

admin@koozali.org
ViewVC Help
Powered by ViewVC 1.2.1 RSS 2.0 feed