def write(self, location):
""" Write configuration back to a config file
"""
project_tree = self.tree.getroot()
if not project_tree:
project_tree = etree.Element("project")
self.tree = etree.ElementTree(element=project_tree)
project_tree.set("name", self.name)
for depend_elem in project_tree.findall("depends"):
project_tree.remove(depend_elem)
build_elem = etree.Element("depends")
build_elem.set("buildtime", "true")
build_elem.set("runtime", "false")
build_elem.set("testtime", "false")
build_elem.set("names", " ".join(self.build_depends))
project_tree.append(build_elem)
run_elem = etree.Element("depends")
run_elem.set("buildtime", "false")
run_elem.set("runtime", "true")
run_elem.set("testtime", "false")
run_elem.set("names", " ".join(self.run_depends))
project_tree.append(run_elem)
test_elem = etree.Element("depends")
test_elem.set("buildtime", "false")
test_elem.set("runtime", "false")
test_elem.set("testtime", "true")
test_elem.set("names", " ".join(self.test_depends))
project_tree.append(test_elem)
qisys.qixml.write(self.tree, location)
def _add_conan_package_xml(package_path, name, info, version):
""" Write an xml file to descibe the package. """
package_xml = os.path.join(package_path, "package.xml")
ui.info(" -> Create package.xml for {}".format(name))
root = etree.Element('package')
root.set("name", name)
root.set("version", version)
root.set("target", info.get("settings").get("os"))
child = etree.Element("licence", text="BSD")
root.append(child)
qisys.qixml.write(root, package_xml)
def add_package_xml(package_path, name, version, target, licence=None):
""" Write an xml file to descibe the package. """
package_xml = os.path.join(package_path, "package.xml")
ui.info(" -> Create package.xml for {} v{}".format(name, version))
root = etree.Element('package')
root.set("name", name)
root.set("version", version)
if target:
ui.info(" -> For target {}".format(target))
root.set("target", target)
if licence:
ui.info(" -> With license {}".format(licence))
child = etree.Element("licence", text=licence)
root.append(child)
qisys.qixml.write(root, package_xml)
def tree(self):
""" Tree """
tree = etree.Element("ide")
tree.set("name", self.name)
if self.path:
tree.set("path", self.path)
return tree
def tree(self):
""" Tree """
tree = etree.Element("qibuild")
tree.set("version", "1")
tree.append(self.defaults.tree())
tree.append(self.build.tree())
return tree
def tree(self):
tree = etree.Element("server")
if self.name:
tree.set("name", self.name)
access_tree = self.access.tree()
tree.append(access_tree)
return tree
def tree(self):
tree = etree.Element("build")
if self.prefix:
tree.set("prefix", self.prefix)
if self.sdk_dir:
tree.set("sdk_dir", self.sdk_dir)
return tree
def write(self, xml_path=None): # pylint: disable=too-many-locals
""" Write back the new config
"""
if not xml_path:
xml_path = get_global_cfg_path()
def get_name(x):
" helper functions to sort elements "
return x.name
qibuild_tree = etree.Element("qibuild")
qibuild_tree.set("version", "1")
defaults_tree = self.defaults.tree()
qibuild_tree.append(defaults_tree)
configs = self.configs.values()
configs.sort(key=get_name)
for config in configs:
config_tree = config.tree()
qibuild_tree.append(config_tree)
ides = self.ides.values()
ides.sort(key=get_name)
for ide in ides:
ide_tree = ide.tree()
qibuild_tree.append(ide_tree)
servers = self.servers.values()
for server in servers:
server_tree = server.tree()
qibuild_tree.append(server_tree)
worktrees = self.worktrees.values()
for worktree in worktrees:
worktree_tree = worktree.tree()
qibuild_tree.append(worktree_tree)
qisys.qixml.write(qibuild_tree, xml_path)
def tree(self):
tree = etree.Element("build")
if self.build_dir:
tree.set("build_dir", self.build_dir)
if self.sdk_dir:
tree.set("sdk_dir", self.sdk_dir)
return tree
def save(self):
""" Save the packages in the xml file """
root = etree.Element("toolchain")
tree = etree.ElementTree(root)
for package in self.packages.itervalues():
element = package.to_xml()
root.append(element)
qisys.qixml.write(tree, self.db_path)
def tree(self):
tree = etree.Element("defaults")
if self.ide:
tree.set("ide", self.ide)
env_tree = self.env.tree()
tree.append(env_tree)
cmake_tree = self.cmake.tree()
tree.append(cmake_tree)
return tree
def tree(self):
tree = etree.Element("access")
if self.root:
tree.set("root", self.root)
if self.username:
tree.set("username", self.username)
if self.password:
tree.set("password", self.password)
return tree
def tree(self):
tree = etree.Element("env")
if self.path:
tree.set("path", self.path)
if self.bat_file:
tree.set("bat_file", self.bat_file)
if self.editor:
tree.set("editor", self.editor)
return tree
def tree(self):
tree = etree.Element("config")
tree.set("name", self.name)
if self.ide:
tree.set("ide", self.ide)
env_tree = self.env.tree()
tree.append(env_tree)
cmake_tree = self.cmake.tree()
tree.append(cmake_tree)
return tree
def _write_xml(res, test, out_xml):
""" Make sure a Junit XML compatible file is written. """
# Windows output is most likely code page 850
# TODO: I need to check that, at least on Win 10
if sys.platform.startswith("win"):
encoding = "ascii"
else:
encoding = "UTF-8"
# Arbitrary limit output (~700 lines) to prevent from crashing on read
res.out = res.out[-16384:]
if six.PY3:
res.out = re.sub(r'\x1b[^m]*m', "", str(res.out))
message_as_string = " ".join(
str(x) for x in res.message if not isinstance(x, ui._Color))
else:
res.out = re.sub('\x1b[^m]*m', "", res.out)
message_as_string = " ".join(
str(x) for x in res.message if not isinstance(x, ui._Color))
try:
res.out = res.out.decode(encoding, "ignore")
message_as_string = message_as_string.decode(
encoding, "ignore")
except UnicodeDecodeError:
pass
# Make sure there are no invalid data in the XML
res.out = qisys.qixml.sanitize_xml(res.out)
if res.ok:
num_failures = "0"
else:
num_failures = "1"
root = etree.Element("testsuites")
root.set("tests", "1")
root.set("failures", num_failures)
root.set("disabled", "0")
root.set("errors", "0")
root.set("time", str(res.time))
root.set("name", "All")
test_suite = etree.SubElement(root, "testsuite")
test_suite.set("name", "test")
test_suite.set("tests", "1")
test_suite.set("failures", num_failures)
test_suite.set("disabled", "0")
test_suite.set("errors", "0")
test_suite.set("time", str(res.time))
test_case = etree.SubElement(test_suite, "testcase")
test_case.set("name", test["name"])
test_case.set("status", "run")
test_case.set("time", str(res.time))
if not res.ok:
failure = etree.SubElement(test_case, "failure")
failure.set("message", message_as_string)
failure.text = res.out
qisys.qixml.write(root, out_xml, encoding=encoding)
def tree(self):
""" Tree """
tree = etree.Element("env")
if self.path:
tree.set("path", self.path)
if self.bat_file:
tree.set("bat_file", self.bat_file)
if self.editor:
tree.set("editor", self.editor)
self.dump_vars(tree)
return tree
def convert_to_qibuild(
package,
package_metadata=None, # pylint: disable=too-many-locals
output_dir=None,
output_name=None):
""" Convert a binary package into a qiBuild package.
:param package: an instance of qitoolchain.binary_package.BinaryPackage.
:param package_metadata: a dict to override the metadata of the package,
or to provide the metadata if the could not be
read from the binary package
:param output_dir: where to put the new qiBuild package, defaults to
the basename of the binary package
:package output_name: the archive name of the qiBuild package,
computed from the metadata if not given
:param gen_cmake: whether we should try to generate a CMake module for
this package
:return: path to the converted qiBuild package
"""
metadata = package.get_metadata()
if package_metadata:
metadata.update(package_metadata)
package_name = metadata["name"]
if not output_dir:
output_dir = os.path.dirname(package.path)
if not output_name:
output_name = package_name
for key in ['version', 'revision', 'arch', 'arch_variant']:
value = metadata.get(key)
if value:
if key == 'revision':
value = "r" + value
output_name += "-" + value
output_name += ".zip"
qisys.sh.mkdir(output_dir, recursive=True)
output_path = os.path.join(output_dir, output_name)
with qisys.sh.TempDir() as work_dir:
root_dir = package.extract(work_dir)
_fix_package_tree(root_dir)
package_xml_path = os.path.join(root_dir, "package.xml")
package_xml_root = etree.Element("package")
# package_xml_tree = etree.ElementTree(package_xml_root)
package_xml_root.set("name", package_name)
version = metadata.get("version")
if version:
package_xml_root.set("version", version)
qisys.qixml.write(package_xml_root, package_xml_path)
res = qisys.archive.compress(root_dir,
algo="zip",
quiet=True,
flat=True)
qisys.sh.mv(res, output_path)
return output_path
def save(self):
""" Save the packages in the xml file """
root = etree.Element("toolchain")
if self.build_target:
root.set("target", self.build_target)
ui.debug("Save target in database xml", self.build_target, "in",
self.db_path)
tree = etree.ElementTree(root)
for package in self.packages.values():
element = package.to_xml()
root.append(element)
qisys.qixml.write(tree, self.db_path)
def save(self):
""" Save the packages in the xml file """
root = etree.Element("toolchain")
tree = etree.ElementTree(root)
for package in self.packages.itervalues():
element = etree.Element("package")
element.set("name", package.name)
if package.path:
element.set("path", package.path)
if package.version:
element.set("version", package.version)
if package.url:
element.set("url", package.url)
if package.toolchain_file:
element.set("toolchain_file", package.toolchain_file)
if package.sysroot:
element.set("sysroot", package.sysroot)
if package.cross_gdb:
element.set("cross_gdb", package.cross_gdb)
root.append(element)
qisys.qixml.write(tree, self.db_path)
def dump_manifest_config(self):
""" Save the manifest config in .qi/manifest.xml """
root = etree.Element("worktree")
manifest_elem = etree.SubElement(root, "manifest")
manifest_elem.set("url", self.manifest.url)
manifest_elem.set("branch", self.manifest.branch)
if self.manifest.groups is not None:
manifest_elem.set("groups", " ".join(self.manifest.groups))
if self.manifest.review:
manifest_elem.set("review", "true")
else:
manifest_elem.set("review", "false")
tree = etree.ElementTree(root)
qisys.qixml.write(tree, self.manifest_xml)
def to_xml(self):
""" Return an ``etree.Element`` representing this package """
element = etree.Element("package")
element.set("name", self.name)
if self.path:
element.set("path", self.path)
if self.version:
element.set("version", self.version)
if self.url:
element.set("url", self.url)
if self.toolchain_file:
element.set("toolchain_file", self.toolchain_file)
if self.sysroot:
element.set("sysroot", self.sysroot)
if self.cross_gdb:
element.set("cross_gdb", self.cross_gdb)
return element
def tree(self):
tree = etree.Element("config")
tree.set("name", self.name)
if self.ide:
tree.set("ide", self.ide)
env_tree = self.env.tree()
tree.append(env_tree)
cmake_tree = self.cmake.tree()
tree.append(cmake_tree)
if self.toolchain:
toolchain_elem = etree.SubElement(tree, "toolchain")
toolchain_elem.text = self.toolchain
profiles_elem = etree.SubElement(tree, "profiles")
for profile in self.profiles:
profile_elem = etree.SubElement(profiles_elem, "profile")
profile_elem.text = profile
return tree
def tree(self):
tree = etree.Element("worktree")
tree.set("path", self.path)
return tree
def tree(self):
tree = etree.Element("build")
if self.incredibuild:
tree.set("incredibuild", "true")
return tree
def tree(self):
tree = etree.Element("defaults")
if self.config:
tree.set("config", self.config)
return tree
def tree(self):
tree = etree.Element("worktree")
tree.set("path", self.path)
tree.append(self.defaults.tree())
return tree
def tree(self):
tree = etree.Element("cmake")
if self.generator:
tree.set("generator", self.generator)
return tree
