xref: /third_party/libabigail/tools/fedabipkgdiff

#!/usr/bin/env python
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
# -*- coding: utf-8 -*-
# -*- Mode: Python
#
# Copyright (C) 2013-2016 Red Hat, Inc.
#
# Author: Chenxiong Qi

from __future__ import print_function

import argparse
import functools
import glob
import logging
import mimetypes
import os
import re
import shutil
import six
import subprocess
import sys

from collections import namedtuple
from itertools import chain

import xdg.BaseDirectory

import rpm
import koji

# @file
#
# You might have known that abipkgdiff is a command line tool to compare two
# RPM packages to find potential differences of ABI. This is really useful for
# Fedora packagers and developers. Usually, excpet the RPM packages built
# locally, if a packager wants to compare RPM packages he just built with
# specific RPM packages that were already built and availabe in Koji,
# fedabipkgdiff is the right tool for him.
#
# With fedabipkgdiff, packager is able to specify certain criteria to tell
# fedabipkgdiff which RPM packages he wants to compare, then fedabipkgdiff will
# find them, download them, and boom, run the abipkgdiff for you.
#
# Currently, fedabipkgdiff returns 0 if everything works well, otherwise, 1 if
# something wrong.


# First, try proper Koji initialization.
try:
    koji_config = koji.read_config('koji')
    DEFAULT_KOJI_SERVER = koji_config['server']
    DEFAULT_KOJI_TOPURL = koji_config['topurl']
except koji.ConfigurationError:
    # ..., but if that fails because of a rather strict interpretation where
    # 'read_config' looks for configuration files, just use dummy values.
    # These fail upon use unless overridden, which for libabigail test suite
    # usage they always are (all relevant artifacts are shipped in the
    # libabigail distribution).
    DEFAULT_KOJI_SERVER = 'dummy_DEFAULT_KOJI_SERVER'
    DEFAULT_KOJI_TOPURL = 'dummy_DEFAULT_KOJI_TOPURL'


# The working directory where to hold all data including downloaded RPM
# packages Currently, it's not configurable and hardcode here. In the future
# version of fedabipkgdiff, I'll make it configurable by users.
HOME_DIR = os.path.join(xdg.BaseDirectory.xdg_cache_home,
                        os.path.splitext(os.path.basename(__file__))[0])

DEFAULT_ABIPKGDIFF = 'abipkgdiff'

# Mask for determining if underlying fedabipkgdiff succeeds or not.
# This is for when the compared ABIs are equal
ABIDIFF_OK = 0
# This bit is set if there an application error.
ABIDIFF_ERROR = 1
# This bit is set if the tool is invoked in an non appropriate manner.
ABIDIFF_USAGE_ERROR = 1 << 1
# This bit is set if the ABIs being compared are different.
ABIDIFF_ABI_CHANGE = 1 << 2


# Used to construct abipkgdiff command line argument, package and associated
# debuginfo package
# fedabipkgdiff runs abipkgdiff in this form
#
#   abipkgdiff \
#       --d1 /path/to/package1-debuginfo.rpm \
#       --d2 /path/to/package2-debuginfo.rpm \
#       /path/to/package1.rpm \
#       /path/to/package2.rpm
#
# ComparisonHalf is a three-elements tuple in format
#
#   (package1.rpm, [package1-debuginfo.rpm..] package1-devel.rpm)
#
# - the first element is the subject representing the package to
#   compare.  It's a dict representing the RPM we are interested in.
#   That dict was retrieved from Koji XMLRPC API.
# - the rest are ancillary packages used for the comparison. So, the
#   second one is a vector containing the needed debuginfo packages
#   (yes there can be more than one), and the last one is the package
#   containing API of the ELF shared libraries carried by subject.
#   All the packages are dicts representing RPMs and those dicts were
#   retrieved fromt he KOji XMLRPC API.
#
# So, before calling abipkgdiff, fedabipkgdiff must prepare and pass
# the following information
#
#   (/path/to/package1.rpm, [/paths/to/package1-debuginfo.rpm ..] /path/to/package1-devel.rpm)
#   (/path/to/package2.rpm, [/paths/to/package2-debuginfo.rpm ..] /path/to/package1-devel.rpm)
#
ComparisonHalf = namedtuple('ComparisonHalf',
                            ['subject', 'ancillary_debug', 'ancillary_devel'])


global_config = None
pathinfo = None
session = None

# There is no way to configure the log format so far. I hope I would have time
# to make it available so that if fedabipkgdiff is scheduled and run by some
# service, the logs logged into log file is muc usable.
logging.basicConfig(format='[%(levelname)s] %(message)s', level=logging.CRITICAL)
logger = logging.getLogger(os.path.basename(__file__))


class KojiPackageNotFound(Exception):
    """Package is not found in Koji"""


class PackageNotFound(Exception):
    """Package is not found locally"""


class RpmNotFound(Exception):
    """RPM is not found"""


class NoBuildsError(Exception):
    """No builds returned from a method to select specific builds"""


class NoCompleteBuilds(Exception):
    """No complete builds for a package

    This is a serious problem, nothing can be done if there is no complete
    builds for a package.
    """


class InvalidDistroError(Exception):
    """Invalid distro error"""


class CannotFindLatestBuildError(Exception):
    """Cannot find latest build from a package"""


class SetCleanCacheAction(argparse._StoreTrueAction):
    """Custom Action making clean-cache as bundle of clean-cache-before and clean-cache-after"""

    def __call__(self, parser, namespace, values, option_string=None):
        setattr(namespace, 'clean_cache_before', self.const)
        setattr(namespace, 'clean_cache_after', self.const)


def is_distro_valid(distro):
    """Adjust if a distro is valid

    Currently, check for Fedora and RHEL.

    :param str distro: a string representing a distro value.
    :return: True if distro is the one specific to Fedora, like fc24, el7.
    "rtype: bool
    """
    return re.match(r'^(fc|el)\d{1,2}$', distro) is not None


def get_distro_from_string(str):
    """Get the part of a string that designates the Fedora distro version number

    For instance, when passed the string '2.3.fc12', this function
    returns the string 'fc12'.

    :param str the string to consider
    :return: The sub-string of the parameter that represents the
    Fedora distro version number, or None if the parameter does not
    contain such a sub-string.
    """

    m = re.match(r'(.*)((fc|el)\d{1,2})(.*)', str)
    if not m:
        return None

    distro = m.group(2)
    return distro


def match_nvr(s):
    """Determine if a string is a N-V-R"""
    return re.match(r'^([^/]+)-(.+)-(.+)$', s) is not None


