def generate_rosinstall(distro_name, names,
from_paths=None, repo_names=None,
deps=False, deps_up_to=None, deps_depth=None, deps_only=False,
wet_only=False, dry_only=False, catkin_only=False, non_catkin_only=False,
excludes=None, exclude_paths=None,
flat=False,
tar=False,
upstream_version_tag=False, upstream_source_version=False):
# classify package/stack names
names, pkg_keywords = _split_special_keywords(names)
# find packages recursively in include paths
if from_paths:
include_names_from_path = set([])
[include_names_from_path.update(_get_package_names(from_path)) for from_path in from_paths]
logger.debug("The following wet packages found in '--from-path' will be considered: %s" % ', '.join(sorted(include_names_from_path)))
names.update(include_names_from_path)
# Allow special keywords in repos
repo_names, repo_keywords = _split_special_keywords(repo_names or [])
if set(repo_keywords).difference(set([ARG_ALL_PACKAGES])):
raise RuntimeError('The only keyword supported by repos is %r' % (ARG_ALL_PACKAGES))
if ARG_ALL_PACKAGES in repo_keywords:
wet_distro = get_wet_distro(distro_name)
repo_names = wet_distro.repositories.keys()
# expand repository names into package names
repo_names, unknown_repo_names = _classify_repo_names(distro_name, repo_names)
if unknown_repo_names:
logger.warn('The following unknown repositories will be ignored: %s' % (', '.join(sorted(unknown_repo_names))))
wet_package_names, unreleased_repo_names = _get_packages_for_repos(distro_name, repo_names, source=upstream_source_version)
names.update(wet_package_names)
if unreleased_repo_names and not upstream_version_tag and not upstream_source_version:
logger.warn('The following unreleased repositories will be ignored: %s' % ', '.join(sorted(unreleased_repo_names)))
if unreleased_repo_names and (deps or deps_up_to) and (upstream_version_tag or upstream_source_version):
logger.warn('The dependencies of the following unreleased repositories are unknown and will be ignored: %s' % ', '.join(sorted(unreleased_repo_names)))
has_repos = ((repo_names - unreleased_repo_names) and (upstream_version_tag or upstream_source_version)) or (unreleased_repo_names and upstream_source_version)
names, unknown_names = _classify_names(distro_name, names, source=upstream_source_version)
if unknown_names:
logger.warn('The following unreleased packages/stacks will be ignored: %s' % (', '.join(sorted(unknown_names))))
if pkg_keywords:
expanded_names, unknown_names = _classify_names(distro_name, _expand_keywords(distro_name, pkg_keywords), source=upstream_source_version)
if unknown_names:
logger.warn('The following unreleased packages/stacks from the %s will be ignored: %s' % (ROS_PACKAGE_PATH, ', '.join(sorted(unknown_names))))
names.update(expanded_names)
if not names.wet_package_names and not names.dry_stack_names and not has_repos:
raise RuntimeError('No packages/stacks left after ignoring unreleased')
if names.wet_package_names or names.dry_stack_names:
logger.debug('Packages/stacks: %s' % ', '.join(sorted(names.wet_package_names | names.dry_stack_names)))
if unreleased_repo_names:
logger.debug('Unreleased repositories: %s' % ', '.join(sorted(unreleased_repo_names)))
# classify deps-up-to
deps_up_to_names, deps_keywords = _split_special_keywords(deps_up_to or [])
deps_up_to_names, unknown_names = _classify_names(distro_name, deps_up_to_names, source=upstream_source_version)
if unknown_names:
logger.warn("The following unreleased '--deps-up-to' packages/stacks will be ignored: %s" % (', '.join(sorted(unknown_names))))
if deps_keywords:
expanded_names, unknown_names = _classify_names(distro_name, _expand_keywords(distro_name, deps_keywords), source=upstream_source_version)
if unknown_names:
logger.warn("The following unreleased '--deps-up-to' packages/stacks from the %s will be ignored: %s" % (ROS_PACKAGE_PATH, ', '.join(sorted(unknown_names))))
deps_up_to_names.update(expanded_names)
if deps_up_to:
logger.debug('Dependencies up to: %s' % ', '.join(sorted(deps_up_to_names.wet_package_names | deps_up_to_names.dry_stack_names)))
# classify excludes
exclude_names, excludes_keywords = _split_special_keywords(excludes or [])
if exclude_paths:
exclude_names_from_path = set([])
[exclude_names_from_path.update(_get_package_names(exclude_path)) for exclude_path in exclude_paths]
logger.debug("The following wet packages found in '--exclude-path' will be excluded: %s" % ', '.join(sorted(exclude_names_from_path)))
exclude_names.update(exclude_names_from_path)
exclude_names, unknown_names = _classify_names(distro_name, exclude_names, source=upstream_source_version)
if unknown_names:
logger.warn("The following unreleased '--exclude' packages/stacks will be ignored: %s" % (', '.join(sorted(unknown_names))))
if excludes_keywords:
expanded_names, unknown_names = _classify_names(distro_name, _expand_keywords(distro_name, excludes_keywords), source=upstream_source_version)
exclude_names.update(expanded_names)
if excludes:
logger.debug('Excluded packages/stacks: %s' % ', '.join(sorted(exclude_names.wet_package_names | exclude_names.dry_stack_names)))
result = copy.deepcopy(names)
# clear wet packages if not requested
if dry_only:
result.wet_package_names.clear()
# clear dry packages if not requested and no dependencies
if wet_only and not deps and not deps_up_to:
result.dry_stack_names.clear()
# remove excluded names from the list of wet and dry names
result.wet_package_names -= exclude_names.wet_package_names
result.dry_stack_names -= exclude_names.dry_stack_names
if not result.wet_package_names and not result.dry_stack_names and not has_repos:
raise RuntimeError('No packages/stacks left after applying the exclusions')
if result.wet_package_names:
logger.debug('Wet packages: %s' % ', '.join(sorted(result.wet_package_names)))
if result.dry_stack_names:
logger.debug('Dry stacks: %s' % ', '.join(sorted(result.dry_stack_names)))
# extend the names with recursive dependencies
if deps or deps_up_to:
# add dry dependencies
if result.dry_stack_names:
dry_distro = get_dry_distro(distro_name)
_, unreleased_stack_names = get_stack_names(dry_distro)
excludes = exclude_names.dry_stack_names | deps_up_to_names.dry_stack_names | set(unreleased_stack_names)
dry_dependencies, wet_dependencies = get_recursive_dependencies_of_dry(dry_distro, result.dry_stack_names, excludes=excludes)
logger.debug('Dry stacks including dependencies: %s' % ', '.join(sorted(dry_dependencies)))
result.dry_stack_names |= dry_dependencies
if not dry_only:
# add wet dependencies of dry stuff
logger.debug('Wet dependencies of dry stacks: %s' % ', '.join(sorted(wet_dependencies)))
for depend in wet_dependencies:
if depend in exclude_names.wet_package_names or depend in deps_up_to_names.wet_package_names:
continue
wet_distro = get_wet_distro(distro_name)
assert depend in wet_distro.release_packages, "Package '%s' does not have a version" % depend
result.wet_package_names.add(depend)
# add wet dependencies
if result.wet_package_names:
wet_distro = get_wet_distro(distro_name)
_, unreleased_package_names = get_package_names(wet_distro)
excludes = exclude_names.wet_package_names | deps_up_to_names.wet_package_names | set(unreleased_package_names)
result.wet_package_names |= get_recursive_dependencies_of_wet(wet_distro, result.wet_package_names, excludes=excludes,
limit_depth=deps_depth, source=upstream_source_version)
logger.debug('Wet packages including dependencies: %s' % ', '.join(sorted(result.wet_package_names)))
# intersect result with recursive dependencies on
if deps_up_to:
# intersect with wet dependencies on
if deps_up_to_names.wet_package_names:
wet_distro = get_wet_distro(distro_name)
# wet depends on do not include the names since they are excluded to stop recursion asap
wet_package_names = get_recursive_dependencies_on_of_wet(wet_distro, deps_up_to_names.wet_package_names, excludes=names.wet_package_names,
limit=result.wet_package_names, source=upstream_source_version)
# keep all names which are already in the result set
wet_package_names |= result.wet_package_names & names.wet_package_names
result.wet_package_names = wet_package_names
else:
result.wet_package_names.clear()
logger.debug('Wet packages after intersection: %s' % ', '.join(sorted(result.wet_package_names)))
# intersect with dry dependencies on
dry_dependency_names = result.wet_package_names | deps_up_to_names.dry_stack_names
if dry_dependency_names and not wet_only:
dry_distro = get_dry_distro(distro_name)
# dry depends on do not include the names since they are excluded to stop recursion asap
dry_stack_names = get_recursive_dependencies_on_of_dry(dry_distro, dry_dependency_names, excludes=names.dry_stack_names, limit=result.dry_stack_names)
# keep all names which are already in the result set
dry_stack_names |= result.dry_stack_names & names.dry_stack_names
result.dry_stack_names = dry_stack_names
else:
result.dry_stack_names.clear()
logger.debug('Dry stacks after intersection: %s' % ', '.join(sorted(result.dry_stack_names)))
# exclude passed in names
if deps_only:
result.wet_package_names -= set(names.wet_package_names)
result.dry_stack_names -= set(names.dry_stack_names)
# exclude wet packages based on build type
if catkin_only or non_catkin_only:
wet_distro = get_wet_distro(distro_name)
for pkg_name in list(result.wet_package_names):
pkg_xml = wet_distro.get_release_package_xml(pkg_name)
try:
pkg = parse_package_string(pkg_xml)
except InvalidPackage as e:
logger.warn("The package '%s' has an invalid manifest and will be ignored: %s" % (pkg_name, e))
result.wet_package_names.remove(pkg_name)
continue
build_type = ([e.content for e in pkg.exports if e.tagname == 'build_type'][0]) if 'build_type' in [e.tagname for e in pkg.exports] else 'catkin'
if catkin_only ^ (build_type == 'catkin'):
result.wet_package_names.remove(pkg_name)
# get wet and/or dry rosinstall data
rosinstall_data = []
if not dry_only and (result.wet_package_names or has_repos):
wet_distro = get_wet_distro(distro_name)
if upstream_version_tag or upstream_source_version:
# determine repositories based on package names and passed in repository names
repos = {}
for pkg_name in result.wet_package_names:
if upstream_source_version and wet_distro.source_packages:
pkg = wet_distro.source_packages[pkg_name]
repos[pkg.repository_name] = wet_distro.repositories[pkg.repository_name]
else:
pkg = wet_distro.release_packages[pkg_name]
if pkg.repository_name not in repos:
repo = wet_distro.repositories[pkg.repository_name]
release_repo = repo.release_repository
assert not upstream_version_tag or release_repo.version is not None, "Package '%s' in repository '%s' does not have a release version" % (pkg_name, pkg.repository_name)
repos[pkg.repository_name] = repo
# If asked to get upstream development then the release state doesn't matter
if upstream_source_version:
repo_names = repo_names.union(unreleased_repo_names)
for repo_name in repo_names:
if repo_name not in repos:
repos[repo_name] = wet_distro.repositories[repo_name]
# ignore repos which lack information
repos_without_source = [repo_name for repo_name, repo in repos.items() if not repo.source_repository]
if repos_without_source:
logger.warn('The following repositories with an unknown upstream will be ignored: %s' % ', '.join(sorted(repos_without_source)))
[repos.pop(repo_name) for repo_name in repos_without_source]
if upstream_version_tag:
repos_without_release = [repo_name for repo_name, repo in repos.items() if not repo.release_repository or not repo.release_repository.version]
if repos_without_release:
logger.warn('The following repositories without a release will be ignored: %s' % ', '.join(sorted(repos_without_release)))
[repos.pop(repo_name) for repo_name in repos_without_release]
logger.debug('Generate rosinstall entries for wet repositories: %s' % ', '.join(sorted(repos.keys())))
wet_rosinstall_data = generate_rosinstall_for_repos(repos, version_tag=upstream_version_tag, tar=tar)
rosinstall_data += wet_rosinstall_data
else:
logger.debug('Generate rosinstall entries for wet packages: %s' % ', '.join(sorted(result.wet_package_names)))
wet_rosinstall_data = generate_wet_rosinstall(wet_distro, result.wet_package_names, flat=flat, tar=tar)
rosinstall_data += wet_rosinstall_data
if not wet_only and result.dry_stack_names:
logger.debug('Generate rosinstall entries for dry stacks: %s' % ', '.join(sorted(result.dry_stack_names)))
dry_distro = get_dry_distro(distro_name)
dry_rosinstall_data = generate_dry_rosinstall(dry_distro, result.dry_stack_names)
rosinstall_data += dry_rosinstall_data
return rosinstall_data
def generate_rosinstall(distro_name, names,
deps=False, deps_up_to=None, deps_depth=None, deps_only=False,
wet_only=False, dry_only=False, catkin_only=False, non_catkin_only=False,
excludes=None,
flat=False,
tar=False):
# classify package/stack names
names, keywords = _split_special_keywords(names)
names, unknown_names = _classify_names(distro_name, names)
if unknown_names:
logger.warn('The following not released packages/stacks will be ignored: %s' % (', '.join(sorted(unknown_names))))
if keywords:
expanded_names, unknown_names = _classify_names(distro_name, _expand_keywords(distro_name, keywords))
if unknown_names:
logger.warn('The following not released packages/stacks from the %s will be ignored: %s' % (ROS_PACKAGE_PATH, ', '.join(sorted(unknown_names))))
names.update(expanded_names)
if not names.wet_package_names and not names.dry_stack_names:
raise RuntimeError('No packages/stacks left after ignoring not released')
logger.debug('Packages/stacks: %s' % ', '.join(sorted(names.wet_package_names | names.dry_stack_names)))
# classify deps-up-to
deps_up_to_names, keywords = _split_special_keywords(deps_up_to or [])
deps_up_to_names, unknown_names = _classify_names(distro_name, deps_up_to_names)
if unknown_names:
logger.warn("The following not released '--deps-up-to' packages/stacks will be ignored: %s" % (', '.join(sorted(unknown_names))))
if keywords:
expanded_names, unknown_names = _classify_names(distro_name, _expand_keywords(distro_name, keywords))
if unknown_names:
logger.warn("The following not released '--deps-up-to' packages/stacks from the %s will be ignored: %s" % (ROS_PACKAGE_PATH, ', '.join(sorted(unknown_names))))
deps_up_to_names.update(expanded_names)
if deps_up_to:
logger.debug('Dependencies up to: %s' % ', '.join(sorted(deps_up_to_names.wet_package_names | deps_up_to_names.dry_stack_names)))
# classify excludes
exclude_names, keywords = _split_special_keywords(excludes or [])
exclude_names, unknown_names = _classify_names(distro_name, exclude_names)
if unknown_names:
logger.warn("The following not released '--exclude' packages/stacks will be ignored: %s" % (', '.join(sorted(unknown_names))))
if keywords:
expanded_names, unknown_names = _classify_names(distro_name, _expand_keywords(distro_name, keywords))
exclude_names.update(expanded_names)
if excludes:
logger.debug('Excluded packages/stacks: %s' % ', '.join(sorted(exclude_names.wet_package_names | exclude_names.dry_stack_names)))
result = copy.deepcopy(names)
# clear wet packages if not requested
if dry_only:
result.wet_package_names.clear()
# clear dry packages if not requested and no dependencies
if wet_only and not deps and not deps_up_to:
result.dry_stack_names.clear()
# remove excluded names from the list of wet and dry names
result.wet_package_names -= exclude_names.wet_package_names
result.dry_stack_names -= exclude_names.dry_stack_names
if not result.wet_package_names and not result.dry_stack_names:
raise RuntimeError('No packages/stacks left after applying the exclusions')
if result.wet_package_names:
logger.debug('Wet packages: %s' % ', '.join(sorted(result.wet_package_names)))
if result.dry_stack_names:
logger.debug('Dry stacks: %s' % ', '.join(sorted(result.dry_stack_names)))
# extend the names with recursive dependencies
if deps or deps_up_to:
# add dry dependencies
if result.dry_stack_names:
dry_distro = get_dry_distro(distro_name)
_, unreleased_stack_names = get_stack_names(dry_distro)
excludes = exclude_names.dry_stack_names | deps_up_to_names.dry_stack_names | set(unreleased_stack_names)
dry_dependencies, wet_dependencies = get_recursive_dependencies_of_dry(dry_distro, result.dry_stack_names, excludes=excludes)
logger.debug('Dry stacks including dependencies: %s' % ', '.join(sorted(dry_dependencies)))
result.dry_stack_names |= dry_dependencies
if not dry_only:
# add wet dependencies of dry stuff
logger.debug('Wet dependencies of dry stacks: %s' % ', '.join(sorted(wet_dependencies)))
for depend in wet_dependencies:
if depend in exclude_names.wet_package_names or depend in deps_up_to_names.wet_package_names:
continue
wet_distro = get_wet_distro(distro_name)
assert depend in wet_distro.release_packages, "Package '%s' does not have a version" % depend
result.wet_package_names.add(depend)
# add wet dependencies
if result.wet_package_names:
wet_distro = get_wet_distro(distro_name)
_, unreleased_package_names = get_package_names(wet_distro)
excludes = exclude_names.wet_package_names | deps_up_to_names.wet_package_names | set(unreleased_package_names)
result.wet_package_names |= get_recursive_dependencies_of_wet(wet_distro, result.wet_package_names, excludes=excludes, limit_depth=deps_depth)
logger.debug('Wet packages including dependencies: %s' % ', '.join(sorted(result.wet_package_names)))
# intersect result with recursive dependencies on
if deps_up_to:
# intersect with wet dependencies on
if deps_up_to_names.wet_package_names:
wet_distro = get_wet_distro(distro_name)
# wet depends on do not include the names since they are excluded to stop recursion asap
wet_package_names = get_recursive_dependencies_on_of_wet(wet_distro, deps_up_to_names.wet_package_names, excludes=names.wet_package_names, limit=result.wet_package_names)
# keep all names which are already in the result set
wet_package_names |= result.wet_package_names & names.wet_package_names
result.wet_package_names = wet_package_names
else:
result.wet_package_names.clear()
logger.debug('Wet packages after intersection: %s' % ', '.join(sorted(result.wet_package_names)))
# intersect with dry dependencies on
dry_dependency_names = result.wet_package_names | deps_up_to_names.dry_stack_names
if dry_dependency_names and not wet_only:
dry_distro = get_dry_distro(distro_name)
# dry depends on do not include the names since they are excluded to stop recursion asap
dry_stack_names = get_recursive_dependencies_on_of_dry(dry_distro, dry_dependency_names, excludes=names.dry_stack_names, limit=result.dry_stack_names)
# keep all names which are already in the result set
dry_stack_names |= result.dry_stack_names & names.dry_stack_names
result.dry_stack_names = dry_stack_names
else:
result.dry_stack_names.clear()
logger.debug('Dry stacks after intersection: %s' % ', '.join(sorted(result.dry_stack_names)))
# exclude passed in names
if deps_only:
result.wet_package_names -= set(names.wet_package_names)
result.dry_stack_names -= set(names.dry_stack_names)
# exclude wet packages based on build type
if catkin_only or non_catkin_only:
wet_distro = get_wet_distro(distro_name)
for pkg_name in list(result.wet_package_names):
pkg_xml = wet_distro.get_release_package_xml(pkg_name)
try:
pkg = parse_package_string(pkg_xml)
except InvalidPackage as e:
logger.warn("The package '%s' has an invalid manifest and will be ignored: %s" % (pkg_name, e))
result.wet_package_names.remove(pkg_name)
continue
build_type = ([e.content for e in pkg.exports if e.tagname == 'build_type'][0]) if 'build_type' in [e.tagname for e in pkg.exports] else 'catkin'
if catkin_only ^ (build_type == 'catkin'):
result.wet_package_names.remove(pkg_name)
# get wet and/or dry rosinstall data
rosinstall_data = []
if not dry_only and result.wet_package_names:
logger.debug('Generate rosinstall entries for wet packages: %s' % ', '.join(sorted(result.wet_package_names)))
wet_distro = get_wet_distro(distro_name)
wet_rosinstall_data = generate_wet_rosinstall(wet_distro, result.wet_package_names, flat=flat, tar=tar)
rosinstall_data += wet_rosinstall_data
if not wet_only and result.dry_stack_names:
logger.debug('Generate rosinstall entries for dry stacks: %s' % ', '.join(sorted(result.dry_stack_names)))
dry_distro = get_dry_distro(distro_name)
dry_rosinstall_data = generate_dry_rosinstall(dry_distro, result.dry_stack_names)
rosinstall_data += dry_rosinstall_data
return rosinstall_data
def generate_rosinstall(distro_name, names,
from_paths=None, repo_names=None,
deps=False, deps_up_to=None, deps_depth=None, deps_only=False,
wet_only=False, dry_only=False, catkin_only=False, non_catkin_only=False,
excludes=None, exclude_paths=None,
flat=False,
tar=False,
upstream_version_tag=False, upstream_source_version=False):
# classify package/stack names
names, keywords = _split_special_keywords(names)
# find packages recursively in include paths
if from_paths:
include_names_from_path = set([])
[include_names_from_path.update(_get_package_names(from_path)) for from_path in from_paths]
logger.debug("The following wet packages found in '--from-path' will be considered: %s" % ', '.join(sorted(include_names_from_path)))
names.update(include_names_from_path)
# expand repository names into package names
repo_names, unknown_repo_names = _classify_repo_names(distro_name, repo_names)
if unknown_repo_names:
logger.warn('The following unknown repositories will be ignored: %s' % (', '.join(sorted(unknown_repo_names))))
wet_package_names, unreleased_repo_names = _get_packages_for_repos(distro_name, repo_names)
names.update(wet_package_names)
if unreleased_repo_names and not upstream_version_tag and not upstream_source_version:
logger.warn('The following unreleased repositories will be ignored: %s' % ', '.join(sorted(unreleased_repo_names)))
if unreleased_repo_names and (deps or deps_up_to) and (upstream_version_tag or upstream_source_version):
logger.warn('The dependencies of the following unreleased repositories are unknown and will be ignored: %s' % ', '.join(sorted(unreleased_repo_names)))
has_repos = ((repo_names - unreleased_repo_names) and (upstream_version_tag or upstream_source_version)) or (unreleased_repo_names and upstream_source_version)
names, unknown_names = _classify_names(distro_name, names)
if unknown_names:
logger.warn('The following not released packages/stacks will be ignored: %s' % (', '.join(sorted(unknown_names))))
if keywords:
expanded_names, unknown_names = _classify_names(distro_name, _expand_keywords(distro_name, keywords))
if unknown_names:
logger.warn('The following not released packages/stacks from the %s will be ignored: %s' % (ROS_PACKAGE_PATH, ', '.join(sorted(unknown_names))))
names.update(expanded_names)
if not names.wet_package_names and not names.dry_stack_names and not has_repos:
raise RuntimeError('No packages/stacks left after ignoring not released')
if names.wet_package_names or names.dry_stack_names:
logger.debug('Packages/stacks: %s' % ', '.join(sorted(names.wet_package_names | names.dry_stack_names)))
if unreleased_repo_names:
logger.debug('Unreleased repositories: %s' % ', '.join(sorted(unreleased_repo_names)))
# classify deps-up-to
deps_up_to_names, keywords = _split_special_keywords(deps_up_to or [])
deps_up_to_names, unknown_names = _classify_names(distro_name, deps_up_to_names)
if unknown_names:
logger.warn("The following not released '--deps-up-to' packages/stacks will be ignored: %s" % (', '.join(sorted(unknown_names))))
if keywords:
expanded_names, unknown_names = _classify_names(distro_name, _expand_keywords(distro_name, keywords))
if unknown_names:
logger.warn("The following not released '--deps-up-to' packages/stacks from the %s will be ignored: %s" % (ROS_PACKAGE_PATH, ', '.join(sorted(unknown_names))))
deps_up_to_names.update(expanded_names)
if deps_up_to:
logger.debug('Dependencies up to: %s' % ', '.join(sorted(deps_up_to_names.wet_package_names | deps_up_to_names.dry_stack_names)))
# classify excludes
exclude_names, keywords = _split_special_keywords(excludes or [])
if exclude_paths:
exclude_names_from_path = set([])
[exclude_names_from_path.update(_get_package_names(exclude_path)) for exclude_path in exclude_paths]
logger.debug("The following wet packages found in '--exclude-path' will be excluded: %s" % ', '.join(sorted(exclude_names_from_path)))
exclude_names.update(exclude_names_from_path)
exclude_names, unknown_names = _classify_names(distro_name, exclude_names)
if unknown_names:
logger.warn("The following not released '--exclude' packages/stacks will be ignored: %s" % (', '.join(sorted(unknown_names))))
if keywords:
expanded_names, unknown_names = _classify_names(distro_name, _expand_keywords(distro_name, keywords))
exclude_names.update(expanded_names)
if excludes:
logger.debug('Excluded packages/stacks: %s' % ', '.join(sorted(exclude_names.wet_package_names | exclude_names.dry_stack_names)))
result = copy.deepcopy(names)
# clear wet packages if not requested
if dry_only:
result.wet_package_names.clear()
# clear dry packages if not requested and no dependencies
if wet_only and not deps and not deps_up_to:
result.dry_stack_names.clear()
# remove excluded names from the list of wet and dry names
result.wet_package_names -= exclude_names.wet_package_names
result.dry_stack_names -= exclude_names.dry_stack_names
if not result.wet_package_names and not result.dry_stack_names and not has_repos:
raise RuntimeError('No packages/stacks left after applying the exclusions')
if result.wet_package_names:
logger.debug('Wet packages: %s' % ', '.join(sorted(result.wet_package_names)))
if result.dry_stack_names:
logger.debug('Dry stacks: %s' % ', '.join(sorted(result.dry_stack_names)))
# extend the names with recursive dependencies
if deps or deps_up_to:
# add dry dependencies
if result.dry_stack_names:
dry_distro = get_dry_distro(distro_name)
_, unreleased_stack_names = get_stack_names(dry_distro)
excludes = exclude_names.dry_stack_names | deps_up_to_names.dry_stack_names | set(unreleased_stack_names)
dry_dependencies, wet_dependencies = get_recursive_dependencies_of_dry(dry_distro, result.dry_stack_names, excludes=excludes)
logger.debug('Dry stacks including dependencies: %s' % ', '.join(sorted(dry_dependencies)))
result.dry_stack_names |= dry_dependencies
if not dry_only:
# add wet dependencies of dry stuff
logger.debug('Wet dependencies of dry stacks: %s' % ', '.join(sorted(wet_dependencies)))
for depend in wet_dependencies:
if depend in exclude_names.wet_package_names or depend in deps_up_to_names.wet_package_names:
continue
wet_distro = get_wet_distro(distro_name)
assert depend in wet_distro.release_packages, "Package '%s' does not have a version" % depend
result.wet_package_names.add(depend)
# add wet dependencies
if result.wet_package_names:
wet_distro = get_wet_distro(distro_name)
_, unreleased_package_names = get_package_names(wet_distro)
excludes = exclude_names.wet_package_names | deps_up_to_names.wet_package_names | set(unreleased_package_names)
result.wet_package_names |= get_recursive_dependencies_of_wet(wet_distro, result.wet_package_names, excludes=excludes, limit_depth=deps_depth)
logger.debug('Wet packages including dependencies: %s' % ', '.join(sorted(result.wet_package_names)))
# intersect result with recursive dependencies on
if deps_up_to:
# intersect with wet dependencies on
if deps_up_to_names.wet_package_names:
wet_distro = get_wet_distro(distro_name)
# wet depends on do not include the names since they are excluded to stop recursion asap
wet_package_names = get_recursive_dependencies_on_of_wet(wet_distro, deps_up_to_names.wet_package_names, excludes=names.wet_package_names, limit=result.wet_package_names)
# keep all names which are already in the result set
wet_package_names |= result.wet_package_names & names.wet_package_names
result.wet_package_names = wet_package_names
else:
result.wet_package_names.clear()
logger.debug('Wet packages after intersection: %s' % ', '.join(sorted(result.wet_package_names)))
# intersect with dry dependencies on
dry_dependency_names = result.wet_package_names | deps_up_to_names.dry_stack_names
if dry_dependency_names and not wet_only:
dry_distro = get_dry_distro(distro_name)
# dry depends on do not include the names since they are excluded to stop recursion asap
dry_stack_names = get_recursive_dependencies_on_of_dry(dry_distro, dry_dependency_names, excludes=names.dry_stack_names, limit=result.dry_stack_names)
# keep all names which are already in the result set
dry_stack_names |= result.dry_stack_names & names.dry_stack_names
result.dry_stack_names = dry_stack_names
else:
result.dry_stack_names.clear()
logger.debug('Dry stacks after intersection: %s' % ', '.join(sorted(result.dry_stack_names)))
# exclude passed in names
if deps_only:
result.wet_package_names -= set(names.wet_package_names)
result.dry_stack_names -= set(names.dry_stack_names)
# exclude wet packages based on build type
if catkin_only or non_catkin_only:
wet_distro = get_wet_distro(distro_name)
for pkg_name in list(result.wet_package_names):
pkg_xml = wet_distro.get_release_package_xml(pkg_name)
try:
pkg = parse_package_string(pkg_xml)
except InvalidPackage as e:
logger.warn("The package '%s' has an invalid manifest and will be ignored: %s" % (pkg_name, e))
result.wet_package_names.remove(pkg_name)
continue
build_type = ([e.content for e in pkg.exports if e.tagname == 'build_type'][0]) if 'build_type' in [e.tagname for e in pkg.exports] else 'catkin'
if catkin_only ^ (build_type == 'catkin'):
result.wet_package_names.remove(pkg_name)
# get wet and/or dry rosinstall data
rosinstall_data = []
if not dry_only and (result.wet_package_names or has_repos):
wet_distro = get_wet_distro(distro_name)
if upstream_version_tag or upstream_source_version:
# determine repositories based on package names and passed in repository names
repos = {}
for pkg_name in result.wet_package_names:
pkg = wet_distro.release_packages[pkg_name]
if pkg.repository_name not in repos:
repo = wet_distro.repositories[pkg.repository_name]
release_repo = repo.release_repository
assert not upstream_version_tag or release_repo.version is not None, "Package '%s' in repository '%s' does not have a release version" % (pkg_name, pkg.repository_name)
repos[pkg.repository_name] = repo
for repo_name in repo_names:
if repo_name not in repos:
repos[repo_name] = wet_distro.repositories[repo_name]
# ignore repos which lack information
repos_without_source = [repo_name for repo_name, repo in repos.items() if not repo.source_repository]
if repos_without_source:
logger.warn('The following repositories with an unknown upstream will be ignored: %s' % ', '.join(sorted(repos_without_source)))
[repos.pop(repo_name) for repo_name in repos_without_source]
if upstream_version_tag:
repos_without_release = [repo_name for repo_name, repo in repos.items() if not repo.release_repository or not repo.release_repository.version]
if repos_without_release:
logger.warn('The following repositories without a release will be ignored: %s' % ', '.join(sorted(repos_without_release)))
[repos.pop(repo_name) for repo_name in repos_without_release]
logger.debug('Generate rosinstall entries for wet repositories: %s' % ', '.join(sorted(repos.keys())))
wet_rosinstall_data = generate_rosinstall_for_repos(repos, version_tag=upstream_version_tag, tar=tar)
rosinstall_data += wet_rosinstall_data
else:
logger.debug('Generate rosinstall entries for wet packages: %s' % ', '.join(sorted(result.wet_package_names)))
wet_rosinstall_data = generate_wet_rosinstall(wet_distro, result.wet_package_names, flat=flat, tar=tar)
rosinstall_data += wet_rosinstall_data
if not wet_only and result.dry_stack_names:
logger.debug('Generate rosinstall entries for dry stacks: %s' % ', '.join(sorted(result.dry_stack_names)))
dry_distro = get_dry_distro(distro_name)
dry_rosinstall_data = generate_dry_rosinstall(dry_distro, result.dry_stack_names)
rosinstall_data += dry_rosinstall_data
return rosinstall_data
