Remove host_snapshot module (ef693fc9) · Commits · e / os / android_build_soong

snapshot/Android.bp

+0 −4

Original line number	Diff line number	Diff line
		@@ -14,12 +14,8 @@ bootstrap_go_package {
		// Source file name convention is to include _snapshot as a
		// file suffix for files that are generating snapshots.
		srcs: [
		"host_snapshot.go",
		"snapshot_base.go",
		"util.go",
		],
		testSrcs: [
		"host_test.go",
		],
		pluginFor: ["soong_build"],
		}

snapshot/host_snapshot.go

deleted100644 → 0

+0 −238

Original line number	Diff line number	Diff line
		// Copyright 2021 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 snapshot

		import (
		"encoding/json"
		"fmt"
		"path/filepath"
		"sort"
		"strings"

		"github.com/google/blueprint"
		"github.com/google/blueprint/proptools"

		"android/soong/android"
		)

		//
		// The host_snapshot module creates a snapshot of the modules defined in
		// the deps property. The modules within the deps property (host tools)
		// are ones that return a valid path via HostToolPath() of the
		// HostToolProvider. The created snapshot contains the binaries and any
		// transitive PackagingSpecs of the included host tools, along with a JSON
		// meta file.
		//
		// The snapshot is installed into a source tree via
		// development/vendor_snapshot/update.py, the included modules are
		// provided as preferred prebuilts.
		//
		// To determine which tools to include in the host snapshot see
		// host_fake_snapshot.go.

		func init() {
		registerHostBuildComponents(android.InitRegistrationContext)
		}

		func registerHostBuildComponents(ctx android.RegistrationContext) {
		ctx.RegisterModuleType("host_snapshot", hostSnapshotFactory)
		}

		// Relative installation path
		type RelativeInstallPath interface {
		RelativeInstallPath() string
		}

		type hostSnapshot struct {
		android.ModuleBase
		android.PackagingBase

		outputFile android.OutputPath
		installDir android.InstallPath
		}

		type ProcMacro interface {
		ProcMacro() bool
		CrateName() string
		}

		func hostSnapshotFactory() android.Module {
		module := &hostSnapshot{}
		initHostToolsModule(module)
		return module
		}
		func initHostToolsModule(module *hostSnapshot) {
		android.InitPackageModule(module)
		android.InitAndroidMultiTargetsArchModule(module, android.HostSupported, android.MultilibCommon)
		}

		var dependencyTag = struct {
		blueprint.BaseDependencyTag
		android.InstallAlwaysNeededDependencyTag
		android.PackagingItemAlwaysDepTag
		}{}

		func (f *hostSnapshot) DepsMutator(ctx android.BottomUpMutatorContext) {
		f.AddDeps(ctx, dependencyTag)
		}
		func (f *hostSnapshot) installFileName() string {
		return f.Name() + ".zip"
		}

		// Create zipfile with JSON description, notice files... for dependent modules
		func (f *hostSnapshot) CreateMetaData(ctx android.ModuleContext, fileName string) android.OutputPath {
		var jsonData []SnapshotJsonFlags
		var metaPaths android.Paths

		installedNotices := make(map[string]bool)
		metaZipFile := android.PathForModuleOut(ctx, fileName).OutputPath

		// Create JSON file based on the direct dependencies
		ctx.VisitDirectDeps(func(dep android.Module) {
		desc := hostJsonDesc(ctx, dep)
		if desc != nil {
		jsonData = append(jsonData, *desc)
		}
		for _, notice := range dep.EffectiveLicenseFiles() {
		if _, ok := installedNotices[notice.String()]; !ok {
		installedNotices[notice.String()] = true
		noticeOut := android.PathForModuleOut(ctx, "NOTICE_FILES", notice.String()).OutputPath
		CopyFileToOutputPathRule(pctx, ctx, notice, noticeOut)
		metaPaths = append(metaPaths, noticeOut)
		}
		}
		})
		// Sort notice paths and json data for repeatble build
		sort.Slice(jsonData, func(i, j int) bool {
		return (jsonData[i].ModuleName < jsonData[j].ModuleName)
		})
		sort.Slice(metaPaths, func(i, j int) bool {
		return (metaPaths[i].String() < metaPaths[j].String())
		})

		marsh, err := json.Marshal(jsonData)
		if err != nil {
		ctx.ModuleErrorf("host snapshot json marshal failure: %#v", err)
		return android.OutputPath{}
		}

		jsonZipFile := android.PathForModuleOut(ctx, "host_snapshot.json").OutputPath
		metaPaths = append(metaPaths, jsonZipFile)
		rspFile := android.PathForModuleOut(ctx, "host_snapshot.rsp").OutputPath
		android.WriteFileRule(ctx, jsonZipFile, string(marsh))

		builder := android.NewRuleBuilder(pctx, ctx)

		builder.Command().
		BuiltTool("soong_zip").
		FlagWithArg("-C ", android.PathForModuleOut(ctx).OutputPath.String()).
		FlagWithOutput("-o ", metaZipFile).
		FlagWithRspFileInputList("-r ", rspFile, metaPaths)
		builder.Build("zip_meta", fmt.Sprintf("zipping meta data for %s", ctx.ModuleName()))

		return metaZipFile
		}

		// Create the host tool zip file
		func (f *hostSnapshot) GenerateAndroidBuildActions(ctx android.ModuleContext) {
		// Create a zip file for the binaries, and a zip of the meta data, then merge zips
		depsZipFile := android.PathForModuleOut(ctx, f.Name()+"_deps.zip").OutputPath
		modsZipFile := android.PathForModuleOut(ctx, f.Name()+"_mods.zip").OutputPath
		f.outputFile = android.PathForModuleOut(ctx, f.installFileName()).OutputPath

		f.installDir = android.PathForModuleInstall(ctx)

		f.CopyDepsToZip(ctx, f.GatherPackagingSpecs(ctx), depsZipFile)

		builder := android.NewRuleBuilder(pctx, ctx)
		builder.Command().
		BuiltTool("zip2zip").
		FlagWithInput("-i ", depsZipFile).
		FlagWithOutput("-o ", modsZipFile).
		Text("*/:" + proptools.ShellEscape(f.installDir.String()))

		metaZipFile := f.CreateMetaData(ctx, f.Name()+"_meta.zip")

		builder.Command().
		BuiltTool("merge_zips").
		Output(f.outputFile).
		Input(metaZipFile).
		Input(modsZipFile)

		builder.Build("manifest", fmt.Sprintf("Adding manifest %s", f.installFileName()))
		ctx.InstallFile(f.installDir, f.installFileName(), f.outputFile)

		}

		// Implements android.AndroidMkEntriesProvider
		func (f *hostSnapshot) AndroidMkEntries() []android.AndroidMkEntries {
		return []android.AndroidMkEntries{android.AndroidMkEntries{
		Class: "ETC",
		OutputFile: android.OptionalPathForPath(f.outputFile),
		DistFiles: android.MakeDefaultDistFiles(f.outputFile),
		ExtraEntries: []android.AndroidMkExtraEntriesFunc{
		func(ctx android.AndroidMkExtraEntriesContext, entries *android.AndroidMkEntries) {
		entries.SetString("LOCAL_MODULE_PATH", f.installDir.String())
		entries.SetString("LOCAL_INSTALLED_MODULE_STEM", f.installFileName())
		},
		},
		}}
		}

		// Get host tools path and relative install string helpers
		func hostToolPath(m android.Module) android.OptionalPath {
		if provider, ok := m.(android.HostToolProvider); ok {
		return provider.HostToolPath()
		}
		return android.OptionalPath{}

		}
		func hostRelativePathString(m android.Module) string {
		var outString string
		if rel, ok := m.(RelativeInstallPath); ok {
		outString = rel.RelativeInstallPath()
		}
		return outString
		}

		// Create JSON description for given module, only create descriptions for binary modules
		// and rust_proc_macro modules which provide a valid HostToolPath
		func hostJsonDesc(ctx android.ConfigAndErrorContext, m android.Module) *SnapshotJsonFlags {
		path := hostToolPath(m)
		relPath := hostRelativePathString(m)
		procMacro := false
		moduleStem := filepath.Base(path.String())
		crateName := ""

		if pm, ok := m.(ProcMacro); ok && pm.ProcMacro() {
		procMacro = pm.ProcMacro()
		moduleStem = strings.TrimSuffix(moduleStem, filepath.Ext(moduleStem))
		crateName = pm.CrateName()
		}

		if path.Valid() && path.String() != "" {
		props := &SnapshotJsonFlags{
		ModuleStemName: moduleStem,
		Filename: path.String(),
		Required: append(m.HostRequiredModuleNames(), m.RequiredModuleNames(ctx)...),
		RelativeInstallPath: relPath,
		RustProcMacro: procMacro,
		CrateName: crateName,
		}
		props.InitBaseSnapshotProps(m)
		return props
		}
		return nil
		}

