github.com/tilt-dev/tilt@v0.33.15-0.20240515162809-0a22ed45d8a0/internal/container/container.go (about)

     1  package container
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/distribution/reference"
     7  	"github.com/pkg/errors"
     8  )
     9  
    10  type ID string
    11  type Name string
    12  
    13  func (id ID) Empty() bool    { return id.String() == "" }
    14  func (id ID) String() string { return string(id) }
    15  func (id ID) ShortStr() string {
    16  	if len(string(id)) > 10 {
    17  		return string(id)[:10]
    18  	}
    19  	return string(id)
    20  }
    21  
    22  func (n Name) String() string { return string(n) }
    23  
    24  func ParseNamed(s string) (reference.Named, error) {
    25  	return reference.ParseNormalizedNamed(s)
    26  }
    27  
    28  func ParseNamedMulti(strs []string) ([]reference.Named, error) {
    29  	var err error
    30  	res := make([]reference.Named, len(strs))
    31  	for i, s := range strs {
    32  		res[i], err = reference.ParseNormalizedNamed(s)
    33  		if err != nil {
    34  			return nil, err
    35  		}
    36  	}
    37  	return res, nil
    38  }
    39  
    40  func ParseNamedTagged(s string) (reference.NamedTagged, error) {
    41  	ref, err := reference.ParseNormalizedNamed(s)
    42  	if err != nil {
    43  		return nil, errors.Wrapf(err, "parsing %q", s)
    44  	}
    45  
    46  	nt, ok := ref.(reference.NamedTagged)
    47  	if !ok {
    48  		return nil, fmt.Errorf("Expected reference %q to contain a tag", s)
    49  	}
    50  	return nt, nil
    51  }
    52  
    53  func MustParseNamedTagged(s string) reference.NamedTagged {
    54  	nt, err := ParseNamedTagged(s)
    55  	if err != nil {
    56  		panic(err)
    57  	}
    58  	return nt
    59  }
    60  
    61  func MustParseNamed(s string) reference.Named {
    62  	n, err := reference.ParseNormalizedNamed(s)
    63  	if err != nil {
    64  		panic(fmt.Sprintf("MustParseNamed(%q): %v", s, err))
    65  	}
    66  	return n
    67  }
    68  
    69  func MustWithTag(name reference.Named, tag string) reference.NamedTagged {
    70  	nt, err := reference.WithTag(name, tag)
    71  	if err != nil {
    72  		panic(err)
    73  	}
    74  	return nt
    75  }
    76  
    77  // ImageNamesEqual returns true if the references correspond to the same named
    78  // image.
    79  //
    80  // If either reference is not a valid named image reference, false is returned.
    81  //
    82  // For example: `reg.example.com/foo:abc` & `reg.example.com/foo:def` are equal
    83  // because the named image is `reg.example.com/foo` in both cases.
    84  func ImageNamesEqual(a, b string) bool {
    85  	aRef, err := reference.ParseNormalizedNamed(a)
    86  	if err != nil {
    87  		return false
    88  	}
    89  
    90  	bRef, err := reference.ParseNormalizedNamed(b)
    91  	if err != nil {
    92  		return false
    93  	}
    94  
    95  	return reference.FamiliarName(aRef) == reference.FamiliarName(bRef)
    96  }