def match_nvra(s):
    """Determine if a string is a N-V-R.A"""
    return re.match(r'^([^/]+)-(.+)-(.+)\.(.+)$', s) is not None


def is_rpm_file(filename):
    """Return if a file is a RPM"""
    isfile = os.path.isfile(filename)
    mimetype = mimetypes.guess_type(filename)[0] if isfile else None
    isrpm = (mimetype == 'application/x-redhat-package-manager'
             or mimetype == 'application/x-rpm')

    # Most systems won't have rpm defined as a mimetype
    if not mimetype and filename.endswith('.rpm'):
        isrpm = True
    logger.debug('is_rpm_file(\'%s\'): isfile=%s, mimetype=\'%s\', isrpm=%s',
                 filename, isfile, mimetype, isrpm)
    return isrpm


def cmp_nvr(left, right):
    """Compare function for sorting a sequence of NVRs

    This is the compare function used in sorted function to sort builds so that
    fedabipkgdiff is able to select the latest build. Return value follows the
    rules described in the part of paramter cmp of sorted documentation.

    :param str left: left nvr to compare.
    :param str right: right nvr to compare.
    :return: -1, 0, or 1 that represents left is considered smaller than,
    equal to, or larger than the right individually.
    :rtype: int
    """
    left_nvr = koji.parse_NVR(left['nvr'])
    right_nvr = koji.parse_NVR(right['nvr'])
    return rpm.labelCompare(
        (left_nvr['epoch'], left_nvr['version'], left_nvr['release']),
        (right_nvr['epoch'], right_nvr['version'], right_nvr['release']))


def log_call(func):
    """A decorator that logs a method invocation

    Method's name and all arguments, either positional or keyword arguments,
    will be logged by logger.debug. Also, return value from the decorated
    method will be logged just after the invocation is done.

    This decorator does not catch any exception thrown from the decorated
    method. If there is any exception thrown from decorated method, you can
    catch them in the caller and obviously, no return value is logged.

    :param callable func: a callable object to decorate
    """
    def proxy(*args, **kwargs):
        logger.debug('Call %s, args: %s, kwargs: %s',
                     func.__name__,
                     args if args else '',
                     kwargs if kwargs else '')
        result = func(*args, **kwargs)
        logger.debug('Result from %s: %s', func.__name__, result)
        return result
    return proxy


def delete_download_cache():
    """Delete download cache directory"""
    download_dir = get_download_dir()
    if global_config.dry_run:
        print('DRY-RUN: Delete cached downloaded RPM packages at {0}'.format(download_dir))
    else:
        logger.debug('Delete cached downloaded RPM packages at {0}'.format(download_dir))
        shutil.rmtree(download_dir)


class RPM(object):
    """Wrapper around an RPM descriptor received from Koji

    The RPM descriptor that is returned from Koji XMLRPC API is a
    dict. This wrapper class makes it eaiser to access all these
    properties in the way of object.property.
    """

    def __init__(self, rpm_info):
        """Initialize a RPM object

        :param dict rpm_info: a dict representing an RPM descriptor
        received from the Koji API, either listRPMs or getRPM
        """
        self.rpm_info = rpm_info

    def __str__(self):
        """Return the string representation of this RPM

        Return the string representation of RPM information returned from Koji
        directly so that RPM can be treated in same way.
        """
        return str(self.rpm_info)

    def __getattr__(self, name):
        """Access RPM information in the way of object.property

        :param str name: the property name to access.
        :raises AttributeError: if name is not one of keys of RPM information.
        """
        if name in self.rpm_info:
            return self.rpm_info[name]
        else:
            raise AttributeError('No attribute name {0}'.format(name))

    def is_peer(self, another_rpm):
        """Determine if this is the peer of a given rpm.

        Here is what "peer" means.

        Consider a package P for which the tripplet Name, Version,
        Release is made of the values {N,V,R}.  Then, consider a
        package P' for which the similar tripplet is {N', V', R'}.

        P' is a peer of P if N == N', and either V != V' or R != R'.
        given package with a given NVR is another package with a N'V'
        """
        return self.name == another_rpm.name and \
            self.arch == another_rpm.arch and \
            not (self.version == another_rpm.version
                 and self.release == another_rpm.release)

    @property
    def nvra(self):
        """Return a RPM's N-V-R-A representation

        An example: libabigail-1.0-0.8.rc4.1.fc23.x86_64
        """
        nvra, _ = os.path.splitext(self.filename)
        return nvra

    @property
    def filename(self):
        """Return a RPM file name

        An example: libabigail-1.0-0.8.rc4.1.fc23.x86_64.rpm
        """
        return os.path.basename(pathinfo.rpm(self.rpm_info))

    @property
    def is_debuginfo(self):
        """Check if the name of the current RPM denotes a debug info package"""
        return koji.is_debuginfo(self.rpm_info['name'])

    @property
    def is_devel(self):
        """Check if the name of current RPM denotes a development package"""
        return self.rpm_info['name'].endswith('-devel')

    @property
    def download_url(self):
        """Get the URL from where to download this RPM"""
        build = session.getBuild(self.build_id)
        return os.path.join(pathinfo.build(build), pathinfo.rpm(self.rpm_info))

    @property
    def downloaded_file(self):
        """Get a pridictable downloaded file name with absolute path"""
        # arch should be removed from the result returned from PathInfo.rpm
        filename = os.path.basename(pathinfo.rpm(self.rpm_info))
        return os.path.join(get_download_dir(), filename)

    @property
    def is_downloaded(self):
        """Check if this RPM was already downloaded to local disk"""
        return os.path.exists(self.downloaded_file)


class LocalRPM(RPM):
    """Representing a local RPM

    Local RPM means the one that could be already downloaded or built from
    where I can find it
    """

    def __init__(self, filename):
        """Initialize local RPM with a filename

        :param str filename: a filename pointing to a RPM file in local
        disk. Note that, this file must not exist necessarily.
        """
        self.local_filename = filename
        self.rpm_info = koji.parse_NVRA(os.path.basename(filename))

    @property
    def downloaded_file(self):
        """Return filename of this RPM

        Returned filename is just the one passed when initializing this RPM.

        :return: filename of this RPM
        :rtype: str
        """
        return self.local_filename

    @property
    def download_url(self):
        raise NotImplementedError('LocalRPM has no URL to download')

    def _find_rpm(self, rpm_filename):
        """Search an RPM from the directory of the current instance of LocalRPM

        :param str rpm_filename: filename of rpm to find, for example
        foo-devel-0.1-1.fc24.
        :return: an instance of LocalRPM representing the found rpm, or None if
        no RPM was found.
        """
        search_dir = os.path.dirname(os.path.abspath(self.local_filename))
        filename = os.path.join(search_dir, rpm_filename)
        return LocalRPM(filename) if os.path.exists(filename) else None

    @log_call
    def find_debuginfo(self):
        """Find debuginfo RPM package from a directory"""
        filename = \
            '%(name)s-debuginfo-%(version)s-%(release)s.%(arch)s.rpm' % \
            self.rpm_info
        return self._find_rpm(filename)

    @log_call
    def find_devel(self):
        """Find development package from a directory"""
        filename = \
            '%(name)s-devel-%(version)s-%(release)s.%(arch)s.rpm' % \
            self.rpm_info
        return self._find_rpm(filename)


