def get_toolchain(args):
"""
Get the toolchain to use.
If we are inside a build worktree, return the default toolchain is this worktree.
"""
if args.toolchain_name:
return qitoolchain.get_toolchain(args.toolchain_name)
config = args.config
if not config:
try:
build_worktree = qibuild.parsers.get_build_worktree(args)
active_build_config = build_worktree.build_config.active_build_config
if active_build_config:
config = active_build_config.toolchain
else:
config = None
except qisys.worktree.NotInWorkTree:
config = None
if not config:
mess = "Could not find which config to use.\n"
mess += "(not in a work tree or no default config in "
mess += "current worktree configuration)\n"
mess += "Please specify a configuration with -c, --config \n"
mess += "or a toolchain name with -t, --toolchain"
raise Exception(mess)
qibuild_cfg = qibuild.config.QiBuildConfig()
qibuild_cfg.read()
build_config = qibuild_cfg.configs.get(config)
if not build_config:
raise Exception("No such config: %s" % config)
tc_name = build_config.toolchain
if not tc_name:
raise Exception("config %s has no toolchain" % config)
return qitoolchain.get_toolchain(tc_name)
def do(args):
"""Main entry point"""
worktree = args.worktree
if not worktree:
worktree = os.getcwd()
if args.config:
# Just make sure the user choose a valid default toolchain
qitoolchain.get_toolchain(args.config)
worktree = qibuild.sh.to_native_path(worktree)
parent_worktree = qisrc.worktree.guess_worktree(worktree)
if parent_worktree:
if parent_worktree != worktree:
# Refuse to create nested worktrees
ui.error("""A qi worktree already exists in {parent_worktree}
Refusing to create a nested worktree in {worktree}
Use:
qibuild init -f -w {parent_worktree}
If you want to re-initialize the worktree in {parent_worktree}
""".format(worktree=worktree, parent_worktree=parent_worktree))
sys.exit(1)
else:
# Refuse to re-initalize the worktree unless "-f" is given
if not args.force:
ui.warning("There is already a worktree in", worktree, "\n"
"Use --force if you want to re-initialize this worktree")
return
qibuild.toc.create(worktree, force=args.force)
# User maybe re-running qibuild init because it has a
# bad default exception ...
try:
toc = qibuild.toc.toc_open(worktree)
except qibuild.toc.WrongDefaultException:
pass
toc_cfg_path = os.path.join(worktree, ".qi", "qibuild.xml")
qibuild_cfg = qibuild.config.QiBuildConfig()
qibuild_cfg.read()
qibuild_cfg.read_local_config(toc_cfg_path)
qibuild_cfg.local.defaults.config = args.config
qibuild_cfg.write_local_config(toc_cfg_path)
# Safe to be called now that we've created it
# and that we know we don't have a wrong defaut config:
toc = qibuild.toc.toc_open(worktree)
if not args.interactive:
return
qibuild.wizard.run_config_wizard(toc)
def do(args):
"""Main entry point
"""
feed = args.feed
tc_name = args.name
if tc_name:
toolchain = qitoolchain.get_toolchain(tc_name)
if not feed:
feed = toolchain.feed_url
if not feed:
mess = "Could not find feed for toolchain %s\n" % tc_name
mess += "Please check configuration or " \
"specifiy a feed on the command line\n"
raise Exception(mess)
toolchain.update(feed)
else:
tc_names = qitoolchain.get_tc_names()
for i, tc_name in enumerate(tc_names, start=1):
toolchain = qitoolchain.toolchain.Toolchain(tc_name)
tc_feed = toolchain.feed_url
if not tc_feed:
ui.warning("No feed found for %s, skipping" % tc_name)
continue
ui.info(ui.green, "*", ui.reset, "(%i/%i)" % (i, len(tc_names)),
ui.green, "Updating", ui.blue, tc_name)
toolchain.update(tc_feed)
def do(args):
"""Main entry point
"""
feed = args.feed
tc_name = args.name
dry_run = args.dry_run
if tc_name:
toolchain = qitoolchain.get_toolchain(tc_name)
if not feed:
feed = qitoolchain.toolchain.get_tc_feed(tc_name)
if not feed:
mess = "Could not find feed for toolchain %s\n" % tc_name
mess += "Pleas check configuration or specifiy a feed on the command line\n"
raise Exception(mess)
ui.info(ui.green, "Updating toolchain", tc_name, "with", feed)
toolchain.parse_feed(feed, dry_run=dry_run)
else:
tc_names = qitoolchain.get_tc_names()
i = 0
for tc_name in tc_names:
i += 1
tc_feed = qitoolchain.toolchain.get_tc_feed(tc_name)
ui.info(ui.green, "*", ui.reset, "(%i/%i)" % (i, len(tc_names)),
ui.green, "Updating", ui.blue, tc_name)
if not tc_feed:
ui.warning("No feed found for %s, skipping" % tc_name)
continue
ui.info(ui.green, "Reading", tc_feed)
toolchain = qitoolchain.Toolchain(tc_name)
toolchain.parse_feed(tc_feed, dry_run=dry_run)
def get_toolchain_binary_paths(build_config):
""" Get the toolchain of the build_config and return the PATH of every bin packages as a string """
bins = []
if build_config:
toolchain = None
try:
if hasattr(build_config, 'toolchain'):
toolchain = build_config.toolchain
else:
# When called from qibuildfarm.release.functions (ie: build_config is the build_config name as string)
from qibuild.config import QiBuildConfig
from qitoolchain import get_toolchain
qibuild_cfg = QiBuildConfig()
qibuild_cfg.read()
qibuild_config = qibuild_cfg.configs.get(build_config)
if qibuild_config:
toolchain = get_toolchain(qibuild_config.toolchain)
if toolchain:
for pkg in toolchain.packages:
bin_dir = os.path.join(pkg.path, 'bin')
if os.path.isdir(bin_dir):
bins.append(bin_dir)
except Exception:
pass
return os.pathsep.join(bins)
def do(args):
""" Main entry point """
feed = args.feed
tc_name = args.name
if tc_name:
toolchain = qitoolchain.get_toolchain(tc_name)
if not feed:
feed = toolchain.feed_url
if not feed:
mess = "Could not find feed for toolchain %s\n" % tc_name
mess += "Please check configuration or " \
"specifiy a feed on the command line\n"
raise Exception(mess)
toolchain.update(feed, branch=args.branch, name=args.feed_name)
else:
tc_names = qitoolchain.get_tc_names()
tc_with_feed = [x for x in tc_names if qitoolchain.toolchain.Toolchain(x).feed_url]
tc_without_feed = list(set(tc_names) - set(tc_with_feed))
for i, tc_name in enumerate(tc_with_feed, start=1):
toolchain = qitoolchain.toolchain.Toolchain(tc_name)
tc_feed = toolchain.feed_url
ui.info(ui.green, "*", ui.reset, "(%i/%i)" % (i, len(tc_with_feed)),
ui.green, "Updating", ui.blue, tc_name, ui.reset, "with", ui.green,
tc_feed)
toolchain.update(tc_feed)
if tc_without_feed:
ui.info("These toolchains will be skipped because they have no feed:", ", ".join(tc_without_feed))
def do(args):
""" Main entry point
"""
dry_run = args.dry_run
tc = qitoolchain.get_toolchain(args.name)
tc.clean_cache(dry_run=dry_run)
def do(args):
""" Main entry point """
force_rm = args.force_remove
tc = qitoolchain.get_toolchain(args.name)
ui.info(ui.green, "Removing toolchain", ui.blue, tc.name)
tc.remove(force_remove=force_rm)
ui.info(ui.green, "done")
def add_package(self, name, package_name, package_version="r1"):
toolchain = qitoolchain.get_toolchain(name)
package_path = self.tmp.mkdir(package_name)
package = qitoolchain.qipackage.QiPackage(package_name, package_version)
package.path = package_path.strpath
toolchain.add_package(package)
return package
def do(args):
""" Main entry point """
toolchain = qitoolchain.get_toolchain(args.name)
svn_packages = list()
for package in toolchain.packages:
svn_dir = os.path.join(package.path, ".svn")
if os.path.exists(svn_dir):
svn_packages.append(package)
not_clean = list()
for i, svn_package in enumerate(svn_packages, start=1):
to_write = "Checking (%d/%d) " % (i, len(svn_packages))
sys.stdout.write(to_write + "\r")
sys.stdout.flush()
svn = qisrc.svn.Svn(svn_package.path)
_rc, out = svn.call("status", raises=False)
if out:
not_clean.append((svn_package.name, out))
if not not_clean:
ui.info("\n", ui.green, "All OK")
sys.exit(0)
ui.warning("Some svn packages are not clean")
for name, message in not_clean:
ui.info(ui.green, "*", ui.reset, ui.blue, name)
ui.info(message)
sys.exit(1)
def test_simple(qitoolchain_action):
qitoolchain_action("create", "foo")
word_package = qitoolchain_action.get_test_package("world")
qitoolchain_action("add-package", "-c", "foo", word_package)
tc = qitoolchain.get_toolchain("foo")
world_package = tc.packages[0]
assert world_package.name == "world"
assert world_package.path
def toolchain(self):
""" The current toolchain, either set by the user from the command
line or read from the local qibuild settings
"""
if self.active_config:
return qitoolchain.get_toolchain(self.active_config)
return None
def do(args):
""" Main method """
if args.name:
tc_names = [args.name]
else:
tc_names = qitoolchain.get_tc_names()
for tc_name in tc_names:
toolchain = qitoolchain.get_toolchain(tc_name)
ui.info(str(toolchain))
def do(args):
""" Main entry point """
tc = qitoolchain.get_toolchain(args.name)
if args.force:
ui.info(ui.green, "Removing toolchain", ui.blue, tc.name)
tc.remove()
ui.info(ui.green, "done")
else:
ui.info("Would remove toolchain", ui.blue, tc.name)
def test_simple(qitoolchain_action):
""" Test Simple """
qitoolchain_action("create", "foo")
qibuild.config.add_build_config("foo", toolchain="foo")
word_package = qitoolchain_action.get_test_package("world")
qitoolchain_action("add-package", "-c", "foo", word_package)
tc = qitoolchain.get_toolchain("foo")
world_package = tc.packages[0]
assert world_package.name == "world"
assert world_package.path
def do(args):
""" Main method """
tc_names = qitoolchain.get_tc_names()
tc_name = args.name
if tc_name:
toolchain = qitoolchain.get_toolchain(tc_name)
print toolchain
else:
for tc_name in tc_names:
toolchain = qitoolchain.Toolchain(tc_name)
print toolchain
print
def test_legacy_happy_path(tmpdir, qitoolchain_action):
qitoolchain_action("create", "foo")
qibuild.config.add_build_config("foo", toolchain="foo")
world = tmpdir.mkdir("world")
world.ensure("include", "world.h", file=True)
world.ensure("lib", "libworld.so", file=True)
archive = qisys.archive.compress(world.strpath)
qitoolchain_action("add-package", "-c", "foo", "--name", "world", archive)
tc = qitoolchain.get_toolchain("foo")
world_package = tc.get_package("world")
assert os.path.exists(os.path.join(world_package.path, "include", "world.h"))
assert os.path.exists(os.path.join(world_package.path, "lib", "libworld.so"))
def do(args):
""" Remove a project from a toolchain
- Check that there is a current toolchain
- Remove the package from the toolchain
"""
package_name = args.package_name
tc = qitoolchain.get_toolchain(args)
LOGGER.info("Removing package %s from toolchain %s", package_name, tc.name)
tc.remove_package(package_name)
def do(args):
""" Remove a project from a toolchain
- Check that there is a current toolchain
- Remove the package from the toolchain
"""
package_name = args.package_name
tc_name = qitoolchain.toolchain_name_from_args(args)
tc = qitoolchain.get_toolchain(tc_name)
ui.info(ui.green, "Removing package", ui.blue, package_name,
ui.green, "from toolchain", ui.blue, tc.name)
tc.remove_package(package_name)
def test_simple(qitoolchain_action, tmpdir, toolchains):
this_dir = os.path.dirname(__file__)
json_c_bz2_path_src = os.path.join(this_dir, "packages", "json-c-0.9.tbz2")
json_c_bz2_path = tmpdir.join("json-c-0.9.tbz2").strpath
qisys.sh.install(json_c_bz2_path_src, json_c_bz2_path)
res = qitoolchain_action("convert-package",
"--name", "json-c",
"--batch", json_c_bz2_path)
qitoolchain_action("create", "test")
qitoolchain_action("add-package", "--config", "test", res)
toolchain = qitoolchain.get_toolchain("test")
assert toolchain.get_package("json-c")
def read_local_settings(self):
""" Read ``<worktree>/.qi/qibuild.xml`` """
local_settings = qibuild.config.LocalSettings()
tree = qisys.qixml.read(self.build_worktree.qibuild_xml)
local_settings.parse(tree)
default_config = local_settings.defaults.config
if not default_config:
return
try:
qitoolchain.get_toolchain(default_config)
except Exception:
mess = """ \
Incorrect config detected for worktree in {build_worktree.root}
Default config set in .qi/qibuild.xml is {default_config}
but this does not match any toolchain name
"""
mess = mess.format(build_worktree=self.build_worktree,
default_config=default_config)
raise Exception(mess)
self._default_config = default_config
self.qibuild_cfg.set_active_config(default_config)
self.set_active_config(default_config)
def toolchain(self):
""" The current toolchain, either set by the user from the command
line or read from the local qibuild settings
"""
if self._toolchain:
return self._toolchain
if self.active_build_config:
toolchain_name = self.active_build_config.toolchain
if toolchain_name:
self._toolchain = qitoolchain.get_toolchain(toolchain_name)
return self._toolchain
else:
return None
def test_legacy_happy_path(tmpdir, qitoolchain_action):
qitoolchain_action("create", "foo")
qibuild.config.add_build_config("foo", toolchain="foo")
world = tmpdir.mkdir("world")
world.ensure("include", "world.h", file=True)
world.ensure("lib", "libworld.so", file=True)
archive = qisys.archive.compress(world.strpath)
qitoolchain_action("add-package", "-c", "foo", "--name", "world", archive)
tc = qitoolchain.get_toolchain("foo")
world_package = tc.get_package("world")
assert os.path.exists(
os.path.join(world_package.path, "include", "world.h"))
assert os.path.exists(
os.path.join(world_package.path, "lib", "libworld.so"))
def toolchain(self):
""" The current toolchain, either set by the user from the command
line or read from the local qibuild settings
"""
if self._toolchain:
return self._toolchain
if self.active_build_config:
toolchain_name = self.active_build_config.toolchain
if toolchain_name:
self._toolchain = qitoolchain.get_toolchain(toolchain_name)
return self._toolchain
else:
return None
def do(args):
""" Main entry point """
tc = qitoolchain.get_toolchain(args.name, args.ignore)
if tc:
if args.force:
ui.info(ui.green, "Removing toolchain", ui.blue, tc.name)
tc.remove()
ui.info(ui.green, "done")
else:
ui.info("Would remove toolchain", ui.blue, tc.name)
ui.info("Use --force to actually remove it.")
return
else:
ui.info("Would remove toolchain", ui.blue, args.name)
ui.info("This toolchain does not exists.")
return
def do(args):
""" Main entry point """
try:
tc = qitoolchain.get_toolchain(args.name)
except Exception:
if args.force:
return
else:
raise
if args.force:
ui.info(ui.green, "Removing toolchain", ui.blue, tc.name)
tc.remove()
ui.info(ui.green, "done")
else:
ui.info("Would remove toolchain", ui.blue, tc.name)
ui.info("Use --force to actually remove it.")
def do(args):
""" Main entry point """
tc = qitoolchain.get_toolchain(args.name, args.ignore)
if tc:
if args.force:
ui.info(ui.green, "Removing toolchain", ui.blue, tc.name)
tc.remove()
ui.info(ui.green, "done")
else:
ui.info("Would remove toolchain", ui.blue, tc.name)
ui.info("Use --force to actually remove it.")
return
else:
ui.info("Would remove toolchain", ui.blue, args.name)
ui.info("This toolchain does not exists.")
return
def test_simple(qitoolchain_action, tmpdir, toolchains):
""" Test Simple """
this_dir = os.path.dirname(__file__)
json_c_bz2_path_src = os.path.join(this_dir, "packages", "json-c-0.9.tbz2")
json_c_bz2_path = tmpdir.join("json-c-0.9.tbz2").strpath
qisys.sh.install(json_c_bz2_path_src, json_c_bz2_path)
res = qitoolchain_action(
"convert-package",
"--name",
"json-c",
"--batch",
json_c_bz2_path
)
qitoolchain_action("create", "test")
qibuild.config.add_build_config("test", toolchain="test")
qitoolchain_action("add-package", "--config", "test", res)
toolchain = qitoolchain.get_toolchain("test")
assert toolchain.get_package("json-c")
def test_flags_package(tmpdir, qitoolchain_action):
""" Test Flags Package """
qitoolchain_action("create", "foo")
c11_flags = tmpdir.mkdir("c++11-flags")
c11_flags.join("config.cmake").write("""\nset(CMAKE_CXX_FLAGS "-std=gnu++11")\n""")
c11_flags.join("package.xml").write("""\n<package name="c++11-flags" toolchain_file="config.cmake" />\n""")
flags_package = tmpdir.join("c++11-flags.zip")
qisys.archive.compress(c11_flags.strpath, output=flags_package.strpath, flat=True)
qitoolchain_action("add-package", "--toolchain", "foo", flags_package.strpath)
foo_toolchain = qitoolchain.get_toolchain("foo")
tc_file = foo_toolchain.toolchain_file
with open(tc_file, "r") as fp:
contents = fp.read()
included_file = None
for line in contents.splitlines():
match = re.match(r'include\("(.*)"\)', line)
if match:
included_file = match.groups()[0]
assert os.path.exists(included_file)
def do(args):
""" Main entry point """
tc = qitoolchain.get_toolchain(args.name)
if args.force:
ui.info(ui.green, "Removing toolchain", ui.blue, tc.name)
tc.remove()
ui.info(ui.green, "done")
else:
ui.info("Would remove toolchain", ui.blue, tc.name)
ui.info("Use --force to actually remove it.")
return
qibuild_cfg = qibuild.config.QiBuildConfig()
qibuild_cfg.read()
build_configs = qibuild_cfg.configs.values()
for build_config in build_configs:
if build_config.toolchain == tc.name:
build_config.toolchain = None
qibuild_cfg.write()
def add_package(self, name, package_name, package_version="r1",
build_depends=None, run_depends=None, test_depends=None):
""" Add a Package """
toolchain = qitoolchain.get_toolchain(name)
package_path = self.tmp.mkdir(package_name)
package = qitoolchain.qipackage.QiPackage(package_name, package_version)
package.path = package_path.strpath
package.build_depends = build_depends
package.run_depends = run_depends
package.test_depends = test_depends
package_xml = self.tmp.join(package_name, "package.xml")
xml_elem = qisys.qixml.etree.Element("package")
xml_elem.set("name", package_name)
if package_version:
xml_elem.set("version", package_version)
qibuild.deps.dump_deps_to_xml(package, xml_elem)
qisys.qixml.write(xml_elem, package_xml.strpath)
toolchain.add_package(package)
return package
def do(args):
""" Main entry point """
tc = qitoolchain.get_toolchain(args.name)
if args.force:
ui.info(ui.green, "Removing toolchain", ui.blue, tc.name)
tc.remove()
ui.info(ui.green, "done")
else:
ui.info("Would remove toolchain", ui.blue, tc.name)
ui.info("Use --force to actually remove it.")
return
qibuild_cfg = qibuild.config.QiBuildConfig()
qibuild_cfg.read()
build_configs = qibuild_cfg.configs.values()
for build_config in build_configs:
if build_config.toolchain == tc.name:
build_config.toolchain = None
qibuild_cfg.write()
def add_package(self, name, package_name, package_version="r1",
build_depends=None, run_depends=None, test_depends=None,
host_depends=None):
toolchain = qitoolchain.get_toolchain(name)
package_path = self.tmp.mkdir(package_name)
package = qitoolchain.qipackage.QiPackage(package_name, package_version)
package.path = package_path.strpath
# Make sure self.*_depends are sets
for dep_type in ["build", "run", "test", "host"]:
attr_name = "%s_depends" % dep_type
value = locals()[attr_name]
if value:
setattr(package, attr_name, set(value))
else:
setattr(package, attr_name, set())
package.write_package_xml()
toolchain.add_package(package)
return package
def test_path_conf_contains_toolchain_paths(qibuild_action, toolchains):
toolchains.create("foo")
qibuild.config.add_build_config("foo", toolchain="foo")
toolchains.add_package("foo", "bar")
foo_tc = qitoolchain.get_toolchain("foo")
bar_path = foo_tc.get_package("bar").path
qibuild_action.add_test_project("hello")
qibuild_action.add_test_project("world")
build_woktree = TestBuildWorkTree()
build_woktree.build_config.set_active_config("foo")
qibuild_action("configure", "hello", "--config", "foo")
world_proj = build_woktree.get_build_project("world")
hello_proj = build_woktree.get_build_project("hello")
path_conf = os.path.join(hello_proj.sdk_directory, "share", "qi", "path.conf")
with open(path_conf, "r") as fp:
contents = fp.readlines()
sdk_dirs = [x.strip() for x in contents]
assert hello_proj.sdk_directory in sdk_dirs
assert world_proj.sdk_directory in sdk_dirs
assert bar_path in sdk_dirs
def test_path_conf_contains_toolchain_paths(qibuild_action, toolchains):
toolchains.create("foo")
qibuild.config.add_build_config("foo", toolchain="foo")
toolchains.add_package("foo", "bar")
foo_tc = qitoolchain.get_toolchain("foo")
bar_path = foo_tc.get_package("bar").path
qibuild_action.add_test_project("hello")
qibuild_action.add_test_project("world")
build_woktree = TestBuildWorkTree()
build_woktree.build_config.set_active_config("foo")
qibuild_action("configure", "hello", "--config", "foo")
world_proj = build_woktree.get_build_project("world")
hello_proj = build_woktree.get_build_project("hello")
path_conf = os.path.join(hello_proj.sdk_directory, "share", "qi", "path.conf")
with open(path_conf, "r") as fp:
contents = fp.readlines()
sdk_dirs = [x.strip() for x in contents]
assert hello_proj.sdk_directory in sdk_dirs
assert world_proj.sdk_directory in sdk_dirs
assert bar_path in sdk_dirs
def do(args):
""" Add a package to a toolchain
- Check that there is a current toolchain
- Add the package to the cache
- Add the package from cache to toolchain
"""
package_name = args.package_name
package_path = args.package_path
tc = qitoolchain.get_toolchain(args)
# extract it to the default packages path of the toolchain
tc_packages_path = qitoolchain.toolchain.get_default_packages_path(tc.name)
dest = os.path.join(tc_packages_path, package_name)
qibuild.sh.rm(dest)
with qibuild.sh.TempDir() as tmp:
extracted = qibuild.archive.extract(package_path, tmp)
qibuild.sh.install(extracted, dest, quiet=True)
package = qitoolchain.Package(package_name, dest)
tc.add_package(package)
def get_toolchain(args):
""" Get the toolchain to use.
If we are inside a build worktree, return the default
toolchain is this worktree
"""
config = args.config
if not config:
try:
build_worktree = qibuild.parsers.get_build_worktree(args)
config = build_worktree.build_config.active_config
except qisys.worktree.NotInWorkTree:
config = None
if not config:
mess = "Could not find which config to use.\n"
mess += "(not in a work tree or no default config in "
mess += "current worktree configuration)\n"
mess += "Please specify a configuration with -c \n"
raise Exception(mess)
return qitoolchain.get_toolchain(config)
def do(args):
""" Add a package to a toolchain
- Check that there is a current toolchain
- Add the package to the cache
- Add the package from cache to toolchain
"""
package_name = args.package_name
package_path = args.package_path
tc_name = qitoolchain.toolchain_name_from_args(args)
tc = qitoolchain.get_toolchain(tc_name)
# extract it to the default packages path of the toolchain
tc_packages_path = qitoolchain.toolchain.get_default_packages_path(tc.name)
dest = os.path.join(tc_packages_path, package_name)
qisys.sh.rm(dest)
with qisys.sh.TempDir() as tmp:
extracted = qisys.archive.extract(package_path, tmp)
qisys.sh.install(extracted, dest, quiet=True)
package = qitoolchain.Package(package_name, dest)
tc.add_package(package)
def test_flags_package(tmpdir, qitoolchain_action):
""" Test Flags Package """
qitoolchain_action("create", "foo")
c11_flags = tmpdir.mkdir("c++11-flags")
c11_flags.join("config.cmake").write(
"""\nset(CMAKE_CXX_FLAGS "-std=gnu++11")\n""")
c11_flags.join("package.xml").write(
"""\n<package name="c++11-flags" toolchain_file="config.cmake" />\n""")
flags_package = tmpdir.join("c++11-flags.zip")
qisys.archive.compress(c11_flags.strpath,
output=flags_package.strpath,
flat=True)
qitoolchain_action("add-package", "--toolchain", "foo",
flags_package.strpath)
foo_toolchain = qitoolchain.get_toolchain("foo")
tc_file = foo_toolchain.toolchain_file
with open(tc_file, "r") as fp:
contents = fp.read()
included_file = None
for line in contents.splitlines():
match = re.match(r'include\("(.*)"\)', line)
if match:
included_file = match.groups()[0]
assert os.path.exists(included_file)
def do(args):
""" Main entry point
"""
dry_run = args.dry_run
tc = qitoolchain.get_toolchain(args.name)
tc_cache = tc.cache
dirs_to_rm = os.listdir(tc_cache)
dirs_to_rm = [os.path.join(tc_cache, x) for x in dirs_to_rm]
dirs_to_rm = [x for x in dirs_to_rm if os.path.isdir(x)]
num_dirs = len(dirs_to_rm)
ui.info(ui.green, "Cleaning cache for", ui.blue, tc.name)
if dry_run:
print "Would remove %i packages" % num_dirs
print "Use -f to proceed"
return
for (i, dir_to_rm) in enumerate(dirs_to_rm):
sys.stdout.write("Removing package %i / %i\r" % ((i + 1), num_dirs))
sys.stdout.flush()
qisys.sh.rm(dir_to_rm)
ui.info(ui.green, "done")
def do(args):
""" Main entry point
"""
tc = qitoolchain.get_toolchain(args.name)
tc.clean_cache()
def configure(workspace, build_config, build_type="Release"):
build_dir = os.path.join(workspace, "build-%s" % build_type)
qisys.sh.mkdir(build_dir, recursive=True)
platform = get_platform(build_config)
toolchain = qitoolchain.get_toolchain(build_config.toolchain)
toolchain.update()
ui.info(str(toolchain))
toolchain_path = toolchain.db.db_path
cmake_args = list()
cmake_args.append("-Wno-dev")
cmake_args.append("-DCMAKE_BUILD_TYPE=%s" % build_type)
# Find Boost in toolchain
boost_path = toolchain.get_package("boost", raises=True).path
boost_root = qisys.sh.to_posix_path(boost_path)
cmake_args.append("-DBOOST_ROOT=%s" % boost_root)
# our boost package assumes boost libs are shared:
cmake_args.append("-DBoost_USE_STATIC_LIBS=OFF")
# Find Eigen3 in toolchain
eigen_path = toolchain.get_package("eigen3", raises=True).path
eigen_root = qisys.sh.to_posix_path(eigen_path)
cmake_args.append("-DEIGEN_ROOT=%s" % eigen_root)
# Find console_bridge in toolchain
console_bridge_path = toolchain.get_package("console_bridge",
raises=True).path
console_bridge_dir = os.path.join(console_bridge_path, "share", "cmake",
"console_bridge")
console_bridge_dir = qisys.sh.to_posix_path(console_bridge_dir)
cmake_args.append("-Dconsole_bridge_DIR=%s" % console_bridge_dir)
# Need an absolute, non-empty path for CMAKE_INSTALL_PREFIX
cmake_args.append("-DCMAKE_INSTALL_PREFIX=/prefix")
# Don't bother building tests:
cmake_args.append("-DCATKIN_ENABLE_TESTING=OFF")
if platform == "linux":
cmake_include_path = list()
cmake_lib_path = list()
# Need to find lz4 and bz2 (deps of rosbag) in toolchain:
for dep in ["bzip2", "lz4"]:
package_path = toolchain.get_package(dep, raises=True).path
include_path = os.path.join(package_path, "include")
lib_path = os.path.join(package_path, "lib")
cmake_include_path.append(include_path)
cmake_lib_path.append(lib_path)
cmake_args.append("-DCMAKE_INCLUDE_PATH=%s" %
";".join(cmake_include_path))
cmake_args.append("-DCMAKE_LIBRARY_PATH=%s" % ";".join(cmake_lib_path))
cmake_args.append("-DCMAKE_CXX_FLAGS=-std=gnu++11")
if platform == "windows":
cmake_args.append("-DCMAKE_DEBUG_POSTFIX=_d")
cmake_flags = (
# our boost package assumes boost libs are shared:
("BOOST_ALL_DYN_LINK", "1"),
# ros/time.h uses #ifdef WIN32 instead of #ifdef _WIN32 ...
("WIN32", "1"),
)
cmake_flags_arg = "-DCMAKE_CXX_FLAGS="
for key, value in cmake_flags:
cmake_flags_arg += "/D%s=%s " % (key, value)
# re-add some flags
# (they get removed when we set CMAKE_CXX_FLAGS
# for some reason)
# /EHsc is required for exceptions, and
# /MD for linking with the 'dynamic' runtime
cmake_flags_arg += "/EHsc /MD"
cmake_args.append(cmake_flags_arg)
if platform != "linux":
# Ninja may not work on linux ...
cmake_args.append("-GNinja")
cmake_args.append("../src")
build_env = get_build_env(build_config)
qisys.command.call(["cmake"] + cmake_args, env=build_env, cwd=build_dir)