From 1eccbf24c5b3fe6e5023a0de47d73faa2c673aad Mon Sep 17 00:00:00 2001 From: LaMont Jones Date: Mon, 8 Apr 2024 09:09:35 -0700 Subject: [PATCH] release_config: Initial implementation Bug: 328495189 Test: manual Change-Id: I25a2a197f0227bfa7c63e0dfb7cab09e7d756d90 --- cmd/release_config/Android.bp | 30 + cmd/release_config/main.go | 691 ++++++++++++++ .../release_config_proto/Android.bp | 30 + .../build_flags_out.pb.go | 486 ++++++++++ .../build_flags_out.proto | 86 ++ .../build_flags_src.pb.go | 855 ++++++++++++++++++ .../build_flags_src.proto | 154 ++++ .../release_config_proto/regen.sh | 3 + 8 files changed, 2335 insertions(+) create mode 100644 cmd/release_config/Android.bp create mode 100644 cmd/release_config/main.go create mode 100644 cmd/release_config/release_config_proto/Android.bp create mode 100644 cmd/release_config/release_config_proto/build_flags_out.pb.go create mode 100644 cmd/release_config/release_config_proto/build_flags_out.proto create mode 100644 cmd/release_config/release_config_proto/build_flags_src.pb.go create mode 100644 cmd/release_config/release_config_proto/build_flags_src.proto create mode 100644 cmd/release_config/release_config_proto/regen.sh diff --git a/cmd/release_config/Android.bp b/cmd/release_config/Android.bp new file mode 100644 index 000000000..7f627ffb7 --- /dev/null +++ b/cmd/release_config/Android.bp @@ -0,0 +1,30 @@ +package { + default_applicable_licenses: ["Android-Apache-2.0"], +} + +bootstrap_go_package { + name: "release-config", + pkgPath: "android/soong/cmd/release_config", + deps: [ + "golang-protobuf-encoding-prototext", + "golang-protobuf-reflect-protoreflect", + "golang-protobuf-runtime-protoimpl", + "soong-cmd-release-config-proto", + ], + srcs: [ + "main.go", + ], +} + +bootstrap_go_package { + name: "soong-cmd-release-config-proto", + pkgPath: "android/soong/cmd/release_config/release_config_proto", + deps: [ + "golang-protobuf-reflect-protoreflect", + "golang-protobuf-runtime-protoimpl", + ], + srcs: [ + "release_config_proto/build_flags_out.pb.go", + "release_config_proto/build_flags_src.pb.go", + ], +} diff --git a/cmd/release_config/main.go b/cmd/release_config/main.go new file mode 100644 index 000000000..3bb6b3dfe --- /dev/null +++ b/cmd/release_config/main.go @@ -0,0 +1,691 @@ +// Copyright 2024 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 main + +import ( + "cmp" + "encoding/json" + "flag" + "fmt" + "io/fs" + "os" + "path/filepath" + "slices" + "strings" + + "android/soong/cmd/release_config/release_config_proto" + + "google.golang.org/protobuf/encoding/prototext" + "google.golang.org/protobuf/proto" +) + +var verboseFlag bool + +type StringList []string + +func (l *StringList) Set(v string) error { + *l = append(*l, v) + return nil +} + +func (l *StringList) String() string { + return fmt.Sprintf("%v", *l) +} + +var releaseConfigMapPaths StringList + +func DumpProtos(outDir string, message proto.Message) error { + basePath := filepath.Join(outDir, "all_release_configs") + writer := func(suffix string, marshal func() ([]byte, error)) error { + data, err := marshal() + if err != nil { + return err + } + return os.WriteFile(fmt.Sprintf("%s.%s", basePath, suffix), data, 0644) + } + err := writer("textproto", func() ([]byte, error) { return prototext.MarshalOptions{Multiline: true}.Marshal(message) }) + if err != nil { + return err + } + + err = writer("pb", func() ([]byte, error) { return proto.Marshal(message) }) + if err != nil { + return err + } + + return writer("json", func() ([]byte, error) { return json.MarshalIndent(message, "", " ") }) +} + +func LoadTextproto(path string, message proto.Message) error { + data, err := os.ReadFile(path) + if err != nil { + return err + } + ret := prototext.Unmarshal(data, message) + if verboseFlag { + debug, _ := prototext.Marshal(message) + fmt.Printf("%s: %s\n", path, debug) + } + return ret +} + +func WalkTextprotoFiles(root string, subdir string, Func fs.WalkDirFunc) error { + path := filepath.Join(root, subdir) + if _, err := os.Stat(path); err != nil { + // Missing subdirs are not an error. + return nil + } + return filepath.WalkDir(path, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if strings.HasSuffix(d.Name(), ".textproto") && d.Type().IsRegular() { + return Func(path, d, err) + } + return nil + }) +} + +type FlagValue struct { + // The path providing this value. + path string + + // Protobuf + proto release_config_proto.FlagValue +} + +func FlagValueFactory(protoPath string) (fv *FlagValue) { + fv = &FlagValue{path: protoPath} + if protoPath != "" { + LoadTextproto(protoPath, &fv.proto) + } + return fv +} + +// One directory's contribution to the a release config. +type ReleaseConfigContribution struct { + // Paths to files providing this config. + path string + + // The index of the config directory where this release config + // contribution was declared. + // Flag values cannot be set in a location with a lower index. + DeclarationIndex int + + // Protobufs relevant to the config. + proto release_config_proto.ReleaseConfig + + FlagValues []*FlagValue +} + +// A single release_config_map.textproto and its associated data. +// Used primarily for debugging. +type ReleaseConfigMap struct { + // The path to this release_config_map file. + path string + + // Data received + proto release_config_proto.ReleaseConfigMap + + ReleaseConfigContributions map[string]*ReleaseConfigContribution + FlagDeclarations []release_config_proto.FlagDeclaration +} + +// A generated release config. +type ReleaseConfig struct { + // the Name of the release config + Name string + + // The index of the config directory where this release config was + // first declared. + // Flag values cannot be set in a location with a lower index. + DeclarationIndex int + + // What contributes to this config. + Contributions []*ReleaseConfigContribution + + // Aliases for this release + OtherNames []string + + // The names of release configs that we inherit + InheritNames []string + + // Unmarshalled flag artifacts + FlagArtifacts FlagArtifacts + + // Generated release config + ReleaseConfigArtifact *release_config_proto.ReleaseConfigArtifact + + // We have begun compiling this release config. + compileInProgress bool +} + +type FlagArtifact struct { + FlagDeclaration *release_config_proto.FlagDeclaration + + // The index of the config directory where this flag was declared. + // Flag values cannot be set in a location with a lower index. + DeclarationIndex int + + Traces []*release_config_proto.Tracepoint + + // Assigned value + Value *release_config_proto.Value +} + +// Key is flag name. +type FlagArtifacts map[string]*FlagArtifact + +type ReleaseConfigDirMap map[string]int + +// The generated release configs. +type ReleaseConfigs struct { + // Ordered list of release config maps processed. + ReleaseConfigMaps []*ReleaseConfigMap + + // Aliases + Aliases map[string]*string + + // Dictionary of flag_name:FlagDeclaration, with no overrides applied. + FlagArtifacts FlagArtifacts + + // Dictionary of name:ReleaseConfig + ReleaseConfigs map[string]*ReleaseConfig + + // Generated release configs + Artifact release_config_proto.ReleaseConfigsArtifact + + // The list of config directories used. + ConfigDirs []string + + // A map from the config directory to its order in the list of config + // directories. + ConfigDirIndexes ReleaseConfigDirMap +} + +func (src *FlagArtifact) Clone() *FlagArtifact { + value := &release_config_proto.Value{} + proto.Merge(value, src.Value) + return &FlagArtifact{ + FlagDeclaration: src.FlagDeclaration, + Traces: src.Traces, + Value: value, + } +} + +func (src FlagArtifacts) Clone() (dst FlagArtifacts) { + if dst == nil { + dst = make(FlagArtifacts) + } + for k, v := range src { + dst[k] = v.Clone() + } + return +} + +func ReleaseConfigFactory(name string, index int) (c *ReleaseConfig) { + return &ReleaseConfig{Name: name, DeclarationIndex: index} +} + +func ReleaseConfigsFactory() (c *ReleaseConfigs) { + return &ReleaseConfigs{ + Aliases: make(map[string]*string), + FlagArtifacts: make(map[string]*FlagArtifact), + ReleaseConfigs: make(map[string]*ReleaseConfig), + ConfigDirs: []string{}, + ConfigDirIndexes: make(ReleaseConfigDirMap), + } +} + +func ReleaseConfigMapFactory(protoPath string) (m *ReleaseConfigMap) { + m = &ReleaseConfigMap{ + path: protoPath, + ReleaseConfigContributions: make(map[string]*ReleaseConfigContribution), + } + if protoPath != "" { + LoadTextproto(protoPath, &m.proto) + } + return m +} + +func FlagDeclarationFactory(protoPath string) (fd *release_config_proto.FlagDeclaration) { + fd = &release_config_proto.FlagDeclaration{} + if protoPath != "" { + LoadTextproto(protoPath, fd) + } + return fd +} + +func (configs *ReleaseConfigs) LoadReleaseConfigMap(path string, ConfigDirIndex int) error { + m := ReleaseConfigMapFactory(path) + if m.proto.Origin == nil || *m.proto.Origin == "" { + return fmt.Errorf("Release config map %s lacks origin", path) + } + if m.proto.DefaultContainer == nil { + return fmt.Errorf("Release config map %s lacks default_container", path) + } + dir := filepath.Dir(path) + // Record any aliases, checking for duplicates. + for _, alias := range m.proto.Aliases { + name := *alias.Name + oldTarget, ok := configs.Aliases[name] + if ok { + if *oldTarget != *alias.Target { + return fmt.Errorf("Conflicting alias declarations: %s vs %s", + *oldTarget, *alias.Target) + } + } + configs.Aliases[name] = alias.Target + } + var err error + err = WalkTextprotoFiles(dir, "flag_declarations", func(path string, d fs.DirEntry, err error) error { + flagDeclaration := FlagDeclarationFactory(path) + // Container must be specified. + if flagDeclaration.Container == nil { + flagDeclaration.Container = m.proto.DefaultContainer + } + // TODO: drop flag_declaration.origin from the proto. + if flagDeclaration.Origin == nil { + flagDeclaration.Origin = m.proto.Origin + } + // There is always a default value. + if flagDeclaration.Value == nil { + flagDeclaration.Value = &release_config_proto.Value{Val: &release_config_proto.Value_UnspecifiedValue{true}} + } + m.FlagDeclarations = append(m.FlagDeclarations, *flagDeclaration) + name := *flagDeclaration.Name + if def, ok := configs.FlagArtifacts[name]; !ok { + configs.FlagArtifacts[name] = &FlagArtifact{FlagDeclaration: flagDeclaration, DeclarationIndex: ConfigDirIndex} + } else if !proto.Equal(def.FlagDeclaration, flagDeclaration) { + return fmt.Errorf("Duplicate definition of %s", *flagDeclaration.Name) + } + // Set the initial value in the flag artifact. + configs.FlagArtifacts[name].UpdateValue( + FlagValue{path: path, proto: release_config_proto.FlagValue{ + Name: proto.String(name), Value: flagDeclaration.Value}}) + return nil + }) + if err != nil { + return err + } + + err = WalkTextprotoFiles(dir, "release_configs", func(path string, d fs.DirEntry, err error) error { + releaseConfigContribution := &ReleaseConfigContribution{path: path, DeclarationIndex: ConfigDirIndex} + LoadTextproto(path, &releaseConfigContribution.proto) + name := *releaseConfigContribution.proto.Name + if fmt.Sprintf("%s.textproto", name) != filepath.Base(path) { + return fmt.Errorf("%s incorrectly declares release config %s", path, name) + } + if _, ok := configs.ReleaseConfigs[name]; !ok { + configs.ReleaseConfigs[name] = ReleaseConfigFactory(name, ConfigDirIndex) + } + config := configs.ReleaseConfigs[name] + config.InheritNames = append(config.InheritNames, releaseConfigContribution.proto.Inherits...) + + // Only walk flag_values/{RELEASE} for defined releases. + err2 := WalkTextprotoFiles(dir, filepath.Join("flag_values", name), func(path string, d fs.DirEntry, err error) error { + flagValue := FlagValueFactory(path) + if fmt.Sprintf("%s.textproto", *flagValue.proto.Name) != filepath.Base(path) { + return fmt.Errorf("%s incorrectly sets value for flag %s", path, *flagValue.proto.Name) + } + releaseConfigContribution.FlagValues = append(releaseConfigContribution.FlagValues, flagValue) + return nil + }) + if err2 != nil { + return err2 + } + m.ReleaseConfigContributions[name] = releaseConfigContribution + config.Contributions = append(config.Contributions, releaseConfigContribution) + return nil + }) + if err != nil { + return err + } + configs.ReleaseConfigMaps = append(configs.ReleaseConfigMaps, m) + return nil +} + +func (configs *ReleaseConfigs) GetReleaseConfig(name string) (*ReleaseConfig, error) { + trace := []string{name} + for target, ok := configs.Aliases[name]; ok; target, ok = configs.Aliases[name] { + name = *target + trace = append(trace, name) + } + if config, ok := configs.ReleaseConfigs[name]; ok { + return config, nil + } + return nil, fmt.Errorf("Missing config %s. Trace=%v", name, trace) +} + +func (configs *ReleaseConfigs) DumpMakefile(outDir, targetRelease string) error { + outFile := filepath.Join(outDir, "release_config.mk") + makeVars := make(map[string]string) + config, err := configs.GetReleaseConfig(targetRelease) + if err != nil { + return err + } + // Sort the flags by name first. + names := []string{} + for k, _ := range config.FlagArtifacts { + names = append(names, k) + } + slices.SortFunc(names, func(a, b string) int { + return cmp.Compare(a, b) + }) + partitions := make(map[string][]string) + + vNames := []string{} + addVar := func(name, suffix, value string) { + fullName := fmt.Sprintf("_ALL_RELEASE_FLAGS.%s.%s", name, suffix) + vNames = append(vNames, fullName) + makeVars[fullName] = value + } + + for _, name := range names { + flag := config.FlagArtifacts[name] + decl := flag.FlagDeclaration + + // cName := strings.ToLower(release_config_proto.Container_name[decl.GetContainer()]) + cName := strings.ToLower(decl.Container.String()) + if cName == strings.ToLower(release_config_proto.Container_ALL.String()) { + partitions["product"] = append(partitions["product"], name) + partitions["system"] = append(partitions["system"], name) + partitions["system_ext"] = append(partitions["system_ext"], name) + partitions["vendor"] = append(partitions["vendor"], name) + } else { + partitions[cName] = append(partitions[cName], name) + } + value := MarshalValue(flag.Value) + makeVars[name] = value + addVar(name, "PARTITIONS", cName) + addVar(name, "DEFAULT", MarshalValue(decl.Value)) + addVar(name, "VALUE", value) + addVar(name, "DECLARED_IN", *flag.Traces[0].Source) + addVar(name, "SET_IN", *flag.Traces[len(flag.Traces)-1].Source) + addVar(name, "ORIGIN", *decl.Origin) + } + pNames := []string{} + for k, _ := range partitions { + pNames = append(pNames, k) + } + slices.SortFunc(pNames, func(a, b string) int { + return cmp.Compare(a, b) + }) + + // Now sort the make variables, and output them. + slices.SortFunc(vNames, func(a, b string) int { + return cmp.Compare(a, b) + }) + + // Write the flags as: + // _ALL_RELELASE_FLAGS + // _ALL_RELEASE_FLAGS.PARTITIONS.* + // all _ALL_RELEASE_FLAGS.*, sorted by name + // Final flag values, sorted by name. + data := fmt.Sprintf("_ALL_RELEASE_FLAGS :=$= %s\n", strings.Join(names, " ")) + for _, pName := range pNames { + data += fmt.Sprintf("_ALL_RELEASE_FLAGS.PARTITIONS.%s :=$= %s\n", pName, strings.Join(partitions[pName], " ")) + } + for _, vName := range vNames { + data += fmt.Sprintf("%s :=$= %s\n", vName, makeVars[vName]) + } + data += "\n\n# Values for all build flags\n" + data += fmt.Sprintf("RELEASE_ACONFIG_VALUE_SETS :=$= %s\n", + strings.Join(config.ReleaseConfigArtifact.AconfigValueSets, " ")) + for _, name := range names { + data += fmt.Sprintf("%s :=$= %s\n", name, makeVars[name]) + } + return os.WriteFile(outFile, []byte(data), 0644) +} + +func (configs *ReleaseConfigs) GenerateReleaseConfigs(targetRelease string) error { + otherNames := make(map[string][]string) + for aliasName, aliasTarget := range configs.Aliases { + if _, ok := configs.ReleaseConfigs[aliasName]; ok { + return fmt.Errorf("Alias %s is a declared release config", aliasName) + } + if _, ok := configs.ReleaseConfigs[*aliasTarget]; !ok { + if _, ok2 := configs.Aliases[*aliasTarget]; !ok2 { + return fmt.Errorf("Alias %s points to non-existing config %s", aliasName, *aliasTarget) + } + } + otherNames[*aliasTarget] = append(otherNames[*aliasTarget], aliasName) + } + for name, aliases := range otherNames { + configs.ReleaseConfigs[name].OtherNames = aliases + } + + for _, config := range configs.ReleaseConfigs { + err := config.GenerateReleaseConfig(configs) + if err != nil { + return err + } + } + + releaseConfig, err := configs.GetReleaseConfig(targetRelease) + if err != nil { + return err + } + configs.Artifact = release_config_proto.ReleaseConfigsArtifact{ + ReleaseConfig: releaseConfig.ReleaseConfigArtifact, + OtherReleaseConfigs: func() []*release_config_proto.ReleaseConfigArtifact { + orc := []*release_config_proto.ReleaseConfigArtifact{} + for name, config := range configs.ReleaseConfigs { + if name != releaseConfig.Name { + orc = append(orc, config.ReleaseConfigArtifact) + } + } + return orc + }(), + } + return nil +} + +func MarshalValue(value *release_config_proto.Value) string { + switch val := value.Val.(type) { + case *release_config_proto.Value_UnspecifiedValue: + // Value was never set. + return "" + case *release_config_proto.Value_StringValue: + return val.StringValue + case *release_config_proto.Value_BoolValue: + if val.BoolValue { + return "true" + } + // False ==> empty string + return "" + case *release_config_proto.Value_Obsolete: + return " #OBSOLETE" + default: + // Flagged as error elsewhere, so return empty string here. + return "" + } +} + +func (fa *FlagArtifact) UpdateValue(flagValue FlagValue) error { + name := *flagValue.proto.Name + fa.Traces = append(fa.Traces, &release_config_proto.Tracepoint{Source: proto.String(flagValue.path), Value: flagValue.proto.Value}) + if fa.Value.GetObsolete() { + return fmt.Errorf("Attempting to set obsolete flag %s. Trace=%v", name, fa.Traces) + } + switch val := flagValue.proto.Value.Val.(type) { + case *release_config_proto.Value_StringValue: + fa.Value = &release_config_proto.Value{Val: &release_config_proto.Value_StringValue{val.StringValue}} + case *release_config_proto.Value_BoolValue: + fa.Value = &release_config_proto.Value{Val: &release_config_proto.Value_BoolValue{val.BoolValue}} + case *release_config_proto.Value_Obsolete: + if !val.Obsolete { + return fmt.Errorf("%s: Cannot set obsolete=false. Trace=%v", name, fa.Traces) + } + fa.Value = &release_config_proto.Value{Val: &release_config_proto.Value_Obsolete{true}} + default: + return fmt.Errorf("Invalid type for flag_value: %T. Trace=%v", val, fa.Traces) + } + return nil +} + +func (fa *FlagArtifact) Marshal() (*release_config_proto.FlagArtifact, error) { + return &release_config_proto.FlagArtifact{ + FlagDeclaration: fa.FlagDeclaration, + Value: fa.Value, + Traces: fa.Traces, + }, nil +} + +func (config *ReleaseConfig) GenerateReleaseConfig(configs *ReleaseConfigs) error { + if config.ReleaseConfigArtifact != nil { + return nil + } + if config.compileInProgress { + return fmt.Errorf("Loop detected for release config %s", config.Name) + } + config.compileInProgress = true + + // Generate any configs we need to inherit. This will detect loops in + // the config. + contributionsToApply := []*ReleaseConfigContribution{} + myInherits := []string{} + myInheritsSet := make(map[string]bool) + for _, inherit := range config.InheritNames { + if _, ok := myInheritsSet[inherit]; ok { + continue + } + myInherits = append(myInherits, inherit) + myInheritsSet[inherit] = true + iConfig, err := configs.GetReleaseConfig(inherit) + if err != nil { + return err + } + iConfig.GenerateReleaseConfig(configs) + contributionsToApply = append(contributionsToApply, iConfig.Contributions...) + } + contributionsToApply = append(contributionsToApply, config.Contributions...) + + myAconfigValueSets := []string{} + myFlags := configs.FlagArtifacts.Clone() + myDirsMap := make(map[int]bool) + for _, contrib := range contributionsToApply { + myAconfigValueSets = append(myAconfigValueSets, contrib.proto.AconfigValueSets...) + myDirsMap[contrib.DeclarationIndex] = true + for _, value := range contrib.FlagValues { + fa, ok := myFlags[*value.proto.Name] + if !ok { + return fmt.Errorf("Setting value for undefined flag %s in %s\n", *value.proto.Name, value.path) + } + myDirsMap[fa.DeclarationIndex] = true + if fa.DeclarationIndex > contrib.DeclarationIndex { + // Setting location is to the left of declaration. + return fmt.Errorf("Setting value for flag %s not allowed in %s\n", *value.proto.Name, value.path) + } + if err := fa.UpdateValue(*value); err != nil { + return err + } + } + } + + directories := []string{} + for idx, confDir := range configs.ConfigDirs { + if _, ok := myDirsMap[idx]; ok { + directories = append(directories, confDir) + } + } + + config.FlagArtifacts = myFlags + config.ReleaseConfigArtifact = &release_config_proto.ReleaseConfigArtifact{ + Name: proto.String(config.Name), + OtherNames: config.OtherNames, + FlagArtifacts: func() []*release_config_proto.FlagArtifact { + ret := []*release_config_proto.FlagArtifact{} + for _, flag := range myFlags { + ret = append(ret, &release_config_proto.FlagArtifact{ + FlagDeclaration: flag.FlagDeclaration, + Traces: flag.Traces, + Value: flag.Value, + }) + } + return ret + }(), + AconfigValueSets: myAconfigValueSets, + Inherits: myInherits, + Directories: directories, + } + + config.compileInProgress = false + return nil +} + +func main() { + var targetRelease string + var outputDir string + + outEnv := os.Getenv("OUT_DIR") + if outEnv == "" { + outEnv = "out" + } + defaultOutputDir := filepath.Join(outEnv, "soong", "release-config") + var defaultMapPaths StringList + defaultLocations := StringList{ + "build/release/release_config_map.textproto", + "vendor/google_shared/build/release/release_config_map.textproto", + "vendor/google/release/release_config_map.textproto", + } + for _, path := range defaultLocations { + if _, err := os.Stat(path); err == nil { + defaultMapPaths = append(defaultMapPaths, path) + } + } + prodMaps := os.Getenv("PRODUCT_RELEASE_CONFIG_MAPS") + if prodMaps != "" { + defaultMapPaths = append(defaultMapPaths, strings.Split(prodMaps, " ")...) + } + + flag.BoolVar(&verboseFlag, "debug", false, "print debugging information") + flag.Var(&releaseConfigMapPaths, "map", "path to a release_config_map.textproto. may be repeated") + flag.StringVar(&targetRelease, "release", "trunk_staging", "TARGET_RELEASE for this build") + flag.StringVar(&outputDir, "out_dir", defaultOutputDir, "basepath for the output. Multiple formats are created") + flag.Parse() + + if len(releaseConfigMapPaths) == 0 { + releaseConfigMapPaths = defaultMapPaths + fmt.Printf("No --map argument provided. Using: --map %s\n", strings.Join(releaseConfigMapPaths, " --map ")) + } + + configs := ReleaseConfigsFactory() + for idx, releaseConfigMapPath := range releaseConfigMapPaths { + // Maintain an ordered list of release config directories. + configDir := filepath.Dir(releaseConfigMapPath) + configs.ConfigDirIndexes[configDir] = idx + configs.ConfigDirs = append(configs.ConfigDirs, configDir) + err := configs.LoadReleaseConfigMap(releaseConfigMapPath, idx) + if err != nil { + panic(err) + } + } + + // Now that we have all of the release config maps, can meld them and generate the artifacts. + err := configs.GenerateReleaseConfigs(targetRelease) + if err != nil { + panic(err) + } + err = os.MkdirAll(outputDir, 0775) + if err != nil { + panic(err) + } + err = configs.DumpMakefile(outputDir, targetRelease) + if err != nil { + panic(err) + } + DumpProtos(outputDir, &configs.Artifact) +} diff --git a/cmd/release_config/release_config_proto/Android.bp b/cmd/release_config/release_config_proto/Android.bp new file mode 100644 index 000000000..a8660c753 --- /dev/null +++ b/cmd/release_config/release_config_proto/Android.bp @@ -0,0 +1,30 @@ +// Copyright 2024 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 { + default_applicable_licenses: ["Android-Apache-2.0"], +} + +bootstrap_go_package { + name: "soong-release_config_proto", + pkgPath: "android/soong/release_config/release_config_proto", + deps: [ + "golang-protobuf-reflect-protoreflect", + "golang-protobuf-runtime-protoimpl", + ], + srcs: [ + "build_flags_src.pb.go", + "build_flags_out.pb.go", + ], +} diff --git a/cmd/release_config/release_config_proto/build_flags_out.pb.go b/cmd/release_config/release_config_proto/build_flags_out.pb.go new file mode 100644 index 000000000..adc1ea4bd --- /dev/null +++ b/cmd/release_config/release_config_proto/build_flags_out.pb.go @@ -0,0 +1,486 @@ +// 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. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.33.0 +// protoc v3.21.12 +// source: build_flags_out.proto + +package release_config_proto + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Tracepoint struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Path to declaration or value file relative to $TOP + Source *string `protobuf:"bytes,1,opt,name=source" json:"source,omitempty"` + Value *Value `protobuf:"bytes,201,opt,name=value" json:"value,omitempty"` +} + +func (x *Tracepoint) Reset() { + *x = Tracepoint{} + if protoimpl.UnsafeEnabled { + mi := &file_build_flags_out_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Tracepoint) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Tracepoint) ProtoMessage() {} + +func (x *Tracepoint) ProtoReflect() protoreflect.Message { + mi := &file_build_flags_out_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Tracepoint.ProtoReflect.Descriptor instead. +func (*Tracepoint) Descriptor() ([]byte, []int) { + return file_build_flags_out_proto_rawDescGZIP(), []int{0} +} + +func (x *Tracepoint) GetSource() string { + if x != nil && x.Source != nil { + return *x.Source + } + return "" +} + +func (x *Tracepoint) GetValue() *Value { + if x != nil { + return x.Value + } + return nil +} + +type FlagArtifact struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The original declaration + FlagDeclaration *FlagDeclaration `protobuf:"bytes,1,opt,name=flag_declaration,json=flagDeclaration" json:"flag_declaration,omitempty"` + // Value for the flag + Value *Value `protobuf:"bytes,201,opt,name=value" json:"value,omitempty"` + // Trace of where the flag value was assigned. + Traces []*Tracepoint `protobuf:"bytes,8,rep,name=traces" json:"traces,omitempty"` +} + +func (x *FlagArtifact) Reset() { + *x = FlagArtifact{} + if protoimpl.UnsafeEnabled { + mi := &file_build_flags_out_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FlagArtifact) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FlagArtifact) ProtoMessage() {} + +func (x *FlagArtifact) ProtoReflect() protoreflect.Message { + mi := &file_build_flags_out_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FlagArtifact.ProtoReflect.Descriptor instead. +func (*FlagArtifact) Descriptor() ([]byte, []int) { + return file_build_flags_out_proto_rawDescGZIP(), []int{1} +} + +func (x *FlagArtifact) GetFlagDeclaration() *FlagDeclaration { + if x != nil { + return x.FlagDeclaration + } + return nil +} + +func (x *FlagArtifact) GetValue() *Value { + if x != nil { + return x.Value + } + return nil +} + +func (x *FlagArtifact) GetTraces() []*Tracepoint { + if x != nil { + return x.Traces + } + return nil +} + +type ReleaseConfigArtifact struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the release config. + // See # name for format detail + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // Other names by which this release is known (for example, `next`) + OtherNames []string `protobuf:"bytes,2,rep,name=other_names,json=otherNames" json:"other_names,omitempty"` + // The complete set of build flags in this release config, after all + // inheritance and other processing is complete. + FlagArtifacts []*FlagArtifact `protobuf:"bytes,3,rep,name=flag_artifacts,json=flagArtifacts" json:"flag_artifacts,omitempty"` + // The (complete) list of aconfig_value_sets Soong modules to use. + AconfigValueSets []string `protobuf:"bytes,4,rep,name=aconfig_value_sets,json=aconfigValueSets" json:"aconfig_value_sets,omitempty"` + // The names of the release_config_artifacts from which we inherited. + // Included for reference only. + Inherits []string `protobuf:"bytes,5,rep,name=inherits" json:"inherits,omitempty"` + // The release config directories used for this config. + // For example, "build/release". + Directories []string `protobuf:"bytes,6,rep,name=directories" json:"directories,omitempty"` +} + +func (x *ReleaseConfigArtifact) Reset() { + *x = ReleaseConfigArtifact{} + if protoimpl.UnsafeEnabled { + mi := &file_build_flags_out_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReleaseConfigArtifact) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReleaseConfigArtifact) ProtoMessage() {} + +func (x *ReleaseConfigArtifact) ProtoReflect() protoreflect.Message { + mi := &file_build_flags_out_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReleaseConfigArtifact.ProtoReflect.Descriptor instead. +func (*ReleaseConfigArtifact) Descriptor() ([]byte, []int) { + return file_build_flags_out_proto_rawDescGZIP(), []int{2} +} + +func (x *ReleaseConfigArtifact) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *ReleaseConfigArtifact) GetOtherNames() []string { + if x != nil { + return x.OtherNames + } + return nil +} + +func (x *ReleaseConfigArtifact) GetFlagArtifacts() []*FlagArtifact { + if x != nil { + return x.FlagArtifacts + } + return nil +} + +func (x *ReleaseConfigArtifact) GetAconfigValueSets() []string { + if x != nil { + return x.AconfigValueSets + } + return nil +} + +func (x *ReleaseConfigArtifact) GetInherits() []string { + if x != nil { + return x.Inherits + } + return nil +} + +func (x *ReleaseConfigArtifact) GetDirectories() []string { + if x != nil { + return x.Directories + } + return nil +} + +type ReleaseConfigsArtifact struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The active release config for this build. + ReleaseConfig *ReleaseConfigArtifact `protobuf:"bytes,1,opt,name=release_config,json=releaseConfig" json:"release_config,omitempty"` + // All other release configs defined for this TARGET_PRODUCT. + OtherReleaseConfigs []*ReleaseConfigArtifact `protobuf:"bytes,2,rep,name=other_release_configs,json=otherReleaseConfigs" json:"other_release_configs,omitempty"` +} + +func (x *ReleaseConfigsArtifact) Reset() { + *x = ReleaseConfigsArtifact{} + if protoimpl.UnsafeEnabled { + mi := &file_build_flags_out_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReleaseConfigsArtifact) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReleaseConfigsArtifact) ProtoMessage() {} + +func (x *ReleaseConfigsArtifact) ProtoReflect() protoreflect.Message { + mi := &file_build_flags_out_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReleaseConfigsArtifact.ProtoReflect.Descriptor instead. +func (*ReleaseConfigsArtifact) Descriptor() ([]byte, []int) { + return file_build_flags_out_proto_rawDescGZIP(), []int{3} +} + +func (x *ReleaseConfigsArtifact) GetReleaseConfig() *ReleaseConfigArtifact { + if x != nil { + return x.ReleaseConfig + } + return nil +} + +func (x *ReleaseConfigsArtifact) GetOtherReleaseConfigs() []*ReleaseConfigArtifact { + if x != nil { + return x.OtherReleaseConfigs + } + return nil +} + +var File_build_flags_out_proto protoreflect.FileDescriptor + +var file_build_flags_out_proto_rawDesc = []byte{ + 0x0a, 0x15, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x5f, 0x6f, 0x75, + 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1c, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x15, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x66, 0x6c, 0x61, + 0x67, 0x73, 0x5f, 0x73, 0x72, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x60, 0x0a, 0x0a, + 0x74, 0x72, 0x61, 0x63, 0x65, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x12, 0x3a, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0xc9, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2e, 0x72, 0x65, 0x6c, + 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xe8, + 0x01, 0x0a, 0x0d, 0x66, 0x6c, 0x61, 0x67, 0x5f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x12, 0x59, 0x0a, 0x10, 0x66, 0x6c, 0x61, 0x67, 0x5f, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x61, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x66, 0x6c, 0x61, 0x67, 0x5f, 0x64, + 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0f, 0x66, 0x6c, 0x61, 0x67, + 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3a, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0xc9, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x61, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x40, 0x0a, 0x06, 0x74, 0x72, 0x61, 0x63, 0x65, + 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x72, 0x61, 0x63, 0x65, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x52, 0x06, 0x74, 0x72, 0x61, 0x63, 0x65, 0x73, 0x22, 0x8e, 0x02, 0x0a, 0x17, 0x72, 0x65, + 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x74, 0x68, + 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, + 0x6f, 0x74, 0x68, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x52, 0x0a, 0x0e, 0x66, 0x6c, + 0x61, 0x67, 0x5f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2e, 0x72, 0x65, 0x6c, + 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x66, 0x6c, 0x61, 0x67, 0x5f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x52, + 0x0d, 0x66, 0x6c, 0x61, 0x67, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x12, 0x2c, + 0x0a, 0x12, 0x61, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, + 0x73, 0x65, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x61, 0x63, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x65, 0x74, 0x73, 0x12, 0x1a, 0x0a, 0x08, + 0x69, 0x6e, 0x68, 0x65, 0x72, 0x69, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, + 0x69, 0x6e, 0x68, 0x65, 0x72, 0x69, 0x74, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x64, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x22, 0xe3, 0x01, 0x0a, 0x18, 0x72, + 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x5f, 0x61, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x12, 0x5c, 0x0a, 0x0e, 0x72, 0x65, 0x6c, 0x65, 0x61, + 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x35, 0x2e, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, + 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, + 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x61, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x52, 0x0d, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x69, 0x0a, 0x15, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x5f, 0x72, + 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2e, 0x72, + 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x5f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x52, 0x13, 0x6f, 0x74, 0x68, + 0x65, 0x72, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, + 0x42, 0x33, 0x5a, 0x31, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2f, 0x73, 0x6f, 0x6f, 0x6e, + 0x67, 0x2f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x2f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, +} + +var ( + file_build_flags_out_proto_rawDescOnce sync.Once + file_build_flags_out_proto_rawDescData = file_build_flags_out_proto_rawDesc +) + +func file_build_flags_out_proto_rawDescGZIP() []byte { + file_build_flags_out_proto_rawDescOnce.Do(func() { + file_build_flags_out_proto_rawDescData = protoimpl.X.CompressGZIP(file_build_flags_out_proto_rawDescData) + }) + return file_build_flags_out_proto_rawDescData +} + +var file_build_flags_out_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_build_flags_out_proto_goTypes = []interface{}{ + (*Tracepoint)(nil), // 0: android.release_config_proto.tracepoint + (*FlagArtifact)(nil), // 1: android.release_config_proto.flag_artifact + (*ReleaseConfigArtifact)(nil), // 2: android.release_config_proto.release_config_artifact + (*ReleaseConfigsArtifact)(nil), // 3: android.release_config_proto.release_configs_artifact + (*Value)(nil), // 4: android.release_config_proto.value + (*FlagDeclaration)(nil), // 5: android.release_config_proto.flag_declaration +} +var file_build_flags_out_proto_depIdxs = []int32{ + 4, // 0: android.release_config_proto.tracepoint.value:type_name -> android.release_config_proto.value + 5, // 1: android.release_config_proto.flag_artifact.flag_declaration:type_name -> android.release_config_proto.flag_declaration + 4, // 2: android.release_config_proto.flag_artifact.value:type_name -> android.release_config_proto.value + 0, // 3: android.release_config_proto.flag_artifact.traces:type_name -> android.release_config_proto.tracepoint + 1, // 4: android.release_config_proto.release_config_artifact.flag_artifacts:type_name -> android.release_config_proto.flag_artifact + 2, // 5: android.release_config_proto.release_configs_artifact.release_config:type_name -> android.release_config_proto.release_config_artifact + 2, // 6: android.release_config_proto.release_configs_artifact.other_release_configs:type_name -> android.release_config_proto.release_config_artifact + 7, // [7:7] is the sub-list for method output_type + 7, // [7:7] is the sub-list for method input_type + 7, // [7:7] is the sub-list for extension type_name + 7, // [7:7] is the sub-list for extension extendee + 0, // [0:7] is the sub-list for field type_name +} + +func init() { file_build_flags_out_proto_init() } +func file_build_flags_out_proto_init() { + if File_build_flags_out_proto != nil { + return + } + file_build_flags_src_proto_init() + if !protoimpl.UnsafeEnabled { + file_build_flags_out_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Tracepoint); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_build_flags_out_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FlagArtifact); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_build_flags_out_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReleaseConfigArtifact); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_build_flags_out_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReleaseConfigsArtifact); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_build_flags_out_proto_rawDesc, + NumEnums: 0, + NumMessages: 4, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_build_flags_out_proto_goTypes, + DependencyIndexes: file_build_flags_out_proto_depIdxs, + MessageInfos: file_build_flags_out_proto_msgTypes, + }.Build() + File_build_flags_out_proto = out.File + file_build_flags_out_proto_rawDesc = nil + file_build_flags_out_proto_goTypes = nil + file_build_flags_out_proto_depIdxs = nil +} diff --git a/cmd/release_config/release_config_proto/build_flags_out.proto b/cmd/release_config/release_config_proto/build_flags_out.proto new file mode 100644 index 000000000..fd8487bd4 --- /dev/null +++ b/cmd/release_config/release_config_proto/build_flags_out.proto @@ -0,0 +1,86 @@ +// 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. + +syntax = "proto2"; +package android.release_config_proto; +option go_package = "android/soong/release_config/release_config_proto"; + +import "build_flags_src.proto"; + +// This protobuf file defines messages used to represent the release config for +// the android build system, delivered as a build artifact for use by tools such +// as Gantry. +// +// The following format requirements apply across various message fields: +// +// # name: name of the flag +// +// format: an uppercase string in SNAKE_CASE format starting with RELEASE_, +// no consecutive underscores, and no leading digit. For example +// RELEASE_MY_PACKAGE_FLAG is a valid name, while MY_PACKAGE_FLAG, and +// RELEASE_MY_PACKAGE__FLAG are invalid. +// +// # package: package to which the flag belongs +// +// format: lowercase strings in snake_case format, delimited by dots, no +// consecutive underscores and no leading digit in each string. For example +// com.android.mypackage is a valid name while com.android.myPackage, +// com.android.1mypackage are invalid + +message tracepoint { + // Path to declaration or value file relative to $TOP + optional string source = 1; + optional value value = 201; +} + +message flag_artifact { + // The original declaration + optional flag_declaration flag_declaration = 1; + + // Value for the flag + optional value value = 201; + + // Trace of where the flag value was assigned. + repeated tracepoint traces = 8; +} + +message release_config_artifact { + // The name of the release config. + // See # name for format detail + optional string name = 1; + + // Other names by which this release is known (for example, `next`) + repeated string other_names = 2; + + // The complete set of build flags in this release config, after all + // inheritance and other processing is complete. + repeated flag_artifact flag_artifacts = 3; + + // The (complete) list of aconfig_value_sets Soong modules to use. + repeated string aconfig_value_sets = 4; + + // The names of the release_config_artifacts from which we inherited. + // Included for reference only. + repeated string inherits = 5; + + // The release config directories used for this config. + // For example, "build/release". + repeated string directories = 6; +} + +message release_configs_artifact { + // The active release config for this build. + optional release_config_artifact release_config = 1; + + // All other release configs defined for this TARGET_PRODUCT. + repeated release_config_artifact other_release_configs = 2; +} + diff --git a/cmd/release_config/release_config_proto/build_flags_src.pb.go b/cmd/release_config/release_config_proto/build_flags_src.pb.go new file mode 100644 index 000000000..0f2c30b76 --- /dev/null +++ b/cmd/release_config/release_config_proto/build_flags_src.pb.go @@ -0,0 +1,855 @@ +// 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. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.33.0 +// protoc v3.21.12 +// source: build_flags_src.proto + +package release_config_proto + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Workflow int32 + +const ( + Workflow_UNSPECIFIED_workflow Workflow = 0 + // Boolean value flags that progress from false to true. + Workflow_LAUNCH Workflow = 1 + // String value flags that get updated with new version strings to control + // prebuilt inclusion. + Workflow_PREBUILT Workflow = 2 + // Manually managed outside flags. These are likely to be found in a + // different directory than flags with other workflows. + Workflow_MANUAL Workflow = 3 +) + +// Enum value maps for Workflow. +var ( + Workflow_name = map[int32]string{ + 0: "UNSPECIFIED_workflow", + 1: "LAUNCH", + 2: "PREBUILT", + 3: "MANUAL", + } + Workflow_value = map[string]int32{ + "UNSPECIFIED_workflow": 0, + "LAUNCH": 1, + "PREBUILT": 2, + "MANUAL": 3, + } +) + +func (x Workflow) Enum() *Workflow { + p := new(Workflow) + *p = x + return p +} + +func (x Workflow) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Workflow) Descriptor() protoreflect.EnumDescriptor { + return file_build_flags_src_proto_enumTypes[0].Descriptor() +} + +func (Workflow) Type() protoreflect.EnumType { + return &file_build_flags_src_proto_enumTypes[0] +} + +func (x Workflow) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *Workflow) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = Workflow(num) + return nil +} + +// Deprecated: Use Workflow.Descriptor instead. +func (Workflow) EnumDescriptor() ([]byte, []int) { + return file_build_flags_src_proto_rawDescGZIP(), []int{0} +} + +type Container int32 + +const ( + Container_UNSPECIFIED_container Container = 0 + // All containers + Container_ALL Container = 1 + // Specific containers + Container_PRODUCT Container = 2 + Container_SYSTEM Container = 3 + Container_SYSTEM_EXT Container = 4 + Container_VENDOR Container = 5 +) + +// Enum value maps for Container. +var ( + Container_name = map[int32]string{ + 0: "UNSPECIFIED_container", + 1: "ALL", + 2: "PRODUCT", + 3: "SYSTEM", + 4: "SYSTEM_EXT", + 5: "VENDOR", + } + Container_value = map[string]int32{ + "UNSPECIFIED_container": 0, + "ALL": 1, + "PRODUCT": 2, + "SYSTEM": 3, + "SYSTEM_EXT": 4, + "VENDOR": 5, + } +) + +func (x Container) Enum() *Container { + p := new(Container) + *p = x + return p +} + +func (x Container) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Container) Descriptor() protoreflect.EnumDescriptor { + return file_build_flags_src_proto_enumTypes[1].Descriptor() +} + +func (Container) Type() protoreflect.EnumType { + return &file_build_flags_src_proto_enumTypes[1] +} + +func (x Container) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *Container) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = Container(num) + return nil +} + +// Deprecated: Use Container.Descriptor instead. +func (Container) EnumDescriptor() ([]byte, []int) { + return file_build_flags_src_proto_rawDescGZIP(), []int{1} +} + +type Value struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Val: + // + // *Value_UnspecifiedValue + // *Value_StringValue + // *Value_BoolValue + // *Value_Obsolete + Val isValue_Val `protobuf_oneof:"val"` +} + +func (x *Value) Reset() { + *x = Value{} + if protoimpl.UnsafeEnabled { + mi := &file_build_flags_src_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Value) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Value) ProtoMessage() {} + +func (x *Value) ProtoReflect() protoreflect.Message { + mi := &file_build_flags_src_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Value.ProtoReflect.Descriptor instead. +func (*Value) Descriptor() ([]byte, []int) { + return file_build_flags_src_proto_rawDescGZIP(), []int{0} +} + +func (m *Value) GetVal() isValue_Val { + if m != nil { + return m.Val + } + return nil +} + +func (x *Value) GetUnspecifiedValue() bool { + if x, ok := x.GetVal().(*Value_UnspecifiedValue); ok { + return x.UnspecifiedValue + } + return false +} + +func (x *Value) GetStringValue() string { + if x, ok := x.GetVal().(*Value_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *Value) GetBoolValue() bool { + if x, ok := x.GetVal().(*Value_BoolValue); ok { + return x.BoolValue + } + return false +} + +func (x *Value) GetObsolete() bool { + if x, ok := x.GetVal().(*Value_Obsolete); ok { + return x.Obsolete + } + return false +} + +type isValue_Val interface { + isValue_Val() +} + +type Value_UnspecifiedValue struct { + UnspecifiedValue bool `protobuf:"varint,200,opt,name=unspecified_value,json=unspecifiedValue,oneof"` +} + +type Value_StringValue struct { + StringValue string `protobuf:"bytes,201,opt,name=string_value,json=stringValue,oneof"` +} + +type Value_BoolValue struct { + BoolValue bool `protobuf:"varint,202,opt,name=bool_value,json=boolValue,oneof"` +} + +type Value_Obsolete struct { + // If true, the flag is obsolete. Assigning it further will be flagged. + Obsolete bool `protobuf:"varint,203,opt,name=obsolete,oneof"` +} + +func (*Value_UnspecifiedValue) isValue_Val() {} + +func (*Value_StringValue) isValue_Val() {} + +func (*Value_BoolValue) isValue_Val() {} + +func (*Value_Obsolete) isValue_Val() {} + +// The proto used in the source tree. +type FlagDeclaration struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the flag. + // See # name for format detail + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // Text description of the flag's purpose. + Description *string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"` + // Value for the flag + Value *Value `protobuf:"bytes,201,opt,name=value" json:"value,omitempty"` + // Workflow for this flag. + Workflow *Workflow `protobuf:"varint,205,opt,name=workflow,enum=android.release_config_proto.Workflow" json:"workflow,omitempty"` + // The container for this flag. This overrides any default container given + // in the release_config_map message. + Container *Container `protobuf:"varint,206,opt,name=container,enum=android.release_config_proto.Container" json:"container,omitempty"` + // Temporarily allow origin at the flag declaration level while we + // move flags to their own locations. + Origin *string `protobuf:"bytes,208,opt,name=origin" json:"origin,omitempty"` +} + +func (x *FlagDeclaration) Reset() { + *x = FlagDeclaration{} + if protoimpl.UnsafeEnabled { + mi := &file_build_flags_src_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FlagDeclaration) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FlagDeclaration) ProtoMessage() {} + +func (x *FlagDeclaration) ProtoReflect() protoreflect.Message { + mi := &file_build_flags_src_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FlagDeclaration.ProtoReflect.Descriptor instead. +func (*FlagDeclaration) Descriptor() ([]byte, []int) { + return file_build_flags_src_proto_rawDescGZIP(), []int{1} +} + +func (x *FlagDeclaration) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *FlagDeclaration) GetDescription() string { + if x != nil && x.Description != nil { + return *x.Description + } + return "" +} + +func (x *FlagDeclaration) GetValue() *Value { + if x != nil { + return x.Value + } + return nil +} + +func (x *FlagDeclaration) GetWorkflow() Workflow { + if x != nil && x.Workflow != nil { + return *x.Workflow + } + return Workflow_UNSPECIFIED_workflow +} + +func (x *FlagDeclaration) GetContainer() Container { + if x != nil && x.Container != nil { + return *x.Container + } + return Container_UNSPECIFIED_container +} + +func (x *FlagDeclaration) GetOrigin() string { + if x != nil && x.Origin != nil { + return *x.Origin + } + return "" +} + +type FlagValue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Name of the flag. + // See # name for format detail + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + // Value for the flag + Value *Value `protobuf:"bytes,201,opt,name=value" json:"value,omitempty"` +} + +func (x *FlagValue) Reset() { + *x = FlagValue{} + if protoimpl.UnsafeEnabled { + mi := &file_build_flags_src_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FlagValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FlagValue) ProtoMessage() {} + +func (x *FlagValue) ProtoReflect() protoreflect.Message { + mi := &file_build_flags_src_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FlagValue.ProtoReflect.Descriptor instead. +func (*FlagValue) Descriptor() ([]byte, []int) { + return file_build_flags_src_proto_rawDescGZIP(), []int{2} +} + +func (x *FlagValue) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *FlagValue) GetValue() *Value { + if x != nil { + return x.Value + } + return nil +} + +// This replaces $(call declare-release-config). +type ReleaseConfig struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the release config. + // See # name for format detail + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // From which other release configs does this one inherit? + Inherits []string `protobuf:"bytes,2,rep,name=inherits" json:"inherits,omitempty"` + // List of names of the aconfig_value_set soong module(s) for this + // contribution. + AconfigValueSets []string `protobuf:"bytes,3,rep,name=aconfig_value_sets,json=aconfigValueSets" json:"aconfig_value_sets,omitempty"` +} + +func (x *ReleaseConfig) Reset() { + *x = ReleaseConfig{} + if protoimpl.UnsafeEnabled { + mi := &file_build_flags_src_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReleaseConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReleaseConfig) ProtoMessage() {} + +func (x *ReleaseConfig) ProtoReflect() protoreflect.Message { + mi := &file_build_flags_src_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReleaseConfig.ProtoReflect.Descriptor instead. +func (*ReleaseConfig) Descriptor() ([]byte, []int) { + return file_build_flags_src_proto_rawDescGZIP(), []int{3} +} + +func (x *ReleaseConfig) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *ReleaseConfig) GetInherits() []string { + if x != nil { + return x.Inherits + } + return nil +} + +func (x *ReleaseConfig) GetAconfigValueSets() []string { + if x != nil { + return x.AconfigValueSets + } + return nil +} + +// Any aliases. These are used for continuous integration builder config. +type ReleaseAlias struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the alias. + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // The release that `name` is an alias for. + Target *string `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"` +} + +func (x *ReleaseAlias) Reset() { + *x = ReleaseAlias{} + if protoimpl.UnsafeEnabled { + mi := &file_build_flags_src_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReleaseAlias) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReleaseAlias) ProtoMessage() {} + +func (x *ReleaseAlias) ProtoReflect() protoreflect.Message { + mi := &file_build_flags_src_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReleaseAlias.ProtoReflect.Descriptor instead. +func (*ReleaseAlias) Descriptor() ([]byte, []int) { + return file_build_flags_src_proto_rawDescGZIP(), []int{4} +} + +func (x *ReleaseAlias) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *ReleaseAlias) GetTarget() string { + if x != nil && x.Target != nil { + return *x.Target + } + return "" +} + +// This provides the data from release_config_map.mk +type ReleaseConfigMap struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Any aliases. + Aliases []*ReleaseAlias `protobuf:"bytes,1,rep,name=aliases" json:"aliases,omitempty"` + // The origin for flags declared here. + Origin *string `protobuf:"bytes,2,opt,name=origin" json:"origin,omitempty"` + // The default container for flags declared here. + DefaultContainer *Container `protobuf:"varint,3,opt,name=default_container,json=defaultContainer,enum=android.release_config_proto.Container" json:"default_container,omitempty"` +} + +func (x *ReleaseConfigMap) Reset() { + *x = ReleaseConfigMap{} + if protoimpl.UnsafeEnabled { + mi := &file_build_flags_src_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReleaseConfigMap) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReleaseConfigMap) ProtoMessage() {} + +func (x *ReleaseConfigMap) ProtoReflect() protoreflect.Message { + mi := &file_build_flags_src_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReleaseConfigMap.ProtoReflect.Descriptor instead. +func (*ReleaseConfigMap) Descriptor() ([]byte, []int) { + return file_build_flags_src_proto_rawDescGZIP(), []int{5} +} + +func (x *ReleaseConfigMap) GetAliases() []*ReleaseAlias { + if x != nil { + return x.Aliases + } + return nil +} + +func (x *ReleaseConfigMap) GetOrigin() string { + if x != nil && x.Origin != nil { + return *x.Origin + } + return "" +} + +func (x *ReleaseConfigMap) GetDefaultContainer() Container { + if x != nil && x.DefaultContainer != nil { + return *x.DefaultContainer + } + return Container_UNSPECIFIED_container +} + +var File_build_flags_src_proto protoreflect.FileDescriptor + +var file_build_flags_src_proto_rawDesc = []byte{ + 0x0a, 0x15, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x5f, 0x73, 0x72, + 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1c, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa5, 0x01, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, + 0x2e, 0x0a, 0x11, 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0xc8, 0x01, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x10, 0x75, + 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, + 0x24, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0xc9, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x62, 0x6f, 0x6f, 0x6c, 0x5f, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0xca, 0x01, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09, 0x62, 0x6f, + 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x08, 0x6f, 0x62, 0x73, 0x6f, 0x6c, + 0x65, 0x74, 0x65, 0x18, 0xcb, 0x01, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x08, 0x6f, 0x62, + 0x73, 0x6f, 0x6c, 0x65, 0x74, 0x65, 0x42, 0x05, 0x0a, 0x03, 0x76, 0x61, 0x6c, 0x22, 0xb8, 0x02, + 0x0a, 0x10, 0x66, 0x6c, 0x61, 0x67, 0x5f, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3a, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0xc9, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x61, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x12, 0x43, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x18, 0xcd, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, + 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x46, 0x0a, 0x09, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x18, 0xce, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, + 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, + 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x12, 0x17, 0x0a, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x18, 0xd0, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, + 0x4a, 0x06, 0x08, 0xcf, 0x01, 0x10, 0xd0, 0x01, 0x22, 0x5c, 0x0a, 0x0a, 0x66, 0x6c, 0x61, 0x67, + 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0xc9, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x61, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x6e, 0x0a, 0x0e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, + 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, + 0x69, 0x6e, 0x68, 0x65, 0x72, 0x69, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, + 0x69, 0x6e, 0x68, 0x65, 0x72, 0x69, 0x74, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x61, 0x63, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x61, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x53, 0x65, 0x74, 0x73, 0x22, 0x3b, 0x0a, 0x0d, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, + 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x74, + 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x72, + 0x67, 0x65, 0x74, 0x22, 0xc9, 0x01, 0x0a, 0x12, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, + 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x6d, 0x61, 0x70, 0x12, 0x45, 0x0a, 0x07, 0x61, 0x6c, + 0x69, 0x61, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x61, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x65, 0x6c, 0x65, 0x61, + 0x73, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x07, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, + 0x73, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x12, 0x54, 0x0a, 0x11, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2e, 0x72, + 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x10, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2a, + 0x4a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x18, 0x0a, 0x14, 0x55, + 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x5f, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x4c, 0x41, 0x55, 0x4e, 0x43, 0x48, 0x10, + 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x50, 0x52, 0x45, 0x42, 0x55, 0x49, 0x4c, 0x54, 0x10, 0x02, 0x12, + 0x0a, 0x0a, 0x06, 0x4d, 0x41, 0x4e, 0x55, 0x41, 0x4c, 0x10, 0x03, 0x2a, 0x64, 0x0a, 0x09, 0x63, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x19, 0x0a, 0x15, 0x55, 0x4e, 0x53, 0x50, + 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x41, 0x4c, 0x4c, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, + 0x50, 0x52, 0x4f, 0x44, 0x55, 0x43, 0x54, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x59, 0x53, + 0x54, 0x45, 0x4d, 0x10, 0x03, 0x12, 0x0e, 0x0a, 0x0a, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, + 0x45, 0x58, 0x54, 0x10, 0x04, 0x12, 0x0a, 0x0a, 0x06, 0x56, 0x45, 0x4e, 0x44, 0x4f, 0x52, 0x10, + 0x05, 0x42, 0x33, 0x5a, 0x31, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2f, 0x73, 0x6f, 0x6f, + 0x6e, 0x67, 0x2f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x2f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, +} + +var ( + file_build_flags_src_proto_rawDescOnce sync.Once + file_build_flags_src_proto_rawDescData = file_build_flags_src_proto_rawDesc +) + +func file_build_flags_src_proto_rawDescGZIP() []byte { + file_build_flags_src_proto_rawDescOnce.Do(func() { + file_build_flags_src_proto_rawDescData = protoimpl.X.CompressGZIP(file_build_flags_src_proto_rawDescData) + }) + return file_build_flags_src_proto_rawDescData +} + +var file_build_flags_src_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_build_flags_src_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_build_flags_src_proto_goTypes = []interface{}{ + (Workflow)(0), // 0: android.release_config_proto.workflow + (Container)(0), // 1: android.release_config_proto.container + (*Value)(nil), // 2: android.release_config_proto.value + (*FlagDeclaration)(nil), // 3: android.release_config_proto.flag_declaration + (*FlagValue)(nil), // 4: android.release_config_proto.flag_value + (*ReleaseConfig)(nil), // 5: android.release_config_proto.release_config + (*ReleaseAlias)(nil), // 6: android.release_config_proto.release_alias + (*ReleaseConfigMap)(nil), // 7: android.release_config_proto.release_config_map +} +var file_build_flags_src_proto_depIdxs = []int32{ + 2, // 0: android.release_config_proto.flag_declaration.value:type_name -> android.release_config_proto.value + 0, // 1: android.release_config_proto.flag_declaration.workflow:type_name -> android.release_config_proto.workflow + 1, // 2: android.release_config_proto.flag_declaration.container:type_name -> android.release_config_proto.container + 2, // 3: android.release_config_proto.flag_value.value:type_name -> android.release_config_proto.value + 6, // 4: android.release_config_proto.release_config_map.aliases:type_name -> android.release_config_proto.release_alias + 1, // 5: android.release_config_proto.release_config_map.default_container:type_name -> android.release_config_proto.container + 6, // [6:6] is the sub-list for method output_type + 6, // [6:6] is the sub-list for method input_type + 6, // [6:6] is the sub-list for extension type_name + 6, // [6:6] is the sub-list for extension extendee + 0, // [0:6] is the sub-list for field type_name +} + +func init() { file_build_flags_src_proto_init() } +func file_build_flags_src_proto_init() { + if File_build_flags_src_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_build_flags_src_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Value); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_build_flags_src_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FlagDeclaration); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_build_flags_src_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FlagValue); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_build_flags_src_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReleaseConfig); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_build_flags_src_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReleaseAlias); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_build_flags_src_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReleaseConfigMap); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_build_flags_src_proto_msgTypes[0].OneofWrappers = []interface{}{ + (*Value_UnspecifiedValue)(nil), + (*Value_StringValue)(nil), + (*Value_BoolValue)(nil), + (*Value_Obsolete)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_build_flags_src_proto_rawDesc, + NumEnums: 2, + NumMessages: 6, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_build_flags_src_proto_goTypes, + DependencyIndexes: file_build_flags_src_proto_depIdxs, + EnumInfos: file_build_flags_src_proto_enumTypes, + MessageInfos: file_build_flags_src_proto_msgTypes, + }.Build() + File_build_flags_src_proto = out.File + file_build_flags_src_proto_rawDesc = nil + file_build_flags_src_proto_goTypes = nil + file_build_flags_src_proto_depIdxs = nil +} diff --git a/cmd/release_config/release_config_proto/build_flags_src.proto b/cmd/release_config/release_config_proto/build_flags_src.proto new file mode 100644 index 000000000..0662716d5 --- /dev/null +++ b/cmd/release_config/release_config_proto/build_flags_src.proto @@ -0,0 +1,154 @@ +// 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. + +syntax = "proto2"; +package android.release_config_proto; +option go_package = "android/soong/release_config/release_config_proto"; + +// This protobuf file defines messages used to represent the build flags used by +// a release in a more human-editable form. It is used for on-disk files in the +// source tree. +// +// The following format requirements apply across various message fields: +// +// # name: name of the flag +// +// format: an uppercase string in SNAKE_CASE format starting with RELEASE_, +// no consecutive underscores, and no leading digit. For example +// RELEASE_MY_PACKAGE_FLAG is a valid name, while MY_PACKAGE_FLAG, and +// RELEASE_MY_PACKAGE__FLAG are invalid. +// +// # package: package to which the flag belongs +// +// format: lowercase strings in snake_case format, delimited by dots, no +// consecutive underscores and no leading digit in each string. For example +// com.android.mypackage is a valid name while com.android.myPackage, +// com.android.1mypackage are invalid + +enum workflow { + UNSPECIFIED_workflow = 0; + + // Boolean value flags that progress from false to true. + LAUNCH = 1; + + // String value flags that get updated with new version strings to control + // prebuilt inclusion. + PREBUILT = 2; + + // Manually managed outside flags. These are likely to be found in a + // different directory than flags with other workflows. + MANUAL = 3; +} + +enum container { + UNSPECIFIED_container = 0; + + // All containers + ALL = 1; + + // Specific containers + PRODUCT = 2; + SYSTEM = 3; + SYSTEM_EXT = 4; + VENDOR = 5; +} + +message value { + oneof val { + bool unspecified_value = 200; + string string_value = 201; + bool bool_value = 202; + // If true, the flag is obsolete. Assigning it further will be flagged. + bool obsolete = 203; + } +} + +// The proto used in the source tree. +message flag_declaration { + // The name of the flag. + // See # name for format detail + optional string name = 1; + + // Text description of the flag's purpose. + optional string description = 3; + + // reserve this for bug, if needed. + reserved 4; + + // Value for the flag + optional value value = 201; + + // Workflow for this flag. + optional workflow workflow = 205; + + // The container for this flag. This overrides any default container given + // in the release_config_map message. + optional container container = 206; + + // The package associated with this flag. + // (when Gantry is ready for it) optional string package = 207; + reserved 207; + + // Temporarily allow origin at the flag declaration level while we + // move flags to their own locations. + optional string origin = 208; + + // TODO: do we want to include "first used in" (= ap2a)? +} + +message flag_value { + // Name of the flag. + // See # name for format detail + optional string name = 2; + + // Value for the flag + optional value value = 201; +} + +// This replaces $(call declare-release-config). +message release_config { + // The name of the release config. + // See # name for format detail + optional string name = 1; + + // From which other release configs does this one inherit? + repeated string inherits = 2; + + // List of names of the aconfig_value_set soong module(s) for this + // contribution. + repeated string aconfig_value_sets = 3; +} + +// Any aliases. These are used for continuous integration builder config. +message release_alias { + // The name of the alias. + optional string name = 1; + + // The release that `name` is an alias for. + optional string target = 2; +} + +// This provides the data from release_config_map.mk +message release_config_map { + // Any aliases. + repeated release_alias aliases = 1; + + // The origin for flags declared here. + optional string origin = 2; + + // The default container for flags declared here. + optional container default_container = 3; + + // If needed, we can add these fields instead of hardcoding the location. + // Flag declarations: `flag_declarations/*.textproto` + // Release config contributions: `release_configs/*.textproto` + // Flag values: `flag_values/{RELEASE_NAME}/*.textproto` +} diff --git a/cmd/release_config/release_config_proto/regen.sh b/cmd/release_config/release_config_proto/regen.sh new file mode 100644 index 000000000..1846c4d87 --- /dev/null +++ b/cmd/release_config/release_config_proto/regen.sh @@ -0,0 +1,3 @@ +#!/bin/bash + +aprotoc --go_out=paths=source_relative:. build_flags_src.proto build_flags_out.proto