class RPMCollection(object):
    """Collection of RPMs

    This is a simple collection containing RPMs collected from a
    directory on the local filesystem or retrieved from Koji.

    A collection can contain one or more sets of RPMs.  Each set of
    RPMs being for a particular architecture.

    For a given architecture, a set of RPMs is made of one RPM and its
    ancillary RPMs.  An ancillary RPM is either a debuginfo RPM or a
    devel RPM.

    So a given RPMCollection would (informally) look like:

    {
      i686   => {foo.i686.rpm, foo-debuginfo.i686.rpm, foo-devel.i686.rpm}
      x86_64 => {foo.x86_64.rpm, foo-debuginfo.x86_64.rpm, foo-devel.x86_64.rpm,}
    }

    """

    def __init__(self, rpms=None):
        # Mapping from arch to a list of rpm_infos.
        # Note that *all* RPMs of the collections are present in this
        # map; that is the RPM to consider and its ancillary RPMs.
        self.rpms = {}

        # Mapping from arch to another mapping containing index of debuginfo
        # and development package
        # e.g.
        # self.ancillary_rpms = {'i686', {'debuginfo': foo-debuginfo.rpm,
        #                                 'devel': foo-devel.rpm}}
        self.ancillary_rpms = {}

        if rpms:
            for rpm in rpms:
                self.add(rpm)

    @classmethod
    def gather_from_dir(cls, rpm_file, all_rpms=None):
        """Gather RPM collection from local directory"""
        dir_name = os.path.dirname(os.path.abspath(rpm_file))
        filename = os.path.basename(rpm_file)

        nvra = koji.parse_NVRA(filename)
        rpm_files = glob.glob(os.path.join(
            dir_name, '*-%(version)s-%(release)s.%(arch)s.rpm' % nvra))
        rpm_col = cls()

        if all_rpms:
            selector = lambda rpm: True
        else:
            selector = lambda rpm: local_rpm.is_devel or \
                local_rpm.is_debuginfo or local_rpm.filename == filename

        found_debuginfo = 1

        for rpm_file in rpm_files:
            local_rpm = LocalRPM(rpm_file)

            if local_rpm.is_debuginfo:
                found_debuginfo <<= 1
                if found_debuginfo == 4:
                    raise RuntimeError(
                        'Found more than one debuginfo package in '
                         'this directory. At the moment, fedabipkgdiff '
                        'is not able to deal with this case. '
                        'Please create two separate directories and '
                        'put an RPM and its ancillary debuginfo and '
                        'devel RPMs in each directory.')

            if selector(local_rpm):
                rpm_col.add(local_rpm)

        return rpm_col

    def add(self, rpm):
        """Add a RPM into this collection"""
        self.rpms.setdefault(rpm.arch, []).append(rpm)

        devel_debuginfo_default = {'debuginfo': None, 'devel': None}

        if rpm.is_debuginfo:
            self.ancillary_rpms.setdefault(
                rpm.arch, devel_debuginfo_default)['debuginfo'] = rpm

        if rpm.is_devel:
            self.ancillary_rpms.setdefault(
                rpm.arch, devel_debuginfo_default)['devel'] = rpm

    def rpms_iter(self, arches=None, default_behavior=True):
        """Iterator of RPMs to go through RPMs with specific arches"""
        arches = sorted(self.rpms.keys())

        for arch in arches:
            for _rpm in self.rpms[arch]:
                yield _rpm

    def get_sibling_debuginfo(self, rpm):
        """Get sibling debuginfo package of given rpm

        The sibling debuginfo is a debug info package for the
        'rpm'.  Note that if there are several debuginfo packages
        associated to 'rpm' and users want to get the one which name
        matches exactly 'rpm', then they might want to use the member
        function 'get_matching_debuginfo' instead.

        """
        if rpm.arch not in self.ancillary_rpms:
            return None
        return self.ancillary_rpms[rpm.arch].get('debuginfo')

    def get_matching_debuginfo(self, rpm):
        """Get the debuginfo package that matches a given one """
        all_debuginfo_list = self.get_all_debuginfo_rpms(rpm)
        debuginfo_pkg = None
        for d in all_debuginfo_list:
            if d.name == '{0}-debuginfo'.format(rpm.name):
                debuginfo_pkg = d
                break
        if not debuginfo_pkg:
            debuginfo_pkg = self.get_sibling_debuginfo(rpm)

        return debuginfo_pkg

    def get_sibling_devel(self, rpm):
        """Get sibling devel package of given rpm"""
        if rpm.arch not in self.ancillary_rpms:
            return None
        return self.ancillary_rpms[rpm.arch].get('devel')

    def get_peer_rpm(self, rpm):
        """Get peer rpm of rpm from this collection"""
        if rpm.arch not in self.rpms:
            return None
        for _rpm in self.rpms[rpm.arch]:
            if _rpm.is_peer(rpm):
                return _rpm
        return None

    def get_all_debuginfo_rpms(self, rpm_info):
        """Return a list of descriptors of all the debuginfo RPMs associated
        to a given RPM.

        :param: dict rpm_info a dict representing an RPM.  This was
        received from the Koji API, either from listRPMs or getRPM.
        :return: a list of dicts containing RPM descriptors (dicts)
        for the debuginfo RPMs associated to rpm_info
        :retype: dict
        """
        rpm_infos = self.rpms[rpm_info.arch]
        result = []
        for r in rpm_infos:
            if r.is_debuginfo:
                result.append(r)
        return result


