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 __init__(self):
self.tree = etree.ElementTree()
self.defaults = Defaults()
# Set by self.read_local_config()
self.local = LocalSettings()
# A dict of possible configs
self.configs = dict()
# A dict of possible IDE
self.ides = dict()
# A dicf of server name -> access:
self.servers = dict()
# Active env:
self.env = Env()
# Active IDE:
self.ide = None
# Active CMake config:
self.cmake = CMake()
# A dict of worktree, key being the path
self.worktrees = dict()
def __init__(self):
""" ProjectConfig Init """
self.name = None
self.build_depends = set()
self.run_depends = set()
self.test_depends = set()
self.tree = etree.ElementTree()
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 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 convert_to_qibuild(package,
package_metadata=None,
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 binaray package
:package output_name: the archive name of the qiBuild package,
computed from the metadat 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 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 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 __init__(self):
self.name = None
self.build_depends = set()
self.run_depends = set()
self.test_depends = set()
self.tree = etree.ElementTree()
