Temp commit - Adding pkg_rules support

Author: nradakovic

MODULE.bazel

@@ -45,3 +45,4 @@ bazel_dep(name = "tar.bzl", version = "0.7.0")
 bazel_dep(name = "score_tooling", version = "1.1.2")
 bazel_dep(name = "aspect_rules_lint", version = "2.3.0")
 bazel_dep(name = "buildifier_prebuilt", version = "8.5.1")
+bazel_dep(name = "rules_pkg", version = "1.2.0")

MODULE.bazel.lock

@@ -0,0 +1,109 @@
+"""
+Supports QNX FS image generation from rules_pkg providers. Filters rules_pkg
+targets from srcs and generates QNX build file entries from their contents.
+"""
+
+load("@bazel_skylib//lib:paths.bzl", "paths")
+load("@rules_pkg//pkg:providers.bzl", "PackageDirsInfo", "PackageFilegroupInfo", "PackageFilesInfo", "PackageSymlinkInfo")
+
+_DEFAULT_FILE_MODE = "0644"
+_DEFAULT_DIR_MODE = "0755"
+_DEFAULT_LINK_MODE = "0777"
+_DEFAULT_UID = 0
+_DEFAULT_GID = 0
+_FIXED_MTIME = "2021-03-22-20:20:00"
+
+def _get_pkg_attr(attributes, field, default):
+    """Get a single field from a pkg_attributes dict, defaulting if absent or None."""
+    if attributes == None:
+        return default
+    value = attributes.get(field)
+    if value == None:
+        return default
+    return value
+
+def qnx_build_inputs_from_pkg(ctx, pkg_srcs, per_file_attrs = None):
+    """Generate QNX build file and collect contents from rules_pkg sources.
+
+    Args:
+        ctx: Rule context.
+        pkg_srcs: List of targets providing rules_pkg providers.
+        per_file_attrs: Optional list of extra attributes for file entries
+            (e.g. ["-optional"]).
+    Returns:
+        fs_contents: List of Files to include in the image.
+        build_file: Generated QNX build file.
+    """
+    content = "[mtime={}]\n".format(_FIXED_MTIME)
+    fs_contents = []
+    extra_attrs_str = ""
+    if per_file_attrs:
+        extra_attrs_str = " ".join(per_file_attrs) + " "
+
+    for src in pkg_srcs:
+        # Normalize to lists of (provider, label) tuples regardless of source type
+        if PackageFilegroupInfo in src:
+            pfgi = src[PackageFilegroupInfo]
+            files_list = pfgi.pkg_files
+            dirs_list = pfgi.pkg_dirs
+            symlinks_list = pfgi.pkg_symlinks
+        elif (
+            PackageFilesInfo in src or
+            PackageDirsInfo in src or
+            PackageSymlinkInfo in src
+        ):
+            # src.label is included in the manually-constructed tuples to match the (provider, label) structure from PackageFilegroupInfo.
+            files_list = [(src[PackageFilesInfo], src.label)] if PackageFilesInfo in src else []
+            dirs_list = [(src[PackageDirsInfo], src.label)] if PackageDirsInfo in src else []
+            symlinks_list = [(src[PackageSymlinkInfo], src.label)] if PackageSymlinkInfo in src else []
+        else:
+            fail("Target {} does not provide any rules_pkg provider".format(src.label))
+
+        # Process directories
+        for pdi, _label in dirs_list:
+            mode = _get_pkg_attr(pdi.attributes, "mode", _DEFAULT_DIR_MODE)
+            uid = _get_pkg_attr(pdi.attributes, "uid", _DEFAULT_UID)
+            gid = _get_pkg_attr(pdi.attributes, "gid", _DEFAULT_GID)
+            for dir_path in pdi.dirs:
+                dir_path = paths.normalize(dir_path)
+                content += "[type=dir uid={} gid={} perms={}] /{}\n".format(
+                    uid,
+                    gid,
+                    mode,
+                    dir_path,
+                )
+
+        # Process files
+        for pfi, _label in files_list:
+            mode = _get_pkg_attr(pfi.attributes, "mode", _DEFAULT_FILE_MODE)
+            uid = _get_pkg_attr(pfi.attributes, "uid", _DEFAULT_UID)
+            gid = _get_pkg_attr(pfi.attributes, "gid", _DEFAULT_GID)
+            for dest, src_file in sorted(pfi.dest_src_map.items()):
+                content += "[{}uid={} gid={} perms={}] /{}={}\n".format(
+                    extra_attrs_str,
+                    uid,
+                    gid,
+                    mode,
+                    dest,
+                    src_file.path,
+                )
+                fs_contents.append(src_file)
+
+        # Process symlinks
+        for psi, _label in symlinks_list:
+            mode = _get_pkg_attr(psi.attributes, "mode", _DEFAULT_LINK_MODE)
+            uid = _get_pkg_attr(psi.attributes, "uid", _DEFAULT_UID)
+            gid = _get_pkg_attr(psi.attributes, "gid", _DEFAULT_GID)
+            dest = paths.normalize(psi.destination)
+            content += "[type=link uid={} gid={} perms={}] /{}={}\n".format(
+                uid,
+                gid,
+                mode,
+                dest,
+                psi.target,
+            )
+
+    build_file = ctx.actions.declare_file("{}_pkg_content.build".format(ctx.attr.name))
+    ctx.actions.write(build_file, content)
+
+    return fs_contents, build_file