def generate_comparison_halves(rpm_col1, rpm_col2):
    """Iterate RPM collection and peer's to generate comparison halves"""
    for _rpm in rpm_col1.rpms_iter():
        if _rpm.is_debuginfo:
            continue
        if _rpm.is_devel and not global_config.check_all_subpackages:
            continue

        if global_config.self_compare:
            rpm2 = _rpm
        else:
            rpm2 = rpm_col2.get_peer_rpm(_rpm)
            if rpm2 is None:
                logger.warning('Peer RPM of {0} is not found.'.format(_rpm.filename))
                continue

        debuginfo_list1 = []
        debuginfo_list2 = []

        # If this is a *devel* package we are looking at, then get all
        # the debug info packages associated to with the main package
        # and stick them into the resulting comparison half.

        if _rpm.is_devel:
            debuginfo_list1 = rpm_col1.get_all_debuginfo_rpms(_rpm)
        else:
            debuginfo_list1.append(rpm_col1.get_matching_debuginfo(_rpm))

        devel1 = rpm_col1.get_sibling_devel(_rpm)

        if global_config.self_compare:
            debuginfo_list2 = debuginfo_list1
            devel2 = devel1
        else:
            if rpm2.is_devel:
                debuginfo_list2 = rpm_col2.get_all_debuginfo_rpms(rpm2)
            else:
                debuginfo_list2.append(rpm_col2.get_matching_debuginfo(rpm2))
            devel2 = rpm_col2.get_sibling_devel(rpm2)

        yield (ComparisonHalf(subject=_rpm,
                              ancillary_debug=debuginfo_list1,
                              ancillary_devel=devel1),
               ComparisonHalf(subject=rpm2,
                              ancillary_debug=debuginfo_list2,
                              ancillary_devel=devel2))


