Source code for insights.parsers.uname

Uname - command ``uname -a``

The ``Uname`` class reads the output of the ``uname -a`` command and
interprets it.  It also does a number of handy extra things, like deriving
the RHEL release from the kernel version.

Uname objects can also be compared by their kernel versions.

An example from the following ``uname -a`` output::

    Linux 2.6.32-504.el6.x86_64 #1 SMP Tue Sep 16 01:56:35 EDT 2014 x86_64 x86_64 x86_64 GNU/Linux


    >>> type(uname)
    <class 'insights.parsers.uname.Uname'>
    >>> uname.version
    >>> uname.release
    >>> uname.arch
    >>> uname.nodename

Uname objects can be created from, and compared to, other Uname objects or
kernel strings::

    >>> early_rhel6 = Uname.from_kernel('2.6.32-71')
    >>> late_rhel6 = Uname.from_release('6.7')
    >>> late_rhel6 > early_rhel6
    >>> early_rhel6 > '2.6.32-279.el6.x86_64'


from collections import namedtuple
from distutils.version import LooseVersion, StrictVersion
from .. import parser, CommandParser
from insights.core.context import Context
from insights.specs import Specs

rhel_release_map = {
    "2.4.21-4": "3.0",
    "2.4.21-9": "3.1",
    "2.4.21-15": "3.2",
    "2.4.21-20": "3.3",
    "2.4.21-27": "3.4",
    "2.4.21-32": "3.5",
    "2.4.21-37": "3.6",
    "2.4.21-40": "3.7",
    "2.4.21-47": "3.8",
    "2.4.21-50": "3.9",
    "2.6.9-5": "4.0",
    "2.6.9-11": "4.1",
    "2.6.9-22": "4.2",
    "2.6.9-34": "4.3",
    "2.6.9-42": "4.4",
    "2.6.9-55": "4.5",
    "2.6.9-67": "4.6",
    "2.6.9-78": "4.7",
    "2.6.9-89": "4.8",
    "2.6.9-100": "4.9",
    "2.6.18-8": "5.0",
    "2.6.18-53": "5.1",
    "2.6.18-92": "5.2",
    "2.6.18-128": "5.3",
    "2.6.18-164": "5.4",
    "2.6.18-194": "5.5",
    "2.6.18-238": "5.6",
    "2.6.18-274": "5.7",
    "2.6.18-308": "5.8",
    "2.6.18-348": "5.9",
    "2.6.18-371": "5.10",
    "2.6.18-398": "5.11",
    "2.6.18-400": "5.11",
    "2.6.18-402": "5.11",
    "2.6.18-404": "5.11",
    "2.6.18-408": "5.11",
    "2.6.32-71": "6.0",
    "2.6.32-131": "6.1",
    "2.6.32-220": "6.2",
    "2.6.32-279": "6.3",
    "2.6.32-358": "6.4",
    "2.6.32-431": "6.5",
    "2.6.32-504": "6.6",
    "2.6.32-573": "6.7",
    "2.6.32-642": "6.8",
    "2.6.32-696": "6.9",
    "2.6.32-754": "6.10",
    "3.10.0-123": "7.0",
    "3.10.0-229": "7.1",
    "3.10.0-327": "7.2",
    "3.10.0-514": "7.3",
    "3.10.0-693": "7.4",
    "3.10.0-862": "7.5",
    "3.10.0-957": "7.6",
    "3.10.0-1062": "7.7",
    "3.10.0-1127": "7.8",
    "3.10.0-1160": "7.9",
    # Added alt to the below 3 kernel entries since they're part of the
    # kernel-alt pkg, if we don't it would create duplicate entries and
    # mess with what's returned by from_release.
    "4.11.0-44": "7.4.alt",
    "4.14.0-49": "7.5.alt",
    "4.14.0-115": "7.6.alt",
    "4.18.0-80": "8.0",
    "4.18.0-147": "8.1",
    "4.18.0-193": "8.2",
    "4.18.0-240": "8.3",
    "4.18.0-305": "8.4",
    "4.18.0-348": "8.5",
    "4.18.0-372": "8.6",
    "4.18.0-425": "8.7",
    "4.18.0-477": "8.8",
    "4.18.0-513": "8.9",
    "5.14.0-70": "9.0",
    "5.14.0-162": "9.1",
    "5.14.0-284": "9.2",
    "5.14.0-362": "9.3",

release_to_kernel_map = dict((v, k) for k, v in rhel_release_map.items())
RedhatRelease = namedtuple("RedhatRelease", ("major", "minor"))

[docs] class UnameError(Exception): """ Exception subclass for errors related to uname content data and the Uname class. This exception should not be caught by rules plugins unless it is necessary for the plugin to return a particular answer when a problem occurs with uname data. If a plugin catches this exception it must reraise it so that the engine has the opportunity to handle it/log it as necessary. """ def __init__(self, msg, uname_line): """Class constructor :Parameters: - `msg`: Specific description of the error that occurred. - `uname_line`: Uname content that was being evaluated with the error occurred. """ super(UnameError, self).__init__(msg, uname_line) self.msg = msg self.uname_line = uname_line def __str__(self): return "{0}:'{1}'".format(self.msg, self.uname_line)
[docs] @parser(Specs.uname) class Uname(CommandParser): """ A utility class to parse uname content data and compare version and release information. The input is a uname content string. The content is parsed into specific uname elements that are made available through instance variables. Operators are provided for comparison of version and release information. Uname content is expected to be in the format returned by the ``uname -a`` command. The following instance variables are provided by this class: - `kernel`: Provides an unparsed copy of the full version and release string provided in the uname content input. No validation is performed on this information. Generally in the format ``#.#.#-#.#.#.el#.arch``. - `name`: The kernel name, usually ``Linux``. - `nodename`: Hostname of the computer where the uname command was executed. This information may obfuscated for security. - `version`: The major identification number for the kernel release. It should be in the format ``#.#.#[.#]`` or a UnameError exception will be raised. - `release`: The minor identification number for the kernel release. This information is generally in the format #.#.#.el#, however this is not strictly enforced. If the release.arch information cannot be reliably parsed then `release` and `release_arch` will be the same value. - `release_arch`: This is the `release` plus the kernel architecture information as provided in `arch`. - `arch`: This contains the kernel architecture information like ``x86_64`` or `s390`. A list of known architectures is provided by the global variable `KNOWN_ARCHITECTURES`. This information is not always present in the uname content. - `ver_rel`: This is a combination of `version` and `release` in the format ``version-release``. - `rhel_release`: A list of two elements, the major and minor RHEL product release numbers. - `debug_kernel`: A bool that's returns True when the server is running the debug kernel. """ keys = [ 'os', 'hw_platform', 'processor', 'machine', 'kernel_date', 'kernel_type', 'kernel', 'name', 'nodename', 'version', 'release', 'release_arch', 'arch', 'ver_rel', 'rhel_release', 'debug_kernel', '_lv_release', '_rel_maj', '_sv_version', '_lv_version' ] defaults = dict.fromkeys(keys) def __init__(self, context): super(Uname, self).__init__(context) if not context: return data = dict(self.defaults) data.update( = data for k, v in setattr(self, k, v)
[docs] def parse_content(self, content): """ Parses uname content into individual uname components. :Parameters: - `content`: Uname content from Insights to be parsed. :Exceptions: - `UnameError`: Raised when there are any errors evaluating the uname content. """ # Remove extra whitespace prior to parsing, preserve original line if not content: raise UnameError('Empty uname line', '') data = {} uname_list = [line for line in content if line.startswith("Linux")] if not uname_list: raise UnameError("Uname string appears invalid", '') uname_line = uname_list[0] uname_parts = uname_line.split(' ') if len(uname_parts) < 3: raise UnameError("Uname string appears invalid", uname_line) else: data['kernel'] = uname_parts[2] data['name'] = uname_parts[0] data['nodename'] = uname_parts[1] # Check if the last segment of kernel version is the architecture (e.g. x86_64) last_kernel_segment = data['kernel'].split(".")[-1] # If the last segment contains "el" then we assume its the product indicator (e.g. el9_2) # If the last segment contains more than just digits we assume its the architecture (e.g. x86_64) has_arch = "el" not in last_kernel_segment and not last_kernel_segment.isdigit() try: data = self.parse_nvr(data['kernel'], data, arch=has_arch) except UnameError as error: error.uname_line = uname_line raise error # Additional uname content parsing, may not be as reliable if len(uname_parts) >= 15: data['os'] = uname_parts[-1] data['hw_platform'] = uname_parts[-2] data['processor'] = uname_parts[-3] data['machine'] = uname_parts[-4] data['kernel_date'] = " ".join(uname_parts[-10:-4]) data['kernel_type'] = uname_parts[-11] else: data['os'] = None data['hw_platform'] = None data['processor'] = None data['machine'] = None data['kernel_date'] = None data['kernel_type'] = None = data
[docs] @classmethod def from_kernel(cls, kernel): """ Create a Uname object from a kernel NVR (e.g. '2.6.32-504.el6.x86_64'). :Parameters: - `kernel` - the kernel version and release string. """ data = cls.parse_nvr(kernel, arch=False) content = ["{name} {nodename} {kernel} {kernel_type} {kernel_date} {machine} {processor} {hw_platform} {os}".format( name="Linux", nodename=data['nodename'], kernel=kernel, kernel_type=data['kernel_type'], kernel_date=data['kernel_date'], machine=data['machine'], processor=data['processor'], hw_platform=data['hw_platform'], os=data['os'])] return cls(Context(content=content, path=None))
[docs] @classmethod def from_uname_str(cls, uname_str): """ Create a Uname object from a string containing the output of 'uname -a'. :Parameters: - `uname_str` - the string output of `uname -a` """ if len(uname_str.split(' ')) == 1: uname_str = "Linux " + "hostname " + uname_str return cls(Context(content=[uname_str.strip()], path=None))
[docs] @classmethod def from_release(cls, release): """ Attempt to create a Uname object from a release (e.g. '7.2'). This translates from the release to the kernel version for that release, and then uses that to generate a Uname object using the class `from_kernel` method. If the release does not match a known release, it returns None. :Parameters: - `release`: RHEL release version. """ if isinstance(release, tuple): release = '.'.join(release) nvr = release_to_kernel_map.get(release) # return cls(Context(content=[nvr], path=None)) return cls.from_kernel(nvr)
[docs] @classmethod def parse_nvr(cls, nvr, data=None, arch=True): """ Called by `parse_uname_line` to separate the version, release and arch information. :Parameters: - `nvr`: Uname content to parse. - `arch`: Flag to indicate whether there is architecture information in the release. :Exceptions: - `UnameError`: Raised on errors in evaluating the uname content. """ if len(nvr.split('-')) < 2: raise UnameError("Too few parts in the uname version-release", nvr) if data is None: data = dict(cls.defaults) data['version'], data['release_arch'] = nvr.split('-', 1) # Debug kernels have .debug appended to the end, so remove it before continuing. if data['release_arch'].endswith('.debug'): data['debug_kernel'] = True data['release_arch'] = data['release_arch'].rsplit('.', 1)[0] else: data['debug_kernel'] = False if arch: try: data['release'], data['arch'] = data['release_arch'].rsplit('.', 1) except ValueError: data['release'] = data['release_arch'] data['arch'] = None else: data['release'] = data['release_arch'] data['arch'] = None data['_rel_maj'] = data['release'].split(".")[0] rhel_key = "-".join([data['version'], data['_rel_maj']]) rhel_release = rhel_release_map.get(rhel_key, '-1.-1') data['rhel_release'] = rhel_release.split('.') try: data['_sv_version'] = StrictVersion(data['version']) except ValueError: data['_sv_version'] = None # LooseVersion doesn't raise errors, it just goes with what it gets data['_lv_version'] = LooseVersion(data['version']) num_sections = 7 if 'rt' in data['release'] else 5 data['_lv_release'] = LooseVersion(pad_release(data['release'], num_sections=num_sections)) data['ver_rel'] = '%s-%s' % (data['version'], data['release']) return data
def _best_version(self, other): """ Use strict versions for comparisons, or loose versions if strict are not available. """ if self._sv_version and other._sv_version: return self._sv_version, other._sv_version else: return self._lv_version, other._lv_version def _best_lv_release(self, other): """ When the _lv_release in self and other both or neither have the distribution part, return then directly. Otherwise, removing the distribution part, and raising a warning. Notes:: Now, only `.el*` distribution is supported. """ dist_opts = ('el',) s_release_parts = self._lv_release.vstring.split(".") o_release_parts = other._lv_release.vstring.split(".") is_s_with_dist = s_release_parts[-1].startswith(dist_opts) is_o_with_dist = o_release_parts[-1].startswith(dist_opts) if not (is_s_with_dist ^ is_o_with_dist): return self._lv_release, other._lv_release import warnings warnings.warn('Comparison of distribution part will be ingored.') s_release = ( self._lv_release.vstring if not is_s_with_dist else pad_release(".".join(s_release_parts[:-1]), len(s_release_parts)) ) o_release = ( other._lv_release.vstring if not is_o_with_dist else pad_release(".".join(o_release_parts[:-1]), len(o_release_parts)) ) return LooseVersion(s_release), LooseVersion(o_release) def __str__(self): return "version: %s; release: %s; rel_maj: %s; lv_release: %s" % ( self.version, self.release, self._rel_maj, self._lv_release ) def __repr__(self): return "<%s '%s'>" % (self.__class__.__name__, str(self)) def __eq__(self, other): """ Operator to perform equal comparison of a Uname object to another Uname object or a string. The overloaded operators ``=``,``!=``,``<``,``>``,``<=``, and ``>=`` provide logical comparison for a Uname object. If the `other` object is a Uname or a string then comparison will be performed. If `other` is any other type then currently a `NotImplementedError` exception is raised. Comparison is performed on the version and release information. Version comparison is strict, meaning that a the Uname class will only accept three integers as a version number such as "3.10.0". Release comparison is also strict in that Uname expect a set of three numbers and a RHEL product string, however less than three numbers is accepted as long as there is at least one number. For example "327.10.1.el7", "327.10.el7", and "327.el7" are all valid releases. Also, for comparison purposes all missing numbers are assumed to be "0". For example: "327.10.0.el7" == "327.10.el7" and "327.0.0.el7" == "327.el7". :Parameters: - `other`: Uname object or version-release string to compare. :Exceptions: - `UnameError`: This exception is raised when there are any errors evaluating the uname content. - `ValueError`: This exception is raised when a version-release string is in an unparsable format. - `NotImplementedError`: This exception is thrown if a type other than ``Uname`` or ``str`` is provided as a parameter. """ if isinstance(other, Uname): other_uname = other else: other_uname = Uname.from_uname_str(other) s_version, o_version = self._best_version(other_uname) return s_version == o_version and self._lv_release == other_uname._lv_release def __ne__(self, other): """ Operator to perform inequality comparison of a Uname object to another Uname object or a string. See the `__eq__` operator for a detailed description. """ return not (self == other) def __lt__(self, other): """ Operator to perform less than comparison of a Uname object to another Uname object or a string. See the `__eq__` operator for a detailed description. """ if isinstance(other, Uname): other_uname = other else: other_uname = Uname.from_uname_str(other) s_version, o_version = self._best_version(other_uname) return s_version < o_version or \ (s_version == o_version and self._lv_release < other_uname._lv_release) def __le__(self, other): """ Operator to perform less than or equal comparison of a Uname object to another Uname object or a string. See the :__eq__: operator for a detailed description. """ return self < other or self == other def __gt__(self, other): """ Operator to perform greater than comparison of a Uname object to another Uname object or a string. See the :__eq__: operator for a detailed description. """ if isinstance(other, Uname): other_uname = other else: other_uname = Uname.from_uname_str(other) s_version, o_version = self._best_version(other_uname) return s_version > o_version or \ (s_version == o_version and self._lv_release > other_uname._lv_release) def __ge__(self, other): """ Operator to perform greater than or equal comparison of a Uname object to another Uname object or a string. See the :__eq__: operator for a detailed description. """ return self.__gt__(other) or self.__eq__(other) def _less_than(self, other): """ Compare two ``Uname`` classes. This function is used like one might use ``__lt__``. However, if an invalid ``_lv_release`` indicated by a value of ``None``, ``False`` is returned. Since this behavior is not optimal for the the '<' comparison operator (raising an Error would probably be better) we'll keep it internal to the class. """ s_version, o_version = self._best_version(other) s_lv_release, o_lv_release = self._best_lv_release(other) if s_version == o_version: ret = s_lv_release < o_lv_release else: ret = s_version < o_version return ret
[docs] def fixed_by(self, *fixes, **kwargs): """ Determine whether the Uname object is fixed by a range of releases or by a specific release. Only RHEL Uname objects and RHEL real time Uname objects are supported. :Parameters: - `fixes`: List of one or more Uname objects to compare to the current object. `fixes` is a list of one or more Uname objects and each will be compared with the current object to determine a match. - `kwargs`: List of key word argument/Uname object pairs. Currently only `introduced_in` is supported as a keyword. When used the current Uname object is checked to see if it is prior to the `introduced_in` release. It will be further checked against fixes only if it is the same as or newer than the `introduced_in` release. """ introduced_in = kwargs.get("introduced_in") if introduced_in and self._less_than(self.from_kernel(introduced_in)): return [] fix_unames = sorted((self.from_kernel(f) for f in fixes)) fix_kernels = [f.kernel for f in fix_unames] # If there is a fix in your kernel release stream # See if you are fixed by it for i, fixed in enumerate(fix_unames): if self._rel_maj == fixed._rel_maj: if self._less_than(fixed): return fix_kernels[i:] else: return [] # No fixes for your specific release so just return # all fixes that are greater return [fix.kernel for fix in fix_unames if self._less_than(fix)]
@property def release_tuple(self): rel = [] for v in['rhel_release']: try: rel.append(int(v)) except ValueError: rel.append(v) return tuple(rel) @property def redhat_release(self): return RedhatRelease(major=int(self.rhel_release[0]), minor=int(self.rhel_release[1]))
[docs] def pad_release(release_to_pad, num_sections=4): ''' Pad out package and kernel release versions so that ``LooseVersion`` comparisons will be correct. Release versions with less than num_sections will padded with zeros where missing versions segments are. For example :: pad_release("390.el6", 4) will return ``390.0.0.el6`` and :: pad_release("390.11.el6", 4) will return ``390.11.0.el6``. pad_release("390.11.rt6.8.el6", 7) will return ``390.11.0.0.rt6.8.el6``. Finally, if no "el" is specified: pad_release("390.11", 4) will return ``390.11.0.0``. If the number of sections of the release to be padded is greater than num_sections, a ``ValueError`` will be raised. ''' def find_rt_release(items): for i, s in enumerate(items): if s.startswith("rt"): return i return -1 parts = release_to_pad.split('.') if len(parts) > num_sections: raise ValueError("Too many sections encountered ({found} > {num} in release string {rel}".format( found=len(parts), num=num_sections, rel=release_to_pad )) pad_count = num_sections - len(parts) is_el_release = any(letter.isalpha() for letter in parts[-1]) rt_release_idx = find_rt_release(parts) if len(parts) > 1 and rt_release_idx >= 0: return ".".join(parts[:rt_release_idx] + ['0'] * pad_count + parts[rt_release_idx:]) elif len(parts) > 1 and is_el_release: return ".".join(parts[:-1] + ['0'] * pad_count + parts[-1:]) else: return ".".join(parts + ['0'] * pad_count)