def __init__(self, component_name, num_pkgs, pkg_name, pkg_xml, distro, src_uri, tar_dir, md5_cache, sha256_cache, skip_keys): self.component = component_name yoctoRecipe.max_component_name = max(yoctoRecipe.max_component_name, len(component_name)) self.oe_component = yoctoRecipe.convert_to_oe_name(component_name) self.num_pkgs = num_pkgs self.name = pkg_name self.distro = distro.name self.version = get_pkg_version(distro, pkg_name, is_oe=True) self.src_uri = src_uri self.pkg_xml = pkg_xml self.author = None if self.pkg_xml: pkg_fields = PackageMetadata(pkg_xml) maintainer_name = pkg_fields.upstream_name maintainer_email = pkg_fields.upstream_email author_name = pkg_fields.author_name author_email = pkg_fields.author_email self.maintainer = maintainer_name + ' <' + maintainer_email + '>' if author_name or author_email: self.author = author_name + \ (' <' + author_email + '>' if author_email else '') self.license = pkg_fields.upstream_license self.description = pkg_fields.description self.homepage = pkg_fields.homepage self.build_type = pkg_fields.build_type else: self.description = '' self.license = None self.homepage = None self.build_type = 'catkin' self.maintainer = "OSRF" self.depends = set() self.depends_external = set() self.buildtool_depends = set() self.buildtool_depends_external = set() self.export_depends = set() self.export_depends_external = set() self.buildtool_export_depends = set() self.buildtool_export_depends_external = set() self.rdepends = set() self.rdepends_external = set() self.tdepends = set() self.tdepends_external = set() self.license_line = None self.archive_name = None self.license_md5 = None self.tar_dir = tar_dir if self.getArchiveName() not in md5_cache or \ self.getArchiveName() not in sha256_cache: self.downloadArchive() md5_cache[self.getArchiveName()] = hashlib.md5( open(self.getArchiveName(), 'rb').read()).hexdigest() sha256_cache[self.getArchiveName()] = hashlib.sha256( open(self.getArchiveName(), 'rb').read()).hexdigest() self.src_sha256 = sha256_cache[self.getArchiveName()] self.src_md5 = md5_cache[self.getArchiveName()] self.skip_keys = skip_keys self.multi_hyphen_re = re.compile('-{2,}')
def __init__(self, name, distro, src_uri, tar_dir, md5_cache, sha256_cache, patches, incs): self.name = name self.distro = distro.name self.version = get_pkg_version(distro, name) self.description = '' self.src_uri = src_uri self.pkg_xml = None self.author = "OSRF" self.license = None self.depends = list() self.license_line = None self.archive_name = None self.license_md5 = None self.patch_files = patches self.inc_files = incs self.tar_dir = tar_dir if self.getArchiveName() not in md5_cache or \ self.getArchiveName() not in sha256_cache: self.downloadArchive() md5_cache[self.getArchiveName()] = hashlib.md5( open(self.getArchiveName(), 'rb').read()).hexdigest() sha256_cache[self.getArchiveName()] = hashlib.sha256( open(self.getArchiveName(), 'rb').read()).hexdigest() self.src_sha256 = sha256_cache[self.getArchiveName()] self.src_md5 = md5_cache[self.getArchiveName()]
def regenerate_pkg(overlay, pkg, distro, preserve_existing=False): version = get_pkg_version(distro, pkg) ebuild_name =\ '/ros-{0}/{1}/{1}-{2}.ebuild'.format(distro.name, pkg, version) ebuild_name = overlay.repo.repo_dir + ebuild_name patch_path = '/ros-{}/{}/files'.format(distro.name, pkg) patch_path = overlay.repo.repo_dir + patch_path has_patches = os.path.exists(patch_path) pkg_names = get_package_names(distro)[0] if pkg not in pkg_names: raise RuntimeError("Unknown package '%s'" % (pkg)) # otherwise, remove a (potentially) existing ebuild. existing = glob.glob('{0}/ros-{1}/{2}/*.ebuild'.format( overlay.repo.repo_dir, distro.name, pkg)) if preserve_existing and os.path.isfile(ebuild_name): ok("ebuild for package '%s' up to date, skipping..." % pkg) return None, [] elif existing: overlay.repo.remove_file(existing[0]) manifest_file = '{0}/ros-{1}/{2}/Manifest'.format( overlay.repo.repo_dir, distro.name, pkg) overlay.repo.remove_file(manifest_file) try: current = gentoo_installer(distro, pkg, has_patches) current.ebuild.name = pkg except Exception as e: err('Failed to generate installer for package {}!'.format(pkg)) raise e try: ebuild_text = current.ebuild_text() metadata_text = current.metadata_text() except UnresolvedDependency: dep_err = 'Failed to resolve required dependencies for' err("{0} package {1}!".format(dep_err, pkg)) unresolved = current.ebuild.get_unresolved() for dep in unresolved: err(" unresolved: \"{}\"".format(dep)) return None, current.ebuild.get_unresolved() except KeyError as ke: err("Failed to parse data for package {}!".format(pkg)) raise ke make_dir("{}/ros-{}/{}".format(overlay.repo.repo_dir, distro.name, pkg)) success_msg = 'Successfully generated installer for package' ok('{0} \'{1}\'.'.format(success_msg, pkg)) try: ebuild_file = '{0}/ros-{1}/{2}/{2}-{3}.ebuild'.format( overlay.repo.repo_dir, distro.name, pkg, version) ebuild_file = open(ebuild_file, "w") metadata_file = '{0}/ros-{1}/{2}/metadata.xml'.format( overlay.repo.repo_dir, distro.name, pkg) metadata_file = open(metadata_file, "w") ebuild_file.write(ebuild_text) metadata_file.write(metadata_text) except Exception as e: err("Failed to write ebuild/metadata to disk!") raise e return current, []
def __init__( self, component_name, num_pkgs, pkg_name, pkg_xml, distro, src_uri, srcrev_cache, skip_keys ): self.component = component_name yoctoRecipe.max_component_name = max( yoctoRecipe.max_component_name, len(component_name)) self.oe_component = yoctoRecipe.convert_to_oe_name(component_name) self.num_pkgs = num_pkgs self.name = pkg_name self.distro = distro.name self.version = get_pkg_version(distro, pkg_name, is_oe=True) self.src_uri = src_uri self.pkg_xml = pkg_xml self.author = None if self.pkg_xml: pkg_fields = PackageMetadata(pkg_xml) maintainer_name = pkg_fields.upstream_name maintainer_email = pkg_fields.upstream_email author_name = pkg_fields.author_name author_email = pkg_fields.author_email self.maintainer = maintainer_name + ' <' + maintainer_email + '>' if author_name or author_email: self.author = author_name + \ (' <' + author_email + '>' if author_email else '') self.license = pkg_fields.upstream_license self.description = pkg_fields.description self.homepage = pkg_fields.homepage self.build_type = pkg_fields.build_type else: self.description = '' self.license = None self.homepage = None self.build_type = 'catkin' if \ yoctoRecipe._get_ros_version(distro) == 1 else 'ament_cmake' self.maintainer = "OSRF" self.depends = set() self.depends_external = set() self.buildtool_depends = set() self.buildtool_depends_external = set() self.export_depends = set() self.export_depends_external = set() self.buildtool_export_depends = set() self.buildtool_export_depends_external = set() self.rdepends = set() self.rdepends_external = set() self.tdepends = set() self.tdepends_external = set() self.license_line = None self.license_md5 = None if self.src_uri not in srcrev_cache: srcrev_cache[self.src_uri] = self.get_srcrev() self.srcrev = srcrev_cache[self.src_uri] self.skip_keys = skip_keys self.multi_hyphen_re = re.compile('-{2,}')
def regenerate_installer(overlay, pkg, distro, preserve_existing, tar_dir): make_dir("{0}/recipes-ros-{1}".format(overlay.repo.repo_dir, distro.name)) version = get_pkg_version(distro, pkg) pkg_names = get_package_names(distro)[0] if pkg not in pkg_names: raise RuntimeError("Unknown package '%s'" % pkg) # check for an existing recipe existing = glob.glob('{0}/recipes-ros-{1}/{2}/*.bb'.format( overlay.repo.repo_dir, distro.name, pkg)) if preserve_existing and existing: ok("recipe for package '%s' up to date, skpping..." % pkg) return None, [] elif existing: overlay.repo.remove_file(existing[0]) try: current = oe_installer(distro, pkg, tar_dir) current.recipe.name = pkg.replace('_', '-') except Exception as e: err('Failed to generate installer for package {}!'.format(pkg)) raise e try: recipe_text = current.recipe_text() except UnresolvedDependency: dep_err = 'Failed to resolve required dependencies for' err("{0} package {1}!".format(dep_err, pkg)) unresolved = current.recipe.get_unresolved() for dep in unresolved: err(" unresolved: \"{}\"".format(dep)) return None, current.recipe.get_unresolved() except NoPkgXml: err("Could not fetch pkg!") return None, [] except KeyError as ke: err("Failed to parse data for package {}!".format(pkg)) raise ke make_dir("{0}/recipes-ros-{1}/{2}".format(overlay.repo.repo_dir, distro.name, pkg.replace('_', '-'))) success_msg = 'Successfully generated installer for package' ok('{0} \'{1}\'.'.format(success_msg, pkg)) recipe_name = '{0}/recipes-ros-{1}/{2}/{2}_{3}.bb'.format( overlay.repo.repo_dir, distro.name, pkg.replace('_', '-'), version) try: with open('{0}'.format(recipe_name), "w") as recipe_file: recipe_file.write(recipe_text) except Exception as e: err("Failed to write recipe to disk!") raise e return current, []
def __init__(self, name, distro, src_uri, tar_dir): self.name = name self.distro = distro.name self.version = get_pkg_version(distro, name) self.description = '' self.src_uri = src_uri self.pkg_xml = None self.author = "OSRF" self.license = None self.depends = list() self.license_line = None self.archive_name = None self.license_md5 = None self.tar_dir = tar_dir self.downloadArchive() self.src_sha256 = hashlib.sha256( open(self.getArchiveName(), 'rb').read()).hexdigest() self.src_md5 = hashlib.md5(open(self.getArchiveName(), 'rb').read()).hexdigest()
def regenerate_pkg(overlay, pkg, rosdistro, preserve_existing, srcrev_cache, skip_keys): pkg_names = get_package_names(rosdistro)[0] if pkg not in pkg_names: yoctoRecipe.not_generated_recipes.add(pkg) raise RuntimeError("Unknown package '%s' available packages" " in selected distro: %s" % (pkg, get_package_names(rosdistro))) try: version = get_pkg_version(rosdistro, pkg, is_oe=True) except KeyError as ke: yoctoRecipe.not_generated_recipes.add(pkg) raise ke repo_dir = overlay.repo.repo_dir component_name = yoctoRecipe.convert_to_oe_name( rosdistro.release_packages[pkg].repository_name) recipe = yoctoRecipe.convert_to_oe_name(pkg) # check for an existing recipe which was removed by clean_ros_recipe_dirs prefix = 'meta-ros{0}-{1}/generated-recipes/*/{2}_*.bb'.format( yoctoRecipe._get_ros_version(rosdistro.name), rosdistro.name, recipe) existing = overlay.repo.git.status('--porcelain', '--', prefix) if existing: # The git status --porcelain output will look like this: # D meta-ros2-eloquent/generated-recipes/variants/ros-base_0.8.3-1.bb # we want just the path with filename if len(existing.split('\n')) > 1: warn('More than 1 recipe was output by "git status --porcelain ' 'meta-ros{0}-{1}/generated-recipes/*/{2}_*.bb": "{3}"'.format( yoctoRecipe._get_ros_version(rosdistro.name), rosdistro.name, recipe, existing)) if existing.split()[0] != 'D': err('Unexpected output from "git status --porcelain ' 'meta-ros{0}-{1}/generated-recipes/*/{2}_*.bb": "{3}"'.format( yoctoRecipe._get_ros_version(rosdistro.name), rosdistro.name, recipe, existing)) existing = existing.split()[1] else: # If it isn't shown in git status, it could still exist as normal # unchanged file when --only option is being used import glob existing = glob.glob('{0}/{1}'.format(repo_dir, prefix)) if existing: if len(existing) > 1: err('More than 1 recipe was output by "git status ' '--porcelain ' 'meta-ros{0}-{1}/generated-recipes/*/{2}_*.bb": "{3}"'. format(yoctoRecipe._get_ros_version(rosdistro.name), rosdistro.name, recipe, existing)) existing = existing[0] previous_version = None if preserve_existing and existing: ok("recipe for package '%s' up to date, skipping..." % pkg) yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None elif existing: overlay.repo.remove_file(existing, True) idx_version = existing.rfind('_') + len('_') previous_version = existing[idx_version:].rstrip('.bb') try: current = oe_recipe(rosdistro, pkg, srcrev_cache, skip_keys) except InvalidPackage as e: err('Invalid package: ' + str(e)) yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None except Exception as e: err('Failed generating recipe for {}! {}'.format(pkg, str(e))) yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None try: recipe_text = current.recipe_text() except NoPkgXml as nopkg: err("Could not fetch pkg! {}".format(str(nopkg))) yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None except KeyError as ke: err("Failed to parse data for package {}! {}".format(pkg, str(ke))) yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None make_dir("{0}/meta-ros{1}-{2}/generated-recipes/{3}".format( repo_dir, yoctoRecipe._get_ros_version(rosdistro.name), rosdistro.name, component_name)) success_msg = 'Successfully generated recipe for package' ok('{0} \'{1}\'.'.format(success_msg, pkg)) recipe_file_name = '{0}/meta-ros{1}-{2}/generated-recipes/{3}/' \ '{4}_{5}.bb'.format( repo_dir, yoctoRecipe._get_ros_version(rosdistro.name), rosdistro.name, component_name, recipe, version ) try: with open('{0}'.format(recipe_file_name), "w") as recipe_file: ok('Writing recipe {0}'.format(recipe_file_name)) recipe_file.write(recipe_text) yoctoRecipe.generated_components.add(component_name) yoctoRecipe.generated_recipes[recipe] = (version, component_name) except Exception: err("Failed to write recipe to disk!") yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None return current, previous_version, recipe
def generate_installers( distro, # ros distro overlay, # repo instance gen_pkg_func, # function to call for generating preserve_existing=True, # don't regenerate if installer exists *args, # any additional args for gen_pkg_func **kwargs # any additional keyword arguments ): distro_name = distro.name pkg_names = get_package_names(distro) total = float(len(pkg_names[0])) borkd_pkgs = dict() changes = [] installers = [] bad_installers = [] succeeded = 0 failed = 0 info("Generating installers for distro '%s'" % distro_name) for i, pkg in enumerate(sorted(pkg_names[0])): if 'skip_keys' in kwargs and pkg in kwargs['skip_keys']: warn("Package '%s' is in skip-keys list, skipping..." % pkg) continue version = get_pkg_version(distro, pkg) percent = '%.1f' % (100 * (float(i) / total)) try: current, current_info = gen_pkg_func(overlay, pkg, distro, preserve_existing, *args) if not current and current_info: # we are missing dependencies failed_msg = "{0}%: Failed to generate".format(percent) failed_msg += " installer for package '%s'!" % pkg err(failed_msg) borkd_pkgs[pkg] = current_info failed = failed + 1 continue elif not current and preserve_existing: # don't replace the installer succeeded = succeeded + 1 continue success_msg = 'Successfully generated installer for package' ok('{0}%: {1} \'{2}\'.'.format(percent, success_msg, pkg)) succeeded = succeeded + 1 if current_info: changes.append('*{0} {1} --> {2}*'.format( pkg, current_info, version)) else: changes.append('*{0} {1}*'.format(pkg, version)) installers.append(pkg) except UnknownBuildType as ub: err("{0}%: Unknown Build type '{1}' for package '{2}'".format( percent, str(ub), pkg)) failed = failed + 1 except KeyError: failed_msg = 'Failed to generate installer' err("{0}%: {1} for package {2}!".format(percent, failed_msg, pkg)) bad_installers.append(pkg) failed = failed + 1 results = 'Generated {0} / {1}'.format(succeeded, failed + succeeded) results += ' for distro {0}'.format(distro_name) info("------ {0} ------\n".format(results)) if len(borkd_pkgs) > 0: warn("Unresolved:") for broken in borkd_pkgs.keys(): warn("{}:".format(broken)) warn(" {}".format(borkd_pkgs[broken])) return installers, borkd_pkgs, changes
def regenerate_pkg(overlay, pkg, distro, preserve_existing, srcrev_cache, skip_keys): pkg_names = get_package_names(distro)[0] if pkg not in pkg_names: yoctoRecipe.not_generated_recipes.add(pkg) raise RuntimeError("Unknown package '%s'" % pkg) try: version = get_pkg_version(distro, pkg, is_oe=True) except KeyError as ke: yoctoRecipe.not_generated_recipes.add(pkg) raise ke repo_dir = overlay.repo.repo_dir component_name = yoctoRecipe.convert_to_oe_name( distro.release_packages[pkg].repository_name) recipe = yoctoRecipe.convert_to_oe_name(pkg) # check for an existing recipe prefix = '{0}/meta-ros{1}-{2}/generated-recipes/{3}/{4}'.format( repo_dir, yoctoRecipe._get_ros_version(distro.name), distro.name, component_name, recipe, ) existing = glob.glob('{}_*.bb'.format(prefix)) previous_version = None if preserve_existing and existing: ok("recipe for package '%s' up to date, skipping..." % pkg) yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None elif existing: existing = existing[0] overlay.repo.remove_file(existing, True) idx_version = existing.rfind('_') + len('_') previous_version = existing[idx_version:].rstrip('.bb') try: current = oe_recipe(distro, pkg, srcrev_cache, skip_keys) except InvalidPackage as e: err('Invalid package: ' + str(e)) yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None except Exception as e: err('Failed generating recipe for {}! {}'.format(pkg, str(e))) yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None try: recipe_text = current.recipe_text() except NoPkgXml as nopkg: err("Could not fetch pkg! {}".format(str(nopkg))) yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None except KeyError as ke: err("Failed to parse data for package {}! {}".format(pkg, str(ke))) yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None make_dir("{0}/meta-ros{1}-{2}/generated-recipes/{3}".format( repo_dir, yoctoRecipe._get_ros_version(distro.name), distro.name, component_name)) success_msg = 'Successfully generated recipe for package' ok('{0} \'{1}\'.'.format(success_msg, pkg)) recipe_file_name = '{0}/meta-ros{1}-{2}/generated-recipes/{3}/' \ 'ros{1}-{4}_{5}.bb'.format( repo_dir, yoctoRecipe._get_ros_version(distro.name), distro.name, component_name, recipe, version ) try: with open('{0}'.format(recipe_file_name), "w") as recipe_file: ok('Writing recipe {0}'.format(recipe_file_name)) recipe_file.write(recipe_text) yoctoRecipe.generated_components.add(component_name) yoctoRecipe.generated_recipes['ros{0}-{1}'.format( yoctoRecipe._get_ros_version(distro.name), recipe)] = (version, component_name) except Exception: err("Failed to write recipe to disk!") yoctoRecipe.not_generated_recipes.add(pkg) return None, [], None return current, previous_version, recipe
def regenerate_pkg(overlay, pkg, distro, preserve_existing, tar_dir, md5_cache, sha256_cache, skip_keys): pkg_names = get_package_names(distro)[0] if pkg not in pkg_names: yoctoRecipe.not_generated_recipes.add(pkg) raise RuntimeError("Unknown package '%s'" % pkg) try: version = get_pkg_version(distro, pkg, is_oe=True) except KeyError as ke: yoctoRecipe.not_generated_recipes.add(pkg) raise ke repo_dir = overlay.repo.repo_dir component_name = yoctoRecipe.convert_to_oe_name( distro.release_packages[pkg].repository_name) recipe = yoctoRecipe.convert_to_oe_name(pkg) # check for an existing recipe glob_pattern = '{0}/generated-recipes-{1}/{2}/{3}*.bb'.format( repo_dir, distro.name, component_name, recipe) existing = glob.glob(glob_pattern) if preserve_existing and existing: ok("recipe for package '%s' up to date, skipping..." % pkg) yoctoRecipe.not_generated_recipes.add(pkg) return None, [] elif existing: overlay.repo.remove_file(existing[0], True) try: current = oe_installer(distro, pkg, tar_dir, md5_cache, sha256_cache, skip_keys) except InvalidPackage as e: err('Invalid package: ' + str(e)) yoctoRecipe.not_generated_recipes.add(pkg) return None, [] except Exception as e: err('Failed generating installer for {}! {}'.format(pkg, str(e))) yoctoRecipe.not_generated_recipes.add(pkg) return None, [] try: recipe_text = current.recipe_text() except NoPkgXml as nopkg: err("Could not fetch pkg! {}".format(str(nopkg))) yoctoRecipe.not_generated_recipes.add(pkg) return None, [] except KeyError as ke: err("Failed to parse data for package {}! {}".format(pkg, str(ke))) yoctoRecipe.not_generated_recipes.add(pkg) return None, [] make_dir("{0}/generated-recipes-{1}/{2}".format(repo_dir, distro.name, component_name)) success_msg = 'Successfully generated installer for package' ok('{0} \'{1}\'.'.format(success_msg, pkg)) recipe_file_name = '{0}/generated-recipes-{1}/{2}/{3}_{4}.bb'.format( repo_dir, distro.name, component_name, recipe, version) try: with open('{0}'.format(recipe_file_name), "w") as recipe_file: ok('Writing recipe {0}'.format(recipe_file_name)) recipe_file.write(recipe_text) yoctoRecipe.generated_components.add(component_name) yoctoRecipe.generated_recipes[recipe] = (version, component_name) except Exception: err("Failed to write recipe to disk!") yoctoRecipe.not_generated_recipes.add(pkg) return None, [] return current, []
def __init__( self, component_name, num_pkgs, pkg_name, pkg_xml, rosdistro, src_uri, srcrev_cache, skip_keys ): self.component = component_name yoctoRecipe.max_component_name = max( yoctoRecipe.max_component_name, len(component_name)) self.oe_component = yoctoRecipe.convert_to_oe_name(component_name) self.num_pkgs = num_pkgs self.name = pkg_name self.distro = rosdistro.name self.version = get_pkg_version(rosdistro, pkg_name, is_oe=True) self.src_uri = src_uri self.pkg_xml = pkg_xml self.author = None if self.pkg_xml: pkg_fields = PackageMetadata( pkg_xml, yoctoRecipe._get_condition_context(rosdistro.name)) maintainer_name = pkg_fields.upstream_name maintainer_email = pkg_fields.upstream_email author_name = pkg_fields.author_name author_email = pkg_fields.author_email self.maintainer = maintainer_name + ' <' + maintainer_email + '>' if author_name or author_email: self.author = author_name + \ (' <' + author_email + '>' if author_email else '') self.license = pkg_fields.upstream_license self.description = pkg_fields.description self.homepage = pkg_fields.homepage pkg_build_type = pkg_fields.build_type if pkg_build_type == 'catkin' and \ yoctoRecipe._get_ros_version(rosdistro.name) == 2: err("Package " + pkg_name + " either doesn't have <export>" "<build_type> element at all or it's set to 'catkin'" " which isn't a valid option for ROS 2; changing it to" " 'ament_cmake'") pkg_build_type = 'ament_cmake' self.build_type = pkg_build_type else: self.description = '' self.license = None self.homepage = None self.build_type = 'catkin' if \ yoctoRecipe._get_ros_version(rosdistro.name) == 1 \ else 'ament_cmake' self.maintainer = "OSRF" self.depends = set() self.depends_external = set() self.buildtool_depends = set() self.buildtool_depends_external = set() self.export_depends = set() self.export_depends_external = set() self.buildtool_export_depends = set() self.buildtool_export_depends_external = set() self.rdepends = set() self.rdepends_external = set() self.tdepends = set() self.tdepends_external = set() self.license_line = None self.license_md5 = None if self.src_uri not in srcrev_cache: srcrev_cache[self.src_uri] = self.get_srcrev() self.srcrev = srcrev_cache[self.src_uri] self.skip_keys = skip_keys
def regenerate_pkg(overlay, pkg, distro, preserve_existing=False): version = get_pkg_version(distro, pkg) pkgbuild_name =\ '/ros-{0}/{1}/{1}.pkgbuild'.format(distro.name, pkg) pkgbuild_name = overlay.repo.repo_dir + pkgbuild_name patch_path = '/ros-{}/{}/files'.format(distro.name, pkg) patch_path = overlay.repo.repo_dir + patch_path is_ros2 = get_distros()[distro.name]['distribution_type'] == 'ros2' has_patches = os.path.exists(patch_path) pkg_names = get_package_names(distro)[0] patches = None if os.path.exists(patch_path): patches = [ f for f in glob.glob('%s/*.patch' % patch_path) ] if pkg not in pkg_names: raise RuntimeError("Unknown package '%s'" % (pkg)) # otherwise, remove a (potentially) existing pkgbuild. prefix = '{0}/ros-{1}/{2}/'.format(overlay.repo.repo_dir, distro.name, pkg) existing = glob.glob('%s*.pkgbuild' % prefix) previous_version = None if preserve_existing and os.path.isfile(pkgbuild_name): ok("pkgbuild for package '%s' up to date, skipping..." % pkg) return None, [], None elif existing: overlay.repo.remove_file(existing[0]) previous_version = existing[0].lstrip(prefix).rstrip('.pkgbuild') manifest_file = '{0}/ros-{1}/{2}/Manifest'.format( overlay.repo.repo_dir, distro.name, pkg ) overlay.repo.remove_file(manifest_file) try: current = arch_pkgbuild(distro, pkg, has_patches) current.pkgbuild.name = pkg current.pkgbuild.version = version current.pkgbuild.patches = patches current.pkgbuild.is_ros2 = is_ros2 except Exception as e: err('Failed to generate pkgbuild for package {}!'.format(pkg)) raise e try: pkgbuild_text = current.pkgbuild_text() except UnresolvedDependency: dep_err = 'Failed to resolve required dependencies for' err("{0} package {1}!".format(dep_err, pkg)) unresolved = current.pkgbuild.get_unresolved() for dep in unresolved: err(" unresolved: \"{}\"".format(dep)) return None, current.pkgbuild.get_unresolved(), None except KeyError as ke: err("Failed to parse data for package {}!".format(pkg)) raise ke make_dir( "{}/ros-{}/{}".format(overlay.repo.repo_dir, distro.name, pkg) ) success_msg = 'Successfully generated pkgbuild for package' ok('{0} \'{1}\'.'.format(success_msg, pkg)) try: pkgbuild_file = '{0}/ros-{1}/{2}/PKGBUILD'.format( overlay.repo.repo_dir, distro.name, pkg, ) ok(f"writing {pkgbuild_file}") with open(pkgbuild_file, "w") as pkgbuild_file_f: pkgbuild_file_f.write(pkgbuild_text) except Exception as e: err(f"Failed to write f{pkgbuild_file} to disk!") raise e return current, previous_version, pkg
def generate_installers( distro_name, # ros distro name overlay, # repo instance gen_pkg_func, # function to call for generating preserve_existing=True, # don't regenerate if installer exists *args # any aditional args for gen_pkg_func ): distro = get_distro(distro_name) pkg_names = get_package_names(distro) total = float(len(pkg_names[0])) borkd_pkgs = dict() changes = [] installers = [] bad_installers = [] succeeded = 0 failed = 0 info("Generating installers for distro '%s'" % distro_name) for i, pkg in enumerate(sorted(pkg_names[0])): version = get_pkg_version(distro, pkg) percent = '%.1f' % (100 * (float(i) / total)) try: current, bad_deps = gen_pkg_func(overlay, pkg, distro, preserve_existing, *args) if not current and bad_deps: # we are missing dependencies failed_msg = "{0}%: Failed to generate".format(percent) failed_msg += " installer for package '%s'!" % pkg err(failed_msg) borkd_pkgs[pkg] = bad_deps failed = failed + 1 continue elif not current and preserve_existing: # don't replace the installer succeeded = succeeded + 1 continue success_msg = 'Successfully generated installer for package' ok('{0}%: {1} \'{2}\'.'.format(percent, success_msg, pkg)) succeeded = succeeded + 1 changes.append('*{0} --> {1}*'.format(pkg, version)) installers.append(pkg) except UnknownLicense as ul: err("{0}%: Unknown License '{1}'.".format(percent, str(ul))) bad_installers.append(pkg) failed = failed + 1 except KeyError: failed_msg = 'Failed to generate installer' err("{0}%: {1} for package {2}!".format(percent, failed_msg, pkg)) bad_installers.append(pkg) failed = failed + 1 results = 'Generated {0} / {1}'.format(succeeded, failed + succeeded) results += ' for distro {0}'.format(distro_name) info("------ {0} ------\n".format(results)) if len(borkd_pkgs) > 0: warn("Unresolved:") for broken in borkd_pkgs.keys(): warn("{}:".format(broken)) warn(" {}".format(borkd_pkgs[broken])) return installers, borkd_pkgs, changes