class Brew(object):
    """Interface to Koji XMLRPC API with enhancements specific to fedabipkgdiff

    kojihub XMLRPC APIs are well-documented in koji's source code. For more
    details information, please refer to class RootExports within kojihub.py.

    For details of APIs used within fedabipkgdiff, refer to from line

    https://pagure.io/koji/blob/master/f/hub/kojihub.py#_7835
    """

    def __init__(self, baseurl):
        """Initialize Brew

        :param str baseurl: the kojihub URL to initialize a session, that is
        used to access koji XMLRPC APIs.
        """
        self.session = koji.ClientSession(baseurl)

    @log_call
    def listRPMs(self, buildID=None, arches=None, selector=None):
        """Get list of RPMs of a build from Koji

        Call kojihub.listRPMs to get list of RPMs. Return selected RPMs without
        changing each RPM information.

        A RPM returned from listRPMs contains following keys:

        - id
        - name
        - version
        - release
        - nvr (synthesized for sorting purposes)
        - arch
        - epoch
        - payloadhash
        - size
        - buildtime
        - build_id
        - buildroot_id
        - external_repo_id
        - external_repo_name
        - metadata_only
        - extra

        :param int buildID: id of a build from which to list RPMs.
        :param arches: to restrict to list RPMs with specified arches.
        :type arches: list or tuple
        :param selector: called to determine if a RPM should be selected and
        included in the final returned result. Selector must be a callable
        object and accepts one parameter of a RPM.
        :type selector: a callable object
        :return: a list of RPMs, each of them is a dict object
        :rtype: list
        """
        if selector:
            assert hasattr(selector, '__call__'), 'selector must be callable.'
        rpms = self.session.listRPMs(buildID=buildID, arches=arches)
        if selector:
            rpms = [rpm for rpm in rpms if selector(rpm)]
        return rpms

    @log_call
    def getRPM(self, rpminfo):
        """Get a RPM from koji

        Call kojihub.getRPM, and returns the result directly without any
        change.

        When not found a RPM, koji.getRPM will return None, then
        this method will raise RpmNotFound error immediately to claim what is
        happening. I want to raise fedabipkgdiff specific error rather than
        koji's GenericError and then raise RpmNotFound again, so I just simply
        don't use strict parameter to call koji.getRPM.

        :param rpminfo: rpminfo may be a N-V-R.A or a map containing name,
        version, release, and arch. For example, file-5.25-5.fc24.x86_64, and
        `{'name': 'file', 'version': '5.25', 'release': '5.fc24', 'arch':
        'x86_64'}`.
        :type rpminfo: str or dict
        :return: a map containing RPM information, that contains same keys as
        method `Brew.listRPMs`.
        :rtype: dict
        :raises RpmNotFound: if a RPM cannot be found with rpminfo.
        """
        rpm = self.session.getRPM(rpminfo)
        if rpm is None:
            raise RpmNotFound('Cannot find RPM {0}'.format(rpminfo))
        return rpm

    @log_call
    def listBuilds(self, packageID, state=None, topone=None,
                   selector=None, order_by=None, reverse=None):
        """Get list of builds from Koji

        Call kojihub.listBuilds, and return selected builds without changing
        each build information.

        By default, only builds with COMPLETE state are queried and returns
        afterwards.

        :param int packageID: id of package to list builds from.
        :param int state: build state. There are five states of a build in
        Koji. fedabipkgdiff only cares about builds with COMPLETE state. If
        state is omitted, builds with COMPLETE state are queried from Koji by
        default.
        :param bool topone: just return the top first build.
        :param selector: a callable object used to select specific subset of
        builds. Selector will be called immediately after Koji returns queried
        builds. When each call to selector, a build is passed to
        selector. Return True if select current build, False if not.
        :type selector: a callable object
        :param str order_by: the attribute name by which to order the builds,
        for example, name, version, or nvr.
        :param bool reverse: whether to order builds reversely.
        :return: a list of builds, even if there is only one build.
        :rtype: list
        :raises TypeError: if selector is not callable, or if order_by is not a
        string value.
        """
        if state is None:
            state = koji.BUILD_STATES['COMPLETE']

        if selector is not None and not hasattr(selector, '__call__'):
            raise TypeError(
                '{0} is not a callable object.'.format(str(selector)))

        if order_by is not None and not isinstance(order_by, six.string_types):
            raise TypeError('order_by {0} is invalid.'.format(order_by))

        builds = self.session.listBuilds(packageID=packageID, state=state)
        if selector is not None:
            builds = [build for build in builds if selector(build)]
        if order_by is not None:
            # FIXME: is it possible to sort builds by using opts parameter of
            # listBuilds
            if order_by == 'nvr':
                if six.PY2:
                    builds = sorted(builds, cmp=cmp_nvr, reverse=reverse)
                else:
                    builds = sorted(builds,
                                    key=functools.cmp_to_key(cmp_nvr),
                                    reverse=reverse)
            else:
                builds = sorted(
                    builds, key=lambda b: b[order_by], reverse=reverse)
        if topone:
            builds = builds[0:1]

        return builds

    @log_call
    def getPackage(self, name):
        """Get a package from Koji

        :param str name: a package name.
        :return: a mapping containing package information. For example,
        `{'id': 1, 'name': 'package'}`.
        :rtype: dict
        """
        package = self.session.getPackage(name)
        if package is None:
            package = self.session.getPackage(name.rsplit('-', 1)[0])
            if package is None:
                raise KojiPackageNotFound(
                    'Cannot find package {0}.'.format(name))
        return package

    @log_call
    def getBuild(self, buildID):
        """Get a build from Koji

        Call kojihub.getBuild. Return got build directly without change.

        :param int buildID: id of build to get from Koji.
        :return: the found build. Return None, if not found a build with
        buildID.
        :rtype: dict
        """
        return self.session.getBuild(buildID)

    @log_call
    def get_rpm_build_id(self, name, version, release, arch=None):
        """Get build ID that contains a RPM with specific nvra

        If arch is not omitted, a RPM can be identified by its N-V-R-A.

        If arch is omitted, name is used to get associated package, and then
        to get the build.

        Example:

        >>> brew = Brew('url to kojihub')
        >>> brew.get_rpm_build_id('httpd', '2.4.18', '2.fc24')
        >>> brew.get_rpm_build_id('httpd', '2.4.18', '2.fc25', 'x86_64')

        :param str name: name of a rpm
        :param str version: version of a rpm
        :param str release: release of a rpm
        :param arch: arch of a rpm
        :type arch: str or None
        :return: id of the build from where the RPM is built
        :rtype: dict
        :raises KojiPackageNotFound: if name is not found from Koji if arch
        is None.
        """
        if arch is None:
            package = self.getPackage(name)
            selector = lambda item: item['version'] == version and \
                item['release'] == release
            builds = self.listBuilds(packageID=package['id'],
                                     selector=selector)
            if not builds:
                raise NoBuildsError(
                    'No builds are selected from package {0}.'.format(
                        package['name']))
            return builds[0]['build_id']
        else:
            rpm = self.getRPM({'name': name,
                               'version': version,
                               'release': release,
                               'arch': arch,
                               })
            return rpm['build_id']

    @log_call
    def get_package_latest_build(self, package_name, distro):
        """Get latest build from a package, for a particular distro.

        Example:

        >>> brew = Brew('url to kojihub')
        >>> brew.get_package_latest_build('httpd', 'fc24')

        :param str package_name: from which package to get the latest build
        :param str distro: which distro the latest build belongs to
        :return: the found build
        :rtype: dict or None
        :raises NoCompleteBuilds: if there is no latest build of a package.
        """
        package = self.getPackage(package_name)
        selector = lambda item: item['release'].find(distro) > -1

        builds = self.listBuilds(packageID=package['id'],
                                 selector=selector,
                                 order_by='nvr',
                                 reverse=True)
        if not builds:
            # So we found no build which distro string exactly matches
            # the 'distro' parameter.
            #
            # Now lets try to get builds which distro string are less
            # than the value of the 'distro' parameter.  This is for
            # cases when, for instance, the build of package foo that
            # is present in current Fedora 27 is foo-1.fc26.  That
            # build originates from Fedora 26 but is being re-used in
            # Fedora 27.  So we want this function to pick up that
            # foo-1.fc26, even though we want the builds of foo that
            # match the distro string fc27.

            selector = lambda build: get_distro_from_string(build['release']) and \
                       get_distro_from_string(build['release']) <= distro

            builds = self.listBuilds(packageID=package['id'],
                                 selector=selector,
                                 order_by='nvr',
                                 reverse=True);

        if not builds:
            raise NoCompleteBuilds(
                'No complete builds of package {0}'.format(package_name))

        return builds[0]

    @log_call
    def select_rpms_from_a_build(self, build_id, package_name, arches=None,
                                 select_subpackages=None):
        """Select specific RPMs within a build

        RPMs could be filtered be specific criterias by the parameters.

        By default, fedabipkgdiff requires the RPM package, as well as
        its associated debuginfo and devel packages.  These three
        packages are selected, and noarch and src are excluded.

        :param int build_id: from which build to select rpms.
        :param str package_name: which rpm to select that matches this name.
        :param arches: which arches to select. If arches omits, rpms with all
        arches except noarch and src will be selected.
        :type arches: list, tuple or None
        :param bool select_subpackages: indicate whether to select all RPMs
        with specific arch from build.
        :return: a list of RPMs returned from listRPMs
        :rtype: list
        """
        excluded_arches = ('noarch', 'src')

        def rpms_selector(package_name, excluded_arches):
            return lambda rpm: \
                rpm['arch'] not in excluded_arches and \
                (rpm['name'] == package_name or
                 rpm['name'].endswith('-debuginfo') or
                 rpm['name'].endswith('-devel'))

        if select_subpackages:
            selector = lambda rpm: rpm['arch'] not in excluded_arches
        else:
            selector = rpms_selector(package_name, excluded_arches)
        rpm_infos = self.listRPMs(buildID=build_id,
                                  arches=arches,
                                  selector=selector)
        return RPMCollection((RPM(rpm_info) for rpm_info in rpm_infos))

    @log_call
    def get_latest_built_rpms(self, package_name, distro, arches=None):
        """Get RPMs from latest build of a package

        :param str package_name: from which package to get the rpms
        :param str distro: which distro the rpms belong to
        :param arches: which arches the rpms belong to
        :type arches: str or None
        :return: the selected RPMs
        :rtype: list
        """
        latest_build = self.get_package_latest_build(package_name, distro)
        # Get rpm and debuginfo rpm from each arch
        return self.select_rpms_from_a_build(latest_build['build_id'],
                                             package_name,
                                             arches=arches)


@log_call
def get_session():
    """Get instance of Brew to talk with Koji"""
    return Brew(global_config.koji_server)


@log_call
def get_download_dir():
    """Return the directory holding all downloaded RPMs

    If directory does not exist, it is created automatically.

    :return: path to directory holding downloaded RPMs.
    :rtype: str
    """
    download_dir = os.path.join(HOME_DIR, 'downloads')
    if not os.path.exists(download_dir):
        os.makedirs(download_dir)
    return download_dir


@log_call
def download_rpm(url):
    """Using curl to download a RPM from Koji

    Currently, curl is called and runs in a spawned process. pycurl would be a
    good way instead. This would be changed in the future.

    :param str url: URL of a RPM to download.
    :return: True if a RPM is downloaded successfully, False otherwise.
    :rtype: bool
    """
    cmd = 'curl --location --silent {0} -o {1}'.format(
        url, os.path.join(get_download_dir(),
                          os.path.basename(url)))
    if global_config.dry_run:
        print('DRY-RUN: {0}'.format(cmd))
        return

    return_code = subprocess.call(cmd, shell=True)
    if return_code > 0:
        logger.error('curl fails with returned code: %d.', return_code)
        return False
    return True


