def test_ensure_workspace_marker(self):
try:
root_dir = tempfile.mkdtemp()
ensure_workspace_marker(root_dir)
self.assertTrue(os.path.exists(os.path.join(root_dir, CATKIN_WORKSPACE_MARKER_FILE)))
# assert no exception on revisit
ensure_workspace_marker(root_dir)
finally:
shutil.rmtree(root_dir)
def test_ensure_workspace_marker(self):
try:
root_dir = tempfile.mkdtemp()
ensure_workspace_marker(root_dir)
self.assertTrue(
os.path.exists(
os.path.join(root_dir, CATKIN_WORKSPACE_MARKER_FILE)))
# assert no exception on revisit
ensure_workspace_marker(root_dir)
finally:
shutil.rmtree(root_dir)
def build_workspace_isolated(workspace='.',
sourcespace=None,
buildspace=None,
develspace=None,
installspace=None,
merge=False,
install=False,
force_cmake=False,
colorize=True,
build_packages=None,
quiet=False,
cmake_args=None,
make_args=None,
catkin_make_args=None,
continue_from_pkg=False,
only_pkg_with_deps=None,
destdir=None,
use_ninja=False):
'''
Runs ``cmake``, ``make`` and optionally ``make install`` for all
catkin packages in sourcespace_dir. It creates several folders
in the current working directory. For non-catkin packages it runs
``cmake``, ``make`` and ``make install`` for each, installing it to
the devel space or install space if the ``install`` option is specified.
:param workspace: path to the current workspace, ``str``
:param sourcespace: workspace folder containing catkin packages, ``str``
:param buildspace: path to build space location, ``str``
:param develspace: path to devel space location, ``str``
:param installspace: path to install space (CMAKE_INSTALL_PREFIX), ``str``
:param merge: if True, build each catkin package into the same
devel space (not affecting plain cmake packages), ``bool``
:param install: if True, install all packages to the install space,
``bool``
:param force_cmake: (optional), if True calls cmake explicitly for each
package, ``bool``
:param colorize: if True, colorize cmake output and other messages,
``bool``
:param build_packages: specific packages to build (all parent packages
in the topological order must have been built before), ``str``
:param quiet: if True, hides some build output, ``bool``
:param cmake_args: additional arguments for cmake, ``[str]``
:param make_args: additional arguments for make, ``[str]``
:param catkin_make_args: additional arguments for make but only for catkin
packages, ``[str]``
:param continue_from_pkg: indicates whether or not cmi should continue
when a package is reached, ``bool``
:param only_pkg_with_deps: only consider the specific packages and their
recursive dependencies and ignore all other packages in the workspace,
``[str]``
:param destdir: define DESTDIR for cmake/invocation, ``string``
:param use_ninja: if True, use ninja instead of make, ``bool``
'''
if not colorize:
disable_ANSI_colors()
# Check workspace existance
if not os.path.exists(workspace):
sys.exit("Workspace path '{0}' does not exist.".format(workspace))
workspace = os.path.abspath(workspace)
# Check source space existance
if sourcespace is None:
sourcespace = os.path.join(workspace, 'src')
if not os.path.exists(sourcespace):
sys.exit('Could not find source space: {0}'.format(sourcespace))
print('Base path: ' + str(workspace))
print('Source space: ' + str(sourcespace))
# Check build space
if buildspace is None:
buildspace = os.path.join(workspace, 'build_isolated')
if not os.path.exists(buildspace):
os.mkdir(buildspace)
print('Build space: ' + str(buildspace))
# Check devel space
if develspace is None:
develspace = os.path.join(workspace, 'devel_isolated')
print('Devel space: ' + str(develspace))
# Check install space
if installspace is None:
installspace = os.path.join(workspace, 'install_isolated')
print('Install space: ' + str(installspace))
if cmake_args:
print("Additional CMake Arguments: " + " ".join(cmake_args))
else:
cmake_args = []
if not [arg for arg in cmake_args if arg.startswith('-G')]:
if not use_ninja:
cmake_args += ['-G', 'Unix Makefiles']
else:
cmake_args += ['-G', 'Ninja']
elif use_ninja:
print(
colorize_line(
"Error: either specify a generator using '-G...' or '--use-ninja' but not both"
))
sys.exit(1)
if make_args:
print("Additional make Arguments: " + " ".join(make_args))
else:
make_args = []
if catkin_make_args:
print("Additional make Arguments for catkin packages: " +
" ".join(catkin_make_args))
else:
catkin_make_args = []
# Find packages
packages = find_packages(sourcespace, exclude_subspaces=True)
if not packages:
print(fmt("@{yf}No packages found in source space: %s@|" %
sourcespace))
# whitelist packages and their dependencies in workspace
if only_pkg_with_deps:
package_names = [p.name for p in packages.values()]
unknown_packages = [
name for name in only_pkg_with_deps if name not in package_names
]
if unknown_packages:
sys.exit('Packages not found in the workspace: %s' %
', '.join(unknown_packages))
whitelist_pkg_names = get_package_names_with_recursive_dependencies(
packages, only_pkg_with_deps)
print('Whitelisted packages: %s' %
', '.join(sorted(whitelist_pkg_names)))
packages = {
path: p
for path, p in packages.items() if p.name in whitelist_pkg_names
}
# verify that specified package exists in workspace
if build_packages:
packages_by_name = {p.name: path for path, p in packages.items()}
unknown_packages = [
p for p in build_packages if p not in packages_by_name
]
if unknown_packages:
sys.exit('Packages not found in the workspace: %s' %
', '.join(unknown_packages))
# Report topological ordering
ordered_packages = topological_order_packages(packages)
unknown_build_types = []
msg = []
msg.append('@{pf}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' +
('~' * len(str(len(ordered_packages)))))
msg.append('@{pf}~~@| traversing %d packages in topological order:' %
len(ordered_packages))
for path, package in ordered_packages:
if path is None:
print(
fmt('@{rf}Error: Circular dependency in subset of packages: @!%s@|'
% package))
sys.exit('Can not build workspace with circular dependency')
export_tags = [e.tagname for e in package.exports]
if 'build_type' in export_tags:
build_type_tag = [
e.content for e in package.exports if e.tagname == 'build_type'
][0]
else:
build_type_tag = 'catkin'
if build_type_tag == 'catkin':
msg.append('@{pf}~~@| - @!@{bf}' + package.name + '@|')
elif build_type_tag == 'cmake':
msg.append('@{pf}~~@| - @!@{bf}' + package.name + '@|' +
' (@!@{cf}plain cmake@|)')
else:
msg.append('@{pf}~~@| - @!@{bf}' + package.name + '@|' +
' (@{rf}unknown@|)')
unknown_build_types.append(package)
msg.append('@{pf}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' +
('~' * len(str(len(ordered_packages)))))
for index in range(len(msg)):
msg[index] = fmt(msg[index])
print('\n'.join(msg))
# Error if there are packages with unknown build_types
if unknown_build_types:
print(colorize_line('Error: Packages with unknown build types exist'))
sys.exit('Can not build workspace with packages of unknown build_type')
# Check to see if the workspace has changed
cmake_args_with_spaces = list(cmake_args)
if develspace:
cmake_args_with_spaces.append('-DCATKIN_DEVEL_PREFIX=' + develspace)
if installspace:
cmake_args_with_spaces.append('-DCMAKE_INSTALL_PREFIX=' + installspace)
if not force_cmake and cmake_input_changed(
packages,
buildspace,
cmake_args=cmake_args_with_spaces,
filename='catkin_make_isolated'):
print(
'The packages or cmake arguments have changed, forcing cmake invocation'
)
force_cmake = True
ensure_workspace_marker(workspace)
# Build packages
pkg_develspace = None
last_env = None
for index, path_package in enumerate(ordered_packages):
path, package = path_package
if merge:
pkg_develspace = develspace
else:
pkg_develspace = os.path.join(develspace, package.name)
if not build_packages or package.name in build_packages:
if continue_from_pkg and build_packages and package.name in build_packages:
build_packages = None
try:
print()
last_env = build_package(path,
package,
workspace,
buildspace,
pkg_develspace,
installspace,
install,
force_cmake,
quiet,
last_env,
cmake_args,
make_args,
catkin_make_args,
destdir=destdir,
use_ninja=use_ninja,
number=index + 1,
of=len(ordered_packages))
except subprocess.CalledProcessError as e:
_print_build_error(package, e)
# Let users know how to reproduce
# First add the cd to the build folder of the package
cmd = 'cd ' + quote(os.path.join(buildspace,
package.name)) + ' && '
# Then reproduce the command called
if isinstance(e.cmd, list):
# quote arguments to allow copy-n-paste of command
cmd += ' '.join([quote(arg) for arg in e.cmd])
else:
cmd += e.cmd
print(fmt("\n@{rf}Reproduce this error by running:"))
print(fmt("@{gf}@!==> @|") + cmd + "\n")
sys.exit('Command failed, exiting.')
except Exception as e:
print("Unhandled exception of type '{0}':".format(
type(e).__name__))
import traceback
traceback.print_exc()
_print_build_error(package, e)
sys.exit('Command failed, exiting.')
else:
cprint("Skipping package: '@!@{bf}" + package.name + "@|'")
last_env = get_new_env(package, pkg_develspace, installspace,
install, last_env, destdir)
# Provide a top level devel space environment setup script
if not os.path.exists(develspace):
os.makedirs(develspace)
if not build_packages:
generated_env_sh = os.path.join(develspace, 'env.sh')
generated_setup_util_py = os.path.join(develspace, '_setup_util.py')
if not merge and pkg_develspace:
# generate env.sh and setup.sh|bash|zsh which relay to last devel space
with open(generated_env_sh, 'w') as f:
f.write("""\
#!/usr/bin/env sh
# generated from catkin.builder module
{0} "$@"
""".format(os.path.join(pkg_develspace, 'env.sh')))
os.chmod(generated_env_sh,
stat.S_IXUSR | stat.S_IWUSR | stat.S_IRUSR)
for shell in ['sh', 'bash', 'zsh']:
with open(os.path.join(develspace, 'setup.%s' % shell),
'w') as f:
f.write("""\
#!/usr/bin/env {1}
# generated from catkin.builder module
. "{0}/setup.{1}"
""".format(pkg_develspace, shell))
# remove _setup_util.py file which might have been generated for an empty devel space before
if os.path.exists(generated_setup_util_py):
os.remove(generated_setup_util_py)
elif not pkg_develspace:
# generate env.sh and setup.sh|bash|zsh for an empty devel space
if 'CMAKE_PREFIX_PATH' in os.environ.keys():
variables = {
'CATKIN_GLOBAL_BIN_DESTINATION':
'bin',
'CATKIN_LIB_ENVIRONMENT_PATHS':
"'lib'",
'CATKIN_PKGCONFIG_ENVIRONMENT_PATHS':
"os.path.join('lib', 'pkgconfig')",
'CMAKE_PREFIX_PATH_AS_IS':
';'.join(os.environ['CMAKE_PREFIX_PATH'].split(
os.pathsep)),
'PYTHON_EXECUTABLE':
sys.executable,
'PYTHON_INSTALL_DIR':
get_python_install_dir(),
}
with open(generated_setup_util_py, 'w') as f:
f.write(
configure_file(
os.path.join(get_cmake_path(), 'templates',
'_setup_util.py.in'), variables))
os.chmod(generated_setup_util_py,
stat.S_IXUSR | stat.S_IWUSR | stat.S_IRUSR)
else:
sys.exit(
"Unable to process CMAKE_PREFIX_PATH from environment. Cannot generate environment files."
)
variables = {'SETUP_FILENAME': 'setup'}
with open(generated_env_sh, 'w') as f:
f.write(
configure_file(
os.path.join(get_cmake_path(), 'templates',
'env.sh.in'), variables))
os.chmod(generated_env_sh,
stat.S_IXUSR | stat.S_IWUSR | stat.S_IRUSR)
variables = {'SETUP_DIR': develspace}
for shell in ['sh', 'bash', 'zsh']:
with open(os.path.join(develspace, 'setup.%s' % shell),
'w') as f:
f.write(
configure_file(
os.path.join(get_cmake_path(), 'templates',
'setup.%s.in' % shell), variables))
def build_workspace_isolated(
workspace='.',
sourcespace=None,
buildspace=None,
develspace=None,
installspace=None,
merge=False,
install=False,
force_cmake=False,
colorize=True,
build_packages=None,
quiet=False,
cmake_args=None,
make_args=None,
catkin_make_args=None,
continue_from_pkg=False,
only_pkg_with_deps=None,
destdir=None,
use_ninja=False,
use_nmake=False,
override_build_tool_check=False
):
'''
Runs ``cmake``, ``make`` and optionally ``make install`` for all
catkin packages in sourcespace_dir. It creates several folders
in the current working directory. For non-catkin packages it runs
``cmake``, ``make`` and ``make install`` for each, installing it to
the devel space or install space if the ``install`` option is specified.
:param workspace: path to the current workspace, ``str``
:param sourcespace: workspace folder containing catkin packages, ``str``
:param buildspace: path to build space location, ``str``
:param develspace: path to devel space location, ``str``
:param installspace: path to install space (CMAKE_INSTALL_PREFIX), ``str``
:param merge: if True, build each catkin package into the same
devel space (not affecting plain cmake packages), ``bool``
:param install: if True, install all packages to the install space,
``bool``
:param force_cmake: (optional), if True calls cmake explicitly for each
package, ``bool``
:param colorize: if True, colorize cmake output and other messages,
``bool``
:param build_packages: specific packages to build (all parent packages
in the topological order must have been built before), ``str``
:param quiet: if True, hides some build output, ``bool``
:param cmake_args: additional arguments for cmake, ``[str]``
:param make_args: additional arguments for make, ``[str]``
:param catkin_make_args: additional arguments for make but only for catkin
packages, ``[str]``
:param continue_from_pkg: indicates whether or not cmi should continue
when a package is reached, ``bool``
:param only_pkg_with_deps: only consider the specific packages and their
recursive dependencies and ignore all other packages in the workspace,
``[str]``
:param destdir: define DESTDIR for cmake/invocation, ``string``
:param use_ninja: if True, use ninja instead of make, ``bool``
:param use_nmake: if True, use nmake instead of make, ``bool``
:param override_build_tool_check: if True, build even if a space was built
by another tool previously.
'''
if not colorize:
disable_ANSI_colors()
# Check workspace existance
if not os.path.exists(workspace):
sys.exit("Workspace path '{0}' does not exist.".format(workspace))
workspace = os.path.abspath(workspace)
# Check source space existance
if sourcespace is None:
sourcespace = os.path.join(workspace, 'src')
if not os.path.exists(sourcespace):
sys.exit('Could not find source space: {0}'.format(sourcespace))
print('Base path: ' + str(workspace))
print('Source space: ' + str(sourcespace))
# Check build space
if buildspace is None:
buildspace = os.path.join(workspace, 'build_isolated')
if not os.path.exists(buildspace):
os.mkdir(buildspace)
print('Build space: ' + str(buildspace))
# ensure the build space was previously built by catkin_make_isolated
previous_tool = get_previous_tool_used_on_the_space(buildspace)
if previous_tool is not None and previous_tool != 'catkin_make_isolated':
if override_build_tool_check:
print(fmt(
"@{yf}Warning: build space at '%s' was previously built by '%s', "
"but --override-build-tool-check was passed so continuing anyways."
% (buildspace, previous_tool)))
else:
sys.exit(fmt(
"@{rf}The build space at '%s' was previously built by '%s'. "
"Please remove the build space or pick a different build space."
% (buildspace, previous_tool)))
mark_space_as_built_by(buildspace, 'catkin_make_isolated')
# Check devel space
if develspace is None:
develspace = os.path.join(workspace, 'devel_isolated')
print('Devel space: ' + str(develspace))
# ensure the devel space was previously built by catkin_make_isolated
previous_tool = get_previous_tool_used_on_the_space(develspace)
if previous_tool is not None and previous_tool != 'catkin_make_isolated':
if override_build_tool_check:
print(fmt(
"@{yf}Warning: devel space at '%s' was previously built by '%s', "
"but --override-build-tool-check was passed so continuing anyways."
% (develspace, previous_tool)))
else:
sys.exit(fmt(
"@{rf}The devel space at '%s' was previously built by '%s'. "
"Please remove the devel space or pick a different devel space."
% (develspace, previous_tool)))
mark_space_as_built_by(develspace, 'catkin_make_isolated')
# Check install space
if installspace is None:
installspace = os.path.join(workspace, 'install_isolated')
print('Install space: ' + str(installspace))
if cmake_args:
print("Additional CMake Arguments: " + " ".join(cmake_args))
else:
cmake_args = []
if not [arg for arg in cmake_args if arg.startswith('-G')]:
if use_ninja:
cmake_args += ['-G', 'Ninja']
elif use_nmake:
cmake_args += ['-G', 'NMake Makefiles']
else:
cmake_args += ['-G', 'Unix Makefiles']
elif use_ninja or use_nmake:
print(colorize_line("Error: either specify a generator using '-G...' or '--use-[ninja|nmake]' but not both"))
sys.exit(1)
if make_args:
print("Additional make Arguments: " + " ".join(make_args))
else:
make_args = []
if catkin_make_args:
print("Additional make Arguments for catkin packages: " + " ".join(catkin_make_args))
else:
catkin_make_args = []
# Find packages
packages = find_packages(sourcespace, exclude_subspaces=True)
if not packages:
print(fmt("@{yf}No packages found in source space: %s@|" % sourcespace))
# whitelist packages and their dependencies in workspace
if only_pkg_with_deps:
package_names = [p.name for p in packages.values()]
unknown_packages = [name for name in only_pkg_with_deps if name not in package_names]
if unknown_packages:
sys.exit('Packages not found in the workspace: %s' % ', '.join(unknown_packages))
whitelist_pkg_names = get_package_names_with_recursive_dependencies(packages, only_pkg_with_deps)
print('Whitelisted packages: %s' % ', '.join(sorted(whitelist_pkg_names)))
packages = {path: p for path, p in packages.items() if p.name in whitelist_pkg_names}
# verify that specified package exists in workspace
if build_packages:
packages_by_name = {p.name: path for path, p in packages.items()}
unknown_packages = [p for p in build_packages if p not in packages_by_name]
if unknown_packages:
sys.exit('Packages not found in the workspace: %s' % ', '.join(unknown_packages))
# Report topological ordering
ordered_packages = topological_order_packages(packages)
unknown_build_types = []
msg = []
msg.append('@{pf}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' + ('~' * len(str(len(ordered_packages)))))
msg.append('@{pf}~~@| traversing %d packages in topological order:' % len(ordered_packages))
for path, package in ordered_packages:
if path is None:
print(fmt('@{rf}Error: Circular dependency in subset of packages: @!%s@|' % package))
sys.exit('Can not build workspace with circular dependency')
export_tags = [e.tagname for e in package.exports]
if 'build_type' in export_tags:
build_type_tag = [e.content for e in package.exports if e.tagname == 'build_type'][0]
else:
build_type_tag = 'catkin'
if build_type_tag == 'catkin':
msg.append('@{pf}~~@| - @!@{bf}' + package.name + '@|')
elif build_type_tag == 'cmake':
msg.append(
'@{pf}~~@| - @!@{bf}' + package.name + '@|' +
' (@!@{cf}plain cmake@|)'
)
else:
msg.append(
'@{pf}~~@| - @!@{bf}' + package.name + '@|' +
' (@{rf}unknown@|)'
)
unknown_build_types.append(package)
msg.append('@{pf}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' + ('~' * len(str(len(ordered_packages)))))
for index in range(len(msg)):
msg[index] = fmt(msg[index])
print('\n'.join(msg))
# Error if there are packages with unknown build_types
if unknown_build_types:
print(colorize_line('Error: Packages with unknown build types exist'))
sys.exit('Can not build workspace with packages of unknown build_type')
# Check to see if the workspace has changed
cmake_args_with_spaces = list(cmake_args)
if develspace:
cmake_args_with_spaces.append('-DCATKIN_DEVEL_PREFIX=' + develspace)
if installspace:
cmake_args_with_spaces.append('-DCMAKE_INSTALL_PREFIX=' + installspace)
if (
not force_cmake and
cmake_input_changed(packages, buildspace, cmake_args=cmake_args_with_spaces, filename='catkin_make_isolated')
):
print('The packages or cmake arguments have changed, forcing cmake invocation')
force_cmake = True
ensure_workspace_marker(workspace)
# Build packages
pkg_develspace = None
last_env = None
for index, path_package in enumerate(ordered_packages):
path, package = path_package
if merge:
pkg_develspace = develspace
else:
pkg_develspace = os.path.join(develspace, package.name)
if not build_packages or package.name in build_packages:
if continue_from_pkg and build_packages and package.name in build_packages:
build_packages = None
try:
print()
last_env = build_package(
path, package,
workspace, buildspace, pkg_develspace, installspace,
install, force_cmake,
quiet, last_env, cmake_args, make_args, catkin_make_args,
destdir=destdir, use_ninja=use_ninja,
number=index + 1, of=len(ordered_packages)
)
except subprocess.CalledProcessError as e:
_print_build_error(package, e)
# Let users know how to reproduce
# First add the cd to the build folder of the package
cmd = 'cd ' + quote(os.path.join(buildspace, package.name)) + ' && '
# Then reproduce the command called
if isinstance(e.cmd, list):
# quote arguments to allow copy-n-paste of command
cmd += ' '.join([quote(arg) for arg in e.cmd])
else:
cmd += e.cmd
print(fmt("\n@{rf}Reproduce this error by running:"))
print(fmt("@{gf}@!==> @|") + cmd + "\n")
sys.exit('Command failed, exiting.')
except Exception as e:
print("Unhandled exception of type '{0}':".format(type(e).__name__))
import traceback
traceback.print_exc()
_print_build_error(package, e)
sys.exit('Command failed, exiting.')
else:
cprint("Skipping package: '@!@{bf}" + package.name + "@|'")
last_env = get_new_env(package, pkg_develspace, installspace, install, last_env, destdir)
# Provide a top level devel space environment setup script
if not os.path.exists(develspace):
os.makedirs(develspace)
if not build_packages:
generated_env_sh = os.path.join(develspace, 'env.sh')
generated_setup_util_py = os.path.join(develspace, '_setup_util.py')
if not merge and pkg_develspace:
# generate env.sh and setup.sh|bash|zsh which relay to last devel space
with open(generated_env_sh, 'w') as f:
f.write("""\
#!/usr/bin/env sh
# generated from catkin.builder module
{0} "$@"
""".format(os.path.join(pkg_develspace, 'env.sh')))
os.chmod(generated_env_sh, stat.S_IXUSR | stat.S_IWUSR | stat.S_IRUSR)
for shell in ['sh', 'bash', 'zsh']:
with open(os.path.join(develspace, 'setup.%s' % shell), 'w') as f:
f.write("""\
#!/usr/bin/env {1}
# generated from catkin.builder module
. "{0}/setup.{1}"
""".format(pkg_develspace, shell))
# remove _setup_util.py file which might have been generated for an empty devel space before
if os.path.exists(generated_setup_util_py):
os.remove(generated_setup_util_py)
elif not pkg_develspace:
# generate env.sh and setup.sh|bash|zsh for an empty devel space
if 'CMAKE_PREFIX_PATH' in os.environ.keys():
variables = {
'CATKIN_GLOBAL_BIN_DESTINATION': 'bin',
'CATKIN_LIB_ENVIRONMENT_PATHS': "'lib'",
'CATKIN_PKGCONFIG_ENVIRONMENT_PATHS': "os.path.join('lib', 'pkgconfig')",
'CMAKE_PREFIX_PATH_AS_IS': ';'.join(os.environ['CMAKE_PREFIX_PATH'].split(os.pathsep)),
'PYTHON_EXECUTABLE': sys.executable,
'PYTHON_INSTALL_DIR': get_python_install_dir(),
}
with open(generated_setup_util_py, 'w') as f:
f.write(configure_file(
os.path.join(get_cmake_path(), 'templates', '_setup_util.py.in'),
variables))
os.chmod(generated_setup_util_py, stat.S_IXUSR | stat.S_IWUSR | stat.S_IRUSR)
else:
sys.exit("Unable to process CMAKE_PREFIX_PATH from environment. Cannot generate environment files.")
variables = {'SETUP_FILENAME': 'setup'}
with open(generated_env_sh, 'w') as f:
f.write(configure_file(os.path.join(get_cmake_path(), 'templates', 'env.sh.in'), variables))
os.chmod(generated_env_sh, stat.S_IXUSR | stat.S_IWUSR | stat.S_IRUSR)
variables = {'SETUP_DIR': develspace}
for shell in ['sh', 'bash', 'zsh']:
with open(os.path.join(develspace, 'setup.%s' % shell), 'w') as f:
f.write(configure_file(
os.path.join(get_cmake_path(), 'templates', 'setup.%s.in' % shell),
variables))
def build_workspace_isolated(
workspace=".",
sourcespace=None,
buildspace=None,
develspace=None,
installspace=None,
merge=False,
install=False,
force_cmake=False,
colorize=True,
build_packages=None,
quiet=False,
cmake_args=None,
make_args=None,
catkin_make_args=None,
continue_from_pkg=False,
only_pkg_with_deps=None,
destdir=None,
):
"""
Runs ``cmake``, ``make`` and optionally ``make install`` for all
catkin packages in sourcespace_dir. It creates several folders
in the current working directory. For non-catkin packages it runs
``cmake``, ``make`` and ``make install`` for each, installing it to
the devel space or install space if the ``install`` option is specified.
:param workspace: path to the current workspace, ``str``
:param sourcespace: workspace folder containing catkin packages, ``str``
:param buildspace: path to build space location, ``str``
:param develspace: path to devel space location, ``str``
:param installspace: path to install space (CMAKE_INSTALL_PREFIX), ``str``
:param merge: if True, build each catkin package into the same
devel space (not affecting plain cmake packages), ``bool``
:param install: if True, install all packages to the install space,
``bool``
:param force_cmake: (optional), if True calls cmake explicitly for each
package, ``bool``
:param colorize: if True, colorize cmake output and other messages,
``bool``
:param build_packages: specific packages to build (all parent packages
in the topological order must have been built before), ``str``
:param quiet: if True, hides some build output, ``bool``
:param cmake_args: additional arguments for cmake, ``[str]``
:param make_args: additional arguments for make, ``[str]``
:param catkin_make_args: additional arguments for make but only for catkin
packages, ``[str]``
:param continue_from_pkg: indicates whether or not cmi should continue
when a package is reached, ``bool``
:param only_pkg_with_deps: only consider the specific packages and their
recursive dependencies and ignore all other packages in the workspace,
``[str]``
:param destdir: define DESTDIR for cmake/invocation, ``string``
"""
if not colorize:
disable_ANSI_colors()
# Check workspace existance
if not os.path.exists(workspace):
sys.exit("Workspace path '{0}' does not exist.".format(workspace))
workspace = os.path.abspath(workspace)
# Check source space existance
if sourcespace is None:
sourcespace = os.path.join(workspace, "src")
if not os.path.exists(sourcespace):
sys.exit("Could not find source space: {0}".format(sourcespace))
print("Base path: " + str(workspace))
print("Source space: " + str(sourcespace))
# Check build space
if buildspace is None:
buildspace = os.path.join(workspace, "build_isolated")
if not os.path.exists(buildspace):
os.mkdir(buildspace)
print("Build space: " + str(buildspace))
# Check devel space
if develspace is None:
develspace = os.path.join(workspace, "devel_isolated")
print("Devel space: " + str(develspace))
# Check install space
if installspace is None:
installspace = os.path.join(workspace, "install_isolated")
print("Install space: " + str(installspace))
if cmake_args:
print("Additional CMake Arguments: " + " ".join(cmake_args))
else:
cmake_args = []
if make_args:
print("Additional make Arguments: " + " ".join(make_args))
else:
make_args = []
if catkin_make_args:
print("Additional make Arguments for catkin packages: " + " ".join(catkin_make_args))
else:
catkin_make_args = []
# Find packages
packages = find_packages(sourcespace, exclude_subspaces=True)
if not packages:
print(fmt("@{yf}No packages found in source space: %s@|" % sourcespace))
# whitelist packages and their dependencies in workspace
if only_pkg_with_deps:
package_names = [p.name for p in packages.values()]
unknown_packages = [name for name in only_pkg_with_deps if name not in package_names]
if unknown_packages:
sys.exit("Packages not found in the workspace: %s" % ", ".join(unknown_packages))
whitelist_pkg_names = get_package_names_with_recursive_dependencies(packages, only_pkg_with_deps)
print("Whitelisted packages: %s" % ", ".join(sorted(whitelist_pkg_names)))
packages = {path: p for path, p in packages.items() if p.name in whitelist_pkg_names}
# verify that specified package exists in workspace
if build_packages:
packages_by_name = {p.name: path for path, p in packages.items()}
unknown_packages = [p for p in build_packages if p not in packages_by_name]
if unknown_packages:
sys.exit("Packages not found in the workspace: %s" % ", ".join(unknown_packages))
# Report topological ordering
ordered_packages = topological_order_packages(packages)
unknown_build_types = []
msg = []
msg.append("@{pf}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" + ("~" * len(str(len(ordered_packages)))))
msg.append("@{pf}~~@| traversing %d packages in topological order:" % len(ordered_packages))
for path, package in ordered_packages:
if path is None:
print(fmt("@{rf}Error: Circular dependency in subset of packages: @!%s@|" % package))
sys.exit("Can not build workspace with circular dependency")
export_tags = [e.tagname for e in package.exports]
if "build_type" in export_tags:
build_type_tag = [e.content for e in package.exports if e.tagname == "build_type"][0]
else:
build_type_tag = "catkin"
if build_type_tag == "catkin":
msg.append("@{pf}~~@| - @!@{bf}" + package.name + "@|")
elif build_type_tag == "cmake":
msg.append("@{pf}~~@| - @!@{bf}" + package.name + "@|" + " (@!@{cf}plain cmake@|)")
else:
msg.append("@{pf}~~@| - @!@{bf}" + package.name + "@|" + " (@{rf}unknown@|)")
unknown_build_types.append(package)
msg.append("@{pf}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" + ("~" * len(str(len(ordered_packages)))))
for index in range(len(msg)):
msg[index] = fmt(msg[index])
print("\n".join(msg))
# Error if there are packages with unknown build_types
if unknown_build_types:
print(colorize_line("Error: Packages with unknown build types exist"))
sys.exit("Can not build workspace with packages of unknown build_type")
# Check to see if the workspace has changed
cmake_args_with_spaces = list(cmake_args)
if develspace:
cmake_args_with_spaces.append("-DCATKIN_DEVEL_PREFIX=" + develspace)
if installspace:
cmake_args_with_spaces.append("-DCMAKE_INSTALL_PREFIX=" + installspace)
if not force_cmake and cmake_input_changed(
packages, buildspace, cmake_args=cmake_args_with_spaces, filename="catkin_make_isolated"
):
print("The packages or cmake arguments have changed, forcing cmake invocation")
force_cmake = True
ensure_workspace_marker(workspace)
# Build packages
pkg_develspace = None
last_env = None
for index, path_package in enumerate(ordered_packages):
path, package = path_package
if merge:
pkg_develspace = develspace
else:
pkg_develspace = os.path.join(develspace, package.name)
if not build_packages or package.name in build_packages:
if continue_from_pkg and build_packages and package.name in build_packages:
build_packages = None
try:
print()
last_env = build_package(
path,
package,
workspace,
buildspace,
pkg_develspace,
installspace,
install,
force_cmake,
quiet,
last_env,
cmake_args,
make_args,
catkin_make_args,
destdir=destdir,
number=index + 1,
of=len(ordered_packages),
)
except subprocess.CalledProcessError as e:
_print_build_error(package, e)
# Let users know how to reproduce
# First add the cd to the build folder of the package
cmd = "cd " + os.path.join(buildspace, package.name) + " && "
# Then reproduce the command called
cmd += " ".join(e.cmd) if isinstance(e.cmd, list) else e.cmd
print(fmt("\n@{rf}Reproduce this error by running:"))
print(fmt("@{gf}@!==> @|") + cmd + "\n")
sys.exit("Command failed, exiting.")
except Exception as e:
print("Unhandled exception of type '{0}':".format(type(e).__name__))
import traceback
traceback.print_exc()
_print_build_error(package, e)
sys.exit("Command failed, exiting.")
else:
cprint("Skipping package: '@!@{bf}" + package.name + "@|'")
last_env = get_new_env(package, pkg_develspace, installspace, install, last_env, destdir)
# Provide a top level devel space environment setup script
if not os.path.exists(develspace):
os.makedirs(develspace)
if not build_packages:
generated_env_sh = os.path.join(develspace, "env.sh")
generated_setup_util_py = os.path.join(develspace, "_setup_util.py")
if not merge and pkg_develspace:
# generate env.sh and setup.sh|bash|zsh which relay to last devel space
with open(generated_env_sh, "w") as f:
f.write(
"""\
#!/usr/bin/env sh
# generated from catkin.builder module
{0} "$@"
""".format(
os.path.join(pkg_develspace, "env.sh")
)
)
os.chmod(generated_env_sh, stat.S_IXUSR | stat.S_IWUSR | stat.S_IRUSR)
for shell in ["sh", "bash", "zsh"]:
with open(os.path.join(develspace, "setup.%s" % shell), "w") as f:
f.write(
"""\
#!/usr/bin/env {1}
# generated from catkin.builder module
. "{0}/setup.{1}"
""".format(
pkg_develspace, shell
)
)
# remove _setup_util.py file which might have been generated for an empty devel space before
if os.path.exists(generated_setup_util_py):
os.remove(generated_setup_util_py)
elif not pkg_develspace:
# generate env.sh and setup.sh|bash|zsh for an empty devel space
if "CMAKE_PREFIX_PATH" in os.environ.keys():
variables = {
"CATKIN_GLOBAL_BIN_DESTINATION": "bin",
"CATKIN_GLOBAL_LIB_DESTINATION": "lib",
"CMAKE_PREFIX_PATH_AS_IS": ";".join(os.environ["CMAKE_PREFIX_PATH"].split(os.pathsep)),
"PYTHON_INSTALL_DIR": get_python_install_dir(),
}
with open(generated_setup_util_py, "w") as f:
f.write(configure_file(os.path.join(get_cmake_path(), "templates", "_setup_util.py.in"), variables))
os.chmod(generated_setup_util_py, stat.S_IXUSR | stat.S_IWUSR | stat.S_IRUSR)
else:
sys.exit("Unable to process CMAKE_PREFIX_PATH from environment. Cannot generate environment files.")
variables = {"SETUP_FILENAME": "setup"}
with open(generated_env_sh, "w") as f:
f.write(configure_file(os.path.join(get_cmake_path(), "templates", "env.sh.in"), variables))
os.chmod(generated_env_sh, stat.S_IXUSR | stat.S_IWUSR | stat.S_IRUSR)
variables = {"SETUP_DIR": develspace}
for shell in ["sh", "bash", "zsh"]:
with open(os.path.join(develspace, "setup.%s" % shell), "w") as f:
f.write(
configure_file(os.path.join(get_cmake_path(), "templates", "setup.%s.in" % shell), variables)
)
