releaser.go

Documentation: edge-infra.dev/pkg/f8n/warehouse/release

     1  package release
     2  
     3  import (
     4  	"context"
     5  
     6  	edgeinfra "edge-infra.dev"
     7  	"edge-infra.dev/pkg/lib/build/semver"
     8  
     9  	"fmt"
    10  
    11  	"github.com/go-logr/logr"
    12  	"github.com/google/go-containerregistry/pkg/authn"
    13  	ociname "github.com/google/go-containerregistry/pkg/name"
    14  	"github.com/google/go-containerregistry/pkg/v1/google"
    15  	gremote "github.com/google/go-containerregistry/pkg/v1/remote"
    16  
    17  	edgename "edge-infra.dev/pkg/f8n/warehouse/oci/name"
    18  	"edge-infra.dev/pkg/f8n/warehouse/oci/remote"
    19  
    20  	"edge-infra.dev/pkg/f8n/warehouse/pallet"
    21  )
    22  
    23  var (
    24  	defaultVersion string = edgeinfra.SemVer
    25  )
    26  
    27  // The Releaser is the structure for sourcing information to build and lock releases
    28  // from a source repository and list of pallets to serialize into an EdgeRelease
    29  // artifact
    30  type Releaser struct {
    31  	CurrentVersion        string     `yaml:"current_version,omitempty"`
    32  	SourceRepository      Repository `yaml:"source_repository"`
    33  	DestinationRepository Repository `yaml:"destination_repository"`
    34  	PalletNames           []string   `yaml:"pallets"`
    35  	Log                   logr.Logger
    36  }
    37  
    38  func (r *Releaser) BuildRelease(ctx context.Context, buildInfo pallet.BuildInfo) (EdgeRelease, error) {
    39  	if r.CurrentVersion == "" {
    40  		r.CurrentVersion = defaultVersion
    41  	}
    42  
    43  	err := semver.IsValidSemver(r.CurrentVersion)
    44  	if err != nil {
    45  		return EdgeRelease{}, err
    46  	}
    47  
    48  	meta := Metadata{
    49  		Vendor:          "NCR",
    50  		Version:         r.CurrentVersion,
    51  		BuildInfo:       buildInfo,
    52  		ReleaseRegistry: r.SourceRepository.Registry(),
    53  		ReleaseRepo:     r.SourceRepository.Name(),
    54  	}
    55  	pallets, err := r.getPallets(ctx)
    56  	if err != nil {
    57  		return EdgeRelease{}, err
    58  	}
    59  
    60  	release := New(meta, pallets)
    61  
    62  	return release, nil
    63  }
    64  
    65  func (r *Releaser) Push(ctx context.Context, rel EdgeRelease) error {
    66  	relTag, err := edgename.Tag(fmt.Sprintf("%s/edge-release:%s", r.DestinationRepository, rel.Metadata.Version))
    67  	if err != nil {
    68  		return err
    69  	}
    70  
    71  	r.Log.Info(fmt.Sprintf("writing %s", relTag))
    72  	err = remote.MultiWrite(
    73  		map[ociname.Reference]gremote.Taggable{relTag: rel.Artifact},
    74  		[]remote.Option{
    75  			remote.WithContext(ctx),
    76  			gremote.WithAuthFromKeychain(authn.NewMultiKeychain(
    77  				google.Keychain,
    78  				authn.DefaultKeychain,
    79  			)),
    80  		}...,
    81  	)
    82  	if err != nil {
    83  		return err
    84  	}
    85  	return nil
    86  }
    87  
    88  func (r *Releaser) getPallets(ctx context.Context) ([]pallet.Pallet, error) {
    89  	pallets := []pallet.Pallet{}
    90  
    91  	for _, p := range r.PalletNames {
    92  		pkgPath := fmt.Sprintf("%s/%s:%s", r.SourceRepository, p, r.CurrentVersion)
    93  		t, err := edgename.Tag(
    94  			pkgPath,
    95  			[]ociname.Option{
    96  				ociname.WithDefaultRegistry(r.SourceRepository.Registry()),
    97  			}...,
    98  		)
    99  		if err != nil {
   100  			return nil, err
   101  		}
   102  		r.Log.Info(fmt.Sprintf("pulling %s", pkgPath))
   103  		pall, err := remote.Pallet(
   104  			t,
   105  			[]remote.Option{
   106  				remote.WithContext(ctx),
   107  				gremote.WithAuthFromKeychain(authn.NewMultiKeychain(
   108  					google.Keychain,
   109  					authn.DefaultKeychain,
   110  				)),
   111  			}...,
   112  		)
   113  		if err != nil {
   114  			return nil, err
   115  		}
   116  		pallets = append(pallets, pall)
   117  	}
   118  	return pallets, nil
   119  }
   120
View as plain text