Merge "Read BUILD files in bp2build"
diff --git a/android/bazel_handler.go b/android/bazel_handler.go
index 28bcace..4645e6b 100644
--- a/android/bazel_handler.go
+++ b/android/bazel_handler.go
@@ -689,26 +689,20 @@
func (context *mixedBuildBazelContext) createBazelCommand(config Config, runName bazel.RunName, command bazelCommand,
extraFlags ...string) bazel.CmdRequest {
+ if runtime.GOOS != "linux" && runtime.GOOS != "darwin" {
+ panic("Unknown GOOS: " + runtime.GOOS)
+ }
cmdFlags := []string{
"--output_base=" + absolutePath(context.paths.outputBase),
command.command,
command.expression,
"--profile=" + shared.BazelMetricsFilename(context.paths, runName),
- // We don't need to set --host_platforms because it's set in bazelrc files
- // that the bazel shell script wrapper passes
-
- // Optimize Ninja rebuilds by ensuring Bazel write into product-agnostic
- // output paths for the configured targets that shouldn't be affected by
- // TARGET_PRODUCT. Otherwise product agnostic modules will be rebuilt by
- // Ninja when the product changes, unconditionally.
- //
- // For example, Mainline APEXes should be identical regardless of the
- // product (modulo arch/cpu).
- //
- // This flag forcibly disables the platform prefix in the intermediate
- // outputs during a mixed build.
- "--noexperimental_platform_in_output_dir",
+ "--host_platform=@soong_injection//product_config_platforms:mixed_builds_product-" + context.targetBuildVariant + "_" + runtime.GOOS + "_x86_64",
+ // Don't specify --platforms, because on some products/branches (like kernel-build-tools)
+ // the main platform for mixed_builds_product-variant doesn't exist because an arch isn't
+ // specified in product config. The derivative platforms that config_node transitions into
+ // will still work.
// Suppress noise
"--ui_event_filters=-INFO",
@@ -755,9 +749,9 @@
#####################################################
def _config_node_transition_impl(settings, attr):
if attr.os == "android" and attr.arch == "target":
- target = "current_product-{VARIANT}"
+ target = "mixed_builds_product-{VARIANT}"
else:
- target = "current_product-{VARIANT}_%s_%s" % (attr.os, attr.arch)
+ target = "mixed_builds_product-{VARIANT}_%s_%s" % (attr.os, attr.arch)
apex_name = ""
if attr.within_apex:
# //build/bazel/rules/apex:apex_name has to be set to a non_empty value,
@@ -994,9 +988,9 @@
platform_name = platforms[0].name
if platform_name == "host":
return "HOST"
- if not platform_name.startswith("current_product-{TARGET_BUILD_VARIANT}"):
- fail("expected platform name of the form 'current_product-{TARGET_BUILD_VARIANT}_android_<arch>' or 'current_product-{TARGET_BUILD_VARIANT}_linux_<arch>', but was " + str(platforms))
- platform_name = platform_name.removeprefix("current_product-{TARGET_BUILD_VARIANT}").removeprefix("_")
+ if not platform_name.startswith("mixed_builds_product-{TARGET_BUILD_VARIANT}"):
+ fail("expected platform name of the form 'mixed_builds_product-{TARGET_BUILD_VARIANT}_android_<arch>' or 'mixed_builds_product-{TARGET_BUILD_VARIANT}_linux_<arch>', but was " + str(platforms))
+ platform_name = platform_name.removeprefix("mixed_builds_product-{TARGET_BUILD_VARIANT}").removeprefix("_")
config_key = ""
if not platform_name:
config_key = "target|android"
@@ -1005,7 +999,7 @@
elif platform_name.startswith("linux_"):
config_key = platform_name.removeprefix("linux_") + "|linux"
else:
- fail("expected platform name of the form 'current_product-{TARGET_BUILD_VARIANT}_android_<arch>' or 'current_product-{TARGET_BUILD_VARIANT}_linux_<arch>', but was " + str(platforms))
+ fail("expected platform name of the form 'mixed_builds_product-{TARGET_BUILD_VARIANT}_android_<arch>' or 'mixed_builds_product-{TARGET_BUILD_VARIANT}_linux_<arch>', but was " + str(platforms))
within_apex = buildoptions.get("//build/bazel/rules/apex:within_apex")
apex_sdk_version = buildoptions.get("//build/bazel/rules/apex:min_sdk_version")
diff --git a/android/test_asserts.go b/android/test_asserts.go
index 5cc7e4a..3a2cb1a 100644
--- a/android/test_asserts.go
+++ b/android/test_asserts.go
@@ -200,6 +200,22 @@
}
}
+// Asserts that each of the Paths in actual end with the corresponding string
+// from expected. Useful to test that output paths contain expected items without
+// hard-coding where intermediate files might be located.
+func AssertPathsEndWith(t *testing.T, message string, expected []string, actual []Path) {
+ t.Helper()
+ if len(expected) != len(actual) {
+ t.Errorf("%s (length): expected %d, actual %d", message, len(expected), len(actual))
+ return
+ }
+ for i := range expected {
+ if !strings.HasSuffix(actual[i].String(), expected[i]) {
+ t.Errorf("%s (item %d): expected '%s', actual '%s'", message, i, expected[i], actual[i].String())
+ }
+ }
+}
+
// AssertDeepEquals checks if the expected and actual values are equal using reflect.DeepEqual and
// if they are not then it reports an error prefixed with the supplied message and including a
// reason for why it failed.
diff --git a/bp2build/bp2build_product_config.go b/bp2build/bp2build_product_config.go
index 66d0cc5..7224496 100644
--- a/bp2build/bp2build_product_config.go
+++ b/bp2build/bp2build_product_config.go
@@ -72,8 +72,13 @@
load("//{PRODUCT_FOLDER}:soong.variables.bzl", _soong_variables = "variables")
load("@//build/bazel/product_config:android_product.bzl", "android_product")
+# Bazel will qualify its outputs by the platform name. When switching between products, this
+# means that soong-built files that depend on bazel-built files will suddenly get different
+# dependency files, because the path changes, and they will be rebuilt. In order to avoid this
+# extra rebuilding, make mixed builds always use a single platform so that the bazel artifacts
+# are always under the same path.
android_product(
- name = "current_product-{VARIANT}",
+ name = "mixed_builds_product-{VARIANT}",
soong_variables = _soong_variables,
)
`)),
@@ -86,7 +91,7 @@
# TODO: When we start generating the platforms for more than just the
# currently lunched product, they should all be listed here
product_labels = [
- "@soong_injection//product_config_platforms:current_product-{VARIANT}",
+ "@soong_injection//product_config_platforms:mixed_builds_product-{VARIANT}",
"@soong_injection//{PRODUCT_FOLDER}:{PRODUCT}-{VARIANT}"
]
`)),
@@ -94,38 +99,25 @@
"product_config_platforms",
"common.bazelrc",
productReplacer.Replace(`
-# current_product refers to the current TARGET_PRODUCT set, usually through
-# 'lunch' or 'banchan'. Every build will have a primary TARGET_PRODUCT, but
-# bazel supports using other products in tests or configuration transitions. The
-# other products can be found in
-# @soong_injection//product_config_platforms/products/...
-build --platforms @soong_injection//product_config_platforms:current_product-{VARIANT}_linux_x86_64
+build --platforms @soong_injection//{PRODUCT_FOLDER}:{PRODUCT}-{VARIANT}_linux_x86_64
-build:android --platforms=@soong_injection//product_config_platforms:current_product-{VARIANT}
-build:linux_x86_64 --platforms=@soong_injection//product_config_platforms:current_product-{VARIANT}_linux_x86_64
-build:linux_bionic_x86_64 --platforms=@soong_injection//product_config_platforms:current_product-{VARIANT}_linux_bionic_x86_64
-build:linux_musl_x86 --platforms=@soong_injection//product_config_platforms:current_product-{VARIANT}_linux_musl_x86
-build:linux_musl_x86_64 --platforms=@soong_injection//product_config_platforms:current_product-{VARIANT}_linux_musl_x86_64
+build:android --platforms=@soong_injection//{PRODUCT_FOLDER}:{PRODUCT}-{VARIANT}
+build:linux_x86_64 --platforms=@soong_injection//{PRODUCT_FOLDER}:{PRODUCT}-{VARIANT}_linux_x86_64
+build:linux_bionic_x86_64 --platforms=@soong_injection//{PRODUCT_FOLDER}:{PRODUCT}-{VARIANT}_linux_bionic_x86_64
+build:linux_musl_x86 --platforms=@soong_injection//{PRODUCT_FOLDER}:{PRODUCT}-{VARIANT}_linux_musl_x86
+build:linux_musl_x86_64 --platforms=@soong_injection//{PRODUCT_FOLDER}:{PRODUCT}-{VARIANT}_linux_musl_x86_64
`)),
newFile(
"product_config_platforms",
"linux.bazelrc",
productReplacer.Replace(`
-build --host_platform @soong_injection//product_config_platforms:current_product-{VARIANT}_linux_x86_64
+build --host_platform @soong_injection//{PRODUCT_FOLDER}:{PRODUCT}-{VARIANT}_linux_x86_64
`)),
newFile(
"product_config_platforms",
"darwin.bazelrc",
productReplacer.Replace(`
-build --host_platform product_config_platforms:current_product-{VARIANT}_darwin_x86_64
-`)),
- newFile(
- "product_config_platforms",
- "platform_mappings",
- productReplacer.Replace(`
-flags:
- --cpu=k8
- @soong_injection//product_config_platforms:current_product-{VARIANT}
+build --host_platform @soong_injection//{PRODUCT_FOLDER}:{PRODUCT}-{VARIANT}_darwin_x86_64
`)),
}
diff --git a/device_config/Android.bp b/device_config/Android.bp
index 360b389..6c44454 100644
--- a/device_config/Android.bp
+++ b/device_config/Android.bp
@@ -12,19 +12,21 @@
"soong",
"soong-android",
"soong-bazel",
- "soong-shared",
+ "soong-android",
+ "soong-java",
],
srcs: [
"device_config_definitions.go",
"device_config_values.go",
"device_config_value_set.go",
"init.go",
- //"testing.go"
+ "java_device_config_definitions_library.go",
+ "testing.go",
],
- /*
testSrcs: [
- "device_config_test.go",
+ "device_config_definitions_test.go",
+ "device_config_values_test.go",
+ "device_config_value_set_test.go",
],
- */
pluginFor: ["soong_build"],
}
diff --git a/device_config/device_config_definitions.go b/device_config/device_config_definitions.go
index c565766..bb78695 100644
--- a/device_config/device_config_definitions.go
+++ b/device_config/device_config_definitions.go
@@ -38,7 +38,6 @@
}
intermediatePath android.WritablePath
- srcJarPath android.WritablePath
}
func DefinitionsFactory() android.Module {
@@ -78,8 +77,6 @@
func (module *DefinitionsModule) OutputFiles(tag string) (android.Paths, error) {
switch tag {
- case ".srcjar":
- return []android.Path{module.srcJarPath}, nil
case "":
// The default output of this module is the intermediates format, which is
// not installable and in a private format that no other rules can handle
@@ -99,6 +96,14 @@
return sb.String()
}
+// Provider published by device_config_value_set
+type definitionsProviderData struct {
+ namespace string
+ intermediatePath android.WritablePath
+}
+
+var definitionsProviderKey = blueprint.NewProvider(definitionsProviderData{})
+
func (module *DefinitionsModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
// Get the values that came from the global RELEASE_DEVICE_CONFIG_VALUE_SETS flag
ctx.VisitDirectDeps(func(dep android.Module) {
@@ -117,11 +122,11 @@
// Intermediate format
inputFiles := android.PathsForModuleSrc(ctx, module.properties.Srcs)
- module.intermediatePath = android.PathForModuleOut(ctx, "intermediate.json")
+ intermediatePath := android.PathForModuleOut(ctx, "intermediate.json")
ctx.Build(pctx, android.BuildParams{
Rule: aconfigRule,
Inputs: inputFiles,
- Output: module.intermediatePath,
+ Output: intermediatePath,
Description: "device_config_definitions",
Args: map[string]string{
"release_version": ctx.Config().ReleaseVersion(),
@@ -130,21 +135,9 @@
},
})
- // Generated java inside a srcjar
- module.srcJarPath = android.PathForModuleGen(ctx, ctx.ModuleName()+".srcjar")
- ctx.Build(pctx, android.BuildParams{
- Rule: srcJarRule,
- Input: module.intermediatePath,
- Output: module.srcJarPath,
- Description: "device_config.srcjar",
+ ctx.SetProvider(definitionsProviderKey, definitionsProviderData{
+ namespace: module.properties.Namespace,
+ intermediatePath: intermediatePath,
})
- // TODO: C++
-
- // Phony target for debugging convenience
- ctx.Build(pctx, android.BuildParams{
- Rule: blueprint.Phony,
- Output: android.PathForPhony(ctx, ctx.ModuleName()),
- Inputs: []android.Path{module.srcJarPath}, // TODO: C++
- })
}
diff --git a/device_config/device_config_definitions_test.go b/device_config/device_config_definitions_test.go
new file mode 100644
index 0000000..49afcc4
--- /dev/null
+++ b/device_config/device_config_definitions_test.go
@@ -0,0 +1,42 @@
+// Copyright 2018 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package device_config
+
+import (
+ "strings"
+ "testing"
+
+ "android/soong/android"
+)
+
+func TestDeviceConfigDefinitions(t *testing.T) {
+ bp := `
+ device_config_definitions {
+ name: "module_name",
+ namespace: "com.example.package",
+ srcs: ["foo.aconfig"],
+ }
+ `
+ result := runTest(t, android.FixtureExpectsNoErrors, bp)
+
+ module := result.ModuleForTests("module_name", "").Module().(*DefinitionsModule)
+
+ // Check that the provider has the right contents
+ depData := result.ModuleProvider(module, definitionsProviderKey).(definitionsProviderData)
+ android.AssertStringEquals(t, "namespace", depData.namespace, "com.example.package")
+ if !strings.HasSuffix(depData.intermediatePath.String(), "/intermediate.json") {
+ t.Errorf("Missing intermediates path in provider: %s", depData.intermediatePath.String())
+ }
+}
diff --git a/device_config/device_config_test.go b/device_config/device_config_test.go
deleted file mode 100644
index 91a06a7..0000000
--- a/device_config/device_config_test.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (C) 2019 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package device_config
-
-import (
- "os"
- "testing"
-
- "android/soong/android"
- "android/soong/java"
-)
-
-func TestMain(m *testing.M) {
- os.Exit(m.Run())
-}
-
-func test(t *testing.T, bp string) *android.TestResult {
- t.Helper()
-
- mockFS := android.MockFS{
- "config.aconfig": nil,
- }
-
- result := android.GroupFixturePreparers(
- java.PrepareForTestWithJavaDefaultModules,
- PrepareForTestWithSyspropBuildComponents,
- // TODO: Consider values files, although maybe in its own test
- // android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
- // variables.ReleaseConfigValuesBasePaths = ...
- //})
- mockFS.AddToFixture(),
- android.FixtureWithRootAndroidBp(bp),
- ).RunTest(t)
-
- return result
-}
-
-func TestOutputs(t *testing.T) {
- /*result := */ test(t, `
- device_config {
- name: "my_device_config",
- srcs: ["config.aconfig"],
- }
- `)
-
- // TODO: Make sure it exports a .srcjar, which is used by java libraries
- // TODO: Make sure it exports an intermediates file
- // TODO: Make sure the intermediates file is propagated to the Android.mk file
-}
diff --git a/device_config/device_config_value_set_test.go b/device_config/device_config_value_set_test.go
new file mode 100644
index 0000000..f9e7c38
--- /dev/null
+++ b/device_config/device_config_value_set_test.go
@@ -0,0 +1,43 @@
+// Copyright 2018 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package device_config
+
+import (
+ "testing"
+
+ "android/soong/android"
+)
+
+func TestDeviceConfigValueSet(t *testing.T) {
+ bp := `
+ device_config_values {
+ name: "one",
+ srcs: [ "blah.aconfig_values" ],
+ namespace: "foo.namespace"
+ }
+
+ device_config_value_set {
+ name: "module_name",
+ values: [ "one" ],
+ }
+ `
+ result := runTest(t, android.FixtureExpectsNoErrors, bp)
+
+ module := result.ModuleForTests("module_name", "").Module().(*ValueSetModule)
+
+ // Check that the provider has the right contents
+ depData := result.ModuleProvider(module, valueSetProviderKey).(valueSetProviderData)
+ android.AssertStringEquals(t, "AvailableNamespaces", "blah.aconfig_values", depData.AvailableNamespaces["foo.namespace"][0].String())
+}
diff --git a/device_config/device_config_values_test.go b/device_config/device_config_values_test.go
new file mode 100644
index 0000000..64c57eb
--- /dev/null
+++ b/device_config/device_config_values_test.go
@@ -0,0 +1,39 @@
+// Copyright 2018 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package device_config
+
+import (
+ "testing"
+
+ "android/soong/android"
+)
+
+func TestDeviceConfigValues(t *testing.T) {
+ bp := `
+ device_config_values {
+ name: "module_name",
+ srcs: [ "blah.aconfig_values" ],
+ namespace: "foo.namespace"
+ }
+ `
+ result := runTest(t, android.FixtureExpectsNoErrors, bp)
+
+ module := result.ModuleForTests("module_name", "").Module().(*ValuesModule)
+
+ // Check that the provider has the right contents
+ depData := result.ModuleProvider(module, valuesProviderKey).(valuesProviderData)
+ android.AssertStringEquals(t, "namespace", "foo.namespace", depData.Namespace)
+ android.AssertPathsEndWith(t, "srcs", []string{"blah.aconfig_values"}, depData.Values)
+}
diff --git a/device_config/init.go b/device_config/init.go
index 6d235c4..04bbab6 100644
--- a/device_config/init.go
+++ b/device_config/init.go
@@ -23,7 +23,6 @@
pctx = android.NewPackageContext("android/soong/device_config")
// For device_config_definitions: Generate cache file
- // TODO: Restat
aconfigRule = pctx.AndroidStaticRule("aconfig",
blueprint.RuleParams{
Command: `${aconfig} create-cache` +
@@ -39,7 +38,7 @@
Restat: true,
}, "release_version", "namespace", "values")
- // For device_config_definitions: Generate java file
+ // For java_device_config_definitions_library: Generate java file
srcJarRule = pctx.AndroidStaticRule("aconfig_srcjar",
blueprint.RuleParams{
Command: `rm -rf ${out}.tmp` +
@@ -59,12 +58,13 @@
func init() {
registerBuildComponents(android.InitRegistrationContext)
+ pctx.HostBinToolVariable("aconfig", "aconfig")
+ pctx.HostBinToolVariable("soong_zip", "soong_zip")
}
func registerBuildComponents(ctx android.RegistrationContext) {
ctx.RegisterModuleType("device_config_definitions", DefinitionsFactory)
ctx.RegisterModuleType("device_config_values", ValuesFactory)
ctx.RegisterModuleType("device_config_value_set", ValueSetFactory)
- pctx.HostBinToolVariable("aconfig", "aconfig")
- pctx.HostBinToolVariable("soong_zip", "soong_zip")
+ ctx.RegisterModuleType("java_device_config_definitions_library", JavaDefinitionsLibraryFactory)
}
diff --git a/device_config/java_device_config_definitions_library.go b/device_config/java_device_config_definitions_library.go
new file mode 100644
index 0000000..6e48ece
--- /dev/null
+++ b/device_config/java_device_config_definitions_library.go
@@ -0,0 +1,71 @@
+// Copyright 2023 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package device_config
+
+import (
+ "android/soong/android"
+ "android/soong/java"
+ "fmt"
+ "github.com/google/blueprint"
+)
+
+type definitionsTagType struct {
+ blueprint.BaseDependencyTag
+}
+
+var definitionsTag = definitionsTagType{}
+
+type JavaDeviceConfigDefinitionsLibraryProperties struct {
+ // name of the device_config_definitions module to generate a library for
+ Device_config_definitions string
+}
+
+type JavaDeviceConfigDefinitionsLibraryCallbacks struct {
+ properties JavaDeviceConfigDefinitionsLibraryProperties
+}
+
+func JavaDefinitionsLibraryFactory() android.Module {
+ callbacks := &JavaDeviceConfigDefinitionsLibraryCallbacks{}
+ return java.GeneratedJavaLibraryModuleFactory("java_device_config_definitions_library", callbacks, &callbacks.properties)
+}
+
+func (callbacks *JavaDeviceConfigDefinitionsLibraryCallbacks) DepsMutator(module *java.GeneratedJavaLibraryModule, ctx android.BottomUpMutatorContext) {
+ definitions := callbacks.properties.Device_config_definitions
+ if len(definitions) == 0 {
+ // TODO: Add test for this case
+ ctx.PropertyErrorf("device_config_definitions", "device_config_definitions property required")
+ } else {
+ ctx.AddDependency(ctx.Module(), definitionsTag, definitions)
+ }
+}
+
+func (callbacks *JavaDeviceConfigDefinitionsLibraryCallbacks) GenerateSourceJarBuildActions(ctx android.ModuleContext) android.Path {
+ // Get the values that came from the global RELEASE_DEVICE_CONFIG_VALUE_SETS flag
+ definitionsModules := ctx.GetDirectDepsWithTag(definitionsTag)
+ if len(definitionsModules) != 1 {
+ panic(fmt.Errorf("Exactly one device_config_definitions property required"))
+ }
+ definitions := ctx.OtherModuleProvider(definitionsModules[0], definitionsProviderKey).(definitionsProviderData)
+
+ srcJarPath := android.PathForModuleGen(ctx, ctx.ModuleName()+".srcjar")
+ ctx.Build(pctx, android.BuildParams{
+ Rule: srcJarRule,
+ Input: definitions.intermediatePath,
+ Output: srcJarPath,
+ Description: "device_config.srcjar",
+ })
+
+ return srcJarPath
+}
diff --git a/device_config/testing.go b/device_config/testing.go
index f054476..284a7fa 100644
--- a/device_config/testing.go
+++ b/device_config/testing.go
@@ -14,6 +14,16 @@
package device_config
-import "android/soong/android"
+import (
+ "testing"
-var PrepareForTestWithSyspropBuildComponents = android.FixtureRegisterWithContext(registerBuildComponents)
+ "android/soong/android"
+)
+
+var PrepareForTestWithDeviceConfigBuildComponents = android.FixtureRegisterWithContext(registerBuildComponents)
+
+func runTest(t *testing.T, errorHandler android.FixtureErrorHandler, bp string) *android.TestResult {
+ return android.GroupFixturePreparers(PrepareForTestWithDeviceConfigBuildComponents).
+ ExtendWithErrorHandler(errorHandler).
+ RunTestWithBp(t, bp)
+}
diff --git a/java/Android.bp b/java/Android.bp
index 4af2a14..e079869 100644
--- a/java/Android.bp
+++ b/java/Android.bp
@@ -48,6 +48,7 @@
"droidstubs.go",
"fuzz.go",
"gen.go",
+ "generated_java_library.go",
"genrule.go",
"hiddenapi.go",
"hiddenapi_modular.go",
@@ -92,6 +93,7 @@
"droidstubs_test.go",
"fuzz_test.go",
"genrule_test.go",
+ "generated_java_library_test.go",
"hiddenapi_singleton_test.go",
"jacoco_test.go",
"java_test.go",
diff --git a/java/base.go b/java/base.go
index ed61e12..afb626a 100644
--- a/java/base.go
+++ b/java/base.go
@@ -187,6 +187,9 @@
// A list of java_library instances that provide additional hiddenapi annotations for the library.
Hiddenapi_additional_annotations []string
+
+ // Additional srcJars tacked in by GeneratedJavaLibraryModule
+ Generated_srcjars []android.Path `android:"mutated"`
}
// Properties that are specific to device modules. Host module factories should not add these when
@@ -1041,6 +1044,10 @@
}
+func (module *Module) addGeneratedSrcJars(path android.Path) {
+ module.properties.Generated_srcjars = append(module.properties.Generated_srcjars, path)
+}
+
func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) {
j.exportAidlIncludeDirs = android.PathsForModuleSrc(ctx, j.deviceProperties.Aidl.Export_include_dirs)
@@ -1082,6 +1089,10 @@
if aaptSrcJar != nil {
srcJars = append(srcJars, aaptSrcJar)
}
+ srcJars = append(srcJars, j.properties.Generated_srcjars...)
+ if len(j.properties.Generated_srcjars) > 0 {
+ fmt.Printf("Java module %s Generated_srcjars: %v\n", ctx.ModuleName(), j.properties.Generated_srcjars)
+ }
srcFiles = srcFiles.FilterOutByExt(".srcjar")
if j.properties.Jarjar_rules != nil {
diff --git a/java/builder.go b/java/builder.go
index 0c57738..c4395e9 100644
--- a/java/builder.go
+++ b/java/builder.go
@@ -305,6 +305,12 @@
proto android.ProtoFlags
}
+func DefaultJavaBuilderFlags() javaBuilderFlags {
+ return javaBuilderFlags{
+ javaVersion: JAVA_VERSION_8,
+ }
+}
+
func TransformJavaToClasses(ctx android.ModuleContext, outputFile android.WritablePath, shardIdx int,
srcFiles, srcJars android.Paths, flags javaBuilderFlags, deps android.Paths) {
diff --git a/java/generated_java_library.go b/java/generated_java_library.go
new file mode 100644
index 0000000..1b3de9f
--- /dev/null
+++ b/java/generated_java_library.go
@@ -0,0 +1,94 @@
+// Copyright 2023 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package java
+
+import (
+ "android/soong/android"
+)
+
+type GeneratedJavaLibraryModule struct {
+ Library
+ callbacks GeneratedJavaLibraryCallbacks
+ moduleName string
+}
+
+type GeneratedJavaLibraryCallbacks interface {
+ // Called from inside DepsMutator, gives a chance to AddDependencies
+ DepsMutator(module *GeneratedJavaLibraryModule, ctx android.BottomUpMutatorContext)
+
+ // Called from inside GenerateAndroidBuildActions. Add the build rules to
+ // make the srcjar, and return the path to it.
+ GenerateSourceJarBuildActions(ctx android.ModuleContext) android.Path
+}
+
+// GeneratedJavaLibraryModuleFactory provides a utility for modules that are generated
+// source code, including ones outside the java package to build jar files
+// from that generated source.
+//
+// To use GeneratedJavaLibraryModule, call GeneratedJavaLibraryModuleFactory with
+// a callback interface and a properties object to add to the module.
+//
+// These modules will have some properties blocked, and it will be an error if
+// modules attempt to set them. See the list of property names in GeneratedAndroidBuildActions
+// for the list of those properties.
+func GeneratedJavaLibraryModuleFactory(moduleName string, callbacks GeneratedJavaLibraryCallbacks, properties interface{}) android.Module {
+ module := &GeneratedJavaLibraryModule{
+ callbacks: callbacks,
+ moduleName: moduleName,
+ }
+ module.addHostAndDeviceProperties()
+ module.initModuleAndImport(module)
+ android.InitApexModule(module)
+ android.InitBazelModule(module)
+ InitJavaModule(module, android.HostAndDeviceSupported)
+ if properties != nil {
+ module.AddProperties(properties)
+ }
+ return module
+}
+
+func (module *GeneratedJavaLibraryModule) DepsMutator(ctx android.BottomUpMutatorContext) {
+ module.callbacks.DepsMutator(module, ctx)
+ module.Library.DepsMutator(ctx)
+}
+
+func checkPropertyEmpty(ctx android.ModuleContext, module *GeneratedJavaLibraryModule, name string, value []string) {
+ if len(value) != 0 {
+ ctx.PropertyErrorf(name, "%s not allowed on %s", name, module.moduleName)
+ }
+}
+
+func (module *GeneratedJavaLibraryModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+ // These modules are all-generated, so disallow these properties to keep it simple.
+ // No additional sources
+ checkPropertyEmpty(ctx, module, "srcs", module.Library.properties.Srcs)
+ checkPropertyEmpty(ctx, module, "common_srcs", module.Library.properties.Common_srcs)
+ checkPropertyEmpty(ctx, module, "exclude_srcs", module.Library.properties.Exclude_srcs)
+ checkPropertyEmpty(ctx, module, "java_resource_dirs", module.Library.properties.Java_resource_dirs)
+ checkPropertyEmpty(ctx, module, "exclude_java_resource_dirs", module.Library.properties.Exclude_java_resource_dirs)
+ // No additional libraries. The generator should add anything necessary automatically
+ // by returning something from ____ (TODO: Additional libraries aren't needed now, so
+ // these are just blocked).
+ checkPropertyEmpty(ctx, module, "libs", module.Library.properties.Libs)
+ checkPropertyEmpty(ctx, module, "static_libs", module.Library.properties.Static_libs)
+ // Restrict these for no good reason other than to limit the surface area. If there's a
+ // good use case put them back.
+ checkPropertyEmpty(ctx, module, "plugins", module.Library.properties.Plugins)
+ checkPropertyEmpty(ctx, module, "exported_plugins", module.Library.properties.Exported_plugins)
+
+ srcJarPath := module.callbacks.GenerateSourceJarBuildActions(ctx)
+ module.Library.properties.Generated_srcjars = append(module.Library.properties.Generated_srcjars, srcJarPath)
+ module.Library.GenerateAndroidBuildActions(ctx)
+}
diff --git a/java/generated_java_library_test.go b/java/generated_java_library_test.go
new file mode 100644
index 0000000..68f1f7e
--- /dev/null
+++ b/java/generated_java_library_test.go
@@ -0,0 +1,65 @@
+// Copyright 2018 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package java
+
+import (
+ "testing"
+
+ "android/soong/android"
+)
+
+func JavaGenLibTestFactory() android.Module {
+ callbacks := &JavaGenLibTestCallbacks{}
+ return GeneratedJavaLibraryModuleFactory("test_java_gen_lib", callbacks, &callbacks.properties)
+}
+
+type JavaGenLibTestProperties struct {
+ Foo string
+}
+
+type JavaGenLibTestCallbacks struct {
+ properties JavaGenLibTestProperties
+}
+
+func (callbacks *JavaGenLibTestCallbacks) DepsMutator(module *GeneratedJavaLibraryModule, ctx android.BottomUpMutatorContext) {
+}
+
+func (callbacks *JavaGenLibTestCallbacks) GenerateSourceJarBuildActions(ctx android.ModuleContext) android.Path {
+ return android.PathForOutput(ctx, "blah.srcjar")
+}
+
+func testGenLib(t *testing.T, errorHandler android.FixtureErrorHandler, bp string) *android.TestResult {
+ return android.GroupFixturePreparers(
+ PrepareForIntegrationTestWithJava,
+ android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) {
+ ctx.RegisterModuleType("test_java_gen_lib", JavaGenLibTestFactory)
+ }),
+ ).
+ ExtendWithErrorHandler(errorHandler).
+ RunTestWithBp(t, bp)
+}
+
+func TestGenLib(t *testing.T) {
+ bp := `
+ test_java_gen_lib {
+ name: "javagenlibtest",
+ foo: "bar", // Note: This won't parse if the property didn't get added
+ }
+ `
+ result := testGenLib(t, android.FixtureExpectsNoErrors, bp)
+
+ javagenlibtest := result.ModuleForTests("javagenlibtest", "android_common").Module().(*GeneratedJavaLibraryModule)
+ android.AssertPathsEndWith(t, "Generated_srcjars", []string{"/blah.srcjar"}, javagenlibtest.Library.properties.Generated_srcjars)
+}
diff --git a/java/java.go b/java/java.go
index 3a80471..a026610 100644
--- a/java/java.go
+++ b/java/java.go
@@ -273,6 +273,8 @@
// JacocoReportClassesFile is the path to a jar containing uninstrumented classes that will be
// instrumented by jacoco.
JacocoReportClassesFile android.Path
+
+ // TODO: Add device config declarations here?
}
var JavaInfoProvider = blueprint.NewProvider(JavaInfo{})
diff --git a/tests/bp2build_bazel_test.sh b/tests/bp2build_bazel_test.sh
index 1ee3a32..090114b 100755
--- a/tests/bp2build_bazel_test.sh
+++ b/tests/bp2build_bazel_test.sh
@@ -439,4 +439,39 @@
run_bazel build --config=android --config=api_bp2build //foo:libfoo.contribution
}
+function test_bazel_standalone_output_paths_contain_product_name {
+ setup
+ mkdir -p a
+ cat > a/Android.bp <<EOF
+cc_object {
+ name: "qq",
+ srcs: ["qq.cc"],
+ bazel_module: {
+ bp2build_available: true,
+ },
+ stl: "none",
+ system_shared_libs: [],
+}
+EOF
+
+ cat > a/qq.cc <<EOF
+#include "qq.h"
+int qq() {
+ return QQ;
+}
+EOF
+
+ cat > a/qq.h <<EOF
+#define QQ 1
+EOF
+
+ export TARGET_PRODUCT=aosp_arm; run_soong bp2build
+ local -r output=$(run_bazel cquery //a:qq --output=files --config=android --config=bp2build --config=ci)
+ if [[ ! $(echo ${output} | grep "bazel-out/aosp_arm") ]]; then
+ fail "Did not find the product name '${TARGET_PRODUCT}' in the output path. This can cause " \
+ "unnecessary rebuilds when toggling between products as bazel outputs for different products will " \
+ "clobber each other. Output paths are: \n${output}"
+ fi
+}
+
scan_and_run_tests
diff --git a/tests/genrule_sandbox_test.py b/tests/genrule_sandbox_test.py
new file mode 100755
index 0000000..697fc26
--- /dev/null
+++ b/tests/genrule_sandbox_test.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2023 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import collections
+import json
+import os.path
+import subprocess
+import tempfile
+
+SRC_ROOT_DIR = os.path.abspath(__file__ + "/../../../..")
+
+
+def _module_graph_path(out_dir):
+ return os.path.join(SRC_ROOT_DIR, out_dir, "soong", "module-actions.json")
+
+
+def _build_with_soong(targets, target_product, out_dir, extra_env={}):
+ env = {
+ "TARGET_PRODUCT": target_product,
+ "TARGET_BUILD_VARIANT": "userdebug",
+ }
+ env.update(os.environ)
+ env.update(extra_env)
+ args = [
+ "build/soong/soong_ui.bash",
+ "--make-mode",
+ "--skip-soong-tests",
+ ]
+ args.extend(targets)
+ try:
+ out = subprocess.check_output(
+ args,
+ cwd=SRC_ROOT_DIR,
+ env=env,
+ )
+ except subprocess.CalledProcessError as e:
+ print(e)
+ print(e.stdout)
+ print(e.stderr)
+ exit(1)
+
+
+def _find_outputs_for_modules(modules, out_dir, target_product):
+ module_path = os.path.join(
+ SRC_ROOT_DIR, out_dir, "soong", "module-actions.json"
+ )
+
+ if not os.path.exists(module_path):
+ _build_with_soong(["json-module-graph"], target_product, out_dir)
+
+ action_graph = json.load(open(_module_graph_path(out_dir)))
+
+ module_to_outs = collections.defaultdict(set)
+ for mod in action_graph:
+ name = mod["Name"]
+ if name in modules:
+ for act in mod["Module"]["Actions"]:
+ if "}generate " in act["Desc"]:
+ module_to_outs[name].update(act["Outputs"])
+ return module_to_outs
+
+
+def _store_outputs_to_tmp(output_files):
+ try:
+ tempdir = tempfile.TemporaryDirectory()
+ for f in output_files:
+ out = subprocess.check_output(
+ ["cp", "--parents", f, tempdir.name],
+ cwd=SRC_ROOT_DIR,
+ )
+ return tempdir
+ except subprocess.CalledProcessError as e:
+ print(e)
+ print(e.stdout)
+ print(e.stderr)
+
+
+def _diff_outs(file1, file2, show_diff):
+ base_args = ["diff"]
+ if not show_diff:
+ base_args.append("--brief")
+ try:
+ args = base_args + [file1, file2]
+ output = subprocess.check_output(
+ args,
+ cwd=SRC_ROOT_DIR,
+ )
+ except subprocess.CalledProcessError as e:
+ if e.returncode == 1:
+ if show_diff:
+ return output
+ return True
+ return None
+
+
+def _compare_outputs(module_to_outs, tempdir, show_diff):
+ different_modules = collections.defaultdict(list)
+ for module, outs in module_to_outs.items():
+ for out in outs:
+ output = None
+ diff = _diff_outs(os.path.join(tempdir.name, out), out, show_diff)
+ if diff:
+ different_modules[module].append(diff)
+
+ tempdir.cleanup()
+ return different_modules
+
+
+def main():
+ parser = argparse.ArgumentParser()
+ parser.add_argument(
+ "--target_product",
+ "-t",
+ default="aosp_cf_arm64_phone",
+ help="optional, target product, always runs as eng",
+ )
+ parser.add_argument(
+ "modules",
+ nargs="+",
+ help="modules to compare builds with genrule sandboxing enabled/not",
+ )
+ parser.add_argument(
+ "--show-diff",
+ "-d",
+ action="store_true",
+ required=False,
+ help="whether to display differing files",
+ )
+ parser.add_argument(
+ "--output-paths-only",
+ "-o",
+ action="store_true",
+ required=False,
+ help="Whether to only return the output paths per module",
+ )
+ args = parser.parse_args()
+
+ out_dir = os.environ.get("OUT_DIR", "out")
+ target_product = args.target_product
+ modules = set(args.modules)
+
+ module_to_outs = _find_outputs_for_modules(modules, out_dir, target_product)
+ if args.output_paths_only:
+ for m, o in module_to_outs.items():
+ print(f"{m} outputs: {o}")
+ exit(0)
+
+ all_outs = set()
+ for outs in module_to_outs.values():
+ all_outs.update(outs)
+ print("build without sandboxing")
+ _build_with_soong(list(all_outs), target_product, out_dir)
+ tempdir = _store_outputs_to_tmp(all_outs)
+ print("build with sandboxing")
+ _build_with_soong(
+ list(all_outs),
+ target_product,
+ out_dir,
+ extra_env={"GENRULE_SANDBOXING": "true"},
+ )
+ diffs = _compare_outputs(module_to_outs, tempdir, args.show_diff)
+ if len(diffs) == 0:
+ print("All modules are correct")
+ elif args.show_diff:
+ for m, d in diffs.items():
+ print(f"Module {m} has diffs {d}")
+ else:
+ print(f"Modules {list(diffs.keys())} have diffs")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tests/genrule_sandbox_test.sh b/tests/genrule_sandbox_test.sh
deleted file mode 100755
index 21b476b..0000000
--- a/tests/genrule_sandbox_test.sh
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/bin/bash
-
-# Copyright (C) 2023 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-set -e
-
-# Build the given genrule modules with GENRULE_SANDBOXING enabled and disabled,
-# then compare the output of the modules and report result.
-
-function die() { format=$1; shift; printf >&2 "$format\n" $@; exit 1; }
-
-function usage() {
- die "usage: ${0##*/} <-t lunch_target> [module]..."
-}
-
-if [ ! -e "build/make/core/Makefile" ]; then
- die "$0 must be run from the top of the Android source tree."
-fi
-
-declare TARGET=
-while getopts "t:" opt; do
- case $opt in
- t)
- TARGET=$OPTARG ;;
- *) usage ;;
- esac
-done
-
-shift $((OPTIND-1))
-MODULES="$@"
-
-source build/envsetup.sh
-
-if [[ -n $TARGET ]]; then
- lunch $TARGET
-fi
-
-if [[ -z ${OUT_DIR+x} ]]; then
- OUT_DIR="out"
-fi
-
-OUTPUT_DIR="$(mktemp -d tmp.XXXXXX)"
-PASS=true
-
-function cleanup {
- if [ $PASS = true ]; then
- rm -rf "${OUTPUT_DIR}"
- fi
-}
-trap cleanup EXIT
-
-declare -A GEN_PATH_MAP
-
-function find_gen_paths() {
- for module in $MODULES; do
- module_path=$(pathmod "$module")
- package_path=${module_path#$ANDROID_BUILD_TOP}
- gen_path=$OUT_DIR/soong/.intermediates$package_path/$module
- GEN_PATH_MAP[$module]=$gen_path
- done
-}
-
-function store_outputs() {
- local dir=$1; shift
-
- for module in $MODULES; do
- dest_dir=$dir/${module}
- mkdir -p $dest_dir
- gen_path=${GEN_PATH_MAP[$module]}
- cp -r $gen_path $dest_dir
- done
-}
-
-function cmp_outputs() {
- local dir1=$1; shift
- local dir2=$1; shift
-
- for module in $MODULES; do
- if ! diff -rq --exclude=genrule.sbox.textproto $dir1/$module $dir2/$module; then
- PASS=false
- echo "$module differ"
- fi
- done
- if [ $PASS = true ]; then
- echo "Test passed"
- fi
-}
-
-if [ ! -f "$ANDROID_PRODUCT_OUT/module-info.json" ]; then
- refreshmod
-fi
-
-find_gen_paths
-m --skip-soong-tests GENRULE_SANDBOXING=true "${MODULES[@]}"
-store_outputs "$OUTPUT_DIR/sandbox"
-m --skip-soong-tests GENRULE_SANDBOXING=false "${MODULES[@]}"
-store_outputs "$OUTPUT_DIR/non_sandbox"
-
-cmp_outputs "$OUTPUT_DIR/non_sandbox" "$OUTPUT_DIR/sandbox"