snapshot/host_test.go

deleted100644 → 0

+0 −131

Original line number	Diff line number	Diff line
		// Copyright 2021 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 snapshot

		import (
		"path/filepath"
		"testing"

		"android/soong/android"
		)

		// host_snapshot and host-fake-snapshot test functions

		type hostTestModule struct {
		android.ModuleBase
		props struct {
		Deps []string
		}
		}

		func hostTestBinOut(bin string) string {
		return filepath.Join("out", "bin", bin)
		}

		func (c *hostTestModule) HostToolPath() android.OptionalPath {
		return (android.OptionalPathForPath(android.PathForTesting(hostTestBinOut(c.Name()))))
		}

		func hostTestModuleFactory() android.Module {
		m := &hostTestModule{}
		m.AddProperties(&m.props)
		android.InitAndroidArchModule(m, android.HostSupported, android.MultilibFirst)
		return m
		}
		func (m *hostTestModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
		builtFile := android.PathForModuleOut(ctx, m.Name())
		dir := ctx.Target().Arch.ArchType.Multilib
		installDir := android.PathForModuleInstall(ctx, dir)
		ctx.InstallFile(installDir, m.Name(), builtFile)
		}

		// Common blueprint used for testing
		var hostTestBp = `
		license_kind {
		name: "test_notice",
		conditions: ["notice"],
		}
		license {
		name: "host_test_license",
		visibility: ["//visibility:public"],
		license_kinds: [
		"test_notice"
		],
		license_text: [
		"NOTICE",
		],
		}
		component {
		name: "foo",
		deps: ["bar"],
		}
		component {
		name: "bar",
		licenses: ["host_test_license"],
		}
		`

		var hostTestModBp = `
		host_snapshot {
		name: "test-host-snapshot",
		deps: [
		"foo",
		],
		}
		`

		var prepareForHostTest = android.GroupFixturePreparers(
		android.PrepareForTestWithAndroidBuildComponents,
		android.PrepareForTestWithLicenses,
		android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) {
		ctx.RegisterModuleType("component", hostTestModuleFactory)
		}),
		)

		// Prepare for host_snapshot test
		var prepareForHostModTest = android.GroupFixturePreparers(
		prepareForHostTest,
		android.FixtureWithRootAndroidBp(hostTestBp+hostTestModBp),
		android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) {
		registerHostBuildComponents(ctx)
		}),
		)

		// Prepare for fake host snapshot test disabled
		var prepareForFakeHostTest = android.GroupFixturePreparers(
		prepareForHostTest,
		android.FixtureWithRootAndroidBp(hostTestBp),
		)

		// Validate that a hostSnapshot object is created containing zip files and JSON file
		// content of zip file is not validated as this is done by PackagingSpecs
		func TestHostSnapshot(t *testing.T) {
		result := prepareForHostModTest.RunTest(t)
		t.Helper()
		ctx := result.TestContext.ModuleForTests("test-host-snapshot", result.Config.BuildOS.String()+"_common")
		mod := ctx.Module().(*hostSnapshot)
		if ctx.MaybeOutput("host_snapshot.json").Rule == nil {
		t.Error("Manifest file not found")
		}
		zips := []string{"_deps.zip", "_mods.zip", ".zip"}

		for _, zip := range zips {
		zFile := mod.Name() + zip
		if ctx.MaybeOutput(zFile).Rule == nil {
		t.Error("Zip file ", zFile, "not found")
		}

		}
		}