An error occurred while loading the file. Please try again.
-
Adam Reese authored
Signed-off-by:Adam Reese <adam@reese.io>
Unverified9e1e26f0
/*Copyright The Helm Authors.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 athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed 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 andlimitations under the License.*/package chartutilimport ( "log" "strings" "github.com/ghodss/yaml" "k8s.io/helm/pkg/chart" "k8s.io/helm/pkg/version")// ProcessRequirementsConditions disables charts based on condition path value in valuesfunc ProcessRequirementsConditions(reqs []*chart.Dependency, cvals Values) { if reqs == nil { return } for _, r := range reqs { var hasTrue, hasFalse bool for _, c := range strings.Split(strings.TrimSpace(r.Condition), ",") { if len(c) > 0 { // retrieve value vv, err := cvals.PathValue(c) if err == nil { // if not bool, warn if bv, ok := vv.(bool); ok { if bv { hasTrue = true } else { hasFalse = true } } else { log.Printf("Warning: Condition path '%s' for chart %s returned non-bool value", c, r.Name) } } else if _, ok := err.(ErrNoValue); !ok { // this is a real error log.Printf("Warning: PathValue returned error %v", err) } if vv != nil { // got first value, break loop break } } } if !hasTrue && hasFalse { r.Enabled = false } else if hasTrue { r.Enabled = true } }}// ProcessRequirementsTags disables charts based on tags in valuesfunc ProcessRequirementsTags(reqs []*chart.Dependency, cvals Values) {7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
if reqs == nil {
return
}
vt, err := cvals.Table("tags")
if err != nil {
return
}
for _, r := range reqs {
var hasTrue, hasFalse bool
for _, k := range r.Tags {
if b, ok := vt[k]; ok {
// if not bool, warn
if bv, ok := b.(bool); ok {
if bv {
hasTrue = true
} else {
hasFalse = true
}
} else {
log.Printf("Warning: Tag '%s' for chart %s returned non-bool value", k, r.Name)
}
}
}
if !hasTrue && hasFalse {
r.Enabled = false
} else if hasTrue || !hasTrue && !hasFalse {
r.Enabled = true
}
}
}
func getAliasDependency(charts []*chart.Chart, aliasChart *chart.Dependency) *chart.Chart {
var chartFound chart.Chart
for _, existingChart := range charts {
if existingChart == nil {
continue
}
if existingChart.Metadata == nil {
continue
}
if existingChart.Metadata.Name != aliasChart.Name {
continue
}
if !version.IsCompatibleRange(aliasChart.Version, existingChart.Metadata.Version) {
continue
}
chartFound = *existingChart
newMetadata := *existingChart.Metadata
if aliasChart.Alias != "" {
newMetadata.Name = aliasChart.Alias
}
chartFound.Metadata = &newMetadata
return &chartFound
}
return nil
}
// ProcessRequirementsEnabled removes disabled charts from dependencies
func ProcessRequirementsEnabled(c *chart.Chart, v map[string]interface{}) error {
if c.Metadata.Requirements == nil {
return nil
}
var chartDependencies []*chart.Chart
// If any dependency is not a part of Chart.yaml
// then this should be added to chartDependencies.
// However, if the dependency is already specified in Chart.yaml
// we should not add it, as it would be anyways processed from Chart.yaml
for _, existingDependency := range c.Dependencies() {
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
var dependencyFound bool
for _, req := range c.Metadata.Requirements {
if existingDependency.Metadata.Name == req.Name && version.IsCompatibleRange(req.Version, existingDependency.Metadata.Version) {
dependencyFound = true
break
}
}
if !dependencyFound {
chartDependencies = append(chartDependencies, existingDependency)
}
}
for _, req := range c.Metadata.Requirements {
if chartDependency := getAliasDependency(c.Dependencies(), req); chartDependency != nil {
chartDependencies = append(chartDependencies, chartDependency)
}
if req.Alias != "" {
req.Name = req.Alias
}
}
c.SetDependencies(chartDependencies...)
// set all to true
for _, lr := range c.Metadata.Requirements {
lr.Enabled = true
}
b, _ := yaml.Marshal(v)
cvals, err := CoalesceValues(c, b)
if err != nil {
return err
}
// flag dependencies as enabled/disabled
ProcessRequirementsTags(c.Metadata.Requirements, cvals)
ProcessRequirementsConditions(c.Metadata.Requirements, cvals)
// make a map of charts to remove
rm := map[string]struct{}{}
for _, r := range c.Metadata.Requirements {
if !r.Enabled {
// remove disabled chart
rm[r.Name] = struct{}{}
}
}
// don't keep disabled charts in new slice
cd := []*chart.Chart{}
copy(cd, c.Dependencies()[:0])
for _, n := range c.Dependencies() {
if _, ok := rm[n.Metadata.Name]; !ok {
cd = append(cd, n)
}
}
// recursively call self to process sub dependencies
for _, t := range cd {
if err := ProcessRequirementsEnabled(t, cvals); err != nil {
return err
}
}
c.SetDependencies(cd...)
return nil
}
// pathToMap creates a nested map given a YAML path in dot notation.
func pathToMap(path string, data map[string]interface{}) map[string]interface{} {
if path == "." {
return data
}
return set(parsePath(path), data)
}
211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280
func set(path []string, data map[string]interface{}) map[string]interface{} {
if len(path) == 0 {
return nil
}
cur := data
for i := len(path) - 1; i >= 0; i-- {
cur = map[string]interface{}{path[i]: cur}
}
return cur
}
// processImportValues merges values from child to parent based on the chart's dependencies' ImportValues field.
func processImportValues(c *chart.Chart) error {
if c.Metadata.Requirements == nil {
return nil
}
// combine chart values and empty config to get Values
cvals, err := CoalesceValues(c, []byte{})
if err != nil {
return err
}
b := make(map[string]interface{})
// import values from each dependency if specified in import-values
for _, r := range c.Metadata.Requirements {
var outiv []interface{}
for _, riv := range r.ImportValues {
switch iv := riv.(type) {
case map[string]interface{}:
child := iv["child"].(string)
parent := iv["parent"].(string)
outiv = append(outiv, map[string]string{
"child": child,
"parent": parent,
})
// get child table
vv, err := cvals.Table(r.Name + "." + child)
if err != nil {
log.Printf("Warning: ImportValues missing table: %v", err)
continue
}
// create value map from child to be merged into parent
b = coalesceTables(cvals, pathToMap(parent, vv.AsMap()))
case string:
child := "exports." + iv
outiv = append(outiv, map[string]string{
"child": child,
"parent": ".",
})
vm, err := cvals.Table(r.Name + "." + child)
if err != nil {
log.Printf("Warning: ImportValues missing table: %v", err)
continue
}
b = coalesceTables(b, vm.AsMap())
}
}
// set our formatted import values
r.ImportValues = outiv
}
// set the new values
c.Values = coalesceTables(b, cvals)
return nil
}
// ProcessRequirementsImportValues imports specified chart values from child to parent.
func ProcessRequirementsImportValues(c *chart.Chart) error {
281282283284285286287288289
for _, d := range c.Dependencies() {
// recurse
if err := ProcessRequirementsImportValues(d); err != nil {
return err
}
}
return processImportValues(c)
}