| // Copyright (C) 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 aidl |
| |
| import ( |
| "android/soong/aidl_library" |
| "android/soong/android" |
| "reflect" |
| |
| "fmt" |
| "io" |
| "path/filepath" |
| "strconv" |
| "strings" |
| |
| "github.com/google/blueprint" |
| "github.com/google/blueprint/proptools" |
| ) |
| |
| var ( |
| aidlDumpApiRule = pctx.StaticRule("aidlDumpApiRule", blueprint.RuleParams{ |
| Command: `rm -rf "${outDir}" && mkdir -p "${outDir}" && ` + |
| `${aidlCmd} --dumpapi ${imports} ${optionalFlags} --out ${outDir} ${in} && ` + |
| `${aidlHashGen} ${outDir} ${latestVersion} ${hashFile}`, |
| CommandDeps: []string{"${aidlCmd}", "${aidlHashGen}"}, |
| }, "optionalFlags", "imports", "outDir", "hashFile", "latestVersion") |
| |
| aidlCheckApiRule = pctx.StaticRule("aidlCheckApiRule", blueprint.RuleParams{ |
| Command: `(${aidlCmd} ${optionalFlags} --checkapi=${checkApiLevel} ${imports} ${old} ${new} && touch ${out}) || ` + |
| `(cat ${messageFile} && exit 1)`, |
| CommandDeps: []string{"${aidlCmd}"}, |
| Description: "AIDL CHECK API: ${new} against ${old}", |
| }, "optionalFlags", "imports", "old", "new", "messageFile", "checkApiLevel") |
| |
| aidlVerifyHashRule = pctx.StaticRule("aidlVerifyHashRule", blueprint.RuleParams{ |
| Command: `if [ $$(cd '${apiDir}' && { find ./ -name "*.aidl" -print0 | LC_ALL=C sort -z | xargs -0 sha1sum && echo ${version}; } | sha1sum | cut -d " " -f 1) = $$(tail -1 '${hashFile}') ]; then ` + |
| `touch ${out}; else cat '${messageFile}' && exit 1; fi`, |
| Description: "Verify ${apiDir} files have not been modified", |
| }, "apiDir", "version", "messageFile", "hashFile") |
| ) |
| |
| type aidlApiProperties struct { |
| BaseName string |
| Srcs []string `android:"path"` |
| AidlRoot string // base directory for the input aidl file |
| Stability *string |
| Unstable *bool |
| Imports []string |
| Headers []string |
| Versions []string |
| Dumpapi DumpApiProperties |
| Frozen *bool |
| } |
| |
| type aidlApi struct { |
| android.ModuleBase |
| |
| properties aidlApiProperties |
| |
| // for triggering api check for version X against version X-1 |
| checkApiTimestamps android.WritablePaths |
| |
| // for triggering updating current API |
| updateApiTimestamp android.WritablePath |
| |
| // for triggering check that files have not been modified |
| checkHashTimestamps android.WritablePaths |
| |
| // for triggering freezing API as the new version |
| freezeApiTimestamp android.WritablePath |
| |
| // for checking for active development on unfrozen version |
| hasDevelopment android.WritablePath |
| } |
| |
| func (m *aidlApi) apiDir() string { |
| return filepath.Join(aidlApiDir, m.properties.BaseName) |
| } |
| |
| // `m <iface>-freeze-api` will freeze ToT as this version |
| func (m *aidlApi) nextVersion() string { |
| return nextVersion(m.properties.Versions) |
| } |
| |
| func (m *aidlApi) hasVersion() bool { |
| return len(m.properties.Versions) > 0 |
| } |
| |
| func (m *aidlApi) latestVersion() string { |
| if !m.hasVersion() { |
| return "0" |
| } |
| return m.properties.Versions[len(m.properties.Versions)-1] |
| } |
| |
| func (m *aidlApi) isFrozen() bool { |
| return proptools.Bool(m.properties.Frozen) |
| } |
| |
| // in order to keep original behavior for certain operations, we may want to |
| // check if frozen is set. |
| func (m *aidlApi) isExplicitlyUnFrozen() bool { |
| return m.properties.Frozen != nil && !proptools.Bool(m.properties.Frozen) |
| } |
| |
| type apiDump struct { |
| version string |
| dir android.Path |
| files android.Paths |
| hashFile android.OptionalPath |
| } |
| |
| func (m *aidlApi) getImports(ctx android.ModuleContext, version string) map[string]string { |
| iface := ctx.GetDirectDepWithTag(m.properties.BaseName, interfaceDep).(*aidlInterface) |
| return iface.getImports(version) |
| } |
| |
| func (m *aidlApi) createApiDumpFromSource(ctx android.ModuleContext) apiDump { |
| srcs, imports := getPaths(ctx, m.properties.Srcs, m.properties.AidlRoot) |
| |
| if ctx.Failed() { |
| return apiDump{} |
| } |
| |
| // dumpapi uses imports for ToT("") version |
| deps := getDeps(ctx, m.getImports(ctx, m.nextVersion())) |
| imports = append(imports, deps.imports...) |
| |
| var apiDir android.WritablePath |
| var apiFiles android.WritablePaths |
| var hashFile android.WritablePath |
| |
| apiDir = android.PathForModuleOut(ctx, "dump") |
| for _, src := range srcs { |
| outFile := android.PathForModuleOut(ctx, "dump", src.Rel()) |
| apiFiles = append(apiFiles, outFile) |
| } |
| hashFile = android.PathForModuleOut(ctx, "dump", ".hash") |
| |
| var optionalFlags []string |
| if !proptools.Bool(m.properties.Unstable) { |
| optionalFlags = append(optionalFlags, "--structured") |
| } |
| if m.properties.Stability != nil { |
| optionalFlags = append(optionalFlags, "--stability", *m.properties.Stability) |
| } |
| if proptools.Bool(m.properties.Dumpapi.No_license) { |
| optionalFlags = append(optionalFlags, "--no_license") |
| } |
| optionalFlags = append(optionalFlags, wrap("-p", deps.preprocessed.Strings(), "")...) |
| |
| version := nextVersion(m.properties.Versions) |
| ctx.Build(pctx, android.BuildParams{ |
| Rule: aidlDumpApiRule, |
| Outputs: append(apiFiles, hashFile), |
| Inputs: srcs, |
| Implicits: deps.preprocessed, |
| Args: map[string]string{ |
| "optionalFlags": strings.Join(optionalFlags, " "), |
| "imports": strings.Join(wrap("-I", imports, ""), " "), |
| "outDir": apiDir.String(), |
| "hashFile": hashFile.String(), |
| "latestVersion": versionForHashGen(version), |
| }, |
| }) |
| return apiDump{version, apiDir, apiFiles.Paths(), android.OptionalPathForPath(hashFile)} |
| } |
| |
| func wrapWithDiffCheckIfElse(m *aidlApi, rb *android.RuleBuilder, writer func(*android.RuleBuilderCommand), elseBlock func(*android.RuleBuilderCommand)) { |
| rbc := rb.Command() |
| rbc.Text("if [ \"$(cat ").Input(m.hasDevelopment).Text(")\" = \"1\" ]; then") |
| writer(rbc) |
| rbc.Text("; else") |
| elseBlock(rbc) |
| rbc.Text("; fi") |
| } |
| |
| func wrapWithDiffCheckIf(m *aidlApi, rb *android.RuleBuilder, writer func(*android.RuleBuilderCommand), needToWrap bool) { |
| rbc := rb.Command() |
| if needToWrap { |
| rbc.Text("if [ \"$(cat ").Input(m.hasDevelopment).Text(")\" = \"1\" ]; then") |
| } |
| writer(rbc) |
| if needToWrap { |
| rbc.Text("; fi") |
| } |
| } |
| |
| // Migrate `versions` into `version_with_info`, and then append a version if it isn't nil |
| func (m *aidlApi) migrateAndAppendVersion(ctx android.ModuleContext, rb *android.RuleBuilder, version *string, transitive bool) { |
| isFreezingApi := version != nil |
| |
| // Remove `versions` property which is deprecated. |
| wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { |
| rbc.BuiltTool("bpmodify"). |
| Text("-w -m " + m.properties.BaseName). |
| Text("-parameter versions -remove-property"). |
| Text(android.PathForModuleSrc(ctx, "Android.bp").String()) |
| }, isFreezingApi) |
| |
| var iface *aidlInterface |
| ctx.VisitDirectDeps(func(dep android.Module) { |
| switch ctx.OtherModuleDependencyTag(dep).(type) { |
| case interfaceDepTag: |
| iface = dep.(*aidlInterface) |
| } |
| }) |
| if iface == nil { |
| ctx.ModuleErrorf("aidl_interface %s doesn't exist", m.properties.BaseName) |
| return |
| } |
| var versions []string |
| if len(iface.properties.Versions_with_info) == 0 { |
| versions = append(versions, iface.getVersions()...) |
| } |
| if isFreezingApi { |
| versions = append(versions, *version) |
| } |
| for _, v := range versions { |
| importIfaces := make(map[string]*aidlInterface) |
| ctx.VisitDirectDeps(func(dep android.Module) { |
| if _, ok := ctx.OtherModuleDependencyTag(dep).(importInterfaceDepTag); ok { |
| other := dep.(*aidlInterface) |
| importIfaces[other.BaseModuleName()] = other |
| } |
| }) |
| imports := make([]string, 0, len(iface.getImportsForVersion(v))) |
| needTransitiveFreeze := isFreezingApi && v == *version && transitive |
| |
| if needTransitiveFreeze { |
| importApis := make(map[string]*aidlApi) |
| ctx.WalkDeps(func(child android.Module, parent android.Module) bool { |
| if api, ok := child.(*aidlApi); ok { |
| moduleName := strings.TrimSuffix(api.Name(), aidlApiSuffix) |
| if _, ok := importIfaces[moduleName]; ok { |
| importApis[moduleName] = api |
| return false |
| } |
| } |
| return true |
| }) |
| wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { |
| rbc.BuiltTool("bpmodify"). |
| Text("-w -m " + m.properties.BaseName). |
| Text("-parameter versions_with_info -add-literal '"). |
| Text(fmt.Sprintf(`{version: "%s", imports: [`, v)) |
| |
| for _, im := range iface.getImportsForVersion(v) { |
| moduleName, version := parseModuleWithVersion(im) |
| |
| // Invoke an imported interface's freeze-api only if it depends on ToT version explicitly or implicitly. |
| if version == importIfaces[moduleName].nextVersion() || !hasVersionSuffix(im) { |
| rb.Command().Text(fmt.Sprintf(`echo "Call %s-freeze-api because %s depends on %s."`, moduleName, m.properties.BaseName, moduleName)) |
| rbc.Implicit(importApis[moduleName].freezeApiTimestamp) |
| } |
| if hasVersionSuffix(im) { |
| rbc.Text(fmt.Sprintf(`"%s",`, im)) |
| } else { |
| rbc.Text("\"" + im + "-V'" + `$(if [ "$(cat `). |
| Input(importApis[im].hasDevelopment). |
| Text(`)" = "1" ]; then echo "` + importIfaces[im].nextVersion() + |
| `"; else echo "` + importIfaces[im].latestVersion() + `"; fi)'", `) |
| } |
| } |
| rbc.Text("]}' "). |
| Text(android.PathForModuleSrc(ctx, "Android.bp").String()). |
| Text("&&"). |
| BuiltTool("bpmodify"). |
| Text("-w -m " + m.properties.BaseName). |
| Text("-parameter frozen -set-bool true"). |
| Text(android.PathForModuleSrc(ctx, "Android.bp").String()) |
| }, isFreezingApi) |
| } else { |
| for _, im := range iface.getImportsForVersion(v) { |
| if hasVersionSuffix(im) { |
| imports = append(imports, im) |
| } else { |
| versionSuffix := importIfaces[im].latestVersion() |
| if !importIfaces[im].hasVersion() || |
| importIfaces[im].isExplicitlyUnFrozen() { |
| versionSuffix = importIfaces[im].nextVersion() |
| } |
| imports = append(imports, im+"-V"+versionSuffix) |
| } |
| } |
| importsStr := strings.Join(wrap(`"`, imports, `"`), ", ") |
| data := fmt.Sprintf(`{version: "%s", imports: [%s]}`, v, importsStr) |
| |
| // Also modify Android.bp file to add the new version to the 'versions_with_info' property. |
| wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { |
| rbc.BuiltTool("bpmodify"). |
| Text("-w -m " + m.properties.BaseName). |
| Text("-parameter versions_with_info -add-literal '" + data + "' "). |
| Text(android.PathForModuleSrc(ctx, "Android.bp").String()). |
| Text("&&"). |
| BuiltTool("bpmodify"). |
| Text("-w -m " + m.properties.BaseName). |
| Text("-parameter frozen -set-bool true"). |
| Text(android.PathForModuleSrc(ctx, "Android.bp").String()) |
| }, isFreezingApi) |
| } |
| } |
| } |
| |
| func (m *aidlApi) makeApiDumpAsVersion(ctx android.ModuleContext, dump apiDump, version string, latestVersionDump *apiDump) android.WritablePath { |
| creatingNewVersion := version != currentVersion |
| moduleDir := android.PathForModuleSrc(ctx).String() |
| targetDir := filepath.Join(moduleDir, m.apiDir(), version) |
| rb := android.NewRuleBuilder(pctx, ctx) |
| transitive := ctx.Config().IsEnvTrue("AIDL_TRANSITIVE_FREEZE") |
| var actionWord string |
| if creatingNewVersion { |
| actionWord = "Making" |
| // We are asked to create a new version. But before doing that, check if the given |
| // dump is the same as the latest version. If so, don't create a new version, |
| // otherwise we will be unnecessarily creating many versions. |
| // Copy the given dump to the target directory only when the equality check failed |
| // (i.e. `has_development` file contains "1"). |
| wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { |
| rbc.Text("mkdir -p " + targetDir + " && "). |
| Text("cp -rf " + dump.dir.String() + "/. " + targetDir).Implicits(dump.files) |
| }, true /* needToWrap */) |
| wrapWithDiffCheckIfElse(m, rb, func(rbc *android.RuleBuilderCommand) { |
| rbc.Text(fmt.Sprintf(`echo "There is change between ToT version and the latest stable version. Freezing %s-V%s."`, m.properties.BaseName, version)) |
| }, func(rbc *android.RuleBuilderCommand) { |
| rbc.Text(fmt.Sprintf(`echo "There is no change from the latest stable version of %s. Nothing happened."`, m.properties.BaseName)) |
| }) |
| m.migrateAndAppendVersion(ctx, rb, &version, transitive) |
| } else { |
| actionWord = "Updating" |
| if m.isFrozen() { |
| rb.Command().BuiltTool("bpmodify"). |
| Text("-w -m " + m.properties.BaseName). |
| Text("-parameter frozen -set-bool false"). |
| Text(android.PathForModuleSrc(ctx, "Android.bp").String()) |
| |
| } |
| // We are updating the current version. Don't copy .hash to the current dump |
| rb.Command().Text("mkdir -p " + targetDir) |
| rb.Command().Text("rsync --recursive --update --delete-before " + dump.dir.String() + "/* " + targetDir).Implicits(dump.files) |
| m.migrateAndAppendVersion(ctx, rb, nil, false) |
| } |
| |
| timestampFile := android.PathForModuleOut(ctx, "update_or_freeze_api_"+version+".timestamp") |
| // explicitly don't touch timestamp, so that the command can be run repeatedly |
| rb.Command().Text("true").ImplicitOutput(timestampFile) |
| |
| rb.Build("dump_aidl_api_"+m.properties.BaseName+"_"+version, actionWord+" AIDL API dump version "+version+" for "+m.properties.BaseName+" (see "+targetDir+")") |
| return timestampFile |
| } |
| |
| type deps struct { |
| preprocessed android.Paths |
| implicits android.Paths |
| imports []string |
| } |
| |
| // calculates import flags(-I) from deps. |
| // When the target is ToT, use ToT of imported interfaces. If not, we use "current" snapshot of |
| // imported interfaces. |
| func getDeps(ctx android.ModuleContext, versionedImports map[string]string) deps { |
| var deps deps |
| ctx.VisitDirectDeps(func(dep android.Module) { |
| switch ctx.OtherModuleDependencyTag(dep).(type) { |
| case importInterfaceDepTag: |
| iface := dep.(*aidlInterface) |
| if version, ok := versionedImports[iface.BaseModuleName()]; ok { |
| if iface.preprocessed[version] == nil { |
| ctx.ModuleErrorf("can't import %v's preprocessed(version=%v)", iface.BaseModuleName(), version) |
| } |
| deps.preprocessed = append(deps.preprocessed, iface.preprocessed[version]) |
| } |
| case interfaceDepTag: |
| iface := dep.(*aidlInterface) |
| deps.imports = append(deps.imports, iface.properties.Include_dirs...) |
| case apiDepTag: |
| api := dep.(*aidlApi) |
| // add imported module's checkapiTimestamps as implicits to make sure that imported apiDump is up-to-date |
| deps.implicits = append(deps.implicits, api.checkApiTimestamps.Paths()...) |
| deps.implicits = append(deps.implicits, api.checkHashTimestamps.Paths()...) |
| deps.implicits = append(deps.implicits, api.hasDevelopment) |
| case interfaceHeadersDepTag: |
| aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider) |
| if !ok { |
| ctx.PropertyErrorf("headers", "module %v does not provide AidlLibraryInfo", dep.Name()) |
| return |
| } |
| deps.implicits = append(deps.implicits, aidlLibraryInfo.Hdrs.ToList()...) |
| deps.imports = append(deps.imports, android.Paths(aidlLibraryInfo.IncludeDirs.ToList()).Strings()...) |
| } |
| }) |
| return deps |
| } |
| |
| func (m *aidlApi) checkApi(ctx android.ModuleContext, oldDump, newDump apiDump, checkApiLevel string, messageFile android.Path) android.WritablePath { |
| newVersion := newDump.dir.Base() |
| timestampFile := android.PathForModuleOut(ctx, "checkapi_"+newVersion+".timestamp") |
| |
| // --checkapi(old,new) should use imports for "new" |
| deps := getDeps(ctx, m.getImports(ctx, newDump.version)) |
| var implicits android.Paths |
| implicits = append(implicits, deps.implicits...) |
| implicits = append(implicits, deps.preprocessed...) |
| implicits = append(implicits, oldDump.files...) |
| implicits = append(implicits, newDump.files...) |
| implicits = append(implicits, messageFile) |
| |
| var optionalFlags []string |
| if m.properties.Stability != nil { |
| optionalFlags = append(optionalFlags, "--stability", *m.properties.Stability) |
| } |
| optionalFlags = append(optionalFlags, wrap("-p", deps.preprocessed.Strings(), "")...) |
| |
| ctx.Build(pctx, android.BuildParams{ |
| Rule: aidlCheckApiRule, |
| Implicits: implicits, |
| Output: timestampFile, |
| Args: map[string]string{ |
| "optionalFlags": strings.Join(optionalFlags, " "), |
| "imports": strings.Join(wrap("-I", deps.imports, ""), " "), |
| "old": oldDump.dir.String(), |
| "new": newDump.dir.String(), |
| "messageFile": messageFile.String(), |
| "checkApiLevel": checkApiLevel, |
| }, |
| }) |
| return timestampFile |
| } |
| |
| func (m *aidlApi) checkCompatibility(ctx android.ModuleContext, oldDump, newDump apiDump) android.WritablePath { |
| messageFile := android.PathForSource(ctx, "system/tools/aidl/build/message_check_compatibility.txt") |
| return m.checkApi(ctx, oldDump, newDump, "compatible", messageFile) |
| } |
| |
| func (m *aidlApi) checkEquality(ctx android.ModuleContext, oldDump apiDump, newDump apiDump) android.WritablePath { |
| // Use different messages depending on whether platform SDK is finalized or not. |
| // In case when it is finalized, we should never allow updating the already frozen API. |
| // If it's not finalized, we let users to update the current version by invoking |
| // `m <name>-update-api`. |
| var messageFile android.SourcePath |
| if m.isFrozen() { |
| messageFile = android.PathForSource(ctx, "system/tools/aidl/build/message_check_equality_frozen.txt") |
| } else { |
| messageFile = android.PathForSource(ctx, "system/tools/aidl/build/message_check_equality.txt") |
| } |
| formattedMessageFile := android.PathForModuleOut(ctx, "message_check_equality.txt") |
| rb := android.NewRuleBuilder(pctx, ctx) |
| rb.Command().Text("sed").Flag(" s/%s/" + m.properties.BaseName + "/g ").Input(messageFile).Text(" > ").Output(formattedMessageFile) |
| rb.Build("format_message_"+m.properties.BaseName, "") |
| |
| return m.checkApi(ctx, oldDump, newDump, "equal", formattedMessageFile) |
| } |
| |
| func (m *aidlApi) checkIntegrity(ctx android.ModuleContext, dump apiDump) android.WritablePath { |
| version := dump.dir.Base() |
| timestampFile := android.PathForModuleOut(ctx, "checkhash_"+version+".timestamp") |
| messageFile := android.PathForSource(ctx, "system/tools/aidl/build/message_check_integrity.txt") |
| |
| var implicits android.Paths |
| implicits = append(implicits, dump.files...) |
| implicits = append(implicits, dump.hashFile.Path()) |
| implicits = append(implicits, messageFile) |
| ctx.Build(pctx, android.BuildParams{ |
| Rule: aidlVerifyHashRule, |
| Implicits: implicits, |
| Output: timestampFile, |
| Args: map[string]string{ |
| "apiDir": dump.dir.String(), |
| "version": versionForHashGen(version), |
| "hashFile": dump.hashFile.Path().String(), |
| "messageFile": messageFile.String(), |
| }, |
| }) |
| return timestampFile |
| } |
| |
| // Get the `latest` versions of the imported AIDL interfaces. If an interface is frozen, this is the |
| // last frozen version, if it is `frozen: false` this is the last frozen version + 1, if `frozen` is |
| // not set this is the last frozen version because we don't know if there are changes or not to the |
| // interface. |
| // map["foo":"3", "bar":1] |
| func (m *aidlApi) getLatestImportVersions(ctx android.ModuleContext) map[string]string { |
| var latest_versions = make(map[string]string) |
| ctx.VisitDirectDeps(func(dep android.Module) { |
| switch ctx.OtherModuleDependencyTag(dep).(type) { |
| case apiDepTag: |
| api := dep.(*aidlApi) |
| if len(api.properties.Versions) > 0 { |
| if api.properties.Frozen == nil || api.isFrozen() { |
| latest_versions[api.properties.BaseName] = api.latestVersion() |
| } else { |
| latest_versions[api.properties.BaseName] = api.nextVersion() |
| } |
| } else { |
| latest_versions[api.properties.BaseName] = "1" |
| } |
| } |
| }) |
| return latest_versions |
| } |
| |
| func (m *aidlApi) checkForDevelopment(ctx android.ModuleContext, latestVersionDump *apiDump, totDump apiDump) android.WritablePath { |
| hasDevPath := android.PathForModuleOut(ctx, "has_development") |
| rb := android.NewRuleBuilder(pctx, ctx) |
| rb.Command().Text("rm -f " + hasDevPath.String()) |
| if latestVersionDump != nil { |
| current_imports := m.getImports(ctx, currentVersion) |
| last_frozen_imports := m.getImports(ctx, m.properties.Versions[len(m.properties.Versions)-1]) |
| var latest_versions = m.getLatestImportVersions(ctx) |
| // replace any "latest" version with the version number from latest_versions |
| for import_name, latest_version := range current_imports { |
| if latest_version == "latest" { |
| current_imports[import_name] = latest_versions[import_name] |
| } |
| } |
| for import_name, latest_version := range last_frozen_imports { |
| if latest_version == "latest" { |
| last_frozen_imports[import_name] = latest_versions[import_name] |
| } |
| } |
| different_imports := false |
| if !reflect.DeepEqual(current_imports, last_frozen_imports) { |
| if m.isFrozen() { |
| ctx.ModuleErrorf("This interface is 'frozen: true' but the imports have changed. Set 'frozen: false' to allow changes: \n Version %s imports: %s\n Version %s imports: %s\n", |
| currentVersion, |
| fmt.Sprint(current_imports), |
| m.properties.Versions[len(m.properties.Versions)-1], |
| fmt.Sprint(last_frozen_imports)) |
| return hasDevPath |
| } |
| different_imports = true |
| } |
| // checkapi(latest, tot) should use imports for nextVersion(=tot) |
| hasDevCommand := rb.Command() |
| if !different_imports { |
| hasDevCommand.BuiltTool("aidl").FlagWithArg("--checkapi=", "equal") |
| if m.properties.Stability != nil { |
| hasDevCommand.FlagWithArg("--stability ", *m.properties.Stability) |
| } |
| deps := getDeps(ctx, m.getImports(ctx, m.nextVersion())) |
| hasDevCommand. |
| FlagForEachArg("-I", deps.imports).Implicits(deps.implicits). |
| FlagForEachInput("-p", deps.preprocessed). |
| Text(latestVersionDump.dir.String()).Implicits(latestVersionDump.files). |
| Text(totDump.dir.String()).Implicits(totDump.files) |
| if m.isExplicitlyUnFrozen() { |
| // Throw an error if checkapi returns with no differences |
| msg := fmt.Sprintf("echo \"Interface %s can not be marked \\`frozen: false\\` if there are no changes "+ |
| "between the current version and the last frozen version.\"", m.properties.BaseName) |
| hasDevCommand. |
| Text(fmt.Sprintf("2> /dev/null && %s && exit -1 || echo $? >", msg)).Output(hasDevPath) |
| } else { |
| // if is explicitly frozen |
| if m.isFrozen() { |
| // Throw an error if checkapi returns WITH differences |
| msg := fmt.Sprintf("echo \"Interface %s can not be marked \\`frozen: true\\` because there are changes "+ |
| "between the current version and the last frozen version.\"", m.properties.BaseName) |
| hasDevCommand. |
| Text(fmt.Sprintf("2> /dev/null || ( %s && exit -1) && echo 0 >", msg)).Output(hasDevPath) |
| } else { |
| hasDevCommand. |
| Text("2> /dev/null; echo $? >").Output(hasDevPath) |
| } |
| |
| } |
| } else { |
| // We know there are different imports which means has_development must be true |
| hasDevCommand.Text("echo 1 >").Output(hasDevPath) |
| } |
| } else { |
| rb.Command().Text("echo 1 >").Output(hasDevPath) |
| } |
| rb.Build("check_for_development", "") |
| return hasDevPath |
| } |
| |
| func (m *aidlApi) GenerateAndroidBuildActions(ctx android.ModuleContext) { |
| // An API dump is created from source and it is compared against the API dump of the |
| // 'current' (yet-to-be-finalized) version. By checking this we enforce that any change in |
| // the AIDL interface is gated by the AIDL API review even before the interface is frozen as |
| // a new version. |
| totApiDump := m.createApiDumpFromSource(ctx) |
| currentApiDir := android.ExistentPathForSource(ctx, ctx.ModuleDir(), m.apiDir(), currentVersion) |
| var currentApiDump apiDump |
| if currentApiDir.Valid() { |
| currentApiDump = apiDump{ |
| version: nextVersion(m.properties.Versions), |
| dir: currentApiDir.Path(), |
| files: ctx.Glob(filepath.Join(currentApiDir.Path().String(), "**/*.aidl"), nil), |
| hashFile: android.ExistentPathForSource(ctx, ctx.ModuleDir(), m.apiDir(), currentVersion, ".hash"), |
| } |
| checked := m.checkEquality(ctx, currentApiDump, totApiDump) |
| m.checkApiTimestamps = append(m.checkApiTimestamps, checked) |
| } else { |
| // The "current" directory might not exist, in case when the interface is first created. |
| // Instruct user to create one by executing `m <name>-update-api`. |
| rb := android.NewRuleBuilder(pctx, ctx) |
| ifaceName := m.properties.BaseName |
| rb.Command().Text(fmt.Sprintf(`echo "API dump for the current version of AIDL interface %s does not exist."`, ifaceName)) |
| rb.Command().Text(fmt.Sprintf(`echo "Run the command \"m %s-update-api\" or add \"unstable: true\" to the build rule for the interface if it does not need to be versioned"`, ifaceName)) |
| // This file will never be created. Otherwise, the build will pass simply by running 'm; m'. |
| alwaysChecked := android.PathForModuleOut(ctx, "checkapi_current.timestamp") |
| rb.Command().Text("false").ImplicitOutput(alwaysChecked) |
| rb.Build("check_current_aidl_api", "") |
| m.checkApiTimestamps = append(m.checkApiTimestamps, alwaysChecked) |
| } |
| |
| // Also check that version X is backwards compatible with version X-1. |
| // "current" is checked against the latest version. |
| var dumps []apiDump |
| for _, ver := range m.properties.Versions { |
| apiDir := filepath.Join(ctx.ModuleDir(), m.apiDir(), ver) |
| apiDirPath := android.ExistentPathForSource(ctx, apiDir) |
| if apiDirPath.Valid() { |
| hashFilePath := filepath.Join(apiDir, ".hash") |
| dump := apiDump{ |
| version: ver, |
| dir: apiDirPath.Path(), |
| files: ctx.Glob(filepath.Join(apiDirPath.String(), "**/*.aidl"), nil), |
| hashFile: android.ExistentPathForSource(ctx, hashFilePath), |
| } |
| if !dump.hashFile.Valid() { |
| // We should show the source path of hash_gen because aidl_hash_gen cannot be built due to build error. |
| cmd := fmt.Sprintf(`(croot && system/tools/aidl/build/hash_gen.sh %s %s %s)`, apiDir, versionForHashGen(ver), hashFilePath) |
| ctx.ModuleErrorf("A frozen aidl_interface must have '.hash' file, but %s-V%s doesn't have it. Use the command below to generate a hash (DANGER: this should not normally happen. If an interface is changed downstream, it may cause undefined behavior, test failures, unexplained weather conditions, or otherwise broad malfunction of society. DO NOT RUN THIS COMMAND TO BREAK APIS. DO NOT!).\n%s\n", |
| m.properties.BaseName, ver, cmd) |
| } |
| dumps = append(dumps, dump) |
| } else if ctx.Config().AllowMissingDependencies() { |
| ctx.AddMissingDependencies([]string{apiDir}) |
| } else { |
| ctx.ModuleErrorf("API version %s path %s does not exist", ver, apiDir) |
| } |
| } |
| var latestVersionDump *apiDump |
| if len(dumps) >= 1 { |
| latestVersionDump = &dumps[len(dumps)-1] |
| } |
| if currentApiDir.Valid() { |
| dumps = append(dumps, currentApiDump) |
| } |
| for i, _ := range dumps { |
| if dumps[i].hashFile.Valid() { |
| checkHashTimestamp := m.checkIntegrity(ctx, dumps[i]) |
| m.checkHashTimestamps = append(m.checkHashTimestamps, checkHashTimestamp) |
| } |
| |
| if i == 0 { |
| continue |
| } |
| checked := m.checkCompatibility(ctx, dumps[i-1], dumps[i]) |
| m.checkApiTimestamps = append(m.checkApiTimestamps, checked) |
| } |
| |
| // Check for active development on the unfrozen version |
| m.hasDevelopment = m.checkForDevelopment(ctx, latestVersionDump, totApiDump) |
| |
| // API dump from source is updated to the 'current' version. Triggered by `m <name>-update-api` |
| m.updateApiTimestamp = m.makeApiDumpAsVersion(ctx, totApiDump, currentVersion, nil) |
| |
| // API dump from source is frozen as the next stable version. Triggered by `m <name>-freeze-api` |
| nextVersion := m.nextVersion() |
| m.freezeApiTimestamp = m.makeApiDumpAsVersion(ctx, totApiDump, nextVersion, latestVersionDump) |
| |
| nextApiDir := filepath.Join(ctx.ModuleDir(), m.apiDir(), nextVersion) |
| if android.ExistentPathForSource(ctx, nextApiDir).Valid() { |
| ctx.ModuleErrorf("API Directory exists for version %s path %s exists, but it is not specified in versions field.", nextVersion, nextApiDir) |
| } |
| } |
| |
| func (m *aidlApi) AndroidMk() android.AndroidMkData { |
| return android.AndroidMkData{ |
| Custom: func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) { |
| android.WriteAndroidMkData(w, data) |
| targetName := m.properties.BaseName + "-freeze-api" |
| fmt.Fprintln(w, ".PHONY:", targetName) |
| fmt.Fprintln(w, targetName+":", m.freezeApiTimestamp.String()) |
| |
| targetName = m.properties.BaseName + "-update-api" |
| fmt.Fprintln(w, ".PHONY:", targetName) |
| fmt.Fprintln(w, targetName+":", m.updateApiTimestamp.String()) |
| }, |
| } |
| } |
| |
| func (m *aidlApi) DepsMutator(ctx android.BottomUpMutatorContext) { |
| ctx.AddReverseDependency(ctx.Module(), nil, aidlMetadataSingletonName) |
| } |
| |
| func aidlApiFactory() android.Module { |
| m := &aidlApi{} |
| m.AddProperties(&m.properties) |
| android.InitAndroidModule(m) |
| return m |
| } |
| |
| func addApiModule(mctx android.DefaultableHookContext, i *aidlInterface) string { |
| apiModule := i.ModuleBase.Name() + aidlApiSuffix |
| srcs, aidlRoot := i.srcsForVersion(mctx, i.nextVersion()) |
| mctx.CreateModule(aidlApiFactory, &nameProperties{ |
| Name: proptools.StringPtr(apiModule), |
| }, &aidlApiProperties{ |
| BaseName: i.ModuleBase.Name(), |
| Srcs: srcs, |
| AidlRoot: aidlRoot, |
| Stability: i.properties.Stability, |
| Unstable: i.properties.Unstable, |
| Imports: i.properties.Imports, |
| Headers: i.properties.Headers, |
| Versions: i.getVersions(), |
| Dumpapi: i.properties.Dumpapi, |
| Frozen: i.properties.Frozen, |
| }) |
| return apiModule |
| } |
| |
| func versionForHashGen(ver string) string { |
| // aidlHashGen uses the version before current version. If it has never been frozen, return 'latest-version'. |
| verInt, _ := strconv.Atoi(ver) |
| if verInt > 1 { |
| return strconv.Itoa(verInt - 1) |
| } |
| return "latest-version" |
| } |
| |
| func init() { |
| android.RegisterParallelSingletonType("aidl-freeze-api", freezeApiSingletonFactory) |
| } |
| |
| func freezeApiSingletonFactory() android.Singleton { |
| return &freezeApiSingleton{} |
| } |
| |
| type freezeApiSingleton struct{} |
| |
| func (f *freezeApiSingleton) GenerateBuildActions(ctx android.SingletonContext) { |
| var files android.Paths |
| ctx.VisitAllModules(func(module android.Module) { |
| if !module.Enabled(ctx) { |
| return |
| } |
| if m, ok := module.(*aidlApi); ok { |
| ownersToFreeze := strings.Fields(ctx.Config().Getenv("AIDL_FREEZE_OWNERS")) |
| var shouldBeFrozen bool |
| if len(ownersToFreeze) > 0 { |
| shouldBeFrozen = android.InList(m.Owner(), ownersToFreeze) |
| } else { |
| shouldBeFrozen = m.Owner() == "" |
| } |
| if shouldBeFrozen { |
| files = append(files, m.freezeApiTimestamp) |
| } |
| } |
| }) |
| ctx.Phony("aidl-freeze-api", files...) |
| } |