rules/qnx/common/pkg.bzl

@@ -0,0 +1,96 @@
+load(":common/pkg.bzl", "qnx_build_inputs_from_pkg")
+
+def _gen_main_build_file(
+        ctx,
+        extra_build_files,
+        global_attrs = None):
+    """
+    Generates the main build file used to create a qnx6fs image.
+
+    Args:
+        ctx: Context.
+        extra_build_files: extra build files to be appended
+        global_attrs:
+          Global options, apply to both the image and extra build files.
+          Accepts a list of a mix of strings or dicts, to represent static
+          options (e.g. -optional) or mapped values (e.g. block_size=4096)
+
+    Returns:
+        main_{}.build
+    """
+    file_name = "main_{}.build".format(ctx.attr.name)
+    main_build_file = ctx.actions.declare_file(file_name)
+
+    content = ""
+    if global_attrs:
+        for attr in global_attrs:
+            if type(attr) == "string":
+                content += "[{}]\n".format(attr)
+            elif type(attr) == "dict":
+                for key, value in attr.items():
+                    content += "[{}={}]\n".format(key, value)
+            else:
+                fail("Unsupported attribute type '{}', must be string or dict".format(type(attr)))
+
+    for build_file in extra_build_files:
+        content += "[+include] {}\n".format(build_file.path)
+
+    ctx.actions.write(main_build_file, content)
+
+    return main_build_file
+
+def gen_image_definition(
+        ctx,
+        srcs,
+        global_attrs = None,
+        extra_build_file = None,
+        extra_build_files = [],
+        repo_mapping = {},
+        repo_mapping_srcs = None):
+    """
+    Process inputs for QNX image definition, return contents and builds files.
+
+    Args:
+        ctx: Rule context.
+        srcs: Input srcs for FS, can be mix of DUI, rules_pkg, and regular.
+        global_attrs: Attributes set globally on main build file.
+        extra_build_file: Additional build file to be included.
+        extra_build_files: Additional build files to be included after the
+            extra_build_file.
+        repo_mapping: Map of Bazel location expressions to hardcoded variable
+                      names in extra build file.
+        repo_mapping_srcs: Bazel targets referenced in the location expressions
+                           of repo_mapping.
+    Returns:
+        main_build_file: Main entrypoint QNX build file.
+        build_files: QNX build files inluded in the main.
+        fs_contents: Files to be included in the QNX image.
+        expanded_repo_map: Expanded Bazel locations with paths of files to be
+                           included.
+    """
+
+    build_files = []
+    fs_contents = []
+
+    # Add extra build files
+    build_files.append(extra_build_file)
+    build_files.extend(extra_build_files)
+
+    # # Rules_pkg contents
+    pkg_contents, pkg_build_file = qnx_build_inputs_from_pkg(
+        ctx,
+        srcs,
+        per_file_attrs = None,
+    )
+
+    build_files.append(pkg_build_file)
+    fs_contents.extend(pkg_contents)
+
+    # Generate main build file which imports others
+    main_build_file = _gen_main_build_file(
+        ctx,
+        build_files,
+        global_attrs,
+    )
+
+    return main_build_file, build_files, fs_contents

rules/qnx/common/qnx_image.bzl

