Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2d5e7579 authored by LaMont Jones's avatar LaMont Jones Committed by Gerrit Code Review
Browse files

Merge changes I708c37f9,I577e7fb0 into main 

* changes:
  Write per-partition build_flags.json
  release_config: various cleanup
parents 996c883b f4cc08e1

cmd/release_config/crunch_flags/main.go

+1 −1
Original line number Diff line number Diff line
@@ -163,7 +163,7 @@ func ProcessBuildFlags(dir string, namespaceMap map[string]string) error { 
}



func ProcessBuildConfigs(dir, name string, paths []string, releaseProto *rc_proto.ReleaseConfig) error {

	valRegexp, err := regexp.Compile("[[:space:]]+value.\"(?<name>[A-Z_0-9]+)\",[[:space:]]*(?<value>[^,)]*)")

	valRegexp, err := regexp.Compile("[[:space:]]+value.\"(?<name>[A-Z_0-9]+)\",[[:space:]]*(?<value>(\"[^\"]*\"|[^\",)]*))")

	if err != nil {

		return err

	}

cmd/release_config/release_config/main.go

+20 −3
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ func main() { 
	var configs *rc_lib.ReleaseConfigs

	var json, pb, textproto bool

	var product string

	var allMake bool



	defaultRelease := os.Getenv("TARGET_RELEASE")

	if defaultRelease == "" {
@@ -48,6 +49,7 @@ func main() { 
	flag.BoolVar(&textproto, "textproto", true, "write artifacts as text protobuf")

	flag.BoolVar(&json, "json", true, "write artifacts as json")

	flag.BoolVar(&pb, "pb", true, "write artifacts as binary protobuf")

	flag.BoolVar(&allMake, "all_make", true, "write makefiles for all release configs")

	flag.Parse()



	if quiet {
@@ -70,11 +72,26 @@ func main() { 
	if err != nil {

		panic(err)

	}



	if err = config.WritePartitionBuildFlags(outputDir, product, targetRelease); err != nil {

		panic(err)

	}



	if allMake {

		for k, _ := range configs.ReleaseConfigs {

			makefilePath := filepath.Join(outputDir, fmt.Sprintf("release_config-%s-%s.mk", product, k))

			err = configs.WriteMakefile(makefilePath, k)

			if err != nil {

				panic(err)

			}

		}

	} else {

		makefilePath := filepath.Join(outputDir, fmt.Sprintf("release_config-%s-%s.mk", product, releaseName))

		err = configs.WriteMakefile(makefilePath, targetRelease)

		if err != nil {

			panic(err)

		}

	}

	if json {

		err = configs.WriteArtifact(outputDir, product, "json")

		if err != nil {

cmd/release_config/release_config_lib/flag_artifact.go

+11 −0
Original line number Diff line number Diff line
@@ -129,3 +129,14 @@ func (fa *FlagArtifact) Marshal() (*rc_proto.FlagArtifact, error) { 
		Traces:          fa.Traces,

	}, nil

}



// Marshal the FlagArtifact without Traces.

func (fa *FlagArtifact) MarshalWithoutTraces() (*rc_proto.FlagArtifact, error) {

	if fa.Redacted {

		return nil, nil

	}

	return &rc_proto.FlagArtifact{

		FlagDeclaration: fa.FlagDeclaration,

		Value:           fa.Value,

	}, nil

}

cmd/release_config/release_config_lib/release_config.go

+104 −27
Original line number Diff line number Diff line
@@ -15,7 +15,11 @@ 
package release_config_lib



import (

	"cmp"

	"fmt"

	"path/filepath"

	"slices"

	"sort"

	"strings"



	rc_proto "android/soong/cmd/release_config/release_config_proto"
@@ -66,12 +70,31 @@ type ReleaseConfig struct { 


	// We have begun compiling this release config.

	compileInProgress bool



	// Partitioned artifacts for {partition}/etc/build_flags.json

	PartitionBuildFlags map[string]*rc_proto.FlagArtifacts

}



func ReleaseConfigFactory(name string, index int) (c *ReleaseConfig) {

	return &ReleaseConfig{Name: name, DeclarationIndex: index}

}



func (config *ReleaseConfig) InheritConfig(iConfig *ReleaseConfig) error {

	for _, fa := range iConfig.FlagArtifacts {

		name := *fa.FlagDeclaration.Name

		myFa, ok := config.FlagArtifacts[name]

		if !ok {

			return fmt.Errorf("Could not inherit flag %s from %s", name, iConfig.Name)

		}

		if len(fa.Traces) > 1 {

			// A value was assigned. Set our value.

			myFa.Traces = append(myFa.Traces, fa.Traces[1:]...)

			myFa.Value = fa.Value

		}

	}

	return nil

}



func (config *ReleaseConfig) GenerateReleaseConfig(configs *ReleaseConfigs) error {

	if config.ReleaseConfigArtifact != nil {

		return nil
@@ -82,6 +105,30 @@ func (config *ReleaseConfig) GenerateReleaseConfig(configs *ReleaseConfigs) erro 
	config.compileInProgress = true

	isRoot := config.Name == "root"



	// Start with only the flag declarations.

	config.FlagArtifacts = configs.FlagArtifacts.Clone()

	// Add RELEASE_ACONFIG_VALUE_SETS

	workflowManual := rc_proto.Workflow(rc_proto.Workflow_MANUAL)

	container := rc_proto.Container(rc_proto.Container_ALL)

	releaseAconfigValueSets := FlagArtifact{

		FlagDeclaration: &rc_proto.FlagDeclaration{

			Name:        proto.String("RELEASE_ACONFIG_VALUE_SETS"),

			Namespace:   proto.String("android_UNKNOWN"),

			Description: proto.String("Aconfig value sets assembled by release-config"),

			Workflow:    &workflowManual,

			Container:   &container,

			Value:       &rc_proto.Value{Val: &rc_proto.Value_StringValue{""}},

		},

		DeclarationIndex: -1,

		Traces: []*rc_proto.Tracepoint{

			&rc_proto.Tracepoint{

				Source: proto.String("$release-config"),

				Value:  &rc_proto.Value{Val: &rc_proto.Value_StringValue{""}},

			},

		},

	}

	config.FlagArtifacts["RELEASE_ACONFIG_VALUE_SETS"] = &releaseAconfigValueSets



	// Generate any configs we need to inherit.  This will detect loops in

	// the config.

	contributionsToApply := []*ReleaseConfigContribution{}
@@ -103,33 +150,17 @@ func (config *ReleaseConfig) GenerateReleaseConfig(configs *ReleaseConfigs) erro 
			return err

		}

		iConfig.GenerateReleaseConfig(configs)

		contributionsToApply = append(contributionsToApply, iConfig.Contributions...)

		if err := config.InheritConfig(iConfig); err != nil {

			return err

		}

	}

	contributionsToApply = append(contributionsToApply, config.Contributions...)



	myAconfigValueSets := []string{}

	myAconfigValueSets := strings.Split(releaseAconfigValueSets.Value.GetStringValue(), " ")

	myAconfigValueSetsMap := map[string]bool{}

	myFlags := configs.FlagArtifacts.Clone()

	workflowManual := rc_proto.Workflow(rc_proto.Workflow_MANUAL)

	container := rc_proto.Container(rc_proto.Container_ALL)

	releaseAconfigValueSets := FlagArtifact{

		FlagDeclaration: &rc_proto.FlagDeclaration{

			Name:        proto.String("RELEASE_ACONFIG_VALUE_SETS"),

			Namespace:   proto.String("android_UNKNOWN"),

			Description: proto.String("Aconfig value sets assembled by release-config"),

			Workflow:    &workflowManual,

			Container:   &container,

			Value:       &rc_proto.Value{Val: &rc_proto.Value_StringValue{""}},

		},

		DeclarationIndex: -1,

		Traces: []*rc_proto.Tracepoint{

			&rc_proto.Tracepoint{

				Source: proto.String("$release-config"),

				Value:  &rc_proto.Value{Val: &rc_proto.Value_StringValue{""}},

			},

		},

	for _, v := range myAconfigValueSets {

		myAconfigValueSetsMap[v] = true

	}

	myFlags["RELEASE_ACONFIG_VALUE_SETS"] = &releaseAconfigValueSets

	myDirsMap := make(map[int]bool)

	for _, contrib := range contributionsToApply {

		if len(contrib.proto.AconfigValueSets) > 0 {
@@ -151,7 +182,7 @@ func (config *ReleaseConfig) GenerateReleaseConfig(configs *ReleaseConfigs) erro 
		myDirsMap[contrib.DeclarationIndex] = true

		for _, value := range contrib.FlagValues {

			name := *value.proto.Name

			fa, ok := myFlags[name]

			fa, ok := config.FlagArtifacts[name]

			if !ok {

				return fmt.Errorf("Setting value for undefined flag %s in %s\n", name, value.path)

			}
@@ -168,11 +199,11 @@ func (config *ReleaseConfig) GenerateReleaseConfig(configs *ReleaseConfigs) erro 
				return err

			}

			if fa.Redacted {

				delete(myFlags, name)

				delete(config.FlagArtifacts, name)

			}

		}

	}

	releaseAconfigValueSets.Value = &rc_proto.Value{Val: &rc_proto.Value_StringValue{strings.Join(myAconfigValueSets, " ")}}

	releaseAconfigValueSets.Value = &rc_proto.Value{Val: &rc_proto.Value_StringValue{strings.TrimSpace(strings.Join(myAconfigValueSets, " "))}}



	directories := []string{}

	for idx, confDir := range configs.configDirs {
@@ -181,13 +212,46 @@ func (config *ReleaseConfig) GenerateReleaseConfig(configs *ReleaseConfigs) erro 
		}

	}



	config.FlagArtifacts = myFlags

	// Now build the per-partition artifacts

	config.PartitionBuildFlags = make(map[string]*rc_proto.FlagArtifacts)

	addPartitionArtifact := func(container string, artifact *rc_proto.FlagArtifact) {

		if _, ok := config.PartitionBuildFlags[container]; !ok {

			config.PartitionBuildFlags[container] = &rc_proto.FlagArtifacts{}

		}

		config.PartitionBuildFlags[container].FlagArtifacts = append(config.PartitionBuildFlags[container].FlagArtifacts, artifact)

	}

	for _, v := range config.FlagArtifacts {

		container := strings.ToLower(rc_proto.Container_name[int32(v.FlagDeclaration.GetContainer())])

		artifact, err := v.MarshalWithoutTraces()

		if err != nil {

			return err

		}

		switch container {

		case "all":

			for cVal, cName := range rc_proto.Container_name {

				// Skip unspecified, and "ALL", but place the flag in the rest.

				if cVal == 0 || cName == "ALL" {

					continue

				}

				cName = strings.ToLower(cName)

				addPartitionArtifact(cName, artifact)

			}

		default:

			addPartitionArtifact(container, artifact)

		}

	}

	config.ReleaseConfigArtifact = &rc_proto.ReleaseConfigArtifact{

		Name:       proto.String(config.Name),

		OtherNames: config.OtherNames,

		FlagArtifacts: func() []*rc_proto.FlagArtifact {

			ret := []*rc_proto.FlagArtifact{}

			for _, flag := range myFlags {

			flagNames := []string{}

			for k := range config.FlagArtifacts {

				flagNames = append(flagNames, k)

			}

			sort.Strings(flagNames)

			for _, flagName := range flagNames {

				flag := config.FlagArtifacts[flagName]

				ret = append(ret, &rc_proto.FlagArtifact{

					FlagDeclaration: flag.FlagDeclaration,

					Traces:          flag.Traces,
@@ -204,3 +268,16 @@ func (config *ReleaseConfig) GenerateReleaseConfig(configs *ReleaseConfigs) erro 
	config.compileInProgress = false

	return nil

}



func (config *ReleaseConfig) WritePartitionBuildFlags(outDir, product, targetRelease string) error {

	var err error

	for partition, flags := range config.PartitionBuildFlags {

		slices.SortFunc(flags.FlagArtifacts, func(a, b *rc_proto.FlagArtifact) int {

			return cmp.Compare(*a.FlagDeclaration.Name, *b.FlagDeclaration.Name)

		})

		if err = WriteMessage(filepath.Join(outDir, fmt.Sprintf("build_flags_%s-%s-%s.json", partition, config.Name, product)), flags); err != nil {

			return err

		}

	}

	return nil

}

cmd/release_config/release_config_lib/release_configs.go

+5 −0
Original line number Diff line number Diff line
@@ -372,9 +372,14 @@ func ReadReleaseConfigMaps(releaseConfigMapPaths StringList, targetRelease strin 
	}



	configs := ReleaseConfigsFactory()

	mapsRead := make(map[string]bool)

	for idx, releaseConfigMapPath := range releaseConfigMapPaths {

		// Maintain an ordered list of release config directories.

		configDir := filepath.Dir(releaseConfigMapPath)

		if mapsRead[configDir] {

			continue

		}

		mapsRead[configDir] = true

		configs.configDirIndexes[configDir] = idx

		configs.configDirs = append(configs.configDirs, configDir)

		err = configs.LoadReleaseConfigMap(releaseConfigMapPath, idx)