@log_call
def download_rpms(rpms):
    """Download RPMs

    :param list rpms: list of RPMs to download.
    """
    def _download(rpm):
        if rpm.is_downloaded:
            logger.debug('Reuse %s', rpm.downloaded_file)
        else:
            logger.debug('Download %s', rpm.download_url)
            download_rpm(rpm.download_url)

    for rpm in rpms:
        _download(rpm)


@log_call
def build_path_to_abipkgdiff():
    """Build the path to the 'abipkgidiff' program to use.

    The path to 'abipkgdiff' is either the argument of the
    --abipkgdiff command line option, or the path to 'abipkgdiff' as
    found in the $PATH environment variable.

    :return: str a string representing the path to the 'abipkgdiff'
    command.
    """
    if global_config.abipkgdiff:
        return global_config.abipkgdiff
    return DEFAULT_ABIPKGDIFF


def format_debug_info_pkg_options(option, debuginfo_list):
    """Given a list of debug info package descriptors return an option
    string that looks like:

       option dbg.rpm1 option dbgrpm2 ...

    :param: list debuginfo_list a list of instances of the RPM class
    representing the debug info rpms to use to construct the option
    string.

    :return: str a string representing the option string that
    concatenate the 'option' parameter before the path to each RPM
    contained in 'debuginfo_list'.
    """
    options = []

    for dbg_pkg in debuginfo_list:
        if dbg_pkg and dbg_pkg.downloaded_file:
            options.append(' {0} {1}'.format(option, dbg_pkg.downloaded_file))

    return ' '.join(options) if options else ''

@log_call
def abipkgdiff(cmp_half1, cmp_half2):
    """Run abipkgdiff against found two RPM packages

    Construct and execute abipkgdiff to get ABI diff

    abipkgdiff \
        --d1 package1-debuginfo --d2 package2-debuginfo \
        package1-rpm package2-rpm

    Output to stdout or stderr from abipkgdiff is not captured. abipkgdiff is
    called synchronously. fedabipkgdiff does not return until underlying
    abipkgdiff finishes.

    :param ComparisonHalf cmp_half1: the first comparison half.
    :param ComparisonHalf cmp_half2: the second comparison half.
    :return: return code of underlying abipkgdiff execution.
    :rtype: int
    """
    abipkgdiff_tool = build_path_to_abipkgdiff()

    suppressions = ''

    if global_config.suppr:
        suppressions = '--suppressions {0}'.format(global_config.suppr)

    if global_config.no_devel_pkg:
        devel_pkg1 = ''
        devel_pkg2 = ''
    else:
        if cmp_half1.ancillary_devel is None:
            msg = 'Development package for {0} does not exist.'.format(cmp_half1.subject.filename)
            if global_config.error_on_warning:
                raise RuntimeError(msg)
            else:
                devel_pkg1 = ''
                logger.warning('{0} Ignored.'.format(msg))
        else:
            devel_pkg1 = '--devel-pkg1 {0}'.format(cmp_half1.ancillary_devel.downloaded_file)

        if cmp_half2.ancillary_devel is None:
            msg = 'Development package for {0} does not exist.'.format(cmp_half2.subject.filename)
            if global_config.error_on_warning:
                raise RuntimeError(msg)
            else:
                devel_pkg2 = ''
                logger.warning('{0} Ignored.'.format(msg))
        else:
            devel_pkg2 = '--devel-pkg2 {0}'.format(cmp_half2.ancillary_devel.downloaded_file)

    if cmp_half1.ancillary_debug is None:
        msg = 'Debuginfo package for {0} does not exist.'.format(cmp_half1.subject.filename)
        if global_config.error_on_warning:
            raise RuntimeError(msg)
        else:
            debuginfo_pkg1 = ''
            logger.warning('{0} Ignored.'.format(msg))
    else:
        debuginfo_pkg1 = format_debug_info_pkg_options("--d1", cmp_half1.ancillary_debug)

    if cmp_half2.ancillary_debug is None:
        msg = 'Debuginfo package for {0} does not exist.'.format(cmp_half2.subject.filename)
        if global_config.error_on_warning:
            raise RuntimeError(msg)
        else:
            debuginfo_pkg2 = ''
            logger.warning('{0} Ignored.'.format(msg))
    else:
        debuginfo_pkg2 = format_debug_info_pkg_options("--d2", cmp_half2.ancillary_debug);

    cmd = []

    if global_config.self_compare:
        cmd = [
            abipkgdiff_tool,
            '--dso-only' if global_config.dso_only else '',
            '--self-check',
            debuginfo_pkg1,
            cmp_half1.subject.downloaded_file,
        ]
    else:
        cmd = [
            abipkgdiff_tool,
            suppressions,
            '--show-identical-binaries' if global_config.show_identical_binaries else '',
            '--no-default-suppression' if global_config.no_default_suppr else '',
            '--dso-only' if global_config.dso_only else '',
            debuginfo_pkg1,
            debuginfo_pkg2,
            devel_pkg1,
            devel_pkg2,
            cmp_half1.subject.downloaded_file,
            cmp_half2.subject.downloaded_file,
        ]
    cmd = [s for s in cmd if s != '']

    if global_config.dry_run:
        print('DRY-RUN: {0}'.format(' '.join(cmd)))
        return

    logger.debug('Run: %s', ' '.join(cmd))

    print('Comparing the ABI of binaries between {0} and {1}:'.format(
        cmp_half1.subject.filename, cmp_half2.subject.filename))
    print()

    proc = subprocess.Popen(' '.join(cmd), shell=True,
                            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                            universal_newlines=True)
    # So we could have done: stdout, stderr = proc.communicate()
    # But then the documentatin of proc.communicate says:
    #
    #    Note: The data read is buffered in memory, so do not use this
    #    method if the data size is large or unlimited. "
    #
    # In practice, we are seeing random cases where this
    # proc.communicate() function does *NOT* terminate and seems to be
    # in a deadlock state.  So we are avoiding it altogether.  We are
    # then busy looping, waiting for the spawn process to finish, and
    # then we get its output.
    #

    while True:
        if proc.poll() != None:
            break

    stdout = ''.join(proc.stdout.readlines())
    stderr = ''.join(proc.stderr.readlines())

    is_ok = proc.returncode == ABIDIFF_OK
    is_internal_error = proc.returncode & ABIDIFF_ERROR or proc.returncode & ABIDIFF_USAGE_ERROR
    has_abi_change = proc.returncode & ABIDIFF_ABI_CHANGE

    if is_internal_error:
        six.print_(stderr, file=sys.stderr)
    elif is_ok or has_abi_change:
        print(stdout)

    return proc.returncode


