예제 #1
0
    def update_version(self, new_version):
        LOG.info("Updating '%s' version to: %s" % (self.path, new_version))

        old_version = re.search(r'Version:\s*(\S+)', self.content).group(1)

        # we accept the Version tag in the format: xxx or %{xxx},
        # but not: xxx%{xxx}, %{xxx}xxx or %{xxx}%{xxx} because
        # there is no reliable way of knowing what the macro
        # represents in these cases.
        if re.match(r'(.+%{.*}|%{.*}.+)', old_version):
            raise exception.PackageSpecError("Failed to parse spec file "
                                             "'Version' tag")

        if "%{" in old_version:
            macro_name = old_version[2:-1]
            self._replace_macro_definition(macro_name, new_version)
        else:
            self.content = re.sub(r'(Version:\s*)\S+', r'\g<1>' + new_version,
                                  self.content)

        # since the version was updated, set the Release to 0. When
        # the release bump is made, it will increment to 1.
        self.content = re.sub(r'(Release:\s*)[\w.-]+', r'\g<1>0', self.content)

        self.write_content()
예제 #2
0
    def _load(self):
        """
        Read yaml file describing this package.
        """
        super(RPM_Package, self)._load()
        try:
            # keeps backwards compatibility with old yaml files which have 'centos'
            # instead of 'CentOS'
            if self.distro.name in self.package_data.get('files', {}):
                distro_attrib_name = self.distro.name
            else:
                distro_attrib_name = self.distro.name.lower()

            # load distro files
            files = self.package_data.get('files', {}).get(
                distro_attrib_name, {}).get(self.distro.version, {}) or {}

            default_build_files_dir_rel_path = os.path.join(
                self.distro.name, self.distro.version, "SOURCES")
            build_files_dir_rel_path = files.get(
                'build_files') or default_build_files_dir_rel_path
            build_files_dir_path = os.path.join(self.package_dir,
                                                build_files_dir_rel_path)
            if os.path.isdir(build_files_dir_path):
                self.build_files = build_files_dir_path
            else:
                self.build_files = None
            self.download_build_files = files.get('download_build_files', [])

            # list of dependencies
            for dep_name in files.get('install_dependencies', []):
                dep = RPM_Package.get_instance(
                    dep_name, self.distro, force_rebuild=self.force_rebuild)
                self.install_dependencies.append(dep)

            # keeps backward compatibility with old yaml files which have 'dependencies'
            # instead of 'install_dependencies'
            for dep_name in files.get('dependencies', []):
                dep = RPM_Package.get_instance(
                    dep_name, self.distro, force_rebuild=self.force_rebuild)
                self.install_dependencies.append(dep)

            for dep_name in files.get('build_dependencies', []):
                dep = RPM_Package.get_instance(
                    dep_name, self.distro, force_rebuild=self.force_rebuild)
                self.build_dependencies.append(dep)

            # keeps backward compatibility with old yaml files which have build
            # dependencies listed as install dependencies
            if self.distro.version == "7.2":
                self.build_dependencies = list(
                    set(self.build_dependencies + self.install_dependencies))

            default_rpm_macros_file_rel_path = os.path.join(
                self.distro.name, self.distro.version, "rpmmacro")
            rpm_macros_file_rel_path = files.get(
                'rpmmacro', default_rpm_macros_file_rel_path)
            rpm_macros_file_path = os.path.join(self.package_dir,
                                                rpm_macros_file_rel_path)
            if os.path.isfile(rpm_macros_file_path):
                self.rpmmacro = rpm_macros_file_path
            else:
                self.rpmmacro = None

            default_spec_file_rel_path = os.path.join(self.distro.name,
                                                      self.distro.version,
                                                      "%s.spec" % self.name)
            spec_file_rel_path = files.get('spec', default_spec_file_rel_path)
            self.spec_file_path = os.path.join(self.package_dir,
                                               spec_file_rel_path)
            self.spec_file = SpecFile(self.spec_file_path)

            if os.path.isfile(self.spec_file.path):
                LOG.info("Package found: %s for %s %s" %
                         (self.name, self.distro.name, self.distro.version))
            else:
                raise exception.PackageSpecError(
                    package=self.name,
                    distro=self.distro.name,
                    distro_version=self.distro.version)
        except TypeError:
            raise exception.PackageDescriptorError(package=self.name)