View file File name : config.py Content :#!/usr/bin/python -t # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # Copyright 2002 Duke University """ Configuration parser and default values for yum. """ _use_iniparse = True import os import sys import warnings import rpm import copy import urlparse import shlex from parser import ConfigPreProcessor, varReplace try: from iniparse import INIConfig from iniparse.compat import NoSectionError, NoOptionError, ParsingError from iniparse.compat import RawConfigParser as ConfigParser except ImportError: _use_iniparse = False if not _use_iniparse: from ConfigParser import NoSectionError, NoOptionError, ParsingError from ConfigParser import ConfigParser import rpmUtils.transaction import rpmUtils.miscutils import Errors import types from misc import get_uuid, read_in_items_from_dot_dir import fnmatch # Alter/patch these to change the default checking... __pkgs_gpgcheck_default__ = False __repo_gpgcheck_default__ = False __payload_gpgcheck_default__ = False __main_multilib_policy_default__ = 'best' __main_failovermethod_default__ = 'priority' __main_installonly_limit_default__ = 3 __group_command_default__ = 'objects' __exactarchlist_default__ = [] class Option(object): """ This class handles a single Yum configuration file option. Create subclasses for each type of supported configuration option. Python descriptor foo (__get__ and __set__) is used to make option definition easy and concise. """ def __init__(self, default=None, parse_default=False): self._setattrname() self.inherit = False if parse_default: default = self.parse(default) self.default = default def _setattrname(self): """Calculate the internal attribute name used to store option state in configuration instances. """ self._attrname = '__opt%d' % id(self) def __get__(self, obj, objtype): """Called when the option is read (via the descriptor protocol). :param obj: The configuration instance to modify. :param objtype: The type of the config instance (not used). :return: The parsed option value or the default value if the value wasn't set in the configuration file. """ # xemacs highlighting hack: ' if obj is None: return self return getattr(obj, self._attrname, None) def __set__(self, obj, value): """Called when the option is set (via the descriptor protocol). :param obj: The configuration instance to modify. :param value: The value to set the option to. """ # Only try to parse if it's a string if isinstance(value, basestring): try: value = self.parse(value) except ValueError, e: # Add the field name onto the error raise ValueError('Error parsing "%s = %r": %s' % (self._optname, value, str(e))) setattr(obj, self._attrname, value) def setup(self, obj, name): """Initialise the option for a config instance. This must be called before the option can be set or retrieved. :param obj: :class:`BaseConfig` (or subclass) instance. :param name: Name of the option. """ self._optname = name setattr(obj, self._attrname, copy.copy(self.default)) def clone(self): """Return a safe copy of this :class:`Option` instance. :return: a safe copy of this :class:`Option` instance """ new = copy.copy(self) new._setattrname() return new def parse(self, s): """Parse the string value to the :class:`Option`'s native value. :param s: raw string value to parse :return: validated native value :raise: ValueError if there was a problem parsing the string. Subclasses should override this """ return s def tostring(self, value): """Convert the :class:`Option`'s native value to a string value. This does the opposite of the :func:`parse` method above. Subclasses should override this. :param value: native option value :return: string representation of input """ return str(value) def Inherit(option_obj): """Clone an :class:`Option` instance for the purposes of inheritance. The returned instance has all the same properties as the input :class:`Option` and shares items such as the default value. Use this to avoid redefinition of reused options. :param option_obj: :class:`Option` instance to inherit :return: New :class:`Option` instance inherited from the input """ new_option = option_obj.clone() new_option.inherit = True return new_option class ListOption(Option): """An option containing a list of strings.""" def __init__(self, default=None, parse_default=False): if default is None: default = [] super(ListOption, self).__init__(default, parse_default) def parse(self, s): """Convert a string from the config file to a workable list, parses globdir: paths as foo.d-style dirs. :param s: The string to be converted to a list. Commas and whitespace are used as separators for the list :return: *s* converted to a list """ # we need to allow for the '\n[whitespace]' continuation - easier # to sub the \n with a space and then read the lines s = s.replace('\n', ' ') s = s.replace(',', ' ') results = [] for item in s.split(): if item.startswith('glob:'): thisglob = item.replace('glob:', '') results.extend(read_in_items_from_dot_dir(thisglob)) continue results.append(item) return results def tostring(self, value): """Convert a list of to a string value. This does the opposite of the :func:`parse` method above. :param value: a list of values :return: string representation of input """ return '\n '.join(value) class UrlOption(Option): """This option handles lists of URLs with validation of the URL scheme. """ def __init__(self, default=None, schemes=('http', 'ftp', 'file', 'https'), allow_none=False): super(UrlOption, self).__init__(default) self.schemes = schemes self.allow_none = allow_none def parse(self, url): """Parse a url to make sure that it is valid, and in a scheme that can be used. :param url: a string containing the url to parse :return: *url* if it is valid :raises: :class:`ValueError` if there is an error parsing the url """ url = url.strip() # Handle the "_none_" special case if url.lower() == '_none_': if self.allow_none: return '_none_' else: raise ValueError('"_none_" is not a valid value') # Check that scheme is valid (s,b,p,q,f,o) = urlparse.urlparse(url) if s not in self.schemes: raise ValueError('URL must be %s not "%s"' % (self._schemelist(), s)) return url def _schemelist(self): '''Return a user friendly list of the allowed schemes ''' if len(self.schemes) < 1: return 'empty' elif len(self.schemes) == 1: return self.schemes[0] else: return '%s or %s' % (', '.join(self.schemes[:-1]), self.schemes[-1]) class ProxyOption(UrlOption): """ Just like URLOption but accept "libproxy" too. """ def parse(self, proxy): if proxy.strip().lower() == 'libproxy': return 'libproxy' return UrlOption.parse(self, proxy) class UrlListOption(ListOption): """Option for handling lists of URLs with validation of the URL scheme. """ def __init__(self, default=None, schemes=('http', 'ftp', 'file', 'https'), parse_default=False): super(UrlListOption, self).__init__(default, parse_default) # Hold a UrlOption instance to assist with parsing self._urloption = UrlOption(schemes=schemes) def parse(self, s): """Parse a string containing multiple urls into a list, and ensure that they are in a scheme that can be used. :param s: the string to parse :return: a list of strings containing the urls in *s* :raises: :class:`ValueError` if there is an error parsing the urls """ out = [] s = s.replace('\n', ' ') s = s.replace(',', ' ') items = [ item.replace(' ', '%20') for item in shlex.split(s) ] tmp = [] for item in items: if item.startswith('glob:'): thisglob = item.replace('glob:', '') tmp.extend(read_in_items_from_dot_dir(thisglob)) continue tmp.append(item) for url in super(UrlListOption, self).parse(' '.join(tmp)): out.append(self._urloption.parse(url)) return out class WildListOption(ListOption): """An option containing a list of strings that supports shell-style wildcard matching in membership test operations.""" def parse(self, s): class WildList(list): def __contains__(self, item): if not isinstance(item, basestring): return False return any(fnmatch.fnmatch(item, p) for p in self) patterns = super(WildListOption, self).parse(s) return WildList(patterns) class IntOption(Option): """An option representing an integer value.""" def __init__(self, default=None, range_min=None, range_max=None): super(IntOption, self).__init__(default) self._range_min = range_min self._range_max = range_max def parse(self, s): """Parse a string containing an integer. :param s: the string to parse :return: the integer in *s* :raises: :class:`ValueError` if there is an error parsing the integer """ try: val = int(s) except (ValueError, TypeError), e: raise ValueError('invalid integer value') if self._range_max is not None and val > self._range_max: raise ValueError('out of range integer value') if self._range_min is not None and val < self._range_min: raise ValueError('out of range integer value') return val class PositiveIntOption(IntOption): """An option representing a positive integer value, where 0 can have a special representation. """ def __init__(self, default=None, range_min=0, range_max=None, names_of_0=None): super(PositiveIntOption, self).__init__(default, range_min, range_max) self._names0 = names_of_0 def parse(self, s): """Parse a string containing a positive integer, where 0 can have a special representation. :param s: the string to parse :return: the integer in *s* :raises: :class:`ValueError` if there is an error parsing the integer """ if s in self._names0: return 0 return super(PositiveIntOption, self).parse(s) class SecondsOption(Option): """An option representing an integer value of seconds, or a human readable variation specifying days, hours, minutes or seconds until something happens. Works like :class:`BytesOption`. Note that due to historical president -1 means "never", so this accepts that and allows the word never, too. Valid inputs: 100, 1.5m, 90s, 1.2d, 1d, 0xF, 0.1, -1, never. Invalid inputs: -10, -0.1, 45.6Z, 1d6h, 1day, 1y. Return value will always be an integer """ MULTS = {'d': 60 * 60 * 24, 'h' : 60 * 60, 'm' : 60, 's': 1} def parse(self, s): """Parse a string containing an integer value of seconds, or a human readable variation specifying days, hours, minutes or seconds until something happens. Works like :class:`BytesOption`. Note that due to historical president -1 means "never", so this accepts that and allows the word never, too. Valid inputs: 100, 1.5m, 90s, 1.2d, 1d, 0xF, 0.1, -1, never. Invalid inputs: -10, -0.1, 45.6Z, 1d6h, 1day, 1y. :param s: the string to parse :return: an integer representing the number of seconds specified by *s* :raises: :class:`ValueError` if there is an error parsing the string """ if len(s) < 1: raise ValueError("no value specified") if s == "-1" or s == "never": # Special cache timeout, meaning never return -1 if s[-1].isalpha(): n = s[:-1] unit = s[-1].lower() mult = self.MULTS.get(unit, None) if not mult: raise ValueError("unknown unit '%s'" % unit) else: n = s mult = 1 try: n = float(n) except (ValueError, TypeError), e: raise ValueError('invalid value') if n < 0: raise ValueError("seconds value may not be negative") return int(n * mult) class BoolOption(Option): """An option representing a boolean value. The value can be one of 0, 1, yes, no, true, or false. """ def parse(self, s): """Parse a string containing a boolean value. 1, yes, and true will evaluate to True; and 0, no, and false will evaluate to False. Case is ignored. :param s: the string containing the boolean value :return: the boolean value contained in *s* :raises: :class:`ValueError` if there is an error in parsing the boolean value """ s = s.lower() if s in ('0', 'no', 'false'): return False elif s in ('1', 'yes', 'true'): return True else: raise ValueError('invalid boolean value') def tostring(self, value): """Convert a boolean value to a string value. This does the opposite of the :func:`parse` method above. :param value: the boolean value to convert :return: a string representation of *value* """ if value: return "1" else: return "0" class FloatOption(Option): """An option representing a numeric float value.""" def parse(self, s): """Parse a string containing a numeric float value. :param s: a string containing a numeric float value to parse :return: the numeric float value contained in *s* :raises: :class:`ValueError` if there is an error parsing float value """ try: return float(s.strip()) except (ValueError, TypeError): raise ValueError('invalid float value') class SelectionOption(Option): """Handles string values where only specific values are allowed. """ def __init__(self, default=None, allowed=(), mapper={}): super(SelectionOption, self).__init__(default) self._allowed = allowed self._mapper = mapper def parse(self, s): """Parse a string for specific values. :param s: the string to parse :return: *s* if it contains a valid value :raises: :class:`ValueError` if there is an error parsing the values """ if s in self._mapper: s = self._mapper[s] if s not in self._allowed: raise ValueError('"%s" is not an allowed value' % s) return s class CaselessSelectionOption(SelectionOption): """Mainly for compatibility with :class:`BoolOption`, works like :class:`SelectionOption` but lowers input case. """ def parse(self, s): """Parse a string for specific values. :param s: the string to parse :return: *s* if it contains a valid value :raises: :class:`ValueError` if there is an error parsing the values """ return super(CaselessSelectionOption, self).parse(s.lower()) class BytesOption(Option): """An option representing a value in bytes. The value may be given in bytes, kilobytes, megabytes, or gigabytes. """ # Multipliers for unit symbols MULTS = { 'k': 1024, 'm': 1024*1024, 'g': 1024*1024*1024, } def parse(self, s): """Parse a friendly bandwidth option to bytes. The input should be a string containing a (possibly floating point) number followed by an optional single character unit. Valid units are 'k', 'M', 'G'. Case is ignored. The convention that 1k = 1024 bytes is used. Valid inputs: 100, 123M, 45.6k, 12.4G, 100K, 786.3, 0. Invalid inputs: -10, -0.1, 45.6L, 123Mb. :param s: the string to parse :return: the number of bytes represented by *s* :raises: :class:`ValueError` if the option can't be parsed """ if len(s) < 1: raise ValueError("no value specified") if s[-1].isalpha(): n = s[:-1] unit = s[-1].lower() mult = self.MULTS.get(unit, None) if not mult: raise ValueError("unknown unit '%s'" % unit) else: n = s mult = 1 try: n = float(n) except ValueError: raise ValueError("couldn't convert '%s' to number" % n) if n < 0: raise ValueError("bytes value may not be negative") return int(n * mult) class ThrottleOption(BytesOption): """An option representing a bandwidth throttle value. See :func:`parse` for acceptable input values. """ def parse(self, s): """Get a throttle option. Input may either be a percentage or a "friendly bandwidth value" as accepted by the :class:`BytesOption`. Valid inputs: 100, 50%, 80.5%, 123M, 45.6k, 12.4G, 100K, 786.0, 0. Invalid inputs: 100.1%, -4%, -500. :param s: the string to parse :return: the bandwidth represented by *s*. The return value will be an int if a bandwidth value was specified, and a float if a percentage was given :raises: :class:`ValueError` if input can't be parsed """ if len(s) < 1: raise ValueError("no value specified") if s[-1] == '%': n = s[:-1] try: n = float(n) except ValueError: raise ValueError("couldn't convert '%s' to number" % n) if n < 0 or n > 100: raise ValueError("percentage is out of range") return n / 100.0 else: return BytesOption.parse(self, s) class BaseConfig(object): """Base class for storing configuration definitions. Subclass when creating your own definitions. """ def __init__(self): self._section = None for name in self.iterkeys(): option = self.optionobj(name) option.setup(self, name) def __str__(self): out = [] out.append('[%s]' % self._section) for name, value in self.iteritems(): out.append('%s: %r' % (name, value)) return '\n'.join(out) def populate(self, parser, section, parent=None): """Set option values from an INI file section. :param parser: :class:`ConfigParser` instance (or subclass) :param section: INI file section to read use :param parent: Optional parent :class:`BaseConfig` (or subclass) instance to use when doing option value inheritance """ self.cfg = parser self._section = section if parser.has_section(section): opts = set(parser.options(section)) else: opts = set() for name in self.iterkeys(): option = self.optionobj(name) value = None if name in opts: value = parser.get(section, name) else: # No matching option in this section, try inheriting if parent and option.inherit: value = getattr(parent, name) if value is not None: setattr(self, name, value) def optionobj(cls, name, exceptions=True): """Return the :class:`Option` instance for the given name. :param cls: the class to return the :class:`Option` instance from :param name: the name of the :class:`Option` instance to return :param exceptions: defines what action to take if the specified :class:`Option` instance does not exist. If *exceptions* is True, a :class:`KeyError` will be raised. If *exceptions* is False, None will be returned :return: the :class:`Option` instance specified by *name*, or None if it does not exist and *exceptions* is False :raises: :class:`KeyError` if the specified :class:`Option` does not exist, and *exceptions* is True """ obj = getattr(cls, name, None) if isinstance(obj, Option): return obj elif exceptions: raise KeyError else: return None optionobj = classmethod(optionobj) def isoption(cls, name): """Return True if the given name refers to a defined option. :param cls: the class to find the option in :param name: the name of the option to search for :return: whether *name* specifies a defined option """ return cls.optionobj(name, exceptions=False) is not None isoption = classmethod(isoption) def iterkeys(self): """Yield the names of all defined options in the instance.""" for name in dir(self): if self.isoption(name): yield name def iteritems(self): """Yield (name, value) pairs for every option in the instance. The value returned is the parsed, validated option value. """ # Use dir() so that we see inherited options too for name in self.iterkeys(): yield (name, getattr(self, name)) def write(self, fileobj, section=None, always=()): """Write out the configuration to a file-like object. :param fileobj: File-like object to write to :param section: Section name to use. If not specified, the section name used during parsing will be used :param always: A sequence of option names to always write out. Options not listed here will only be written out if they are at non-default values. Set to None to dump out all options """ # Write section heading if section is None: if self._section is None: raise ValueError("not populated, don't know section") section = self._section # Updated the ConfigParser with the changed values cfgOptions = self.cfg.options(section) for name,value in self.iteritems(): option = self.optionobj(name) if always is None or name in always or option.default != value or name in cfgOptions : self.cfg.set(section,name, option.tostring(value)) # write the updated ConfigParser to the fileobj. self.cfg.write(fileobj) def getConfigOption(self, option, default=None): """Return the current value of the given option. :param option: string specifying the option to return the value of :param default: the value to return if the option does not exist :return: the value of the option specified by *option*, or *default* if it does not exist """ warnings.warn('getConfigOption() will go away in a future version of Yum.\n' 'Please access option values as attributes or using getattr().', DeprecationWarning) if hasattr(self, option): return getattr(self, option) return default def setConfigOption(self, option, value): """Set the value of the given option to the given value. :param option: string specifying the option to set the value of :param value: the value to set the option to """ warnings.warn('setConfigOption() will go away in a future version of Yum.\n' 'Please set option values as attributes or using setattr().', DeprecationWarning) if hasattr(self, option): setattr(self, option, value) else: raise Errors.ConfigError, 'No such option %s' % option class StartupConf(BaseConfig): """Configuration option definitions for yum.conf's [main] section that are required early in the initialisation process or before the other [main] options can be parsed. """ # xemacs highlighting hack: ' debuglevel = IntOption(2, -4, 10) errorlevel = IntOption(2, 0, 10) distroverpkg = ListOption(['system-release(releasever)', 'redhat-release']) installroot = Option('/') config_file_path = Option('/etc/yum/yum.conf') plugins = BoolOption(False) pluginpath = ListOption(['/usr/share/yum-plugins', '/usr/lib/yum-plugins']) pluginconfpath = ListOption(['/etc/yum/pluginconf.d']) gaftonmode = BoolOption(False) syslog_ident = Option() syslog_facility = Option('LOG_USER') syslog_device = Option('/dev/log') persistdir = Option('/var/lib/yum') skip_missing_names_on_install = BoolOption(True) skip_missing_names_on_update = BoolOption(True) class YumConf(StartupConf): """Configuration option definitions for yum.conf's [main] section. Note: see also options inherited from :class:`StartupConf` """ retries = PositiveIntOption(10, names_of_0=["<forever>"]) recent = IntOption(7, range_min=0) reset_nice = BoolOption(True) cachedir = Option('/var/cache/yum') keepcache = BoolOption(True) usercache = BoolOption(True) logfile = Option('/var/log/yum.log') reposdir = ListOption(['/etc/yum/repos.d', '/etc/yum.repos.d']) commands = ListOption() exclude = ListOption() failovermethod = Option(__main_failovermethod_default__) proxy = ProxyOption(default=False, schemes=('http', 'ftp', 'https', 'socks4', 'socks4a', 'socks5', 'socks5h'), allow_none=True) proxy_username = Option() proxy_password = Option() username = Option() password = Option() installonlypkgs = ListOption(['kernel', 'kernel-bigmem', 'installonlypkg(kernel)', 'installonlypkg(kernel-module)', 'installonlypkg(vm)', 'kernel-enterprise','kernel-smp', 'kernel-debug', 'kernel-unsupported', 'kernel-source', 'kernel-devel', 'kernel-PAE', 'kernel-PAE-debug']) # NOTE: If you set this to 2, then because it keeps the current kernel it # means if you ever install an "old" kernel it'll get rid of the newest one # so you probably want to use 3 as a minimum ... if you turn it on. installonly_limit = PositiveIntOption(__main_installonly_limit_default__, range_min=2, names_of_0=["0", "<off>"]) kernelpkgnames = ListOption(['kernel','kernel-smp', 'kernel-enterprise', 'kernel-bigmem', 'kernel-BOOT', 'kernel-PAE', 'kernel-PAE-debug']) exactarchlist = WildListOption(__exactarchlist_default__) tsflags = ListOption() override_install_langs = Option() assumeyes = BoolOption(False) assumeno = BoolOption(False) alwaysprompt = BoolOption(True) exactarch = BoolOption(True) tolerant = BoolOption(True) diskspacecheck = BoolOption(True) overwrite_groups = BoolOption(False) keepalive = BoolOption(True) # FIXME: rename gpgcheck to pkgs_gpgcheck gpgcheck = BoolOption(__pkgs_gpgcheck_default__) repo_gpgcheck = BoolOption(__repo_gpgcheck_default__) localpkg_gpgcheck = BoolOption(__pkgs_gpgcheck_default__) payload_gpgcheck = BoolOption(__payload_gpgcheck_default__) obsoletes = BoolOption(True) showdupesfromrepos = BoolOption(False) enabled = BoolOption(True) remove_leaf_only = BoolOption(False) repopkgsremove_leaf_only = BoolOption(False) enablegroups = BoolOption(True) enable_group_conditionals = BoolOption(True) groupremove_leaf_only = BoolOption(False) group_package_types = ListOption(['mandatory', 'default']) group_command = SelectionOption(__group_command_default__, ('compat', 'objects', 'simple')) upgrade_group_objects_upgrade = BoolOption(True) timeout = FloatOption(30.0) # FIXME: Should use variation of SecondsOption minrate = IntOption(0) bandwidth = BytesOption(0) throttle = ThrottleOption(0) ip_resolve = CaselessSelectionOption( allowed = ('ipv4', 'ipv6', 'whatever'), mapper = {'4': 'ipv4', '6': 'ipv6'}) max_connections = IntOption(0, range_min=0) ftp_disable_epsv = BoolOption(False) deltarpm = IntOption(2, range_min=-16, range_max=128) deltarpm_percentage = IntOption(75, range_min=0, range_max=100) deltarpm_metadata_percentage = IntOption(100, range_min=0) http_caching = SelectionOption('all', ('none', 'packages', 'all', 'lazy:packages')) metadata_expire = SecondsOption(60 * 60 * 6) # Time in seconds (6h). metadata_expire_filter = SelectionOption('read-only:present', ('never', 'read-only:future', 'read-only:present', 'read-only:past')) # Time in seconds (1 day). NOTE: This isn't used when using metalinks mirrorlist_expire = SecondsOption(60 * 60 * 24) # XXX rpm_check_debug is unused, left around for API compatibility for now rpm_check_debug = BoolOption(True) disable_excludes = ListOption() query_install_excludes = BoolOption(False) skip_broken = BoolOption(False) # Note that "instant" is the old behaviour, but group:primary is very # similar but better :). mdpolicy = ListOption(['group:small']) mddownloadpolicy = SelectionOption('sqlite', ('sqlite', 'xml')) # ('instant', 'group:all', 'group:main', 'group:small', 'group:primary')) multilib_policy = SelectionOption(__main_multilib_policy_default__, ('best', 'all')) # all == install any/all arches you can # best == use the 'best arch' for the system bugtracker_url = Option('https://bugzilla.redhat.com/enter_bug.cgi?product=Fedora&version=rawhide&component=yum') color = SelectionOption('auto', ('auto', 'never', 'always'), mapper={'on' : 'always', 'yes' : 'always', '1' : 'always', 'true' : 'always', 'off' : 'never', 'no' : 'never', '0' : 'never', 'false' : 'never', 'tty' : 'auto', 'if-tty' : 'auto'}) color_list_installed_older = Option('bold') color_list_installed_newer = Option('bold,yellow') color_list_installed_reinstall = Option('normal') color_list_installed_extra = Option('bold,red') color_list_installed_running_kernel = Option('bold,underline') color_list_available_upgrade = Option('bold,blue') color_list_available_downgrade = Option('dim,cyan') color_list_available_reinstall = Option('bold,underline,green') color_list_available_install = Option('normal') color_list_available_running_kernel = Option('bold,underline') color_update_installed = Option('normal') color_update_local = Option('bold') color_update_remote = Option('normal') color_search_match = Option('bold') ui_repoid_vars = ListOption(['releasever', 'basearch']) sslcacert = Option() sslverify = BoolOption(True) sslclientcert = Option() sslclientkey = Option() ssl_check_cert_permissions = BoolOption(True) history_record = BoolOption(True) history_record_packages = ListOption(['yum', 'rpm']) rpmverbosity = Option('info') protected_packages = ListOption("yum, glob:/etc/yum/protected.d/*.conf", parse_default=True) protected_multilib = BoolOption(True) exit_on_lock = BoolOption(False) loadts_ignoremissing = BoolOption(False) loadts_ignorerpm = BoolOption(False) loadts_ignorenewrpm = BoolOption(False) autosavets = BoolOption(True) clean_requirements_on_remove = BoolOption(False) upgrade_requirements_on_install = BoolOption(False) history_list_view = SelectionOption('single-user-commands', ('single-user-commands', 'users', 'commands'), mapper={'cmds' : 'commands', 'default' :'single-user-commands'}) recheck_installed_requires = BoolOption(False) fssnap_automatic_pre = BoolOption(False) fssnap_automatic_post = BoolOption(False) fssnap_automatic_keep = IntOption(1) fssnap_percentage = IntOption(100, range_min=1, range_max=100) fssnap_devices = ListOption("!*/swap !*/lv_swap " "glob:/etc/yum/fssnap.d/*.conf", parse_default=True) fssnap_abort_on_errors = SelectionOption('any', ('broken-setup', 'snapshot-failure', 'any', 'none')) depsolve_loop_limit = PositiveIntOption(100, names_of_0=["<forever>"]) autocheck_running_kernel = BoolOption(True) check_config_file_age = BoolOption(True) usr_w_check = BoolOption(True) shell_exit_status = SelectionOption('0', ('0', '?')) _reposlist = [] # cachedir before variable substitutions _pristine_cachedir = None def dump(self): """Return a string representing the values of all the configuration options. :return: a string representing the values of all the configuration options """ output = '[main]\n' # we exclude all vars which start with _ or are in this list: excluded_vars = ('cfg', 'uid', 'yumvar', 'progress_obj', 'failure_obj', 'disable_excludes', 'config_file_age', 'config_file_path', ) for attr in dir(self): if attr.startswith('_'): continue if attr in excluded_vars: continue if isinstance(getattr(self, attr), types.MethodType): continue res = getattr(self, attr) if not res and type(res) not in (type(False), type(0)): res = '' if type(res) == types.ListType: res = ',\n '.join(res) output = output + '%s = %s\n' % (attr, res) return output class RepoConf(BaseConfig): """Option definitions for repository INI file sections.""" __cached_keys = set() def iterkeys(self): """Yield the names of all defined options in the instance.""" ck = self.__cached_keys if not isinstance(self, RepoConf): ck = set() if not ck: ck.update(list(BaseConfig.iterkeys(self))) for name in self.__cached_keys: yield name name = Option() enabled = Inherit(YumConf.enabled) keepcache = Inherit(YumConf.keepcache) baseurl = UrlListOption() mirrorlist = UrlOption() metalink = UrlOption() mediaid = Option() gpgkey = UrlListOption() gpgcakey = UrlListOption() exclude = ListOption() includepkgs = ListOption() proxy = Inherit(YumConf.proxy) proxy_username = Inherit(YumConf.proxy_username) proxy_password = Inherit(YumConf.proxy_password) retries = Inherit(YumConf.retries) failovermethod = Inherit(YumConf.failovermethod) username = Inherit(YumConf.username) password = Inherit(YumConf.password) # FIXME: rename gpgcheck to pkgs_gpgcheck gpgcheck = Inherit(YumConf.gpgcheck) repo_gpgcheck = Inherit(YumConf.repo_gpgcheck) keepalive = Inherit(YumConf.keepalive) enablegroups = Inherit(YumConf.enablegroups) minrate = Inherit(YumConf.minrate) bandwidth = Inherit(YumConf.bandwidth) throttle = Inherit(YumConf.throttle) timeout = Inherit(YumConf.timeout) ip_resolve = Inherit(YumConf.ip_resolve) # This isn't inherited so that we can automatically disable file:// _only_ # repos. if they haven't set an explicit deltarpm_percentage for the repo. deltarpm_percentage = IntOption(None, range_min=0, range_max=100) # Rely on the above config. to do automatic disabling, and thus. no hack # needed here. deltarpm_metadata_percentage = Inherit(YumConf.deltarpm_metadata_percentage) ftp_disable_epsv = Inherit(YumConf.ftp_disable_epsv) http_caching = Inherit(YumConf.http_caching) metadata_expire = Inherit(YumConf.metadata_expire) metadata_expire_filter = Inherit(YumConf.metadata_expire_filter) mirrorlist_expire = Inherit(YumConf.mirrorlist_expire) # NOTE: metalink expire _must_ be the same as metadata_expire, due to the # checksumming of the repomd.xml. mdpolicy = Inherit(YumConf.mdpolicy) mddownloadpolicy = Inherit(YumConf.mddownloadpolicy) cost = IntOption(1000) sslcacert = Inherit(YumConf.sslcacert) sslverify = Inherit(YumConf.sslverify) sslclientcert = Inherit(YumConf.sslclientcert) sslclientkey = Inherit(YumConf.sslclientkey) ssl_check_cert_permissions = Inherit(YumConf.ssl_check_cert_permissions) skip_if_unavailable = BoolOption(False) async = BoolOption(True) ui_repoid_vars = Inherit(YumConf.ui_repoid_vars) check_config_file_age = Inherit(YumConf.check_config_file_age) compare_providers_priority = IntOption(80, range_min=1, range_max=99) class VersionGroupConf(BaseConfig): """Option definitions for version groups.""" pkglist = ListOption() run_with_packages = BoolOption(False) def _read_yumvars(yumvars, root): # Read the FS yumvars try: dir_fsvars = root + "/etc/yum/vars/" fsvars = os.listdir(dir_fsvars) except OSError: fsvars = [] for fsvar in fsvars: if os.path.islink(dir_fsvars + fsvar): continue try: val = open(dir_fsvars + fsvar).readline() if val and val[-1] == '\n': val = val[:-1] except (OSError, IOError): continue yumvars[fsvar] = val def readStartupConfig(configfile, root, releasever=None): """Parse Yum's main configuration file and return a :class:`StartupConf` instance. This is required in order to access configuration settings required as Yum starts up. :param configfile: the path to yum.conf :param root: the base path to use for installation (typically '/') :return: A :class:`StartupConf` instance :raises: :class:`Errors.ConfigError` if a problem is detected with while parsing. """ # ' xemacs syntax hack StartupConf.installroot.default = root startupconf = StartupConf() startupconf.config_file_path = configfile parser = ConfigParser() confpp_obj = ConfigPreProcessor(configfile) yumvars = _getEnvVar() _read_yumvars(yumvars, startupconf.installroot) confpp_obj._vars = yumvars startupconf.yumvars = yumvars try: parser.readfp(confpp_obj) except ParsingError, e: raise Errors.ConfigError("Parsing file failed: %s" % e) startupconf.populate(parser, 'main') # Check that plugin paths are all absolute for path in startupconf.pluginpath: if not path[0] == '/': raise Errors.ConfigError("All plugin search paths must be absolute") # Stuff this here to avoid later re-parsing startupconf._parser = parser # setup the release ver here if releasever is None: releasever = _getsysver(startupconf.installroot, startupconf.distroverpkg) startupconf.releasever = releasever uuidfile = '%s/%s/uuid' % (startupconf.installroot, startupconf.persistdir) startupconf.uuid = get_uuid(uuidfile) return startupconf def readMainConfig(startupconf): """Parse Yum's main configuration file :param startupconf: :class:`StartupConf` instance as returned by readStartupConfig() :return: Populated :class:`YumConf` instance """ # ' xemacs syntax hack # Set up substitution vars but make sure we always prefer FS yumvars yumvars = startupconf.yumvars yumvars.setdefault('basearch', startupconf.basearch) yumvars.setdefault('arch', startupconf.arch) yumvars.setdefault('releasever', startupconf.releasever) yumvars.setdefault('uuid', startupconf.uuid) # Read [main] section yumconf = YumConf() yumconf.populate(startupconf._parser, 'main') # Store the original cachedir (for later reference in clean commands) yumconf._pristine_cachedir = yumconf.cachedir # Apply the installroot to directory options def _apply_installroot(yumconf, option): path = getattr(yumconf, option) ir_path = yumconf.installroot + path ir_path = ir_path.replace('//', '/') # os.path.normpath won't fix this and # it annoys me ir_path = varReplace(ir_path, yumvars) setattr(yumconf, option, ir_path) if StartupConf.installroot.default != yumconf.installroot: # Note that this isn't perfect, in that if the initial installroot has # X=Y, and X doesn't exist in the new installroot ... then we'll still # have X afterwards (but if the new installroot has X=Z, that will be # the value after this). _read_yumvars(yumvars, yumconf.installroot) # These can use the above FS yumvars for option in ('cachedir', 'logfile', 'persistdir'): _apply_installroot(yumconf, option) # Add in some extra attributes which aren't actually configuration values yumconf.yumvar = yumvars yumconf.uid = 0 yumconf.cache = 0 yumconf.progess_obj = None # items related to the originating config file yumconf.config_file_path = startupconf.config_file_path if os.path.exists(startupconf.config_file_path): yumconf.config_file_age = os.stat(startupconf.config_file_path)[8] else: yumconf.config_file_age = 0 # propagate the debuglevel and errorlevel values: yumconf.debuglevel = startupconf.debuglevel yumconf.errorlevel = startupconf.errorlevel return yumconf def readVersionGroupsConfig(configfile="/etc/yum/version-groups.conf"): """Parse the configuration file for version groups. :param configfile: the configuration file to read :return: a dictionary containing the parsed options """ parser = ConfigParser() confpp_obj = ConfigPreProcessor(configfile) try: parser.readfp(confpp_obj) except ParsingError, e: raise Errors.ConfigError("Parsing file failed: %s" % e) ret = {} for section in parser.sections(): ret[section] = VersionGroupConf() ret[section].populate(parser, section) return ret def getOption(conf, section, name, option): """Convenience function to retrieve a parsed and converted value from a :class:`ConfigParser`. :param conf: ConfigParser instance or similar :param section: Section name :param name: :class:`Option` name :param option: :class:`Option` instance to use for conversion :return: The parsed value or default if value was not present :raises: :class:`ValueError` if the option could not be parsed """ try: val = conf.get(section, name) except (NoSectionError, NoOptionError): return option.default return option.parse(val) def _getEnvVar(): '''Return variable replacements from the environment variables YUM0 to YUM9 The result is intended to be used with parser.varReplace() ''' yumvar = {} for num in range(0, 10): env = 'YUM%d' % num val = os.environ.get(env, '') if val: yumvar[env.lower()] = val return yumvar def _getsysver(installroot, distroverpkg): '''Calculate the release version for the system. @param installroot: The value of the installroot option. @param distroverpkg: The value of the distroverpkg option. @return: The release version as a string (eg. '4' for FC4) ''' ts = rpmUtils.transaction.initReadOnlyTransaction(root=installroot) ts.pushVSFlags(~(rpm._RPMVSF_NOSIGNATURES|rpm._RPMVSF_NODIGESTS)) try: for distroverpkg_prov in distroverpkg: idx = ts.dbMatch('provides', distroverpkg_prov) if idx.count(): break except TypeError, e: # This is code for "cannot open rpmdb" # this is for pep 352 compliance on python 2.6 and above :( if sys.hexversion < 0x02050000: if hasattr(e,'message'): raise Errors.YumBaseError("Error: " + str(e.message)) else: raise Errors.YumBaseError("Error: " + str(e)) raise Errors.YumBaseError("Error: " + str(e)) except rpm.error, e: # This is the "new" code for "cannot open rpmdb", 4.8.0 ish raise Errors.YumBaseError("Error: " + str(e)) # we're going to take the first one - if there is more than one of these # then the user needs a beating if idx.count() == 0: releasever = '$releasever' else: try: hdr = idx.next() except StopIteration: raise Errors.YumBaseError("Error: rpmdb failed release provides. Try: rpm --rebuilddb") releasever = hdr['version'] off = hdr[getattr(rpm, 'RPMTAG_PROVIDENAME')].index(distroverpkg_prov) flag = hdr[getattr(rpm, 'RPMTAG_PROVIDEFLAGS')][off] flag = rpmUtils.miscutils.flagToString(flag) ver = hdr[getattr(rpm, 'RPMTAG_PROVIDEVERSION')][off] if flag == 'EQ' and ver: if hdr['name'] != distroverpkg_prov: # override the package version releasever = ver del hdr del idx del ts return releasever def _readRawRepoFile(repo): if not _use_iniparse: return None if not hasattr(repo, 'repofile') or not repo.repofile: return None try: ini = INIConfig(open(repo.repofile)) except: return None # b/c repoids can have $values in them we need to map both ways to figure # out which one is which section_id = repo.id if repo.id not in ini._sections: for sect in ini._sections.keys(): if varReplace(sect, repo.yumvar) == repo.id: section_id = sect break else: return None return ini, section_id def writeRawRepoFile(repo,only=None): """Write changes in a repo object back to a .repo file. :param repo: the Repo Object to write back out :param only: list of attributes to work on. If *only* is None, all options will be written out """ if not _use_iniparse: return ini, section_id = _readRawRepoFile(repo) # Updated the ConfigParser with the changed values cfgOptions = repo.cfg.options(repo.id) for name,value in repo.iteritems(): if value is None: # Proxy continue if only is not None and name not in only: continue option = repo.optionobj(name) ovalue = option.tostring(value) # If the value is the same, but just interpreted ... when we don't want # to keep the interpreted values. if (name in ini[section_id] and ovalue == varReplace(ini[section_id][name], repo.yumvar)): ovalue = ini[section_id][name] if name not in cfgOptions and option.default == value: continue ini[section_id][name] = ovalue fp =file(repo.repofile,"w") fp.write(str(ini)) fp.close() # Copied from yum-config-manager ... how we alter yu.conf ... used in "yum fs" def _writeRawConfigFile(filename, section_id, yumvar, cfgoptions, items, optionobj, only=None): """ From writeRawRepoFile, but so we can alter [main] too. """ ini = INIConfig(open(filename)) osection_id = section_id # b/c repoids can have $values in them we need to map both ways to figure # out which one is which if section_id not in ini._sections: for sect in ini._sections.keys(): if varReplace(sect, yumvar) == section_id: section_id = sect # Updated the ConfigParser with the changed values cfgOptions = cfgoptions(osection_id) for name,value in items(): if value is None: # Proxy continue if only is not None and name not in only: continue option = optionobj(name) ovalue = option.tostring(value) # If the value is the same, but just interpreted ... when we don't want # to keep the interpreted values. if (name in ini[section_id] and ovalue == varReplace(ini[section_id][name], yumvar)): ovalue = ini[section_id][name] if name not in cfgOptions and option.default == value: continue ini[section_id][name] = ovalue fp =file(filename, "w") fp.write(str(ini)) fp.close() #def main(): # mainconf = readMainConfig(readStartupConfig('/etc/yum/yum.conf', '/')) # print mainconf.cachedir # #if __name__ == '__main__': # main()