@log_call
def run_abipkgdiff(rpm_col1, rpm_col2):
    """Run abipkgdiff

    If one of the executions finds ABI differences, the return code is the
    return code from abipkgdiff.

    :param RPMCollection rpm_col1: a collection of RPMs
    :param RPMCollection rpm_col2: same as rpm_col1
    :return: exit code of the last non-zero returned from underlying abipkgdiff
    :rtype: int
    """
    return_codes = [
        abipkgdiff(cmp_half1, cmp_half2) for cmp_half1, cmp_half2
        in generate_comparison_halves(rpm_col1, rpm_col2)]
    return max(return_codes, key=abs) if return_codes else 0


@log_call
def diff_local_rpm_with_latest_rpm_from_koji():
    """Diff against local rpm and remove latest rpm

    This operation handles a local rpm and debuginfo rpm and remote ones
    located in remote Koji server, that has specific distro specificed by
    argument --from.

    1/ Suppose the packager has just locally built a package named
    foo-3.0.fc24.rpm. To compare the ABI of this locally build package with the
    latest stable package from Fedora 23, one would do:

    fedabipkgdiff --from fc23 ./foo-3.0.fc24.rpm
    """

    from_distro = global_config.from_distro
    if not is_distro_valid(from_distro):
        raise InvalidDistroError('Invalid distro {0}'.format(from_distro))

    local_rpm_file = global_config.NVR[0]
    if not os.path.exists(local_rpm_file):
        raise ValueError('{0} does not exist.'.format(local_rpm_file))

    local_rpm = LocalRPM(local_rpm_file)
    rpm_col1 = session.get_latest_built_rpms(local_rpm.name,
                                             from_distro,
                                             arches=local_rpm.arch)
    rpm_col2 = RPMCollection.gather_from_dir(local_rpm_file)

    if global_config.clean_cache_before:
        delete_download_cache()

    download_rpms(rpm_col1.rpms_iter())
    result = run_abipkgdiff(rpm_col1, rpm_col2)

    if global_config.clean_cache_after:
        delete_download_cache()

    return result


@log_call
def diff_latest_rpms_based_on_distros():
    """abipkgdiff rpms based on two distros

    2/ Suppose the packager wants to see how the ABIs of the package foo
    evolved between fedora 19 and fedora 22. She would thus type the command:

    fedabipkgdiff --from fc19 --to fc22 foo
    """

    from_distro = global_config.from_distro
    to_distro = global_config.to_distro

    if not is_distro_valid(from_distro):
        raise InvalidDistroError('Invalid distro {0}'.format(from_distro))

    if not is_distro_valid(to_distro):
        raise InvalidDistroError('Invalid distro {0}'.format(to_distro))

    package_name = global_config.NVR[0]

    rpm_col1 = session.get_latest_built_rpms(package_name,
                                             distro=global_config.from_distro)
    rpm_col2 = session.get_latest_built_rpms(package_name,
                                             distro=global_config.to_distro)

    if global_config.clean_cache_before:
        delete_download_cache()

    download_rpms(chain(rpm_col1.rpms_iter(), rpm_col2.rpms_iter()))
    result = run_abipkgdiff(rpm_col1, rpm_col2)

    if global_config.clean_cache_after:
        delete_download_cache()

    return result


@log_call
def diff_two_nvras_from_koji():
    """Diff two nvras from koji

    The arch probably omits, that means febabipkgdiff will diff all arches. If
    specificed, the specific arch will be handled.

    3/ Suppose the packager wants to compare the ABI of two packages designated
    by their name and version. She would issue a command like this:

    fedabipkgdiff foo-1.0.fc19 foo-3.0.fc24
    fedabipkgdiff foo-1.0.fc19.i686 foo-1.0.fc24.i686
    """
    left_rpm = koji.parse_NVRA(global_config.NVR[0])
    right_rpm = koji.parse_NVRA(global_config.NVR[1])

    if is_distro_valid(left_rpm['arch']) and \
            is_distro_valid(right_rpm['arch']):
        nvr = koji.parse_NVR(global_config.NVR[0])
        params1 = (nvr['name'], nvr['version'], nvr['release'], None)

        nvr = koji.parse_NVR(global_config.NVR[1])
        params2 = (nvr['name'], nvr['version'], nvr['release'], None)
    else:
        params1 = (left_rpm['name'],
                   left_rpm['version'],
                   left_rpm['release'],
                   left_rpm['arch'])
        params2 = (right_rpm['name'],
                   right_rpm['version'],
                   right_rpm['release'],
                   right_rpm['arch'])

    build_id = session.get_rpm_build_id(*params1)
    rpm_col1 = session.select_rpms_from_a_build(
        build_id, params1[0], arches=params1[3],
        select_subpackages=global_config.check_all_subpackages)

    build_id = session.get_rpm_build_id(*params2)
    rpm_col2 = session.select_rpms_from_a_build(
        build_id, params2[0], arches=params2[3],
        select_subpackages=global_config.check_all_subpackages)

    if global_config.clean_cache_before:
        delete_download_cache()

    download_rpms(chain(rpm_col1.rpms_iter(), rpm_col2.rpms_iter()))
    result = run_abipkgdiff(rpm_col1, rpm_col2)

    if global_config.clean_cache_after:
        delete_download_cache()

    return result


@log_call
def self_compare_rpms_from_distro():
    """Compare ABI between same package from a distro

    Doing ABI comparison on self package should return no
    ABI change and hence return code should be 0. This is useful
    to ensure that functionality of libabigail itself
    didn't break. This utility can be invoked like this:

    fedabipkgdiff --self-compare -a --from fc25 foo
    """

    from_distro = global_config.from_distro

    if not is_distro_valid(from_distro):
        raise InvalidDistroError('Invalid distro {0}'.format(from_distro))

    package_name = global_config.NVR[0]

    rpm_col1 = session.get_latest_built_rpms(package_name,
                                             distro=global_config.from_distro)

    if global_config.clean_cache_before:
        delete_download_cache()

    download_rpms(rpm_col1.rpms_iter())
    result = run_abipkgdiff(rpm_col1, rpm_col1)

    if global_config.clean_cache_after:
        delete_download_cache()

    return result


