| // 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/android" |
| |
| "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 --structured ${imports} ${optionalFlags} --out ${outDir} ${in} && ` + |
| `(cd ${outDir} && find ./ -name "*.aidl" -print0 | LC_ALL=C sort -z | xargs -0 sha1sum && echo ${latestVersion}) | sha1sum | cut -d " " -f 1 > ${hashFile} `, |
| CommandDeps: []string{"${aidlCmd}"}, |
| }, "optionalFlags", "imports", "outDir", "hashFile", "latestVersion") |
| |
| aidlCheckApiRule = pctx.StaticRule("aidlCheckApiRule", blueprint.RuleParams{ |
| Command: `(${aidlCmd} ${optionalFlags} --checkapi=${checkApiLevel} ${old} ${new} && touch ${out}) || ` + |
| `(cat ${messageFile} && exit 1)`, |
| CommandDeps: []string{"${aidlCmd}"}, |
| Description: "AIDL CHECK API: ${new} against ${old}", |
| }, "optionalFlags", "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) = $$(read -r <'${hashFile}' hash extra; printf %s $$hash) ]; 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 |
| ImportsWithoutVersion []string |
| Versions []string |
| Dumpapi DumpApiProperties |
| } |
| |
| 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 |
| } |
| |
| 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) |
| } |
| |
| type apiDump struct { |
| dir android.Path |
| files android.Paths |
| hashFile android.OptionalPath |
| } |
| |
| func (m *aidlApi) createApiDumpFromSource(ctx android.ModuleContext) apiDump { |
| srcs, imports := getPaths(ctx, m.properties.Srcs, m.properties.AidlRoot) |
| |
| if ctx.Failed() { |
| return apiDump{} |
| } |
| |
| var importPaths []string |
| importPaths = append(importPaths, imports...) |
| ctx.VisitDirectDeps(func(dep android.Module) { |
| if importedAidl, ok := dep.(*aidlInterface); ok { |
| importPaths = append(importPaths, importedAidl.properties.Full_import_paths...) |
| } |
| }) |
| |
| var apiDir android.WritablePath |
| var apiFiles android.WritablePaths |
| var hashFile android.WritablePath |
| |
| apiDir = android.PathForModuleOut(ctx, "dump") |
| aidlRoot := android.PathForModuleSrc(ctx, m.properties.AidlRoot) |
| for _, src := range srcs { |
| baseDir := getBaseDir(ctx, src, aidlRoot) |
| relPath, _ := filepath.Rel(baseDir, src.String()) |
| outFile := android.PathForModuleOut(ctx, "dump", relPath) |
| apiFiles = append(apiFiles, outFile) |
| } |
| hashFile = android.PathForModuleOut(ctx, "dump", ".hash") |
| latestVersion := "latest-version" |
| if len(m.properties.Versions) >= 1 { |
| latestVersion = m.properties.Versions[len(m.properties.Versions)-1] |
| } |
| |
| var optionalFlags []string |
| 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") |
| } |
| |
| ctx.Build(pctx, android.BuildParams{ |
| Rule: aidlDumpApiRule, |
| Outputs: append(apiFiles, hashFile), |
| Inputs: srcs, |
| Args: map[string]string{ |
| "optionalFlags": strings.Join(optionalFlags, " "), |
| "imports": strings.Join(wrap("-I", importPaths, ""), " "), |
| "outDir": apiDir.String(), |
| "hashFile": hashFile.String(), |
| "latestVersion": latestVersion, |
| }, |
| }) |
| return apiDump{apiDir, apiFiles.Paths(), android.OptionalPathForPath(hashFile)} |
| } |
| |
| 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) |
| |
| if creatingNewVersion { |
| // 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. `newVersionNeededFile` |
| // is created when the equality check fails. |
| newVersionNeededFile := android.PathForModuleOut(ctx, "updateapi_"+version+".needed") |
| rb.Command().Text("rm -f " + newVersionNeededFile.String()) |
| |
| if latestVersionDump != nil { |
| equalityCheckCommand := rb.Command() |
| equalityCheckCommand.BuiltTool("aidl"). |
| FlagWithArg("--checkapi=", "equal") |
| if m.properties.Stability != nil { |
| equalityCheckCommand.FlagWithArg("--stability ", *m.properties.Stability) |
| } |
| equalityCheckCommand. |
| Text(latestVersionDump.dir.String()).Implicits(latestVersionDump.files). |
| Text(dump.dir.String()).Implicits(dump.files). |
| Text("&> /dev/null") |
| equalityCheckCommand. |
| Text("|| touch"). |
| Text(newVersionNeededFile.String()) |
| } else { |
| // If there is no latest version (i.e. we are creating the initial version) |
| // create the new version unconditionally |
| rb.Command().Text("touch").Text(newVersionNeededFile.String()) |
| } |
| |
| // Copy the given dump to the target directory only when the equality check failed |
| // (i.e. `newVersionNeededFile` exists). |
| rb.Command(). |
| Text("if [ -f " + newVersionNeededFile.String() + " ]; then"). |
| Text("cp -rf " + dump.dir.String() + "/. " + targetDir).Implicits(dump.files). |
| Text("; fi") |
| |
| // Also modify Android.bp file to add the new version to the 'versions' property. |
| rb.Command(). |
| Text("if [ -f " + newVersionNeededFile.String() + " ]; then"). |
| BuiltTool("bpmodify"). |
| Text("-w -m " + m.properties.BaseName). |
| Text("-parameter versions -a " + version). |
| Text(android.PathForModuleSrc(ctx, "Android.bp").String()). |
| Text("; fi") |
| |
| } else { |
| // We are updating the current version. Don't copy .hash to the current dump |
| rb.Command().Text("mkdir -p " + targetDir) |
| rb.Command().Text("rm -rf " + targetDir + "/*") |
| rb.Command().Text("cp -rf " + dump.dir.String() + "/* " + targetDir).Implicits(dump.files) |
| } |
| |
| timestampFile := android.PathForModuleOut(ctx, "updateapi_"+version+".timestamp") |
| rb.Command().Text("touch").Output(timestampFile) |
| |
| rb.Build("dump_aidl_api"+m.properties.BaseName+"_"+version, |
| "Making AIDL API of "+m.properties.BaseName+" as version "+version) |
| return timestampFile |
| } |
| |
| type depTag struct { |
| blueprint.BaseDependencyTag |
| name string |
| } |
| |
| var ( |
| apiDep = depTag{name: "api"} |
| interfaceDep = depTag{name: "interface"} |
| |
| importApiDep = depTag{name: "imported-api"} |
| importInterfaceDep = depTag{name: "imported-interface"} |
| ) |
| |
| // 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 getImportsFromDeps(ctx android.ModuleContext, targetIsToT bool) (importPaths []string, implicits android.Paths) { |
| ctx.VisitDirectDeps(func(dep android.Module) { |
| switch ctx.OtherModuleDependencyTag(dep) { |
| case importInterfaceDep: |
| iface := dep.(*aidlInterface) |
| if proptools.Bool(iface.properties.Unstable) || targetIsToT { |
| importPaths = append(importPaths, iface.properties.Full_import_paths...) |
| } else { |
| // use "current" snapshot from stable "imported" modules |
| currentDir := filepath.Join(ctx.OtherModuleDir(dep), aidlApiDir, iface.BaseModuleName(), currentVersion) |
| importPaths = append(importPaths, currentDir) |
| // TODO(b/189288369) this should be transitive |
| importPaths = append(importPaths, iface.properties.Include_dirs...) |
| } |
| case interfaceDep: |
| iface := dep.(*aidlInterface) |
| importPaths = append(importPaths, iface.properties.Include_dirs...) |
| case importApiDep, apiDep: |
| api := dep.(*aidlApi) |
| // add imported module's checkapiTimestamps as implicits to make sure that imported apiDump is up-to-date |
| implicits = append(implicits, api.checkApiTimestamps.Paths()...) |
| implicits = append(implicits, api.checkHashTimestamps.Paths()...) |
| } |
| }) |
| return |
| } |
| |
| 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") |
| |
| var optionalFlags []string |
| if m.properties.Stability != nil { |
| optionalFlags = append(optionalFlags, "--stability", *m.properties.Stability) |
| } |
| |
| var implicits android.Paths |
| implicits = append(implicits, oldDump.files...) |
| implicits = append(implicits, newDump.files...) |
| implicits = append(implicits, messageFile) |
| ctx.Build(pctx, android.BuildParams{ |
| Rule: aidlCheckApiRule, |
| Implicits: implicits, |
| Output: timestampFile, |
| Args: map[string]string{ |
| "optionalFlags": strings.Join(optionalFlags, " "), |
| "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`. |
| messageFile := android.PathForSource(ctx, "system/tools/aidl/build/message_check_equality.txt") |
| sdkIsFinal := !ctx.Config().DefaultAppTargetSdk(ctx).IsPreview() |
| if sdkIsFinal { |
| messageFile = android.PathForSource(ctx, "system/tools/aidl/build/message_check_equality_release.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, "") |
| |
| var implicits android.Paths |
| implicits = append(implicits, oldDump.files...) |
| implicits = append(implicits, newDump.files...) |
| implicits = append(implicits, formattedMessageFile) |
| 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") |
| |
| i, _ := strconv.Atoi(version) |
| if i == 1 { |
| version = "latest-version" |
| } else { |
| version = strconv.Itoa(i - 1) |
| } |
| |
| 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": version, |
| "hashFile": dump.hashFile.Path().String(), |
| "messageFile": messageFile.String(), |
| }, |
| }) |
| return timestampFile |
| } |
| |
| 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{ |
| 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 "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() { |
| dumps = append(dumps, apiDump{ |
| dir: apiDirPath.Path(), |
| files: ctx.Glob(filepath.Join(apiDirPath.String(), "**/*.aidl"), nil), |
| hashFile: android.ExistentPathForSource(ctx, ctx.ModuleDir(), m.apiDir(), ver, ".hash"), |
| }) |
| } 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) |
| } |
| |
| // 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) |
| } |
| |
| 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.AddDependency(ctx.Module(), nil, wrap("", m.properties.ImportsWithoutVersion, aidlInterfaceSuffix)...) |
| } |
| |
| func aidlApiFactory() android.Module { |
| m := &aidlApi{} |
| m.AddProperties(&m.properties) |
| android.InitAndroidModule(m) |
| return m |
| } |
| |
| func addApiModule(mctx android.LoadHookContext, 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, |
| ImportsWithoutVersion: concat(i.properties.ImportsWithoutVersion, []string{i.ModuleBase.Name()}), |
| Versions: i.properties.Versions, |
| Dumpapi: i.properties.Dumpapi, |
| }) |
| return apiModule |
| } |
| |
| func init() { |
| android.RegisterSingletonType("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() { |
| return |
| } |
| if m, ok := module.(*aidlApi); ok { |
| files = append(files, m.freezeApiTimestamp) |
| } |
| }) |
| ctx.Phony("aidl-freeze-api", files...) |
| } |