def test_create_default_installer_context():
import rosdep2
# test both constructors
for context in [rosdep2.create_default_installer_context(), rosdep2.create_default_installer_context(verbose=True)]:
assert context is not None
assert isinstance(context, rosdep2.InstallerContext)
# this is just tripwire as we actual value will change over time
from rospkg.os_detect import OS_UBUNTU, OsDetect
assert OS_UBUNTU in context.get_os_keys()
assert context.get_installer('apt') is not None
assert 'apt' in context.get_os_installer_keys(OS_UBUNTU)
assert OsDetect.get_codename == context.get_os_version_type(OS_UBUNTU)
def test_RosdepLookup_resolve_all():
from rosdep2 import create_default_installer_context
from rosdep2.lookup import RosdepLookup
rospack, rosstack = get_test_rospkgs()
sources_loader = create_test_SourcesListLoader()
lookup = RosdepLookup.create_from_rospkg(rospack=rospack,
rosstack=rosstack,
sources_loader=sources_loader)
installer_context = create_default_installer_context()
installer_context.set_os_override('ubuntu', 'lucid')
# repeat for caching
lookup.verbose = True
for count in range(0, 2):
resolutions, errors = lookup.resolve_all(
['rospack_fake', 'roscpp_fake'], installer_context)
assert not errors, errors
installer_keys, resolveds = zip(*resolutions)
assert 'apt' in installer_keys
apt_resolutions = []
for k, v in resolutions:
if k == 'apt':
apt_resolutions.extend(v)
assert set(apt_resolutions) == set([
'libtinyxml-dev', 'libboost1.40-all-dev', 'libtool', 'libltdl-dev'
]), set(apt_resolutions)
def resolve_rosdeps(rosdep_keys, platform, rospack, rosstack):
"""
Resolve rosdep keys on an 'ubuntu' OS, for the specified ubuntu
platform release version.
NOTE: one flaw in this implementation is that it uses the rosdep
view from the *active environment* to generate the rosdeps. It
does not generate them from specific versions of stacks. The hope
is that rosdeps improve monotonically over time, so that this will
not be a major issue.
:param platform: platform name (e.g. lucid)
:returns: list of system package deps, ``str``
:raises :exc:`KeyError` if no key for rosdep exists
:raises :exc:`rosdep2.ResolutionError` if rosdeps for stack cannot be resolved on the specified platform
:raises :exc:`rospkg.ResourceNotFound` if stack cannot be found
:raises :exc:`rosdep2.UnsupportedOs`
"""
lookup = create_rosdep_lookup(rospack, rosstack)
# get the apt installer
context = rosdep2.create_default_installer_context()
installer = context.get_installer(INSTALLER_KEY)
# resolve the keys
resolved = []
for rosdep_name in rosdep_keys:
view = lookup.get_rosdep_view(DEFAULT_VIEW_KEY)
d = view.lookup(rosdep_name)
_, rule = d.get_rule_for_platform(OS_NAME, platform, [INSTALLER_KEY], INSTALLER_KEY)
resolved.extend(installer.resolve(rule))
return list(set(resolved))
def resolve_rosdep_key(
key,
os_name,
os_version,
ros_distro=None,
ignored=None
):
ignored = ignored or []
ctx = create_default_installer_context()
try:
installer_key = ctx.get_default_os_installer_key(os_name)
except KeyError:
raise UnresolvedDependency(
"could not resolve package {} for os {}."
.format(key, os_name)
)
installer = ctx.get_installer(installer_key)
ros_distro = ros_distro or DEFAULT_ROS_DISTRO
view = get_view(os_name, os_version, ros_distro)
try:
return resolve_more_for_os(key, view, installer, os_name, os_version)
except (KeyError, ResolutionError):
raise UnresolvedDependency(
"could not resolve package {} for os {}."
.format(key, os_name)
)
def resolve_rosdep_key(key, os_name, os_version, ros_distro=None, ignored=None, retry=True):
ignored = ignored or []
ctx = create_default_installer_context()
try:
installer_key = ctx.get_default_os_installer_key(os_name)
except KeyError:
BloomGenerator.exit("Could not determine the installer for '{0}'".format(os_name))
installer = ctx.get_installer(installer_key)
ros_distro = ros_distro or DEFAULT_ROS_DISTRO
view = get_view(os_name, os_version, ros_distro)
try:
return resolve_more_for_os(key, view, installer, os_name, os_version)
except (KeyError, ResolutionError) as exc:
debug(traceback.format_exc())
if key in ignored:
return None, None, None
if isinstance(exc, KeyError):
error("Could not resolve rosdep key '{0}'".format(key))
returncode = code.GENERATOR_NO_SUCH_ROSDEP_KEY
else:
error("Could not resolve rosdep key '{0}' for distro '{1}':".format(key, os_version))
info(str(exc), use_prefix=False)
returncode = code.GENERATOR_NO_ROSDEP_KEY_FOR_DISTRO
if retry:
error("Try to resolve the problem with rosdep and then continue.")
if maybe_continue():
update_rosdep()
invalidate_view_cache()
return resolve_rosdep_key(key, os_name, os_version, ros_distro, ignored, retry=True)
BloomGenerator.exit("Failed to resolve rosdep key '{0}', aborting.".format(key), returncode=returncode)
def resolve_rosdeps(rosdep_keys, platform, rospack, rosstack):
"""
Resolve rosdep keys on an 'ubuntu' OS, for the specified ubuntu
platform release version.
NOTE: one flaw in this implementation is that it uses the rosdep
view from the *active environment* to generate the rosdeps. It
does not generate them from specific versions of stacks. The hope
is that rosdeps improve monotonically over time, so that this will
not be a major issue.
:param platform: platform name (e.g. lucid)
:returns: list of system package deps, ``str``
:raises :exc:`KeyError` if no key for rosdep exists
:raises :exc:`rosdep2.ResolutionError` if rosdeps for stack cannot be resolved on the specified platform
:raises :exc:`rospkg.ResourceNotFound` if stack cannot be found
:raises :exc:`rosdep2.UnsupportedOs`
"""
lookup = create_rosdep_lookup(rospack, rosstack)
# get the apt installer
context = rosdep2.create_default_installer_context()
installer = context.get_installer(INSTALLER_KEY)
# resolve the keys
resolved = []
for rosdep_name in rosdep_keys:
view = lookup.get_rosdep_view(DEFAULT_VIEW_KEY)
d = view.lookup(rosdep_name)
_, rule = d.get_rule_for_platform(OS_NAME, platform, [INSTALLER_KEY],
INSTALLER_KEY)
resolved.extend(installer.resolve(rule))
return list(set(resolved))
def __init__(self,
indexer,
ros_distro=None,
os_name=None,
os_codename=None):
self.indexer = indexer
if not os_name:
os_detector = rospkg.os_detect.OsDetect()
self.os_name = os_detector.get_name()
self.os_codename = os_detector.get_codename()
# FIXME: there should be a way to set this without using an environment variable
if ros_distro:
os.environ['ROS_DISTRO'] = ros_distro
self.sources_loader = SourcesListLoader.create_default(verbose=False)
self.lookup = RosdepLookup.create_from_rospkg(
sources_loader=self.sources_loader)
self.installer_context = create_default_installer_context(
verbose=False)
self.installer_keys = self.installer_context.get_os_installer_keys(
self.os_name)
self.default_key = self.installer_context.get_default_os_installer_key(
self.os_name)
self.installer = self.installer_context.get_installer(self.default_key)
self.view = self.lookup.get_rosdep_view(DEFAULT_VIEW_KEY,
verbose=False)
def resolve_rosdep_key(key, quiet=False):
sources_loader = SourcesListLoader.create_default(
sources_cache_dir=get_sources_cache_dir(),
os_override=None,
verbose=False)
lookup = RosdepLookup.create_from_rospkg(sources_loader=sources_loader)
lookup.verbose = False
installer_context = create_default_installer_context(verbose=False)
installer, installer_keys, default_key, \
os_name, os_version = get_default_installer(
installer_context=installer_context,
verbose=False)
view = lookup.get_rosdep_view(DEFAULT_VIEW_KEY, verbose=False)
try:
d = view.lookup(key)
except KeyError as e:
sys.stderr.write('Invalid key "{}": {}\n'.format(key, e))
return
rule_installer, rule = d.get_rule_for_platform(os_name, os_version,
installer_keys, default_key)
installer = installer_context.get_installer(rule_installer)
resolved = installer.resolve(rule)
for error in lookup.get_errors():
if not quiet:
print('WARNING: %s' % (error), file=sys.stderr)
return {installer: resolved}
def test_RosdepLookup_resolve():
from rosdep2 import create_default_installer_context
from rosdep2.lookup import RosdepLookup
rospack, rosstack = get_test_rospkgs()
sources_loader = create_test_SourcesListLoader()
lookup = RosdepLookup.create_from_rospkg(rospack=rospack, rosstack=rosstack,
sources_loader=sources_loader)
installer_context = create_default_installer_context()
installer_context.set_os_override('ubuntu', 'lucid')
# repeat for caching
for count in xrange(0, 2):
installer_key, resolution, dependencies = lookup.resolve('testtinyxml', 'rospack_fake', installer_context)
assert 'apt' == installer_key
assert ['libtinyxml-dev'] == resolution
assert [] == dependencies
installer_key, resolution, dependencies = lookup.resolve('testboost', 'roscpp_fake', installer_context)
assert 'apt' == installer_key
assert ['libboost1.40-all-dev'] == resolution
assert [] == dependencies
installer_key, resolution, dependencies = lookup.resolve('testlibtool', 'roscpp_fake', installer_context)
assert 'apt' == installer_key
assert set(['libtool', 'libltdl-dev']) == set(resolution)
assert [] == dependencies
def test_RosdepInstaller_install_resolved():
from rosdep2 import create_default_installer_context
from rosdep2.lookup import RosdepLookup
from rosdep2.installers import RosdepInstaller
from rosdep2.platforms.debian import APT_INSTALLER
from rosdep2.lookup import RosdepLookup
rospack, rosstack = get_test_rospkgs()
# create our test fixture. use most of the default toolchain, but
# replace the apt installer with one that we can have more fun
# with. we will do all tests with ubuntu lucid keys -- other
# tests should cover different resolution cases.
sources_loader = create_test_SourcesListLoader()
lookup = RosdepLookup.create_from_rospkg(rospack=rospack, rosstack=rosstack, sources_loader=sources_loader)
context = create_default_installer_context()
context.set_os_override('ubuntu', 'lucid')
installer = RosdepInstaller(context, lookup)
with fakeout() as (stdout, stderr):
installer.install_resolved(APT_INSTALLER, [], simulate=True, verbose=False)
with fakeout() as (stdout, stderr):
installer.install_resolved(APT_INSTALLER, [], simulate=True, verbose=True)
assert stdout.getvalue().strip() == '#No packages to install'
with fakeout() as (stdout, stderr):
installer.install_resolved(APT_INSTALLER, ['rosdep-fake1', 'rosdep-fake2'], simulate=True, verbose=True)
stdout_lines = [x.strip() for x in stdout.getvalue().split('\n') if x.strip()]
assert stdout_lines == ['#[apt] Installation commands:',
'sudo apt-get install rosdep-fake1',
'sudo apt-get install rosdep-fake2',
], ("%s: %s"%(stdout.getvalue(), stdout_lines))
def test_RosdepLookup_resolve():
from rosdep2 import create_default_installer_context
from rosdep2.lookup import RosdepLookup
rospack, rosstack = get_test_rospkgs()
sources_loader = create_test_SourcesListLoader()
lookup = RosdepLookup.create_from_rospkg(rospack=rospack,
rosstack=rosstack,
sources_loader=sources_loader)
installer_context = create_default_installer_context()
installer_context.set_os_override('ubuntu', 'lucid')
# repeat for caching
for count in range(0, 2):
installer_key, resolution, dependencies = lookup.resolve(
'testtinyxml', 'rospack_fake', installer_context)
assert 'apt' == installer_key
assert ['libtinyxml-dev'] == resolution
assert [] == dependencies
installer_key, resolution, dependencies = lookup.resolve(
'testboost', 'roscpp_fake', installer_context)
assert 'apt' == installer_key
assert ['libboost1.40-all-dev'] == resolution
assert [] == dependencies
installer_key, resolution, dependencies = lookup.resolve(
'testlibtool', 'roscpp_fake', installer_context)
assert 'apt' == installer_key
assert set(['libtool', 'libltdl-dev']) == set(resolution)
assert [] == dependencies
def test_RosdepInstaller_get_uninstalled_unconfigured():
from rosdep2 import create_default_installer_context, RosdepInternalError
from rosdep2.lookup import RosdepLookup, ResolutionError
from rosdep2.installers import RosdepInstaller, PackageManagerInstaller
from rosdep2.platforms.debian import APT_INSTALLER
from rosdep2.lookup import RosdepLookup
rospack, rosstack = get_test_rospkgs()
sources_loader = create_test_SourcesListLoader()
# create our test fixture. we want to setup a fixture that cannot resolve the rosdep data in order to test error conditions
lookup = RosdepLookup.create_from_rospkg(rospack=rospack, rosstack=rosstack, sources_loader=sources_loader)
context = create_default_installer_context()
context.set_os_override('ubuntu', 'lucid')
installer = RosdepInstaller(context, lookup)
# - delete the apt installer
context.set_installer(APT_INSTALLER, None)
for verbose in [True, False]:
uninstalled, errors = installer.get_uninstalled(['empty'], verbose)
assert not uninstalled, uninstalled
assert not errors
# make sure there is an error when we lookup something that resolves to an apt depend
uninstalled, errors = installer.get_uninstalled(['roscpp_fake'], verbose)
assert not uninstalled, uninstalled
assert errors.keys() == ['roscpp_fake']
uninstalled, errors = installer.get_uninstalled(['roscpp_fake', 'stack1_p1'], verbose)
assert not uninstalled, uninstalled
assert set(errors.keys()) == set(['roscpp_fake', 'stack1_p1'])
print(errors)
assert isinstance(errors['roscpp_fake'], ResolutionError), errors['roscpp_fake'][0]
# fake/bad installer to test that we re-cast general installer issues
class BadInstaller(PackageManagerInstaller):
def __init__(self):
super(BadInstaller, self).__init__(lambda x: x)
def get_packages_to_install(*args):
raise Exception("deadbeef")
context.set_installer(APT_INSTALLER, BadInstaller())
try:
installer.get_uninstalled(['roscpp_fake'])
assert False, "should have raised"
except RosdepInternalError as e:
assert 'apt' in str(e)
# annoying mock to test generally impossible error condition
from mock import Mock
lookup = Mock(spec=RosdepLookup)
lookup.resolve_all.return_value = ([('bad-key', ['stuff'])], [])
installer = RosdepInstaller(context, lookup)
try:
installer.get_uninstalled(['roscpp_fake'])
assert False, "should have raised"
except RosdepInternalError:
pass
def main(args=None, get_subs_fn=None):
get_subs_fn = get_subs_fn or get_subs
_place_template_files = True
_process_template_files = True
package_path = os.getcwd()
if args is not None:
package_path = args.package_path or os.getcwd()
_place_template_files = args.place_template_files
_process_template_files = args.process_template_files
pkgs_dict = find_packages(package_path)
if len(pkgs_dict) == 0:
sys.exit("No packages found in path: '{0}'".format(package_path))
if len(pkgs_dict) > 1:
sys.exit("Multiple packages found, " "this tool only supports one package at a time.")
os_data = create_default_installer_context().get_os_name_and_version()
os_name, os_version = os_data
ros_distro = os.environ.get("ROS_DISTRO", "indigo")
# Allow args overrides
os_name = args.os_name or os_name
os_version = args.os_version or os_version
ros_distro = args.ros_distro or ros_distro
# Summarize
info(
fmt("@!@{gf}==> @|")
+ fmt(
"Generating debs for @{cf}%s:%s@| for package(s) %s"
% (os_name, os_version, [p.name for p in pkgs_dict.values()])
)
)
for path, pkg in pkgs_dict.items():
template_files = None
try:
subs = get_subs_fn(pkg, os_name, os_version, ros_distro)
if _place_template_files:
# Place template files
place_template_files(path)
if _process_template_files:
# Just process existing template files
template_files = process_template_files(path, subs)
if not _place_template_files and not _process_template_files:
# If neither, do both
place_template_files(path)
template_files = process_template_files(path, subs)
if template_files is not None:
for template_file in template_files:
os.remove(os.path.normpath(template_file))
except Exception as exc:
debug(traceback.format_exc())
error(type(exc).__name__ + ": " + str(exc), exit=True)
except (KeyboardInterrupt, EOFError):
sys.exit(1)
def init_environment():
global os_name, os_version, rdistro, ctx, os_installers, default_os_installer, dist_data, rindex, rcache, rview
ctx = create_default_installer_context()
os_installers = ctx.get_os_installer_keys(os_name)
default_os_installer = ctx.get_default_os_installer_key(os_name)
rindex = get_index(get_index_url())
dist_data = _get_dist_file_data(rindex, rdistro, 'distribution')
rcache = get_distribution(rindex, rdistro)
rview = get_catkin_view(rdistro, os_name, os_version, False)
def test_RosdepInstaller_ctor():
# tripwire/coverage
from rosdep2 import create_default_installer_context
from rosdep2.lookup import RosdepLookup
from rosdep2.installers import RosdepInstaller
lookup = RosdepLookup.create_from_rospkg()
context = create_default_installer_context()
installer = RosdepInstaller(context, lookup)
assert lookup == installer.lookup
assert context == installer.installer_context
def test_RosdepInstaller_ctor():
# tripwire/coverage
from rosdep2 import create_default_installer_context
from rosdep2.lookup import RosdepLookup
from rosdep2.installers import RosdepInstaller
lookup = RosdepLookup.create_from_rospkg()
context = create_default_installer_context()
installer = RosdepInstaller(context, lookup)
assert lookup == installer.lookup
assert context == installer.installer_context
def build_debian_pkg(args=None, get_subs_fn=None):
get_subs_fn = get_subs_fn or get_subs
_place_template_files = True
_process_template_files = True
package_path = os.getcwd()
if args is not None:
package_path = args.package_path or os.getcwd()
_place_template_files = args.place_template_files
_process_template_files = args.process_template_files
pkgs_dict = find_packages(package_path)
if len(pkgs_dict) == 0:
sys.exit("No packages found in path: '{0}'".format(package_path))
# if len(pkgs_dict) > 1:
# sys.exit("Multiple packages found, "
# "this tool only supports one package at a time.")
os_data = create_default_installer_context().get_os_name_and_version()
os_name, os_version = os_data
ros_distro = os.environ.get('ROS_DISTRO', 'indigo')
# Allow args overrides
os_name = args.os_name or os_name
os_version = args.os_version or os_version
ros_distro = args.ros_distro or ros_distro
install_prefix = args.install_prefix or "/opt"
# Summarize
info(fmt("@!@{gf}==> @|") +
fmt("Generating debs for @{cf}%s:%s@| for package(s) %s" %
(os_name, os_version, [p.name for p in pkgs_dict.values()])))
# Test Creating single
all_subs = merge_packages(pkgs_dict, get_subs_fn, os_name, os_version, ros_distro, install_prefix, args.native)
path = ''
build_type = 'cmake'
try:
if _place_template_files:
# Place template files
place_template_files(path, build_type)
if _process_template_files:
# Just process existing template files
template_files = process_template_files(path, all_subs)
if not _place_template_files and not _process_template_files:
# If neither, do both
place_template_files(path, build_type)
template_files = process_template_files(path, all_subs)
if template_files is not None:
for template_file in template_files:
os.remove(os.path.normpath(template_file))
except Exception as exc:
debug(traceback.format_exc())
error(type(exc).__name__ + ": " + str(exc), exit=True)
except (KeyboardInterrupt, EOFError):
sys.exit(1)
def __init__(self): # noqa: D107
installer_context = create_default_installer_context(verbose=False)
self.installer, self.installer_keys, self.default_key, \
self.os_name, self.os_version = get_default_installer(
installer_context=installer_context, verbose=False)
sources_loader = SourcesListLoader.create_default()
lookup = RosdepLookup.create_from_rospkg(sources_loader=sources_loader)
lookup.verbose = True
self.view = lookup.get_rosdep_view(DEFAULT_VIEW_KEY, verbose=False)
def test_RosdepInstaller_get_uninstalled():
from rosdep2 import create_default_installer_context
from rosdep2.lookup import RosdepLookup
from rosdep2.installers import RosdepInstaller
from rosdep2.platforms.debian import APT_INSTALLER
from rosdep2.lookup import RosdepLookup
rospack, rosstack = get_test_rospkgs()
# create our test fixture. use most of the default toolchain, but
# replace the apt installer with one that we can have more fun
# with. we will do all tests with ubuntu lucid keys -- other
# tests should cover different resolution cases.
sources_loader = create_test_SourcesListLoader()
lookup = RosdepLookup.create_from_rospkg(rospack=rospack, rosstack=rosstack, sources_loader=sources_loader)
context = create_default_installer_context()
context.set_os_override('ubuntu', 'lucid')
installer = RosdepInstaller(context, lookup)
# in this first test, detect_fn detects everything as installed
fake_apt = get_fake_apt(lambda x: x)
context.set_installer(APT_INSTALLER, fake_apt)
for verbose in [True, False]:
tests = [['roscpp_fake'], ['roscpp_fake', 'rospack_fake'], ['empty_package'],
['roscpp_fake', 'rospack_fake', 'empty_package'],
['roscpp_fake', 'rospack_fake'],
]
for test in tests:
uninstalled, errors = installer.get_uninstalled(test, verbose)
assert not uninstalled, uninstalled
assert not errors, errors
# in this second test, detect_fn detects nothing as installed
fake_apt = get_fake_apt(lambda x: [])
context.set_installer(APT_INSTALLER, fake_apt)
for verbose in [True, False]:
uninstalled, errors = installer.get_uninstalled(['empty'], verbose)
assert not uninstalled, uninstalled
assert not errors
expected = set(['libltdl-dev', 'libboost1.40-all-dev', 'libtool'])
uninstalled, errors = installer.get_uninstalled(['roscpp_fake'], verbose)
assert uninstalled.keys() == [APT_INSTALLER]
assert set(uninstalled[APT_INSTALLER]) == expected
assert not errors
expected = ['libtinyxml-dev']
uninstalled, errors = installer.get_uninstalled(['rospack_fake'], verbose)
assert uninstalled.keys() == [APT_INSTALLER]
assert uninstalled[APT_INSTALLER] == expected, uninstalled
assert not errors
def test_RosdepInstaller_install_resolved():
from rosdep2 import create_default_installer_context
from rosdep2.lookup import RosdepLookup
from rosdep2.installers import RosdepInstaller
from rosdep2.platforms.debian import APT_INSTALLER
from rosdep2.lookup import RosdepLookup
rospack, rosstack = get_test_rospkgs()
# create our test fixture. use most of the default toolchain, but
# replace the apt installer with one that we can have more fun
# with. we will do all tests with ubuntu lucid keys -- other
# tests should cover different resolution cases.
sources_loader = create_test_SourcesListLoader()
lookup = RosdepLookup.create_from_rospkg(rospack=rospack,
rosstack=rosstack,
sources_loader=sources_loader)
context = create_default_installer_context()
context.set_os_override('ubuntu', 'lucid')
installer = RosdepInstaller(context, lookup)
with fakeout() as (stdout, stderr):
installer.install_resolved(APT_INSTALLER, [],
simulate=True,
verbose=False)
with fakeout() as (stdout, stderr):
installer.install_resolved(APT_INSTALLER, [],
simulate=True,
verbose=True)
assert stdout.getvalue().strip() == '#No packages to install'
with fakeout() as (stdout, stderr):
try:
installer.install_resolved(APT_INSTALLER,
['rosdep-fake1', 'rosdep-fake2'],
simulate=True,
verbose=True)
except OSError as e:
if str(e).count('[Errno 2] No such file or directory') == 0:
raise
return True
stdout_lines = [
x.strip() for x in stdout.getvalue().split('\n') if x.strip()
]
assert stdout_lines == [
'#[apt] Installation commands:',
'sudo apt-get install rosdep-fake1',
'sudo apt-get install rosdep-fake2',
], ("%s: %s" % (stdout.getvalue(), stdout_lines))
def initialize_resolver(rosdistro_name, os_name, os_code_name):
# resolve rosdep keys into binary package names
ctx = create_default_installer_context()
try:
installer_key = ctx.get_default_os_installer_key(os_name)
except KeyError:
raise RuntimeError(
"Could not determine the rosdep installer for '%s'" % os_name)
installer = ctx.get_installer(installer_key)
view = get_catkin_view(rosdistro_name, os_name, os_code_name, update=False)
return {
'os_name': os_name,
'os_code_name': os_code_name,
'installer': installer,
'view': view,
}
def initialize_resolver(rosdistro_name, os_name, os_code_name):
# resolve rosdep keys into binary package names
ctx = create_default_installer_context()
try:
installer_key = ctx.get_default_os_installer_key(os_name)
except KeyError:
raise RuntimeError(
"Could not determine the rosdep installer for '%s'" % os_name)
installer = ctx.get_installer(installer_key)
view = get_catkin_view(rosdistro_name, os_name, os_code_name, update=False)
return {
'os_name': os_name,
'os_code_name': os_code_name,
'installer': installer,
'view': view,
}
def resolve_more_for_os(rosdep_key, view, installer, os_name, os_version):
"""
Resolve rosdep key to dependencies and installer key.
(This was copied from rosdep2.catkin_support)
:param os_name: OS name, e.g. 'ubuntu'
:returns: resolved key, resolved installer key, and default installer key
:raises: :exc:`rosdep2.ResolutionError`
"""
d = view.lookup(rosdep_key)
ctx = create_default_installer_context()
os_installers = ctx.get_os_installer_keys(os_name)
default_os_installer = ctx.get_default_os_installer_key(os_name)
inst_key, rule = d.get_rule_for_platform(os_name, os_version, os_installers, default_os_installer)
assert inst_key in os_installers
return installer.resolve(rule), inst_key, default_os_installer
def resolve_more_for_os(rosdep_key, view, installer, os_name, os_version):
"""
Resolve rosdep key to dependencies and installer key.
(This was copied from rosdep2.catkin_support)
:param os_name: OS name, e.g. 'ubuntu'
:returns: resolved key, resolved installer key, and default installer key
:raises: :exc:`rosdep2.ResolutionError`
"""
d = view.lookup(rosdep_key)
ctx = create_default_installer_context()
os_installers = ctx.get_os_installer_keys(os_name)
default_os_installer = ctx.get_default_os_installer_key(os_name)
inst_key, rule = d.get_rule_for_platform(os_name, os_version, os_installers, default_os_installer)
assert inst_key in os_installers
return installer.resolve(rule), inst_key, default_os_installer
def resolve_rosdep_key(key,
os_name,
os_version,
ros_distro=None,
ignored=None,
retry=True):
ignored = ignored or []
ctx = create_default_installer_context()
try:
installer_key = ctx.get_default_os_installer_key(os_name)
except KeyError:
BloomGenerator.exit(
"Could not determine the installer for '{0}'".format(os_name))
installer = ctx.get_installer(installer_key)
ros_distro = ros_distro or DEFAULT_ROS_DISTRO
view = get_view(os_name, os_version, ros_distro)
try:
return resolve_more_for_os(key, view, installer, os_name, os_version)
except (KeyError, ResolutionError) as exc:
debug(traceback.format_exc())
if key in ignored:
return None, None, None
if isinstance(exc, KeyError):
error("Could not resolve rosdep key '{0}'".format(key))
returncode = code.GENERATOR_NO_SUCH_ROSDEP_KEY
else:
error(
"Could not resolve rosdep key '{0}' for distro '{1}':".format(
key, os_version))
info(str(exc), use_prefix=False)
returncode = code.GENERATOR_NO_ROSDEP_KEY_FOR_DISTRO
if retry:
error("Try to resolve the problem with rosdep and then continue.")
if maybe_continue():
update_rosdep()
invalidate_view_cache()
return resolve_rosdep_key(key,
os_name,
os_version,
ros_distro,
ignored,
retry=True)
BloomGenerator.exit(
"Failed to resolve rosdep key '{0}', aborting.".format(key),
returncode=returncode)
def test_RosdepLookup_resolve_all():
from rosdep2 import create_default_installer_context
from rosdep2.lookup import RosdepLookup
rospack, rosstack = get_test_rospkgs()
sources_loader = create_test_SourcesListLoader()
lookup = RosdepLookup.create_from_rospkg(rospack=rospack, rosstack=rosstack,
sources_loader=sources_loader)
installer_context = create_default_installer_context()
installer_context.set_os_override('ubuntu', 'lucid')
# repeat for caching
lookup.verbose = True
for count in xrange(0, 2):
resolutions, errors = lookup.resolve_all(['rospack_fake', 'roscpp_fake'], installer_context)
assert not errors, errors
assert 'apt' in resolutions
assert set(resolutions['apt']) == set(['libtinyxml-dev', 'libboost1.40-all-dev', 'libtool', 'libltdl-dev']), set(resolutions['apt'])
def resolve(ros_distro, deps):
lookup = load_lookup()
installer_context = rosdep2.create_default_installer_context()
os_name, os_version = installer_context.get_os_name_and_version()
installer_keys = installer_context.get_os_installer_keys(os_name)
default_key = installer_context.get_default_os_installer_key(os_name)
keys = []
not_provided = []
for dep in deps:
if dep is None:
continue
view = lookup.get_rosdep_view(rosdep2.rospkg_loader.DEFAULT_VIEW_KEY)
try:
d = view.lookup(dep.name)
except KeyError as e:
keys.append(
ros_pkgname_to_pkgname(ros_distro, dep.name) + dep.version)
continue
try:
rule_installer, rule = d.get_rule_for_platform(
os_name, os_version, installer_keys, default_key)
except rosdep2.lookup.ResolutionError as e:
# ignoring ROS packages since Alpine ROS packages are not solvable at now
if '_is_ros' in e.rosdep_data:
if e.rosdep_data['_is_ros']:
keys.append(
ros_pkgname_to_pkgname(ros_distro, dep.name) +
dep.version)
continue
not_provided.append(dep.name)
continue
installer = installer_context.get_installer(rule_installer)
resolved = installer.resolve(rule)
for r in resolved:
keys.append(r + dep.version)
if len(not_provided) > 0:
print('Some package is not provided by native installer: ' +
' '.join(not_provided),
file=sys.stderr)
return None
return keys
def __init__(self):
self.cached_installers = {}
gc.disable()
try:
import sys
from . import dummy_pkg_resources
sys.modules["pkg_resources"] = dummy_pkg_resources
from rosdep2.lookup import RosdepLookup
from rosdep2.rospkg_loader import DEFAULT_VIEW_KEY
from rosdep2 import get_default_installer, create_default_installer_context
self.lookup = RosdepLookup.create_from_rospkg(rospack=DummyRospkg(), rosstack=DummyRospkg())
self.view = self.lookup.get_rosdep_view(DEFAULT_VIEW_KEY)
self.installer_ctx = create_default_installer_context()
_, self.installer_keys, self.default_key, \
self.os_name, self.os_version = get_default_installer(self.installer_ctx)
except Exception as e:
error("failed to initialize rosdep: %s" % str(e))
self.view = None
gc.enable()
def __init__(self):
self.cached_installers = {}
gc.disable()
try:
import sys
from . import dummy_pkg_resources
sys.modules["pkg_resources"] = dummy_pkg_resources
from rosdep2.lookup import RosdepLookup
from rosdep2.rospkg_loader import DEFAULT_VIEW_KEY
from rosdep2 import get_default_installer, create_default_installer_context
self.lookup = RosdepLookup.create_from_rospkg(
rospack=DummyRospkg(), rosstack=DummyRospkg())
self.view = self.lookup.get_rosdep_view(DEFAULT_VIEW_KEY)
self.installer_ctx = create_default_installer_context()
_, self.installer_keys, self.default_key, \
self.os_name, self.os_version = get_default_installer(self.installer_ctx)
except Exception as e:
error("failed to initialize rosdep: %s" % str(e))
self.view = None
gc.enable()
def __init__(self, indexer, ros_distro=None, os_name=None, os_codename=None):
self.indexer = indexer
if not os_name:
os_detector = rospkg.os_detect.OsDetect()
self.os_name = os_detector.get_name()
self.os_codename = os_detector.get_codename()
# FIXME: there should be a way to set this without using an environment variable
if ros_distro:
os.environ['ROS_DISTRO'] = ros_distro
self.sources_loader = SourcesListLoader.create_default(verbose=False)
self.lookup = RosdepLookup.create_from_rospkg(sources_loader=self.sources_loader)
self.installer_context = create_default_installer_context(verbose=False)
self.installer_keys = self.installer_context.get_os_installer_keys(self.os_name)
self.default_key = self.installer_context.get_default_os_installer_key(self.os_name)
self.installer = self.installer_context.get_installer(self.default_key)
self.view = self.lookup.get_rosdep_view(DEFAULT_VIEW_KEY, verbose=False)
def get_rosdep(key):
installer_context = create_default_installer_context(verbose=False)
installer, installer_keys, default_key, os_name, os_version = get_default_installer(
installer_context=installer_context, verbose=False)
global cached_view
if not cached_view:
lookup = RosdepLookup.create_from_rospkg()
lookup.verbose = False
view = lookup.get_rosdep_view(DEFAULT_VIEW_KEY, verbose=False)
cached_view = view
else:
view = cached_view
try:
d = view.lookup(key)
rule_installer, rule = d.get_rule_for_platform(os_name, os_version,
installer_keys,
default_key)
return rule_installer, rule
except KeyError:
return False
def __init__(self):
self.installer_context = create_default_installer_context()
_, self.installer_keys, self.default_key, self.os_name, self.os_version = get_default_installer(
installer_context=self.installer_context)
self.lookup = RosdepLookup.create_from_rospkg()
self.rosdep_view = self.lookup.get_rosdep_view(DEFAULT_VIEW_KEY)
'test_msgs',
'rttest',
'tlsf',
'tlsf_cpp',
'pendulum_control']
rospack = rospkg.RosPack()
source_cache_dir = rosdep2.sources_list.get_sources_cache_dir()
sources_loader = rosdep2.sources_list.SourcesListLoader.create_default(sources_cache_dir=source_cache_dir, os_override=convert_os_override_option())
lookup = rosdep2.lookup.RosdepLookup.create_from_rospkg(rospack=rospack, sources_loader=sources_loader)
view = lookup.get_rosdep_view(rosdep2.rospkg_loader.DEFAULT_VIEW_KEY)
installer_context = rosdep2.create_default_installer_context()
installer_context.set_os_override('conda', '10')
def _resolve(pkg):
resolved = []
try:
d = view.lookup(pkg)
os_name, os_version = installer_context.get_os_name_and_version()
rule_installer, rule = d.get_rule_for_platform(
os_name, os_version,
installer_context.get_os_installer_keys(os_name),
installer_context.get_default_os_installer_key(os_name))
installer = installer_context.get_installer(rule_installer)
resolved = installer.resolve(rule)
except:
def test_RosdepInstaller_get_uninstalled():
from rosdep2 import create_default_installer_context
from rosdep2.lookup import RosdepLookup
from rosdep2.installers import RosdepInstaller
from rosdep2.platforms.debian import APT_INSTALLER
from rosdep2.lookup import RosdepLookup
rospack, rosstack = get_test_rospkgs()
# create our test fixture. use most of the default toolchain, but
# replace the apt installer with one that we can have more fun
# with. we will do all tests with ubuntu lucid keys -- other
# tests should cover different resolution cases.
sources_loader = create_test_SourcesListLoader()
lookup = RosdepLookup.create_from_rospkg(rospack=rospack,
rosstack=rosstack,
sources_loader=sources_loader)
context = create_default_installer_context()
context.set_os_override('ubuntu', 'lucid')
installer = RosdepInstaller(context, lookup)
# in this first test, detect_fn detects everything as installed
fake_apt = get_fake_apt(lambda x: x)
context.set_installer(APT_INSTALLER, fake_apt)
for verbose in [True, False]:
tests = [
['roscpp_fake'],
['roscpp_fake', 'rospack_fake'],
['empty_package'],
['roscpp_fake', 'rospack_fake', 'empty_package'],
['roscpp_fake', 'rospack_fake'],
]
for test in tests:
uninstalled, errors = installer.get_uninstalled(test, verbose)
assert not uninstalled, uninstalled
assert not errors, errors
# in this second test, detect_fn detects nothing as installed
fake_apt = get_fake_apt(lambda x: [])
context.set_installer(APT_INSTALLER, fake_apt)
for verbose in [True, False]:
uninstalled, errors = installer.get_uninstalled(['empty'], verbose)
assert not uninstalled, uninstalled
assert not errors
expected = set(['libltdl-dev', 'libboost1.40-all-dev', 'libtool'])
uninstalled, errors = installer.get_uninstalled(['roscpp_fake'],
verbose)
keys, values = zip(*uninstalled)
apt_uninstalled = []
for k, v in uninstalled:
if k == APT_INSTALLER:
apt_uninstalled.extend(v)
assert list(set(keys)) == [APT_INSTALLER]
assert set(apt_uninstalled) == expected
assert not errors
expected = ['libtinyxml-dev']
uninstalled, errors = installer.get_uninstalled(['rospack_fake'],
verbose)
keys, values = zip(*uninstalled)
apt_uninstalled = []
for k, v in uninstalled:
if k == APT_INSTALLER:
apt_uninstalled.extend(v)
assert list(set(keys)) == [APT_INSTALLER]
assert apt_uninstalled == expected, uninstalled
assert not errors
def test_RosdepInstaller_get_uninstalled_unconfigured():
from rosdep2 import create_default_installer_context, RosdepInternalError
from rosdep2.lookup import RosdepLookup, ResolutionError
from rosdep2.installers import RosdepInstaller, PackageManagerInstaller
from rosdep2.platforms.debian import APT_INSTALLER
from rosdep2.lookup import RosdepLookup
rospack, rosstack = get_test_rospkgs()
sources_loader = create_test_SourcesListLoader()
# create our test fixture. we want to setup a fixture that cannot resolve the rosdep data in order to test error conditions
lookup = RosdepLookup.create_from_rospkg(rospack=rospack,
rosstack=rosstack,
sources_loader=sources_loader)
context = create_default_installer_context()
context.set_os_override('ubuntu', 'lucid')
installer = RosdepInstaller(context, lookup)
# - delete the apt installer
context.set_installer(APT_INSTALLER, None)
for verbose in [True, False]:
uninstalled, errors = installer.get_uninstalled(['empty'], verbose)
assert not uninstalled, uninstalled
assert not errors
# make sure there is an error when we lookup something that resolves to an apt depend
uninstalled, errors = installer.get_uninstalled(['roscpp_fake'],
verbose)
assert not uninstalled, uninstalled
assert list(errors.keys()) == ['roscpp_fake']
uninstalled, errors = installer.get_uninstalled(
['roscpp_fake', 'stack1_p1'], verbose)
assert not uninstalled, uninstalled
assert set(errors.keys()) == set(['roscpp_fake', 'stack1_p1'])
print(errors)
assert isinstance(errors['roscpp_fake'],
ResolutionError), errors['roscpp_fake'][0]
# fake/bad installer to test that we re-cast general installer issues
class BadInstaller(PackageManagerInstaller):
def __init__(self):
super(BadInstaller, self).__init__(lambda x: x)
def get_packages_to_install(*args):
raise Exception("deadbeef")
context.set_installer(APT_INSTALLER, BadInstaller())
try:
installer.get_uninstalled(['roscpp_fake'])
assert False, "should have raised"
except RosdepInternalError as e:
assert 'apt' in str(e)
# annoying mock to test generally impossible error condition
from mock import Mock
lookup = Mock(spec=RosdepLookup)
lookup.resolve_all.return_value = ([('bad-key', ['stuff'])], [])
installer = RosdepInstaller(context, lookup)
try:
installer.get_uninstalled(['roscpp_fake'])
assert False, "should have raised"
except RosdepInternalError:
pass
def main(args=None, get_subs_fn=None):
get_subs_fn = get_subs_fn or get_subs
_place_template_files = True
_process_template_files = True
package_path = os.getcwd()
skip_package_names = None
if args is not None:
package_path = args.package_path or os.getcwd()
_place_template_files = args.place_template_files
_process_template_files = args.process_template_files
# create dependency-skip package name lists
skip_name_path = args.skip_package_names or ''
if os.path.isfile(os.path.abspath(skip_name_path)):
with open(os.path.abspath(skip_name_path), 'r') as f:
skip_package_names = []
for line in f:
# comment string
if line[:1] == '#':
continue
# add lists
skip_package_names.append(line.strip())
pkgs_dict = find_packages(package_path)
if len(pkgs_dict) == 0:
sys.exit("No packages found in path: '{0}'".format(package_path))
if len(pkgs_dict) > 1:
sys.exit("Multiple packages found, "
"this tool only supports one package at a time.")
os_data = create_default_installer_context().get_os_name_and_version()
os_name, os_version = os_data
ros_distro = os.environ.get('ROS_DISTRO', 'indigo')
# Allow args overrides
os_name = args.os_name or os_name
os_version = args.os_version or os_version
ros_distro = args.ros_distro or ros_distro
# Summarize
info(
fmt("@!@{gf}==> @|") +
fmt("Generating debs for @{cf}%s:%s@| for package(s) %s" %
(os_name, os_version, [p.name for p in pkgs_dict.values()])))
for path, pkg in pkgs_dict.items():
template_files = None
try:
subs = get_subs_fn(pkg, os_name, os_version, ros_distro,
args.native, skip_package_names)
if _place_template_files:
# Place template files
place_template_files(path, pkg.get_build_type())
if _process_template_files:
# Just process existing template files
template_files = process_template_files(path, subs)
if not _place_template_files and not _process_template_files:
# If neither, do both
place_template_files(path, pkg.get_build_type())
template_files = process_template_files(path, subs)
if template_files is not None:
for template_file in template_files:
os.remove(os.path.normpath(template_file))
except Exception as exc:
debug(traceback.format_exc())
error(type(exc).__name__ + ": " + str(exc), exit=True)
except (KeyboardInterrupt, EOFError):
sys.exit(1)
