build/assembly/assembly_input_bundle.gni

# Copyright 2021 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import("//build/bazel/bazel_inputs.gni")
import("//build/components/fuchsia_package.gni")
import("//build/group_with_inputs.gni")
import("//build/python/python_action.gni")
import("//tools/cmc/build/restricted_features.gni")

# Creates an Assembly Input Bundle from sets of deps.
#
# NOTE: This is not yet able to support all categories of inputs that are in an
#       AIB.  That support will be added in future CLs.  See the parameters
#       below for the categories that are currently supported.
#
# NOTE: This template DOES NOT use GN metadata, all labels for packages must be
# the actual target that creates the package.
#
# Parameters
#
#  allowed_in [optional]
#    [list, strings] Which feature set + build type combinations this AIB is
#    allowed to be included in. Assembly asserts during product assembly that
#    the AIB is not included in any feature set + build type combinations
#    that are not in this list.
#
#    Options:
#    - "everything"
#    - "standard", "utility", "bootstrap", "embeddable"
#    - "user", "userdebug", "eng"
#    - "standard::user", "utility::eng", etc.
#
#  scrutiny_required [optional]
#    [list, strings] Which feature set + build type combinations to expect the
#    contents of this AIB to be added to. Adding to this list will force the
#    contents of this AIB to be listed as required in scrutiny goldens.
#
#    Options:
#    - "everything"
#    - "standard", "utility", "bootstrap", "embeddable"
#    - "user", "userdebug", "eng"
#    - "standard::user", "utility::eng", etc.
#
#  auto_include_in [optional]
#    [list, strings] Which feature set + build type combinations to
#    automatically include this AIB in.
#
#    Options:
#    - "everything"
#    - "standard", "utility", "bootstrap", "embeddable"
#    - "user", "userdebug", "eng"
#    - "standard::user", "utility::eng", etc.
#
#  experimental [optional; default=false]
#    [bool] Whether this AIB is experimental and should be excluded from the
#    scrutiny goldens. Experimental AIBs must be available in userdebug and
#    never in user. Experimental AIBs are allowed in any feature set level.
#    The typical way to mark an AIB as available in userdebug but not user is to
#    set `experimental = true` and `allowed_in = ["userdebug", "eng"]`.
#
#  base_packages [optional]
#    [list, GN labels] A list of GN labels of fuchsia_package targets to
#    include in the base package set.
#
#    Note: These are direct labels for specific targets, not deps to walk for
#    metadata.  If the target isn't a package target, it will cause an error
#    like:
#      "no dependency provides the input <package_name>/package_manifest.json"
#
#  bootfs_or_base_packages
#    [list, GN labels] A list of GN labels of fuchsia_package targets to include
#    in the bootfs_or_base package set, which means the package will go in the
#    base package set if the product has it, or bootfs if not. Products with the
#    `standard` or `utility` feature set have base packages while `embeddable`
#    or `bootstrap` do not.
#
#    Note: These are direct labels for specific targets, not deps to walk for
#    metadata.  If the target isn't a package target, it will cause an error
#    like:
#      "no dependency provides the input <package_name>/package_manifest.json"
#
#   drivers [optional]
#     [list, GN scopes] A list of GN scopes that hold the driver packages to
#     include in the assembly input bundle. The scope must have a `package_target`
#     field pointing to the GN target of the fuchsia_package, `driver_components`
#     field containing a list of relative paths to driver components provided by
#     the package, e.g. "meta/driver.cm", and a `set` field ("base" or "bootfs").
#
#  cache_packages [optional]
#    [list, GN labels] A list of GN labels of fuchsia_package targets to
#    include in the cache package set.
#
#  anchored_automatic_packages [optional]
#    [list, GN labels] A list of GN labels of fuchsia_package targets to
#    include in the anchored automatic package set.
#
#  anchored_on_demand_packages [optional]
#    [list, GN labels] A list of GN labels of fuchsia_package targets to
#    include in the anchored on-demand package set.
#
#  flexible_packages [optional]
#    [list, GN labels] A list of GN labels of fuchsia_package targets that
#    assembly may choose to put in base, cache, or elsewhere depending on the
#    assembly context.
#
#  bootfs_packages [optional]
#    [list, GN labels] A list of GN labels of fuchsia_package targets to
#    include in the bootfs package set.
#
#    Note: These are direct labels for specific targets, not deps to walk for
#    metadata.  If the target isn't a package target, it will cause an error
#    like:
#      "no dependency provides the input <package_name>/package_manifest.json"
#
#  bootfs_files_labels [optional]
#    [list, GN labels] A list of GN labels of bootfs_files_for_assembly()
#    targets to include in bootfs_files provided by this AIB.
#
#    Note: These are direct labels for specific targets, not deps to walk for
#    metadata. If the target isn't a bootfs_files_for_assembly target, it will
#    cause an error like:
#      "no dependency provides the input <package_name>/bootfs_files.json"
#
#  config_data_labels [optional]
#    [list, GN labels] A list of GN labels of config_data_for_assembly() targets
#    to include in the config_data provided by this AIB.
#
#    Note: These are direct labels for specific targets, not deps to walk for
#    metadata.  If the target isn't a config_data_for_assembly() target, it will
#    cause an error like:
#      "no dependency provides the input <package_name>/config_data_entry.json"
#
#  config_data [optional]
#    [list, scopes] A list of scopes, defining each config_data associated with
#    a given package, and the source, label, and destination required to add it
#    in bootfs using assembly.
#
#    Example w/ source-files:
#    config_data = [
#      {
#        package_name = "example_package"
#        files = [
#          {
#            source =
#                "//src/path_to_config/config1.json"
#            destination = "config1.json"
#          },
#          {
#            source = "//src/path_to_config/other_stuff.txt"
#            destination = "other_stuff.txt"
#          },
#        ]
#      },
#    ]
#
#    Example w/ build-output:
#    config_data = [
#      {
#        package_name = "example_package"
#        label = "//src/package/path:example_package"
#        files = [
#          {
#            source =
#                "//src/path_to_config/config1.json"
#            destination = "config1.json"
#          },
#          {
#            source = "//src/path_to_config/other_stuff.txt"
#            destination = "other_stuff.txt"
#          },
#        ]
#      },
#    ]
#
#  qemu_kernel (optional; default: false)
#    [path] Path to the qemu kernel.
#
#  kernel_cmdline (optional: default: [])
#    [list of strings] Kernel cmdline arguments.
#
#  shell_commands (optional; default: empty)
#    [list of scopes] A list of scopes that describe the shell commands for each
#    listed package
#
#    Example:
#    shell_commands = [
#      {
#        package = "//third_party/sbase"
#        components = [ "ls" ]
#      },
#    ]
#
#  compiled_packages [optional]
#     [list of GN scopes] List of GN scopes of `CompiledPackageDefinition`s
#     that describe packages that are to be built dynamically by Assembly, for
#     example, the `core` package. This is passed directly through to the AIB
#     config so all paths should be rebased by the caller.
#
#     Example:
#
#     # Add a core shard
#     compiled_packages = [
#       {
#         name = "core"
#         packages = [ "//path/to/package" ],
#         components = [
#           {
#             component_name = "core"
#             shards = [
#                     "//src/sys/process-resolver/meta/process_resolver.core_shard.cml",
#             ]
#           },
#           ...
#         component_includes = [ ... ]
#       },
#     ]
#
#     shards [optional]
#       [list of GN file paths] List of CML files to merge together when
#       compiling the component.
#
#     cmc_features [optional]
#       [list of string] List of CMC features to enable for component
#       compilation.
#
#     component_includes [optional]
#       [list of FileEntry] List of source/destination pairs related to a
#       compiled package in the compiled_packages list that specifies cml files
#       that can be included by any cml shards in any platform AIB for the given
#       package. These files will be included in the Assembly Input Bundle.
#
#  bootstrap_shards [optional]
#    [list of file paths] A list of CML shard files to add to the "bootstrap"
#    component of the "bootstrap" compiled package. This package is a bootfs
#    package.
#
#  core_shards [optional]
#    [list of file paths] A list of CML shard files to add to the "core"
#    component of the "core" compiled package.
#
#  root_shards [optional]
#    [list of file paths] A list of CML shard files to add to the "root"
#    component of the "root" compiled package. This package is a bootfs package.
#
#  toolbox_shards [optional]
#    [list of file paths] A list of CML shard files to add to the "toolbox"
#    component of the "toolbox" compiled package. This package is a bootfs
#    package.
#
#  memory_buckets (optional; default: [])
#    [list of paths] Paths to memory bucket configs that should get merged and
#    passed to memory monitor.
#
#
#
#  Outputs
#    A directory structure and manifest that matches that documented in
#    //build/python/modules/assembly/assembly_input_bundle.py.
#
#   manifest path:
#   $target_out_dir/$target_name/assembly_config.json
#
#
# GN usual meanings
#  testonly, visibility
template("assembly_input_bundle") {
  bundles_dir = target_out_dir
  bundle_name = target_name
  assert(bundle_name != "resources",
         "The bundle name 'resources' is reserved for internal use")

  labels = {
    # The AIB itself
    assembly_input_bundle = "$target_name.bundle"

    bazel_inputs = "${target_name}_bazel_inputs"
    gn_targets_name = target_name

    bootfs_files_package = "${target_name}.bootfs_files_package"
    config_data = "${target_name}.config_data_list"
    config_data_with_verification = "${target_name}.group_with.config_data"
    kernel_cmdline = "${target_name}.kernel_cmdline"
    shell_commands_list = "${target_name}.shell_commands.list"
    compiled_packages = "${target_name}.compiled_packages"
  }

  files = {
    # The directory where all the bundle contents are written to
    assembly_input_bundle_dir = "${bundles_dir}/${bundle_name}"

    # The unpackaged bootfs files that we throw into a package to add to the
    # AIB.
    bootfs_files_package = "$target_out_dir/$target_name.bootfs_files_package/package_manifest.json"

    # The "official" outputs file that we create in that directory
    assembly_input_bundle_config =
        "${assembly_input_bundle_dir}/assembly_config.json"

    # The files that we create as book-keeping between our tasks.
    assembly_input_bundle_depfile = "${assembly_input_bundle_dir}.d"

    # The manifest of all files in the AIB, used to create pkgs and archives.
    assembly_input_bundle_manifest =
        "${assembly_input_bundle_dir}.fini_manifest"

    _gen_files = "${target_gen_dir}/${target_name}"
    shell_commands_list = "${_gen_files}/shell_commands.list"

    # The output path for the generated file which collects config_data from
    # the invoking scope
    config_data = "${assembly_input_bundle_dir}.config_data_list"

    # The output path for the generated file which collects kernel cmdline
    # arguments.
    kernel_cmdline = "${assembly_input_bundle_dir}.kernel_cmdline"

    # The list of user-provided compiled_package_definitions to include in
    # the AIB config
    compiled_packages = "${assembly_input_bundle_dir}.compiled_packages"
  }

  _allowed_on_user = false
  _allowed_in = []
  if (defined(invoker.allowed_in)) {
    _allowed_in += invoker.allowed_in
  }
  if (defined(invoker.scrutiny_required)) {
    _allowed_in += invoker.scrutiny_required
  }
  if (defined(invoker.auto_include_in)) {
    _allowed_in += invoker.auto_include_in
  }
  if (_allowed_in == []) {
    _allowed_on_user = true
  } else {
    foreach(allow_rule, _allowed_in) {
      if (allow_rule == "standard" || allow_rule == "utility" ||
          allow_rule == "bootstrap" || allow_rule == "embeddable" ||
          allow_rule == "user" || allow_rule == "everything") {
        _allowed_on_user = true
      } else {
        _allow_rule_parts = []
        _allow_rule_parts = string_split(allow_rule, "::")
        if (_allow_rule_parts + [ "user" ] - [ "user" ] != _allow_rule_parts) {
          _allowed_on_user = true
        }
      }
    }
  }

  creation_args = []
  creation_inputs = []
  creation_deps = []
  if (defined(invoker.deps)) {
    creation_deps += invoker.deps
  }

  if (defined(invoker.testonly) && invoker.testonly) {
    creation_args += [ "--testonly" ]
  }

  if (defined(invoker.allowed_in)) {
    foreach(include, invoker.allowed_in) {
      creation_args += [
        "--allowed-in",
        include,
      ]
    }
  }

  if (defined(invoker.scrutiny_required)) {
    foreach(include, invoker.scrutiny_required) {
      creation_args += [
        "--scrutiny-required",
        include,
      ]
    }
  }

  if (defined(invoker.auto_include_in)) {
    foreach(include, invoker.auto_include_in) {
      creation_args += [
        "--auto-include-in",
        include,
      ]
    }
  }

  if (defined(invoker.experimental) && invoker.experimental) {
    creation_args += [ "--experimental" ]
  }

  if (defined(invoker.bootfs_files_labels)) {
    fuchsia_package(labels.bootfs_files_package) {
      forward_variables_from(invoker, [ "testonly" ])
      deps = invoker.bootfs_files_labels
    }

    # Pass the bootfs files package to the assembly tool.
    creation_args += [
      "--bootfs-files-package",
      rebase_path(files.bootfs_files_package, root_build_dir),
    ]
    creation_deps += [ ":${labels.bootfs_files_package}" ]
  }

  # Convert the list of config_data_labels into a set of config_data_entry.json
  # files that are inputs that define config data entry scopes.
  if (defined(invoker.config_data_labels)) {
    _config_data_entries = []

    foreach(entry_label, invoker.config_data_labels) {
      # Assume this is a GN-label to a config_data_for_assembly()
      # instantiation, which is similar to packages.
      _entry_out_dir = get_label_info(entry_label, "target_out_dir")
      _entry_name = get_label_info(entry_label, "name")
      _entry_file = "${_entry_out_dir}/${_entry_name}/config_data_entry.json"
      _config_data_entries += [ _entry_file ]

      creation_args += [
        "--config-data-list",
        rebase_path(_entry_file, root_build_dir),
      ]
    }

    creation_deps += invoker.config_data_labels
    creation_inputs += _config_data_entries
  }

  # Splits config_data inputs from the invoker into:
  # 1) group_with_inputs deps / sources and
  # 2) generated_file contents
  if (defined(invoker.config_data)) {
    config_data_contents = []
    _config_data_deps = []
    _config_data_sources = []
    foreach(definition, invoker.config_data) {
      assert(defined(definition.package_name),
             "config_data definitions must include package_name")
      assert(defined(definition.files),
             "config_data definitions must include source")

      if (defined(definition.label)) {
        _config_data_deps += [ definition.label ]
      }

      foreach(file, definition.files) {
        assert(defined(file.source), "file must have source in scope")
        assert(defined(file.destination), "file must have destination in scope")
        _config_data_sources += [ file.source ]
        config_data_contents += [
          {
            package_name = definition.package_name
            source = rebase_path(file.source, root_build_dir)
            destination = file.destination
          },
        ]
      }
    }
    group_with_inputs(labels.config_data_with_verification) {
      deps = _config_data_deps
      sources = _config_data_sources
    }

    generated_file(labels.config_data) {
      forward_variables_from(invoker, [ "testonly" ])
      contents = config_data_contents
      outputs = [ "${files.config_data}" ]
      output_conversion = "json"
    }

    creation_deps += [
      ":${labels.config_data_with_verification}",
      ":${labels.config_data}",
    ]

    creation_args += [
      "--config-data-list",
      rebase_path(files.config_data, root_build_dir),
    ]
    creation_inputs += [ files.config_data ]
  }

  # Convert each set of package targets into:
  #  1) a set of manifests paths in a file
  #  2) add that file as an input and argument to the AIB creation action
  #  3) add the target labels as dependencies of the AIB creation action

  # This defines a set of package sets that can be looped over by name to find
  # process.  This use of defined() and the invoker is to tolerate undefined,
  # optional, parameters to the template, as `invoker[name]` is not supported
  # with defined
  package_sets = {
    base = []
    if (defined(invoker.base_packages)) {
      foreach(_target, invoker.base_packages) {
        base += [
          {
            package_target = _target
          },
        ]
      }
    }
    cache = []
    if (defined(invoker.cache_packages)) {
      foreach(_target, invoker.cache_packages) {
        cache += [
          {
            package_target = _target
          },
        ]
      }
    }
    anchored_automatic = []
    if (defined(invoker.anchored_automatic_packages)) {
      foreach(_target, invoker.anchored_automatic_packages) {
        anchored_automatic += [
          {
            package_target = _target
          },
        ]
      }
    }
    anchored_on_demand = []
    if (defined(invoker.anchored_on_demand_packages)) {
      foreach(_target, invoker.anchored_on_demand_packages) {
        anchored_on_demand += [
          {
            package_target = _target
          },
        ]
      }
    }
    flexible = []
    if (defined(invoker.flexible_packages)) {
      foreach(_target, invoker.flexible_packages) {
        flexible += [
          {
            package_target = _target
          },
        ]
      }
    }
    system = []
    if (defined(invoker.system_packages)) {
      foreach(_target, invoker.system_packages) {
        system += [
          {
            package_target = _target
          },
        ]
      }
    }
    bootfs = []
    if (defined(invoker.bootfs_packages)) {
      foreach(_target, invoker.bootfs_packages) {
        bootfs += [
          {
            package_target = _target
          },
        ]
      }
    }
    bootfs_or_base = []
    if (defined(invoker.bootfs_or_base_packages)) {
      foreach(_target, invoker.bootfs_or_base_packages) {
        bootfs_or_base += [
          {
            package_target = _target
          },
        ]
      }
    }
    on_demand = []
    if (defined(invoker.on_demand)) {
      foreach(_target, invoker.on_demand) {
        on_demand += [
          {
            package_target = _target
          },
        ]
      }
    }

    drivers = []
    if (defined(invoker.drivers)) {
      drivers = invoker.drivers
    }
  }

  # Loop over the above sets of packages
  foreach(set_name,
          [
            "base",
            "cache",
            "anchored-automatic",
            "anchored-on-demand",
            "flexible",
            "system",
            "bootfs",
            "bootfs-or-base",
            "on-demand",
            "drivers",
          ]) {
    _package_target_details = []
    _package_target_details = package_sets[string_replace(set_name, "-", "_")]
    _package_targets = []
    _manifest_entries = []

    # Skip empty package sets
    if (_package_target_details != []) {
      # 1a) Calculate the manifest path for each package target
      foreach(details, _package_target_details) {
        assert(
            defined(details.package_target),
            "A target must be defined for each package. (this should be unreachable)")
        _package_targets += [ details.package_target ]
        _package_out_dir =
            get_label_info(details.package_target, "target_out_dir")
        _package_name = get_label_info(details.package_target, "name")
        _manifest_path =
            "${_package_out_dir}/${_package_name}/package_manifest.json"
        _manifest_path_rebased = rebase_path(_manifest_path, root_build_dir)

        if (set_name == "drivers") {
          assert(defined(details.driver_components),
                 "driver_components must be specified for driver targets")
          assert(defined(details.set),
                 "set must be specified for driver targets")

          _manifest_entries += [
            {
              package_target = _manifest_path_rebased
              driver_components = details.driver_components
              set = details.set
            },
          ]
        } else {
          _manifest_entries += [ _manifest_path_rebased ]
        }
      }

      _manifest_list = "${target_name}.${set_name}_packages.list"
      _manifest_list_file = "${target_gen_dir}/${_manifest_list}"

      # 1b) Generate a file containing that list
      # For base packages this will be a list of package manifests.
      # For drivers, this will be a list of DriverDetails, containing
      # the package manifests and component file paths.
      generated_file(_manifest_list) {
        forward_variables_from(invoker, [ "testonly" ])
        deps = _package_targets
        outputs = [ "${_manifest_list_file}" ]
        output_conversion = "json"
        contents = _manifest_entries
      }

      # 2) add the file as an input and argument to the AIB creation action
      if (set_name == "drivers") {
        creation_args += [
          "--drivers-list",
          rebase_path(_manifest_list_file, root_build_dir),
        ]
      } else {
        creation_args += [
          "--${set_name}-pkg-list",
          rebase_path(_manifest_list_file, root_build_dir),
        ]
      }
      creation_inputs += [ _manifest_list_file ]

      # 3) add the file as a dependency of the AIB creation action (linking the
      #    actual package deps transitively, to preserve the route by which they
      #    are added to the AIB:
      #      AIB
      #       +-> AIB.base_packages_list
      #            +-> [ base package deps ]
      #       +-> AIB.cache_packages_list
      #            +-> [ cache package deps ]
      creation_deps += [ ":${_manifest_list}" ]
    }
  }

  # Only add the shell command packages list if it's non-empty
  if (defined(invoker.shell_commands) && invoker.shell_commands != []) {
    shell_commands_json_contents = []

    foreach(shell_command, invoker.shell_commands) {
      assert(
          defined(shell_command.package),
          "shell_command entries must specify a package name: ${shell_command}")
      assert(
          defined(shell_command.components),
          "shell_command components must be a list of strings pointing to binaries that are components in the package that make up the package: ${shell_command}")
      _package_name = get_label_info(shell_command.package, "name")
      _bootfs_package = false
      if (defined(shell_command.bootfs_package)) {
        _bootfs_package = shell_command.bootfs_package
      }
      shell_commands_json_contents += [
        {
          package = _package_name
          bootfs_package = _bootfs_package
          components = shell_command.components
        },
      ]
    }

    generated_file(labels.shell_commands_list) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      outputs = [ files.shell_commands_list ]
      output_conversion = "json"
      contents = shell_commands_json_contents
    }

    creation_args += [
      "--shell-cmds-list",
      rebase_path(files.shell_commands_list, root_build_dir),
    ]
    creation_inputs += [ files.shell_commands_list ]
    creation_deps += [ ":${labels.shell_commands_list}" ]
  }

  if (defined(invoker.qemu_kernel)) {
    creation_args += [
      "--qemu-kernel",
      rebase_path(invoker.qemu_kernel, root_build_dir),
    ]
  }

  if (defined(invoker.kernel_cmdline)) {
    generated_file(labels.kernel_cmdline) {
      forward_variables_from(invoker, [ "testonly" ])
      outputs = [ files.kernel_cmdline ]
      output_conversion = "json"
      contents = invoker.kernel_cmdline
    }

    creation_args += [
      "--kernel-cmdline",
      rebase_path(files.kernel_cmdline, root_build_dir),
    ]
    creation_inputs += [ files.kernel_cmdline ]
    creation_deps += [ ":${labels.kernel_cmdline}" ]
  }

  # Add the additional shards to the compiled packages list.
  _all_compiled_packages = []
  if (defined(invoker.compiled_packages)) {
    _all_compiled_packages = invoker.compiled_packages
  }

  _shard_types = [
    {
      name = "bootstrap"
      arg = "bootstrap_shards"
      bootfs = true
    },
    {
      name = "core"
      arg = "core_shards"
      bootfs = false
    },
    {
      name = "root"
      arg = "root_shards"
      bootfs = true
    },
    {
      name = "toolbox"
      arg = "toolbox_shards"
      bootfs = true
    },
  ]

  # Keep track of all the hardcoded shard types from above that we already
  # merged in. This will ensure that we add any missing types after the merge.
  _merged_shard_types = []

  # Accumulate a list of all the compiled packages by merging
  # _all_compiled_packages with the hardcoded shard lists above.
  _merged_compiled_packages = []
  foreach(package, _all_compiled_packages) {
    # Search for a hardcoded shard type that matches this package.
    _package_found = false
    foreach(type, _shard_types) {
      # Merge the compiled_package with the hardcoded shard type.
      if (!_package_found && defined(invoker[type.arg]) &&
          invoker[type.arg] != [] && type.name == package.name) {
        _package_found = true

        # Search for an existing component inside the package to merge the
        # shards lists.
        _component_found = false
        if (defined(package.components)) {
          foreach(component, package.components) {
            if (!_component_found && type.name == component.component_name) {
              _component_found = true

              if (defined(component.shards)) {
                component.shards += invoker[type.arg]
              } else {
                component.shards = invoker[type.arg]
              }
            }
          }
        } else {
          package.components = []
        }

        # The component was not found in the package, so add it.
        if (!_component_found) {
          package.components += [
            {
              component_name = type.name
              shards = invoker[type.arg]
            },
          ]
        }

        _merged_shard_types += [ type.name ]
      }
    }
    _merged_compiled_packages += [ package ]
  }

  # If we walked _all_compiled_packages and didn't find one of the hardcoded
  # shard types (such as 'core'), we need to add the missing hardcoded shard
  # types to _merged_compiled_packages.
  foreach(type, _shard_types) {
    if (defined(invoker[type.arg]) && invoker[type.arg] != []) {
      _missing = true
      foreach(added_type, _merged_shard_types) {
        if (type.name == added_type) {
          _missing = false
        }
      }
      if (_missing) {
        _new_package = {
        }
        _new_package = {
          name = type.name
          components = [
            {
              component_name = type.name
              shards = invoker[type.arg]
            },
          ]
        }
        if (type.bootfs) {
          _new_package.bootfs_package = true
        }
        _merged_compiled_packages += [ _new_package ]
      }
    }
  }
  _all_compiled_packages = []
  _all_compiled_packages = _merged_compiled_packages
  not_needed(_merged_shard_types)

  if (_all_compiled_packages != []) {
    _compiled_packages = []
    foreach(package, _all_compiled_packages) {
      _package = {
      }
      _package = {
        forward_variables_from(package,
                               [
                                 "name",
                                 "bootfs_package",
                               ])
      }

      # Rebase and create input groups for the contents, component shards, and
      # component includes for each package in the group.
      _inputs = []
      _deps = []

      # Gather the package manifests as input files
      if (defined(package.packages)) {
        packages = []
        foreach(entry, package.packages) {
          _package_out_dir = get_label_info(entry, "target_out_dir")
          _package_name = get_label_info(entry, "name")
          _manifest_path =
              "${_package_out_dir}/${_package_name}/package_manifest.json"
          _inputs += [ _manifest_path ]
          _deps += [ entry ]
          packages += [ rebase_path(_manifest_path, root_build_dir) ]
        }
        _package.packages = packages
      }

      # Gather the core shards as input files
      if (defined(package.components)) {
        components = []
        foreach(entry, package.components) {
          _inputs += entry.shards
          components += [
            {
              forward_variables_from(entry, "*", [ "shards" ])
              shards = rebase_path(entry.shards, root_build_dir)
            },
          ]
          if (defined(entry.cmc_features) && entry.cmc_features != []) {
            # This component is using potentially gated CMC features. Encode
            # this in a group dependency that potentially requires addition to a
            # visibility group.
            _features_group_name = "${target_name}.compiled_package.${package.name}.${entry.component_name}.cmc_features"
            _deps += [ ":${_features_group_name}" ]
            group(_features_group_name) {
              deps = []
              foreach(feature, entry.cmc_features) {
                if (filter_include(cmc_security_owned_restricted_features,
                                   [ feature ]) != []) {
                  deps += [ "//tools/cmc/build/restricted_features/security_owned:$feature" ]
                } else {
                  deps += [ "//tools/cmc/build/restricted_features:$feature" ]
                }
              }
            }
          }
        }
        _package.components = components
      }

      # Gather the component includes as input files
      if (defined(package.component_includes)) {
        component_includes = []
        foreach(entry, package.component_includes) {
          _inputs += [ entry.source ]
          component_includes += [
            {
              source = rebase_path(entry.source, root_build_dir)
              destination = entry.destination
            },
          ]
        }
        _package.component_includes = component_includes
      }

      # Create a group that wraps together all the deps and inputs found above,
      # to make sure that all input files are either source, or an output that's
      # accounted for by one of the deps.
      group_name = "${target_name}.compiled_package.${package.name}.inputs"
      group_with_inputs(group_name) {
        deps = _deps
        inputs = _inputs
      }
      creation_deps += [ ":${group_name}" ]

      _compiled_packages += [ _package ]
    }

    # Write out the whole compiled_package json file, now that all the inputs
    # in it have been found, and all GN file paths rebased.
    generated_file(labels.compiled_packages) {
      forward_variables_from(invoker, [ "testonly" ])
      outputs = [ "${files.compiled_packages}" ]
      output_conversion = "json"
      contents = _compiled_packages
    }

    creation_args += [
      "--compiled-packages",
      rebase_path(files.compiled_packages, root_build_dir),
    ]

    creation_inputs += [ files.compiled_packages ]
    creation_deps += [ ":${labels.compiled_packages}" ]
  }

  if (defined(invoker.memory_buckets)) {
    foreach(memory_bucket, invoker.memory_buckets) {
      creation_args += [
        "--memory-buckets",
        rebase_path(memory_bucket, root_build_dir),
      ]
      creation_inputs += [ memory_bucket ]
    }
  }

  # Create the out-of-tree-usable Assembly Input Bundle
  python_action(labels.assembly_input_bundle) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])

    binary_label = "//build/assembly/scripts:assembly_input_bundle_tool"

    # The contents of these folders is dynamic, and managed entirely by this
    # action.  Further, this action will need to delete items from these
    # directories that are not added back (on an incremental build, if an item
    # is removed from one of these sets)
    #
    # These folders would grow in size forever, if it was not cleaned out on
    # each incremental build.
    hermetic_action_ignored_prefixes = [
      "${files.assembly_input_bundle_dir}/blobs",
      "${files.assembly_input_bundle_dir}/bootfs",
      "${files.assembly_input_bundle_dir}/compiled_packages",
      "${files.assembly_input_bundle_dir}/config_data",
      "${files.assembly_input_bundle_dir}/kernel",
      "${files.assembly_input_bundle_dir}/packages",
      "${files.assembly_input_bundle_dir}/subpackages",
      "${files.assembly_input_bundle_dir}/memory_buckets",
    ]

    outputs = [ files.assembly_input_bundle_config ]
    depfile = files.assembly_input_bundle_depfile

    args = [
      "create",
      "--outdir",
      rebase_path(files.assembly_input_bundle_dir, root_build_dir),
      "--depfile",
      rebase_path(files.assembly_input_bundle_depfile, root_build_dir),
    ]
    args += creation_args

    inputs = creation_inputs
    deps = creation_deps

    metadata = {
      # We insert these barriers to prevent the dependencies of the input bundle
      # from leaking into images "higher up" in the dependency chain.
      package_barrier = []
      assembly_package_barrier = []
      config_package_barrier = []
      distribution_entries_barrier = []
      shell_commands_barrier = []
      assembly_input_archives_barrier = []
    }
  }

  # Make generated AIBs available to Bazel builds.
  bazel_input_directory(labels.bazel_inputs) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    generator = ":${labels.assembly_input_bundle}"
    output_directory = files.assembly_input_bundle_dir
    gn_targets_name = labels.gn_targets_name
  }

  group(target_name) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    deps = [ ":${labels.bazel_inputs}" ]
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }
    public_deps = [ ":${labels.assembly_input_bundle}" ]
    metadata = {
      if (!_allowed_on_user) {
        applicable_licenses_host_barrier = []
      }
      assembly_input_bundles = [
        {
          name = target_name
          path = rebase_path(files.assembly_input_bundle_dir, root_build_dir)
          label =
              get_label_info(labels.assembly_input_bundle, "label_no_toolchain")
        },
      ]
    }
  }
}