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
