github.com/buildpacks/pack@v0.33.3-0.20240516162812-884dd1837311/acceptance/config/run_combination.go (about)

     1  //go:build acceptance
     2  // +build acceptance
     3  
     4  package config
     5  
     6  import (
     7  	"encoding/json"
     8  	"fmt"
     9  
    10  	"github.com/pkg/errors"
    11  
    12  	"github.com/buildpacks/pack/internal/style"
    13  )
    14  
    15  type ComboValue int
    16  
    17  const (
    18  	Current ComboValue = iota
    19  	Previous
    20  	DefaultKind
    21  )
    22  
    23  func (v ComboValue) String() string {
    24  	switch v {
    25  	case Current:
    26  		return "current"
    27  	case Previous:
    28  		return "previous"
    29  	case DefaultKind:
    30  		return "default"
    31  	}
    32  	return ""
    33  }
    34  
    35  type RunCombo struct {
    36  	Pack              ComboValue `json:"pack"`
    37  	PackCreateBuilder ComboValue `json:"pack_create_builder"`
    38  	Lifecycle         ComboValue `json:"lifecycle"`
    39  }
    40  
    41  var defaultRunCombo = []*RunCombo{
    42  	{Pack: Current, PackCreateBuilder: Current, Lifecycle: DefaultKind},
    43  }
    44  
    45  func (c *RunCombo) UnmarshalJSON(b []byte) error {
    46  	var o map[string]string
    47  
    48  	if err := json.Unmarshal(b, &o); err != nil {
    49  		return errors.Errorf(`failed to unmarshal run combo element: %s`, b)
    50  	}
    51  
    52  	for k, v := range o {
    53  		switch k {
    54  		case "pack":
    55  			val, err := validatedPackKind(v)
    56  			if err != nil {
    57  				return errors.Errorf("failed to parse kind of %s: %s", style.Symbol("pack"), err)
    58  			}
    59  
    60  			c.Pack = val
    61  		case "pack_create_builder":
    62  			val, err := validatedPackKind(v)
    63  			if err != nil {
    64  				return errors.Errorf(
    65  					"failed to parse kind of %s: %s", style.Symbol("pack_create_builder"),
    66  					err,
    67  				)
    68  			}
    69  
    70  			c.PackCreateBuilder = val
    71  		case "lifecycle":
    72  			val, err := validateLifecycleKind(v)
    73  			if err != nil {
    74  				return errors.Errorf("failed to parse kind of %s: %s", style.Symbol("lifecycle"), err)
    75  			}
    76  
    77  			c.Lifecycle = val
    78  		default:
    79  			return errors.Errorf("unknown key %s in run combo", style.Symbol(k))
    80  		}
    81  	}
    82  
    83  	return nil
    84  }
    85  
    86  func validatedPackKind(k string) (ComboValue, error) {
    87  	switch k {
    88  	case "current":
    89  		return Current, nil
    90  	case "previous":
    91  		return Previous, nil
    92  	default:
    93  		return Current, errors.Errorf("must be either current or previous, was %s", style.Symbol(k))
    94  	}
    95  }
    96  
    97  func validateLifecycleKind(k string) (ComboValue, error) {
    98  	switch k {
    99  	case "current":
   100  		return Current, nil
   101  	case "previous":
   102  		return Previous, nil
   103  	case "default":
   104  		return DefaultKind, nil
   105  	default:
   106  		return Current, errors.Errorf("must be either current or previous, was %s", style.Symbol(k))
   107  	}
   108  }
   109  
   110  func (c *RunCombo) String() string {
   111  	return fmt.Sprintf("p_%s cb_%s lc_%s", c.Pack, c.PackCreateBuilder, c.Lifecycle)
   112  }
   113  
   114  func (c *RunCombo) Describe(assets AssetManager) string {
   115  	packPath, packFixturesPaths := assets.PackPaths(c.Pack)
   116  	cbPackPath, cbPackFixturesPaths := assets.PackPaths(c.PackCreateBuilder)
   117  	lifecyclePath := assets.LifecyclePath(c.Lifecycle)
   118  	lifecycleDescriptor := assets.LifecycleDescriptor(c.Lifecycle)
   119  
   120  	return fmt.Sprintf(`
   121  pack:
   122  |__ path: %s
   123  |__ fixtures: %s
   124  
   125  create builder:
   126  |__ pack path: %s
   127  |__ pack fixtures: %s
   128  
   129  lifecycle:
   130  |__ path: %s
   131  |__ version: %s
   132  |__ buildpack api: %s
   133  |__ platform api: %s
   134  `,
   135  		packPath,
   136  		packFixturesPaths,
   137  		cbPackPath,
   138  		cbPackFixturesPaths,
   139  		lifecyclePath,
   140  		lifecycleDescriptor.Info.Version,
   141  		lifecycleDescriptor.API.BuildpackVersion,
   142  		lifecycleDescriptor.API.PlatformVersion,
   143  	)
   144  }
   145  
   146  type ComboSet []*RunCombo
   147  
   148  func (combos ComboSet) requiresCurrentPack() bool {
   149  	return combos.requiresPackKind(Current)
   150  }
   151  
   152  func (combos ComboSet) requiresPreviousPack() bool {
   153  	return combos.requiresPackKind(Previous)
   154  }
   155  
   156  func (combos ComboSet) requiresPackKind(k ComboValue) bool {
   157  	for _, c := range combos {
   158  		if c.Pack == k || c.PackCreateBuilder == k {
   159  			return true
   160  		}
   161  	}
   162  
   163  	return false
   164  }
   165  
   166  func (combos ComboSet) IncludesCurrentSubjectPack() bool {
   167  	for _, c := range combos {
   168  		if c.Pack == Current {
   169  			return true
   170  		}
   171  	}
   172  
   173  	return false
   174  }
   175  
   176  func (combos ComboSet) requiresCurrentLifecycle() bool {
   177  	return combos.requiresLifecycleKind(Current)
   178  }
   179  
   180  func (combos ComboSet) requiresPreviousLifecycle() bool {
   181  	return combos.requiresLifecycleKind(Previous)
   182  }
   183  
   184  func (combos ComboSet) requiresDefaultLifecycle() bool {
   185  	return combos.requiresLifecycleKind(DefaultKind)
   186  }
   187  
   188  func (combos ComboSet) requiresLifecycleKind(k ComboValue) bool {
   189  	for _, c := range combos {
   190  		if c.Lifecycle == k {
   191  			return true
   192  		}
   193  	}
   194  
   195  	return false
   196  }