Spaces:
Runtime error
Runtime error
| """distutils.command.bdist_rpm | |
| Implements the Distutils 'bdist_rpm' command (create RPM source and binary | |
| distributions).""" | |
| import subprocess, sys, os | |
| from distutils.core import Command | |
| from distutils.debug import DEBUG | |
| from distutils.file_util import write_file | |
| from distutils.errors import * | |
| from distutils.sysconfig import get_python_version | |
| from distutils import log | |
| class bdist_rpm(Command): | |
| description = "create an RPM distribution" | |
| user_options = [ | |
| ('bdist-base=', None, | |
| "base directory for creating built distributions"), | |
| ('rpm-base=', None, | |
| "base directory for creating RPMs (defaults to \"rpm\" under " | |
| "--bdist-base; must be specified for RPM 2)"), | |
| ('dist-dir=', 'd', | |
| "directory to put final RPM files in " | |
| "(and .spec files if --spec-only)"), | |
| ('python=', None, | |
| "path to Python interpreter to hard-code in the .spec file " | |
| "(default: \"python\")"), | |
| ('fix-python', None, | |
| "hard-code the exact path to the current Python interpreter in " | |
| "the .spec file"), | |
| ('spec-only', None, | |
| "only regenerate spec file"), | |
| ('source-only', None, | |
| "only generate source RPM"), | |
| ('binary-only', None, | |
| "only generate binary RPM"), | |
| ('use-bzip2', None, | |
| "use bzip2 instead of gzip to create source distribution"), | |
| # More meta-data: too RPM-specific to put in the setup script, | |
| # but needs to go in the .spec file -- so we make these options | |
| # to "bdist_rpm". The idea is that packagers would put this | |
| # info in setup.cfg, although they are of course free to | |
| # supply it on the command line. | |
| ('distribution-name=', None, | |
| "name of the (Linux) distribution to which this " | |
| "RPM applies (*not* the name of the module distribution!)"), | |
| ('group=', None, | |
| "package classification [default: \"Development/Libraries\"]"), | |
| ('release=', None, | |
| "RPM release number"), | |
| ('serial=', None, | |
| "RPM serial number"), | |
| ('vendor=', None, | |
| "RPM \"vendor\" (eg. \"Joe Blow <[email protected]>\") " | |
| "[default: maintainer or author from setup script]"), | |
| ('packager=', None, | |
| "RPM packager (eg. \"Jane Doe <[email protected]>\") " | |
| "[default: vendor]"), | |
| ('doc-files=', None, | |
| "list of documentation files (space or comma-separated)"), | |
| ('changelog=', None, | |
| "RPM changelog"), | |
| ('icon=', None, | |
| "name of icon file"), | |
| ('provides=', None, | |
| "capabilities provided by this package"), | |
| ('requires=', None, | |
| "capabilities required by this package"), | |
| ('conflicts=', None, | |
| "capabilities which conflict with this package"), | |
| ('build-requires=', None, | |
| "capabilities required to build this package"), | |
| ('obsoletes=', None, | |
| "capabilities made obsolete by this package"), | |
| ('no-autoreq', None, | |
| "do not automatically calculate dependencies"), | |
| # Actions to take when building RPM | |
| ('keep-temp', 'k', | |
| "don't clean up RPM build directory"), | |
| ('no-keep-temp', None, | |
| "clean up RPM build directory [default]"), | |
| ('use-rpm-opt-flags', None, | |
| "compile with RPM_OPT_FLAGS when building from source RPM"), | |
| ('no-rpm-opt-flags', None, | |
| "do not pass any RPM CFLAGS to compiler"), | |
| ('rpm3-mode', None, | |
| "RPM 3 compatibility mode (default)"), | |
| ('rpm2-mode', None, | |
| "RPM 2 compatibility mode"), | |
| # Add the hooks necessary for specifying custom scripts | |
| ('prep-script=', None, | |
| "Specify a script for the PREP phase of RPM building"), | |
| ('build-script=', None, | |
| "Specify a script for the BUILD phase of RPM building"), | |
| ('pre-install=', None, | |
| "Specify a script for the pre-INSTALL phase of RPM building"), | |
| ('install-script=', None, | |
| "Specify a script for the INSTALL phase of RPM building"), | |
| ('post-install=', None, | |
| "Specify a script for the post-INSTALL phase of RPM building"), | |
| ('pre-uninstall=', None, | |
| "Specify a script for the pre-UNINSTALL phase of RPM building"), | |
| ('post-uninstall=', None, | |
| "Specify a script for the post-UNINSTALL phase of RPM building"), | |
| ('clean-script=', None, | |
| "Specify a script for the CLEAN phase of RPM building"), | |
| ('verify-script=', None, | |
| "Specify a script for the VERIFY phase of the RPM build"), | |
| # Allow a packager to explicitly force an architecture | |
| ('force-arch=', None, | |
| "Force an architecture onto the RPM build process"), | |
| ('quiet', 'q', | |
| "Run the INSTALL phase of RPM building in quiet mode"), | |
| ] | |
| boolean_options = ['keep-temp', 'use-rpm-opt-flags', 'rpm3-mode', | |
| 'no-autoreq', 'quiet'] | |
| negative_opt = {'no-keep-temp': 'keep-temp', | |
| 'no-rpm-opt-flags': 'use-rpm-opt-flags', | |
| 'rpm2-mode': 'rpm3-mode'} | |
| def initialize_options(self): | |
| self.bdist_base = None | |
| self.rpm_base = None | |
| self.dist_dir = None | |
| self.python = None | |
| self.fix_python = None | |
| self.spec_only = None | |
| self.binary_only = None | |
| self.source_only = None | |
| self.use_bzip2 = None | |
| self.distribution_name = None | |
| self.group = None | |
| self.release = None | |
| self.serial = None | |
| self.vendor = None | |
| self.packager = None | |
| self.doc_files = None | |
| self.changelog = None | |
| self.icon = None | |
| self.prep_script = None | |
| self.build_script = None | |
| self.install_script = None | |
| self.clean_script = None | |
| self.verify_script = None | |
| self.pre_install = None | |
| self.post_install = None | |
| self.pre_uninstall = None | |
| self.post_uninstall = None | |
| self.prep = None | |
| self.provides = None | |
| self.requires = None | |
| self.conflicts = None | |
| self.build_requires = None | |
| self.obsoletes = None | |
| self.keep_temp = 0 | |
| self.use_rpm_opt_flags = 1 | |
| self.rpm3_mode = 1 | |
| self.no_autoreq = 0 | |
| self.force_arch = None | |
| self.quiet = 0 | |
| def finalize_options(self): | |
| self.set_undefined_options('bdist', ('bdist_base', 'bdist_base')) | |
| if self.rpm_base is None: | |
| if not self.rpm3_mode: | |
| raise DistutilsOptionError( | |
| "you must specify --rpm-base in RPM 2 mode") | |
| self.rpm_base = os.path.join(self.bdist_base, "rpm") | |
| if self.python is None: | |
| if self.fix_python: | |
| self.python = sys.executable | |
| else: | |
| self.python = "python3" | |
| elif self.fix_python: | |
| raise DistutilsOptionError( | |
| "--python and --fix-python are mutually exclusive options") | |
| if os.name != 'posix': | |
| raise DistutilsPlatformError("don't know how to create RPM " | |
| "distributions on platform %s" % os.name) | |
| if self.binary_only and self.source_only: | |
| raise DistutilsOptionError( | |
| "cannot supply both '--source-only' and '--binary-only'") | |
| # don't pass CFLAGS to pure python distributions | |
| if not self.distribution.has_ext_modules(): | |
| self.use_rpm_opt_flags = 0 | |
| self.set_undefined_options('bdist', ('dist_dir', 'dist_dir')) | |
| self.finalize_package_data() | |
| def finalize_package_data(self): | |
| self.ensure_string('group', "Development/Libraries") | |
| self.ensure_string('vendor', | |
| "%s <%s>" % (self.distribution.get_contact(), | |
| self.distribution.get_contact_email())) | |
| self.ensure_string('packager') | |
| self.ensure_string_list('doc_files') | |
| if isinstance(self.doc_files, list): | |
| for readme in ('README', 'README.txt'): | |
| if os.path.exists(readme) and readme not in self.doc_files: | |
| self.doc_files.append(readme) | |
| self.ensure_string('release', "1") | |
| self.ensure_string('serial') # should it be an int? | |
| self.ensure_string('distribution_name') | |
| self.ensure_string('changelog') | |
| # Format changelog correctly | |
| self.changelog = self._format_changelog(self.changelog) | |
| self.ensure_filename('icon') | |
| self.ensure_filename('prep_script') | |
| self.ensure_filename('build_script') | |
| self.ensure_filename('install_script') | |
| self.ensure_filename('clean_script') | |
| self.ensure_filename('verify_script') | |
| self.ensure_filename('pre_install') | |
| self.ensure_filename('post_install') | |
| self.ensure_filename('pre_uninstall') | |
| self.ensure_filename('post_uninstall') | |
| # XXX don't forget we punted on summaries and descriptions -- they | |
| # should be handled here eventually! | |
| # Now *this* is some meta-data that belongs in the setup script... | |
| self.ensure_string_list('provides') | |
| self.ensure_string_list('requires') | |
| self.ensure_string_list('conflicts') | |
| self.ensure_string_list('build_requires') | |
| self.ensure_string_list('obsoletes') | |
| self.ensure_string('force_arch') | |
| def run(self): | |
| if DEBUG: | |
| print("before _get_package_data():") | |
| print("vendor =", self.vendor) | |
| print("packager =", self.packager) | |
| print("doc_files =", self.doc_files) | |
| print("changelog =", self.changelog) | |
| # make directories | |
| if self.spec_only: | |
| spec_dir = self.dist_dir | |
| self.mkpath(spec_dir) | |
| else: | |
| rpm_dir = {} | |
| for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'): | |
| rpm_dir[d] = os.path.join(self.rpm_base, d) | |
| self.mkpath(rpm_dir[d]) | |
| spec_dir = rpm_dir['SPECS'] | |
| # Spec file goes into 'dist_dir' if '--spec-only specified', | |
| # build/rpm.<plat> otherwise. | |
| spec_path = os.path.join(spec_dir, | |
| "%s.spec" % self.distribution.get_name()) | |
| self.execute(write_file, | |
| (spec_path, | |
| self._make_spec_file()), | |
| "writing '%s'" % spec_path) | |
| if self.spec_only: # stop if requested | |
| return | |
| # Make a source distribution and copy to SOURCES directory with | |
| # optional icon. | |
| saved_dist_files = self.distribution.dist_files[:] | |
| sdist = self.reinitialize_command('sdist') | |
| if self.use_bzip2: | |
| sdist.formats = ['bztar'] | |
| else: | |
| sdist.formats = ['gztar'] | |
| self.run_command('sdist') | |
| self.distribution.dist_files = saved_dist_files | |
| source = sdist.get_archive_files()[0] | |
| source_dir = rpm_dir['SOURCES'] | |
| self.copy_file(source, source_dir) | |
| if self.icon: | |
| if os.path.exists(self.icon): | |
| self.copy_file(self.icon, source_dir) | |
| else: | |
| raise DistutilsFileError( | |
| "icon file '%s' does not exist" % self.icon) | |
| # build package | |
| log.info("building RPMs") | |
| rpm_cmd = ['rpmbuild'] | |
| if self.source_only: # what kind of RPMs? | |
| rpm_cmd.append('-bs') | |
| elif self.binary_only: | |
| rpm_cmd.append('-bb') | |
| else: | |
| rpm_cmd.append('-ba') | |
| rpm_cmd.extend(['--define', '__python %s' % self.python]) | |
| if self.rpm3_mode: | |
| rpm_cmd.extend(['--define', | |
| '_topdir %s' % os.path.abspath(self.rpm_base)]) | |
| if not self.keep_temp: | |
| rpm_cmd.append('--clean') | |
| if self.quiet: | |
| rpm_cmd.append('--quiet') | |
| rpm_cmd.append(spec_path) | |
| # Determine the binary rpm names that should be built out of this spec | |
| # file | |
| # Note that some of these may not be really built (if the file | |
| # list is empty) | |
| nvr_string = "%{name}-%{version}-%{release}" | |
| src_rpm = nvr_string + ".src.rpm" | |
| non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm" | |
| q_cmd = r"rpm -q --qf '%s %s\n' --specfile '%s'" % ( | |
| src_rpm, non_src_rpm, spec_path) | |
| out = os.popen(q_cmd) | |
| try: | |
| binary_rpms = [] | |
| source_rpm = None | |
| while True: | |
| line = out.readline() | |
| if not line: | |
| break | |
| l = line.strip().split() | |
| assert(len(l) == 2) | |
| binary_rpms.append(l[1]) | |
| # The source rpm is named after the first entry in the spec file | |
| if source_rpm is None: | |
| source_rpm = l[0] | |
| status = out.close() | |
| if status: | |
| raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd)) | |
| finally: | |
| out.close() | |
| self.spawn(rpm_cmd) | |
| if not self.dry_run: | |
| if self.distribution.has_ext_modules(): | |
| pyversion = get_python_version() | |
| else: | |
| pyversion = 'any' | |
| if not self.binary_only: | |
| srpm = os.path.join(rpm_dir['SRPMS'], source_rpm) | |
| assert(os.path.exists(srpm)) | |
| self.move_file(srpm, self.dist_dir) | |
| filename = os.path.join(self.dist_dir, source_rpm) | |
| self.distribution.dist_files.append( | |
| ('bdist_rpm', pyversion, filename)) | |
| if not self.source_only: | |
| for rpm in binary_rpms: | |
| rpm = os.path.join(rpm_dir['RPMS'], rpm) | |
| if os.path.exists(rpm): | |
| self.move_file(rpm, self.dist_dir) | |
| filename = os.path.join(self.dist_dir, | |
| os.path.basename(rpm)) | |
| self.distribution.dist_files.append( | |
| ('bdist_rpm', pyversion, filename)) | |
| def _dist_path(self, path): | |
| return os.path.join(self.dist_dir, os.path.basename(path)) | |
| def _make_spec_file(self): | |
| """Generate the text of an RPM spec file and return it as a | |
| list of strings (one per line). | |
| """ | |
| # definitions and headers | |
| spec_file = [ | |
| '%define name ' + self.distribution.get_name(), | |
| '%define version ' + self.distribution.get_version().replace('-','_'), | |
| '%define unmangled_version ' + self.distribution.get_version(), | |
| '%define release ' + self.release.replace('-','_'), | |
| '', | |
| 'Summary: ' + self.distribution.get_description(), | |
| ] | |
| # Workaround for #14443 which affects some RPM based systems such as | |
| # RHEL6 (and probably derivatives) | |
| vendor_hook = subprocess.getoutput('rpm --eval %{__os_install_post}') | |
| # Generate a potential replacement value for __os_install_post (whilst | |
| # normalizing the whitespace to simplify the test for whether the | |
| # invocation of brp-python-bytecompile passes in __python): | |
| vendor_hook = '\n'.join([' %s \\' % line.strip() | |
| for line in vendor_hook.splitlines()]) | |
| problem = "brp-python-bytecompile \\\n" | |
| fixed = "brp-python-bytecompile %{__python} \\\n" | |
| fixed_hook = vendor_hook.replace(problem, fixed) | |
| if fixed_hook != vendor_hook: | |
| spec_file.append('# Workaround for http://bugs.python.org/issue14443') | |
| spec_file.append('%define __os_install_post ' + fixed_hook + '\n') | |
| # put locale summaries into spec file | |
| # XXX not supported for now (hard to put a dictionary | |
| # in a config file -- arg!) | |
| #for locale in self.summaries.keys(): | |
| # spec_file.append('Summary(%s): %s' % (locale, | |
| # self.summaries[locale])) | |
| spec_file.extend([ | |
| 'Name: %{name}', | |
| 'Version: %{version}', | |
| 'Release: %{release}',]) | |
| # XXX yuck! this filename is available from the "sdist" command, | |
| # but only after it has run: and we create the spec file before | |
| # running "sdist", in case of --spec-only. | |
| if self.use_bzip2: | |
| spec_file.append('Source0: %{name}-%{unmangled_version}.tar.bz2') | |
| else: | |
| spec_file.append('Source0: %{name}-%{unmangled_version}.tar.gz') | |
| spec_file.extend([ | |
| 'License: ' + self.distribution.get_license(), | |
| 'Group: ' + self.group, | |
| 'BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot', | |
| 'Prefix: %{_prefix}', ]) | |
| if not self.force_arch: | |
| # noarch if no extension modules | |
| if not self.distribution.has_ext_modules(): | |
| spec_file.append('BuildArch: noarch') | |
| else: | |
| spec_file.append( 'BuildArch: %s' % self.force_arch ) | |
| for field in ('Vendor', | |
| 'Packager', | |
| 'Provides', | |
| 'Requires', | |
| 'Conflicts', | |
| 'Obsoletes', | |
| ): | |
| val = getattr(self, field.lower()) | |
| if isinstance(val, list): | |
| spec_file.append('%s: %s' % (field, ' '.join(val))) | |
| elif val is not None: | |
| spec_file.append('%s: %s' % (field, val)) | |
| if self.distribution.get_url() != 'UNKNOWN': | |
| spec_file.append('Url: ' + self.distribution.get_url()) | |
| if self.distribution_name: | |
| spec_file.append('Distribution: ' + self.distribution_name) | |
| if self.build_requires: | |
| spec_file.append('BuildRequires: ' + | |
| ' '.join(self.build_requires)) | |
| if self.icon: | |
| spec_file.append('Icon: ' + os.path.basename(self.icon)) | |
| if self.no_autoreq: | |
| spec_file.append('AutoReq: 0') | |
| spec_file.extend([ | |
| '', | |
| '%description', | |
| self.distribution.get_long_description() | |
| ]) | |
| # put locale descriptions into spec file | |
| # XXX again, suppressed because config file syntax doesn't | |
| # easily support this ;-( | |
| #for locale in self.descriptions.keys(): | |
| # spec_file.extend([ | |
| # '', | |
| # '%description -l ' + locale, | |
| # self.descriptions[locale], | |
| # ]) | |
| # rpm scripts | |
| # figure out default build script | |
| def_setup_call = "%s %s" % (self.python,os.path.basename(sys.argv[0])) | |
| def_build = "%s build" % def_setup_call | |
| if self.use_rpm_opt_flags: | |
| def_build = 'env CFLAGS="$RPM_OPT_FLAGS" ' + def_build | |
| # insert contents of files | |
| # XXX this is kind of misleading: user-supplied options are files | |
| # that we open and interpolate into the spec file, but the defaults | |
| # are just text that we drop in as-is. Hmmm. | |
| install_cmd = ('%s install -O1 --root=$RPM_BUILD_ROOT ' | |
| '--record=INSTALLED_FILES') % def_setup_call | |
| script_options = [ | |
| ('prep', 'prep_script', "%setup -n %{name}-%{unmangled_version}"), | |
| ('build', 'build_script', def_build), | |
| ('install', 'install_script', install_cmd), | |
| ('clean', 'clean_script', "rm -rf $RPM_BUILD_ROOT"), | |
| ('verifyscript', 'verify_script', None), | |
| ('pre', 'pre_install', None), | |
| ('post', 'post_install', None), | |
| ('preun', 'pre_uninstall', None), | |
| ('postun', 'post_uninstall', None), | |
| ] | |
| for (rpm_opt, attr, default) in script_options: | |
| # Insert contents of file referred to, if no file is referred to | |
| # use 'default' as contents of script | |
| val = getattr(self, attr) | |
| if val or default: | |
| spec_file.extend([ | |
| '', | |
| '%' + rpm_opt,]) | |
| if val: | |
| with open(val) as f: | |
| spec_file.extend(f.read().split('\n')) | |
| else: | |
| spec_file.append(default) | |
| # files section | |
| spec_file.extend([ | |
| '', | |
| '%files -f INSTALLED_FILES', | |
| '%defattr(-,root,root)', | |
| ]) | |
| if self.doc_files: | |
| spec_file.append('%doc ' + ' '.join(self.doc_files)) | |
| if self.changelog: | |
| spec_file.extend([ | |
| '', | |
| '%changelog',]) | |
| spec_file.extend(self.changelog) | |
| return spec_file | |
| def _format_changelog(self, changelog): | |
| """Format the changelog correctly and convert it to a list of strings | |
| """ | |
| if not changelog: | |
| return changelog | |
| new_changelog = [] | |
| for line in changelog.strip().split('\n'): | |
| line = line.strip() | |
| if line[0] == '*': | |
| new_changelog.extend(['', line]) | |
| elif line[0] == '-': | |
| new_changelog.append(line) | |
| else: | |
| new_changelog.append(' ' + line) | |
| # strip trailing newline inserted by first changelog entry | |
| if not new_changelog[0]: | |
| del new_changelog[0] | |
| return new_changelog | |