Add gen_notice module. (eef4c1c5) · Commits · e / os / android_build_soong

android/Android.bp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -49,6 +49,7 @@ bootstrap_go_package {
	"expand.go",		"expand.go",
	"filegroup.go",		"filegroup.go",
	"fixture.go",		"fixture.go",
			"gen_notice.go",
	"hooks.go",		"hooks.go",
	"image.go",		"image.go",
	"license.go",		"license.go",

android/gen_notice.go

0 → 100644

+207 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright 2020 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 android

			import (
			"fmt"
			"strings"

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

			func init() {
			RegisterGenNoticeBuildComponents(InitRegistrationContext)
			}

			// Register the gen_notice module type.
			func RegisterGenNoticeBuildComponents(ctx RegistrationContext) {
			ctx.RegisterSingletonType("gen_notice_build_rules", GenNoticeBuildRulesFactory)
			ctx.RegisterModuleType("gen_notice", GenNoticeFactory)
			}

			type genNoticeBuildRules struct{}

			func (s *genNoticeBuildRules) GenerateBuildActions(ctx SingletonContext) {
			ctx.VisitAllModules(func(m Module) {
			gm, ok := m.(*genNoticeModule)
			if !ok {
			return
			}
			if len(gm.missing) > 0 {
			missingReferencesRule(ctx, gm)
			return
			}
			out := BuildNoticeTextOutputFromLicenseMetadata
			if proptools.Bool(gm.properties.Xml) {
			out = BuildNoticeXmlOutputFromLicenseMetadata
			} else if proptools.Bool(gm.properties.Html) {
			out = BuildNoticeHtmlOutputFromLicenseMetadata
			}
			defaultName := ""
			if len(gm.properties.For) > 0 {
			defaultName = gm.properties.For[0]
			}

			modules := make([]Module, 0)
			for _, name := range gm.properties.For {
			mods := ctx.ModuleVariantsFromName(gm, name)
			for _, mod := range mods {
			if mod == nil {
			continue
			}
			modules = append(modules, mod)
			}
			}
			if ctx.Failed() {
			return
			}
			out(ctx, gm.output, proptools.StringDefault(gm.properties.ArtifactName, defaultName), "", modules...)
			})
			}

			func GenNoticeBuildRulesFactory() Singleton {
			return &genNoticeBuildRules{}
			}

			type genNoticeProperties struct {
			// For specifies the modules for which to generate a notice file.
			For []string
			// ArtifactName specifies the internal name to use for the notice file.
			// It appears in the "used by:" list for targets whose entire name is stripped by --strip_prefix.
			ArtifactName *string
			// Stem specifies the base name of the output file.
			Stem *string `android:"arch_variant"`
			// Html indicates an html-format file is needed. The default is text. Can be Html or Xml but not both.
			Html *bool
			// Xml indicates an xml-format file is needed. The default is text. Can be Html or Xml but not both.
			Xml *bool
			// Gzipped indicates the output file must be compressed with gzip. Will append .gz to suffix if not there.
			Gzipped *bool
			// Suffix specifies the file extension to use. Defaults to .html for html, .xml for xml, or no extension for text.
			Suffix *string
			// Visibility specifies where this license can be used
			Visibility []string
			}

			type genNoticeModule struct {
			ModuleBase
			DefaultableModuleBase

			properties genNoticeProperties

			output OutputPath
			missing []string
			}

			func (m *genNoticeModule) DepsMutator(ctx BottomUpMutatorContext) {
			if proptools.Bool(m.properties.Html) && proptools.Bool(m.properties.Xml) {
			ctx.ModuleErrorf("can be html or xml but not both")
			}
			if !ctx.Config().AllowMissingDependencies() {
			var missing []string
			// Verify the modules for which to generate notices exist.
			for _, otherMod := range m.properties.For {
			if !ctx.OtherModuleExists(otherMod) {
			missing = append(missing, otherMod)
			}
			}
			if len(missing) == 1 {
			ctx.PropertyErrorf("for", "no %q module exists", missing[0])
			} else if len(missing) > 1 {
			ctx.PropertyErrorf("for", "modules \"%s\" do not exist", strings.Join(missing, "\", \""))
			}
			}
			}

			func (m *genNoticeModule) getStem() string {
			stem := m.base().BaseModuleName()
			if m.properties.Stem != nil {
			stem = proptools.String(m.properties.Stem)
			}
			return stem
			}

			func (m *genNoticeModule) getSuffix() string {
			suffix := ""
			if m.properties.Suffix == nil {
			if proptools.Bool(m.properties.Html) {
			suffix = ".html"
			} else if proptools.Bool(m.properties.Xml) {
			suffix = ".xml"
			}
			} else {
			suffix = proptools.String(m.properties.Suffix)
			}
			if proptools.Bool(m.properties.Gzipped) && !strings.HasSuffix(suffix, ".gz") {
			suffix += ".gz"
			}
			return suffix
			}

			func (m *genNoticeModule) GenerateAndroidBuildActions(ctx ModuleContext) {
			if ctx.Config().AllowMissingDependencies() {
			// Verify the modules for which to generate notices exist.
			for _, otherMod := range m.properties.For {
			if !ctx.OtherModuleExists(otherMod) {
			m.missing = append(m.missing, otherMod)
			}
			}
			m.missing = append(m.missing, ctx.GetMissingDependencies()...)
			m.missing = FirstUniqueStrings(m.missing)
			}
			out := m.getStem() + m.getSuffix()
			m.output = PathForModuleOut(ctx, out).OutputPath
			}

			func GenNoticeFactory() Module {
			module := &genNoticeModule{}

			base := module.base()
			module.AddProperties(&base.nameProperties, &module.properties)

			// The visibility property needs to be checked and parsed by the visibility module.
			setPrimaryVisibilityProperty(module, "visibility", &module.properties.Visibility)

			initAndroidModuleBase(module)
			InitDefaultableModule(module)

			return module
			}

			var _ OutputFileProducer = (*genNoticeModule)(nil)

			// Implements OutputFileProducer
			func (m *genNoticeModule) OutputFiles(tag string) (Paths, error) {
			if tag == "" {
			return Paths{m.output}, nil
			}
			return nil, fmt.Errorf("unrecognized tag %q", tag)
			}

			// missingReferencesRule emits an ErrorRule for missing module references.
			func missingReferencesRule(ctx BuilderContext, m *genNoticeModule) {
			if len(m.missing) < 1 {
			panic(fmt.Errorf("missing references rule requested with no missing references"))
			}

			ctx.Build(pctx, BuildParams{
			Rule: ErrorRule,
			Output: m.output,
			Description: "notice for " + proptools.StringDefault(m.properties.ArtifactName, "container"),
			Args: map[string]string{
			"error": m.Name() + " references missing module(s): " + strings.Join(m.missing, ", "),
			},
			})
			}

android/licenses.go

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -303,6 +303,7 @@ func exemptFromRequiredApplicableLicensesProperty(module Module) bool {
	switch reflect.TypeOf(module).String() {		switch reflect.TypeOf(module).String() {
	case "*android.licenseModule": // is a license, doesn't need one		case "*android.licenseModule": // is a license, doesn't need one
	case "*android.licenseKindModule": // is a license, doesn't need one		case "*android.licenseKindModule": // is a license, doesn't need one
			case "*android.genNoticeModule": // contains license texts as data
	case "*android.NamespaceModule": // just partitions things, doesn't add anything		case "*android.NamespaceModule": // just partitions things, doesn't add anything
	case "*android.soongConfigModuleTypeModule": // creates aliases for modules with licenses		case "*android.soongConfigModuleTypeModule": // creates aliases for modules with licenses
	case "*android.soongConfigModuleTypeImport": // creates aliases for modules with licenses		case "*android.soongConfigModuleTypeImport": // creates aliases for modules with licenses

android/notices.go

+74 −19

Original line number	Original line	Diff line number	Diff line
	@@ -15,31 +15,86 @@
	package android		package android

	import (		import (
			"fmt"
			"path/filepath"
	"strings"		"strings"
	)		)

	// BuildNoticeTextOutputFromLicenseMetadata writes out a notice text file based on the module's		func modulesOutputDirs(ctx BuilderContext, modules ...Module) []string {
	// generated license metadata file.		dirs := make([]string, 0, len(modules))
	func BuildNoticeTextOutputFromLicenseMetadata(ctx ModuleContext, outputFile WritablePath) {		for _, module := range modules {
	depsFile := outputFile.ReplaceExtension(ctx, strings.TrimPrefix(outputFile.Ext()+".d", "."))		paths, err := outputFilesForModule(ctx, module, "")
	rule := NewRuleBuilder(pctx, ctx)		if err != nil {
	rule.Command().		continue
	BuiltTool("textnotice").		}
	FlagWithOutput("-o ", outputFile).		for _, path := range paths {
	FlagWithDepFile("-d ", depsFile).		if path != nil {
	Input(ctx.Module().base().licenseMetadataFile)		dirs = append(dirs, filepath.Dir(path.String()))
	rule.Build("text_notice", "container notice file")		}
			}
			}
			return SortedUniqueStrings(dirs)
			}

			func modulesLicenseMetadata(ctx BuilderContext, modules ...Module) Paths {
			result := make(Paths, 0, len(modules))
			for _, module := range modules {
			if mf := module.base().licenseMetadataFile; mf != nil {
			result = append(result, mf)
			}
			}
			return result
	}		}

	// BuildNoticeHtmlOutputFromLicenseMetadata writes out a notice text file based on the module's		// buildNoticeOutputFromLicenseMetadata writes out a notice file.
	// generated license metadata file.		func buildNoticeOutputFromLicenseMetadata(ctx BuilderContext, tool, name string, outputFile WritablePath, libraryName, stripPrefix string, modules ...Module) {
	func BuildNoticeHtmlOutputFromLicenseMetadata(ctx ModuleContext, outputFile WritablePath) {
	depsFile := outputFile.ReplaceExtension(ctx, strings.TrimPrefix(outputFile.Ext()+".d", "."))		depsFile := outputFile.ReplaceExtension(ctx, strings.TrimPrefix(outputFile.Ext()+".d", "."))
	rule := NewRuleBuilder(pctx, ctx)		rule := NewRuleBuilder(pctx, ctx)
	rule.Command().		if len(modules) == 0 {
	BuiltTool("htmlnotice").		if mctx, ok := ctx.(ModuleContext); ok {
			modules = []Module{mctx.Module()}
			} else {
			panic(fmt.Errorf("%s %q needs a module to generate the notice for", name, libraryName))
			}
			}
			if libraryName == "" {
			libraryName = modules[0].Name()
			}
			cmd := rule.Command().
			BuiltTool(tool).
	FlagWithOutput("-o ", outputFile).		FlagWithOutput("-o ", outputFile).
	FlagWithDepFile("-d ", depsFile).		FlagWithDepFile("-d ", depsFile)
	Input(ctx.Module().base().licenseMetadataFile)		if stripPrefix != "" {
	rule.Build("html_notice", "container notice file")		cmd = cmd.FlagWithArg("--strip_prefix ", stripPrefix)
			}
			outputs := modulesOutputDirs(ctx, modules...)
			if len(outputs) > 0 {
			cmd = cmd.FlagForEachArg("--strip_prefix ", outputs)
			}
			if libraryName != "" {
			cmd = cmd.FlagWithArg("--product ", libraryName)
			}
			cmd = cmd.Inputs(modulesLicenseMetadata(ctx, modules...))
			rule.Build(name, "container notice file")
			}

			// BuildNoticeTextOutputFromLicenseMetadata writes out a notice text file based
			// on the license metadata files for the input `modules` defaulting to the
			// current context module if none given.
			func BuildNoticeTextOutputFromLicenseMetadata(ctx BuilderContext, outputFile WritablePath, libraryName, stripPrefix string, modules ...Module) {
			buildNoticeOutputFromLicenseMetadata(ctx, "textnotice", "text_notice", outputFile, libraryName, stripPrefix, modules...)
			}

			// BuildNoticeHtmlOutputFromLicenseMetadata writes out a notice text file based
			// on the license metadata files for the input `modules` defaulting to the
			// current context module if none given.
			func BuildNoticeHtmlOutputFromLicenseMetadata(ctx BuilderContext, outputFile WritablePath, libraryName, stripPrefix string, modules ...Module) {
			buildNoticeOutputFromLicenseMetadata(ctx, "htmlnotice", "html_notice", outputFile, libraryName, stripPrefix, modules...)
			}

			// BuildNoticeXmlOutputFromLicenseMetadata writes out a notice text file based
			// on the license metadata files for the input `modules` defaulting to the
			// current context module if none given.
			func BuildNoticeXmlOutputFromLicenseMetadata(ctx BuilderContext, outputFile WritablePath, libraryName, stripPrefix string, modules ...Module) {
			buildNoticeOutputFromLicenseMetadata(ctx, "xmlnotice", "xml_notice", outputFile, libraryName, stripPrefix, modules...)
	}		}

android/singleton.go

+30 −0

Original line number	Original line	Diff line number	Diff line
	@@ -29,6 +29,10 @@ type SingletonContext interface {
	ModuleType(module blueprint.Module) string		ModuleType(module blueprint.Module) string
	BlueprintFile(module blueprint.Module) string		BlueprintFile(module blueprint.Module) string

			// ModuleVariantsFromName returns the list of module variants named `name` in the same namespace as `referer` enforcing visibility rules.
			// Allows generating build actions for `referer` based on the metadata for `name` deferred until the singleton context.
			ModuleVariantsFromName(referer Module, name string) []Module

	// ModuleProvider returns the value, if any, for the provider for a module. If the value for the		// ModuleProvider returns the value, if any, for the provider for a module. If the value for the
	// provider was not set it returns the zero value of the type of the provider, which means the		// provider was not set it returns the zero value of the type of the provider, which means the
	// return value can always be type-asserted to the type of the provider. The return value should		// return value can always be type-asserted to the type of the provider. The return value should
	@@ -251,3 +255,29 @@ func (s *singletonContextAdaptor) PrimaryModule(module Module) Module {
	func (s *singletonContextAdaptor) FinalModule(module Module) Module {		func (s *singletonContextAdaptor) FinalModule(module Module) Module {
	return s.SingletonContext.FinalModule(module).(Module)		return s.SingletonContext.FinalModule(module).(Module)
	}		}

			func (s *singletonContextAdaptor) ModuleVariantsFromName(referer Module, name string) []Module {
			// get qualified module name for visibility enforcement
			qualified := createQualifiedModuleName(s.ModuleName(referer), s.ModuleDir(referer))

			modules := s.SingletonContext.ModuleVariantsFromName(referer, name)
			result := make([]Module, 0, len(modules))
			for _, m := range modules {
			if module, ok := m.(Module); ok {
			// enforce visibility
			depName := s.ModuleName(module)
			depDir := s.ModuleDir(module)
			depQualified := qualifiedModuleName{depDir, depName}
			// Targets are always visible to other targets in their own package.
			if depQualified.pkg != qualified.pkg {
			rule := effectiveVisibilityRules(s.Config(), depQualified)
			if !rule.matches(qualified) {
			s.ModuleErrorf(referer, "references %s which is not visible to this module\nYou may need to add %q to its visibility", depQualified, "//"+s.ModuleDir(m))
			continue
			}
			}
			result = append(result, module)
			}
			}
			return result
			}