@log_call
def diff_from_two_rpm_files(from_rpm_file, to_rpm_file):
    """Diff two RPM files"""
    rpm_col1 = RPMCollection.gather_from_dir(from_rpm_file)
    rpm_col2 = RPMCollection.gather_from_dir(to_rpm_file)
    if global_config.clean_cache_before:
        delete_download_cache()
    download_rpms(chain(rpm_col1.rpms_iter(), rpm_col2.rpms_iter()))
    result = run_abipkgdiff(rpm_col1, rpm_col2)
    if global_config.clean_cache_after:
        delete_download_cache()
    return result


def build_commandline_args_parser():
    parser = argparse.ArgumentParser(
        description='Compare ABI of shared libraries in RPM packages from the '
                    'Koji build system')

    parser.add_argument(
        'NVR',
        nargs='*',
        help='RPM package N-V-R, N-V-R-A, N, or local RPM '
             'file names with relative or absolute path.')
    parser.add_argument(
        '--dry-run',
        required=False,
        dest='dry_run',
        action='store_true',
        help='Don\'t actually do the work. The commands that should be '
             'run will be sent to stdout.')
    parser.add_argument(
        '--from',
        required=False,
        metavar='DISTRO',
        dest='from_distro',
        help='baseline Fedora distribution name, for example, fc23')
    parser.add_argument(
        '--to',
        required=False,
        metavar='DISTRO',
        dest='to_distro',
        help='Fedora distribution name to compare against the baseline, for '
             'example, fc24')
    parser.add_argument(
        '-a',
        '--all-subpackages',
        required=False,
        action='store_true',
        dest='check_all_subpackages',
        help='Check all subpackages instead of only the package specificed in '
             'command line.')
    parser.add_argument(
        '--dso-only',
        required=False,
        action='store_true',
        dest='dso_only',
        help='Compare the ABI of shared libraries only. If this option is not '
             'provided, the tool compares the ABI of all ELF binaries.')
    parser.add_argument(
        '--debug',
        required=False,
        action='store_true',
        dest='debug',
        help='show debug output')
    parser.add_argument(
        '--traceback',
        required=False,
        action='store_true',
        dest='show_traceback',
        help='show traceback when there is an exception thrown.')
    parser.add_argument(
        '--server',
        required=False,
        metavar='URL',
        dest='koji_server',
        default=DEFAULT_KOJI_SERVER,
        help='URL of koji XMLRPC service. Default is {0}'.format(
            DEFAULT_KOJI_SERVER))
    parser.add_argument(
        '--topurl',
        required=False,
        metavar='URL',
        dest='koji_topurl',
        default=DEFAULT_KOJI_TOPURL,
        help='URL for RPM files access')
    parser.add_argument(
        '--abipkgdiff',
        required=False,
        metavar='ABIPKGDIFF',
        dest='abipkgdiff',
        default='',
        help="The path to the 'abipkgtool' command to use. "
             "By default use the one found in $PATH.")
    parser.add_argument(
        '--suppressions',
        required=False,
        metavar='SUPPR',
        dest='suppr',
        default='',
        help='The suppression specification file to use during comparison')
    parser.add_argument(
        '--no-default-suppression',
        required=False,
        action='store_true',
        dest='no_default_suppr',
        help='Do not load default suppression specifications')
    parser.add_argument(
        '--no-devel-pkg',
        required=False,
        action='store_true',
        dest='no_devel_pkg',
        help='Do not compare ABI with development package')
    parser.add_argument(
        '--show-identical-binaries',
        required=False,
        action='store_true',
        dest='show_identical_binaries',
        help='Show information about binaries whose ABI are identical')
    parser.add_argument(
        '--error-on-warning',
        required=False,
        action='store_true',
        dest='error_on_warning',
        help='Raise error instead of warning')
    parser.add_argument(
        '--clean-cache',
        required=False,
        action=SetCleanCacheAction,
        dest='clean_cache',
        default=None,
        help='A convenient way to clean cache without specifying '
             '--clean-cache-before and --clean-cache-after at same time')
    parser.add_argument(
        '--clean-cache-before',
        required=False,
        action='store_true',
        dest='clean_cache_before',
        default=None,
        help='Clean cache before ABI comparison')
    parser.add_argument(
        '--clean-cache-after',
        required=False,
        action='store_true',
        dest='clean_cache_after',
        default=None,
        help='Clean cache after ABI comparison')
    parser.add_argument(
        '--self-compare',
        required=False,
        action='store_true',
        dest='self_compare',
        default=None,
        help='ABI comparison on same package')
    return parser


def main():
    parser = build_commandline_args_parser()

    args = parser.parse_args()

    global global_config
    global_config = args

    global pathinfo
    pathinfo = koji.PathInfo(topdir=global_config.koji_topurl)

    global session
    session = get_session()

    if global_config.debug:
        logger.setLevel(logging.DEBUG)

    logger.debug(args)

    if global_config.from_distro and global_config.self_compare and \
            global_config.NVR:
        return self_compare_rpms_from_distro()

    if global_config.from_distro and global_config.to_distro is None and \
            global_config.NVR:
        return diff_local_rpm_with_latest_rpm_from_koji()

    if global_config.from_distro and global_config.to_distro and \
            global_config.NVR:
        return diff_latest_rpms_based_on_distros()

    if global_config.from_distro is None and global_config.to_distro is None:
        if len(global_config.NVR) > 1:
            left_one = global_config.NVR[0]
            right_one = global_config.NVR[1]

            if is_rpm_file(left_one) and is_rpm_file(right_one):
                return diff_from_two_rpm_files(left_one, right_one)

            both_nvr = match_nvr(left_one) and match_nvr(right_one)
            both_nvra = match_nvra(left_one) and match_nvra(right_one)

            if both_nvr or both_nvra:
                return diff_two_nvras_from_koji()

    six.print_('Unknown arguments. Please refer to --help.', file=sys.stderr)
    return 1


if __name__ == '__main__':
    try:
        sys.exit(main())
    except KeyboardInterrupt:
        if global_config is None:
            raise
        if global_config.debug:
            logger.debug('Terminate by user')
        else:
            six.print_('Terminate by user', file=sys.stderr)
        if global_config.show_traceback:
            raise
        else:
            sys.exit(2)
    except Exception as e:
        if global_config is None:
            raise
        if global_config.debug:
            logger.debug(str(e))
        else:
            six.print_(str(e), file=sys.stderr)
        if global_config.show_traceback:
            raise
        else:
            sys.exit(1)