github.com/helmwave/helmwave@v0.36.4-0.20240509190856-b35563eba4c6/pkg/plan/build_releases.go (about)

     1  package plan
     2  
     3  import (
     4  	"slices"
     5  
     6  	"github.com/helmwave/helmwave/pkg/helper"
     7  	"github.com/helmwave/helmwave/pkg/release"
     8  	log "github.com/sirupsen/logrus"
     9  )
    10  
    11  func (p *Plan) buildReleases(tags []string, matchAll bool) ([]release.Config, error) {
    12  	plan := make([]release.Config, 0)
    13  
    14  	for _, r := range p.body.Releases {
    15  		if !checkTagInclusion(tags, r.Tags(), matchAll) {
    16  			continue
    17  		}
    18  
    19  		var err error
    20  		plan, err = addToPlan(plan, r, p.body.Releases)
    21  		if err != nil {
    22  			log.WithError(err).Error("failed to build releases plan")
    23  
    24  			return nil, err
    25  		}
    26  	}
    27  
    28  	return plan, nil
    29  }
    30  
    31  func addToPlan(
    32  	plan release.Configs,
    33  	rel release.Config,
    34  	releases release.Configs,
    35  ) (release.Configs, error) {
    36  	if r, contains := plan.Contains(rel); contains {
    37  		if r != rel {
    38  			return nil, release.NewDuplicateError(rel.Uniq())
    39  		} else {
    40  			return plan, nil
    41  		}
    42  	}
    43  
    44  	newPlan := plan
    45  	newPlan = append(newPlan, rel)
    46  
    47  	deps := rel.DependsOn()
    48  	newDeps := make([]*release.DependsOnReference, 0, len(deps))
    49  
    50  	for _, dep := range deps {
    51  		l := rel.Logger().WithField("dependency", dep.Uniq())
    52  		l.Trace("searching for dependency")
    53  
    54  		r, found := releases.ContainsUniq(dep.Uniq())
    55  		if found {
    56  			var err error
    57  			newPlan, err = addToPlan(newPlan, r, releases)
    58  			if err != nil {
    59  				return nil, err
    60  			}
    61  
    62  			newDeps = append(newDeps, dep)
    63  
    64  			continue
    65  		}
    66  
    67  		if dep.Optional {
    68  			l.Warn("can't find dependency in available releases, skipping")
    69  		} else {
    70  			l.Error("can't find required dependency")
    71  
    72  			return nil, release.ErrDepFailed
    73  		}
    74  	}
    75  
    76  	rel.SetDependsOn(newDeps)
    77  
    78  	return newPlan, nil
    79  }
    80  
    81  func releaseNames(a []release.Config) []string {
    82  	return helper.SlicesMap(a, func(r release.Config) string {
    83  		return r.Uniq().String()
    84  	})
    85  }
    86  
    87  // checkTagInclusion checks where any of release tags are included in target tags.
    88  func checkTagInclusion(targetTags, releaseTags []string, matchAll bool) bool {
    89  	if len(targetTags) == 0 {
    90  		return true
    91  	}
    92  
    93  	if matchAll {
    94  		return checkAllTagsInclusion(targetTags, releaseTags)
    95  	}
    96  
    97  	return checkAnyTagInclusion(targetTags, releaseTags)
    98  }
    99  
   100  func checkAllTagsInclusion(targetTags, releaseTags []string) bool {
   101  	for _, t := range targetTags {
   102  		contains := slices.Contains(releaseTags, t)
   103  		if !contains {
   104  			return false
   105  		}
   106  	}
   107  
   108  	return true
   109  }
   110  
   111  func checkAnyTagInclusion(targetTags, releaseTags []string) bool {
   112  	for _, t := range targetTags {
   113  		contains := slices.Contains(releaseTags, t)
   114  		if contains {
   115  			return true
   116  		}
   117  	}
   118  
   119  	return false
   120  }