| # Copyright 2018 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. |
| |
| # Runs the Cobalt registry parser on either the entire (global) registry or |
| # the registry for a single project. Generates a .pb file containing the |
| # registry. |
| # |
| # Args: |
| # global: (default: false) Should generate the global config. |
| # customer_id: (default: 1) Override the customer for the config. |
| # project_id: numeric project_id of the project to generate the config of |
| # project_name: The string name of the project to use (cobalt v1.0 configs |
| # only) |
| # output_name: base of the filename for the output |
| # generate_binarypb: (default: true) should we generate a *.pb file with a |
| # binary representation of the config. |
| # generate_cc: (default: false) Should we generate a *.cb.h file and a library. |
| # generate_dart: (default: false) Should we generate a dart library. |
| # generate_rust: (default: false) Should we generate a rust crate. |
| # v1_project: (default: true) Is this a v1 project. |
| # directory: (default: //third_party/cobalt_config) The directory to parse. |
| # |
| # Note: Other args are forwarded to dart_library when generate_dart is true. |
| # |
| # example usage: |
| # |
| # metrics_registry("generate_testapp_config") { |
| # project_id = 2 |
| # } |
| |
| import("//build/config/clang/clang.gni") |
| |
| template("metrics_registry") { |
| if (defined(invoker.global)) { |
| global = invoker.global |
| } else { |
| global = false |
| } |
| |
| if (defined(invoker.customer_id)) { |
| not_needed([ "global" ]) |
| customer_id = invoker.customer_id |
| } else if (!global) { |
| # Customer is Fuchsia |
| customer_id = 1 |
| } |
| |
| if (defined(invoker.project_id) && !defined(invoker.project_name)) { |
| not_needed([ "global" ]) |
| project_id = invoker.project_id |
| } else if (!defined(invoker.project_id) && defined(invoker.project_name)) { |
| not_needed([ "global" ]) |
| project_name = invoker.project_name |
| } else { |
| assert( |
| global, |
| "Exactly one of 'project_id' and 'project_name' or 'global' must be defined") |
| } |
| |
| if (defined(invoker.namespace)) { |
| namespace = invoker.namespace |
| } else { |
| namespace = "" |
| } |
| |
| if (defined(invoker.generate_binarypb)) { |
| generate_binarypb = invoker.generate_binarypb |
| } else { |
| generate_binarypb = true |
| } |
| |
| if (defined(invoker.generate_cc)) { |
| generate_cc = invoker.generate_cc |
| } else { |
| generate_cc = false |
| } |
| |
| if (defined(invoker.generate_dart)) { |
| generate_dart = invoker.generate_dart |
| } else { |
| generate_dart = false |
| } |
| |
| if (defined(invoker.generate_go)) { |
| generate_go = invoker.generate_go |
| } else { |
| generate_go = false |
| } |
| |
| if (defined(invoker.go_package_name)) { |
| go_package_name = invoker.go_package_name |
| } |
| |
| if (defined(invoker.generate_rust)) { |
| generate_rust = invoker.generate_rust |
| } else { |
| generate_rust = false |
| } |
| |
| if (defined(invoker.source)) { |
| source = invoker.source |
| } |
| |
| if (defined(invoker.skip_validation)) { |
| skip_validation = invoker.skip_validation |
| } else { |
| skip_validation = false |
| } |
| |
| if (defined(invoker.for_testing)) { |
| for_testing = invoker.for_testing |
| } else { |
| for_testing = false |
| } |
| |
| if (defined(invoker.var_name)) { |
| var_name = invoker.var_name |
| } |
| |
| if (defined(invoker.v1_project)) { |
| v1_project = invoker.v1_project |
| } else { |
| v1_project = true |
| } |
| |
| if (defined(invoker.use_target_name)) { |
| not_needed(invoker, [ "use_target_name" ]) |
| } |
| |
| if (defined(invoker.output_name)) { |
| output_name = invoker.output_name |
| } else { |
| output_name = target_name |
| } |
| |
| if (defined(invoker.directory)) { |
| cobalt_config_dir = invoker.directory |
| } else { |
| cobalt_config_dir = "//third_party/cobalt_config" |
| } |
| |
| out_format = "" |
| generated_files = [] |
| if (generate_binarypb) { |
| out_format = "${out_format}bin " |
| generated_files += [ "$target_gen_dir/$output_name.pb" ] |
| } |
| if (generate_cc) { |
| out_format = "${out_format}cpp " |
| cc_source_file = "$target_gen_dir/$output_name.cb.h" |
| generated_files += [ cc_source_file ] |
| } |
| if (generate_dart) { |
| out_format = "${out_format}dart " |
| dart_out_dir = "$target_gen_dir/${target_name}_package" |
| dart_src_dir = "$dart_out_dir/lib" |
| dart_library_name = target_name |
| dart_source_file = "$dart_src_dir/$output_name.dart" |
| generated_files += [ dart_source_file ] |
| } |
| if (generate_rust) { |
| out_format = "${out_format}rust " |
| rust_source_file = "$target_gen_dir/$output_name.rs" |
| generated_files += [ rust_source_file ] |
| } |
| if (generate_go) { |
| out_format = "${out_format}go " |
| go_source_file = "$target_gen_dir/$output_name.go" |
| generated_files += [ go_source_file ] |
| } |
| |
| gen_target_name = "${target_name}_gen" |
| group_deps = [ ":${gen_target_name}" ] |
| |
| action(gen_target_name) { |
| config_parser_target = |
| "$cobalt_root/src/bin/config_parser/src:bin($host_toolchain)" |
| config_parser_bin = |
| get_label_info(config_parser_target, "root_out_dir") + "/config_parser" |
| |
| depfile = "$target_gen_dir/$output_name.d" |
| outputs = generated_files |
| inputs = [ |
| "$cobalt_config_dir/projects.yaml", |
| ] |
| |
| script = "//build/gn_run_binary.sh" |
| args = [ |
| clang_prefix, |
| rebase_path(config_parser_bin, root_build_dir), |
| "-out_format", |
| "$out_format", |
| "-out_filename", |
| "$output_name", |
| "-out_dir", |
| rebase_path(target_gen_dir, root_build_dir), |
| "-for_client", |
| "-dep_file", |
| rebase_path(depfile, root_build_dir), |
| ] |
| |
| if (skip_validation) { |
| args += [ "-skip_validation" ] |
| } |
| |
| if (for_testing) { |
| args += [ "-for_testing" ] |
| } |
| |
| if (defined(var_name)) { |
| args += [ |
| "-var_name", |
| var_name, |
| ] |
| } |
| |
| if (defined(source)) { |
| args += [ |
| "-config_file", |
| rebase_path(source, root_build_dir), |
| ] |
| if (v1_project) { |
| args += [ "-v1_project" ] |
| } |
| } else { |
| not_needed([ "v1_project" ]) |
| args += [ |
| "-config_dir", |
| rebase_path(cobalt_config_dir, root_build_dir), |
| ] |
| } |
| |
| if (defined(customer_id)) { |
| args += [ |
| "-customer_id", |
| "$customer_id", |
| ] |
| } |
| |
| if (namespace != "") { |
| args += [ |
| "-namespace", |
| "${namespace}", |
| ] |
| } |
| |
| if (defined(project_id)) { |
| args += [ |
| "-project_id", |
| "$project_id", |
| ] |
| } else if (defined(project_name)) { |
| args += [ |
| "-project_name", |
| "$project_name", |
| ] |
| } |
| |
| if (generate_dart) { |
| args += [ |
| "-dart_out_dir", |
| rebase_path(dart_src_dir, root_build_dir), |
| ] |
| } |
| |
| if (generate_go) { |
| args += [ |
| "-go_package", |
| go_package_name, |
| ] |
| } |
| |
| deps = [ |
| config_parser_target, |
| ] |
| } |
| |
| if (generate_cc) { |
| cclib = "${target_name}_cc" |
| group_deps += [ ":${cclib}" ] |
| |
| source_set(cclib) { |
| output_name = cclib |
| |
| sources = [ |
| cc_source_file, |
| ] |
| |
| public_deps = [ |
| ":$gen_target_name", |
| ] |
| } |
| } |
| |
| if (generate_dart) { |
| import("//build/dart/dart_library.gni") |
| |
| dartlib = "${target_name}_dartlib" |
| group_deps += [ ":${dartlib}" ] |
| |
| copy_pubspec_target_name = "${dartlib}_copy_pubspec" |
| copy_options_target_name = "${dartlib}_copy_options" |
| |
| copy(copy_pubspec_target_name) { |
| sources = [ |
| "//build/dart/empty_pubspec.yaml", |
| ] |
| |
| outputs = [ |
| "$dart_out_dir/pubspec.yaml", |
| ] |
| } |
| |
| copy(copy_options_target_name) { |
| sources = [ |
| "//topaz/tools/analysis_options.yaml", |
| ] |
| |
| outputs = [ |
| "$dart_out_dir/analysis_options.yaml", |
| ] |
| } |
| |
| dart_library(dartlib) { |
| forward_variables_from(invoker, |
| [ |
| "testonly", |
| "sdk_category", |
| "visibility", |
| ]) |
| |
| package_root = dart_out_dir |
| |
| package_name = dart_library_name |
| |
| sources = [ |
| rebase_path(dart_source_file, dart_src_dir), |
| ] |
| |
| if (defined(invoker.deps)) { |
| deps += invoker.deps |
| } |
| |
| if (defined(invoker.public_deps)) { |
| deps += invoker.public_deps |
| } |
| |
| non_dart_deps = [ |
| ":$copy_options_target_name", |
| ":$copy_pubspec_target_name", |
| ":$gen_target_name", |
| ] |
| } |
| } |
| |
| if (generate_rust) { |
| import("//build/rust/rustc_library.gni") |
| |
| rust_library_name = target_name |
| rustlib = "${target_name}_rustlib" |
| group_deps += [ ":${rustlib}" ] |
| rustc_library(rustlib) { |
| name = rust_library_name |
| |
| version = "1.0.0" |
| edition = "2018" |
| source_root = rust_source_file |
| |
| non_rust_deps = [ ":$gen_target_name" ] |
| } |
| } |
| |
| if (generate_go) { |
| import("//build/go/go_library.gni") |
| |
| source_dir = target_gen_dir |
| go_library("${target_name}_golib") { |
| non_go_deps = [ ":$gen_target_name" ] |
| } |
| } |
| |
| group(target_name) { |
| forward_variables_from(invoker, [ "testonly" ]) |
| public_deps = group_deps |
| } |
| } |