@@ -20,31 +20,10 @@ other build files or perform other operations like packaging any file into the
 created IFS.
 """
 
-QNX_FS_TOOLCHAIN = "@score_rules_imagefs//toolchains/qnx:ifs_toolchain_type"
-TAR_TOOLCHAIN = "@tar.bzl//tar/toolchain:type"
-
-# todo: Consider to contribute this to "@tar.bzl"
-def _untar(ctx, tarball, output_folder):
-    tarball_as_list = tarball.files.to_list()
-    if len(tarball_as_list) > 1:
-        fail("Provided more then one tar-ball for one key.")
-    tarball = tarball_as_list[0]
-    bsdtar = ctx.toolchains[TAR_TOOLCHAIN]
+load("@rules_pkg//pkg:providers.bzl", "PackageDirsInfo", "PackageFilegroupInfo", "PackageFilesInfo", "PackageSymlinkInfo")
+load(":common/qnx_image.bzl", "gen_image_definition")
 
-    args = ctx.actions.args()
-    args.add("-x")
-    args.add("-C").add(output_folder.path)
-    args.add("-f").add(tarball.path)
-
-    ctx.actions.run(
-        outputs = [output_folder],
-        inputs = [tarball],
-        arguments = [args],
-        executable = bsdtar.tarinfo.binary,
-        toolchain = TAR_TOOLCHAIN,
-        mnemonic = "Untar",
-        progress_message = "untar %{input}",
-    )
+QNX_FS_TOOLCHAIN = "@score_rules_imagefs//toolchains/qnx:ifs_toolchain_type"
 
 def _qnx_ifs_impl(ctx):
     """ Implementation function of qnx_ifs rule.
@@ -61,13 +40,20 @@ def _qnx_ifs_impl(ctx):
         fail("qnx_ifs.out must be a filename without path components, got: {}".format(out_name))
 
     out_ifs = ctx.actions.declare_file(out_name)
-
     ifs_tool_info = ctx.toolchains[QNX_FS_TOOLCHAIN].ifs_toolchain_info
 
+    main_build_file_2, build_files, fs_contents = gen_image_definition(
+        ctx,
+        srcs = ctx.attr.all_files,
+        extra_build_file = ctx.file.build_file,
+        extra_build_files = ctx.files.extra_build_files,
+    )
+
     main_build_file = ctx.file.build_file
 
-    inputs.append(main_build_file)
-    inputs.extend(ctx.files.srcs)
+    inputs.append(main_build_file_2)
+    inputs.extend(build_files)
+    inputs.extend(fs_contents)
 
     args = ctx.actions.args()
 
@@ -87,19 +73,6 @@ def _qnx_ifs_impl(ctx):
     env_to_append = {}
     env_to_append = env_to_append | ifs_tool_info.env
 
-    for key, item in ctx.attr.ext_repo_mapping.items():
-        env_to_append.update({key: ctx.expand_location(item)})
-
-    env_to_append.update({"MAIN_BUILD_FILE_DIR": main_build_file.dirname})
-
-    # Unpack tarballs and add locations as env variables
-    for key, tarball in ctx.attr.tars.items():
-        unpacked_tarball = ctx.actions.declare_directory("{}_{}".format(ctx.attr.name, key))
-        _untar(ctx, tarball, unpacked_tarball)
-
-        env_to_append.update({key: unpacked_tarball.path})
-        inputs.append(unpacked_tarball)
-
     print(env_to_append)
 
     ctx.actions.run(
@@ -119,6 +92,9 @@ qnx_ifs = rule(
     implementation = _qnx_ifs_impl,
     toolchains = [QNX_FS_TOOLCHAIN, TAR_TOOLCHAIN],
     attrs = {
+        "all_files": attr.label_list(
+            mandatory = True,
+        ),
         "build_file": attr.label(
             allow_single_file = True,
             doc = "Single label that points to the main build file (entrypoint)",
@@ -128,20 +104,10 @@ qnx_ifs = rule(
             default = "ifs",
             doc = "Extension for the generated IFS image. Manipulating this extensions is a workaround for IPNext startup code limitation, when interpreting ifs images. This attribute will either disappear or will be replaced by toolchain configuration in order to keep output files consistent.",
         ),
-        "srcs": attr.label_list(
+        "extra_build_files": attr.label_list(
             allow_files = True,
-            doc = "List of labels that are used by the `build_file`",
-            allow_empty = True,
-        ),
-        "ext_repo_mapping": attr.string_dict(
-            allow_empty = True,
-            default = {},
-            doc = "We are using dict to map env. variables with of external repository",
-        ),
-        "tars": attr.string_keyed_label_dict(
-            allow_files = [".tar"],
-            doc = "A map of tar-balls that can be added to the IFS image. The key will be available als variable in the `IFS Build File`, to determine where it should be packaged. e.g. `FOO: '//:my_tar'` can be packaged as /SOME_DIR=${FOO}.",
-            allow_empty = True,
+            default = [],
+            doc = "Additional build files to be included after the main build_file.",
         ),
         "out": attr.string(
             default = "",