repo_name
stringlengths 1
52
| repo_creator
stringclasses 6
values | programming_language
stringclasses 4
values | code
stringlengths 0
9.68M
| num_lines
int64 1
234k
|
|---|---|---|---|---|
eks-anywhere-packages | aws | Go | package filewriter
import (
"errors"
"fmt"
"io"
"io/fs"
"io/ioutil"
"os"
"path/filepath"
)
type writer struct {
dir string
tempDir string
}
func NewWriter(dir string) (FileWriter, error) {
newFolder := filepath.Join(dir, DefaultTmpFolder)
if _, err := os.Stat(newFolder); errors.Is(err, os.ErrNotExist) {
err := os.MkdirAll(newFolder, os.ModePerm)
if err != nil {
return nil, fmt.Errorf("creating directory [%s]: %v", dir, err)
}
}
return &writer{dir: dir, tempDir: newFolder}, nil
}
func (w *writer) Write(fileName string, content []byte, opts ...FileOptionsFunc) (string, error) {
o := buildOptions(w, opts)
filePath := filepath.Join(o.BasePath, fileName)
err := ioutil.WriteFile(filePath, content, o.Permissions)
if err != nil {
return "", fmt.Errorf("writing to file [%s]: %v", filePath, err)
}
return filePath, nil
}
func (w *writer) WithDir(dir string) (FileWriter, error) {
return NewWriter(filepath.Join(w.dir, dir))
}
func (w *writer) Dir() string {
return w.dir
}
func (w *writer) TempDir() string {
return w.tempDir
}
func (w *writer) CleanUp() {
_, err := os.Stat(w.dir)
if err == nil {
os.RemoveAll(w.dir)
}
}
func (w *writer) CleanUpTemp() {
_, err := os.Stat(w.tempDir)
if err == nil {
os.RemoveAll(w.tempDir)
}
}
// Create creates a file with the given name rooted at w's base directory.
func (w *writer) Create(name string, opts ...FileOptionsFunc) (_ io.WriteCloser, path string, _ error) {
o := buildOptions(w, opts)
path = filepath.Join(o.BasePath, name)
fh, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, o.Permissions)
return fh, path, err
}
type options struct {
BasePath string
Permissions fs.FileMode
}
// buildOptions converts a set of FileOptionsFunc's to a single options struct.
func buildOptions(w *writer, opts []FileOptionsFunc) options {
op := defaultFileOptions()
for _, fn := range opts {
fn(op)
}
var basePath string
if op.IsTemp {
basePath = w.tempDir
} else {
basePath = w.dir
}
return options{
BasePath: basePath,
Permissions: op.Permissions,
}
}
| 100 |
eks-anywhere-packages | aws | Go | package filewriter_test
import (
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"github.com/aws/eks-anywhere-packages/credentialproviderpackage/internal/test"
"github.com/aws/eks-anywhere-packages/credentialproviderpackage/pkg/filewriter"
)
func TestWriterWriteValid(t *testing.T) {
folder := "tmp_folder"
folder2 := "tmp_folder_2"
err := os.MkdirAll(folder2, os.ModePerm)
if err != nil {
t.Fatalf("error setting up test: %v", err)
}
defer os.RemoveAll(folder)
defer os.RemoveAll(folder2)
tests := []struct {
testName string
dir string
fileName string
content []byte
}{
{
testName: "test 1",
dir: folder,
fileName: "TestWriterWriteValid-success.yaml",
content: []byte(`
fake content
blablab
`),
},
{
testName: "test 2",
dir: folder2,
fileName: "TestWriterWriteValid-success.yaml",
content: []byte(`
fake content
blablab
`),
},
}
for _, tt := range tests {
t.Run(tt.testName, func(t *testing.T) {
tr, err := filewriter.NewWriter(tt.dir)
if err != nil {
t.Fatalf("failed creating writer error = %v", err)
}
gotPath, err := tr.Write(tt.fileName, tt.content)
if err != nil {
t.Fatalf("writer.Write() error = %v", err)
}
wantPath := filepath.Join(tt.dir, filewriter.DefaultTmpFolder, tt.fileName)
if strings.Compare(gotPath, wantPath) != 0 {
t.Errorf("writer.Write() = %v, want %v", gotPath, wantPath)
}
test.AssertFilesEquals(t, gotPath, wantPath)
})
}
}
func TestEmptyFileName(t *testing.T) {
folder := "tmp_folder"
defer os.RemoveAll(folder)
tr, err := filewriter.NewWriter(folder)
if err != nil {
t.Fatalf("failed creating writer error = %v", err)
}
_, err = tr.Write("", []byte("content"))
if err == nil {
t.Fatalf("writer.Write() error is nil")
}
}
func TestWriterWithDir(t *testing.T) {
rootFolder := "folder_root"
subFolder := "subFolder"
defer os.RemoveAll(rootFolder)
tr, err := filewriter.NewWriter(rootFolder)
if err != nil {
t.Fatalf("failed creating writer error = %v", err)
}
tr, err = tr.WithDir(subFolder)
if err != nil {
t.Fatalf("failed creating writer with subdir error = %v", err)
}
gotPath, err := tr.Write("file.txt", []byte("file content"))
if err != nil {
t.Fatalf("writer.Write() error = %v", err)
}
wantPathPrefix := filepath.Join(rootFolder, subFolder)
if !strings.HasPrefix(gotPath, wantPathPrefix) {
t.Errorf("writer.Write() = %v, want to start with %v", gotPath, wantPathPrefix)
}
}
func TestWriterWritePersistent(t *testing.T) {
folder := "tmp_folder_opt"
folder2 := "tmp_folder_2_opt"
err := os.MkdirAll(folder2, os.ModePerm)
if err != nil {
t.Fatalf("error setting up test: %v", err)
}
defer os.RemoveAll(folder)
defer os.RemoveAll(folder2)
tests := []struct {
testName string
dir string
fileName string
content []byte
options []filewriter.FileOptionsFunc
}{
{
testName: "Write persistent file",
dir: folder,
fileName: "TestWriterWriteValid-success.yaml",
content: []byte(`
fake content
blablab
`),
options: []filewriter.FileOptionsFunc{filewriter.PersistentFile},
},
}
for _, tt := range tests {
t.Run(tt.testName, func(t *testing.T) {
tr, err := filewriter.NewWriter(tt.dir)
if err != nil {
t.Fatalf("failed creating writer error = %v", err)
}
gotPath, err := tr.Write(tt.fileName, tt.content, tt.options...)
if err != nil {
t.Fatalf("writer.Write() error = %v", err)
}
wantPath := filepath.Join(tt.dir, tt.fileName)
if strings.Compare(gotPath, wantPath) != 0 {
t.Errorf("writer.Write() = %v, want %v", gotPath, wantPath)
}
test.AssertFilesEquals(t, gotPath, wantPath)
})
}
}
func TestWriterDir(t *testing.T) {
rootFolder := "folder_root"
defer os.RemoveAll(rootFolder)
tr, err := filewriter.NewWriter(rootFolder)
if err != nil {
t.Fatalf("failed creating writer error = %v", err)
}
if strings.Compare(tr.Dir(), rootFolder) != 0 {
t.Errorf("writer.Dir() = %v, want %v", tr.Dir(), rootFolder)
}
}
func TestWriterTempDir(t *testing.T) {
rootFolder := "folder_root"
tempFolder := fmt.Sprintf("%s/generated", rootFolder)
defer os.RemoveAll(rootFolder)
tr, err := filewriter.NewWriter(rootFolder)
if err != nil {
t.Fatalf("failed creating writer error = %v", err)
}
if strings.Compare(tr.TempDir(), tempFolder) != 0 {
t.Errorf("writer.TempDir() = %v, want %v", tr.TempDir(), tempFolder)
}
}
func TestWriterCleanUpTempDir(t *testing.T) {
rootFolder := "folder_root"
defer os.RemoveAll(rootFolder)
tr, err := filewriter.NewWriter(rootFolder)
if err != nil {
t.Fatalf("failed creating writer error = %v", err)
}
tr.CleanUpTemp()
if _, err := os.Stat(tr.TempDir()); err == nil {
t.Errorf("writer.CleanUp(), want err, got nil")
}
}
| 204 |
eks-anywhere-packages | aws | Go | package log
import (
"log"
"os"
)
var (
InfoLogger *log.Logger
WarningLogger *log.Logger
ErrorLogger *log.Logger
)
func init() {
InfoLogger = log.New(os.Stdout, "INFO: ", log.Lshortfile)
WarningLogger = log.New(os.Stderr, "WARNING: ", log.Lshortfile)
ErrorLogger = log.New(os.Stderr, "ERROR: ", log.Lshortfile)
}
| 19 |
eks-anywhere-packages | aws | Go | package templater
import (
"reflect"
"sigs.k8s.io/yaml"
)
type PartialYaml map[string]interface{}
func (p PartialYaml) AddIfNotZero(k string, v interface{}) {
if !isZeroVal(v) {
p[k] = v
}
}
func isZeroVal(x interface{}) bool {
return x == nil || reflect.DeepEqual(x, reflect.Zero(reflect.TypeOf(x)).Interface())
}
func (p PartialYaml) ToYaml() (string, error) {
b, err := yaml.Marshal(p)
if err != nil {
return "", err
}
s := string(b)
return s, nil
}
| 30 |
eks-anywhere-packages | aws | Go | package templater_test
import (
"reflect"
"testing"
"github.com/aws/eks-anywhere-packages/credentialproviderpackage/internal/test"
"github.com/aws/eks-anywhere-packages/credentialproviderpackage/pkg/templater"
)
func TestPartialYamlAddIfNotZero(t *testing.T) {
tests := []struct {
testName string
p templater.PartialYaml
k string
v interface{}
wantAdded bool
wantV interface{}
}{
{
testName: "add string",
p: templater.PartialYaml{},
k: "key",
v: "value",
wantAdded: true,
wantV: "value",
},
{
testName: "add nil",
p: templater.PartialYaml{},
k: "key",
v: nil,
wantAdded: false,
wantV: nil,
},
{
testName: "add empty string",
p: templater.PartialYaml{},
k: "key",
v: "",
wantAdded: false,
wantV: nil,
},
{
testName: "add present string",
p: templater.PartialYaml{
"key": "value_old",
},
k: "key",
v: "value_new",
wantAdded: true,
wantV: "value_new",
},
}
for _, tt := range tests {
t.Run(tt.testName, func(t *testing.T) {
tt.p.AddIfNotZero(tt.k, tt.v)
gotV, gotAdded := tt.p[tt.k]
if tt.wantAdded != gotAdded {
t.Errorf("PartialYaml.AddIfNotZero() wasAdded = %v, wantAdded %v", gotAdded, tt.wantAdded)
}
if !reflect.DeepEqual(gotV, tt.wantV) {
t.Errorf("PartialYaml.AddIfNotZero() gotValue = %v, wantValue %v", gotV, tt.wantV)
}
})
}
}
func TestPartialYamlToYaml(t *testing.T) {
tests := []struct {
testName string
p templater.PartialYaml
wantFile string
wantErr bool
}{
{
testName: "simple object",
p: templater.PartialYaml{
"key1": "value 1",
"key2": 2,
"key3": "value3",
},
wantFile: "testdata/partial_yaml_object_expected.yaml",
wantErr: false,
},
{
testName: "map",
p: templater.PartialYaml{
"key1": "value 1",
"key2": 2,
"key3": map[string]string{
"key_nest1": "value nest",
"key_nest2": "value nest 2",
},
"key4": map[string]interface{}{
"key_nest1": "value nest",
"key_nest2": 22,
},
},
wantFile: "testdata/partial_yaml_map_expected.yaml",
wantErr: false,
},
{
testName: "array",
p: templater.PartialYaml{
"key1": "value 1",
"key2": 2,
"key3": []string{"value array 1", "value array 2"},
"key4": []interface{}{
map[string]interface{}{
"key_in_nest_array": "value",
"key_in_nest_array_2": 22,
},
},
},
wantFile: "testdata/partial_yaml_array_expected.yaml",
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.testName, func(t *testing.T) {
got, err := tt.p.ToYaml()
if (err != nil) != tt.wantErr {
t.Fatalf("PartialYaml.ToYaml() error = %v, wantErr %v", err, tt.wantErr)
}
test.AssertContentToFile(t, got, tt.wantFile)
})
}
}
| 132 |
eks-anywhere-packages | aws | Go | package templater
import (
"bytes"
"fmt"
"strings"
"text/template"
"github.com/aws/eks-anywhere-packages/credentialproviderpackage/pkg/filewriter"
)
type Templater struct {
writer filewriter.FileWriter
}
func New(writer filewriter.FileWriter) *Templater {
return &Templater{
writer: writer,
}
}
func (t *Templater) WriteToFile(templateContent string, data interface{}, fileName string, f ...filewriter.FileOptionsFunc) (filePath string, err error) {
bytes, err := Execute(templateContent, data)
if err != nil {
return "", err
}
writtenFilePath, err := t.writer.Write(fileName, bytes, f...)
if err != nil {
return "", fmt.Errorf("writing template file: %v", err)
}
return writtenFilePath, nil
}
func (t *Templater) WriteBytesToFile(content []byte, fileName string, f ...filewriter.FileOptionsFunc) (filePath string, err error) {
writtenFilePath, err := t.writer.Write(fileName, content, f...)
if err != nil {
return "", fmt.Errorf("writing template file: %v", err)
}
return writtenFilePath, nil
}
func Execute(templateContent string, data interface{}) ([]byte, error) {
temp := template.New("tmpl")
funcMap := map[string]interface{}{
"indent": func(spaces int, v string) string {
pad := strings.Repeat(" ", spaces)
return pad + strings.Replace(v, "\n", "\n"+pad, -1)
},
"stringsJoin": strings.Join,
}
temp = temp.Funcs(funcMap)
temp, err := temp.Parse(templateContent)
if err != nil {
return nil, fmt.Errorf("parsing template: %v", err)
}
var buf bytes.Buffer
err = temp.Execute(&buf, data)
if err != nil {
return nil, fmt.Errorf("substituting values for template: %v", err)
}
return buf.Bytes(), nil
}
| 67 |
eks-anywhere-packages | aws | Go | package templater_test
import (
"os"
"strings"
"testing"
"github.com/aws/eks-anywhere-packages/credentialproviderpackage/internal/test"
"github.com/aws/eks-anywhere-packages/credentialproviderpackage/pkg/filewriter"
"github.com/aws/eks-anywhere-packages/credentialproviderpackage/pkg/templater"
)
func TestTemplaterWriteToFileSuccess(t *testing.T) {
type dataStruct struct {
Key1, Key2, Key3, KeyAndValue3 string
Conditional bool
}
tests := []struct {
testName string
templateFile string
data dataStruct
fileName string
wantFilePath string
wantErr bool
}{
{
testName: "with conditional true",
templateFile: "testdata/test1_template.yaml",
data: dataStruct{
Key1: "value_1",
Key2: "value_2",
Key3: "value_3",
Conditional: true,
},
fileName: "file_tmp.yaml",
wantFilePath: "testdata/test1_conditional_true_want.yaml",
wantErr: false,
},
{
testName: "with conditional false",
templateFile: "testdata/test1_template.yaml",
data: dataStruct{
Key1: "value_1",
Key2: "value_2",
Key3: "value_3",
Conditional: false,
},
fileName: "file_tmp.yaml",
wantFilePath: "testdata/test1_conditional_false_want.yaml",
wantErr: false,
},
{
testName: "with indent",
templateFile: "testdata/test_indent_template.yaml",
data: dataStruct{
Key1: "value_1",
Key2: "value_2",
KeyAndValue3: "key3: value_3",
Conditional: true,
},
fileName: "file_tmp.yaml",
wantFilePath: "testdata/test_indent_want.yaml",
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.testName, func(t *testing.T) {
_, writer := test.NewWriter(t)
tr := templater.New(writer)
templateContent := test.ReadFile(t, tt.templateFile)
gotFilePath, err := tr.WriteToFile(templateContent, tt.data, tt.fileName)
if (err != nil) != tt.wantErr {
t.Fatalf("Templater.WriteToFile() error = %v, wantErr %v", err, tt.wantErr)
}
if !strings.HasSuffix(gotFilePath, tt.fileName) {
t.Errorf("Templater.WriteToFile() = %v, want to end with %v", gotFilePath, tt.fileName)
}
test.AssertFilesEquals(t, gotFilePath, tt.wantFilePath)
})
}
}
func TestTemplaterWriteToFileError(t *testing.T) {
folder := "tmp_folder"
defer os.RemoveAll(folder)
writer, err := filewriter.NewWriter(folder)
if err != nil {
t.Fatalf("failed creating writer error = #{err}")
}
type dataStruct struct {
Key1, Key2, Key3 string
Conditional bool
}
tests := []struct {
testName string
templateFile string
data dataStruct
fileName string
}{
{
testName: "invalid template",
templateFile: "testdata/invalid_template.yaml",
data: dataStruct{
Key1: "value_1",
Key2: "value_2",
Key3: "value_3",
Conditional: true,
},
fileName: "file_tmp.yaml",
},
{
testName: "data doesn't exist",
templateFile: "testdata/key4_template.yaml",
data: dataStruct{
Key1: "value_1",
Key2: "value_2",
Key3: "value_3",
Conditional: false,
},
fileName: "file_tmp.yaml",
},
}
for _, tt := range tests {
t.Run(tt.testName, func(t *testing.T) {
tr := templater.New(writer)
templateContent := test.ReadFile(t, tt.templateFile)
gotFilePath, err := tr.WriteToFile(templateContent, tt.data, tt.fileName)
if err == nil {
t.Errorf("Templater.WriteToFile() error = nil")
}
if gotFilePath != "" {
t.Errorf("Templater.WriteToFile() = %v, want nil", gotFilePath)
}
})
}
}
| 144 |
eks-anywhere-packages | aws | Go | package templater
import (
"fmt"
"k8s.io/apimachinery/pkg/runtime"
"sigs.k8s.io/yaml"
)
const objectSeparator string = "\n---\n"
func AppendYamlResources(resources ...[]byte) []byte {
separator := []byte(objectSeparator)
size := 0
for _, resource := range resources {
size += len(resource) + len(separator)
}
b := make([]byte, 0, size)
for _, resource := range resources {
b = append(b, resource...)
b = append(b, separator...)
}
return b
}
func ObjectsToYaml(objs ...runtime.Object) ([]byte, error) {
r := [][]byte{}
for _, o := range objs {
b, err := yaml.Marshal(o)
if err != nil {
return nil, fmt.Errorf("failed to marshal object: %v", err)
}
r = append(r, b)
}
return AppendYamlResources(r...), nil
}
| 40 |
eks-anywhere-packages | aws | Go | package main
import (
"fmt"
"os"
"time"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/constants"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/secrets"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/secrets/aws"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/secrets/common"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/secrets/registrymirror"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/utils"
)
func main() {
utils.InfoLogger.Println("Running at " + time.Now().UTC().String())
defaultClientSet, err := common.GetDefaultClientSet()
if err != nil {
utils.ErrorLogger.Println(err)
os.Exit(0)
}
clientSets, err := common.GetRemoteClientSets(defaultClientSet)
if err != nil {
utils.ErrorLogger.Println(err)
os.Exit(0)
}
defaultClusterName, found := os.LookupEnv(constants.DefaultClusterNameKey)
if !found {
utils.ErrorLogger.Println(fmt.Errorf("environment variable %s is required", constants.DefaultClusterNameKey))
os.Exit(0)
}
clientSets[defaultClusterName] = defaultClientSet
secrets := []secrets.Secret{
&aws.AwsSecret{},
®istrymirror.RegistryMirrorSecret{},
}
utils.InfoLogger.Println("Initialization starts...")
for _, secret := range secrets {
err := secret.Init(defaultClusterName, clientSets)
if err != nil {
utils.ErrorLogger.Println(err)
}
}
utils.InfoLogger.Println("Initialization completes...")
utils.InfoLogger.Println("Broadcasting starts...")
for _, secret := range secrets {
if secret.IsActive() {
err = secret.BroadcastCredentials()
if err != nil {
utils.ErrorLogger.Println(err)
}
} else {
utils.InfoLogger.Println(secret.GetName() + " is inactive")
}
}
utils.InfoLogger.Println("Broadcasting ends...")
utils.InfoLogger.Println("Job complete at " + time.Now().UTC().String())
}
| 66 |
eks-anywhere-packages | aws | Go | package constants
const (
ConfigMapName = "ns-secret-map"
EksaSystemNamespace = "eksa-system"
PackagesNamespace = "eksa-packages"
NamespacePrefix = PackagesNamespace + "-"
DefaultClusterNameKey = "CLUSTER_NAME"
)
| 10 |
eks-anywhere-packages | aws | Go | package k8s
import (
"context"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/kubernetes"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/constants"
)
func GetSecret(clientSet kubernetes.Interface, name, namespace string) (*corev1.Secret, error) {
secret, err := clientSet.CoreV1().Secrets(namespace).Get(context.TODO(), name, metav1.GetOptions{})
if err != nil {
return nil, err
}
return secret, nil
}
func CreateSecret(clientSet kubernetes.Interface, name string, namespace string, data map[string][]byte) (*corev1.Secret, error) {
object := metav1.ObjectMeta{
Name: name,
Namespace: namespace,
}
secret := corev1.Secret{
ObjectMeta: object,
Type: corev1.SecretTypeDockerConfigJson,
Data: data,
}
return clientSet.CoreV1().Secrets(namespace).Create(context.TODO(), &secret, metav1.CreateOptions{})
}
func UpdateSecret(clientSet kubernetes.Interface, namespace string, secret *corev1.Secret, data map[string][]byte) (*corev1.Secret, error) {
for k, v := range data {
secret.Data[k] = v
}
return clientSet.CoreV1().Secrets(namespace).Update(context.TODO(), secret, metav1.UpdateOptions{})
}
func GetNamespaces(clientSet kubernetes.Interface) (*corev1.NamespaceList, error) {
nslist, err := clientSet.CoreV1().Namespaces().List(context.TODO(), metav1.ListOptions{})
if err != nil {
return nil, err
}
return nslist, nil
}
func GetConfigMap(clientSet kubernetes.Interface, namespace string) (*corev1.ConfigMap, error) {
cm, err := clientSet.CoreV1().ConfigMaps(namespace).
Get(context.TODO(), constants.ConfigMapName, metav1.GetOptions{})
if err != nil {
return nil, err
}
return cm, err
}
| 58 |
eks-anywhere-packages | aws | Go | package secrets
import "k8s.io/client-go/kubernetes"
type Credential struct {
Registry string
Username string
Password string
CA string
Insecure string
}
type (
ClusterClientSet map[string]kubernetes.Interface
ClusterCredential map[string][]*Credential
)
type Secret interface {
Init(mgmtClusterName string, clientSets ClusterClientSet) error
IsActive() bool
GetClusterCredentials(clientSets ClusterClientSet) (ClusterCredential, error)
BroadcastCredentials() error
GetName() string
}
| 25 |
eks-anywhere-packages | aws | Go | package aws
import (
"encoding/base64"
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ecr"
"github.com/aws/aws-sdk-go/service/sts"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/secrets"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/secrets/common"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/utils"
)
type AwsSecret struct {
secretName string
mgmtClusterName string
clientSets secrets.ClusterClientSet
clusterCredentials secrets.ClusterCredential
}
var _ secrets.Secret = (*AwsSecret)(nil)
const (
envVarAwsSecret = "ECR_TOKEN_SECRET_NAME" //#nosec G101
envVarIRSAToken = "AWS_WEB_IDENTITY_TOKEN_FILE" //#nosec G101
envRoleARN = "AWS_ROLE_ARN"
envWebTokenFile = "AWS_WEB_IDENTITY_TOKEN_FILE" //#nosec G101
sessionName = "GetECRTOKENSession"
sessionTimeSeconds = 1000
defaultAccountID = "783794618700"
devAccountID = "857151390494"
envRegionName = "AWS_REGION"
envVarAwsAccessKeyID = "AWS_ACCESS_KEY_ID"
envVarAwsAccessKey = "AWS_SECRET_ACCESS_KEY"
envSessionToken = "AWS_SESSION_TOKEN"
regionDefault = "us-west-2"
)
func (aws *AwsSecret) Init(mgmtClusterName string, clientSets secrets.ClusterClientSet) error {
secretname := os.Getenv(envVarAwsSecret)
if secretname == "" {
return fmt.Errorf("environment variable %s is required", envVarAwsSecret)
}
aws.secretName = secretname
// Check if IRSA is setup
// If IRSA is enabled, use IRSA to setup enviroment variables for AWS Creds
webIdentityTokenFile := os.Getenv(envVarIRSAToken)
if webIdentityTokenFile != "" {
err := setupIRSA()
if err != nil {
return err
}
}
aws.mgmtClusterName = mgmtClusterName
aws.clientSets = clientSets
return nil
}
func (aws *AwsSecret) IsActive() bool {
if val, _ := os.LookupEnv(envVarAwsAccessKeyID); val == "" {
return false
}
if val, _ := os.LookupEnv(envVarAwsAccessKey); val == "" {
return false
}
return true
}
func (aws *AwsSecret) GetName() string {
return aws.secretName
}
func (aws *AwsSecret) GetClusterCredentials(clientSets secrets.ClusterClientSet) (secrets.ClusterCredential, error) {
creds, err := aws.getCredentials()
if err != nil {
return nil, err
}
clusterCredentials := make(secrets.ClusterCredential)
for clusterName := range clientSets {
clusterCredentials[clusterName] = creds
}
return clusterCredentials, nil
}
func (aws *AwsSecret) getCredentials() ([]*secrets.Credential, error) {
utils.InfoLogger.Println("fetching auth data from AWS... ")
// Default AWS Region to us-west-2 if not set by User.
_, ok := os.LookupEnv(envRegionName)
if !ok {
err := os.Setenv(envRegionName, regionDefault)
if err != nil {
return nil, err
}
}
var ecrRegs []*string
defID := defaultAccountID
ecrRegs = append(ecrRegs, &defID)
devID := devAccountID
ecrRegs = append(ecrRegs, &devID)
svc := ecr.New(session.Must(session.NewSession()))
token, err := svc.GetAuthorizationToken(&ecr.GetAuthorizationTokenInput{RegistryIds: ecrRegs})
if err != nil {
return nil, err
}
if token == nil {
return nil, fmt.Errorf("response output from ECR was nil")
}
if len(token.AuthorizationData) == 0 {
return nil, fmt.Errorf("authorization data was empty")
}
var creds []*secrets.Credential
for _, auth := range token.AuthorizationData {
decode, err := base64.StdEncoding.DecodeString(*auth.AuthorizationToken)
if err != nil {
return nil, err
}
parts := strings.Split(string(decode), ":")
if len(parts) != 2 {
return nil, fmt.Errorf("error parsing username and password from authorization token")
}
cred := secrets.Credential{
Username: parts[0],
Password: parts[1],
Registry: *auth.ProxyEndpoint,
}
creds = append(creds, &cred)
}
utils.InfoLogger.Println("success.")
return creds, nil
}
func (aws *AwsSecret) BroadcastCredentials() error {
var err error
aws.clusterCredentials, err = aws.GetClusterCredentials(aws.clientSets)
if err != nil {
return err
}
for clusterName, creds := range aws.clusterCredentials {
dockerConfig := common.CreateDockerAuthConfig(creds)
configJson, err := json.Marshal(dockerConfig)
if err != nil {
return err
}
common.BroadcastDockerAuthConfig(configJson, aws.clientSets[aws.mgmtClusterName], aws.clientSets[clusterName], aws.secretName, clusterName)
}
return nil
}
func setupIRSA() error {
roleArn := os.Getenv(envRoleARN)
if roleArn == "" {
return fmt.Errorf("environment variable %s missing, check that Webhook for IRSA is setup", envRoleARN)
}
webIdentityTokenFile := os.Getenv(envWebTokenFile)
if webIdentityTokenFile == "" {
return fmt.Errorf("environment variable %s missing, check that token is mounted", envWebTokenFile)
}
token, err := os.ReadFile(filepath.Clean(webIdentityTokenFile))
if err != nil {
return err
}
webIdentityToken := string(token)
session, err := session.NewSession()
if err != nil {
return err
}
svc := sts.New(session)
input := &sts.AssumeRoleWithWebIdentityInput{
DurationSeconds: aws.Int64(sessionTimeSeconds),
RoleArn: aws.String(roleArn),
RoleSessionName: aws.String(sessionName),
WebIdentityToken: aws.String(webIdentityToken),
}
result, err := svc.AssumeRoleWithWebIdentity(input)
if err != nil {
return err
}
err = os.Setenv(envVarAwsAccessKeyID, aws.StringValue(result.Credentials.AccessKeyId))
if err != nil {
return err
}
err = os.Setenv(envVarAwsAccessKey, aws.StringValue(result.Credentials.SecretAccessKey))
if err != nil {
return err
}
err = os.Setenv(envSessionToken, aws.StringValue(result.Credentials.SessionToken))
if err != nil {
return err
}
return err
}
| 212 |
eks-anywhere-packages | aws | Go | package common
import (
"encoding/base64"
"fmt"
"os"
"path/filepath"
"strings"
corev1 "k8s.io/api/core/v1"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/constants"
k8s "github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/kubernetes"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/secrets"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/utils"
)
const defaultEmail = "[email protected]"
type dockerConfig struct {
Auths map[string]*dockerAuth `json:"auths"`
}
type dockerAuth struct {
Username string `json:"username"`
Password string `json:"password"`
Email string `json:"email"`
Auth string `json:"auth"`
}
func GetDefaultClientSet() (*kubernetes.Clientset, error) {
config, err := rest.InClusterConfig()
if err != nil {
// Program is not being run from inside cluster. Try default kubeconfig
if val, ok := os.LookupEnv("KUBECONFIG"); ok {
config, err = clientcmd.BuildConfigFromFlags("", val)
} else {
config, err = clientcmd.BuildConfigFromFlags("",
filepath.Join(os.Getenv("HOME"), ".kube", "config"))
}
if err != nil {
return nil, err
}
}
clientSet, err := kubernetes.NewForConfig(config)
if err != nil {
return nil, err
}
return clientSet, err
}
func GetRemoteClientSets(defaultClientset *kubernetes.Clientset) (secrets.ClusterClientSet, error) {
clusterNames, err := getClusterNameFromNamespaces(defaultClientset)
if err != nil {
return nil, err
}
remoteClientSets := make(secrets.ClusterClientSet)
for _, clusterName := range clusterNames {
secretName := clusterName + "-kubeconfig"
kubeconfigSecret, err := k8s.GetSecret(defaultClientset, secretName, constants.EksaSystemNamespace)
if err != nil {
return nil, err
}
kubeconfig := kubeconfigSecret.Data["value"]
if len(kubeconfig) <= 0 {
return nil, fmt.Errorf("kubeconfig string in secret not set")
}
clientConfig, err := clientcmd.NewClientConfigFromBytes(kubeconfig)
if err != nil {
return nil, fmt.Errorf("creating client config: %s", err)
}
config, err := clientConfig.ClientConfig()
if err != nil {
return nil, fmt.Errorf("creating rest config config: %s", err)
}
remoteClientSet, err := kubernetes.NewForConfig(config)
if err != nil {
return nil, err
}
remoteClientSets[clusterName] = remoteClientSet
}
return remoteClientSets, nil
}
func getClusterNameFromNamespaces(clientSet kubernetes.Interface) ([]string, error) {
clusterNameList := make([]string, 0)
nslist, err := k8s.GetNamespaces(clientSet)
if err != nil {
return nil, err
}
for _, ns := range nslist.Items {
if strings.HasPrefix(ns.Name, constants.NamespacePrefix) {
clusterName := strings.TrimPrefix(ns.Name, constants.NamespacePrefix)
clusterNameList = append(clusterNameList, clusterName)
}
}
return clusterNameList, nil
}
func CreateDockerAuthConfig(creds []*secrets.Credential) *dockerConfig {
config := dockerConfig{Auths: make(map[string]*dockerAuth)}
for _, cred := range creds {
config.Auths[cred.Registry] = &dockerAuth{
Username: cred.Username,
Password: cred.Password,
Email: defaultEmail,
Auth: base64.StdEncoding.EncodeToString([]byte(cred.Username + ":" + cred.Password)),
}
}
return &config
}
func BroadcastDockerAuthConfig(configJson []byte, defaultClientSet, remoteClientSet kubernetes.Interface, secretName, clusterName string) {
namespaces, err := getNamespacesFromConfigMap(defaultClientSet, constants.NamespacePrefix+clusterName)
if err != nil {
utils.WarningLogger.Printf("failed to find config map for cluster %s\n", clusterName)
return
}
for _, ns := range namespaces {
secret, _ := k8s.GetSecret(remoteClientSet, secretName, ns)
if secret == nil {
_, err = k8s.CreateSecret(remoteClientSet, secretName, ns, map[string][]byte{corev1.DockerConfigJsonKey: configJson})
if err != nil {
utils.WarningLogger.Printf("failed to create %s in %s namespace\n", secretName, ns)
}
} else {
_, err = k8s.UpdateSecret(remoteClientSet, ns, secret, map[string][]byte{corev1.DockerConfigJsonKey: configJson})
if err != nil {
utils.WarningLogger.Printf("failed to update %s in %s namespace\n", secretName, ns)
}
}
}
}
func getNamespacesFromConfigMap(clientSet kubernetes.Interface, namespace string) ([]string, error) {
cm, err := k8s.GetConfigMap(clientSet, namespace)
if err != nil {
return nil, err
}
values := make([]string, 0)
for ns := range cm.Data {
values = append(values, ns)
}
return values, err
}
| 162 |
eks-anywhere-packages | aws | Go | package common
import (
"encoding/base64"
"encoding/json"
"testing"
"github.com/stretchr/testify/assert"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/kubernetes/fake"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/constants"
k8s "github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/kubernetes"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/secrets"
)
const (
secretName = "test-secret"
clusterName = "test-cluster"
)
var (
ns = &v1.Namespace{
ObjectMeta: metav1.ObjectMeta{
Name: constants.NamespacePrefix + clusterName,
},
}
cm = &v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: constants.ConfigMapName,
Namespace: constants.NamespacePrefix + clusterName,
},
Data: map[string]string{
"ns1": secretName,
"ns2": secretName,
},
}
secret = &v1.Secret{
ObjectMeta: metav1.ObjectMeta{
Name: secretName,
Namespace: "ns1",
},
Data: map[string][]byte{
v1.DockerConfigJsonKey: {},
},
}
)
func TestCreateDockerAuthConfig(t *testing.T) {
creds := []*secrets.Credential{
{
Username: "user",
Password: "password",
Registry: "1.2.3.4",
},
}
dockerConfig := CreateDockerAuthConfig(creds)
assert.NotNil(t, dockerConfig)
assert.Equal(t, len(dockerConfig.Auths), 1)
assert.EqualValues(t, &dockerAuth{
Username: "user",
Password: "password",
Email: defaultEmail,
Auth: base64.StdEncoding.EncodeToString([]byte("user:password")),
}, dockerConfig.Auths["1.2.3.4"])
}
func TestBroadcastDockerAuthConfig(t *testing.T) {
dockerConfig := dockerConfig{
Auths: map[string]*dockerAuth{
"1.2.3.4": {
Username: "user",
Password: "password",
Email: "[email protected]",
Auth: "dXNlcjpwYXNzd29yZA==",
},
},
}
configJson, _ := json.Marshal(dockerConfig)
defaultClientSet := fake.NewSimpleClientset(cm)
t.Run("create secret", func(t *testing.T) {
remoteClientSets := secrets.ClusterClientSet{
clusterName: fake.NewSimpleClientset(),
}
BroadcastDockerAuthConfig(configJson, defaultClientSet, remoteClientSets[clusterName], secretName, clusterName)
for _, ns := range []string{"ns1", "ns2"} {
secret, err := k8s.GetSecret(remoteClientSets[clusterName], secretName, ns)
assert.NoError(t, err)
assert.Equal(t, configJson, secret.Data[v1.DockerConfigJsonKey])
}
})
t.Run("update secret", func(t *testing.T) {
remoteClientSets := secrets.ClusterClientSet{
clusterName: fake.NewSimpleClientset(secret),
}
BroadcastDockerAuthConfig(configJson, defaultClientSet, remoteClientSets[clusterName], secretName, clusterName)
secret, err := k8s.GetSecret(remoteClientSets[clusterName], secretName, "ns1")
assert.NoError(t, err)
assert.Equal(t, configJson, secret.Data[v1.DockerConfigJsonKey])
})
}
func TestGetClusterNameFromNamespaces(t *testing.T) {
clientSet := fake.NewSimpleClientset(ns)
nsList, err := getClusterNameFromNamespaces(clientSet)
assert.NoError(t, err)
assert.ElementsMatch(t, nsList, []string{clusterName})
}
func TestGetNamespacesFromConfigMap(t *testing.T) {
clientSet := fake.NewSimpleClientset(cm)
nsList, err := getNamespacesFromConfigMap(clientSet, constants.NamespacePrefix+clusterName)
assert.NoError(t, err)
assert.ElementsMatch(t, nsList, []string{"ns1", "ns2"})
}
| 120 |
eks-anywhere-packages | aws | Go | package registrymirror
import (
"encoding/json"
corev1 "k8s.io/api/core/v1"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/constants"
k8s "github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/kubernetes"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/secrets"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/secrets/common"
"github.com/aws/eks-anywhere-packages/ecrtokenrefresher/pkg/utils"
)
const (
endpointKey = "ENDPOINT"
usernameKey = "USERNAME"
passwordKey = "PASSWORD"
caKey = "CACERTCONTENT"
insecureKey = "INSECURE"
credName = "registry-mirror-cred"
secretName = "registry-mirror-secret"
)
type RegistryMirrorSecret struct {
credName string
mgmtClusterName string
clientSets secrets.ClusterClientSet
clusterCredentials secrets.ClusterCredential
}
var _ secrets.Secret = (*RegistryMirrorSecret)(nil)
func (mirror *RegistryMirrorSecret) Init(mgmtClusterName string, clientSets secrets.ClusterClientSet) error {
var err error
mirror.credName = credName
mirror.mgmtClusterName = mgmtClusterName
mirror.clientSets = clientSets
mirror.clusterCredentials, err = mirror.GetClusterCredentials(mirror.clientSets)
return err
}
func (mirror *RegistryMirrorSecret) IsActive() bool {
return len(mirror.clusterCredentials) > 0
}
func (mirror *RegistryMirrorSecret) GetName() string {
return mirror.credName
}
func (mirror *RegistryMirrorSecret) GetClusterCredentials(clientSets secrets.ClusterClientSet) (secrets.ClusterCredential, error) {
clusterCredentials := make(secrets.ClusterCredential)
defaultClientSet := mirror.clientSets[mirror.mgmtClusterName]
for clusterName := range clientSets {
utils.InfoLogger.Printf("fetching registry mirror auth data for cluster %s...\n", clusterName)
namespace := constants.PackagesNamespace
if clusterName != mirror.mgmtClusterName {
namespace = constants.NamespacePrefix + clusterName
}
secret, err := k8s.GetSecret(defaultClientSet, secretName, namespace)
if err == nil {
credential := &secrets.Credential{
Registry: string(secret.Data[endpointKey]),
Username: string(secret.Data[usernameKey]),
Password: string(secret.Data[passwordKey]),
CA: string(secret.Data[caKey]),
Insecure: string(secret.Data[insecureKey]),
}
if credential.Registry != "" && credential.Username != "" && credential.Password != "" {
clusterCredentials[clusterName] = []*secrets.Credential{credential}
utils.InfoLogger.Println("success.")
} else {
utils.InfoLogger.Println("empty credential.")
}
} else {
utils.ErrorLogger.Println(err)
return nil, err
}
}
return clusterCredentials, nil
}
func (mirror *RegistryMirrorSecret) BroadcastCredentials() error {
defaultClientSet := mirror.clientSets[mirror.mgmtClusterName]
data := make(map[string][]byte)
for clusterName, creds := range mirror.clusterCredentials {
dockerConfig := common.CreateDockerAuthConfig(creds)
configJson, err := json.Marshal(*dockerConfig)
if err != nil {
return err
}
common.BroadcastDockerAuthConfig(configJson, defaultClientSet, mirror.clientSets[clusterName], mirror.credName, clusterName)
if clusterName == mirror.mgmtClusterName {
data[corev1.DockerConfigJsonKey] = configJson
}
data[clusterName+"_ca.crt"] = []byte(creds[0].CA)
data["config.json"] = configJson
if creds[0].Insecure == "true" {
data[clusterName+"_insecure"] = []byte(creds[0].Insecure)
}
}
// create a registry mirror secret for package controller pod to mount
if _, ok := data[corev1.DockerConfigJsonKey]; !ok {
configJson, _ := json.Marshal(common.CreateDockerAuthConfig([]*secrets.Credential{{
Registry: "", Username: "", Password: "", CA: "", Insecure: "",
}}))
data[corev1.DockerConfigJsonKey] = configJson
}
secret, _ := k8s.GetSecret(defaultClientSet, credName, constants.PackagesNamespace)
if secret == nil {
_, err := k8s.CreateSecret(defaultClientSet, credName, constants.PackagesNamespace, data)
if err != nil {
return err
}
} else {
_, err := k8s.UpdateSecret(defaultClientSet, constants.PackagesNamespace, secret, data)
if err != nil {
return err
}
}
return nil
}
| 124 |
eks-anywhere-packages | aws | Go | package utils
import (
"log"
"os"
)
var (
InfoLogger *log.Logger
WarningLogger *log.Logger
ErrorLogger *log.Logger
)
func init() {
InfoLogger = log.New(os.Stdout, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)
WarningLogger = log.New(os.Stderr, "WARNING: ", log.Ldate|log.Ltime|log.Lshortfile)
ErrorLogger = log.New(os.Stderr, "ERROR: ", log.Ldate|log.Ltime|log.Lshortfile)
}
| 19 |
eks-anywhere-packages | aws | Go | package main
import (
"context"
"encoding/base64"
"encoding/json"
"fmt"
"os"
"path"
"strings"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
"github.com/aws/aws-sdk-go-v2/service/kms/types"
"gopkg.in/yaml.v2"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
sig "github.com/aws/eks-anywhere-packages/pkg/signature"
)
const (
// Excludes .spec.packages[].source.registry .spec.packages[].source.repository
Excludes = "LnNwZWMucGFja2FnZXNbXS5zb3VyY2UucmVnaXN0cnkKLnNwZWMucGFja2FnZXNbXS5zb3VyY2UucmVwb3NpdG9yeQo="
)
var (
FullSignatureAnnotation = path.Join(sig.EksaDomain.Name, sig.SignatureAnnotation)
FullExcludesAnnotation = path.Join(sig.EksaDomain.Name, sig.ExcludesAnnotation)
DefaultExcludesAnnotation = map[string]string{
FullExcludesAnnotation: Excludes,
}
)
var generatedMetadataFields = []string{"creationTimestamp", "generation", "managedFields", "uid", "resourceVersion"}
type BundleGenerateOpt func(config *BundleGenerate)
// NewBundleGenerate is used for generating YAML for generating a new sample CRD file.
func NewBundleGenerate(bundleName string, opts ...BundleGenerateOpt) *api.PackageBundle {
annotations := make(map[string]string)
annotations[FullExcludesAnnotation] = Excludes
return &api.PackageBundle{
TypeMeta: metav1.TypeMeta{
Kind: api.PackageBundleKind,
APIVersion: api.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: bundleName,
Namespace: api.PackageNamespace,
Annotations: DefaultExcludesAnnotation,
},
Spec: api.PackageBundleSpec{
Packages: []api.BundlePackage{
{
Name: "sample-package",
Source: api.BundlePackageSource{
Repository: "sample-Repository",
Versions: []api.SourceVersion{
{
Name: "v0.0",
Digest: "sha256:da25f5fdff88c259bb2ce7c0f1e9edddaf102dc4fb9cf5159ad6b902b5194e66",
},
},
},
},
},
},
}
}
// NewPackageFromInput finds the SHA tags for any images in your BundlePackage
func (c *SDKClients) NewPackageFromInput(project Project) (*api.BundlePackage, error) {
var versionList []api.SourceVersion
var err error
// Check bundle Input registry for ECR Public Registry
if strings.Contains(project.Registry, "public.ecr.aws") {
versionList, err = c.GetShaForPublicInputs(project)
if err != nil {
return nil, err
}
}
// Check bundle Input registry for ECR Private Registry
if strings.Contains(project.Registry, "amazonaws.com") {
versionList, err = c.ecrClient.GetShaForInputs(project)
if err != nil {
return nil, err
}
}
if len(versionList) < 1 {
return nil, fmt.Errorf("unable to find SHA sum for given input tag %v", project.Versions)
}
bundlePkg := &api.BundlePackage{
Name: project.Name,
WorkloadOnly: project.WorkloadOnly,
Source: api.BundlePackageSource{
Repository: project.Repository,
Registry: project.Registry,
Versions: versionList,
},
}
return bundlePkg, nil
}
// AddMetadata adds the corresponding metadata to the crd files.
func AddMetadata(s api.PackageBundleSpec, name string) *api.PackageBundle {
return &api.PackageBundle{
TypeMeta: metav1.TypeMeta{
Kind: api.PackageBundleKind,
APIVersion: api.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
Namespace: api.PackageNamespace,
Annotations: DefaultExcludesAnnotation,
},
Spec: s,
}
}
// IfSignature checks if a signature exsits on a Packagebundle
func IfSignature(bundle *api.PackageBundle) (bool, error) {
annotations := bundle.Annotations
if annotations != nil {
return true, nil
}
return false, nil
}
// CheckSignature checks if current signature is equal to signature to added as an annotation, and skips if they are the same.
func CheckSignature(bundle *api.PackageBundle, signature string) (bool, error) {
if signature == "" || bundle == nil {
return false, fmt.Errorf("either signature or bundle is missing, but are required")
}
annotations := map[string]string{
FullSignatureAnnotation: signature,
}
// If current signature on file isn't at the --signature input return false, otherwsie true
if annotations[FullSignatureAnnotation] != bundle.Annotations[FullSignatureAnnotation] {
return false, fmt.Errorf("A signature already exists on the input file signatue")
}
return true, nil
}
// GetBundleSignature calls KMS and retrieves a signature, then base64 decodes it and returns that back
func GetBundleSignature(ctx context.Context, bundle *api.PackageBundle, key string) (string, error) {
digest, _, err := sig.GetDigest(bundle, sig.EksaDomain)
if err != nil {
return "", err
}
// Creating AWS Clients with profile
ConfigFilePath := "~/.aws/config"
val, ok := os.LookupEnv("AWS_CONFIG_FILE")
if ok {
ConfigFilePath = val
}
BundleLog.Info("Using Config File", "AWS_CONFIG_FILE", ConfigFilePath)
confWithProfile, err := config.LoadDefaultConfig(context.TODO(),
config.WithSharedConfigFiles(
[]string{ConfigFilePath},
),
config.WithRegion("us-west-2"),
config.WithSharedConfigProfile("default"),
)
if err != nil {
fmt.Println("configuration error, " + err.Error())
os.Exit(-1)
}
client := kms.NewFromConfig(confWithProfile)
input := &kms.SignInput{
KeyId: &key,
SigningAlgorithm: types.SigningAlgorithmSpecEcdsaSha256,
MessageType: types.MessageTypeDigest,
Message: digest[:],
}
out, err := client.Sign(context.Background(), input)
if err != nil {
return "", err
}
return base64.StdEncoding.EncodeToString(out.Signature), nil
}
func serializeBundle(bundle *api.PackageBundle) ([]byte, error) {
out, err := json.Marshal(bundle)
if err != nil {
return nil, err
}
raw := make(map[string]interface{})
err = json.Unmarshal(out, &raw)
if err != nil {
return nil, err
}
delete(raw, "status")
meta := raw["metadata"].(map[string]interface{})
for _, f := range generatedMetadataFields {
delete(meta, f)
}
return yaml.Marshal(raw)
}
| 201 |
eks-anywhere-packages | aws | Go | package main
import (
"context"
"reflect"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/ecrpublic"
ecrpublictypes "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types"
"github.com/aws/aws-sdk-go-v2/service/sts"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
)
func TestNewBundleGenerate(t *testing.T) {
tests := []struct {
testname string
bundleName string
wantBundle *api.PackageBundle
}{
{
testname: "TestNewBundleGenerate",
bundleName: "bundlename",
wantBundle: &api.PackageBundle{
TypeMeta: metav1.TypeMeta{
Kind: "PackageBundle",
APIVersion: "packages.eks.amazonaws.com/v1alpha1",
},
ObjectMeta: metav1.ObjectMeta{
Name: "bundlename",
Namespace: "eksa-packages",
Annotations: map[string]string{
"eksa.aws.com/excludes": "LnNwZWMucGFja2FnZXNbXS5zb3VyY2UucmVnaXN0cnkKLnNwZWMucGFja2FnZXNbXS5zb3VyY2UucmVwb3NpdG9yeQo=",
},
},
Spec: api.PackageBundleSpec{
Packages: []api.BundlePackage{
{
Name: "sample-package",
Source: api.BundlePackageSource{
Repository: "sample-Repository",
Versions: []api.SourceVersion{
{
Name: "v0.0",
Digest: "sha256:da25f5fdff88c259bb2ce7c0f1e9edddaf102dc4fb9cf5159ad6b902b5194e66",
},
},
},
},
},
},
},
},
}
for _, tc := range tests {
t.Run(tc.testname, func(tt *testing.T) {
got := NewBundleGenerate(tc.bundleName)
if !reflect.DeepEqual(got, tc.wantBundle) {
tt.Fatalf("GetClusterConfig() = %#v, want %#v", got, tc.wantBundle)
}
})
}
}
var testTagBundle string = "0.1.0_c4e25cb42e9bb88d2b8c2abfbde9f10ade39b214"
var testShaBundle string = "sha256:d5467083c4d175e7e9bba823e95570d28fff86a2fbccb03f5ec3093db6f039be"
var testImageMediaType string = "application/vnd.oci.image.manifest.v1+json"
var testRegistryId string = "public.ecr.aws/eks-anywhere"
var testRepositoryName string = "hello-eks-anywhere"
var testAccountID string = "123456702424"
func TestNewPackageFromInput(t *testing.T) {
client := newMockPublicRegistryClientBundle(nil)
stsclient := newMockSTSReleaseClient(nil)
tests := []struct {
client *mockPublicRegistryClientBundle
testname string
testproject Project
wantErr bool
wantBundle *api.BundlePackage
}{
{
testname: "Test no tags",
testproject: Project{
Name: "hello-eks-anywhere",
Repository: "hello-eks-anywhere",
Registry: "public.ecr.aws/eks-anywhere",
Versions: []Tag{},
},
wantErr: true,
},
{
testname: "Test named tag",
testproject: Project{
Name: "hello-eks-anywhere",
Repository: "hello-eks-anywhere",
Registry: "public.ecr.aws/eks-anywhere",
Versions: []Tag{
{Name: testTagBundle},
},
},
wantErr: false,
wantBundle: &api.BundlePackage{
Name: "hello-eks-anywhere",
Source: api.BundlePackageSource{
Repository: "hello-eks-anywhere",
Registry: "public.ecr.aws/eks-anywhere",
Versions: []api.SourceVersion{
{
Name: testTagBundle,
Digest: testShaBundle,
},
},
},
},
},
{
testname: "Test 'latest' tag",
testproject: Project{
Name: "hello-eks-anywhere",
Repository: "hello-eks-anywhere",
Registry: "public.ecr.aws/eks-anywhere",
Versions: []Tag{
{Name: "latest"},
},
},
wantErr: false,
wantBundle: &api.BundlePackage{
Name: "hello-eks-anywhere",
Source: api.BundlePackageSource{
Repository: "hello-eks-anywhere",
Registry: "public.ecr.aws/eks-anywhere",
Versions: []api.SourceVersion{
{
Name: testTagBundle,
Digest: testShaBundle,
},
},
},
},
},
{
testname: "Test '-latest' in the middle of tag",
testproject: Project{
Name: "hello-eks-anywhere",
Repository: "hello-eks-anywhere",
Registry: "public.ecr.aws/eks-anywhere",
Versions: []Tag{
{Name: "test-latest-helm"},
},
},
wantErr: false,
wantBundle: &api.BundlePackage{
Name: "hello-eks-anywhere",
Source: api.BundlePackageSource{
Repository: "hello-eks-anywhere",
Registry: "public.ecr.aws/eks-anywhere",
Versions: []api.SourceVersion{
{
Name: "test-latest-helm",
Digest: testShaBundle,
},
},
},
},
},
}
for _, tc := range tests {
t.Run(tc.testname, func(tt *testing.T) {
clients := &SDKClients{
ecrPublicClient: &ecrPublicClient{
publicRegistryClient: client,
},
stsClientRelease: &stsClient{
stsClientInterface: stsclient,
},
}
got, err := clients.NewPackageFromInput(tc.testproject)
if (err != nil) != tc.wantErr {
tt.Fatalf("NewPackageFromInput() error = %v, wantErr %v got %v", err, tc.wantErr, got)
}
if !reflect.DeepEqual(got, tc.wantBundle) {
tt.Fatalf("NewPackageFromInput() = %#v\n\n\n, want %#v", got, tc.wantBundle)
}
})
}
}
func TestIfSignature(t *testing.T) {
tests := []struct {
testname string
testbundle *api.PackageBundle
wantBool bool
}{
{
testname: "Test no annotations",
testbundle: &api.PackageBundle{
TypeMeta: metav1.TypeMeta{
Kind: api.PackageBundleKind,
APIVersion: api.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: "1.20",
Namespace: "eksa-packages",
},
},
wantBool: false,
},
{
testname: "Test with annotations",
testbundle: &api.PackageBundle{
TypeMeta: metav1.TypeMeta{
Kind: api.PackageBundleKind,
APIVersion: api.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: "1.20",
Namespace: "eksa-packages",
Annotations: map[string]string{
"eksa.aws.com/signature": "123",
},
},
},
wantBool: true,
},
}
for _, tc := range tests {
t.Run(tc.testname, func(tt *testing.T) {
got, err := IfSignature(tc.testbundle)
if err != nil {
tt.Fatalf("IfSignature() error = %v", err)
}
if got != tc.wantBool {
tt.Fatalf("IfSignature() = %#v\n\n\n, want %#v", got, tc.wantBool)
}
})
}
}
func TestCheckSignature(t *testing.T) {
tests := []struct {
testname string
testbundle *api.PackageBundle
signature string
wantBool bool
wantErr bool
}{
{
testname: "Test empty signature",
testbundle: &api.PackageBundle{
TypeMeta: metav1.TypeMeta{
Kind: api.PackageBundleKind,
APIVersion: api.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: "1.20",
Namespace: "eksa-packages",
},
},
signature: "",
wantErr: true,
},
{
testname: "Test empty Bundle",
testbundle: nil,
signature: "signature-123",
wantErr: true,
},
{
testname: "Test same signature",
testbundle: &api.PackageBundle{
TypeMeta: metav1.TypeMeta{
Kind: api.PackageBundleKind,
APIVersion: api.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: "1.20",
Namespace: "eksa-packages",
Annotations: map[string]string{
"eksa.aws.com/signature": "signature-123",
},
},
},
signature: "signature-123",
wantBool: true,
wantErr: false,
},
{
testname: "Test different signature",
testbundle: &api.PackageBundle{
TypeMeta: metav1.TypeMeta{
Kind: api.PackageBundleKind,
APIVersion: api.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: "1.20",
Namespace: "eksa-packages",
Annotations: map[string]string{
"eksa.aws.com/signature": "signature-456",
},
},
},
signature: "signature-123",
wantBool: false,
wantErr: true,
},
}
for _, tc := range tests {
t.Run(tc.testname, func(tt *testing.T) {
got, err := CheckSignature(tc.testbundle, tc.signature)
if (err != nil) != tc.wantErr {
tt.Fatalf("CheckSignature() error = %v, wantErr %v", err, tc.wantErr)
}
if got != tc.wantBool {
tt.Fatalf("CheckSignature() = %#v\n\n\n, want %#v", got, tc.wantBool)
}
})
}
}
type mockPublicRegistryClientBundle struct {
err error
}
func newMockPublicRegistryClientBundle(err error) *mockPublicRegistryClientBundle {
return &mockPublicRegistryClientBundle{
err: err,
}
}
func (r *mockPublicRegistryClientBundle) DescribeImages(ctx context.Context, params *ecrpublic.DescribeImagesInput, optFns ...func(*ecrpublic.Options)) (*ecrpublic.DescribeImagesOutput, error) {
if r.err != nil {
return nil, r.err
}
testImagePushedAt := time.Now()
return &ecrpublic.DescribeImagesOutput{
ImageDetails: []ecrpublictypes.ImageDetail{
{
ImageDigest: &testShaBundle,
ImageTags: []string{testTagBundle},
ImageManifestMediaType: &testImageMediaType,
ImagePushedAt: &testImagePushedAt,
RegistryId: &testRegistryId,
RepositoryName: &testRepositoryName,
},
},
}, nil
}
func (r *mockPublicRegistryClientBundle) DescribeRegistries(ctx context.Context, params *ecrpublic.DescribeRegistriesInput, optFns ...func(*ecrpublic.Options)) (*ecrpublic.DescribeRegistriesOutput, error) {
panic("not implemented") // TODO: Implement
}
func (r *mockPublicRegistryClientBundle) GetAuthorizationToken(ctx context.Context, params *ecrpublic.GetAuthorizationTokenInput, optFns ...func(*ecrpublic.Options)) (*ecrpublic.GetAuthorizationTokenOutput, error) {
panic("not implemented") // TODO: Implement
}
type mockSTSReleaseClient struct {
err error
}
func newMockSTSReleaseClient(err error) *mockSTSReleaseClient {
return &mockSTSReleaseClient{
err: err,
}
}
func (r *mockSTSReleaseClient) GetCallerIdentity(ctx context.Context, params *sts.GetCallerIdentityInput, optFns ...func(*sts.Options)) (*sts.GetCallerIdentityOutput, error) {
if r.err != nil {
return nil, r.err
}
return &sts.GetCallerIdentityOutput{
Account: &testAccountID,
}, nil
}
| 378 |
eks-anywhere-packages | aws | Go | package main
import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
)
// BundleGenerate same as Bundle except stripped down for generation of yaml file during generate bundleconfig
// +kubebuilder:object:generate=false
type BundleGenerate struct {
// TypeMeta metav1.TypeMeta `json:",inline"`
metav1.TypeMeta `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty"`
Spec api.PackageBundleSpec `json:"spec,omitempty"`
}
// SigningPackageBundle removes fields that shouldn't be included when signing.
type SigningPackageBundle struct {
*api.PackageBundle
// The fields below are to be modified or removed before signing.
// SigningObjectMeta removes fields that shouldn't be included when signing.
*SigningObjectMeta `json:"metadata,omitempty"`
// Status isn't relevant to a digital signature.
Status interface{} `json:"status,omitempty"`
}
// newSigningPackageBundle is api.PackageBundle using SigningObjectMeta instead of metav1.ObjectMeta
func newSigningPackageBundle(bundle *api.PackageBundle) *SigningPackageBundle {
return &SigningPackageBundle{
PackageBundle: bundle,
SigningObjectMeta: newSigningObjectMeta(&bundle.ObjectMeta),
Status: nil,
}
}
// SigningObjectMeta removes fields that shouldn't be included when signing.
type SigningObjectMeta struct {
*metav1.ObjectMeta
// The fields below are to be removed before signing.
// CreationTimestamp isn't relevant to a digital signature.
CreationTimestamp interface{} `json:"creationTimestamp,omitempty"`
}
// newSigningObjectMeta is metav1.ObjectMeta without the CreationTimestamp since it gets added the yaml as null otherwise.
func newSigningObjectMeta(meta *metav1.ObjectMeta) *SigningObjectMeta {
return &SigningObjectMeta{
ObjectMeta: meta,
CreationTimestamp: nil,
}
}
// Input is the schema for the input file
// +kubebuilder:object:root=true
// +kubebuilder:object:generate=false
type Input struct {
Packages []Org `json:"packages,omitempty"`
Name string `json:"name,omitempty"`
KubernetesVersion string `json:"kubernetesVersion,omitempty"`
// +kubebuilder:validation:Optional
// Minimum required packages controller version
MinVersion string `json:"minControllerVersion"`
}
// Org object containing the input file gitHub org and repo locations
type Org struct {
Org string `json:"org,omitempty"`
Projects []Project `json:"projects,omitempty"`
}
// Project is the object containing the project within the gitHub org, and the release tag
type Project struct {
Name string `json:"name,omitempty"`
Registry string `json:"registry,omitempty"`
Repository string `json:"repository,omitempty"`
Versions []Tag `json:"versions,omitempty"`
WorkloadOnly bool `json:"workloadonly,omitempty"`
CopyImages bool `json:"copyimages,omitempty"`
}
// Tag is the release tag
type Tag struct {
Name string `json:"name,omitempty"`
}
type Requires struct {
Kind string `json:"kind,omitempty"`
metav1.ObjectMeta `json:"metadata,omitempty"`
Spec RequiresSpec `json:"spec,omitempty"`
}
type RequiresSpec struct {
Images []Image `json:"images,omitempty"`
Configurations []Configuration `json:"configurations,omitempty"`
Schema string `json:"schema,omitempty"`
Dependencies []string `json:"dependencies,omitempty"`
}
type Configuration struct {
Name string `json:"name,omitempty"`
Required bool `json:"required,omitempty"`
Default string `json:"default,omitempty"`
}
type Image struct {
Repository string `json:"repository,omitempty"`
Tag string `json:"tag,omitempty"`
Digest string `json:"digest,omitempty"`
}
type DockerAuth struct {
Auths map[string]DockerAuthRegistry `json:"auths,omitempty"`
}
type DockerAuthRegistry struct {
Auth string `json:"auth"`
}
type DockerAuthFile struct {
Authfile string `json:"authfile"`
}
// Matches returns a list of inputs which align with ECR tags that exist
func (project Project) Matches(tag string) []string {
var matches []string
for _, version := range project.Versions {
if version.Name == tag {
matches = append(matches, version.Name)
}
}
return matches
}
| 140 |
eks-anywhere-packages | aws | Go | package main
import (
"context"
"encoding/json"
"fmt"
"os"
"regexp"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/ecr"
ecrtypes "github.com/aws/aws-sdk-go-v2/service/ecr/types"
"github.com/pkg/errors"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
)
const (
ecrRegion = "us-west-2"
ecrPublicRegion = "us-east-1"
)
type ecrClient struct {
registryClient
AuthConfig string
}
type registryClient interface {
DescribeImages(ctx context.Context, params *ecr.DescribeImagesInput, optFns ...func(*ecr.Options)) (*ecr.DescribeImagesOutput, error)
GetAuthorizationToken(ctx context.Context, params *ecr.GetAuthorizationTokenInput, optFns ...func(*ecr.Options)) (*ecr.GetAuthorizationTokenOutput, error)
}
type CheckECR interface {
tagExistsInRepository(repository, tag string) (bool, error)
shaExistsInRepository(repository, tag string) (bool, error)
}
// NewECRClient Creates a new ECR Client client
func NewECRClient(client registryClient, needsCreds bool) (*ecrClient, error) {
ecrClient := &ecrClient{
registryClient: client,
}
if needsCreds {
authorizationToken, err := ecrClient.GetAuthToken()
if err != nil {
return nil, err
}
ecrClient.AuthConfig = authorizationToken
return ecrClient, nil
}
return ecrClient, nil
}
// Describe returns a list of ECR describe results, with Pagination from DescribeImages SDK request
func (c *ecrClient) Describe(describeInput *ecr.DescribeImagesInput) ([]ecrtypes.ImageDetail, error) {
var images []ecrtypes.ImageDetail
resp, err := c.DescribeImages(context.TODO(), describeInput)
if err != nil {
return nil, fmt.Errorf("error: Unable to complete DescribeImagesRequest to ECR. %s", err)
}
images = append(images, resp.ImageDetails...)
if resp.NextToken != nil {
next := describeInput
next.NextToken = resp.NextToken
nextdetails, _ := c.Describe(next)
images = append(images, nextdetails...)
}
return images, nil
}
// GetShaForInputs returns a list of an images version/sha for given inputs to lookup
func (c *ecrClient) GetShaForInputs(project Project) ([]api.SourceVersion, error) {
sourceVersion := []api.SourceVersion{}
for _, tag := range project.Versions {
if !strings.HasSuffix(tag.Name, "latest") {
var imagelookup []ecrtypes.ImageIdentifier
imagelookup = append(imagelookup, ecrtypes.ImageIdentifier{ImageTag: &tag.Name})
ImageDetails, err := c.Describe(&ecr.DescribeImagesInput{
RepositoryName: aws.String(project.Repository),
ImageIds: imagelookup,
})
if err != nil {
return nil, fmt.Errorf("error: Unable to complete DescribeImagesRequest to ECR public. %s", err)
}
for _, images := range ImageDetails {
if *images.ImageManifestMediaType != "application/vnd.oci.image.manifest.v1+json" || len(images.ImageTags) == 0 {
continue
}
if len(images.ImageTags) > 0 {
v := &api.SourceVersion{Name: tag.Name, Digest: *images.ImageDigest}
sourceVersion = append(sourceVersion, *v)
continue
}
}
}
//
if tag.Name == "latest" {
ImageDetails, err := c.Describe(&ecr.DescribeImagesInput{
RepositoryName: aws.String(project.Repository),
})
if err != nil {
return nil, fmt.Errorf("error: Unable to complete DescribeImagesRequest to ECR public. %s", err)
}
var images []ImageDetailsBothECR
for _, image := range ImageDetails {
details, _ := createECRImageDetails(ImageDetailsECR{PrivateImageDetails: image})
images = append(images, details)
}
sha, err := getLastestImageSha(images)
if err != nil {
return nil, err
}
sourceVersion = append(sourceVersion, *sha)
continue
}
//
if strings.HasSuffix(tag.Name, "-latest") {
regex := regexp.MustCompile(`-latest`)
splitVersion := regex.Split(tag.Name, -1) //extract out the version without the latest
ImageDetails, err := c.Describe(&ecr.DescribeImagesInput{
RepositoryName: aws.String(project.Repository),
})
if err != nil {
return nil, fmt.Errorf("error: Unable to complete DescribeImagesRequest to ECR public. %s", err)
}
var images []ImageDetailsBothECR
for _, image := range ImageDetails {
details, _ := createECRImageDetails(ImageDetailsECR{PrivateImageDetails: image})
images = append(images, details)
}
filteredImageDetails := ImageTagFilter(images, splitVersion[0])
sha, err := getLastestImageSha(filteredImageDetails)
if err != nil {
return nil, err
}
sourceVersion = append(sourceVersion, *sha)
continue
}
}
sourceVersion = removeDuplicates(sourceVersion)
return sourceVersion, nil
}
// tagFromSha Looks up the Tag of an ECR artifact from a sha
func (c *ecrClient) tagFromSha(repository, sha, substringTag string) (string, error) {
if repository == "" || sha == "" {
return "", fmt.Errorf("Emtpy repository, or sha passed to the function")
}
var imagelookup []ecrtypes.ImageIdentifier
imagelookup = append(imagelookup, ecrtypes.ImageIdentifier{ImageDigest: &sha})
ImageDetails, err := c.Describe(&ecr.DescribeImagesInput{
RepositoryName: aws.String(repository),
ImageIds: imagelookup,
})
if err != nil {
if strings.Contains(err.Error(), "does not exist within the repository") == true {
return "", nil
} else {
return "", fmt.Errorf("looking up image details %v", err)
}
}
for _, detail := range ImageDetails {
// We can return the first tag for an image, if it has multiple tags
if len(detail.ImageTags) > 0 {
detail.ImageTags = removeStringSlice(detail.ImageTags, "latest")
for j, tag := range detail.ImageTags {
if strings.HasSuffix(tag, substringTag) {
return detail.ImageTags[j], nil
}
}
return detail.ImageTags[0], nil
}
}
return "", nil
}
// GetAuthToken gets an authorization token from ECR
func (c *ecrClient) GetAuthToken() (string, error) {
authTokenOutput, err := c.GetAuthorizationToken(context.TODO(), &ecr.GetAuthorizationTokenInput{})
if err != nil {
return "", errors.Cause(err)
}
authToken := *authTokenOutput.AuthorizationData[0].AuthorizationToken
return authToken, nil
}
// NewAuthFile writes a new Docker Authfile from the DockerAuth struct which a user to be used by Skopeo or Helm.
func NewAuthFile(dockerstruct *DockerAuth) (DockerAuthFile, error) {
jsonbytes, err := json.Marshal(*dockerstruct)
auth := DockerAuthFile{}
if err != nil {
return auth, fmt.Errorf("Marshalling docker auth file to json %w", err)
}
f, err := os.CreateTemp("", "dockerAuth")
if err != nil {
return auth, fmt.Errorf("Creating tempfile %w", err)
}
defer f.Close()
fmt.Fprint(f, string(jsonbytes))
auth.Authfile = f.Name()
return auth, nil
}
func (d DockerAuthFile) Remove() error {
if d.Authfile == "" {
return fmt.Errorf("No Authfile in DockerAuthFile given")
}
defer os.Remove(d.Authfile)
return nil
}
// getNameAndVersion looks up the latest pushed helm chart's tag from a given repo name from ECR.
func (c *SDKClients) getNameAndVersion(repoName, tag, accountID string) (string, string, string, error) {
var version string
var sha string
splitname := strings.Split(repoName, ":") // TODO add a regex filter
name := splitname[0]
ecrname := fmt.Sprintf("%s.dkr.ecr.us-west-2.amazonaws.com/%s", accountID, name)
if len(splitname) > 0 {
// If for promotion, we use a named tag instead of latest we do a lookup for that tag.
if !strings.HasSuffix(tag, "latest") {
imageIDs := []ecrtypes.ImageIdentifier{{ImageTag: &tag}}
ImageDetails, err := c.ecrClient.Describe(&ecr.DescribeImagesInput{
RepositoryName: aws.String(repoName),
ImageIds: imageIDs,
})
if err != nil {
return "", "", "", fmt.Errorf("DescribeImagesRequest to public ECR failed: %w", err)
}
if len(ImageDetails) == 1 {
return ecrname, tag, *ImageDetails[0].ImageDigest, nil
}
}
// If tag is -latest we do a timestamp lookup
if tag == "latest" {
ImageDetails, err := c.ecrClient.Describe(&ecr.DescribeImagesInput{
RepositoryName: aws.String(repoName),
})
if err != nil {
return "", "", "", err
}
var images []ImageDetailsBothECR
for _, image := range ImageDetails {
details, err := createECRImageDetails(ImageDetailsECR{PrivateImageDetails: image})
if err != nil {
return "", "", "", err
}
images = append(images, details)
}
version, sha, err = getLastestHelmTagandSha(images)
return ecrname, version, sha, err
}
// If tag contains -latest we do timestamp lookup of any tags matching a regexp of the specified tag.
if strings.Contains(tag, "-latest") {
regex := regexp.MustCompile(`-latest`)
splitVersion := regex.Split(tag, -1) //extract out the version without the latest
ImageDetails, err := c.ecrClient.Describe(&ecr.DescribeImagesInput{
RepositoryName: aws.String(repoName),
})
if err != nil {
return "", "", "", fmt.Errorf("error: Unable to complete DescribeImagesRequest to ECR public. %s", err)
}
var images []ImageDetailsBothECR
for _, image := range ImageDetails {
details, _ := createECRImageDetails(ImageDetailsECR{PrivateImageDetails: image})
images = append(images, details)
}
filteredImageDetails := ImageTagFilter(images, splitVersion[0])
version, sha, err = getLastestHelmTagandSha(filteredImageDetails)
if err != nil {
return "", "", "", err
}
return ecrname, version, sha, err
}
}
return "", "", "", fmt.Errorf("invalid repository: %q", repoName)
}
// shaExistsInRepository checks if a given OCI artifact exists in a destination repo using the sha sum.
func (c *ecrClient) shaExistsInRepository(repository, sha string) (bool, error) {
if repository == "" || sha == "" {
return false, fmt.Errorf("Emtpy repository, or sha passed to the function")
}
var imagelookup []ecrtypes.ImageIdentifier
imagelookup = append(imagelookup, ecrtypes.ImageIdentifier{ImageDigest: &sha})
ImageDetails, err := c.Describe(&ecr.DescribeImagesInput{
RepositoryName: aws.String(repository),
ImageIds: imagelookup,
})
if err != nil {
if strings.Contains(err.Error(), "does not exist within the repository") == true {
return false, nil
}
}
for _, detail := range ImageDetails {
if detail.ImageDigest != nil && *detail.ImageDigest == sha {
return true, nil
}
}
return false, nil
}
// tagExistsInRepository checks if a given OCI artifact exists in a destination repo using the sha sum.
func (c *ecrClient) tagExistsInRepository(repository, tag string) (bool, error) {
if repository == "" || tag == "" {
return false, fmt.Errorf("Emtpy repository, or tag passed to the function")
}
var imagelookup []ecrtypes.ImageIdentifier
imagelookup = append(imagelookup, ecrtypes.ImageIdentifier{ImageTag: &tag})
ImageDetails, err := c.Describe(&ecr.DescribeImagesInput{
RepositoryName: aws.String(repository),
ImageIds: imagelookup,
})
if err != nil {
if strings.Contains(err.Error(), "does not exist within the repository") == true {
return false, nil
}
}
for _, detail := range ImageDetails {
for _, Imagetag := range detail.ImageTags {
if tag == Imagetag {
return true, nil
}
}
}
return false, nil
}
| 329 |
eks-anywhere-packages | aws | Go | package main
import (
"fmt"
"os/exec"
"reflect"
"strings"
"time"
ecrtypes "github.com/aws/aws-sdk-go-v2/service/ecr/types"
ecrpublictypes "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types"
"github.com/go-logr/logr"
"github.com/jinzhu/copier"
"github.com/pkg/errors"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
)
// removeDuplicates removes any duplicates from Version list, useful for scenarios when
// multiple tags for an image are present, this would cause duplicates on the bundle CRD,
// so we remove the first one in this case since they are the same thing.
// EX sha1234 is tagged 1.1 and 1.2 and sha5678 is tagged 1.2 this would result in a double match of 1.2 so we run this.
func removeDuplicates(s []api.SourceVersion) []api.SourceVersion {
k := make(map[string]bool)
l := []api.SourceVersion{}
for _, i := range s {
if _, j := k[i.Name]; !j {
k[i.Name] = true
l = append(l, api.SourceVersion{Name: i.Name, Digest: i.Digest})
}
}
return l
}
// stringInSlice checks to see if a string is in a slice
func stringInSlice(a string, list []string) bool {
for _, b := range list {
if b == a {
return true
}
}
return false
}
// removeStringSlice removes a named string from a slice, without knowing it's index or it being ordered.
func removeStringSlice(l []string, item string) []string {
for i, other := range l {
if other == item {
return append(l[:i], l[i+1:]...)
}
}
return l
}
func deleteEmptyStringSlice(s []string) []string {
var r []string
for _, str := range s {
if str != "" {
r = append(r, str)
}
}
return r
}
func printSlice[v any](s []v) {
if len(s) == 0 {
return
}
fmt.Println(s[0])
printSlice(s[1:])
}
func printMap[k comparable, v any](m map[k]v) {
if len(m) == 0 {
return
}
for k, v := range m {
fmt.Println(k, ":", v)
}
}
// ExecCommand runs a given command, and constructs the log/output.
func ExecCommand(cmd *exec.Cmd) (string, error) {
stdout, err := cmd.Output()
if err != nil {
return string(stdout), errors.Cause(err)
}
return string(stdout), nil
}
// splitECRName is a helper function where some ECR repo's are formatted with "org/repo", and for aws repos it's just "repo"
func splitECRName(s string) (string, string, error) {
chartNameList := strings.Split(s, "/")
// Scenarios for ECR Public which contain and extra "/"
if strings.Contains(chartNameList[0], "public.ecr.aws") {
return strings.Join(chartNameList[2:], "/"), chartNameList[len(chartNameList)-1], nil
}
if len(chartNameList) > 1 {
return strings.Join(chartNameList[1:], "/"), chartNameList[len(chartNameList)-1], nil
}
return "", "", fmt.Errorf("Error: %s", "Failed parsing chartName, check the input URI is a valid ECR URI")
}
// imageTagFilter is used when filtering a list of images for a specific tag or tag substring
func ImageTagFilter(details []ImageDetailsBothECR, version string) []ImageDetailsBothECR {
var filteredDetails []ImageDetailsBothECR
for _, detail := range details {
for _, tag := range detail.ImageTags {
if strings.HasPrefix(tag, version) {
filteredDetails = append(filteredDetails, detail)
}
}
}
return filteredDetails
}
type ImageDetailsECR struct {
PrivateImageDetails ecrtypes.ImageDetail
PublicImageDetails ecrpublictypes.ImageDetail
}
// ImageDetailsBothECR is used so we can share some functions between private and public ECR bundle creation.
type ImageDetailsBothECR struct {
// The sha256 digest of the image manifest.
ImageDigest *string `copier:"ImageDigest"`
// The media type of the image manifest.
ImageManifestMediaType *string `copier:"ImageManifestMediaType"`
// The date and time, expressed in standard JavaScript date format, at which the
// current image was pushed to the repository.
ImagePushedAt *time.Time `copier:"ImagePushedAt"`
// The list of tags associated with this image.
ImageTags []string `copier:"ImageTags"`
// The Amazon Web Services account ID associated with the registry to which this
// image belongs.
RegistryId *string `copier:"RegistryId"`
// The name of the repository to which this image belongs.
RepositoryName *string `copier:"RepositoryName"`
}
func createECRImageDetails(images ImageDetailsECR) (ImageDetailsBothECR, error) {
t := &ImageDetailsBothECR{}
//Check for empty structs, if non empty copy to new common struct for ECR imagedetails.
if reflect.DeepEqual(images.PublicImageDetails, ecrpublictypes.ImageDetail{}) {
if images.PrivateImageDetails.ImageDigest != nil && images.PrivateImageDetails.ImagePushedAt != nil && images.PrivateImageDetails.RegistryId != nil && images.PrivateImageDetails.RepositoryName != nil {
copier.Copy(&t, &images.PrivateImageDetails)
return *t, nil
}
return ImageDetailsBothECR{}, fmt.Errorf("Error marshalling image details from ECR lookup.")
}
if reflect.DeepEqual(images.PrivateImageDetails, ecrtypes.ImageDetail{}) {
if images.PublicImageDetails.ImageDigest != nil && images.PublicImageDetails.ImagePushedAt != nil && images.PublicImageDetails.RegistryId != nil && images.PublicImageDetails.RepositoryName != nil {
copier.Copy(&t, &images.PublicImageDetails)
return *t, nil
}
return ImageDetailsBothECR{}, fmt.Errorf("Error marshalling image details from ECR lookup.")
}
return ImageDetailsBothECR{}, fmt.Errorf("Error no data passed to createImageDetails")
}
// getLastestHelmTagandSha Iterates list of ECR Helm Charts, to find latest pushed image and return tag/sha of the latest pushed image
func getLastestHelmTagandSha(details []ImageDetailsBothECR) (string, string, error) {
var latest ImageDetailsBothECR
latest.ImagePushedAt = &time.Time{}
for _, detail := range details {
if len(details) < 1 || detail.ImagePushedAt == nil || detail.ImageDigest == nil || detail.ImageTags == nil || len(detail.ImageTags) == 0 || *detail.ImageManifestMediaType != "application/vnd.oci.image.manifest.v1+json" {
continue
}
if detail.ImagePushedAt != nil && latest.ImagePushedAt.Before(*detail.ImagePushedAt) {
latest = detail
}
}
// Check if latest is equal to empty struct, and return error if that's the case.
if reflect.DeepEqual(latest, ImageDetailsBothECR{}) {
return "", "", fmt.Errorf("error no images found")
}
return latest.ImageTags[0], *latest.ImageDigest, nil
}
// getLastestImageSha Iterates list of ECR Public Helm Charts, to find latest pushed image and return tag/sha of the latest pushed image
func getLastestImageSha(details []ImageDetailsBothECR) (*api.SourceVersion, error) {
var latest ImageDetailsBothECR
latest.ImagePushedAt = &time.Time{}
for _, detail := range details {
if len(details) < 1 || detail.ImagePushedAt == nil || detail.ImageDigest == nil || detail.ImageTags == nil || len(detail.ImageTags) == 0 || *detail.ImageManifestMediaType != "application/vnd.oci.image.manifest.v1+json" {
continue
}
if detail.ImagePushedAt != nil && latest.ImagePushedAt.Before(*detail.ImagePushedAt) {
latest = detail
}
}
// Check if latest is equal to empty struct, and return error if that's the case.
if reflect.DeepEqual(latest, ecrpublictypes.ImageDetail{}) {
return nil, fmt.Errorf("error no images found")
}
return &api.SourceVersion{Name: latest.ImageTags[0], Digest: *latest.ImageDigest}, nil
}
// copyImage will copy an OCI artifact from one registry to another registry.
func copyImage(log logr.Logger, authFile, source, destination string) error {
log.Info("Running skopeo copy...", source, destination)
cmd := exec.Command("skopeo", "copy", "--authfile", authFile, source, destination, "-f", "oci", "--all")
stdout, err := ExecCommand(cmd)
fmt.Printf("%s\n", stdout)
if err != nil {
return err
}
return nil
}
| 214 |
eks-anywhere-packages | aws | Go | package main
import (
"context"
"fmt"
"regexp"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/ecrpublic"
ecrpublictypes "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types"
"github.com/pkg/errors"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
)
type ecrPublicClient struct {
publicRegistryClient
AuthConfig string
SourceRegistry string
}
type publicRegistryClient interface {
DescribeImages(ctx context.Context, params *ecrpublic.DescribeImagesInput, optFns ...func(*ecrpublic.Options)) (*ecrpublic.DescribeImagesOutput, error)
DescribeRegistries(ctx context.Context, params *ecrpublic.DescribeRegistriesInput, optFns ...func(*ecrpublic.Options)) (*ecrpublic.DescribeRegistriesOutput, error)
GetAuthorizationToken(ctx context.Context, params *ecrpublic.GetAuthorizationTokenInput, optFns ...func(*ecrpublic.Options)) (*ecrpublic.GetAuthorizationTokenOutput, error)
}
// NewECRPublicClient Creates a new ECR Client Public client
func NewECRPublicClient(client publicRegistryClient, needsCreds bool) (*ecrPublicClient, error) {
ecrPublicClient := &ecrPublicClient{
publicRegistryClient: client,
}
if needsCreds {
authorizationToken, err := ecrPublicClient.GetPublicAuthToken()
if err != nil {
return nil, err
}
ecrPublicClient.AuthConfig = authorizationToken
return ecrPublicClient, nil
}
return ecrPublicClient, nil
}
// Describe returns a list of ECR describe results, with Pagination from DescribeImages SDK request
func (c *ecrPublicClient) DescribePublic(describeInput *ecrpublic.DescribeImagesInput) ([]ecrpublictypes.ImageDetail, error) {
var images []ecrpublictypes.ImageDetail
resp, err := c.DescribeImages(context.TODO(), describeInput)
if err != nil {
return nil, fmt.Errorf("error: Unable to complete DescribeImagesRequest to ECR public. %s", err)
}
images = append(images, resp.ImageDetails...)
if resp.NextToken != nil {
next := describeInput
next.NextToken = resp.NextToken
nextdetails, _ := c.DescribePublic(next)
images = append(images, nextdetails...)
}
return images, nil
}
// GetShaForPublicInputs returns a list of an images version/sha for given inputs to lookup
func (c *SDKClients) GetShaForPublicInputs(project Project) ([]api.SourceVersion, error) {
sourceVersion := []api.SourceVersion{}
for _, tag := range project.Versions {
if !strings.HasSuffix(tag.Name, "latest") {
var imagelookup []ecrpublictypes.ImageIdentifier
imagelookup = append(imagelookup, ecrpublictypes.ImageIdentifier{ImageTag: &tag.Name})
ImageDetails, err := c.ecrPublicClient.DescribePublic(&ecrpublic.DescribeImagesInput{
RepositoryName: aws.String(project.Repository),
ImageIds: imagelookup,
RegistryId: &c.stsClientRelease.AccountID,
})
if err != nil {
return nil, fmt.Errorf("error: Unable to complete DescribeImagesRequest to ECR public. %s", err)
}
for _, images := range ImageDetails {
if *images.ImageManifestMediaType != "application/vnd.oci.image.manifest.v1+json" || len(images.ImageTags) == 0 {
continue
}
if len(images.ImageTags) > 0 {
v := &api.SourceVersion{Name: tag.Name, Digest: *images.ImageDigest}
sourceVersion = append(sourceVersion, *v)
continue
}
}
}
//
if tag.Name == "latest" {
ImageDetails, err := c.ecrPublicClient.DescribePublic(&ecrpublic.DescribeImagesInput{
RepositoryName: aws.String(project.Repository),
})
if err != nil {
return nil, fmt.Errorf("error: Unable to complete DescribeImagesRequest to ECR public. %s", err)
}
var images []ImageDetailsBothECR
for _, image := range ImageDetails {
details, _ := createECRImageDetails(ImageDetailsECR{PublicImageDetails: image})
images = append(images, details)
}
sha, err := getLastestImageSha(images)
if err != nil {
return nil, err
}
sourceVersion = append(sourceVersion, *sha)
continue
}
//
if strings.HasSuffix(tag.Name, "-latest") {
regex := regexp.MustCompile(`-latest`)
splitVersion := regex.Split(tag.Name, -1) //extract out the version without the latest
ImageDetails, err := c.ecrPublicClient.DescribePublic(&ecrpublic.DescribeImagesInput{
RepositoryName: aws.String(project.Repository),
})
if err != nil {
return nil, fmt.Errorf("error: Unable to complete DescribeImagesRequest to ECR public. %s", err)
}
var images []ImageDetailsBothECR
for _, image := range ImageDetails {
details, _ := createECRImageDetails(ImageDetailsECR{PublicImageDetails: image})
images = append(images, details)
}
filteredImageDetails := ImageTagFilter(images, splitVersion[0])
sha, err := getLastestImageSha(filteredImageDetails)
if err != nil {
return nil, err
}
sourceVersion = append(sourceVersion, *sha)
continue
}
}
sourceVersion = removeDuplicates(sourceVersion)
return sourceVersion, nil
}
// shaExistsInRepositoryPublic checks if a given OCI artifact exists in a destination repo using the sha sum.
func (c *ecrPublicClient) shaExistsInRepository(repository, sha string) (bool, error) {
if repository == "" || sha == "" {
return false, fmt.Errorf("Emtpy repository, or sha passed to the function")
}
var imagelookup []ecrpublictypes.ImageIdentifier
imagelookup = append(imagelookup, ecrpublictypes.ImageIdentifier{ImageDigest: &sha})
ImageDetails, err := c.DescribePublic(&ecrpublic.DescribeImagesInput{
RepositoryName: aws.String(repository),
ImageIds: imagelookup,
})
if err != nil {
if strings.Contains(err.Error(), "does not exist within the repository") == true {
return false, nil
}
}
for _, detail := range ImageDetails {
if detail.ImageDigest != nil && *detail.ImageDigest == sha {
return true, nil
}
}
return false, nil
}
// tagExistsInRepository checks if a given OCI artifact exists in a destination repo using the sha sum.
func (c *ecrPublicClient) tagExistsInRepository(repository, tag string) (bool, error) {
if repository == "" || tag == "" {
return false, fmt.Errorf("Emtpy repository, or tag passed to the function")
}
var imagelookup []ecrpublictypes.ImageIdentifier
imagelookup = append(imagelookup, ecrpublictypes.ImageIdentifier{ImageTag: &tag})
ImageDetails, err := c.DescribePublic(&ecrpublic.DescribeImagesInput{
RepositoryName: aws.String(repository),
ImageIds: imagelookup,
})
if err != nil {
if strings.Contains(err.Error(), "does not exist within the repository") == true {
return false, nil
}
}
for _, detail := range ImageDetails {
for _, Imagetag := range detail.ImageTags {
if tag == Imagetag {
return true, nil
}
}
}
return false, nil
}
// GetRegistryURI gets the current account's AWS ECR Public registry URI
func (c *ecrPublicClient) GetRegistryURI() (string, error) {
registries, err := c.DescribeRegistries(context.TODO(), (&ecrpublic.DescribeRegistriesInput{}))
if err != nil {
return "", err
}
if len(registries.Registries) > 0 && registries.Registries[0].RegistryUri != nil && *registries.Registries[0].RegistryUri != "" {
return *registries.Registries[0].RegistryUri, nil
}
return "", fmt.Errorf("Emtpy list of registries for the account")
}
// GetPublicAuthToken gets an authorization token from ECR public
func (c *ecrPublicClient) GetPublicAuthToken() (string, error) {
authTokenOutput, err := c.GetAuthorizationToken(context.TODO(), &ecrpublic.GetAuthorizationTokenInput{})
if err != nil {
return "", errors.Cause(err)
}
authToken := *authTokenOutput.AuthorizationData.AuthorizationToken
return authToken, nil
}
// getNameAndVersionPublic looks up the latest pushed helm chart's tag from a given repo name Full name in Public ECR OCI format.
func (c *SDKClients) getNameAndVersionPublic(repoName, tag, registryURI string) (string, string, string, error) {
var version string
var sha string
splitname := strings.Split(repoName, ":") // TODO add a regex filter
name := splitname[0]
ecrname := fmt.Sprintf("%s/%s", c.ecrPublicClient.SourceRegistry, name)
if len(splitname) > 0 {
if !strings.HasSuffix(tag, "latest") {
imageIDs := []ecrpublictypes.ImageIdentifier{{ImageTag: &tag}}
ImageDetails, err := c.ecrPublicClient.DescribePublic(&ecrpublic.DescribeImagesInput{
RepositoryName: aws.String(repoName),
ImageIds: imageIDs,
})
if err != nil {
return "", "", "", fmt.Errorf("DescribeImagesRequest to public ECR failed: %w", err)
}
if len(ImageDetails) == 1 {
return ecrname, tag, *ImageDetails[0].ImageDigest, nil
}
}
ImageDetails, err := c.ecrPublicClient.DescribePublic(&ecrpublic.DescribeImagesInput{
RepositoryName: aws.String(repoName),
})
if err != nil {
return "", "", "", err
}
var images []ImageDetailsBothECR
for _, image := range ImageDetails {
details, err := createECRImageDetails(ImageDetailsECR{PublicImageDetails: image})
if err != nil {
return "", "", "", err
}
images = append(images, details)
}
version, sha, err = getLastestHelmTagandSha(images)
if err != nil {
return "", "", "", err
}
ecrname := fmt.Sprintf("%s/%s", c.ecrPublicClient.SourceRegistry, name)
return ecrname, version, sha, err
}
return "", "", "", fmt.Errorf("invalid repository: %q", repoName)
}
| 254 |
eks-anywhere-packages | aws | Go | package main
import (
"archive/tar"
"compress/gzip"
"context"
"io"
"os"
"testing"
"github.com/aws/aws-sdk-go-v2/service/ecr"
ecrtypes "github.com/aws/aws-sdk-go-v2/service/ecr/types"
"github.com/aws/aws-sdk-go-v2/service/ecrpublic"
ecrpublictypes "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types"
)
func TestSplitECRName(t *testing.T) {
tests := []struct {
testName string
testHelmName string
chartName string
helmName string
wantErr bool
}{
{
testName: "Test empty name",
testHelmName: "",
chartName: "",
helmName: "",
wantErr: true,
},
{
testName: "Test valid name no prefix",
testHelmName: "646717423341.dkr.ecr.us-west-2.amazonaws.com/hello-eks-anywhere",
chartName: "hello-eks-anywhere",
helmName: "hello-eks-anywhere",
wantErr: false,
},
{
testName: "Test valid name w/ 1 prefix",
testHelmName: "646717423341.dkr.ecr.us-west-2.amazonaws.com/hello-eks-anywhere",
chartName: "hello-eks-anywhere",
helmName: "hello-eks-anywhere",
wantErr: false,
},
{
testName: "Test valid name w/ 2 prefixes",
testHelmName: "646717423341.dkr.ecr.us-west-2.amazonaws.com/test/hello-eks-anywhere",
chartName: "test/hello-eks-anywhere",
helmName: "hello-eks-anywhere",
wantErr: false,
},
{
testName: "Test valid name w/ 3 prefixes",
testHelmName: "646717423341.dkr.ecr.us-west-2.amazonaws.com/test/testing/hello-eks-anywhere",
chartName: "test/testing/hello-eks-anywhere",
helmName: "hello-eks-anywhere",
wantErr: false,
},
{
testName: "Test valid name w/ 4 prefixes",
testHelmName: "646717423341.dkr.ecr.us-west-2.amazonaws.com/test/tested/testing/hello-eks-anywhere",
chartName: "test/tested/testing/hello-eks-anywhere",
helmName: "hello-eks-anywhere",
wantErr: false,
},
}
for _, tc := range tests {
t.Run(tc.testName, func(tt *testing.T) {
got, got2, err := splitECRName(tc.testHelmName)
if (err != nil) != tc.wantErr {
tt.Fatalf("splitECRName() error = %v, wantErr %v", err, tc.wantErr)
}
if got != tc.chartName || got2 != tc.helmName {
tt.Fatalf("splitECRName() = %#v\n\n\n, want %#v %#v", got, tc.chartName, tc.helmName)
}
})
}
}
func TestUnTarHelmChart(t *testing.T) {
//Construct a Valid temp Helm Chart and Targz it.
var tarGZ string = "test.tgz"
err := os.Mkdir("hello-eks-anywhere", 0750)
if err != nil {
t.Fatal("Error creating test dir:", err)
}
defer os.RemoveAll("hello-eks-anywhere")
f, err := os.Create("hello-eks-anywhere/Chart.yaml")
content := []byte("apiVersion: v2\nversion: 0.1.0\nappVersion: 0.1.0\nname: hello-eks-anywhere\n")
err = os.WriteFile("hello-eks-anywhere/Chart.yaml", content, 0644)
if err != nil {
t.Fatal("Error creating test files:", err)
}
defer f.Close()
out, err := os.Create(tarGZ)
if err != nil {
t.Fatal("Error creating test .tar:", err)
}
defer out.Close()
files := []string{f.Name()}
err = createArchive(files, out)
if err != nil {
t.Fatal("Error adding files to .tar:", err)
}
defer os.Remove(tarGZ)
tests := []struct {
testName string
testChartPath string
testChartName string
dest string
wantErr bool
}{
{
testName: "Test empty ChartPath",
testChartPath: "",
testChartName: "hello-eks-anywhere",
wantErr: true,
},
{
testName: "Test empty ChartName",
testChartPath: tarGZ,
testChartName: "",
wantErr: true,
},
{
testName: "Test valid values",
testChartPath: tarGZ,
testChartName: "hello-eks-anywhere",
wantErr: false,
},
}
for _, tc := range tests {
tempDir := t.TempDir()
t.Run(tc.testName, func(tt *testing.T) {
err := UnTarHelmChart(tc.testChartPath, tc.testChartName, tempDir)
if (err != nil) != tc.wantErr {
tt.Fatalf("UnTarHelmChart() error = %v, wantErr %v", err, tc.wantErr)
}
})
}
}
func TestShaExistsInRepository(t *testing.T) {
client := newMockPublicRegistryClient(nil)
tests := []struct {
client *mockPublicRegistryClient
testName string
testRepository string
testVersion string
checkPass bool
wantErr bool
}{
{
testName: "Test empty Repository",
testRepository: "",
testVersion: "sha256:0526725a65691944e831add6b247b25a93b8eeb1033dddadeaa089e95b021172",
wantErr: true,
},
{
testName: "Test empty Version",
testRepository: "hello-eks-anywhere",
testVersion: "",
wantErr: true,
},
{
testName: "Test valid Repository and Version",
testRepository: "hello-eks-anywhere",
testVersion: "sha256:0526725a65691944e831add6b247b25a93b8eeb1033dddadeaa089e95b021172",
checkPass: true,
wantErr: false,
},
}
for _, tc := range tests {
t.Run(tc.testName, func(tt *testing.T) {
clients := &SDKClients{
ecrPublicClient: &ecrPublicClient{
publicRegistryClient: client,
},
}
got, err := clients.ecrPublicClient.shaExistsInRepository(tc.testRepository, tc.testVersion)
if (err != nil) != tc.wantErr {
tt.Fatalf("shaExistsInRepositoryPublic() error = %v, wantErr %v", err, tc.wantErr)
}
if got != tc.checkPass {
tt.Fatalf("shaExistsInRepositoryPublic() = %#v\n\n\n, want %#v", got, tc.checkPass)
}
})
}
}
func TestTagFromSha(t *testing.T) {
client := newMockRegistryClient(nil)
tests := []struct {
client *mockRegistryClient
testName string
testRepository string
testDigest string
testSubstringTag string
checkVersion string
wantErr bool
}{
{
testName: "Test empty Repository",
testRepository: "",
testDigest: "sha256:0526725a65691944e831add6b247b25a93b8eeb1033dddadeaa089e95b021172",
testSubstringTag: "",
wantErr: true,
},
{
testName: "Test empty Version",
testRepository: "hello-eks-anywhere",
testDigest: "",
testSubstringTag: "",
wantErr: true,
},
{
testName: "Test valid Repository and Version",
testRepository: "hello-eks-anywhere",
testDigest: "sha256:0526725a65691944e831add6b247b25a93b8eeb1033dddadeaa089e95b021172",
testSubstringTag: "v0.1.1-baa4ef89fe91d65d3501336d95b680f8ae2ea660",
checkVersion: "v0.1.1-baa4ef89fe91d65d3501336d95b680f8ae2ea660",
wantErr: false,
},
{
testName: "Test valid Repository and substring Version",
testRepository: "hello-eks-anywhere",
testDigest: "sha256:0526725a65691944e831add6b247b25a93b8eeb1033dddadeaa089e95b021172",
testSubstringTag: "v0.1.1",
checkVersion: "v0.1.1-baa4ef89fe91d65d3501336d95b680f8ae2ea660",
wantErr: false,
},
}
//images.Digest, err = ecrClient.tagFromSha(images.Repository, images.Digest)
for _, tc := range tests {
t.Run(tc.testName, func(tt *testing.T) {
clients := &SDKClients{
ecrClient: &ecrClient{
registryClient: client,
},
}
got, err := clients.ecrClient.tagFromSha(tc.testRepository, tc.testDigest, tc.checkVersion)
if (err != nil) != tc.wantErr {
tt.Fatalf("tagFromSha() error = %v, wantErr %v", err, tc.wantErr)
}
if got != tc.checkVersion {
tt.Fatalf("tagFromSha() = %#v\n\n\n, want %#v", got, tc.checkVersion)
}
})
}
}
//Helper funcions
// to create the mocks "impl 'r *mockRegistryClient' registryClient"
type mockPublicRegistryClient struct {
err error
}
func newMockPublicRegistryClient(err error) *mockPublicRegistryClient {
return &mockPublicRegistryClient{
err: err,
}
}
var testSha string = "sha256:0526725a65691944e831add6b247b25a93b8eeb1033dddadeaa089e95b021172"
func (r *mockPublicRegistryClient) DescribeImages(ctx context.Context, params *ecrpublic.DescribeImagesInput, optFns ...func(*ecrpublic.Options)) (*ecrpublic.DescribeImagesOutput, error) {
if r.err != nil {
return nil, r.err
}
return &ecrpublic.DescribeImagesOutput{
ImageDetails: []ecrpublictypes.ImageDetail{
{
ImageDigest: &testSha,
},
},
}, nil
}
func (r *mockPublicRegistryClient) DescribeRegistries(ctx context.Context, params *ecrpublic.DescribeRegistriesInput, optFns ...func(*ecrpublic.Options)) (*ecrpublic.DescribeRegistriesOutput, error) {
panic("not implemented") // TODO: Implement
}
func (r *mockPublicRegistryClient) GetAuthorizationToken(ctx context.Context, params *ecrpublic.GetAuthorizationTokenInput, optFns ...func(*ecrpublic.Options)) (*ecrpublic.GetAuthorizationTokenOutput, error) {
panic("not implemented") // TODO: Implement
}
// ECR
type mockRegistryClient struct {
err error
}
func newMockRegistryClient(err error) *mockRegistryClient {
return &mockRegistryClient{
err: err,
}
}
var testTag1 string = "v0.1.1-baa4ef89fe91d65d3501336d95b680f8ae2ea660"
var testTag2 string = "v0.1.1-baa4ef89fe91d65d3501336d95b680f8ae2ea661"
func (r *mockRegistryClient) DescribeImages(ctx context.Context, params *ecr.DescribeImagesInput, optFns ...func(*ecr.Options)) (*ecr.DescribeImagesOutput, error) {
if r.err != nil {
return nil, r.err
}
return &ecr.DescribeImagesOutput{
ImageDetails: []ecrtypes.ImageDetail{
{
ImageTags: []string{testTag1, testTag2},
},
},
}, nil
}
func (r *mockRegistryClient) GetAuthorizationToken(ctx context.Context, params *ecr.GetAuthorizationTokenInput, optFns ...func(*ecr.Options)) (*ecr.GetAuthorizationTokenOutput, error) {
panic("not implemented") // TODO: Implement
}
func createArchive(files []string, buf io.Writer) error {
// Create new Writers for gzip and tar
// These writers are chained. Writing to the tar writer will
// write to the gzip writer which in turn will write to
// the "buf" writer
gw := gzip.NewWriter(buf)
defer gw.Close()
tw := tar.NewWriter(gw)
defer tw.Close()
// Iterate over files and add them to the tar archive
for _, file := range files {
err := addToArchive(tw, file)
if err != nil {
return err
}
}
return nil
}
func addToArchive(tw *tar.Writer, filename string) error {
// Open the file which will be written into the archive
file, err := os.Open(filename)
if err != nil {
return err
}
defer file.Close()
// Get FileInfo about our file providing file size, mode, etc.
info, err := file.Stat()
if err != nil {
return err
}
// Create a tar Header from the FileInfo data
header, err := tar.FileInfoHeader(info, info.Name())
if err != nil {
return err
}
// Use full path as name (FileInfoHeader only takes the basename)
header.Name = filename
// Write file header to the tar archive
err = tw.WriteHeader(header)
if err != nil {
return err
}
// Copy file content to tar archive
_, err = io.Copy(tw, file)
if err != nil {
return err
}
return nil
}
| 379 |
eks-anywhere-packages | aws | Go | package main
import (
"errors"
"fmt"
"io/ioutil"
"os"
"path/filepath"
)
const (
DefaultTmpFolder = "generated"
objectSeparator string = "---\n"
)
func defaultFileOptions() *FileOptions {
return &FileOptions{os.ModePerm}
}
func PersistentFile(op *FileOptions) {
op.Permissions = os.ModePerm
}
type writer struct {
dir string
}
type FileWriter interface {
Write(fileName string, content []byte, f ...FileOptionsFunc) (path string, err error)
WithDir(dir string) (FileWriter, error)
CleanUp()
Dir() string
}
type FileOptions struct {
Permissions os.FileMode
}
type FileOptionsFunc func(op *FileOptions)
func NewWriter(dir string) (FileWriter, error) {
newFolder := filepath.Join(dir, DefaultTmpFolder)
if _, err := os.Stat(newFolder); errors.Is(err, os.ErrNotExist) {
err := os.MkdirAll(newFolder, os.ModePerm)
if err != nil {
return nil, fmt.Errorf("error creating directory [%s]: %v", dir, err)
}
}
return &writer{dir: dir}, nil
}
func (t *writer) Write(fileName string, content []byte, f ...FileOptionsFunc) (string, error) {
op := defaultFileOptions() // Default file options. -->> temporary file with default permissions
for _, optionFunc := range f {
optionFunc(op)
}
currentDir := t.dir
filePath := filepath.Join(currentDir, fileName)
err := ioutil.WriteFile(filePath, content, op.Permissions)
if err != nil {
return "", fmt.Errorf("error writing to file [%s]: %v", filePath, err)
}
return filePath, nil
}
func (w *writer) WithDir(dir string) (FileWriter, error) {
return NewWriter(filepath.Join(w.dir, dir))
}
func (t *writer) Dir() string {
return t.dir
}
func (t *writer) CleanUp() {
_, err := os.Stat(t.dir)
if err == nil {
_ = os.RemoveAll(t.dir)
}
}
func ConcatYamlResources(resources ...[]byte) []byte {
separator := []byte(objectSeparator)
size := 0
for _, resource := range resources {
size += len(resource) + len(separator)
}
b := make([]byte, 0, size)
b = append(b, separator...)
for _, resource := range resources {
b = append(b, resource...)
}
return b
}
| 96 |
eks-anywhere-packages | aws | Go | package main
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strings"
"github.com/go-logr/logr"
"github.com/pkg/errors"
"helm.sh/helm/v3/pkg/action"
"helm.sh/helm/v3/pkg/chartutil"
"helm.sh/helm/v3/pkg/cli"
"helm.sh/helm/v3/pkg/registry"
"sigs.k8s.io/yaml"
)
// helmDriver implements PackageDriver to install packages from Helm charts.
type helmDriver struct {
cfg *action.Configuration
log logr.Logger
settings *cli.EnvSettings
}
func NewHelm(log logr.Logger, authfile string) (*helmDriver, error) {
settings := cli.New()
options := registry.ClientOptCredentialsFile(authfile)
client, err := registry.NewClient(options)
if err != nil {
return nil, fmt.Errorf("creating registry client while initializing helm driver: %w", err)
}
cfg := &action.Configuration{RegistryClient: client}
err = cfg.Init(settings.RESTClientGetter(), settings.Namespace(),
os.Getenv("HELM_DRIVER"), helmLog(log))
if err != nil {
return nil, fmt.Errorf("initializing helm driver: %w", err)
}
return &helmDriver{
cfg: cfg,
log: log,
settings: settings,
}, nil
}
// PullHelmChart will take in a a remote Helm URI and attempt to pull down the chart if it exists.
func (d *helmDriver) PullHelmChart(name, version string) (string, error) {
if name == "" || version == "" {
return "", fmt.Errorf("empty input for PullHelmChart, check flags")
}
install := action.NewInstall(d.cfg)
install.ChartPathOptions.Version = version
if !strings.HasPrefix(name, "oci://") {
name = fmt.Sprintf("oci://%s", name)
}
chartPath, err := install.LocateChart(name, d.settings)
if err != nil || chartPath == "" {
return "", fmt.Errorf("running the Helm LocateChart command, you might need run an AWS ECR Login: %w", err)
}
return chartPath, nil
}
// helmLog wraps logr.Logger to make it compatible with helm's DebugLog.
func helmLog(log logr.Logger) action.DebugLog {
return func(template string, args ...interface{}) {
log.Info(fmt.Sprintf(template, args...))
}
}
// UnTarHelmChart will attempt to move the helm chart out of the helm cache, by untaring it to the pwd and creating the filesystem to unpack it into.
func UnTarHelmChart(chartRef, chartPath, dest string) error {
if chartRef == "" || chartPath == "" || dest == "" {
return fmt.Errorf("Empty input value given for UnTarHelmChart")
}
_, err := os.Stat(dest)
if os.IsNotExist(err) {
if _, err := os.Stat(chartPath); err != nil {
if err := os.MkdirAll(chartPath, 0755); err != nil {
return errors.Wrap(err, "failed to untar (mkdir)")
}
} else {
return errors.Errorf("failed to untar: a file or directory with the name %s already exists", dest)
}
} else {
if err != nil { // Checks directory check errors such as permission issues to read
return errors.Errorf("failed UnTarHelmChart: %s", err)
}
}
// Untar the files, and create the directory structure
return chartutil.ExpandFile(dest, chartRef)
}
// hasRequires checks for the existance of the requires.yaml within the helm directory
func hasRequires(helmdir string) (string, error) {
requires := filepath.Join(helmdir, "requires.yaml")
info, err := os.Stat(requires)
if os.IsNotExist(err) {
return "", err
}
if info.IsDir() {
return "", fmt.Errorf("Found Dir, not requires.yaml file")
}
return requires, nil
}
// validateHelmRequires runs the parse file into struct function, and validations
func validateHelmRequires(fileName string) (*Requires, error) {
helmrequires := &Requires{}
err := parseHelmRequires(fileName, helmrequires)
if err != nil {
return nil, err
}
err = validateHelmRequiresContent(helmrequires)
if err != nil {
return nil, err
}
return helmrequires, err
}
// validateHelmRequiresContent loops over the validation tests
func validateHelmRequiresContent(helmrequires *Requires) error {
for _, v := range helmRequiresValidations {
if err := v(helmrequires); err != nil {
return err
}
}
return nil
}
var helmRequiresValidations = []func(*Requires) error{
validateHelmRequiresName,
}
func validateHelmRequiresName(helmrequires *Requires) error {
err := helmrequires.validateHelmRequiresNotEmpty()
if err != nil {
return err
}
return nil
}
// validateHelmRequiresNotEmpty checks that it has at least one image in the spec
func (helmrequires *Requires) validateHelmRequiresNotEmpty() error {
// Check if Projects are listed
if len(helmrequires.Spec.Images) < 1 {
return fmt.Errorf("Should use non-empty list of images for requires")
}
return nil
}
// parseHelmRequires will attempt to unpack the requires.yaml into the Go struct `Requires`
func parseHelmRequires(fileName string, helmrequires *Requires) error {
content, err := ioutil.ReadFile(fileName)
if err != nil {
return fmt.Errorf("unable to read file due to: %v", err)
}
for _, c := range strings.Split(string(content), YamlSeparator) {
if err = yaml.Unmarshal([]byte(c), helmrequires); err != nil {
return fmt.Errorf("unable to parse %s\nyaml: %s\n %v", fileName, string(c), err)
}
err = yaml.UnmarshalStrict([]byte(c), helmrequires)
if err != nil {
return fmt.Errorf("unable to UnmarshalStrict %s\nyaml: %s\n %v", helmrequires, string(c), err)
}
return nil
}
return fmt.Errorf("cluster spec file %s is invalid or does not contain kind %v", fileName, helmrequires)
}
| 169 |
eks-anywhere-packages | aws | Go | package main
import (
"bytes"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strings"
"sigs.k8s.io/yaml"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
)
const (
YamlSeparator = "\n---\n"
)
func ValidateInputConfig(fileName string) (*Input, error) {
inputconfig := &Input{}
err := ParseInputConfig(fileName, inputconfig)
if err != nil {
return nil, err
}
err = ValidateInputConfigContent(inputconfig)
if err != nil {
return nil, err
}
return inputconfig, err
}
func ValidateInputConfigContent(inputConfig *Input) error {
for _, v := range inputConfigValidations {
if err := v(inputConfig); err != nil {
return err
}
}
return nil
}
var inputConfigValidations = []func(*Input) error{
validateInputConfigName,
}
func validateInputConfigName(inputConfig *Input) error {
err := inputConfig.ValidateInputNotEmpty()
if err != nil {
return err
}
return nil
}
func (inputConfig *Input) ValidateInputNotEmpty() error {
// Check if Projects are listed
if len(inputConfig.Packages) < 1 {
return fmt.Errorf("Should use non-empty list of projects for input")
}
return nil
}
func ValidateBundle(fileName string) (*api.PackageBundle, error) {
bundle, err := ParseBundle(fileName)
if err != nil {
return nil, err
}
err = ValidateBundleContent(bundle)
if err != nil {
return nil, err
}
return bundle, err
}
func ValidateBundleContent(bundle *api.PackageBundle) error {
for _, v := range bundleValidations {
if err := v(bundle); err != nil {
return err
}
}
return nil
}
var bundleValidations = []func(*api.PackageBundle) error{
validateBundleName,
}
func validateBundleName(bundle *api.PackageBundle) error {
err := ValidateBundleNoSignature(bundle)
if err != nil {
return err
}
return nil
}
func ValidateBundleNoSignature(bundle *api.PackageBundle) error {
// Check if Projects are listed
if len(bundle.Spec.Packages) < 1 {
return fmt.Errorf("Should use non-empty list of projects for input")
}
return nil
}
func ParseBundle(filename string) (*api.PackageBundle, error) {
content, err := ioutil.ReadFile(filepath.Clean(filename))
if err != nil {
return nil, fmt.Errorf("reading package bundle file %q: %w", filename, err)
}
for _, doc := range bytes.Split(content, []byte(YamlSeparator)) {
bundle := &api.PackageBundle{}
err = yaml.UnmarshalStrict(doc, bundle)
if err != nil {
return nil, fmt.Errorf("unmarshaling package bundle from %q: %w",
filename, err)
}
return bundle, nil
}
return nil, fmt.Errorf("invalid package bundle file %q", filename)
}
func ParseInputConfig(fileName string, inputConfig *Input) error {
content, err := ioutil.ReadFile(filepath.Clean(fileName))
if err != nil {
return fmt.Errorf("unable to read file due to: %v", err)
}
for _, c := range strings.Split(string(content), YamlSeparator) {
if err = yaml.Unmarshal([]byte(c), inputConfig); err != nil {
return fmt.Errorf("unable to parse %s\nyaml: %s\n %v", fileName, string(c), err)
}
err = yaml.UnmarshalStrict([]byte(c), inputConfig)
if err != nil {
return fmt.Errorf("unable to UnmarshalStrict %s\nyaml: %s\n %v", fileName, string(c), err)
}
return nil
}
return fmt.Errorf("cluster spec file %s is invalid or does not contain kind %v", fileName, inputConfig)
}
func (c *SDKClients) NewBundleFromInput(Input *Input) (api.PackageBundleSpec, string, map[string]bool, error) {
packageBundleSpec := api.PackageBundleSpec{}
if Input.Name == "" || Input.KubernetesVersion == "" {
return packageBundleSpec, "", nil, fmt.Errorf("error: Empty input field from `Name` or `KubernetesVersion`.")
}
var name string
name, ok := os.LookupEnv("CODEBUILD_BUILD_NUMBER")
if !ok {
name = Input.Name
} else {
version := strings.Split(Input.KubernetesVersion, ".")
name = fmt.Sprintf("v1-%s-%s", version[1], name)
}
if Input.MinVersion != "" {
packageBundleSpec.MinVersion = Input.MinVersion
}
copyImages := map[string]bool{}
for _, org := range Input.Packages {
for _, project := range org.Projects {
copyImages[project.Repository] = project.CopyImages
bundlePkg, err := c.NewPackageFromInput(project)
if err != nil {
BundleLog.Error(err, "Unable to complete NewBundleFromInput from ecr lookup failure")
return packageBundleSpec, "", nil, err
}
packageBundleSpec.Packages = append(packageBundleSpec.Packages, *bundlePkg)
}
}
return packageBundleSpec, name, copyImages, nil
}
| 170 |
eks-anywhere-packages | aws | Go | package main
import (
"context"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/cloudwatch"
cloudwatchtypes "github.com/aws/aws-sdk-go-v2/service/cloudwatch/types"
"github.com/aws/aws-sdk-go-v2/service/ecr"
"github.com/aws/aws-sdk-go-v2/service/ecrpublic"
ctrl "sigs.k8s.io/controller-runtime"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
sig "github.com/aws/eks-anywhere-packages/pkg/signature"
)
var BundleLog = ctrl.Log.WithName("BundleGenerator")
func main() {
opts := NewOptions()
opts.SetupLogger()
if opts.generateSample {
outputFilename := filepath.Join(opts.outputFolder, "bundle.yaml")
f, err := os.OpenFile(outputFilename, os.O_WRONLY|os.O_CREATE, 0644)
if err != nil {
BundleLog.Error(err, fmt.Sprintf("opening output file %q", outputFilename))
os.Exit(1)
}
defer f.Close()
err = cmdGenerateSample(f)
if err != nil {
BundleLog.Error(err, "generating sample bundle")
os.Exit(1)
}
fmt.Printf("sample bundle file written to %q\n", outputFilename)
return
}
if opts.promote != "" {
err := cmdPromote(opts)
if err != nil {
BundleLog.Error(err, "promoting curated package")
os.Exit(1)
}
return
}
if opts.regionCheck {
err := cmdRegion(opts)
if err != nil {
BundleLog.Error(err, "checking bundle across region")
os.Exit(1)
}
return
}
err := cmdGenerate(opts)
if err != nil {
BundleLog.Error(err, "generating bundle")
os.Exit(1)
}
}
// cmdGenerateSample writes a sample bundle file to the given output folder.
func cmdGenerateSample(w io.Writer) error {
sample := NewBundleGenerate("generatesample")
_, yml, err := sig.GetDigest(sample, sig.EksaDomain)
if err != nil {
return fmt.Errorf("generating bundle digest: %w", err)
}
_, err = w.Write(yml)
if err != nil {
return fmt.Errorf("writing sample bundle data: %w", err)
}
return nil
}
func cmdPromote(opts *Options) error {
BundleLog.Info("Starting Promote from private ECR to Public ECR....")
promoteCharts := make(map[string][]string)
if opts.tag == "" {
opts.tag = "latest"
}
// If we are promoting an individual chart with the --promote flag like we do for most charts.
if opts.promote != "" {
promoteCharts[opts.promote] = append(promoteCharts[opts.promote], opts.tag)
}
// If we are promoting multiple chart with the --input file flag we override the struct with files inputs from the file.
if opts.inputFile != "" {
packages, err := opts.ValidateInput()
if err != nil {
return err
}
for _, f := range packages {
Inputs, err := ValidateInputConfig(f)
if err != nil {
BundleLog.Error(err, "Unable to validate input file")
os.Exit(1)
}
delete(promoteCharts, opts.promote) // Clear the promote map to pull values only from file
for _, p := range Inputs.Packages {
for _, project := range p.Projects {
promoteCharts[project.Repository] = append(promoteCharts[project.Repository], project.Versions[0].Name)
}
}
}
}
clients, err := GetSDKClients()
if err != nil {
return fmt.Errorf("getting SDK clients: %w", err)
}
clients.ecrPublicClient.SourceRegistry, err = clients.ecrPublicClient.GetRegistryURI()
if err != nil {
return fmt.Errorf("getting registry URI: %w", err)
}
dockerStruct := &DockerAuth{
Auths: map[string]DockerAuthRegistry{
fmt.Sprintf("%s.dkr.ecr.%s.amazonaws.com", clients.stsClient.AccountID, ecrRegion): {clients.ecrClient.AuthConfig},
"public.ecr.aws": {clients.ecrPublicClient.AuthConfig},
},
}
dockerAuth, err := NewAuthFile(dockerStruct)
if err != nil {
return fmt.Errorf("creating auth file: %w", err)
}
if dockerAuth.Authfile == "" {
return fmt.Errorf("no authfile generated")
}
clients.helmDriver, err = NewHelm(BundleLog, dockerAuth.Authfile)
if err != nil {
BundleLog.Error(err, "Unable to create Helm driver")
os.Exit(1)
}
for repoName, versions := range promoteCharts {
for _, version := range versions {
err = clients.PromoteHelmChart(repoName, dockerAuth.Authfile, version, opts.copyImages)
if err != nil {
return fmt.Errorf("promoting Helm chart: %w", err)
}
}
}
err = dockerAuth.Remove()
if err != nil {
return fmt.Errorf("cleaning up docker auth file: %w", err)
}
BundleLog.Info("Promote Finished, exiting gracefully")
return nil
}
func cmdRegion(opts *Options) error {
BundleLog.Info("Starting Region Check Process")
if opts.bundleFile == "" {
BundleLog.Info("Please use the --bundle flag when running region check")
os.Exit(1)
}
Bundle, err := ValidateBundle(opts.bundleFile)
if err != nil {
BundleLog.Error(err, "Unable to validate input file")
os.Exit(1)
}
d := &RepositoryCloudWatch{}
k8sVersionSlice := strings.Split(Bundle.ObjectMeta.Name, "-")
K8sVersion := fmt.Sprintf("%s-%s", k8sVersionSlice[0], k8sVersionSlice[1])
cloudWatchDataStruct := []RepositoryCloudWatch{}
BundleLog.Info("Getting list of images to Region Check")
for _, packages := range Bundle.Spec.Packages {
for _, versions := range packages.Source.Versions {
for _, images := range versions.Images {
d = &RepositoryCloudWatch{
Repository: images.Repository,
Digest: images.Digest,
TotalHits: 0,
K8sVersion: K8sVersion,
}
cloudWatchDataStruct = append(cloudWatchDataStruct, *d)
}
}
}
// Deduplicate the Array of structs for the CRDs packages which contain the same image reference twice.
m := map[RepositoryCloudWatch]struct{}{}
uniquecloudWatchDataStruct := []RepositoryCloudWatch{}
for _, d := range cloudWatchDataStruct {
if _, ok := m[d]; !ok {
uniquecloudWatchDataStruct = append(uniquecloudWatchDataStruct, d)
m[d] = struct{}{}
}
}
// Creating AWS Clients with profile
Profile := "default"
val, ok := os.LookupEnv("AWS_PROFILE")
if ok {
Profile = val
}
BundleLog.Info("Using Env", "AWS_PROFILE", Profile)
BundleLog.Info("Creating SDK connections to Region Check")
clients := &SDKClients{}
conf, err := config.LoadDefaultConfig(context.TODO(),
config.WithRegion(ecrRegion),
config.WithSharedConfigProfile(Profile),
)
if err != nil {
return fmt.Errorf("loading default AWS config: %w", err)
}
cloudwatchC := cloudwatch.NewFromConfig(conf)
clients, err = clients.GetProfileSDKConnection("ecr", Profile, ecrRegion)
if err != nil {
BundleLog.Error(err, "getting SDK connection")
os.Exit(1)
}
clients, err = clients.GetProfileSDKConnection("sts", Profile, ecrRegion)
if err != nil {
BundleLog.Error(err, "getting profile SDK connection")
os.Exit(1)
}
var cloudwatchData []cloudwatchtypes.MetricDatum
var missingList []string
for _, region := range RegionList {
BundleLog.Info("Starting Check for", "Region", region)
clients, err = clients.GetProfileSDKConnection("ecr", Profile, region)
if err != nil {
BundleLog.Error(err, "getting ECR SDK connection")
os.Exit(1)
}
for i, image := range uniquecloudWatchDataStruct {
check, err := clients.ecrClientRelease.shaExistsInRepository(image.Repository, image.Digest)
if err != nil {
BundleLog.Error(err, "finding ECR images")
}
if check {
uniquecloudWatchDataStruct[i].TotalHits++
} else {
missingList = append(missingList, fmt.Sprintf("%s.dkr.ecr.%s.amazonaws.com/%s:%s", clients.stsClientRelease.AccountID, region, image.Repository, image.Digest))
}
}
}
BundleLog.Info("Missing Region List:")
printSlice(missingList)
for i, image := range uniquecloudWatchDataStruct {
percent := (float64(image.TotalHits) / float64(len(RegionList))) * 100
uniquecloudWatchDataStruct[i].Percent = percent
cloudwatchData = FormCloudWatchData(cloudwatchData, image.Repository, uniquecloudWatchDataStruct[i].Percent)
}
err = PushCloudWatchRegionCheckData(cloudwatchC, cloudwatchData, uniquecloudWatchDataStruct[0].K8sVersion)
if err != nil {
BundleLog.Error(err, "pushing cloudwatch data")
os.Exit(1)
}
BundleLog.Info("Finished Region Check!")
return nil
}
func cmdGenerate(opts *Options) error {
// grab local path to caller, and make new caller
pwd, err := os.Getwd()
if err != nil {
BundleLog.Error(err, "Unable to get current working directory")
os.Exit(1)
}
// validate that an input flag is either given, or the system can find yaml files to use.
files, err := opts.ValidateInput()
if err != nil {
return err
}
// Validate Input config, and turn into Input struct
BundleLog.Info("Using input file to create bundle crds.", "Input file", opts.inputFile)
conf, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(ecrPublicRegion))
if err != nil {
BundleLog.Error(err, "loading default AWS config: %w", err)
os.Exit(1)
}
clients := &SDKClients{}
client := ecrpublic.NewFromConfig(conf)
clients.ecrPublicClient, err = NewECRPublicClient(client, true)
if err != nil {
BundleLog.Error(err, "creating public ECR client")
os.Exit(1)
}
conf, err = config.LoadDefaultConfig(context.TODO(), config.WithRegion(ecrRegion))
if err != nil {
BundleLog.Error(err, "loading default AWS config: %w", err)
os.Exit(1)
}
ecrClient := ecr.NewFromConfig(conf)
clients.ecrClient, err = NewECRClient(ecrClient, true)
if err != nil {
BundleLog.Error(err, "creating ECR client")
os.Exit(1)
}
// Creating AWS Clients with profile
Profile := "default"
val, ok := os.LookupEnv("AWS_PROFILE")
if ok {
Profile = val
}
BundleLog.Info("Using Env", "AWS_PROFILE", Profile)
clients, err = clients.GetProfileSDKConnection("sts", Profile, ecrRegion)
if err != nil {
BundleLog.Error(err, "getting profile SDK connection")
os.Exit(1)
}
for _, f := range files {
Inputs, err := ValidateInputConfig(f)
if err != nil {
BundleLog.Error(err, "Unable to validate input file")
os.Exit(1)
}
// Create Authfile for Helm Driver
dockerReleaseStruct := &DockerAuth{
Auths: map[string]DockerAuthRegistry{
fmt.Sprintf("public.ecr.aws/%s", clients.ecrPublicClient.SourceRegistry): {clients.ecrPublicClient.AuthConfig},
},
}
dockerAuth, err := NewAuthFile(dockerReleaseStruct)
if err != nil || dockerAuth.Authfile == "" {
BundleLog.Error(err, "Unable create AuthFile")
os.Exit(1)
}
driver, err := NewHelm(BundleLog, dockerAuth.Authfile)
if err != nil {
BundleLog.Error(err, "Unable to create Helm driver")
os.Exit(1)
}
BundleLog.Info("In Progress: Populating Bundles and looking up Sha256 tags")
addOnBundleSpec, name, copyImages, err := clients.NewBundleFromInput(Inputs)
if err != nil {
BundleLog.Error(err, "Unable to create bundle from input file")
os.Exit(1)
}
// Pull Helm charts for all the populated helm fields of the bundles.
for i, charts := range addOnBundleSpec.Packages {
fullURI := fmt.Sprintf("%s/%s", charts.Source.Registry, charts.Source.Repository)
chartPath, err := driver.PullHelmChart(fullURI, charts.Source.Versions[0].Name)
if err != nil {
BundleLog.Error(err, "Unable to pull Helm Chart")
os.Exit(1)
}
chartName, helmname, err := splitECRName(fullURI)
if err != nil {
BundleLog.Error(err, "Unable to split helm name, invalid format")
os.Exit(1)
}
dest := filepath.Join(pwd, chartName)
err = UnTarHelmChart(chartPath, chartName, dest)
if err != nil {
BundleLog.Error(err, "Unable to untar Helm Chart")
os.Exit(1)
}
// Check for requires.yaml in the unpacked helm chart
helmDest := filepath.Join(pwd, chartName, helmname)
defer os.RemoveAll(helmDest)
f, err := hasRequires(helmDest)
if err != nil {
BundleLog.Error(err, "Helm chart doesn't have requires.yaml inside")
os.Exit(1)
}
// Unpack requires.yaml into a GO struct
helmRequires, err := validateHelmRequires(f)
if err != nil {
BundleLog.Error(err, "Unable to parse requires.yaml file to Go Struct")
os.Exit(1)
}
// Populate Images to bundle spec from Requires.yaml
helmImage := []api.VersionImages{}
for _, image := range helmRequires.Spec.Images {
helmImage = append(helmImage, api.VersionImages{
Repository: image.Repository,
Digest: image.Digest,
})
}
charts.Source.Versions[0].Images = helmImage
// Populate Configurations to bundle spec from Requires.yaml
if len(deleteEmptyStringSlice(helmRequires.Spec.Dependencies)) > 0 {
charts.Source.Versions[0].Dependencies = helmRequires.Spec.Dependencies
}
charts.Source.Versions[0].Schema = helmRequires.Spec.Schema
// Set the registry to empty string since we pull it from the PackageBundleController instead now.
addOnBundleSpec.Packages[i].Source.Registry = ""
}
err = dockerAuth.Remove()
if err != nil {
BundleLog.Error(err, "unable to remove docker auth file")
os.Exit(1)
}
bundle := AddMetadata(addOnBundleSpec, name)
// We will make a compound check for public and private profile after the launch once we want to stop
// push packages to private ECR.
if opts.publicProfile != "" {
BundleLog.Info("Starting release public ECR process....")
clients, err := GetSDKClients()
if err != nil {
BundleLog.Error(err, "getting sdk clients")
os.Exit(1)
}
clients, err = clients.GetProfileSDKConnection("ecrpublic", opts.publicProfile, ecrPublicRegion)
if err != nil {
BundleLog.Error(err, "Unable create SDK Client connections")
os.Exit(1)
}
clients.ecrPublicClient.SourceRegistry, err = clients.ecrPublicClient.GetRegistryURI()
if err != nil {
BundleLog.Error(err, "Unable create find Public ECR URI from calling account")
os.Exit(1)
}
clients.ecrPublicClientRelease.SourceRegistry, err = clients.ecrPublicClientRelease.GetRegistryURI()
if err != nil {
BundleLog.Error(err, "Unable create find Public ECR URI for destination account")
os.Exit(1)
}
dockerReleaseStruct = &DockerAuth{
Auths: map[string]DockerAuthRegistry{
fmt.Sprintf("%s.dkr.ecr.%s.amazonaws.com", clients.stsClient.AccountID, ecrRegion): {
clients.ecrClient.AuthConfig,
},
fmt.Sprintf("public.ecr.aws/%s", clients.ecrPublicClient.SourceRegistry): {
clients.ecrPublicClient.AuthConfig,
},
"public.ecr.aws": {clients.ecrPublicClientRelease.AuthConfig},
},
}
dockerAuth, err = NewAuthFile(dockerReleaseStruct)
if err != nil || dockerAuth.Authfile == "" {
BundleLog.Error(err, "Unable create AuthFile")
os.Exit(1)
}
clients.helmDriver, err = NewHelm(BundleLog, dockerAuth.Authfile)
if err != nil {
BundleLog.Error(err, "Unable to create Helm driver")
os.Exit(1)
}
for _, charts := range addOnBundleSpec.Packages {
for _, versions := range charts.Source.Versions {
err = clients.PromoteHelmChart(charts.Source.Repository, dockerAuth.Authfile, versions.Name, copyImages[charts.Source.Repository])
if err != nil {
BundleLog.Error(err, "promoting helm chart",
"name", charts.Source.Repository)
os.Exit(1)
}
}
}
err = dockerAuth.Remove()
if err != nil {
BundleLog.Error(err, "removing docker auth file")
os.Exit(1)
}
return nil
}
// See above comment about compound check when we want to cutover
// if o.publicProfile != "" && if o.privateProfile != "" {}
if opts.privateProfile != "" {
BundleLog.Info("Starting release to private ECR process....")
clients, err := GetSDKClients()
if err != nil {
BundleLog.Error(err, "getting SDK clients")
os.Exit(1)
}
clients, err = clients.GetProfileSDKConnection("ecr", opts.privateProfile, ecrRegion)
if err != nil {
BundleLog.Error(err, "getting SDK connection")
os.Exit(1)
}
clients, err = clients.GetProfileSDKConnection("sts", opts.privateProfile, ecrRegion)
if err != nil {
BundleLog.Error(err, "getting profile SDK connection")
os.Exit(1)
}
dockerReleaseStruct = &DockerAuth{
Auths: map[string]DockerAuthRegistry{
fmt.Sprintf("%s.dkr.ecr.%s.amazonaws.com", clients.stsClient.AccountID, ecrRegion): {
clients.ecrClient.AuthConfig,
},
fmt.Sprintf("%s.dkr.ecr.%s.amazonaws.com", clients.stsClientRelease.AccountID, ecrRegion): {
clients.ecrClientRelease.AuthConfig,
},
},
}
dockerAuth, err = NewAuthFile(dockerReleaseStruct)
if err != nil {
BundleLog.Error(err, "Unable create AuthFile")
os.Exit(1)
}
clients.helmDriver, err = NewHelm(BundleLog, dockerAuth.Authfile)
if err != nil {
BundleLog.Error(err, "Unable to create Helm driver")
os.Exit(1)
}
for _, charts := range addOnBundleSpec.Packages {
for _, versions := range charts.Source.Versions {
err = clients.PromoteHelmChart(charts.Source.Repository, dockerAuth.Authfile, versions.Name, true)
if err != nil {
BundleLog.Error(err, "promoting helm chart",
"name", charts.Source.Repository)
os.Exit(1)
}
}
}
err = dockerAuth.Remove()
if err != nil {
BundleLog.Error(err, "removing docker auth file")
os.Exit(1)
}
return nil
}
bundle.Annotations[FullExcludesAnnotation] = Excludes
signature, err := GetBundleSignature(context.Background(), bundle, opts.key)
if err != nil {
BundleLog.Error(err, "Unable to sign bundle with kms key")
os.Exit(1)
}
bundle.Annotations[FullSignatureAnnotation] = signature
yml, err := serializeBundle(bundle)
if err != nil {
BundleLog.Error(err, "marshaling bundle YAML: %w", err)
os.Exit(1)
}
BundleLog.Info("In Progress: Writing bundle to output")
outputDir := filepath.Join(pwd, opts.outputFolder)
outputPath, err := NewWriter(outputDir)
if err != nil {
BundleLog.Error(err, "Unable to create new Writer")
os.Exit(1)
}
if _, err := outputPath.Write("bundle.yaml", yml, PersistentFile); err != nil {
BundleLog.Error(err, "Unable to write Bundle to yaml")
os.Exit(1)
}
BundleLog.Info("Finished writing output crd files.", "Output path", fmt.Sprintf("%s%s", opts.outputFolder, "/"))
}
return nil
}
| 571 |
eks-anywhere-packages | aws | Go | package main
import (
"flag"
"fmt"
"os"
"path/filepath"
"strings"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/log/zap"
)
// Options represents the flag for the current plugin
type Options struct {
inputFile string
outputFolder string
generateSample bool
promote string
tag string
copyImages bool
key string
publicProfile string
privateProfile string
bundleFile string
regionCheck bool
}
func (o *Options) SetupLogger() {
opts := zap.Options{}
opts.BindFlags(flag.CommandLine)
ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts)))
}
// Validate validates the receiving options.
func (o *Options) ValidateInput() ([]string, error) {
f := []string{}
if o.inputFile != "" {
f = append(f, o.inputFile)
return f, nil
}
f, err := getYamlFiles()
if err != nil {
BundleLog.Error(err, "Error getting yaml files from stdin")
return nil, err
}
return f, nil
}
func getYamlFiles() ([]string, error) {
f := []string{}
pwd, _ := os.Getwd()
err := filepath.Walk(pwd, func(path string, info os.FileInfo, err error) error {
if err != nil {
fmt.Println(err)
return err
}
endsWith := strings.HasSuffix(path, ".yaml")
if endsWith {
notoutput := strings.Contains(path, "output/")
if !notoutput {
f = append(f, path)
}
}
return nil
})
if err != nil {
fmt.Println(err)
return nil, err
}
return f, err
}
// NewOptions instantiates Options from arguments
func NewOptions() *Options {
o := Options{}
fs := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
fs.BoolVar(&o.generateSample, "generate-sample", false, "Whether you want to generate a sample bundle for yourself")
fs.StringVar(&o.inputFile, "input", "", "The path where the input bundle generation file lives")
fs.StringVar(&o.outputFolder, "output", "output", "The path where to write the output bundle files")
fs.StringVar(&o.promote, "promote", "", "The Helm chart private ECR OCI uri to pull and promote")
fs.StringVar(&o.tag, "tag", "", "The tag of the helm chart used with promote flag")
fs.BoolVar(&o.copyImages, "copy-images", false, "Whether to copy images during a helm promotion, the default is to Not copy.")
fs.StringVar(&o.key, "key", "k", "The key to sign with")
fs.StringVar(&o.publicProfile, "public-profile", "", "The AWS Public Profile to release the prod bundle into")
fs.StringVar(&o.privateProfile, "private-profile", "", "The AWS Private Profile to release all packages into")
fs.StringVar(&o.bundleFile, "bundle", "", "The path where the bundle file lives")
fs.BoolVar(&o.regionCheck, "region-check", false, "Check the passed in bundle resource and if they exist in the supported ECR regions")
err := fs.Parse(os.Args[1:])
if err != nil {
BundleLog.Error(err, "Error parsing input flags")
}
return &o
}
| 95 |
eks-anywhere-packages | aws | Go | package main
import (
"context"
"fmt"
"os"
"path/filepath"
"strings"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/ecr"
"github.com/aws/aws-sdk-go-v2/service/ecrpublic"
"github.com/aws/aws-sdk-go-v2/service/sts"
)
type SDKClients struct {
ecrClient *ecrClient
ecrPublicClient *ecrPublicClient
stsClient *stsClient
ecrClientRelease *ecrClient
ecrPublicClientRelease *ecrPublicClient
stsClientRelease *stsClient
helmDriver *helmDriver
}
// GetSDKClients is used to handle the creation of different SDK clients.
func GetSDKClients() (*SDKClients, error) {
clients := &SDKClients{}
var err error
// ECR Public Connection with us-east-1 region
conf, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(ecrPublicRegion))
if err != nil {
return nil, fmt.Errorf("loading default AWS config: %w", err)
}
client := ecrpublic.NewFromConfig(conf)
clients.ecrPublicClient, err = NewECRPublicClient(client, true)
if err != nil {
return nil, fmt.Errorf("creating default public ECR client: %w", err)
}
// STS Connection with us-west-2 region
conf, err = config.LoadDefaultConfig(context.TODO(), config.WithRegion(ecrRegion))
if err != nil {
return nil, fmt.Errorf("loading default AWS config: %w", err)
}
stsclient := sts.NewFromConfig(conf)
clients.stsClient, err = NewStsClient(stsclient, true)
if err != nil {
return nil, fmt.Errorf("Unable to create SDK connection to STS %s", err)
}
// ECR Private Connection with us-west-2 region
conf, err = config.LoadDefaultConfig(context.TODO(), config.WithRegion(ecrRegion))
if err != nil {
return nil, fmt.Errorf("loading default AWS config: %w", err)
}
ecrClient := ecr.NewFromConfig(conf)
clients.ecrClient, err = NewECRClient(ecrClient, true)
if err != nil {
return nil, fmt.Errorf("Unable to create SDK connection to ECR %s", err)
}
return clients, nil
}
func (c *SDKClients) GetProfileSDKConnection(service, profile, region string) (*SDKClients, error) {
if service == "" || profile == "" {
return nil, fmt.Errorf("empty service, or profile passed to GetProfileSDKConnection")
}
confWithProfile, err := config.LoadDefaultConfig(context.TODO(),
config.WithRegion(region),
config.WithSharedConfigProfile(profile))
if err != nil {
return nil, fmt.Errorf("creating public AWS client config: %w", err)
}
switch service {
case "ecrpublic":
clientWithProfile := ecrpublic.NewFromConfig(confWithProfile)
c.ecrPublicClientRelease, err = NewECRPublicClient(clientWithProfile, true)
if err != nil {
return nil, fmt.Errorf("Unable to create SDK connection to ECR Public using another profile %s", err)
}
return c, nil
case "ecr":
clientWithProfile := ecr.NewFromConfig(confWithProfile)
c.ecrClientRelease, err = NewECRClient(clientWithProfile, true)
if err != nil {
return nil, fmt.Errorf("Unable to create SDK connection to ECR using another profile %s", err)
}
return c, nil
case "sts":
clientWithProfile := sts.NewFromConfig(confWithProfile)
c.stsClientRelease, err = NewStsClient(clientWithProfile, true)
if err != nil {
return nil, fmt.Errorf("Unable to create SDK connection to STS using another profile %s", err)
}
return c, nil
}
return nil, fmt.Errorf("gave service not supported by GetProfileSDKConnection(), consider adding it to the switch case")
}
// PromoteHelmChart will take a given repository, and authFile and handle helm and image promotion for the mentioned chart.
func (c *SDKClients) PromoteHelmChart(repository, authFile, tag string, copyImages bool) error {
var name, version, sha string
pwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("Error getting pwd %s", err)
}
// If we are not moving artifacts to the Private ECR Packages artifact account, get information from public ECR instead.
// The first scenario runs for flags --private-profile and --promote.
// The 2nd scenario runs for flags and --public-profile.
if c.ecrClientRelease != nil || c.ecrClient != nil {
name, version, sha, err = c.getNameAndVersion(repository, tag, c.stsClient.AccountID)
if err != nil {
return fmt.Errorf("Error getting name and version from helmchart %s", err)
}
}
if c.ecrPublicClientRelease != nil {
name, version, sha, err = c.getNameAndVersionPublic(repository, tag, c.stsClient.AccountID)
if err != nil {
return fmt.Errorf("Error getting name and version from helmchart %s", err)
}
}
// Pull the Helm chart to Helm Cache
BundleLog.Info("Found Helm Chart to read requires.yaml for image information", "Chart", fmt.Sprintf("%s:%s", name, version))
semVer := strings.Replace(version, "_", "+", 1) // TODO use the Semvar library instead of this hack.
chartPath, err := c.helmDriver.PullHelmChart(name, semVer)
if err != nil {
return fmt.Errorf("Error pulling helmchart %s", err)
}
// Get the correct Repo Name from the flag based on ECR repo name formatting
// since we prepend the github org on some repo's, and not on others.
chartName, helmname, err := splitECRName(name)
if err != nil {
return fmt.Errorf("Failed splitECRName %s", err)
}
// Untar the helm .tgz to pwd and name the folder to the helm chart Name
dest := filepath.Join(pwd, chartName)
err = UnTarHelmChart(chartPath, chartName, dest)
if err != nil {
return fmt.Errorf("failed pulling helm release %s", err)
}
// Check for requires.yaml in the unpacked helm chart
helmDest := filepath.Join(pwd, chartName, helmname)
defer os.RemoveAll(helmDest)
f, err := hasRequires(helmDest)
if err != nil {
return fmt.Errorf("Helm chart doesn't have requires.yaml inside %s", err)
}
// Unpack requires.yaml into a GO struct
helmRequiresImages, err := validateHelmRequires(f)
if err != nil {
return fmt.Errorf("Unable to parse requires.yaml file to Go Struct %s", err)
}
// Create a 2nd struct since the the helm chart is going to Public ECR while the images are going to Private ECR.
helmRequires := &Requires{
Spec: RequiresSpec{
Images: []Image{
{
Repository: chartName,
Tag: version,
Digest: sha,
},
},
},
}
// Loop through each image, and the helm chart itself and check for existance in ECR Public, skip if we find the SHA already exists in destination.
// If we don't find the SHA in public, we lookup the tag from Private Dev account, and move to Private Artifact account.
// This runs for flags
// --private-profile
// --promote --copy-images
var destination string
if copyImages {
accountID := c.activeAccountID()
for _, images := range helmRequiresImages.Spec.Images {
checkSha, checkTag, err := c.CheckDestinationECR(images, images.Tag)
// This is going to run a copy if only 1 check passes because there are scenarios where the correct SHA exists, but the tag is not in sync.
// Copy with the correct image SHA, but a new tag will just write a new tag to ECR so it's safe to run.
if checkSha && checkTag {
BundleLog.Info("Digest, and Tag already exists in destination location......skipping", "Destination:", fmt.Sprintf("docker://%s.dkr.ecr.us-west-2.amazonaws.com/%s:%s @ %s", accountID, images.Repository, images.Tag, images.Digest))
continue
} else {
BundleLog.Info("Image Digest, and Tag dont exist in destination location...... copy to", "Location", fmt.Sprintf("%s/%s sha:%s", images.Repository, images.Tag, images.Digest))
// We have cases with tag mismatch where the SHA is accurate, but the tag in the destination repo is not synced, this will sync it.
if images.Tag == "" {
images.Tag, err = c.ecrClient.tagFromSha(images.Repository, images.Digest, tag)
}
if err != nil {
BundleLog.Error(err, "Unable to find Tag from Digest")
}
BundleLog.Info("Moving container images to ECR")
source := fmt.Sprintf("docker://%s.dkr.ecr.us-west-2.amazonaws.com/%s:%s", accountID, images.Repository, images.Tag)
if c.ecrClientRelease != nil {
destination = fmt.Sprintf("docker://%s.dkr.ecr.us-west-2.amazonaws.com/%s:%s", c.stsClientRelease.AccountID, images.Repository, images.Tag)
} else if c.ecrPublicClientRelease != nil {
destination = fmt.Sprintf("docker://%s/%s:%s", c.ecrPublicClientRelease.SourceRegistry, images.Repository, images.Tag)
} else {
destination = fmt.Sprintf("docker://%s/%s:%s", c.ecrPublicClient.SourceRegistry, images.Repository, images.Tag)
}
err := copyImage(BundleLog, authFile, source, destination)
if err != nil {
return fmt.Errorf("Unable to copy image from source to destination repo %s", err)
}
continue
}
}
}
// If we have the profile for the artifact account present, we skip moving helm charts since they go to the public ECR only.
// This will move the Helm chart from Private ECR to Public ECR if it doesn't exist. This goes to either dev or prod depending on the flags passed in.
// This runs for flags --public-profile and --promote.
if c.ecrClientRelease == nil {
for _, images := range helmRequires.Spec.Images {
//Check if the Helm chart is going to Prod, or dev account.
destinationRegistry := c.ecrPublicClient.SourceRegistry
if c.ecrPublicClientRelease != nil {
destinationRegistry = c.ecrPublicClientRelease.SourceRegistry
}
checkSha, checkTag, err := c.CheckDestinationECR(images, images.Tag)
if checkSha && checkTag {
BundleLog.Info("Digest, and Tag already exists in destination location......skipping", "Destination:", fmt.Sprintf("docker://%s/%s:%s @ %s", destinationRegistry, images.Repository, images.Tag, images.Digest))
continue
} else {
if c.ecrPublicClientRelease == nil {
source := fmt.Sprintf("docker://%s.dkr.ecr.us-west-2.amazonaws.com/%s:%s", c.stsClient.AccountID, images.Repository, images.Tag)
destination := fmt.Sprintf("docker://%s/%s:%s", destinationRegistry, images.Repository, images.Tag)
BundleLog.Info("Copying Helm Digest, and Tag to destination location......", "Location", fmt.Sprintf("%s/%s:%s %s", c.ecrPublicClient.SourceRegistry, images.Repository, images.Tag, images.Digest))
err = copyImage(BundleLog, authFile, source, destination)
if err != nil {
return fmt.Errorf("Unable to copy image from source to destination repo %s", err)
}
} else {
source := fmt.Sprintf("docker://%s/%s:%s", c.ecrPublicClient.SourceRegistry, images.Repository, images.Tag)
destination := fmt.Sprintf("docker://%s/%s:%s", destinationRegistry, images.Repository, images.Tag)
BundleLog.Info("Copying Helm Digest, and Tag to destination location......", "Location", fmt.Sprintf("%s/%s:%s %s", c.ecrPublicClient.SourceRegistry, images.Repository, images.Tag, images.Digest))
err = copyImage(BundleLog, authFile, source, destination)
if err != nil {
return fmt.Errorf("Unable to copy image from source to destination repo %s", err)
}
}
}
}
}
return nil
}
func (c *SDKClients) CheckDestinationECR(images Image, version string) (bool, bool, error) {
var checkSha, checkTag bool
var err error
var check CheckECR
// Change the source destination check depending on release to dev or prod.
destination := c.ecrPublicClient
if c.ecrPublicClientRelease != nil {
destination = c.ecrPublicClientRelease
}
// We either check in private ECR or public ECR depending on what's passed in.
if c.stsClientRelease != nil {
check = c.ecrClientRelease
} else {
check = destination
}
checkSha, err = check.shaExistsInRepository(images.Repository, images.Digest)
if err != nil {
return false, false, err
}
checkTag, err = check.tagExistsInRepository(images.Repository, version)
if err != nil {
return false, false, err
}
return checkSha, checkTag, nil
}
func (c *SDKClients) activeAccountID() string {
if c.stsClientRelease != nil && c.stsClient != nil {
return c.stsClient.AccountID
}
if c.stsClientRelease != nil {
return c.stsClientRelease.AccountID
}
if c.stsClient != nil {
return c.stsClient.AccountID
}
return ""
}
| 289 |
eks-anywhere-packages | aws | Go | package main
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/cloudwatch"
cloudwatchtypes "github.com/aws/aws-sdk-go-v2/service/cloudwatch/types"
)
var RegionList = []string{
"us-east-2",
"us-east-1",
"us-west-1",
"us-west-2",
"ap-northeast-3",
"ap-northeast-2",
"ap-southeast-1",
"ap-southeast-2",
"ap-northeast-1",
"ca-central-1",
"eu-central-1",
"eu-west-1",
"eu-west-2",
"eu-west-3",
"eu-north-1",
"sa-east-1",
}
type RepositoryCloudWatch struct {
Repository string `json:"repository,omitempty"`
Digest string `json:"digest,omitempty"`
Region string `json:"region,omitempty"`
TotalHits int `json:"totalhits,omitempty"`
Percent float64 `json:"percent,omitempty"`
K8sVersion string `json:"k8sversion,omitempty"`
}
func FormCloudWatchData(metricData []cloudwatchtypes.MetricDatum, name string, value float64) []cloudwatchtypes.MetricDatum {
regionName := "region-availibity"
d := []cloudwatchtypes.Dimension{
{
Name: ®ionName,
Value: &name,
},
}
metricDataPoint := &cloudwatchtypes.MetricDatum{
Dimensions: d,
MetricName: &name,
Value: &value,
}
metricData = append(metricData, *metricDataPoint)
return metricData
}
func PushCloudWatchRegionCheckData(c *cloudwatch.Client, data []cloudwatchtypes.MetricDatum, k8s_version string) error {
Input := &cloudwatch.PutMetricDataInput{
MetricData: data,
Namespace: &k8s_version,
}
err := pushMetricData(c, *Input)
if err != nil {
return err
}
return nil
}
func pushMetricData(c *cloudwatch.Client, input cloudwatch.PutMetricDataInput) error {
_, err := c.PutMetricData(context.TODO(), &input)
if err != nil {
return fmt.Errorf("sending cloudwatch PutMetricData(): %w", err)
}
return nil
}
| 75 |
eks-anywhere-packages | aws | Go | package main
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/sts"
)
type stsClient struct {
stsClientInterface
AccountID string
}
type stsClientInterface interface {
GetCallerIdentity(ctx context.Context, params *sts.GetCallerIdentityInput, optFns ...func(*sts.Options)) (*sts.GetCallerIdentityOutput, error)
}
func NewStsClient(client stsClientInterface, account bool) (*stsClient, error) {
stsClient := &stsClient{stsClientInterface: client}
if account {
stslookup, err := stsClient.GetCallerIdentity(context.TODO(), &sts.GetCallerIdentityInput{})
if err != nil {
return nil, err
}
if *stslookup.Account != "" {
stsClient.AccountID = *stslookup.Account
return stsClient, nil
}
return nil, fmt.Errorf("Empty Account ID from stslookup call")
}
return stsClient, nil
}
| 34 |
eks-anywhere-packages | aws | Go | package artifacts
import "context"
//go:generate mockgen -source puller.go -destination=mocks/puller.go -package=mocks Client
// Puller is an interface to abstract interaction with OCI registries or other
// storage services.
type Puller interface {
// Pull the artifact at the given reference.
Pull(ctx context.Context, ref string, clusterName string) ([]byte, error)
}
| 13 |
eks-anywhere-packages | aws | Go | package artifacts
import (
"context"
"github.com/go-logr/logr"
"oras.land/oras-go/v2/registry/remote"
"github.com/aws/eks-anywhere-packages/pkg/registry"
)
// RegistryPuller handles pulling OCI artifacts from an OCI registry
type RegistryPuller struct {
log logr.Logger
}
var _ Puller = (*RegistryPuller)(nil)
// NewRegistryPuller creates and initializes a RegistryPuller.
func NewRegistryPuller(logger logr.Logger) *RegistryPuller {
return &RegistryPuller{
log: logger,
}
}
func (p *RegistryPuller) Pull(ctx context.Context, ref string, clusterName string) ([]byte, error) {
art, err := registry.ParseArtifactFromURI(ref)
if err != nil {
return nil, err
}
certificates, err := registry.GetClusterCertificate(clusterName)
if err != nil {
p.log.Info("problem getting certificate file", "error", err.Error())
}
var store *registry.DockerCredentialStore
configFile, err := registry.CredentialsConfigLoad()
if err != nil {
p.log.Info("problem getting credential file", "error", err.Error())
} else {
store = registry.NewDockerCredentialStore(configFile)
}
sc := registry.NewStorageContext(art.Registry, store, certificates, false)
remoteRegistry, err := remote.NewRegistry(art.Registry)
if err != nil {
return nil, err
}
client := registry.NewOCIRegistry(sc, remoteRegistry)
return registry.PullBytes(ctx, client, *art)
}
| 54 |
eks-anywhere-packages | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: puller.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
gomock "github.com/golang/mock/gomock"
)
// MockPuller is a mock of Puller interface.
type MockPuller struct {
ctrl *gomock.Controller
recorder *MockPullerMockRecorder
}
// MockPullerMockRecorder is the mock recorder for MockPuller.
type MockPullerMockRecorder struct {
mock *MockPuller
}
// NewMockPuller creates a new mock instance.
func NewMockPuller(ctrl *gomock.Controller) *MockPuller {
mock := &MockPuller{ctrl: ctrl}
mock.recorder = &MockPullerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPuller) EXPECT() *MockPullerMockRecorder {
return m.recorder
}
// Pull mocks base method.
func (m *MockPuller) Pull(ctx context.Context, ref, clusterName string) ([]byte, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Pull", ctx, ref, clusterName)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Pull indicates an expected call of Pull.
func (mr *MockPullerMockRecorder) Pull(ctx, ref, clusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pull", reflect.TypeOf((*MockPuller)(nil).Pull), ctx, ref, clusterName)
}
| 51 |
eks-anywhere-packages | aws | Go | package authenticator
import "context"
// DockerAuth Structure for the authentication file
type DockerAuth struct {
Auths map[string]DockerAuthRegistry `json:"auths,omitempty"`
}
type DockerAuthRegistry struct {
Auth string `json:"auth"`
}
//go:generate mockgen -source authenticator.go -destination=mocks/authenticator.go -package=mocks Authenticator
// Authenticator is an interface for creating an authentication file with credentials to private registries
//
// Currently this is used with the Helm Driver which takes credentials in this way
// For this first implementation, kubernetes secrets will be used to pass in a token
type Authenticator interface {
// Initialize Points Authenticator to target cluster
Initialize(clusterName string) error
// AuthFilename Gets Authentication File Path for OCI Registry
AuthFilename() string
// AddToConfigMap Adds Namespace to config map
AddToConfigMap(ctx context.Context, name string, namespace string) error
// DelFromConfigMap Removes Namespace from config map
DelFromConfigMap(ctx context.Context, name string, namespace string) error
// GetSecretValues Retrieves ImagePullSecrets data to pass to helm chart
GetSecretValues(ctx context.Context, namespace string) (map[string]interface{}, error)
// AddSecretToAllNamespace Add Secrets to all namespaces
AddSecretToAllNamespace(ctx context.Context) error
}
| 39 |
eks-anywhere-packages | aws | Go | package authenticator
import (
"context"
"os"
"strconv"
"time"
batchv1 "k8s.io/api/batch/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
"github.com/aws/eks-anywhere-packages/pkg/csset"
)
const (
ConfigMapName = "ns-secret-map"
ecrTokenName = "ecr-token"
cronJobName = "cron-ecr-renew"
jobExecName = "eksa-auth-refresher-"
mirrorCredName = "registry-mirror-cred"
)
type ecrSecret struct {
clientset kubernetes.Interface
targetCluster string
}
var _ Authenticator = (*ecrSecret)(nil)
func NewECRSecret(config *rest.Config) (*ecrSecret, error) {
clientset, err := kubernetes.NewForConfig(config)
if err != nil {
return nil, err
}
return &ecrSecret{
clientset: clientset,
targetCluster: api.PackageNamespace,
}, nil
}
func (s *ecrSecret) AuthFilename() string {
// Check if Helm registry config is set
helmconfig := os.Getenv("HELM_REGISTRY_CONFIG")
if helmconfig != "" {
// Use HELM_REGISTRY_CONFIG
return helmconfig
}
return ""
}
func (s *ecrSecret) Initialize(clusterName string) error {
s.targetCluster = api.PackageNamespace + "-" + clusterName
return nil
}
func (s *ecrSecret) AddToConfigMap(ctx context.Context, name string, namespace string) error {
cm, err := s.clientset.CoreV1().ConfigMaps(s.targetCluster).
Get(ctx, ConfigMapName, metav1.GetOptions{})
if err != nil {
return err
}
css := csset.NewCSSet(cm.Data[namespace])
css.Add(name)
cm.Data[namespace] = css.String()
_, err = s.clientset.CoreV1().ConfigMaps(s.targetCluster).
Update(ctx, cm, metav1.UpdateOptions{})
if err != nil {
return err
}
return nil
}
func (s *ecrSecret) AddSecretToAllNamespace(ctx context.Context) error {
cronjob, err := s.clientset.BatchV1().CronJobs(api.PackageNamespace).Get(ctx, cronJobName, metav1.GetOptions{})
if err != nil {
return err
}
if *cronjob.Spec.Suspend {
return nil
}
jobSpec := &batchv1.Job{
ObjectMeta: metav1.ObjectMeta{
Name: jobExecName + strconv.FormatInt(time.Now().UTC().UnixMilli(), 10),
Namespace: api.PackageNamespace,
Labels: map[string]string{"createdBy": "controller"},
},
Spec: cronjob.Spec.JobTemplate.Spec,
}
jobs := s.clientset.BatchV1().Jobs(api.PackageNamespace)
_, err = jobs.Create(ctx, jobSpec, metav1.CreateOptions{})
if err != nil {
return err
}
err = s.cleanupPrevRuns(ctx)
return err
}
func (s *ecrSecret) DelFromConfigMap(ctx context.Context, name string, namespace string) error {
cm, err := s.clientset.CoreV1().ConfigMaps(s.targetCluster).
Get(ctx, ConfigMapName, metav1.GetOptions{})
if err != nil {
return err
}
css := csset.NewCSSet(cm.Data[namespace])
css.Del(name)
cm.Data[namespace] = css.String()
if cm.Data[namespace] == "" {
delete(cm.Data, namespace)
}
_, err = s.clientset.CoreV1().ConfigMaps(s.targetCluster).
Update(ctx, cm, metav1.UpdateOptions{})
if err != nil {
return err
}
return nil
}
func (s *ecrSecret) GetSecretValues(ctx context.Context, namespace string) (map[string]interface{}, error) {
values := make(map[string]interface{})
var imagePullSecret [2]map[string]string
imagePullSecret[0] = make(map[string]string)
imagePullSecret[0]["name"] = ecrTokenName
imagePullSecret[1] = make(map[string]string)
imagePullSecret[1]["name"] = mirrorCredName
values["imagePullSecrets"] = imagePullSecret
return values, nil
}
func (s *ecrSecret) cleanupPrevRuns(ctx context.Context) error {
labelSelector := metav1.LabelSelector{MatchLabels: map[string]string{"createdBy": "controller"}}
deletePropagation := metav1.DeletePropagationBackground
jobs, err := s.clientset.BatchV1().Jobs(api.PackageNamespace).
List(ctx, metav1.ListOptions{LabelSelector: labels.Set(labelSelector.MatchLabels).String()})
if err != nil {
return err
}
for _, job := range jobs.Items {
if job.Status.Succeeded == 1 {
err := s.clientset.BatchV1().Jobs(api.PackageNamespace).
Delete(ctx, job.Name,
metav1.DeleteOptions{PropagationPolicy: &deletePropagation})
if err != nil {
return err
}
}
}
return nil
}
| 167 |
eks-anywhere-packages | aws | Go | package authenticator
import (
"context"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
batchv1 "k8s.io/api/batch/v1"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/kubernetes/fake"
"k8s.io/client-go/rest"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
)
func TestAuthFilename(t *testing.T) {
fakeConfig := rest.Config{}
t.Run("golden path for set HELM_REGISTRY_CONFIG", func(t *testing.T) {
testfile := "/test.txt"
t.Setenv("HELM_REGISTRY_CONFIG", testfile)
ecrAuth, err := NewECRSecret(&fakeConfig)
require.NoError(t, err)
val := ecrAuth.AuthFilename()
assert.Equal(t, val, testfile)
})
t.Run("golden path for no config or secrets", func(t *testing.T) {
t.Setenv("HELM_REGISTRY_CONFIG", "")
ecrAuth, _ := NewECRSecret(&fakeConfig)
val := ecrAuth.AuthFilename()
assert.Equal(t, val, "")
})
}
func TestAddToConfigMap(t *testing.T) {
ctx := context.TODO()
name := "test-name"
namespace := "eksa-packages"
cmdata := make(map[string]string)
clusterName := "w-test"
targetClusterNamespace := api.PackageNamespace + "-" + clusterName
t.Run("golden path for adding new namespace", func(t *testing.T) {
cmdata["otherns"] = "a"
mockClientset := fake.NewSimpleClientset(&v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: ConfigMapName,
Namespace: targetClusterNamespace,
},
Data: cmdata,
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.Initialize(clusterName)
require.NoError(t, err)
err = ecrAuth.AddToConfigMap(ctx, name, namespace)
require.NoError(t, err)
updatedCM, err := mockClientset.CoreV1().ConfigMaps(targetClusterNamespace).
Get(ctx, ConfigMapName, metav1.GetOptions{})
if assert.NoError(t, err) {
assert.Equal(t, name, updatedCM.Data[namespace])
assert.Equal(t, "a", updatedCM.Data["otherns"])
}
})
t.Run("golden path for adding one namespace", func(t *testing.T) {
cmdata[namespace] = "a"
mockClientset := fake.NewSimpleClientset(&v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: ConfigMapName,
Namespace: targetClusterNamespace,
},
Data: cmdata,
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.Initialize(clusterName)
require.NoError(t, err)
err = ecrAuth.AddToConfigMap(ctx, name, namespace)
require.NoError(t, err)
updatedCM, err := mockClientset.CoreV1().ConfigMaps(targetClusterNamespace).
Get(ctx, ConfigMapName, metav1.GetOptions{})
if assert.NoError(t, err) {
assert.ObjectsAreEqual([]string{"a", name},
strings.Split(updatedCM.Data[namespace], ","))
}
})
t.Run("golden path for not repeating name", func(t *testing.T) {
name = "a"
cmdata[namespace] = "a"
mockClientset := fake.NewSimpleClientset(&v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: ConfigMapName,
Namespace: targetClusterNamespace,
},
Data: cmdata,
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.Initialize(clusterName)
require.NoError(t, err)
err = ecrAuth.AddToConfigMap(ctx, name, namespace)
require.NoError(t, err)
updatedCM, _ := mockClientset.CoreV1().ConfigMaps(targetClusterNamespace).
Get(ctx, ConfigMapName, metav1.GetOptions{})
assert.Equal(t, "a", updatedCM.Data[namespace])
})
t.Run("fails if config map doesnt exist", func(t *testing.T) {
mockClientset := fake.NewSimpleClientset(&v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: ConfigMapName,
Namespace: "wrong-ns",
},
Data: cmdata,
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.Initialize(clusterName)
require.NoError(t, err)
err = ecrAuth.AddToConfigMap(ctx, name, namespace)
assert.NotNil(t, err)
})
}
func TestDelFromConfigMap(t *testing.T) {
ctx := context.TODO()
name := "test-name"
namespace := "eksa-packages"
cmdata := make(map[string]string)
clusterName := "w-test"
targetClusterNamespace := api.PackageNamespace + "-" + clusterName
t.Run("golden path for removing one name but still exists", func(t *testing.T) {
name = "a"
cmdata[namespace] = "a,b"
mockClientset := fake.NewSimpleClientset(&v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: ConfigMapName,
Namespace: targetClusterNamespace,
},
Data: cmdata,
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.Initialize(clusterName)
require.NoError(t, err)
err = ecrAuth.DelFromConfigMap(ctx, name, namespace)
require.NoError(t, err)
updatedCM, err := mockClientset.CoreV1().ConfigMaps(targetClusterNamespace).
Get(ctx, ConfigMapName, metav1.GetOptions{})
require.NoError(t, err)
val, exists := updatedCM.Data["eksa-packages"]
assert.Nil(t, err)
assert.True(t, exists)
assert.Equal(t, "b", val)
})
t.Run("golden path for removing one name", func(t *testing.T) {
name = "a"
cmdata[namespace] = "a"
mockClientset := fake.NewSimpleClientset(&v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: ConfigMapName,
Namespace: targetClusterNamespace,
},
Data: cmdata,
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.Initialize(clusterName)
require.NoError(t, err)
err = ecrAuth.DelFromConfigMap(ctx, name, namespace)
require.NoError(t, err)
updatedCM, err := mockClientset.CoreV1().ConfigMaps(targetClusterNamespace).
Get(ctx, ConfigMapName, metav1.GetOptions{})
require.NoError(t, err)
_, exists := updatedCM.Data["eksa-packages"]
assert.False(t, exists)
})
}
func TestGetSecretValues(t *testing.T) {
ctx := context.TODO()
secretdata := make(map[string][]byte)
namespace := "eksa-packages"
t.Run("golden path for Retrieving ECR Secret", func(t *testing.T) {
namespace = "test"
testdata := []byte("testdata")
secretdata[".dockerconfigjson"] = testdata
mockClientset := fake.NewSimpleClientset(&v1.Secret{
ObjectMeta: metav1.ObjectMeta{
Name: ecrTokenName,
Namespace: api.PackageNamespace,
},
Data: secretdata,
Type: ".dockerconfigjson",
})
ecrAuth := ecrSecret{clientset: mockClientset}
values, err := ecrAuth.GetSecretValues(ctx, namespace)
assert.Nil(t, err)
assert.NotNil(t, values["imagePullSecrets"])
})
t.Run("golden path for Retrieving ECR Secret when namespace already exists", func(t *testing.T) {
namespace = "eksa-packages"
testdata := []byte("testdata")
secretdata[".dockerconfigjson"] = testdata
mockClientset := fake.NewSimpleClientset(&v1.Secret{
ObjectMeta: metav1.ObjectMeta{
Name: ecrTokenName,
Namespace: api.PackageNamespace,
},
Data: secretdata,
Type: ".dockerconfigjson",
})
ecrAuth := ecrSecret{clientset: mockClientset}
values, err := ecrAuth.GetSecretValues(ctx, namespace)
assert.Nil(t, err)
assert.NotNil(t, values["imagePullSecrets"])
_, exists := values["pullSecretName"]
assert.False(t, exists)
_, exists = values["pullSecretData"]
assert.False(t, exists)
})
}
func TestAddSecretToAllNamespace(t *testing.T) {
ctx := context.TODO()
suspend := false
t.Run("golden path for adding ECR Secret to all namespaces", func(t *testing.T) {
mockClientset := fake.NewSimpleClientset(&batchv1.CronJob{
ObjectMeta: metav1.ObjectMeta{
Name: cronJobName,
Namespace: api.PackageNamespace,
},
Spec: batchv1.CronJobSpec{
Suspend: &suspend,
},
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.AddSecretToAllNamespace(ctx)
assert.NoError(t, err)
jobs, err := mockClientset.BatchV1().Jobs(api.PackageNamespace).List(ctx, metav1.ListOptions{})
assert.NoError(t, err)
assert.NotNil(t, jobs.Items)
})
t.Run("golden path for adding ECR Secret to all namespaces with missing job", func(t *testing.T) {
mockClientset := fake.NewSimpleClientset(&batchv1.CronJob{
ObjectMeta: metav1.ObjectMeta{
Name: "wrong-name",
Namespace: api.PackageNamespace,
},
Spec: batchv1.CronJobSpec{
Suspend: &suspend,
},
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.AddSecretToAllNamespace(ctx)
assert.NotNil(t, err)
})
t.Run("golden path for adding ECR Secret to all namespaces with missing job in namespace", func(t *testing.T) {
mockClientset := fake.NewSimpleClientset(&batchv1.CronJob{
ObjectMeta: metav1.ObjectMeta{
Name: cronJobName,
Namespace: "wrong-ns",
},
Spec: batchv1.CronJobSpec{
Suspend: &suspend,
},
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.AddSecretToAllNamespace(ctx)
assert.NotNil(t, err)
})
t.Run("golden path for adding ECR Secret to all namespaces skipping if suspended cronjob", func(t *testing.T) {
suspend = true
mockClientset := fake.NewSimpleClientset(&batchv1.CronJob{
ObjectMeta: metav1.ObjectMeta{
Name: cronJobName,
Namespace: api.PackageNamespace,
},
Spec: batchv1.CronJobSpec{
Suspend: &suspend,
},
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.AddSecretToAllNamespace(ctx)
assert.NoError(t, err)
jobs, err := mockClientset.BatchV1().Jobs(api.PackageNamespace).List(ctx, metav1.ListOptions{})
assert.NoError(t, err)
assert.Nil(t, jobs.Items)
})
}
func TestCleanupPrevRuns(t *testing.T) {
ctx := context.TODO()
t.Run("golden path for deleting old auth pods", func(t *testing.T) {
mockClientset := fake.NewSimpleClientset(&batchv1.Job{
ObjectMeta: metav1.ObjectMeta{
Name: jobExecName + "1",
Namespace: api.PackageNamespace,
Labels: map[string]string{"createdBy": "controller"},
},
Status: batchv1.JobStatus{Succeeded: 1},
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.cleanupPrevRuns(ctx)
assert.NoError(t, err)
jobs, err := mockClientset.BatchV1().Jobs(api.PackageNamespace).List(ctx, metav1.ListOptions{})
assert.NoError(t, err)
assert.Nil(t, jobs.Items)
})
t.Run("golden path for not deleting running auth pods", func(t *testing.T) {
mockClientset := fake.NewSimpleClientset(&batchv1.Job{
ObjectMeta: metav1.ObjectMeta{
Name: jobExecName + "1",
Namespace: api.PackageNamespace,
Labels: map[string]string{"createdBy": "controller"},
},
Status: batchv1.JobStatus{Succeeded: 0},
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.cleanupPrevRuns(ctx)
assert.NoError(t, err)
jobs, err := mockClientset.BatchV1().Jobs(api.PackageNamespace).List(ctx, metav1.ListOptions{})
assert.NoError(t, err)
assert.NotNil(t, jobs.Items)
})
t.Run("golden path for not deleting jobs not created by controller", func(t *testing.T) {
mockClientset := fake.NewSimpleClientset(&batchv1.Job{
ObjectMeta: metav1.ObjectMeta{
Name: jobExecName + "1",
Namespace: api.PackageNamespace,
},
Status: batchv1.JobStatus{Succeeded: 1},
})
ecrAuth := ecrSecret{clientset: mockClientset}
err := ecrAuth.cleanupPrevRuns(ctx)
assert.NoError(t, err)
jobs, err := mockClientset.BatchV1().Jobs(api.PackageNamespace).List(ctx, metav1.ListOptions{})
assert.NoError(t, err)
assert.NotNil(t, jobs.Items)
})
}
| 384 |
eks-anywhere-packages | aws | Go | package authenticator
import (
"context"
"fmt"
"os"
"github.com/go-logr/logr"
corev1 "k8s.io/api/core/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/version"
"k8s.io/client-go/discovery"
"k8s.io/client-go/discovery/cached/memory"
"k8s.io/client-go/rest"
"k8s.io/client-go/restmapper"
"k8s.io/client-go/tools/clientcmd"
clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
"sigs.k8s.io/controller-runtime/pkg/client"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
)
const (
clusterNameEnvVar = "CLUSTER_NAME"
eksaSystemNamespace = "eksa-system"
)
//go:generate mockgen -source target_cluster_client.go -destination=mocks/target_cluster_client.go -package=mocks TargetClusterClient
type TargetClusterClient interface {
// Init the target cluster client
Initialize(ctx context.Context, clusterName string) error
// GetServerVersion of the target api server
GetServerVersion(ctx context.Context, clusterName string) (info *version.Info, err error)
// CreateClusterNamespace for the workload cluster.
CreateClusterNamespace(ctx context.Context, clusterName string) (err error)
// CheckNamespace tests for the existence of a namespace.
CheckNamespace(ctx context.Context, namespace string) bool
// ApplySecret for the workload cluster
ApplySecret(ctx context.Context, secret *corev1.Secret) (err error)
// Implement RESTClientGetter
ToRESTConfig() (*rest.Config, error)
ToDiscoveryClient() (discovery.CachedDiscoveryInterface, error)
ToRESTMapper() (meta.RESTMapper, error)
ToRawKubeConfigLoader() clientcmd.ClientConfig
}
type targetClusterClient struct {
Config *rest.Config
Client client.Client
targetSelf bool
clientConfig clientcmd.ClientConfig
logger logr.Logger
}
var _ TargetClusterClient = (*targetClusterClient)(nil)
func NewTargetClusterClient(logger logr.Logger, config *rest.Config, client client.Client) *targetClusterClient {
return &targetClusterClient{logger: logger, Config: config, Client: client}
}
func (tcc *targetClusterClient) Initialize(ctx context.Context, clusterName string) error {
kubeconfig, err := tcc.getKubeconfig(ctx, clusterName)
if err != nil {
return err
}
tcc.targetSelf = false
if kubeconfig == nil {
tcc.targetSelf = true
tcc.clientConfig = clientcmd.NewDefaultClientConfig(clientcmdapi.Config{}, &clientcmd.ConfigOverrides{})
return nil
}
clientConfig, err := clientcmd.NewClientConfigFromBytes(kubeconfig)
if err != nil {
return err
}
rawConfig, err := clientConfig.RawConfig()
if err != nil {
return err
}
tcc.clientConfig = clientcmd.NewDefaultClientConfig(rawConfig, &clientcmd.ConfigOverrides{})
return nil
}
func (tcc *targetClusterClient) ToRESTConfig() (*rest.Config, error) {
if tcc.targetSelf {
return tcc.Config, nil
}
return tcc.clientConfig.ClientConfig()
}
func (tcc *targetClusterClient) ToDiscoveryClient() (discovery.CachedDiscoveryInterface, error) {
restConfig, err := tcc.ToRESTConfig()
if err != nil {
return nil, err
}
dc, err := discovery.NewDiscoveryClientForConfig(restConfig)
if err != nil {
return nil, err
}
return memory.NewMemCacheClient(dc), nil
}
func (tcc *targetClusterClient) ToRESTMapper() (meta.RESTMapper, error) {
dc, err := tcc.ToDiscoveryClient()
if err != nil {
return nil, err
}
return restmapper.NewDeferredDiscoveryRESTMapper(dc), nil
}
func (tcc *targetClusterClient) ToRawKubeConfigLoader() clientcmd.ClientConfig {
return tcc.clientConfig
}
func (tcc *targetClusterClient) getKubeconfig(ctx context.Context, clusterName string) (kubeconfig []byte, err error) {
// Avoid using kubeconfig for ourselves
if clusterName == "" || os.Getenv(clusterNameEnvVar) == clusterName {
// Empty string will cause helm to use the current cluster
return nil, nil
}
secretName := clusterName + "-kubeconfig"
nn := types.NamespacedName{
Namespace: eksaSystemNamespace,
Name: secretName,
}
var kubeconfigSecret corev1.Secret
if err = tcc.Client.Get(ctx, nn, &kubeconfigSecret); err != nil {
return []byte{}, fmt.Errorf("getting kubeconfig for cluster %q: %w", clusterName, err)
}
return kubeconfigSecret.Data["value"], nil
}
func (tcc *targetClusterClient) GetServerVersion(ctx context.Context, clusterName string) (info *version.Info, err error) {
err = tcc.Initialize(ctx, clusterName)
if err != nil {
return nil, fmt.Errorf("initializing target client: %s", err)
}
discoveryClient, err := tcc.ToDiscoveryClient()
if err != nil {
return nil, fmt.Errorf("creating discoveryClient client: %s", err)
}
info, err = discoveryClient.ServerVersion()
if err != nil {
return nil, fmt.Errorf("getting server version: %w", err)
}
return info, nil
}
func (tcc *targetClusterClient) CreateClusterNamespace(ctx context.Context, clusterName string) (err error) {
err = tcc.Initialize(ctx, clusterName)
if err != nil {
return fmt.Errorf("initializing target client: %s", err)
}
restConfig, err := tcc.ToRESTConfig()
if err != nil {
return fmt.Errorf("create rest config for %s: %s", clusterName, err)
}
k8sClient, err := client.New(restConfig, client.Options{})
if err != nil {
return fmt.Errorf("creating client for %s: %s", clusterName, err)
}
if !tcc.CheckNamespace(ctx, api.PackageNamespace) {
err := k8sClient.Create(ctx, &corev1.Namespace{
ObjectMeta: metav1.ObjectMeta{Name: api.PackageNamespace},
})
if err != nil {
return fmt.Errorf("create namespace for %q: %s", clusterName, err)
}
}
return nil
}
// CheckNamespace tests for the existence of a namespace.
//
// It must only be called with an initialized target cluster client.
func (tcc *targetClusterClient) CheckNamespace(ctx context.Context, namespace string) bool {
if tcc.clientConfig == nil {
tcc.logger.Error(fmt.Errorf("client is not initialized"), "checking namespace", "namespace", "namespace")
return false
}
restConfig, err := tcc.ToRESTConfig()
if err != nil {
tcc.logger.V(6).Error(err, "creating rest config", "namespace", namespace)
return false
}
k8sClient, err := client.New(restConfig, client.Options{})
if err != nil {
tcc.logger.V(6).Error(err, "creating k8s client", "namespace", namespace)
return false
}
nn := types.NamespacedName{Name: namespace}
ns := &corev1.Namespace{}
if err := k8sClient.Get(ctx, nn, ns); err != nil {
if !apierrors.IsNotFound(err) {
tcc.logger.V(6).Error(err, "getting namespace", "namespace", namespace)
}
return false
}
return true
}
// ApplySecret on the workload cluster
//
// It must only be called with an initialized target cluster client.
func (tcc *targetClusterClient) ApplySecret(ctx context.Context, secret *corev1.Secret) error {
if tcc.clientConfig == nil {
tcc.logger.Error(fmt.Errorf("client is not initialized"), "creating secret")
return fmt.Errorf("client is not initialized")
}
restConfig, err := tcc.ToRESTConfig()
if err != nil {
tcc.logger.V(6).Error(err, "creating rest config")
return err
}
k8sClient, err := client.New(restConfig, client.Options{})
if err != nil {
tcc.logger.V(6).Error(err, "creating k8s client")
return err
}
newSecret := corev1.Secret{
ObjectMeta: metav1.ObjectMeta{
Name: secret.ObjectMeta.Name,
Namespace: secret.ObjectMeta.Namespace,
},
Data: secret.Data,
}
err = k8sClient.Create(ctx, &newSecret)
if err != nil {
if !apierrors.IsAlreadyExists(err) {
return fmt.Errorf("create secret for workload cluster %s", err)
}
err := k8sClient.Update(ctx, &newSecret)
if err != nil {
return fmt.Errorf("update secret for workload cluster %s", err)
}
}
return nil
}
| 267 |
eks-anywhere-packages | aws | Go | package authenticator
import (
"context"
"fmt"
"testing"
"github.com/go-logr/logr/testr"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/assert"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/types"
"sigs.k8s.io/controller-runtime/pkg/client"
"github.com/aws/eks-anywhere-packages/controllers/mocks"
)
const actualData = `
apiVersion: v1
clusters:
- cluster:
certificate-authority-data: LS0t
server: https://127.0.0.1:6443
name: billy
contexts:
- context:
cluster: billy
user: billy-admin
name: billy-admin@billy
kind: Config
preferences: {}
users:
- name: billy-admin
user:
client-certificate-data: LS0t
client-key-data: LS0t
`
func TestTargetClusterClient_Init(t *testing.T) {
ctx := context.Background()
setKubeConfigSecret := func(src *corev1.Secret) func(_ context.Context, _ types.NamespacedName, kc *corev1.Secret, _ ...client.GetOption) error {
return func(ctx context.Context, name types.NamespacedName, target *corev1.Secret, _ ...client.GetOption) error {
src.DeepCopyInto(target)
return nil
}
}
t.Run("get kubeconfig success", func(t *testing.T) {
logger := testr.New(t)
mockClient := mocks.NewMockClient(gomock.NewController(t))
sut := NewTargetClusterClient(logger, nil, mockClient)
var kubeconfigSecret corev1.Secret
kubeconfigSecret.Data = make(map[string][]byte)
kubeconfigSecret.Data["value"] = []byte(actualData)
nn := types.NamespacedName{
Namespace: "eksa-system",
Name: "billy-kubeconfig",
}
mockClient.EXPECT().Get(ctx, nn, gomock.Any()).DoAndReturn(setKubeConfigSecret(&kubeconfigSecret)).Return(nil)
t.Setenv("CLUSTER_NAME", "franky")
err := sut.Initialize(ctx, "billy")
assert.NoError(t, err)
})
t.Run("get kubeconfig CLUSTER_NAME success", func(t *testing.T) {
logger := testr.New(t)
mockClient := mocks.NewMockClient(gomock.NewController(t))
sut := NewTargetClusterClient(logger, nil, mockClient)
t.Setenv("CLUSTER_NAME", "billy")
err := sut.Initialize(ctx, "billy")
assert.NoError(t, err)
})
t.Run("get kubeconfig failure", func(t *testing.T) {
logger := testr.New(t)
mockClient := mocks.NewMockClient(gomock.NewController(t))
sut := NewTargetClusterClient(logger, nil, mockClient)
nn := types.NamespacedName{
Namespace: "eksa-system",
Name: "billy-kubeconfig",
}
t.Setenv("CLUSTER_NAME", "franky")
mockClient.EXPECT().Get(ctx, nn, gomock.Any()).Return(fmt.Errorf("boom"))
err := sut.Initialize(ctx, "billy")
assert.EqualError(t, err, "getting kubeconfig for cluster \"billy\": boom")
})
t.Run("get kubeconfig no cluster", func(t *testing.T) {
logger := testr.New(t)
mockClient := mocks.NewMockClient(gomock.NewController(t))
sut := NewTargetClusterClient(logger, nil, mockClient)
// TODO do we need to support this case?
err := sut.Initialize(ctx, "")
assert.NoError(t, err)
})
}
| 101 |
eks-anywhere-packages | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: authenticator.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
gomock "github.com/golang/mock/gomock"
)
// MockAuthenticator is a mock of Authenticator interface.
type MockAuthenticator struct {
ctrl *gomock.Controller
recorder *MockAuthenticatorMockRecorder
}
// MockAuthenticatorMockRecorder is the mock recorder for MockAuthenticator.
type MockAuthenticatorMockRecorder struct {
mock *MockAuthenticator
}
// NewMockAuthenticator creates a new mock instance.
func NewMockAuthenticator(ctrl *gomock.Controller) *MockAuthenticator {
mock := &MockAuthenticator{ctrl: ctrl}
mock.recorder = &MockAuthenticatorMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAuthenticator) EXPECT() *MockAuthenticatorMockRecorder {
return m.recorder
}
// AddSecretToAllNamespace mocks base method.
func (m *MockAuthenticator) AddSecretToAllNamespace(ctx context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddSecretToAllNamespace", ctx)
ret0, _ := ret[0].(error)
return ret0
}
// AddSecretToAllNamespace indicates an expected call of AddSecretToAllNamespace.
func (mr *MockAuthenticatorMockRecorder) AddSecretToAllNamespace(ctx interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSecretToAllNamespace", reflect.TypeOf((*MockAuthenticator)(nil).AddSecretToAllNamespace), ctx)
}
// AddToConfigMap mocks base method.
func (m *MockAuthenticator) AddToConfigMap(ctx context.Context, name, namespace string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddToConfigMap", ctx, name, namespace)
ret0, _ := ret[0].(error)
return ret0
}
// AddToConfigMap indicates an expected call of AddToConfigMap.
func (mr *MockAuthenticatorMockRecorder) AddToConfigMap(ctx, name, namespace interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddToConfigMap", reflect.TypeOf((*MockAuthenticator)(nil).AddToConfigMap), ctx, name, namespace)
}
// AuthFilename mocks base method.
func (m *MockAuthenticator) AuthFilename() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AuthFilename")
ret0, _ := ret[0].(string)
return ret0
}
// AuthFilename indicates an expected call of AuthFilename.
func (mr *MockAuthenticatorMockRecorder) AuthFilename() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthFilename", reflect.TypeOf((*MockAuthenticator)(nil).AuthFilename))
}
// DelFromConfigMap mocks base method.
func (m *MockAuthenticator) DelFromConfigMap(ctx context.Context, name, namespace string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DelFromConfigMap", ctx, name, namespace)
ret0, _ := ret[0].(error)
return ret0
}
// DelFromConfigMap indicates an expected call of DelFromConfigMap.
func (mr *MockAuthenticatorMockRecorder) DelFromConfigMap(ctx, name, namespace interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelFromConfigMap", reflect.TypeOf((*MockAuthenticator)(nil).DelFromConfigMap), ctx, name, namespace)
}
// GetSecretValues mocks base method.
func (m *MockAuthenticator) GetSecretValues(ctx context.Context, namespace string) (map[string]interface{}, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetSecretValues", ctx, namespace)
ret0, _ := ret[0].(map[string]interface{})
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetSecretValues indicates an expected call of GetSecretValues.
func (mr *MockAuthenticatorMockRecorder) GetSecretValues(ctx, namespace interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecretValues", reflect.TypeOf((*MockAuthenticator)(nil).GetSecretValues), ctx, namespace)
}
// Initialize mocks base method.
func (m *MockAuthenticator) Initialize(clusterName string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Initialize", clusterName)
ret0, _ := ret[0].(error)
return ret0
}
// Initialize indicates an expected call of Initialize.
func (mr *MockAuthenticatorMockRecorder) Initialize(clusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockAuthenticator)(nil).Initialize), clusterName)
}
| 121 |
eks-anywhere-packages | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: target_cluster_client.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
gomock "github.com/golang/mock/gomock"
v1 "k8s.io/api/core/v1"
meta "k8s.io/apimachinery/pkg/api/meta"
version "k8s.io/apimachinery/pkg/version"
discovery "k8s.io/client-go/discovery"
rest "k8s.io/client-go/rest"
clientcmd "k8s.io/client-go/tools/clientcmd"
)
// MockTargetClusterClient is a mock of TargetClusterClient interface.
type MockTargetClusterClient struct {
ctrl *gomock.Controller
recorder *MockTargetClusterClientMockRecorder
}
// MockTargetClusterClientMockRecorder is the mock recorder for MockTargetClusterClient.
type MockTargetClusterClientMockRecorder struct {
mock *MockTargetClusterClient
}
// NewMockTargetClusterClient creates a new mock instance.
func NewMockTargetClusterClient(ctrl *gomock.Controller) *MockTargetClusterClient {
mock := &MockTargetClusterClient{ctrl: ctrl}
mock.recorder = &MockTargetClusterClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTargetClusterClient) EXPECT() *MockTargetClusterClientMockRecorder {
return m.recorder
}
// ApplySecret mocks base method.
func (m *MockTargetClusterClient) ApplySecret(ctx context.Context, secret *v1.Secret) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ApplySecret", ctx, secret)
ret0, _ := ret[0].(error)
return ret0
}
// ApplySecret indicates an expected call of ApplySecret.
func (mr *MockTargetClusterClientMockRecorder) ApplySecret(ctx, secret interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecret", reflect.TypeOf((*MockTargetClusterClient)(nil).ApplySecret), ctx, secret)
}
// CheckNamespace mocks base method.
func (m *MockTargetClusterClient) CheckNamespace(ctx context.Context, namespace string) bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CheckNamespace", ctx, namespace)
ret0, _ := ret[0].(bool)
return ret0
}
// CheckNamespace indicates an expected call of CheckNamespace.
func (mr *MockTargetClusterClientMockRecorder) CheckNamespace(ctx, namespace interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckNamespace", reflect.TypeOf((*MockTargetClusterClient)(nil).CheckNamespace), ctx, namespace)
}
// CreateClusterNamespace mocks base method.
func (m *MockTargetClusterClient) CreateClusterNamespace(ctx context.Context, clusterName string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateClusterNamespace", ctx, clusterName)
ret0, _ := ret[0].(error)
return ret0
}
// CreateClusterNamespace indicates an expected call of CreateClusterNamespace.
func (mr *MockTargetClusterClientMockRecorder) CreateClusterNamespace(ctx, clusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClusterNamespace", reflect.TypeOf((*MockTargetClusterClient)(nil).CreateClusterNamespace), ctx, clusterName)
}
// GetServerVersion mocks base method.
func (m *MockTargetClusterClient) GetServerVersion(ctx context.Context, clusterName string) (*version.Info, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetServerVersion", ctx, clusterName)
ret0, _ := ret[0].(*version.Info)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetServerVersion indicates an expected call of GetServerVersion.
func (mr *MockTargetClusterClientMockRecorder) GetServerVersion(ctx, clusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerVersion", reflect.TypeOf((*MockTargetClusterClient)(nil).GetServerVersion), ctx, clusterName)
}
// Initialize mocks base method.
func (m *MockTargetClusterClient) Initialize(ctx context.Context, clusterName string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Initialize", ctx, clusterName)
ret0, _ := ret[0].(error)
return ret0
}
// Initialize indicates an expected call of Initialize.
func (mr *MockTargetClusterClientMockRecorder) Initialize(ctx, clusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockTargetClusterClient)(nil).Initialize), ctx, clusterName)
}
// ToDiscoveryClient mocks base method.
func (m *MockTargetClusterClient) ToDiscoveryClient() (discovery.CachedDiscoveryInterface, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ToDiscoveryClient")
ret0, _ := ret[0].(discovery.CachedDiscoveryInterface)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ToDiscoveryClient indicates an expected call of ToDiscoveryClient.
func (mr *MockTargetClusterClientMockRecorder) ToDiscoveryClient() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToDiscoveryClient", reflect.TypeOf((*MockTargetClusterClient)(nil).ToDiscoveryClient))
}
// ToRESTConfig mocks base method.
func (m *MockTargetClusterClient) ToRESTConfig() (*rest.Config, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ToRESTConfig")
ret0, _ := ret[0].(*rest.Config)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ToRESTConfig indicates an expected call of ToRESTConfig.
func (mr *MockTargetClusterClientMockRecorder) ToRESTConfig() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToRESTConfig", reflect.TypeOf((*MockTargetClusterClient)(nil).ToRESTConfig))
}
// ToRESTMapper mocks base method.
func (m *MockTargetClusterClient) ToRESTMapper() (meta.RESTMapper, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ToRESTMapper")
ret0, _ := ret[0].(meta.RESTMapper)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ToRESTMapper indicates an expected call of ToRESTMapper.
func (mr *MockTargetClusterClientMockRecorder) ToRESTMapper() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToRESTMapper", reflect.TypeOf((*MockTargetClusterClient)(nil).ToRESTMapper))
}
// ToRawKubeConfigLoader mocks base method.
func (m *MockTargetClusterClient) ToRawKubeConfigLoader() clientcmd.ClientConfig {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ToRawKubeConfigLoader")
ret0, _ := ret[0].(clientcmd.ClientConfig)
return ret0
}
// ToRawKubeConfigLoader indicates an expected call of ToRawKubeConfigLoader.
func (mr *MockTargetClusterClientMockRecorder) ToRawKubeConfigLoader() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToRawKubeConfigLoader", reflect.TypeOf((*MockTargetClusterClient)(nil).ToRawKubeConfigLoader))
}
| 172 |
eks-anywhere-packages | aws | Go | package bundle
import (
"context"
"fmt"
"os"
v1 "k8s.io/api/core/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
"sigs.k8s.io/controller-runtime/pkg/client"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
auth "github.com/aws/eks-anywhere-packages/pkg/authenticator"
)
//go:generate mockgen -source client.go -destination=mocks/client.go -package=mocks Client
type Client interface {
// GetActiveBundle retrieves the currently active bundle.
GetActiveBundle(ctx context.Context, clusterName string) (activeBundle *api.PackageBundle, err error)
// GetPackageBundleController retrieves clusters package bundle controller
GetPackageBundleController(ctx context.Context, clusterName string) (controller *api.PackageBundleController, err error)
// GetBundleList get list of bundles worthy of consideration
GetBundleList(ctx context.Context) (bundles []api.PackageBundle, err error)
// GetBundle retrieves the named bundle.
GetBundle(ctx context.Context, name string) (namedBundle *api.PackageBundle, err error)
// GetSecret retries the named secret
GetSecret(ctx context.Context, name string) (secret *v1.Secret, err error)
// CreateBundle add a new bundle custom resource
CreateBundle(ctx context.Context, bundle *api.PackageBundle) error
// CreateClusterConfigMap based on cluster name
CreateClusterConfigMap(ctx context.Context, clusterName string) error
// CreatePackage creates a package
CreatePackage(ctx context.Context, pkg *api.Package) (err error)
// GetPackageList retrieves the list of packages resources.
GetPackageList(ctx context.Context, namespace string) (packages api.PackageList, err error)
// SaveStatus saves a resource status
SaveStatus(ctx context.Context, object client.Object) error
// Save saves a resource
Save(ctx context.Context, object client.Object) error
}
type managerClient struct {
client.Client
}
func NewManagerClient(client client.Client) *managerClient {
return &(managerClient{
Client: client,
})
}
var _ Client = (*managerClient)(nil)
// GetActiveBundle retrieves the bundle from which package are installed.
//
// It retrieves the name of the active bundle from the PackageBundleController,
// then uses the K8s API to retrieve and return the active bundle.
func (bc *managerClient) GetActiveBundle(ctx context.Context, clusterName string) (activeBundle *api.PackageBundle, err error) {
pbc, err := bc.GetPackageBundleController(ctx, clusterName)
if err != nil {
return nil, err
}
if pbc.Spec.ActiveBundle == "" {
return nil, fmt.Errorf("no activeBundle set in PackageBundleController")
}
nn := types.NamespacedName{
Namespace: api.PackageNamespace,
Name: pbc.Spec.ActiveBundle,
}
activeBundle = &api.PackageBundle{}
err = bc.Get(ctx, nn, activeBundle)
if err != nil {
return nil, err
}
return activeBundle, nil
}
func (bc *managerClient) GetPackageBundleController(ctx context.Context, clusterName string) (*api.PackageBundleController, error) {
if clusterName == "" {
clusterName = os.Getenv("CLUSTER_NAME")
}
pbc := api.PackageBundleController{}
key := types.NamespacedName{
Namespace: api.PackageNamespace,
Name: clusterName,
}
err := bc.Get(ctx, key, &pbc)
if err != nil {
return nil, fmt.Errorf("getting PackageBundleController: %v", err)
}
return &pbc, nil
}
func (bc *managerClient) GetBundle(ctx context.Context, name string) (namedBundle *api.PackageBundle, err error) {
nn := types.NamespacedName{
Namespace: api.PackageNamespace,
Name: name,
}
namedBundle = &api.PackageBundle{}
err = bc.Get(ctx, nn, namedBundle)
if err != nil {
if apierrors.IsNotFound(err) {
return nil, nil
}
return nil, err
}
return namedBundle, nil
}
func (bc *managerClient) GetSecret(ctx context.Context, name string) (secret *v1.Secret, err error) {
nn := types.NamespacedName{
Namespace: api.PackageNamespace,
Name: name,
}
secret = &v1.Secret{}
err = bc.Get(ctx, nn, secret)
if err != nil {
if apierrors.IsNotFound(err) {
return nil, nil
}
return nil, fmt.Errorf("aws-secret error:%v", err)
}
return secret, nil
}
func (bc *managerClient) GetBundleList(ctx context.Context) (bundles []api.PackageBundle, err error) {
allBundles := &api.PackageBundleList{}
err = bc.Client.List(ctx, allBundles, &client.ListOptions{Namespace: api.PackageNamespace})
if err != nil {
return nil, fmt.Errorf("listing package bundles: %s", err)
}
return allBundles.Items, nil
}
func (bc *managerClient) CreateClusterNamespace(ctx context.Context, clusterName string) error {
name := api.PackageNamespace + "-" + clusterName
key := types.NamespacedName{
Name: name,
}
ns := &v1.Namespace{}
err := bc.Get(ctx, key, ns)
// Nil err check here means that the namespace exists thus we can just return with no error
if err == nil {
return nil
}
if !apierrors.IsNotFound(err) {
return err
}
ns.Name = name
err = bc.Client.Create(ctx, ns)
if err != nil {
return err
}
return nil
}
func (bc *managerClient) CreateClusterConfigMap(ctx context.Context, clusterName string) error {
name := auth.ConfigMapName
namespace := api.PackageNamespace + "-" + clusterName
key := types.NamespacedName{
Name: name,
Namespace: namespace,
}
cm := &v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: name,
Namespace: namespace,
},
}
err := bc.Get(ctx, key, cm)
// Nil err check here means that the config map exists thus we can just return with no error
if err == nil {
return nil
}
if !apierrors.IsNotFound(err) {
return err
}
cm.Data = make(map[string]string)
cm.Data[namespace] = "eksa-package-controller"
// Unfortunate workaround for emissary webhooks hard coded crd namespace
cm.Data["emissary-system"] = "eksa-package-placeholder"
err = bc.Client.Create(ctx, cm)
if err != nil {
return err
}
return nil
}
// CreatePackage creates the given package resource
func (p *managerClient) CreatePackage(ctx context.Context, pkg *api.Package) (err error) {
return p.Client.Create(ctx, pkg)
}
// GetPackageList retrieves all packages present in the given namespace
func (p *managerClient) GetPackageList(ctx context.Context, namespace string) (packages api.PackageList, err error) {
list := api.PackageList{}
return list, p.Client.List(ctx, &list, client.InNamespace(namespace))
}
func (bc *managerClient) CreateBundle(ctx context.Context, bundle *api.PackageBundle) error {
err := bc.Client.Create(ctx, bundle)
if err != nil {
return fmt.Errorf("creating new package bundle: %s", err)
}
return nil
}
func (bc *managerClient) SaveStatus(ctx context.Context, object client.Object) error {
return bc.Client.Status().Update(ctx, object, &client.SubResourceUpdateOptions{})
}
func (bc *managerClient) Save(ctx context.Context, object client.Object) error {
return bc.Client.Update(ctx, object, &client.UpdateOptions{})
}
| 239 |
eks-anywhere-packages | aws | Go | package bundle
import (
"context"
"fmt"
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/types"
"sigs.k8s.io/controller-runtime/pkg/client"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
ctrlmocks "github.com/aws/eks-anywhere-packages/controllers/mocks"
)
const (
testBundleRegistry = "public.ecr.aws/l0g8r8j6"
)
func givenMockClient(t *testing.T) *ctrlmocks.MockClient {
goMockController := gomock.NewController(t)
return ctrlmocks.NewMockClient(goMockController)
}
func givenBundle() *api.PackageBundle {
return &api.PackageBundle{
ObjectMeta: metav1.ObjectMeta{
Name: testBundleName,
Namespace: api.PackageNamespace,
},
Spec: api.PackageBundleSpec{
Packages: []api.BundlePackage{
{
Name: "hello-eks-anywhere",
Source: api.BundlePackageSource{
Registry: "public.ecr.aws/l0g8r8j6",
Repository: "hello-eks-anywhere",
Versions: []api.SourceVersion{
{Name: "0.1.1", Digest: "sha256:deadbeef"},
{Name: "0.1.0", Digest: "sha256:cafebabe"},
},
},
},
},
},
}
}
func givenPackageBundleController() *api.PackageBundleController {
return &api.PackageBundleController{
ObjectMeta: metav1.ObjectMeta{
Name: "cluster01",
Namespace: api.PackageNamespace,
},
Spec: api.PackageBundleControllerSpec{
ActiveBundle: testBundleName,
DefaultRegistry: "public.ecr.aws/l0g8r8j6",
DefaultImageRegistry: "783794618700.dkr.ecr.us-west-2.amazonaws.com",
BundleRepository: "eks-anywhere-packages-bundles",
},
Status: api.PackageBundleControllerStatus{
State: api.BundleControllerStateActive,
},
}
}
func TestNewPackageBundleClient(t *testing.T) {
t.Parallel()
t.Run("golden path", func(t *testing.T) {
t.Parallel()
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
assert.NotNil(t, bundleClient)
})
}
func TestBundleClient_GetActiveBundle(t *testing.T) {
t.Parallel()
ctx := context.Background()
pbc := givenPackageBundleController()
t.Run("golden path", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
testBundle := givenBundle()
mockClient.EXPECT().Get(ctx, gomock.Any(), gomock.AssignableToTypeOf(pbc)).SetArg(2, *pbc)
mockClient.EXPECT().Get(ctx, gomock.Any(), gomock.AssignableToTypeOf(testBundle)).SetArg(2, *testBundle)
bundle, err := bundleClient.GetActiveBundle(ctx, "billy")
assert.Equal(t, bundle.Name, testBundleName)
assert.Equal(t, "hello-eks-anywhere", bundle.Spec.Packages[0].Name)
assert.Equal(t, "public.ecr.aws/l0g8r8j6", bundle.Spec.Packages[0].Source.Registry)
assert.NoError(t, err)
})
t.Run("no active bundle", func(t *testing.T) {
pbc := givenPackageBundleController()
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
pbc.Spec.ActiveBundle = ""
mockClient.EXPECT().Get(ctx, gomock.Any(), gomock.AssignableToTypeOf(pbc)).SetArg(2, *pbc)
bundle, err := bundleClient.GetActiveBundle(ctx, "billy")
assert.Nil(t, bundle)
assert.EqualError(t, err, "no activeBundle set in PackageBundleController")
})
t.Run("error path", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
mockClient.EXPECT().Get(ctx, gomock.Any(), gomock.Any()).Return(fmt.Errorf("oops"))
_, err := bundleClient.GetActiveBundle(ctx, "billy")
assert.EqualError(t, err, "getting PackageBundleController: oops")
})
t.Run("other error path", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
mockClient.EXPECT().Get(ctx, gomock.Any(), gomock.AssignableToTypeOf(pbc)).SetArg(2, *pbc)
mockClient.EXPECT().Get(ctx, gomock.Any(), gomock.Any()).Return(fmt.Errorf("oops"))
_, err := bundleClient.GetActiveBundle(ctx, "billy")
assert.EqualError(t, err, "oops")
})
}
func doAndReturnBundleList(source *api.PackageBundleList) func(context.Context, *api.PackageBundleList, *client.ListOptions) error {
return func(ctx context.Context, target *api.PackageBundleList, options *client.ListOptions) error {
source.DeepCopyInto(target)
return nil
}
}
func doAndReturnBundle(_ context.Context, nn types.NamespacedName, theBundle *api.PackageBundle, _ ...client.GetOption) error {
theBundle.Name = nn.Name
return nil
}
func TestBundleClient_GetBundle(t *testing.T) {
t.Parallel()
ctx := context.Background()
namedBundle := &api.PackageBundle{}
namedBundle.Name = "v1-21-1003"
key := types.NamespacedName{
Name: "v1-21-1003",
Namespace: "eksa-packages",
}
t.Run("already exists", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
mockClient.EXPECT().Get(ctx, key, gomock.Any()).DoAndReturn(doAndReturnBundle)
actualBundle, err := bundleClient.GetBundle(ctx, "v1-21-1003")
assert.NotNil(t, actualBundle)
assert.NoError(t, err)
})
t.Run("already exists error", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
mockClient.EXPECT().Get(ctx, key, gomock.AssignableToTypeOf(namedBundle)).Return(fmt.Errorf("boom"))
actualBundle, err := bundleClient.GetBundle(ctx, "v1-21-1003")
assert.Nil(t, actualBundle)
assert.EqualError(t, err, "boom")
})
t.Run("returns nil when bundle does not", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
groupResource := schema.GroupResource{
Group: key.Name,
Resource: "Namespace",
}
notFoundError := errors.NewNotFound(groupResource, key.Name)
mockClient.EXPECT().Get(ctx, key, gomock.AssignableToTypeOf(namedBundle)).Return(notFoundError)
actualBundle, err := bundleClient.GetBundle(ctx, "v1-21-1003")
assert.Nil(t, actualBundle)
assert.NoError(t, err)
})
}
func TestBundleClient_GetBundleList(t *testing.T) {
t.Parallel()
ctx := context.Background()
t.Run("golden path", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
testBundleList := &api.PackageBundleList{
Items: []api.PackageBundle{
{
ObjectMeta: metav1.ObjectMeta{
Name: "v1-16-1003",
},
},
{
ObjectMeta: metav1.ObjectMeta{
Name: "v1-21-1002",
},
},
{
ObjectMeta: metav1.ObjectMeta{
Name: "v1-21-1001",
},
},
},
}
mockClient.EXPECT().
List(ctx, gomock.Any(), &client.ListOptions{Namespace: api.PackageNamespace}).
DoAndReturn(doAndReturnBundleList(testBundleList))
bundleItems, err := bundleClient.GetBundleList(ctx)
require.NoError(t, err)
assert.ElementsMatch(t, bundleItems, testBundleList.Items)
})
t.Run("error scenario", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
actualList := &api.PackageBundleList{}
mockClient.EXPECT().List(ctx, actualList, &client.ListOptions{Namespace: api.PackageNamespace}).Return(fmt.Errorf("oops"))
bundleItems, err := bundleClient.GetBundleList(ctx)
assert.Nil(t, bundleItems)
assert.EqualError(t, err, "listing package bundles: oops")
})
}
func TestBundleClient_CreateBundle(t *testing.T) {
t.Parallel()
ctx := context.Background()
t.Run("golden path", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
actualBundle := &api.PackageBundle{}
mockClient.EXPECT().Create(ctx, actualBundle).Return(nil)
err := bundleClient.CreateBundle(ctx, actualBundle)
assert.NoError(t, err)
})
t.Run("error scenario", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
actualBundle := &api.PackageBundle{}
mockClient.EXPECT().Create(ctx, actualBundle).Return(fmt.Errorf("oops"))
err := bundleClient.CreateBundle(ctx, actualBundle)
assert.EqualError(t, err, "creating new package bundle: oops")
})
}
func TestBundleClient_CreateClusterNamespace(t *testing.T) {
t.Parallel()
ctx := context.Background()
ns := &v1.Namespace{}
ns.Name = "eksa-packages-bobby"
key := types.NamespacedName{
Name: "eksa-packages-bobby",
}
t.Run("already exists", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
mockClient.EXPECT().Get(ctx, key, gomock.AssignableToTypeOf(ns)).Return(nil)
err := bundleClient.CreateClusterNamespace(ctx, "bobby")
assert.NoError(t, err)
})
t.Run("get error", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
mockClient.EXPECT().Get(ctx, key, gomock.AssignableToTypeOf(ns)).Return(fmt.Errorf("boom"))
err := bundleClient.CreateClusterNamespace(ctx, "bobby")
assert.EqualError(t, err, "boom")
})
t.Run("create namespace", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
groupResource := schema.GroupResource{
Group: key.Name,
Resource: "Namespace",
}
notFoundError := errors.NewNotFound(groupResource, key.Name)
mockClient.EXPECT().Get(ctx, key, gomock.AssignableToTypeOf(ns)).Return(notFoundError)
mockClient.EXPECT().Create(ctx, ns).Return(nil)
err := bundleClient.CreateClusterNamespace(ctx, "bobby")
assert.NoError(t, err)
})
t.Run("create namespace error", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
groupResource := schema.GroupResource{
Group: key.Name,
Resource: "Namespace",
}
notFoundError := errors.NewNotFound(groupResource, key.Name)
mockClient.EXPECT().Get(ctx, key, gomock.AssignableToTypeOf(ns)).Return(notFoundError)
mockClient.EXPECT().Create(ctx, ns).Return(fmt.Errorf("boom"))
err := bundleClient.CreateClusterNamespace(ctx, "bobby")
assert.EqualError(t, err, "boom")
})
}
func TestBundleClient_CreateClusterConfigMap(t *testing.T) {
t.Parallel()
ctx := context.Background()
name := "ns-secret-map"
namespace := "eksa-packages-bobby"
key := types.NamespacedName{
Name: name,
Namespace: namespace,
}
cm := &v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: name,
Namespace: namespace,
},
}
cm.Data = make(map[string]string)
cm.Data[namespace] = "eksa-package-controller"
cm.Data["emissary-system"] = "eksa-package-placeholder"
t.Run("already exists", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
mockClient.EXPECT().Get(ctx, key, gomock.AssignableToTypeOf(cm)).Return(nil)
err := bundleClient.CreateClusterConfigMap(ctx, "bobby")
assert.NoError(t, err)
})
t.Run("get error", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
mockClient.EXPECT().Get(ctx, key, gomock.AssignableToTypeOf(cm)).Return(fmt.Errorf("boom"))
err := bundleClient.CreateClusterConfigMap(ctx, "bobby")
assert.EqualError(t, err, "boom")
})
t.Run("create configmap", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
groupResource := schema.GroupResource{
Group: key.Name,
Resource: "Namespace",
}
notFoundError := errors.NewNotFound(groupResource, key.Name)
mockClient.EXPECT().Get(ctx, key, gomock.AssignableToTypeOf(cm)).Return(notFoundError)
mockClient.EXPECT().Create(ctx, cm).Return(nil)
err := bundleClient.CreateClusterConfigMap(ctx, "bobby")
assert.NoError(t, err)
})
t.Run("create configmap error", func(t *testing.T) {
mockClient := givenMockClient(t)
bundleClient := NewManagerClient(mockClient)
groupResource := schema.GroupResource{
Group: key.Name,
Resource: "Namespace",
}
notFoundError := errors.NewNotFound(groupResource, key.Name)
mockClient.EXPECT().Get(ctx, key, gomock.AssignableToTypeOf(cm)).Return(notFoundError)
mockClient.EXPECT().Create(ctx, cm).Return(fmt.Errorf("boom"))
err := bundleClient.CreateClusterConfigMap(ctx, "bobby")
assert.EqualError(t, err, "boom")
})
}
| 419 |
eks-anywhere-packages | aws | Go | package bundle
import (
"context"
"fmt"
"os"
"time"
"github.com/go-logr/logr"
"golang.org/x/mod/semver"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
"github.com/aws/eks-anywhere-packages/pkg/authenticator"
"github.com/aws/eks-anywhere-packages/pkg/config"
)
//go:generate mockgen -source manager.go -destination=mocks/manager.go -package=mocks Manager
type Manager interface {
// ProcessBundle returns true if there are changes
ProcessBundle(ctx context.Context, newBundle *api.PackageBundle) (bool, error)
// ProcessBundleController process the bundle controller
ProcessBundleController(ctx context.Context, pbc *api.PackageBundleController) error
}
type bundleManager struct {
log logr.Logger
bundleClient Client
registryClient RegistryClient
targetClient authenticator.TargetClusterClient
config config.Config
}
func NewBundleManager(log logr.Logger, registryClient RegistryClient, bundleClient Client, targetClient authenticator.TargetClusterClient, config config.Config) *bundleManager {
return &bundleManager{
log: log,
bundleClient: bundleClient,
registryClient: registryClient,
targetClient: targetClient,
config: config,
}
}
var _ Manager = (*bundleManager)(nil)
func (m bundleManager) ProcessBundle(_ context.Context, newBundle *api.PackageBundle) (bool, error) {
if newBundle.Namespace != api.PackageNamespace {
if newBundle.Status.State != api.PackageBundleStateIgnored {
newBundle.Spec.DeepCopyInto(&newBundle.Status.Spec)
newBundle.Status.State = api.PackageBundleStateIgnored
m.log.V(6).Info("update", "bundle", newBundle.Name, "state", newBundle.Status.State)
return true, nil
}
return false, nil
}
if !m.isCompatibleWith(newBundle) {
if newBundle.Status.State != api.PackageBundleStateUpgradeRequired {
newBundle.Spec.DeepCopyInto(&newBundle.Status.Spec)
newBundle.Status.State = api.PackageBundleStateUpgradeRequired
m.log.V(6).Info("update", "bundle", newBundle.Name, "state", newBundle.Status.State)
return true, nil
}
return false, nil
}
if !newBundle.IsValidVersion() {
if newBundle.Status.State != api.PackageBundleStateInvalid {
newBundle.Spec.DeepCopyInto(&newBundle.Status.Spec)
newBundle.Status.State = api.PackageBundleStateInvalid
m.log.V(6).Info("update", "bundle", newBundle.Name, "state", newBundle.Status.State)
return true, nil
}
return false, nil
}
if newBundle.Status.State != api.PackageBundleStateAvailable {
newBundle.Spec.DeepCopyInto(&newBundle.Status.Spec)
newBundle.Status.State = api.PackageBundleStateAvailable
m.log.V(6).Info("update", "bundle", newBundle.Name, "state", newBundle.Status.State)
return true, nil
}
return false, nil
}
func (m *bundleManager) isCompatibleWith(bundle *api.PackageBundle) bool {
currentVersion := m.config.BuildInfo.Version
return currentVersion == config.DEVELOPMENT || semver.Compare(currentVersion, bundle.Spec.MinVersion) >= 0
}
func (m *bundleManager) hasBundleNamed(bundles []api.PackageBundle, bundleName string) bool {
for _, b := range bundles {
if b.Name == bundleName {
return true
}
}
return false
}
func (m *bundleManager) ProcessBundleController(ctx context.Context, pbc *api.PackageBundleController) error {
info, err := m.targetClient.GetServerVersion(ctx, pbc.Name)
if err != nil {
m.log.Error(err, "Unable to get server version")
if pbc.Status.State == api.BundleControllerStateActive || pbc.Status.State == "" {
pbc.Status.Detail = err.Error()
pbc.Status.State = api.BundleControllerStateDisconnected
err = m.bundleClient.SaveStatus(ctx, pbc)
if err != nil {
return fmt.Errorf("updating %s status to %s: %s", pbc.Name, pbc.Status.State, err)
}
}
return nil
}
if err := m.targetClient.Initialize(ctx, os.Getenv("CLUSTER_NAME")); err != nil {
m.log.Error(err, "failed to intialize cluster client of management cluster")
}
config, _ := m.targetClient.ToRESTConfig()
auth, _ := authenticator.NewECRSecret(config)
if err := auth.AddSecretToAllNamespace(ctx); err != nil {
m.log.Error(err, "failed to Update Secret in all namespaces")
} else {
time.Sleep(3 * time.Second)
}
latestBundle, err := m.registryClient.LatestBundle(ctx, pbc.GetBundleURI(), info.Major, info.Minor, pbc.Name)
if err != nil {
m.log.Error(err, "Unable to get latest bundle")
if pbc.Status.State == api.BundleControllerStateActive || pbc.Status.State == "" {
pbc.Status.State = api.BundleControllerStateDisconnected
pbc.Status.Detail = err.Error()
err = m.bundleClient.SaveStatus(ctx, pbc)
if err != nil {
return fmt.Errorf("updating %s status to %s: %s", pbc.Name, pbc.Status.State, err)
}
}
return nil
}
allBundles, err := m.bundleClient.GetBundleList(ctx)
if err != nil {
return fmt.Errorf("getting bundle list: %s", err)
}
if !m.hasBundleNamed(allBundles, latestBundle.Name) {
err = m.bundleClient.CreateBundle(ctx, latestBundle)
if err != nil {
return err
}
}
latestBundleIsCurrentBundle := latestBundle.Name == pbc.Spec.ActiveBundle
if pbc.Spec.ActiveBundle == "" {
pbc.Status.State = ""
}
switch pbc.Status.State {
case api.BundleControllerStateActive:
err = m.bundleClient.CreateClusterConfigMap(ctx, pbc.Name)
if err != nil {
return fmt.Errorf("creating configmap for %s: %s", pbc.Name, err)
}
err = m.targetClient.CreateClusterNamespace(ctx, pbc.GetName())
if err != nil {
return fmt.Errorf("creating workload cluster namespace eksa-packages for %s: %s", pbc.Name, err)
}
if pbc.GetName() != os.Getenv("CLUSTER_NAME") {
secret, err := m.bundleClient.GetSecret(ctx, "aws-secret")
if err != nil {
return fmt.Errorf("getting aws secret eksa-packages:%s", err)
}
if secret != nil {
err = m.targetClient.ApplySecret(ctx, secret)
if err != nil {
return fmt.Errorf("creating workload cluster secret aws-secret:%s", err)
}
}
}
if len(pbc.Spec.ActiveBundle) > 0 {
if !m.hasBundleNamed(allBundles, pbc.Spec.ActiveBundle) {
activeBundle, err := m.registryClient.DownloadBundle(ctx, pbc.GetActiveBundleURI(), pbc.Name)
if err != nil {
m.log.Error(err, "Active bundle download failed", "bundle", pbc.Spec.ActiveBundle)
return nil
}
m.log.Info("Bundle downloaded", "bundle", pbc.Spec.ActiveBundle)
err = m.bundleClient.CreateBundle(ctx, activeBundle)
if err != nil {
m.log.Error(err, "Recreate active bundle failed", "bundle", pbc.Spec.ActiveBundle)
return nil
}
m.log.Info("Bundle created", "bundle", pbc.Spec.ActiveBundle)
}
}
if latestBundleIsCurrentBundle {
break
}
pbc.Status.State = api.BundleControllerStateUpgradeAvailable
m.log.V(6).Info("update", "PackageBundleController", pbc.Name, "state", pbc.Status.State)
pbc.Status.Detail = latestBundle.Name + " available"
pbc.Spec.DeepCopyInto(&pbc.Status.Spec)
err = m.bundleClient.SaveStatus(ctx, pbc)
if err != nil {
return fmt.Errorf("updating %s status to %s: %s", pbc.Name, pbc.Status.State, err)
}
case api.BundleControllerStateUpgradeAvailable:
if !latestBundleIsCurrentBundle {
if pbc.Status.Detail != latestBundle.Name+" available" {
pbc.Status.Detail = latestBundle.Name + " available"
pbc.Spec.DeepCopyInto(&pbc.Status.Spec)
err = m.bundleClient.SaveStatus(ctx, pbc)
if err != nil {
return fmt.Errorf("updating %s detail to %s: %s", pbc.Name, pbc.Status.Detail, err)
}
}
break
}
pbc.Status.State = api.BundleControllerStateActive
m.log.V(6).Info("update", "PackageBundleController", pbc.Name, "state", pbc.Status.State)
pbc.Status.Detail = ""
pbc.Spec.DeepCopyInto(&pbc.Status.Spec)
err = m.bundleClient.SaveStatus(ctx, pbc)
if err != nil {
return fmt.Errorf("updating %s status to %s: %s", pbc.Name, pbc.Status.State, err)
}
case api.BundleControllerStateDisconnected:
pbc.Status.State = api.BundleControllerStateActive
m.log.V(6).Info("update", "PackageBundleController", pbc.Name, "state", pbc.Status.State)
pbc.Status.Detail = ""
pbc.Spec.DeepCopyInto(&pbc.Status.Spec)
err = m.bundleClient.SaveStatus(ctx, pbc)
if err != nil {
return fmt.Errorf("updating %s status to %s: %s", pbc.Name, pbc.Status.State, err)
}
default:
if pbc.Spec.ActiveBundle != "" {
pbc.Status.State = api.BundleControllerStateActive
m.log.V(6).Info("update", "PackageBundleController", pbc.Name, "state", pbc.Status.State)
pbc.Status.Detail = ""
pbc.Spec.DeepCopyInto(&pbc.Status.Spec)
err = m.bundleClient.SaveStatus(ctx, pbc)
if err != nil {
return fmt.Errorf("updating %s status to %s: %s", pbc.Name, pbc.Status.State, err)
}
} else {
pbc.Spec.ActiveBundle = latestBundle.Name
m.log.V(6).Info("update", "PackageBundleController", pbc.Name, "activeBundle", pbc.Spec.ActiveBundle)
pbc.Status.Detail = ""
err = m.bundleClient.Save(ctx, pbc)
if err != nil {
return fmt.Errorf("updating %s activeBundle to %s: %s", pbc.Name, pbc.Spec.ActiveBundle, err)
}
}
}
return nil
}
| 265 |
eks-anywhere-packages | aws | Go | package bundle
import (
"context"
"fmt"
"os"
"testing"
"github.com/go-logr/logr/testr"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/assert"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/version"
"k8s.io/client-go/rest"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
"github.com/aws/eks-anywhere-packages/pkg/authenticator/mocks"
bundleMocks "github.com/aws/eks-anywhere-packages/pkg/bundle/mocks"
"github.com/aws/eks-anywhere-packages/pkg/config"
)
const (
testPreviousBundleName = "v1-21-1002"
testBundleName = "v1-21-1003"
testNextBundleName = "v1-21-1004"
testKubeMajor = "1"
testKubeMinor = "21"
testKubernetesVersion = "v1.21"
)
func GivenBundle(state api.PackageBundleStateEnum) *api.PackageBundle {
return &api.PackageBundle{
ObjectMeta: metav1.ObjectMeta{
Name: testBundleName,
Namespace: api.PackageNamespace,
},
Status: api.PackageBundleStatus{
State: state,
},
}
}
func givenBundleManager(t *testing.T) (*mocks.MockTargetClusterClient, *bundleMocks.MockRegistryClient, *bundleMocks.MockClient, *bundleManager) {
logger := testr.New(t)
ctrl := gomock.NewController(t)
tcc := mocks.NewMockTargetClusterClient(ctrl)
rc := bundleMocks.NewMockRegistryClient(ctrl)
bc := bundleMocks.NewMockClient(ctrl)
cfg := config.GetConfig()
cfg.BuildInfo.Version = "v2.2.2"
bm := NewBundleManager(logger, rc, bc, tcc, cfg)
return tcc, rc, bc, bm
}
func TestProcessBundle(t *testing.T) {
ctx := context.Background()
t.Run("ignore other namespaces", func(t *testing.T) {
_, _, _, bm := givenBundleManager(t)
bundle := GivenBundle("")
bundle.Namespace = "billy"
update, err := bm.ProcessBundle(ctx, bundle)
assert.True(t, update)
assert.Equal(t, nil, err)
assert.Equal(t, api.PackageBundleStateIgnored, bundle.Status.State)
})
t.Run("already ignore other namespaces", func(t *testing.T) {
_, _, _, bm := givenBundleManager(t)
bundle := GivenBundle(api.PackageBundleStateIgnored)
bundle.Namespace = "billy"
update, err := bm.ProcessBundle(ctx, bundle)
assert.False(t, update)
assert.Equal(t, nil, err)
assert.Equal(t, api.PackageBundleStateIgnored, bundle.Status.State)
})
t.Run("ignore invalid Kubernetes version", func(t *testing.T) {
_, _, _, bm := givenBundleManager(t)
bundle := GivenBundle(api.PackageBundleStateAvailable)
bundle.Name = "v1-21-x"
update, err := bm.ProcessBundle(ctx, bundle)
assert.True(t, update)
assert.Equal(t, nil, err)
assert.Equal(t, api.PackageBundleStateInvalid, bundle.Status.State)
})
t.Run("marks state available", func(t *testing.T) {
_, _, _, bm := givenBundleManager(t)
bundle := GivenBundle("")
update, err := bm.ProcessBundle(ctx, bundle)
assert.True(t, update)
assert.Equal(t, nil, err)
assert.Equal(t, api.PackageBundleStateAvailable, bundle.Status.State)
})
t.Run("already marked state available", func(t *testing.T) {
_, _, _, bm := givenBundleManager(t)
bundle := GivenBundle(api.PackageBundleStateAvailable)
bundle.Name = testPreviousBundleName
update, err := bm.ProcessBundle(ctx, bundle)
assert.False(t, update)
assert.Equal(t, nil, err)
assert.Equal(t, api.PackageBundleStateAvailable, bundle.Status.State)
})
t.Run("newer controller version required", func(t *testing.T) {
_, _, _, bm := givenBundleManager(t)
bundle := GivenBundle("")
bundle.Spec.MinVersion = "v4.4.4"
bundle.Name = testPreviousBundleName
update, err := bm.ProcessBundle(ctx, bundle)
assert.True(t, update)
assert.Equal(t, nil, err)
assert.Equal(t, api.PackageBundleStateUpgradeRequired, bundle.Status.State)
// No change results in no update needed
update, err = bm.ProcessBundle(ctx, bundle)
assert.False(t, update)
assert.Equal(t, nil, err)
assert.Equal(t, api.PackageBundleStateUpgradeRequired, bundle.Status.State)
// Bundle becomes available after upgrade
bm.config.BuildInfo.Version = "v4.4.5"
update, err = bm.ProcessBundle(ctx, bundle)
assert.True(t, update)
assert.Equal(t, nil, err)
assert.Equal(t, api.PackageBundleStateAvailable, bundle.Status.State)
})
}
func TestBundleManager_ProcessBundleController(t *testing.T) {
t.Parallel()
ctx := context.Background()
info := version.Info{
GitVersion: testKubernetesVersion,
Major: "1",
Minor: "21",
}
allBundles := []api.PackageBundle{
{
ObjectMeta: metav1.ObjectMeta{
Name: testBundleName,
},
},
{
ObjectMeta: metav1.ObjectMeta{
Name: "v1-21-1001",
},
},
}
t.Run("active to active", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
tcc.EXPECT().CreateClusterNamespace(ctx, pbc.Name).Return(nil)
tcc.EXPECT().ApplySecret(ctx, gomock.Any()).Return(nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateClusterConfigMap(ctx, pbc.Name).Return(nil)
bc.EXPECT().GetSecret(ctx, "aws-secret").Return(&corev1.Secret{}, nil)
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateActive, pbc.Status.State)
})
t.Run("active missing active bundle", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Spec.ActiveBundle = "v1-21-1002"
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
tcc.EXPECT().CreateClusterNamespace(ctx, pbc.Name).Return(nil)
bc.EXPECT().GetSecret(ctx, "aws-secret").Return(&corev1.Secret{}, nil)
tcc.EXPECT().ApplySecret(ctx, gomock.Any()).Return(nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateClusterConfigMap(ctx, pbc.Name).Return(nil)
rc.EXPECT().DownloadBundle(ctx, "public.ecr.aws/l0g8r8j6/eks-anywhere-packages-bundles:v1-21-1002", pbc.Name).Return(&allBundles[0], nil)
bc.EXPECT().CreateBundle(ctx, gomock.Any()).Return(nil)
bc.EXPECT().SaveStatus(ctx, pbc).Return(nil) // update available
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateUpgradeAvailable, pbc.Status.State)
})
t.Run("active missing active bundle download error", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Spec.ActiveBundle = "v1-21-1002"
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
tcc.EXPECT().CreateClusterNamespace(ctx, pbc.Name).Return(nil)
bc.EXPECT().GetSecret(ctx, "aws-secret").Return(&corev1.Secret{}, nil)
tcc.EXPECT().ApplySecret(ctx, gomock.Any()).Return(nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateClusterConfigMap(ctx, pbc.Name).Return(nil)
rc.EXPECT().DownloadBundle(ctx, "public.ecr.aws/l0g8r8j6/eks-anywhere-packages-bundles:v1-21-1002", pbc.Name).Return(&allBundles[0], fmt.Errorf("boom"))
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateActive, pbc.Status.State)
})
t.Run("active missing active bundle create error", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Spec.ActiveBundle = "v1-21-1002"
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
tcc.EXPECT().CreateClusterNamespace(ctx, pbc.Name).Return(nil)
bc.EXPECT().GetSecret(ctx, "aws-secret").Return(&corev1.Secret{}, nil)
tcc.EXPECT().ApplySecret(ctx, gomock.Any()).Return(nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateClusterConfigMap(ctx, pbc.Name).Return(nil)
rc.EXPECT().DownloadBundle(ctx, "public.ecr.aws/l0g8r8j6/eks-anywhere-packages-bundles:v1-21-1002", pbc.Name).Return(&allBundles[0], nil)
bc.EXPECT().CreateBundle(ctx, gomock.Any()).Return(fmt.Errorf("boom"))
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateActive, pbc.Status.State)
})
t.Run("active to active get bundles error", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
assert.Equal(t, pbc.Spec.ActiveBundle, testBundleName)
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(nil, fmt.Errorf("oops"))
err := bm.ProcessBundleController(ctx, pbc)
assert.EqualError(t, err, "getting bundle list: oops")
})
t.Run("active to disconnected", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
assert.Equal(t, pbc.Spec.ActiveBundle, testBundleName)
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, fmt.Errorf("ooops"))
bc.EXPECT().SaveStatus(ctx, pbc).Return(nil)
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateDisconnected, pbc.Status.State)
})
t.Run("disconnected to disconnected", func(t *testing.T) {
tcc, rc, _, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = api.BundleControllerStateDisconnected
assert.Equal(t, pbc.Spec.ActiveBundle, testBundleName)
latestBundle := givenBundle()
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, fmt.Errorf("ooops"))
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateDisconnected, pbc.Status.State)
})
t.Run("active to disconnected error", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
assert.Equal(t, pbc.Spec.ActiveBundle, testBundleName)
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, fmt.Errorf("ooops"))
bc.EXPECT().SaveStatus(ctx, pbc).Return(fmt.Errorf("oops"))
err := bm.ProcessBundleController(ctx, pbc)
assert.EqualError(t, err, "updating cluster01 status to disconnected: oops")
})
t.Run("active to upgradeAvailable", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
latestBundle := givenBundle()
latestBundle.Name = testNextBundleName
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
tcc.EXPECT().CreateClusterNamespace(ctx, pbc.GetName()).Return(nil)
bc.EXPECT().GetSecret(ctx, "aws-secret").Return(&corev1.Secret{}, nil)
tcc.EXPECT().ApplySecret(ctx, gomock.Any()).Return(nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateBundle(ctx, latestBundle).Return(nil)
bc.EXPECT().CreateClusterConfigMap(ctx, pbc.Name).Return(nil)
bc.EXPECT().SaveStatus(ctx, pbc).Return(nil)
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateUpgradeAvailable, pbc.Status.State)
})
t.Run("active to cm error", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
latestBundle := givenBundle()
latestBundle.Name = testNextBundleName
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateBundle(ctx, latestBundle).Return(nil)
bc.EXPECT().CreateClusterConfigMap(ctx, pbc.Name).Return(fmt.Errorf("boom"))
err := bm.ProcessBundleController(ctx, pbc)
assert.EqualError(t, err, "creating configmap for cluster01: boom")
})
t.Run("active to upgradeAvailable error", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
latestBundle := givenBundle()
latestBundle.Name = testNextBundleName
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
tcc.EXPECT().CreateClusterNamespace(ctx, pbc.Name).Return(nil)
bc.EXPECT().GetSecret(ctx, "aws-secret").Return(&corev1.Secret{}, nil)
tcc.EXPECT().ApplySecret(ctx, gomock.Any()).Return(nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateBundle(ctx, latestBundle).Return(nil)
bc.EXPECT().CreateClusterConfigMap(ctx, pbc.Name).Return(nil)
bc.EXPECT().SaveStatus(ctx, pbc).Return(fmt.Errorf("oops"))
err := bm.ProcessBundleController(ctx, pbc)
assert.EqualError(t, err, "updating cluster01 status to upgrade available: oops")
})
t.Run("active to upgradeAvailable create error", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
latestBundle := givenBundle()
latestBundle.Name = testNextBundleName
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateBundle(ctx, latestBundle).Return(fmt.Errorf("oops"))
err := bm.ProcessBundleController(ctx, pbc)
assert.EqualError(t, err, "oops")
})
t.Run("upgradeAvailable to upgradeAvailable", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = api.BundleControllerStateUpgradeAvailable
pbc.Status.Detail = "v1-21-1004 available"
latestBundle := givenBundle()
latestBundle.Name = testNextBundleName
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateBundle(ctx, latestBundle).Return(nil)
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateUpgradeAvailable, pbc.Status.State)
assert.Equal(t, "v1-21-1004 available", pbc.Status.Detail)
})
t.Run("upgradeAvailable to upgradeAvailable detail fix", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = api.BundleControllerStateUpgradeAvailable
pbc.Status.Detail = "v1-21-1003 available"
latestBundle := givenBundle()
latestBundle.Name = testNextBundleName
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateBundle(ctx, latestBundle).Return(nil)
bc.EXPECT().SaveStatus(ctx, pbc).Return(nil)
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateUpgradeAvailable, pbc.Status.State)
assert.Equal(t, "v1-21-1004 available", pbc.Status.Detail)
})
t.Run("upgradeAvailable to upgradeAvailable detail fix", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = api.BundleControllerStateUpgradeAvailable
pbc.Status.Detail = "v1-21-1003 available"
latestBundle := givenBundle()
latestBundle.Name = testNextBundleName
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateBundle(ctx, latestBundle).Return(nil)
bc.EXPECT().SaveStatus(ctx, pbc).Return(fmt.Errorf("oops"))
err := bm.ProcessBundleController(ctx, pbc)
assert.EqualError(t, err, "updating cluster01 detail to v1-21-1004 available: oops")
})
t.Run("upgradeAvailable to active", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = api.BundleControllerStateUpgradeAvailable
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().SaveStatus(ctx, pbc).Return(nil)
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateActive, pbc.Status.State)
assert.Equal(t, "", pbc.Status.Detail)
})
t.Run("upgradeAvailable to active error", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = api.BundleControllerStateUpgradeAvailable
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().SaveStatus(ctx, pbc).Return(fmt.Errorf("oops"))
err := bm.ProcessBundleController(ctx, pbc)
assert.EqualError(t, err, "updating cluster01 status to active: oops")
})
t.Run("disconnected to active", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = api.BundleControllerStateDisconnected
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().SaveStatus(ctx, pbc).Return(nil)
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateActive, pbc.Status.State)
})
t.Run("disconnected to active error", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = api.BundleControllerStateDisconnected
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().SaveStatus(ctx, pbc).Return(fmt.Errorf("oops"))
err := bm.ProcessBundleController(ctx, pbc)
assert.EqualError(t, err, "updating cluster01 status to active: oops")
})
t.Run("nothing to active bundle set", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = ""
pbc.Spec.ActiveBundle = ""
latestBundle := givenBundle()
latestBundle.Name = testNextBundleName
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
tcc.EXPECT().CreateClusterNamespace(ctx, pbc.GetName()).Return(nil).AnyTimes()
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateBundle(ctx, latestBundle).Return(nil)
bc.EXPECT().Save(ctx, pbc).Return(nil)
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateEnum(""), pbc.Status.State)
assert.Equal(t, testNextBundleName, pbc.Spec.ActiveBundle)
})
t.Run("nothing to active bundle save error", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = ""
pbc.Spec.ActiveBundle = ""
latestBundle := givenBundle()
latestBundle.Name = testNextBundleName
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateBundle(ctx, latestBundle).Return(nil)
bc.EXPECT().Save(ctx, pbc).Return(fmt.Errorf("oops"))
err := bm.ProcessBundleController(ctx, pbc)
assert.EqualError(t, err, "updating cluster01 activeBundle to v1-21-1004: oops")
})
t.Run("nothing to active state", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = ""
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).AnyTimes().Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().SaveStatus(ctx, pbc).Return(nil)
err := bm.ProcessBundleController(ctx, pbc)
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateActive, pbc.Status.State)
assert.Equal(t, testBundleName, pbc.Spec.ActiveBundle)
})
t.Run("nothing to active status save error", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
pbc.Status.State = ""
latestBundle := givenBundle()
latestBundle.Name = testNextBundleName
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).AnyTimes().Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateBundle(ctx, latestBundle).Return(nil)
bc.EXPECT().SaveStatus(ctx, pbc).Return(fmt.Errorf("oops"))
err := bm.ProcessBundleController(ctx, pbc)
assert.EqualError(t, err, "updating cluster01 status to active: oops")
})
t.Run("skip applying secret when pbc is mgmt", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
_ = os.Setenv("CLUSTER_NAME", pbc.Name)
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
tcc.EXPECT().CreateClusterNamespace(ctx, pbc.Name).Return(nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateClusterConfigMap(ctx, pbc.Name).Return(nil)
err := bm.ProcessBundleController(ctx, pbc)
_ = os.Setenv("CLUSTER_NAME", "")
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateActive, pbc.Status.State)
})
t.Run("active to active skip secret when pbc", func(t *testing.T) {
tcc, rc, bc, bm := givenBundleManager(t)
pbc := givenPackageBundleController()
_ = os.Setenv("CLUSTER_NAME", "other-cluster-name")
latestBundle := givenBundle()
tcc.EXPECT().GetServerVersion(ctx, pbc.Name).Return(&info, nil)
tcc.EXPECT().Initialize(ctx, gomock.Any()).Return(nil)
tcc.EXPECT().ToRESTConfig().Return(&rest.Config{}, nil)
tcc.EXPECT().CreateClusterNamespace(ctx, pbc.Name).Return(nil)
tcc.EXPECT().ApplySecret(ctx, gomock.Any()).Return(nil)
rc.EXPECT().LatestBundle(ctx, testBundleRegistry+"/eks-anywhere-packages-bundles", testKubeMajor, testKubeMinor, pbc.Name).Return(latestBundle, nil)
bc.EXPECT().GetBundleList(ctx).Return(allBundles, nil)
bc.EXPECT().CreateClusterConfigMap(ctx, pbc.Name).Return(nil)
bc.EXPECT().GetSecret(ctx, "aws-secret").Return(&corev1.Secret{}, nil)
err := bm.ProcessBundleController(ctx, pbc)
_ = os.Setenv("CLUSTER_NAME", "")
assert.NoError(t, err)
assert.Equal(t, api.BundleControllerStateActive, pbc.Status.State)
})
}
func TestBundleManager_isCompatible(t *testing.T) {
t.Parallel()
tests := map[string]struct {
minVersion string
curVersion string
isCompatible bool
}{
"same version": {minVersion: "v2.2.2", curVersion: "v2.2.2", isCompatible: true},
"development is compatible with anything": {minVersion: "v2.2.2", curVersion: "development", isCompatible: true},
"newer patch version requirement makes it incompatible": {minVersion: "v2.2.3", curVersion: "v2.2.2", isCompatible: false},
"newer minor version requirement makes it incompatible": {minVersion: "v2.3.2", curVersion: "v2.2.2", isCompatible: false},
"newer major version requirement makes it incompatible": {minVersion: "v3.2.2", curVersion: "v2.2.2", isCompatible: false},
"build info is irrelevant": {minVersion: "v2.2.2", curVersion: "v2.2.2+shasum", isCompatible: true},
"build info is irrelevant also if incompatible": {minVersion: "v2.2.3", curVersion: "v2.2.2+shasum", isCompatible: false},
"invalid pkg version is incompatible": {minVersion: "v2.2.3", curVersion: "2.2.3", isCompatible: false},
"both invalid version is compatible, I suppose?": {minVersion: "2.2.3", curVersion: "2.2.2", isCompatible: true},
"any version is compatible when no requirements imposed": {minVersion: "", curVersion: "2.2.2", isCompatible: true},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
_, _, _, bm := givenBundleManager(t)
latestBundle := givenBundle()
latestBundle.Spec.MinVersion = test.minVersion
bm.config.BuildInfo.Version = test.curVersion
assert.Equal(t, test.isCompatible, bm.isCompatibleWith(latestBundle))
})
}
}
| 694 |
eks-anywhere-packages | aws | Go | package bundle
import (
"bytes"
"context"
"fmt"
"sigs.k8s.io/yaml"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
"github.com/aws/eks-anywhere-packages/pkg/artifacts"
)
//go:generate mockgen -source registry_client.go -destination=mocks/registry_client.go -package=mocks RegistryClient
type RegistryClient interface {
// LatestBundle pulls the bundle tagged with "latest" from the bundle source.
LatestBundle(ctx context.Context, baseRef string, kubeMajor string, kubeMinor string, clusterName string) (*api.PackageBundle, error)
// DownloadBundle downloads the bundle with a given tag.
DownloadBundle(ctx context.Context, ref string, clusterName string) (
*api.PackageBundle, error)
}
type registryClient struct {
puller artifacts.Puller
}
func NewRegistryClient(puller artifacts.Puller) (manager *registryClient) {
return ®istryClient{
puller: puller,
}
}
var _ RegistryClient = (*registryClient)(nil)
// LatestBundle pulls the bundle tagged with "latest" from the bundle source.
//
// It returns an error if the bundle it retrieves is empty. This is because an
// empty file would be successfully parsed and a Zero-value PackageBundle
// returned, which is not acceptable.
func (rc *registryClient) LatestBundle(ctx context.Context, baseRef string, kubeMajor string, kubeMinor string, clusterName string) (*api.PackageBundle, error) {
tag := "latest"
ref := fmt.Sprintf("%s:v%s-%s-%s", baseRef, kubeMajor, kubeMinor, tag)
return rc.DownloadBundle(ctx, ref, clusterName)
}
func (rc *registryClient) DownloadBundle(ctx context.Context, ref string, clusterName string) (*api.PackageBundle, error) {
data, err := rc.puller.Pull(ctx, ref, clusterName)
if err != nil {
return nil, fmt.Errorf("pulling package bundle: %s", err)
}
if len(bytes.TrimSpace(data)) == 0 {
return nil, fmt.Errorf("package bundle artifact is empty")
}
bundle := &api.PackageBundle{}
err = yaml.Unmarshal(data, bundle)
if err != nil {
return nil, fmt.Errorf("unmarshalling package bundle: %s", err)
}
return bundle, nil
}
| 66 |
eks-anywhere-packages | aws | Go | package bundle
import (
"context"
"fmt"
"os"
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/assert"
"github.com/aws/eks-anywhere-packages/pkg/artifacts/mocks"
)
func TestDownloadBundle(t *testing.T) {
t.Parallel()
baseRef := "example.com/org"
t.Run("golden path", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
puller := mocks.NewMockPuller(gomock.NewController(t))
contents, err := os.ReadFile("../../api/testdata/bundle_one.yaml")
assert.NoError(t, err)
puller.EXPECT().Pull(ctx, "example.com/org:v1-21-latest", gomock.Any()).Return(contents, nil)
ecr := NewRegistryClient(puller)
kubeVersion := "v1-21"
tag := "latest"
ref := fmt.Sprintf("%s:%s-%s", baseRef, kubeVersion, tag)
bundle, err := ecr.DownloadBundle(ctx, ref, gomock.Any().String())
assert.NoError(t, err)
assert.NotNil(t, bundle)
assert.Equal(t, 3, len(bundle.Spec.Packages))
assert.Equal(t, "hello-eks-anywhere", bundle.Spec.Packages[0].Name)
assert.Equal(t, "flux", bundle.Spec.Packages[1].Name)
assert.Equal(t, "harbor", bundle.Spec.Packages[2].Name)
})
t.Run("handles pull errors", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
puller := mocks.NewMockPuller(gomock.NewController(t))
puller.EXPECT().Pull(ctx, "example.com/org:v1-21-latest", gomock.Any()).Return(nil, fmt.Errorf("test error"))
ecr := NewRegistryClient(puller)
kubeVersion := "v1-21"
tag := "latest"
ref := fmt.Sprintf("%s:%s-%s", baseRef, kubeVersion, tag)
_, err := ecr.DownloadBundle(ctx, ref, gomock.Any().String())
assert.EqualError(t, err, "pulling package bundle: test error")
})
t.Run("errors on empty responses", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
puller := mocks.NewMockPuller(gomock.NewController(t))
puller.EXPECT().Pull(ctx, "example.com/org:v1-21-latest", gomock.Any()).Return([]byte(""), nil)
ecr := NewRegistryClient(puller)
kubeVersion := "v1-21"
tag := "latest"
ref := fmt.Sprintf("%s:%s-%s", baseRef, kubeVersion, tag)
_, err := ecr.DownloadBundle(ctx, ref, gomock.Any().String())
assert.EqualError(t, err, "package bundle artifact is empty")
})
t.Run("handles YAML unmarshalling errors", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
puller := mocks.NewMockPuller(gomock.NewController(t))
puller.EXPECT().Pull(ctx, "example.com/org:v1-21-latest", gomock.Any()).Return([]byte("invalid yaml"), nil)
ecr := NewRegistryClient(puller)
kubeVersion := "v1-21"
tag := "latest"
ref := fmt.Sprintf("%s:%s-%s", baseRef, kubeVersion, tag)
_, err := ecr.DownloadBundle(ctx, ref, gomock.Any().String())
assert.EqualError(t, err, "unmarshalling package bundle: error unmarshaling JSON: while decoding JSON: json: cannot unmarshal string into Go value of type v1alpha1.PackageBundle")
})
}
func TestRegistryClient_LatestBundle(t *testing.T) {
t.Parallel()
ctx := context.Background()
t.Run("latest bundle error", func(t *testing.T) {
puller := mocks.NewMockPuller(gomock.NewController(t))
puller.EXPECT().Pull(ctx, "test:v1-21-latest", gomock.Any()).Return(nil, fmt.Errorf("oops"))
bm := NewRegistryClient(puller)
result, err := bm.LatestBundle(ctx, "test", "1", "21", "")
assert.EqualError(t, err, "pulling package bundle: oops")
assert.Nil(t, result)
})
}
| 112 |
eks-anywhere-packages | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: client.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
v1alpha1 "github.com/aws/eks-anywhere-packages/api/v1alpha1"
gomock "github.com/golang/mock/gomock"
v1 "k8s.io/api/core/v1"
client "sigs.k8s.io/controller-runtime/pkg/client"
)
// MockClient is a mock of Client interface.
type MockClient struct {
ctrl *gomock.Controller
recorder *MockClientMockRecorder
}
// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
mock *MockClient
}
// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
mock := &MockClient{ctrl: ctrl}
mock.recorder = &MockClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClient) EXPECT() *MockClientMockRecorder {
return m.recorder
}
// CreateBundle mocks base method.
func (m *MockClient) CreateBundle(ctx context.Context, bundle *v1alpha1.PackageBundle) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateBundle", ctx, bundle)
ret0, _ := ret[0].(error)
return ret0
}
// CreateBundle indicates an expected call of CreateBundle.
func (mr *MockClientMockRecorder) CreateBundle(ctx, bundle interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBundle", reflect.TypeOf((*MockClient)(nil).CreateBundle), ctx, bundle)
}
// CreateClusterConfigMap mocks base method.
func (m *MockClient) CreateClusterConfigMap(ctx context.Context, clusterName string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateClusterConfigMap", ctx, clusterName)
ret0, _ := ret[0].(error)
return ret0
}
// CreateClusterConfigMap indicates an expected call of CreateClusterConfigMap.
func (mr *MockClientMockRecorder) CreateClusterConfigMap(ctx, clusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClusterConfigMap", reflect.TypeOf((*MockClient)(nil).CreateClusterConfigMap), ctx, clusterName)
}
// CreatePackage mocks base method.
func (m *MockClient) CreatePackage(ctx context.Context, pkg *v1alpha1.Package) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreatePackage", ctx, pkg)
ret0, _ := ret[0].(error)
return ret0
}
// CreatePackage indicates an expected call of CreatePackage.
func (mr *MockClientMockRecorder) CreatePackage(ctx, pkg interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePackage", reflect.TypeOf((*MockClient)(nil).CreatePackage), ctx, pkg)
}
// GetActiveBundle mocks base method.
func (m *MockClient) GetActiveBundle(ctx context.Context, clusterName string) (*v1alpha1.PackageBundle, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetActiveBundle", ctx, clusterName)
ret0, _ := ret[0].(*v1alpha1.PackageBundle)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetActiveBundle indicates an expected call of GetActiveBundle.
func (mr *MockClientMockRecorder) GetActiveBundle(ctx, clusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveBundle", reflect.TypeOf((*MockClient)(nil).GetActiveBundle), ctx, clusterName)
}
// GetBundle mocks base method.
func (m *MockClient) GetBundle(ctx context.Context, name string) (*v1alpha1.PackageBundle, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetBundle", ctx, name)
ret0, _ := ret[0].(*v1alpha1.PackageBundle)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetBundle indicates an expected call of GetBundle.
func (mr *MockClientMockRecorder) GetBundle(ctx, name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBundle", reflect.TypeOf((*MockClient)(nil).GetBundle), ctx, name)
}
// GetBundleList mocks base method.
func (m *MockClient) GetBundleList(ctx context.Context) ([]v1alpha1.PackageBundle, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetBundleList", ctx)
ret0, _ := ret[0].([]v1alpha1.PackageBundle)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetBundleList indicates an expected call of GetBundleList.
func (mr *MockClientMockRecorder) GetBundleList(ctx interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBundleList", reflect.TypeOf((*MockClient)(nil).GetBundleList), ctx)
}
// GetPackageBundleController mocks base method.
func (m *MockClient) GetPackageBundleController(ctx context.Context, clusterName string) (*v1alpha1.PackageBundleController, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPackageBundleController", ctx, clusterName)
ret0, _ := ret[0].(*v1alpha1.PackageBundleController)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPackageBundleController indicates an expected call of GetPackageBundleController.
func (mr *MockClientMockRecorder) GetPackageBundleController(ctx, clusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPackageBundleController", reflect.TypeOf((*MockClient)(nil).GetPackageBundleController), ctx, clusterName)
}
// GetPackageList mocks base method.
func (m *MockClient) GetPackageList(ctx context.Context, namespace string) (v1alpha1.PackageList, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPackageList", ctx, namespace)
ret0, _ := ret[0].(v1alpha1.PackageList)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPackageList indicates an expected call of GetPackageList.
func (mr *MockClientMockRecorder) GetPackageList(ctx, namespace interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPackageList", reflect.TypeOf((*MockClient)(nil).GetPackageList), ctx, namespace)
}
// GetSecret mocks base method.
func (m *MockClient) GetSecret(ctx context.Context, name string) (*v1.Secret, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetSecret", ctx, name)
ret0, _ := ret[0].(*v1.Secret)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetSecret indicates an expected call of GetSecret.
func (mr *MockClientMockRecorder) GetSecret(ctx, name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecret", reflect.TypeOf((*MockClient)(nil).GetSecret), ctx, name)
}
// Save mocks base method.
func (m *MockClient) Save(ctx context.Context, object client.Object) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Save", ctx, object)
ret0, _ := ret[0].(error)
return ret0
}
// Save indicates an expected call of Save.
func (mr *MockClientMockRecorder) Save(ctx, object interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockClient)(nil).Save), ctx, object)
}
// SaveStatus mocks base method.
func (m *MockClient) SaveStatus(ctx context.Context, object client.Object) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SaveStatus", ctx, object)
ret0, _ := ret[0].(error)
return ret0
}
// SaveStatus indicates an expected call of SaveStatus.
func (mr *MockClientMockRecorder) SaveStatus(ctx, object interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveStatus", reflect.TypeOf((*MockClient)(nil).SaveStatus), ctx, object)
}
| 199 |
eks-anywhere-packages | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: manager.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
v1alpha1 "github.com/aws/eks-anywhere-packages/api/v1alpha1"
gomock "github.com/golang/mock/gomock"
)
// MockManager is a mock of Manager interface.
type MockManager struct {
ctrl *gomock.Controller
recorder *MockManagerMockRecorder
}
// MockManagerMockRecorder is the mock recorder for MockManager.
type MockManagerMockRecorder struct {
mock *MockManager
}
// NewMockManager creates a new mock instance.
func NewMockManager(ctrl *gomock.Controller) *MockManager {
mock := &MockManager{ctrl: ctrl}
mock.recorder = &MockManagerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockManager) EXPECT() *MockManagerMockRecorder {
return m.recorder
}
// ProcessBundle mocks base method.
func (m *MockManager) ProcessBundle(ctx context.Context, newBundle *v1alpha1.PackageBundle) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ProcessBundle", ctx, newBundle)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ProcessBundle indicates an expected call of ProcessBundle.
func (mr *MockManagerMockRecorder) ProcessBundle(ctx, newBundle interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessBundle", reflect.TypeOf((*MockManager)(nil).ProcessBundle), ctx, newBundle)
}
// ProcessBundleController mocks base method.
func (m *MockManager) ProcessBundleController(ctx context.Context, pbc *v1alpha1.PackageBundleController) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ProcessBundleController", ctx, pbc)
ret0, _ := ret[0].(error)
return ret0
}
// ProcessBundleController indicates an expected call of ProcessBundleController.
func (mr *MockManagerMockRecorder) ProcessBundleController(ctx, pbc interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessBundleController", reflect.TypeOf((*MockManager)(nil).ProcessBundleController), ctx, pbc)
}
| 66 |
eks-anywhere-packages | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: registry_client.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
v1alpha1 "github.com/aws/eks-anywhere-packages/api/v1alpha1"
gomock "github.com/golang/mock/gomock"
)
// MockRegistryClient is a mock of RegistryClient interface.
type MockRegistryClient struct {
ctrl *gomock.Controller
recorder *MockRegistryClientMockRecorder
}
// MockRegistryClientMockRecorder is the mock recorder for MockRegistryClient.
type MockRegistryClientMockRecorder struct {
mock *MockRegistryClient
}
// NewMockRegistryClient creates a new mock instance.
func NewMockRegistryClient(ctrl *gomock.Controller) *MockRegistryClient {
mock := &MockRegistryClient{ctrl: ctrl}
mock.recorder = &MockRegistryClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRegistryClient) EXPECT() *MockRegistryClientMockRecorder {
return m.recorder
}
// DownloadBundle mocks base method.
func (m *MockRegistryClient) DownloadBundle(ctx context.Context, ref, clusterName string) (*v1alpha1.PackageBundle, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DownloadBundle", ctx, ref, clusterName)
ret0, _ := ret[0].(*v1alpha1.PackageBundle)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DownloadBundle indicates an expected call of DownloadBundle.
func (mr *MockRegistryClientMockRecorder) DownloadBundle(ctx, ref, clusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBundle", reflect.TypeOf((*MockRegistryClient)(nil).DownloadBundle), ctx, ref, clusterName)
}
// LatestBundle mocks base method.
func (m *MockRegistryClient) LatestBundle(ctx context.Context, baseRef, kubeMajor, kubeMinor, clusterName string) (*v1alpha1.PackageBundle, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "LatestBundle", ctx, baseRef, kubeMajor, kubeMinor, clusterName)
ret0, _ := ret[0].(*v1alpha1.PackageBundle)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// LatestBundle indicates an expected call of LatestBundle.
func (mr *MockRegistryClientMockRecorder) LatestBundle(ctx, baseRef, kubeMajor, kubeMinor, clusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestBundle", reflect.TypeOf((*MockRegistryClient)(nil).LatestBundle), ctx, baseRef, kubeMajor, kubeMinor, clusterName)
}
| 67 |
eks-anywhere-packages | aws | Go | package config
import (
"strconv"
"time"
)
const (
DEVELOPMENT = "development"
HEAD = "HEAD"
EPOCH = "0"
)
var config Config
var version = DEVELOPMENT
var gitHash = HEAD
var buildTime = EPOCH
type Config struct {
BuildInfo BuildInfo
Env BuildInfo
}
type BuildInfo struct {
Version string
GitHash string
BuildTime time.Time
}
func init() {
config = GetConfig()
}
func GetGlobalConfig() Config {
return config
}
func GetConfig() Config {
btime, err := strconv.ParseInt(buildTime, 10, 64)
if err != nil {
btime = 0
}
return Config{
BuildInfo: BuildInfo{
Version: version,
GitHash: gitHash,
BuildTime: time.Unix(btime, 0),
},
}
}
| 53 |
eks-anywhere-packages | aws | Go | package csset
import (
"strings"
"sync"
)
// CSSet is a comma-separated set of strings.
type CSSet struct {
mu sync.Mutex
set map[string]struct{}
}
func NewCSSet(s string) *CSSet {
c := &CSSet{
set: make(map[string]struct{}),
}
if s == "" {
return c
}
for _, value := range strings.Split(s, ",") {
c.Add(value)
}
return c
}
func (c *CSSet) Add(value string) {
c.mu.Lock()
defer c.mu.Unlock()
c.set[value] = struct{}{}
}
func (c *CSSet) Del(value string) {
c.mu.Lock()
defer c.mu.Unlock()
delete(c.set, value)
}
func (c *CSSet) Has(value string) bool {
c.mu.Lock()
defer c.mu.Unlock()
_, found := c.set[value]
return found
}
func (c *CSSet) Size() int {
c.mu.Lock()
defer c.mu.Unlock()
return len(c.set)
}
func (c *CSSet) String() string {
out := []string{}
c.mu.Lock()
defer c.mu.Unlock()
for key := range c.set {
out = append(out, key)
}
return strings.Join(out, ",")
}
| 62 |
eks-anywhere-packages | aws | Go | package csset
import (
"strings"
"testing"
"github.com/stretchr/testify/assert"
)
func TestCSSetEmptyInit(t *testing.T) {
set := NewCSSet("")
assert.Equal(t, "", set.String())
}
func TestCSSetContentsInit(t *testing.T) {
set := NewCSSet("one,three,two")
n := struct{}{}
assert.ObjectsAreEqual(map[string]struct{}{
"one": n, "two": n, "three": n},
set.set)
}
func TestCSSetAdd(t *testing.T) {
set := NewCSSet("")
set.Add("one")
assert.Equal(t, "one", set.String())
}
func TestCSSetTwo(t *testing.T) {
set := NewCSSet("")
set.Add("one")
set.Add("two")
exp := [2]string{"one", "two"}
res := strings.Split(set.String(), ",")
assert.ElementsMatch(t, exp, res)
}
func TestCSSetDel(t *testing.T) {
set := NewCSSet("one,two")
set.Del("one")
assert.Equal(t, "two", set.String())
}
func TestCSSetHas(t *testing.T) {
set := NewCSSet("one,two")
assert.True(t, set.Has("one"))
assert.True(t, set.Has("two"))
assert.False(t, set.Has("three"))
}
func TestCSSetDelNotExists(t *testing.T) {
set := NewCSSet("one,two")
assert.NotPanics(t, func() { set.Del("three") })
}
func TestCSSetLenZero(t *testing.T) {
set := NewCSSet("")
assert.Zero(t, set.Size())
}
func TestCSSetLenTwo(t *testing.T) {
set := NewCSSet("one,two")
assert.Equal(t, 2, set.Size())
}
| 65 |
eks-anywhere-packages | aws | Go | package driver
import (
"context"
"errors"
"fmt"
"os"
"reflect"
"strings"
"github.com/go-logr/logr"
"helm.sh/helm/v3/pkg/action"
"helm.sh/helm/v3/pkg/chart"
"helm.sh/helm/v3/pkg/chart/loader"
"helm.sh/helm/v3/pkg/cli"
"helm.sh/helm/v3/pkg/registry"
"helm.sh/helm/v3/pkg/storage/driver"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
auth "github.com/aws/eks-anywhere-packages/pkg/authenticator"
packagesRegistry "github.com/aws/eks-anywhere-packages/pkg/registry"
)
const (
varHelmUpgradeMaxHistory = 2
)
// helmDriver implements PackageDriver to install packages from Helm charts.
type helmDriver struct {
cfg *action.Configuration
secretAuth auth.Authenticator
tcc auth.TargetClusterClient
log logr.Logger
settings *cli.EnvSettings
}
var _ PackageDriver = (*helmDriver)(nil)
func NewHelm(log logr.Logger, secretAuth auth.Authenticator, tcc auth.TargetClusterClient) *helmDriver {
return &helmDriver{
secretAuth: secretAuth,
tcc: tcc,
log: log,
}
}
func (d *helmDriver) Initialize(ctx context.Context, clusterName string) (err error) {
err = d.secretAuth.Initialize(clusterName)
if err != nil {
d.log.Info("failed to change target cluster for secrets")
}
err = d.tcc.Initialize(ctx, clusterName)
if err != nil {
return fmt.Errorf("initialiing target cluster %s client for helm driver: %w", clusterName, err)
}
d.settings = cli.New()
insecure := packagesRegistry.GetRegistryInsecure(clusterName)
caFile := packagesRegistry.GetClusterCertificateFileName(clusterName)
client, err := newRegistryClient("", "", caFile, insecure, d.settings)
if err != nil {
return fmt.Errorf("creating registry client for helm driver: %w", err)
}
d.cfg = &action.Configuration{RegistryClient: client}
err = d.cfg.Init(d.tcc, d.settings.Namespace(), os.Getenv("HELM_DRIVER"), helmLog(d.log))
if err != nil {
return fmt.Errorf("initializing helm driver: %w", err)
}
return nil
}
func (d *helmDriver) Install(ctx context.Context,
name string, namespace string, createNamespace bool, source api.PackageOCISource, values map[string]interface{},
) error {
var err error
install := action.NewInstall(d.cfg)
install.Version = source.Version
install.ReleaseName = name
install.CreateNamespace = createNamespace
helmChart, err := d.getChart(install, source)
if err != nil {
return fmt.Errorf("loading helm chart %s: %w", name, err)
}
// If no target namespace provided read chart values to find namespace
if namespace == "" {
if chartNS, ok := helmChart.Values["defaultNamespace"]; ok {
namespace = chartNS.(string)
} else {
// Fall back case of assuming its default
namespace = "default"
}
}
install.Namespace = namespace
// Update values with imagePullSecrets
// If no secret values we should still continue as it could be case of public registry or local registry
secretvals, err := d.secretAuth.GetSecretValues(ctx, namespace)
if err != nil {
secretvals = nil
// Continue as its possible that a private registry is being used here and thus no data necessary
}
for key, val := range secretvals {
values[key] = val
}
// Check if there exists a matching helm release.
get := action.NewGet(d.cfg)
_, err = get.Run(name)
if err != nil {
if errors.Is(err, driver.ErrReleaseNotFound) {
// Trigger configmap updates and namespace before trying to install charts
if err := d.secretAuth.AddToConfigMap(ctx, name, namespace); err != nil {
d.log.Info("failed to Update ConfigMap with installed namespace", "error", err)
}
if err := d.secretAuth.AddSecretToAllNamespace(ctx); err != nil {
d.log.Info("failed to Update Secret in all namespaces", "error", err)
}
err = d.createRelease(ctx, install, helmChart, values)
if err != nil {
err1 := d.secretAuth.DelFromConfigMap(ctx, name, namespace)
if err1 != nil {
d.log.Info("failed to remove namespace from configmap")
}
return err
}
// Failsafe in event namespace is created via the charts
if err := d.secretAuth.AddSecretToAllNamespace(ctx); err != nil {
d.log.Info("failed to Update Secret in all namespaces", "error", err)
}
return nil
}
return fmt.Errorf("getting helm release %s: %w", name, err)
}
err = d.upgradeRelease(ctx, name, helmChart, values)
if err != nil {
return fmt.Errorf("upgrading helm chart %s: %w", name, err)
}
// Update installed-namespaces on successful install
err = d.secretAuth.AddToConfigMap(ctx, name, namespace)
if err != nil {
d.log.Info("failed to Update ConfigMap with installed namespace", "error", err)
}
if err := d.secretAuth.AddSecretToAllNamespace(ctx); err != nil {
d.log.Info("failed to Update Secret in all namespaces", "error", err)
}
err = d.upgradeRelease(ctx, name, helmChart, values)
if err != nil {
return fmt.Errorf("upgrading helm chart %s: %w", name, err)
}
if err := d.secretAuth.AddSecretToAllNamespace(ctx); err != nil {
d.log.Info("failed to Update Secret in all namespaces", "error", err)
}
return nil
}
func (d *helmDriver) getChart(install *action.Install, source api.PackageOCISource) (*chart.Chart, error) {
url := source.GetChartUri()
chartPath, err := install.LocateChart(url, d.settings)
if err != nil {
return nil, fmt.Errorf("locating helm chart %s tag %s: %w", url, source.Digest, err)
}
return loader.Load(chartPath)
}
func (d *helmDriver) createRelease(ctx context.Context,
install *action.Install, helmChart *chart.Chart, values map[string]interface{},
) error {
_, err := install.RunWithContext(ctx, helmChart, values)
if err != nil {
return fmt.Errorf("installing helm chart %s: %w", install.ReleaseName, err)
}
return nil
}
// helmChartURLIsPrefixed detects if the given URL has an acceptable scheme
// prefix.
func helmChartURLIsPrefixed(url string) bool {
return strings.HasPrefix(url, "https://") ||
strings.HasPrefix(url, "http://") ||
strings.HasPrefix(url, "oci://")
}
// upgradeRelease instructs helm to upgrade a release.
func (d *helmDriver) upgradeRelease(ctx context.Context, name string,
helmChart *chart.Chart, values map[string]interface{},
) (err error) {
// upgrade unless changes in the values are detected. For POC, run helm
// every time and rely on its idempotency.
upgrade := action.NewUpgrade(d.cfg)
// Limit history saved as secret for resource limit
upgrade.MaxHistory = varHelmUpgradeMaxHistory
_, err = upgrade.RunWithContext(ctx, name, helmChart, values)
if err != nil {
return fmt.Errorf("upgrading helm release %s: %w", name, err)
}
return nil
}
func (d *helmDriver) Uninstall(ctx context.Context, name string) (err error) {
uninstall := action.NewUninstall(d.cfg)
rel, err := uninstall.Run(name)
if err != nil {
if errors.Is(err, driver.ErrReleaseNotFound) {
return nil
}
return fmt.Errorf("uninstalling helm chart %s: %w", name, err)
}
err = d.secretAuth.DelFromConfigMap(ctx, name, rel.Release.Namespace)
if err != nil {
d.log.Info("failed to remove namespace from configmap")
}
return nil
}
// helmLog wraps logr.Logger to make it compatible with helm's DebugLog.
func helmLog(log logr.Logger) action.DebugLog {
return func(template string, args ...interface{}) {
log.Info(fmt.Sprintf(template, args...))
}
}
func (d *helmDriver) IsConfigChanged(_ context.Context, name string, values map[string]interface{}) (bool, error) {
get := action.NewGet(d.cfg)
rel, err := get.Run(name)
if err != nil {
d.log.Info("Installation not found %q: %w", name, err)
return true, nil
}
// Check imagePullSecret not defined in config
if _, exist := values["imagePullSecrets"]; !exist {
// Check if imagePullSecrets was added by driver
if val, ok := rel.Config["imagePullSecrets"]; ok {
values["imagePullSecrets"] = val
}
}
return !reflect.DeepEqual(values, rel.Config), nil
}
func newRegistryClient(certFile, keyFile, caFile string, insecureSkipTLSverify bool, settings *cli.EnvSettings) (*registry.Client, error) {
if certFile != "" && keyFile != "" || caFile != "" || !insecureSkipTLSverify {
registryClient, err := newRegistryClientWithTLS(certFile, keyFile, caFile, insecureSkipTLSverify, settings)
if err != nil {
return nil, err
}
return registryClient, nil
}
registryClient, err := newDefaultRegistryClient(settings)
if err != nil {
return nil, err
}
return registryClient, nil
}
func newDefaultRegistryClient(settings *cli.EnvSettings) (*registry.Client, error) {
// Create a new registry client
registryClient, err := registry.NewClient(
registry.ClientOptDebug(settings.Debug),
registry.ClientOptEnableCache(false),
registry.ClientOptWriter(os.Stderr),
registry.ClientOptCredentialsFile(settings.RegistryConfig),
)
if err != nil {
return nil, err
}
return registryClient, nil
}
func newRegistryClientWithTLS(certFile, keyFile, caFile string, insecureSkipTLSverify bool, settings *cli.EnvSettings) (*registry.Client, error) {
// Create a new registry client
registryClient, err := registry.NewRegistryClientWithTLS(os.Stderr, certFile, keyFile, caFile, insecureSkipTLSverify,
settings.RegistryConfig, settings.Debug,
)
if err != nil {
return nil, err
}
return registryClient, nil
}
| 291 |
eks-anywhere-packages | aws | Go | package driver
import (
"context"
"fmt"
"testing"
"github.com/go-logr/logr"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v3/pkg/kube"
"helm.sh/helm/v3/pkg/release"
"github.com/aws/eks-anywhere-packages/pkg/authenticator/mocks"
)
var ctx context.Context = context.Background()
func TestHelmChartURLIsPrefixed(t *testing.T) {
t.Run("https yes", func(t *testing.T) {
t.Parallel()
assert.True(t, helmChartURLIsPrefixed("https://foo"))
})
t.Run("http yes", func(t *testing.T) {
t.Parallel()
assert.True(t, helmChartURLIsPrefixed("http://foo"))
})
t.Run("oci yes", func(t *testing.T) {
t.Parallel()
assert.True(t, helmChartURLIsPrefixed("oci://foo"))
})
t.Run("boo no", func(t *testing.T) {
t.Parallel()
assert.False(t, helmChartURLIsPrefixed("boo://foo"))
})
}
func TestHelmDriverInitialize(t *testing.T) {
t.Run("golden path", func(t *testing.T) {
t.Parallel()
helm := givenHelmDriver(t)
err := helm.Initialize(ctx, "billy")
assert.NoError(t, err)
})
}
func TestIsConfigChanged(t *testing.T) {
t.Run("returns an error when the resource isn't found", func(t *testing.T) {
t.Parallel()
values := map[string]interface{}{}
helm, err := givenInitializedHelmDriver(t)
require.NoError(t, err)
helm.cfg.KubeClient = newMockKube(fmt.Errorf("blah"))
changed, err := helm.IsConfigChanged(ctx, "name-does-not-exist", values)
assert.NoError(t, err)
assert.True(t, changed)
})
t.Run("golden path returning true", func(t *testing.T) {
t.Parallel()
const foo = 1
origValues := map[string]interface{}{"foo": foo, "bar": true}
newValues := shallowCopy(t, origValues)
newValues["foo"] = foo + 1
rel := &release.Release{Config: newValues}
helm, err := givenInitializedHelmDriver(t)
require.NoError(t, err)
helm.cfg.KubeClient = newMockKube(nil)
helm.cfg.Releases.Driver = newMockReleasesDriver(rel, nil)
changed, err := helm.IsConfigChanged(ctx, "name-does-not-matter", origValues)
assert.NoError(t, err)
assert.True(t, changed)
})
t.Run("golden path returning false", func(t *testing.T) {
t.Parallel()
origValues := map[string]interface{}{"foo": 1, "bar": true}
sameValues := shallowCopy(t, origValues)
rel := &release.Release{Config: sameValues}
helm, err := givenInitializedHelmDriver(t)
require.NoError(t, err)
helm.cfg.KubeClient = newMockKube(nil)
helm.cfg.Releases.Driver = newMockReleasesDriver(rel, nil)
changed, err := helm.IsConfigChanged(ctx, "name-does-not-matter", origValues)
assert.NoError(t, err)
assert.False(t, changed)
})
t.Run("golden path returning false with imagePullSecret added", func(t *testing.T) {
t.Parallel()
const foo = 1
origValues := map[string]interface{}{"foo": foo, "bar": true}
newValues := shallowCopy(t, origValues)
newValues["imagePullSecrets"] = "test"
rel := &release.Release{Config: newValues}
helm, err := givenInitializedHelmDriver(t)
assert.NoError(t, err)
helm.cfg.KubeClient = newMockKube(nil)
helm.cfg.Releases.Driver = newMockReleasesDriver(rel, nil)
changed, err := helm.IsConfigChanged(ctx, "name-does-not-matter", origValues)
assert.NoError(t, err)
assert.False(t, changed)
})
t.Run("golden path returning true with imagePullSecret via config", func(t *testing.T) {
t.Parallel()
const foo = 1
origValues := map[string]interface{}{"foo": foo, "bar": true}
newValues := shallowCopy(t, origValues)
origValues["imagePullSecrets"] = "test"
rel := &release.Release{Config: newValues}
helm, err := givenInitializedHelmDriver(t)
require.NoError(t, err)
helm.cfg.KubeClient = newMockKube(nil)
helm.cfg.Releases.Driver = newMockReleasesDriver(rel, nil)
changed, err := helm.IsConfigChanged(ctx, "name-does-not-matter", origValues)
assert.NoError(t, err)
assert.True(t, changed)
})
}
func givenHelmDriver(t *testing.T) *helmDriver {
mockSecretAuth := mocks.NewMockAuthenticator(gomock.NewController(t))
mockSecretAuth.EXPECT().Initialize("billy")
mockTargetClusterClient := mocks.NewMockTargetClusterClient(gomock.NewController(t))
mockTargetClusterClient.EXPECT().Initialize(ctx, "billy")
return NewHelm(logr.Discard(), mockSecretAuth, mockTargetClusterClient)
}
func givenInitializedHelmDriver(t *testing.T) (*helmDriver, error) {
helm := givenHelmDriver(t)
err := helm.Initialize(ctx, "billy")
return helm, err
}
type mockKube struct {
kube.Interface
err error
}
func newMockKube(err error) *mockKube {
return &mockKube{err: err}
}
func (k *mockKube) IsReachable() error {
if k.err != nil {
return fmt.Errorf("IsReachable test error %w", k.err)
}
return nil
}
type mockReleasesDriver struct {
release *release.Release
err error
}
func newMockReleasesDriver(release *release.Release, err error) *mockReleasesDriver {
return &mockReleasesDriver{
release: release,
err: err,
}
}
// generated via
// impl -dir $GOPATH/pkg/mod/helm.sh/helm/[email protected]/pkg/storage 'd *mockReleasesDriver' driver.Driver
func (d *mockReleasesDriver) Create(key string, rls *release.Release) error {
panic("not implemented") // TODO: Implement
}
func (d *mockReleasesDriver) Update(key string, rls *release.Release) error {
panic("not implemented") // TODO: Implement
}
func (d *mockReleasesDriver) Delete(key string) (*release.Release, error) {
panic("not implemented") // TODO: Implement
}
func (d *mockReleasesDriver) Get(key string) (*release.Release, error) {
if d.err != nil {
return nil, d.err
}
return d.release, nil
}
func (d *mockReleasesDriver) List(filter func(*release.Release) bool) ([]*release.Release, error) {
panic("not implemented") // TODO: Implement
}
func (d *mockReleasesDriver) Query(labels map[string]string) ([]*release.Release, error) {
if d.err != nil {
return nil, d.err
}
return []*release.Release{d.release}, nil
}
func (d *mockReleasesDriver) Name() string {
panic("not implemented") // TODO: Implement
}
func shallowCopy(t *testing.T, src map[string]interface{}) map[string]interface{} {
t.Helper()
dst := make(map[string]interface{}, len(src))
for key, value := range src {
dst[key] = value
}
return dst
}
| 231 |
eks-anywhere-packages | aws | Go | package driver
import (
"context"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
)
//go:generate mockgen -source packagedriver.go -destination=mocks/packagedriver.go -package=mocks PackageDriver
// PackageDriver is an interface for converting a CRD to a series of Kubernetes
// objects.
//
// Its first implementation will be Helm, but the interface is used to enhance
// and simplify testing as well as abstract the details of Helm.
type PackageDriver interface {
// Initialize the package driver
Initialize(ctx context.Context, clusterName string) error
// Install or upgrade an package.
Install(ctx context.Context, name string, namespace string, createNamespace bool, source api.PackageOCISource, values map[string]interface{}) error
// Uninstall an package.
Uninstall(ctx context.Context, name string) error
// IsConfigChanged indicates that the values passed differ from
// those currently running.
IsConfigChanged(ctx context.Context, name string,
values map[string]interface{}) (bool, error)
}
| 31 |
eks-anywhere-packages | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: packagedriver.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
v1alpha1 "github.com/aws/eks-anywhere-packages/api/v1alpha1"
gomock "github.com/golang/mock/gomock"
)
// MockPackageDriver is a mock of PackageDriver interface.
type MockPackageDriver struct {
ctrl *gomock.Controller
recorder *MockPackageDriverMockRecorder
}
// MockPackageDriverMockRecorder is the mock recorder for MockPackageDriver.
type MockPackageDriverMockRecorder struct {
mock *MockPackageDriver
}
// NewMockPackageDriver creates a new mock instance.
func NewMockPackageDriver(ctrl *gomock.Controller) *MockPackageDriver {
mock := &MockPackageDriver{ctrl: ctrl}
mock.recorder = &MockPackageDriverMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPackageDriver) EXPECT() *MockPackageDriverMockRecorder {
return m.recorder
}
// Initialize mocks base method.
func (m *MockPackageDriver) Initialize(ctx context.Context, clusterName string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Initialize", ctx, clusterName)
ret0, _ := ret[0].(error)
return ret0
}
// Initialize indicates an expected call of Initialize.
func (mr *MockPackageDriverMockRecorder) Initialize(ctx, clusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockPackageDriver)(nil).Initialize), ctx, clusterName)
}
// Install mocks base method.
func (m *MockPackageDriver) Install(ctx context.Context, name, namespace string, createNamespace bool, source v1alpha1.PackageOCISource, values map[string]interface{}) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Install", ctx, name, namespace, createNamespace, source, values)
ret0, _ := ret[0].(error)
return ret0
}
// Install indicates an expected call of Install.
func (mr *MockPackageDriverMockRecorder) Install(ctx, name, namespace, createNamespace, source, values interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Install", reflect.TypeOf((*MockPackageDriver)(nil).Install), ctx, name, namespace, createNamespace, source, values)
}
// IsConfigChanged mocks base method.
func (m *MockPackageDriver) IsConfigChanged(ctx context.Context, name string, values map[string]interface{}) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsConfigChanged", ctx, name, values)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// IsConfigChanged indicates an expected call of IsConfigChanged.
func (mr *MockPackageDriverMockRecorder) IsConfigChanged(ctx, name, values interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConfigChanged", reflect.TypeOf((*MockPackageDriver)(nil).IsConfigChanged), ctx, name, values)
}
// Uninstall mocks base method.
func (m *MockPackageDriver) Uninstall(ctx context.Context, name string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Uninstall", ctx, name)
ret0, _ := ret[0].(error)
return ret0
}
// Uninstall indicates an expected call of Uninstall.
func (mr *MockPackageDriverMockRecorder) Uninstall(ctx, name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Uninstall", reflect.TypeOf((*MockPackageDriver)(nil).Uninstall), ctx, name)
}
| 94 |
eks-anywhere-packages | aws | Go | package file
import (
"bytes"
"fmt"
"os"
"sigs.k8s.io/yaml"
)
const (
yamlSeparator = "\n---\n"
)
// KindAccessor exposes the Kind field for Cluster type.
//
// The FileReader will compare the Kind field (accessed via MetaKind()) with the
// result of ExpectedKind() to ensure that the data we unmarshaled was meant for
// a struct of the correct type. That is, it prevents us from unmarshaling bytes
// meant for a Foo struct into a Bar struct.
type KindAccessor interface {
// MetaKind is the kind actually read when unmarshaling from a file.
MetaKind() string
// ExpectedKind is the kind we expect to read while unmarshaling.
ExpectedKind() string
}
type FileReader struct {
fileName string
clusterConfigs map[string][]byte
}
func NewFileReader(fileName string) *FileReader {
return &FileReader{
fileName: fileName,
clusterConfigs: map[string][]byte{},
}
}
// sliceYAML returns a slice of YAML documents from a file.
func (reader *FileReader) sliceYAML() ([][]byte, error) {
content, err := os.ReadFile(reader.fileName)
if err != nil {
return nil, err
}
return bytes.Split(content, []byte(yamlSeparator)), nil
}
func (reader *FileReader) Initialize(clusterConfig KindAccessor) error {
yamls, err := reader.sliceYAML()
if err != nil {
return fmt.Errorf("reading <%s>: %v", reader.fileName, err)
}
for _, config := range yamls {
if err = yaml.Unmarshal(config, clusterConfig); err != nil {
return fmt.Errorf("error parsing <%s>:\n%s", reader.fileName, config)
}
reader.clusterConfigs[clusterConfig.MetaKind()] = config
}
return nil
}
func (reader *FileReader) Parse(clusterConfig KindAccessor) error {
if val, ok := reader.clusterConfigs[clusterConfig.ExpectedKind()]; ok {
return ParseByteSlice(val, clusterConfig)
}
return fmt.Errorf("could not find <%s> in cluster configuration %s", clusterConfig.ExpectedKind(), reader.fileName)
}
func ParseByteSlice(data []byte, clusterConfig KindAccessor) error {
return yaml.UnmarshalStrict(data, clusterConfig)
}
| 75 |
eks-anywhere-packages | aws | Go | package file
import (
"testing"
"github.com/stretchr/testify/assert"
)
type testObject struct {
Kind string `json:"kind"`
Foo int `json:"foo"`
}
func (o *testObject) ExpectedKind() string {
return "testObject"
}
func (o *testObject) MetaKind() string {
return o.Kind
}
func TestFileReaderInitializeEnoent(t *testing.T) {
sut := NewFileReader("../../api/testdata/enoent.yaml")
actual := sut.Initialize(&testObject{})
assert.EqualError(t, actual, "reading <../../api/testdata/enoent.yaml>: open ../../api/testdata/enoent.yaml: no such file or directory")
}
func TestFileReaderInitializeBogus(t *testing.T) {
sut := NewFileReader("../../api/testdata/bogus.yaml")
actual := sut.Initialize(&testObject{})
assert.EqualError(t, actual, "error parsing <../../api/testdata/bogus.yaml>:\nbogus\n")
}
func TestFileReaderInitializeGood(t *testing.T) {
sut := NewFileReader("../../api/testdata/multiple.yaml")
actual := sut.Initialize(&testObject{})
assert.Nil(t, actual)
}
func TestFileReaderParseMissing(t *testing.T) {
config := testObject{}
sut := NewFileReader("../../api/testdata/missing.yaml")
initError := sut.Initialize(&config)
assert.Nil(t, initError)
actual := sut.Parse(&config)
assert.EqualError(t, actual, "could not find <testObject> in cluster configuration ../../api/testdata/missing.yaml")
}
func TestFileReaderParseGood(t *testing.T) {
config := &testObject{}
sut := NewFileReader("../../api/testdata/multiple.yaml")
initError := sut.Initialize(config)
assert.Nil(t, initError)
actual := sut.Parse(config)
assert.Nil(t, actual)
}
| 67 |
eks-anywhere-packages | aws | Go | package packages
import (
"context"
"fmt"
"os"
"strings"
"sync"
"time"
"github.com/go-logr/logr"
"sigs.k8s.io/yaml"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
"github.com/aws/eks-anywhere-packages/pkg/bundle"
"github.com/aws/eks-anywhere-packages/pkg/driver"
"github.com/aws/eks-anywhere-packages/pkg/utils"
)
const (
retryNever = time.Duration(0)
retryNow = time.Duration(1)
retrySoon = time.Duration(2) * time.Second
retryShort = time.Duration(30) * time.Second
retryLong = time.Duration(60) * time.Second
retryVeryLong = time.Duration(180) * time.Second
sourceRegistry = "sourceRegistry"
)
type ManagerContext struct {
Ctx context.Context
Package api.Package
PackageDriver driver.PackageDriver
Source api.PackageOCISource
PBC api.PackageBundleController
Version api.SourceVersion
RequeueAfter time.Duration
Log logr.Logger
Bundle *api.PackageBundle
ManagerClient bundle.Client
}
func NewManagerContext(ctx context.Context, log logr.Logger, packageDriver driver.PackageDriver) *ManagerContext {
return &ManagerContext{
Ctx: ctx,
Log: log,
PackageDriver: packageDriver,
}
}
func (mc *ManagerContext) SetUninstalling(namespace string, name string) {
mc.Package.Namespace = namespace
mc.Package.Name = name
mc.Package.Status.State = api.StateUninstalling
}
func (mc *ManagerContext) getImageRegistry(values map[string]interface{}) string {
if val, ok := values[sourceRegistry]; ok {
if val != "" {
return val.(string)
}
}
if mc.PBC.Spec.PrivateRegistry != "" {
return mc.PBC.Spec.PrivateRegistry
}
return mc.PBC.GetDefaultImageRegistry()
}
func processInitializing(mc *ManagerContext) bool {
mc.Log.Info("New installation", "name", mc.Package.Name)
mc.Package.Status.Source = mc.Source
mc.Package.Status.State = api.StateInstallingDependencies
mc.RequeueAfter = retryNow
mc.Package.Spec.DeepCopyInto(&mc.Package.Status.Spec)
return true
}
func processUpdating(mc *ManagerContext) bool {
mc.Log.Info("Updating package ", "name", mc.Package.Name)
mc.Package.Status.State = api.StateInstallingDependencies
mc.RequeueAfter = retryNow
return true
}
func processInstallingDependencies(mc *ManagerContext) bool {
mc.Log.Info("Installing dependencies", "chart", mc.Source)
dependencies, err := mc.Bundle.GetDependencies(mc.Version)
if err != nil {
mc.Package.Status.Detail = fmt.Sprintf(
"invalid package bundle. (%s@%s bundle: %s)",
mc.Package.Name,
mc.Version,
mc.Bundle.Name,
)
mc.Log.Info(mc.Package.Status.Detail)
mc.RequeueAfter = retryLong
return true
}
pkgs, err := mc.ManagerClient.GetPackageList(mc.Ctx, mc.Package.Namespace)
if err != nil {
mc.RequeueAfter = retryShort
mc.Package.Status.Detail = err.Error()
return true
}
pkgsNotReady := []api.Package{}
for _, dep := range dependencies {
var pkg *api.Package
for i := range pkgs.Items {
items := pkgs.Items
if items[i].Spec.PackageName == dep.Name {
pkg = &items[i]
}
}
if pkg != nil {
if pkg.Status.State != api.StateInstalled {
pkgsNotReady = append(pkgsNotReady, *pkg)
}
} else {
p := api.NewPackage(dep.Name, dep.Name, mc.Package.Namespace, mc.Package.Spec.Config)
p.Spec.TargetNamespace = mc.Package.Spec.TargetNamespace
pkgsNotReady = append(pkgsNotReady, p)
err := mc.ManagerClient.CreatePackage(mc.Ctx, &p)
if err != nil {
mc.Log.Error(err, "creating dependency package")
}
}
}
if len(pkgsNotReady) > 0 {
depsStr := utils.Map(pkgsNotReady, func(pkg api.Package) string { return pkg.Spec.PackageName })
mc.Package.Status.Detail = "Waiting for dependencies: " + strings.Join(depsStr, ", ")
mc.RequeueAfter = retrySoon
return true
}
mc.Package.Status.State = api.StateInstalling
mc.Package.Status.Detail = ""
return true
}
func processInstalling(mc *ManagerContext) bool {
mc.Package.Status.Source = mc.Source
mc.Log.Info("installing/updating", "chart", mc.Source)
var err error
var values map[string]interface{}
if values, err = mc.Package.GetValues(); err != nil {
mc.Package.Status.Detail = err.Error()
mc.Log.Error(err, "Install failed")
return true
}
values[sourceRegistry] = mc.getImageRegistry(values)
if mc.Source.Registry == "" {
mc.Source.Registry = mc.PBC.GetDefaultRegistry()
}
if err := mc.PackageDriver.Initialize(mc.Ctx, mc.Package.GetClusterName()); err != nil {
mc.Package.Status.Detail = err.Error()
return true
}
createNamespace := mc.PBC.Spec.CreateNamespace
if err := mc.PackageDriver.Install(mc.Ctx, mc.Package.Name, mc.Package.Spec.TargetNamespace, createNamespace, mc.Source, values); err != nil {
mc.Package.Status.Detail = err.Error()
mc.Log.Error(err, "Install failed")
return true
}
mc.Log.Info("Installed", "name", mc.Package.Name, "chart", mc.Package.Status.Source)
mc.Package.Status.State = api.StateInstalled
mc.Package.Status.CurrentVersion = mc.Source.Version
mc.Package.Status.Detail = ""
if len(mc.Package.GetClusterName()) == 0 {
mc.Package.Status.Detail = "Deprecated package namespace. Move to eksa-packages-" + os.Getenv("CLUSTER_NAME")
}
mc.Package.Spec.DeepCopyInto(&mc.Package.Status.Spec)
return true
}
func processInstalled(mc *ManagerContext) bool {
if mc.Package.Status.Source != mc.Source {
mc.Package.Status.Source = mc.Source
mc.Package.Status.State = api.StateUpdating
mc.RequeueAfter = retryShort
return true
}
var err error
newValues := make(map[string]interface{})
err = yaml.Unmarshal([]byte(mc.Package.Spec.Config), &newValues)
if err != nil {
mc.Log.Error(err, "unmarshaling current package configuration")
mc.Package.Status.Detail = err.Error()
mc.RequeueAfter = retryShort
return true
}
if err := mc.PackageDriver.Initialize(mc.Ctx, mc.Package.GetClusterName()); err != nil {
mc.Package.Status.Detail = err.Error()
mc.Log.Error(err, "Initialization failed")
return true
}
newValues[sourceRegistry] = mc.getImageRegistry(newValues)
needs, err := mc.PackageDriver.IsConfigChanged(mc.Ctx, mc.Package.Name, newValues)
if err != nil {
mc.Log.Error(err, "checking necessity of reconfiguration")
mc.Package.Status.Detail = err.Error()
mc.RequeueAfter = retryLong
return true
}
if needs {
mc.Log.Info("configuration change detected, upgrading")
mc.Package.Status.State = api.StateUpdating
mc.RequeueAfter = retryShort
mc.Package.Spec.DeepCopyInto(&mc.Package.Status.Spec)
return true
}
mc.RequeueAfter = retryVeryLong
return false
}
func processUninstalling(mc *ManagerContext) bool {
if err := mc.PackageDriver.Initialize(mc.Ctx, mc.Package.GetClusterName()); err != nil {
mc.Package.Status.Detail = err.Error()
mc.Log.Error(err, "Initialization failed")
return false
}
if err := mc.PackageDriver.Uninstall(mc.Ctx, mc.Package.Name); err != nil {
mc.Package.Status.Detail = err.Error()
mc.Log.Error(err, "Uninstall failed")
return false
}
mc.Log.Info("Uninstalled", "name", mc.Package.Name)
mc.Package.Status.Detail = ""
mc.RequeueAfter = retryNever
return false
}
func processUnknown(mc *ManagerContext) bool {
mc.Log.Info("Unknown state", "name", mc.Package.Name)
mc.Package.Status.Detail = "Unknown state: " + string(mc.Package.Status.State)
mc.RequeueAfter = retryNever
mc.Package.Spec.DeepCopyInto(&mc.Package.Status.Spec)
return true
}
func processDone(mc *ManagerContext) bool {
mc.RequeueAfter = retryNever
return false
}
//go:generate mockgen -source manager.go -destination=mocks/manager.go -package=mocks Manager
type Manager interface {
// Process package events returns true if status update
Process(mc *ManagerContext) bool
}
type manager struct {
packageStates map[api.StateEnum]func(*ManagerContext) bool
}
var (
instance Manager
once sync.Once
)
func NewManager() Manager {
once.Do(func() {
instance = &(manager{
packageStates: map[api.StateEnum]func(*ManagerContext) bool{
api.StateInitializing: processInitializing,
api.StateInstalling: processInstalling,
api.StateInstallingDependencies: processInstallingDependencies,
api.StateInstalled: processInstalled,
api.StateUpdating: processUpdating,
api.StateUninstalling: processUninstalling,
api.StateUnknown: processDone,
},
})
})
return instance
}
func (m manager) getState(stateName api.StateEnum) func(*ManagerContext) bool {
if stateName == "" {
stateName = api.StateInitializing
}
if val, ok := m.packageStates[stateName]; ok {
return val
}
return processUnknown
}
func (m manager) Process(mc *ManagerContext) bool {
mc.RequeueAfter = retryLong
if !mc.Package.IsValidNamespace() {
mc.Package.Status.Detail = "Packages namespaces must start with: " + api.PackageNamespace
mc.RequeueAfter = retryNever
if mc.Package.Status.State == api.StateUnknown {
return false
}
mc.Package.Status.State = api.StateUnknown
return true
}
stateFunc := m.getState(mc.Package.Status.State)
result := stateFunc(mc)
if result {
mc.Log.Info(
"Updating",
"namespace",
mc.Package.Namespace,
"name",
mc.Package.Name,
"state",
mc.Package.Status.State,
"chart",
mc.Package.Status.Source,
)
}
return result
}
| 322 |
eks-anywhere-packages | aws | Go | package packages
import (
"context"
"errors"
"fmt"
"testing"
"time"
"github.com/go-logr/logr"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/assert"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"sigs.k8s.io/controller-runtime/pkg/client"
api "github.com/aws/eks-anywhere-packages/api/v1alpha1"
cMock "github.com/aws/eks-anywhere-packages/controllers/mocks"
"github.com/aws/eks-anywhere-packages/pkg/bundle"
"github.com/aws/eks-anywhere-packages/pkg/driver/mocks"
)
const packageName = "packageName"
const packageInstance = "packageInstance"
const packageBundleName = "testPackageBundle"
const clusterName = "clusterName"
const originalConfiguration = `
make: willys
models:
mb: "41"
cj2a:
year: "45"
`
const newConfiguration = `
make: willys
models:
mc: "49"
cj3a:
year: "49"
`
type PackageOCISource = api.PackageOCISource
var expectedEmptySource = PackageOCISource{
Registry: "",
Repository: "",
Digest: "",
}
var expectedSource = PackageOCISource{
Registry: "public.ecr.aws/l0g8r8j6/",
Repository: "hello-eks-anywhere",
Digest: "sha256:f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2",
}
var expectedUpdate = PackageOCISource{
Registry: "public.ecr.aws/l0g8r8j6/",
Repository: "hello-eks-anywhere",
Digest: "sha256:deadbeefc7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2",
}
func givenPackage() api.Package {
return api.Package{
TypeMeta: metav1.TypeMeta{
Kind: "Package",
},
ObjectMeta: metav1.ObjectMeta{
Name: packageInstance,
Namespace: "eksa-packages-" + clusterName,
},
Spec: api.PackageSpec{
PackageName: packageName,
Config: originalConfiguration,
},
}
}
func givenBundle() *api.PackageBundle {
return &api.PackageBundle{
TypeMeta: metav1.TypeMeta{
Kind: "PackageBundle",
},
ObjectMeta: metav1.ObjectMeta{
Name: packageBundleName,
Namespace: "eksa-packages-" + clusterName,
},
Spec: api.PackageBundleSpec{
Packages: []api.BundlePackage{
{
Name: packageName,
Source: api.BundlePackageSource{
Registry: "public.ecr.aws/j0a1m4z9/",
Repository: "hello-eks-anywhere",
Versions: []api.SourceVersion{
{
Name: "test",
Digest: "sha256:deadbeefc7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2",
Dependencies: []string{
"test-dep",
},
},
},
},
},
{
Name: "test-dep",
Source: api.BundlePackageSource{
Registry: "public.ecr.aws/j0a1m4z9/",
Repository: "test-dep",
Versions: []api.SourceVersion{
{
Name: "test-dep-name",
Digest: "sha256:deadbeefc7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2",
},
},
},
},
},
},
}
}
func givenMockClient(t *testing.T) *cMock.MockClient {
gomockController := gomock.NewController(t)
return cMock.NewMockClient(gomockController)
}
func givenMockDriver(t *testing.T) *mocks.MockPackageDriver {
gomockController := gomock.NewController(t)
return mocks.NewMockPackageDriver(gomockController)
}
func givenMocksWithClient(t *testing.T) (*ManagerContext, *cMock.MockClient) {
mc, _ := givenMocks(t)
mockClient := givenMockClient(t)
managerClient := bundle.NewManagerClient(mockClient)
mc.ManagerClient = managerClient
return mc, mockClient
}
func givenMocks(t *testing.T) (*ManagerContext, *mocks.MockPackageDriver) {
pkg := givenPackage()
mockDriver := givenMockDriver(t)
return &ManagerContext{
Ctx: context.Background(),
Package: pkg,
PackageDriver: mockDriver,
Source: expectedSource,
Bundle: givenBundle(),
PBC: api.PackageBundleController{
Spec: api.PackageBundleControllerSpec{
PrivateRegistry: "privateRegistry",
},
},
RequeueAfter: time.Duration(100),
Log: logr.Discard(),
}, mockDriver
}
func thenManagerContext(t *testing.T, mc *ManagerContext, expectedState api.StateEnum, expectedSource PackageOCISource, expectedRequeue time.Duration, expectedDetail string) {
assert.Equal(t, expectedState, mc.Package.Status.State)
assert.Equal(t, expectedSource, mc.Package.Status.Source)
assert.Equal(t, expectedRequeue, mc.RequeueAfter)
assert.Equal(t, expectedDetail, mc.Package.Status.Detail)
}
func TestManagerContext_SetUninstalling(t *testing.T) {
sut, _ := givenMocks(t)
expectedName := "billy"
expectedState := api.StateUninstalling
sut.SetUninstalling(api.PackageNamespace+"-"+clusterName, expectedName)
assert.Equal(t, expectedName, sut.Package.Name)
assert.Equal(t, expectedState, sut.Package.Status.State)
}
func TestManagerContext_getRegistry(t *testing.T) {
t.Run("registry from values", func(t *testing.T) {
sut, _ := givenMocks(t)
values := make(map[string]interface{})
values["sourceRegistry"] = "valuesRegistry"
assert.Equal(t, "valuesRegistry", sut.getImageRegistry(values))
})
t.Run("registry from privateRegistry", func(t *testing.T) {
sut, _ := givenMocks(t)
values := make(map[string]interface{})
assert.Equal(t, "privateRegistry", sut.getImageRegistry(values))
})
t.Run("registry from default gated registry", func(t *testing.T) {
sut, _ := givenMocks(t)
values := make(map[string]interface{})
sut.PBC.Spec.PrivateRegistry = ""
sut.Source.Registry = ""
assert.Equal(t, "783794618700.dkr.ecr.us-west-2.amazonaws.com", sut.getImageRegistry(values))
})
}
func TestNewManager(t *testing.T) {
expectedManager := NewManager()
actualManager := NewManager()
assert.Equal(t, expectedManager, actualManager)
}
func TestManagerLifecycle(t *testing.T) {
sut := NewManager()
t.Run("New package added with no state initializing", func(t *testing.T) {
mc, _ := givenMocks(t)
mc.Package.Status.State = ""
expectedRequeue := time.Duration(1)
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstallingDependencies, expectedSource, expectedRequeue, "")
})
t.Run("New package added with state initializing", func(t *testing.T) {
mc, _ := givenMocks(t)
mc.Package.Status.State = api.StateInitializing
expectedRequeue := time.Duration(1)
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstallingDependencies, expectedSource, expectedRequeue, "")
})
t.Run("installing with dependency causes dependency package to be created", func(t *testing.T) {
mc, mockClient := givenMocksWithClient(t)
mc.Package.Status.State = api.StateInstallingDependencies
mc.Version = mc.Bundle.Spec.Packages[0].Source.Versions[0]
mockClient.EXPECT().List(mc.Ctx, gomock.AssignableToTypeOf(&api.PackageList{}), gomock.Eq(client.InNamespace(mc.Package.Namespace))).SetArg(1, api.PackageList{})
expectedDepPkg := api.NewPackage("test-dep", "test-dep", mc.Package.Namespace, mc.Package.Spec.Config)
mockClient.EXPECT().Create(mc.Ctx, gomock.Eq(&expectedDepPkg)).Return(nil)
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstallingDependencies, api.PackageOCISource{}, retrySoon, "Waiting for dependencies: test-dep")
})
t.Run("installing succeeds if dependencies are installed", func(t *testing.T) {
mc, mockClient := givenMocksWithClient(t)
mc.Package.Status.State = api.StateInstallingDependencies
mc.Version = mc.Bundle.Spec.Packages[0].Source.Versions[0]
installedPkg := api.NewPackage("test-dep", "test-dep", mc.Package.Namespace, mc.Package.Spec.Config)
installedPkg.Status.State = api.StateInstalled
mockClient.EXPECT().List(mc.Ctx, gomock.AssignableToTypeOf(&api.PackageList{}), gomock.Eq(client.InNamespace(mc.Package.Namespace))).SetArg(1, api.PackageList{
Items: []api.Package{
installedPkg,
},
})
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstalling, api.PackageOCISource{}, retryLong, "")
})
t.Run("installing dependencies fails if the bundle is wrong", func(t *testing.T) {
mc, _ := givenMocksWithClient(t)
mc.Package.Status.State = api.StateInstallingDependencies
mc.Version = mc.Bundle.Spec.Packages[0].Source.Versions[0]
mc.Version.Dependencies = []string{"bad-dep"}
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstallingDependencies, api.PackageOCISource{}, retryLong, "invalid package bundle. (packageInstance@{test sha256:deadbeefc7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2 [] [bad-dep]} bundle: testPackageBundle)")
})
t.Run("installing dependencies fails if the client fails", func(t *testing.T) {
mc, mockClient := givenMocksWithClient(t)
mc.Package.Status.State = api.StateInstallingDependencies
mc.Version = mc.Bundle.Spec.Packages[0].Source.Versions[0]
mockClient.EXPECT().List(mc.Ctx, gomock.AssignableToTypeOf(&api.PackageList{}), gomock.Eq(client.InNamespace(mc.Package.Namespace))).SetArg(1, api.PackageList{}).Return(errors.New("Failed!"))
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstallingDependencies, api.PackageOCISource{}, retryShort, "Failed!")
})
t.Run("installing waits if dependencies are installing and clears the Details field once installing", func(t *testing.T) {
mc, mockClient := givenMocksWithClient(t)
mc.Package.Status.State = api.StateInstallingDependencies
mc.Version = mc.Bundle.Spec.Packages[0].Source.Versions[0]
installedPkg := api.NewPackage("test-dep", "test-dep", mc.Package.Namespace, mc.Package.Spec.Config)
installedPkg.Status.State = api.StateInstalling
mockClient.EXPECT().List(mc.Ctx, gomock.AssignableToTypeOf(&api.PackageList{}), gomock.Eq(client.InNamespace(mc.Package.Namespace))).SetArg(1, api.PackageList{
Items: []api.Package{
installedPkg,
},
})
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstallingDependencies, api.PackageOCISource{}, retrySoon, "Waiting for dependencies: test-dep")
installedPkg.Status.State = api.StateInstalled
mockClient.EXPECT().List(mc.Ctx, gomock.AssignableToTypeOf(&api.PackageList{}), gomock.Eq(client.InNamespace(mc.Package.Namespace))).SetArg(1, api.PackageList{
Items: []api.Package{
installedPkg,
},
})
result = sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstalling, api.PackageOCISource{}, retryLong, "")
})
t.Run("installing installs", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.Package.Status.State = api.StateInstalling
mockDriver.EXPECT().Initialize(mc.Ctx, clusterName).Return(nil)
mockDriver.EXPECT().Install(mc.Ctx, mc.Package.Name, mc.Package.Spec.TargetNamespace, false, mc.Source, gomock.Any()).Return(nil)
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstalled, expectedSource, 60*time.Second, "")
})
t.Run("installing in deprecated namespace", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.Package.Status.State = api.StateInstalling
mc.Package.Namespace = "eksa-packages"
t.Setenv("CLUSTER_NAME", "franky")
mockDriver.EXPECT().Initialize(mc.Ctx, "").Return(nil)
mockDriver.EXPECT().Install(mc.Ctx, mc.Package.Name, mc.Package.Spec.TargetNamespace, false, mc.Source, gomock.Any()).Return(nil)
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstalled, expectedSource, 60*time.Second, "Deprecated package namespace. Move to eksa-packages-franky")
})
t.Run("installing with namespace creation enabled creates the namespace", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.PBC.Spec.CreateNamespace = true
mc.Package.Status.State = api.StateInstalling
mockDriver.EXPECT().Initialize(mc.Ctx, clusterName).Return(nil)
mockDriver.EXPECT().Install(mc.Ctx, mc.Package.Name, mc.Package.Spec.TargetNamespace, true, mc.Source, gomock.Any()).Return(nil)
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstalled, expectedSource, 60*time.Second, "")
})
t.Run("installing initialize fails", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.Package.Status.State = api.StateInstalling
mockDriver.EXPECT().Initialize(mc.Ctx, clusterName).Return(fmt.Errorf("boom"))
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstalling, expectedSource, 60*time.Second, "boom")
})
t.Run("installing install fails", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.Package.Status.State = api.StateInstalling
mockDriver.EXPECT().Initialize(mc.Ctx, clusterName).Return(nil)
mockDriver.EXPECT().Install(mc.Ctx, mc.Package.Name, mc.Package.Spec.TargetNamespace, false, mc.Source, gomock.Any()).Return(fmt.Errorf("boom"))
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstalling, expectedSource, 60*time.Second, "boom")
})
t.Run("installed upgrade triggered", func(t *testing.T) {
mc, _ := givenMocks(t)
mc.Package.Status.State = api.StateInstalled
mc.Package.Status.Source = expectedSource
mc.Source = expectedUpdate
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateUpdating, expectedUpdate, 30*time.Second, "")
})
t.Run("installed configuration update", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.Package.Status.State = api.StateInstalled
mc.Package.Status.Source = expectedSource
mc.Source = expectedSource
mc.Package.Spec.Config = newConfiguration
mockDriver.EXPECT().Initialize(mc.Ctx, clusterName).Return(nil)
mockDriver.EXPECT().IsConfigChanged(mc.Ctx, mc.Package.Name, gomock.Any()).Return(true, nil)
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateUpdating, expectedSource, 30*time.Second, "")
})
t.Run("installed no configuration change", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.Package.Status.State = api.StateInstalled
mc.Package.Status.Source = expectedSource
mc.Source = expectedSource
mc.Package.Spec.Config = originalConfiguration
mockDriver.EXPECT().Initialize(mc.Ctx, clusterName).Return(nil)
mockDriver.EXPECT().IsConfigChanged(mc.Ctx, mc.Package.Name, gomock.Any()).Return(false, nil)
result := sut.Process(mc)
assert.False(t, result)
thenManagerContext(t, mc, api.StateInstalled, expectedSource, 180*time.Second, "")
})
t.Run("installed initialize error", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.Package.Status.State = api.StateInstalled
mc.Package.Status.Source = expectedSource
mc.Source = expectedSource
mc.Package.Spec.Config = newConfiguration
mockDriver.EXPECT().Initialize(mc.Ctx, clusterName).Return(fmt.Errorf("boom"))
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstalled, expectedSource, 60*time.Second, "boom")
})
t.Run("installed IsConfigChanged error", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.Package.Status.State = api.StateInstalled
mc.Package.Status.Source = expectedSource
mc.Source = expectedSource
mc.Package.Spec.Config = newConfiguration
mockDriver.EXPECT().Initialize(mc.Ctx, clusterName).Return(nil)
mockDriver.EXPECT().IsConfigChanged(mc.Ctx, mc.Package.Name, gomock.Any()).Return(true, fmt.Errorf("boom"))
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstalled, expectedSource, 60*time.Second, "boom")
})
t.Run("installed configuration parse error", func(t *testing.T) {
mc, _ := givenMocks(t)
mc.Package.Status.State = api.StateInstalled
mc.Package.Status.Source = expectedSource
mc.Source = expectedSource
mc.Package.Spec.Config = "bogus configuration ---- what ever"
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateInstalled, expectedSource, 30*time.Second, "error unmarshaling JSON: while decoding JSON: json: cannot unmarshal string into Go value of type map[string]interface {}")
})
t.Run("Uninstalling works", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.SetUninstalling(api.PackageNamespace+"-"+clusterName, clusterName)
mockDriver.EXPECT().Initialize(mc.Ctx, clusterName).Return(nil)
mockDriver.EXPECT().Uninstall(mc.Ctx, clusterName).Return(nil)
result := sut.Process(mc)
assert.False(t, result)
thenManagerContext(t, mc, api.StateUninstalling, expectedEmptySource, time.Duration(0), "")
})
t.Run("Uninstalling initialize fails", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.SetUninstalling(api.PackageNamespace+"-"+clusterName, clusterName)
mockDriver.EXPECT().Initialize(mc.Ctx, clusterName).Return(fmt.Errorf("init crunch"))
result := sut.Process(mc)
assert.False(t, result)
thenManagerContext(t, mc, api.StateUninstalling, expectedEmptySource, 60*time.Second, "init crunch")
})
t.Run("Uninstalling fails", func(t *testing.T) {
mc, mockDriver := givenMocks(t)
mc.SetUninstalling(api.PackageNamespace+"-"+clusterName, clusterName)
mockDriver.EXPECT().Initialize(mc.Ctx, clusterName).Return(nil)
mockDriver.EXPECT().Uninstall(mc.Ctx, clusterName).Return(fmt.Errorf("crunch"))
result := sut.Process(mc)
assert.False(t, result)
thenManagerContext(t, mc, api.StateUninstalling, expectedEmptySource, 60*time.Second, "crunch")
})
t.Run("Bogus state is reported", func(t *testing.T) {
mc, _ := givenMocks(t)
mc.Package.Status.State = "bogus"
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, "bogus", expectedEmptySource, time.Duration(0), "Unknown state: bogus")
})
t.Run("Unknown state is ignored", func(t *testing.T) {
mc, _ := givenMocks(t)
mc.Package.Status.State = api.StateUnknown
result := sut.Process(mc)
assert.False(t, result)
thenManagerContext(t, mc, api.StateUnknown, expectedEmptySource, time.Duration(0), "")
})
t.Run("Package in wrong namespace should be ignored", func(t *testing.T) {
mc, _ := givenMocks(t)
mc.Package.Status.State = ""
mc.Package.Namespace = "default"
result := sut.Process(mc)
assert.True(t, result)
thenManagerContext(t, mc, api.StateUnknown, expectedEmptySource, time.Duration(0), "Packages namespaces must start with: eksa-packages")
})
t.Run("Package in wrong namespace should be ignored again", func(t *testing.T) {
mc, _ := givenMocks(t)
mc.Package.Status.State = api.StateUnknown
mc.Package.Namespace = "default"
result := sut.Process(mc)
assert.False(t, result)
thenManagerContext(t, mc, api.StateUnknown, expectedEmptySource, time.Duration(0), "Packages namespaces must start with: eksa-packages")
})
}
| 492 |
eks-anywhere-packages | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: manager.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
packages "github.com/aws/eks-anywhere-packages/pkg/packages"
gomock "github.com/golang/mock/gomock"
)
// MockManager is a mock of Manager interface.
type MockManager struct {
ctrl *gomock.Controller
recorder *MockManagerMockRecorder
}
// MockManagerMockRecorder is the mock recorder for MockManager.
type MockManagerMockRecorder struct {
mock *MockManager
}
// NewMockManager creates a new mock instance.
func NewMockManager(ctrl *gomock.Controller) *MockManager {
mock := &MockManager{ctrl: ctrl}
mock.recorder = &MockManagerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockManager) EXPECT() *MockManagerMockRecorder {
return m.recorder
}
// Process mocks base method.
func (m *MockManager) Process(mc *packages.ManagerContext) bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Process", mc)
ret0, _ := ret[0].(bool)
return ret0
}
// Process indicates an expected call of Process.
func (mr *MockManagerMockRecorder) Process(mc interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Process", reflect.TypeOf((*MockManager)(nil).Process), mc)
}
| 50 |
eks-anywhere-packages | aws | Go | package registry
import (
"fmt"
"strings"
)
// Artifact to head release dependency.
type Artifact struct {
Registry string
Repository string
Tag string
Digest string
}
// NewArtifact creates a new artifact object.
func NewArtifact(registry, repository, tag, digest string) Artifact {
return Artifact{
Registry: registry,
Repository: repository,
Tag: tag,
Digest: digest,
}
}
// ParseArtifactFromURI parses the URI into a new Artifact object.
func ParseArtifactFromURI(uri string) (*Artifact, error) {
elements := strings.SplitN(uri, "/", 2)
if len(elements) != 2 {
return nil, fmt.Errorf("registry not found")
}
registry := elements[0]
rol := elements[1]
var tag string
var digest string
elements = strings.SplitN(rol, "@", 2)
if len(elements) != 2 {
elements = strings.SplitN(rol, ":", 2)
if len(elements) != 2 {
return nil, fmt.Errorf("tag or digest not found")
}
tag = elements[1]
} else {
digest = elements[1]
}
repository := elements[0]
return &Artifact{
Registry: registry,
Repository: repository,
Tag: tag,
Digest: digest,
}, nil
}
// Version returns tag or digest.
func (art Artifact) Version() string {
if art.Digest != "" {
return "@" + art.Digest
}
return ":" + art.Tag
}
// VersionedImage returns full URI for image.
func (art Artifact) VersionedImage() string {
version := art.Version()
return art.Registry + "/" + art.Repository + version
}
| 69 |
eks-anywhere-packages | aws | Go | package registry_test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/aws/eks-anywhere-packages/pkg/registry"
)
func TestArtifact_VersionTag(t *testing.T) {
artifact := registry.NewArtifact("localhost:8443", "owner/repo", "latest", "")
assert.Equal(t, ":latest", artifact.Version())
assert.Equal(t, "localhost:8443/owner/repo:latest", artifact.VersionedImage())
}
func TestArtifact_VersionDigest(t *testing.T) {
artifact := registry.NewArtifact("localhost:8443", "owner/repo", "", "sha256:0db6a")
assert.Equal(t, "@sha256:0db6a", artifact.Version())
assert.Equal(t, "localhost:8443/owner/repo@sha256:0db6a", artifact.VersionedImage())
}
func TestParseArtifactFromURI_VersionedImageMatchesURI(t *testing.T) {
artifact, err := registry.ParseArtifactFromURI("localhost:8443/owner/repo@sha256:0db6a")
require.NoError(t, err)
assert.Equal(t, "localhost:8443/owner/repo@sha256:0db6a", artifact.VersionedImage())
artifact, err = registry.ParseArtifactFromURI("localhost:8443/owner/repo:sometag")
require.NoError(t, err)
assert.Equal(t, "localhost:8443/owner/repo:sometag", artifact.VersionedImage())
}
| 33 |
eks-anywhere-packages | aws | Go | package registry
import (
"crypto/x509"
"fmt"
"os"
"path"
"path/filepath"
)
const (
registryConfigPath = "/tmp/config/registry"
certFile = "ca.crt"
insecureFile = "insecure"
)
func GetRegistryInsecure(clusterName string) bool {
caFile := path.Join(registryConfigPath, clusterName+"_"+insecureFile)
if _, err := os.Stat(caFile); err != nil {
return false
}
return true
}
func GetClusterCertificateFileName(clusterName string) string {
caFile := path.Join(registryConfigPath, clusterName+"_"+certFile)
if _, err := os.Stat(caFile); err != nil {
return ""
}
return caFile
}
func GetClusterCertificate(clusterName string) (certificates *x509.CertPool, err error) {
caFile := GetClusterCertificateFileName(clusterName)
if caFile == "" {
return nil, nil
}
return GetCertificates(caFile)
}
// GetCertificates get X509 certificates.
func GetCertificates(certFile string) (certificates *x509.CertPool, err error) {
if len(certFile) < 1 {
return nil, nil
}
fileContents, err := os.ReadFile(filepath.Clean(certFile))
if err != nil {
return nil, fmt.Errorf("error reading certificate file <%s>: %v", certFile, err)
}
certPool := x509.NewCertPool()
certPool.AppendCertsFromPEM(fileContents)
return certPool, nil
}
| 55 |
eks-anywhere-packages | aws | Go | package registry_test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/aws/eks-anywhere-packages/pkg/registry"
)
func TestGetCertificatesSuccess(t *testing.T) {
result, err := registry.GetCertificates("testdata/harbor.eksa.demo.crt")
assert.NotNil(t, result)
assert.NoError(t, err)
}
func TestGetCertificatesNothing(t *testing.T) {
result, err := registry.GetCertificates("")
assert.Nil(t, result)
assert.NoError(t, err)
}
func TestGetCertificatesError(t *testing.T) {
result, err := registry.GetCertificates("bogus.crt")
assert.Nil(t, result)
assert.EqualError(t, err, "error reading certificate file <bogus.crt>: open bogus.crt: no such file or directory")
}
| 28 |
eks-anywhere-packages | aws | Go | package registry
import (
"context"
"crypto/tls"
"fmt"
"net/http"
"path"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"oras.land/oras-go/v2"
"oras.land/oras-go/v2/content"
orasregistry "oras.land/oras-go/v2/registry"
"oras.land/oras-go/v2/registry/remote"
"oras.land/oras-go/v2/registry/remote/auth"
)
//go:generate mockgen -destination=mocks/storage.go -package=mocks -source storage.go StorageClient
//go:generate mockgen -destination=mocks/repository.go -package=mocks oras.land/oras-go/v2/registry Repository
// OCIRegistryClient storage client for an OCI registry.
type OCIRegistryClient struct {
StorageContext
registry *remote.Registry
}
var _ StorageClient = (*OCIRegistryClient)(nil)
// NewOCIRegistry create an OCI registry client.
func NewOCIRegistry(sc StorageContext, registry *remote.Registry) *OCIRegistryClient {
transport := http.DefaultTransport.(*http.Transport).Clone()
{ // #nosec G402
transport.TLSClientConfig = &tls.Config{
RootCAs: sc.certificates,
InsecureSkipVerify: sc.insecure,
}
}
authClient := &auth.Client{
Client: &http.Client{
Transport: transport,
},
Cache: auth.NewCache(),
}
authClient.SetUserAgent("eksa")
authClient.Credential = func(ctx context.Context, s string) (auth.Credential, error) {
return sc.credentialStore.Credential(s)
}
registry.Client = authClient
return &OCIRegistryClient{
StorageContext: sc,
registry: registry,
}
}
// GetHost for registry host.
func (or *OCIRegistryClient) GetHost() string {
return or.host
}
// SetProject for registry destination.
func (or *OCIRegistryClient) SetProject(project string) {
or.project = project
}
// Destination of this storage registry.
func (or *OCIRegistryClient) Destination(image Artifact) string {
return path.Join(or.host, or.project, image.Repository) + image.Version()
}
// GetStorage object based on repository.
func (or *OCIRegistryClient) GetStorage(ctx context.Context, artifact Artifact) (repo orasregistry.Repository, err error) {
dstRepo := path.Join(or.project, artifact.Repository)
repo, err = or.registry.Repository(ctx, dstRepo)
if err != nil {
return nil, fmt.Errorf("error creating repository %s: %v", dstRepo, err)
}
return repo, nil
}
// Resolve the location of the source repository given the image.
func (or *OCIRegistryClient) Resolve(ctx context.Context, srcStorage orasregistry.Repository, versionedImage string) (desc ocispec.Descriptor, err error) {
or.registry.Reference.Reference = versionedImage
return srcStorage.Resolve(ctx, or.registry.Reference.Reference)
}
// FetchBytes a resource from the registry.
func (or *OCIRegistryClient) FetchBytes(ctx context.Context, srcStorage orasregistry.Repository, artifact Artifact) (ocispec.Descriptor, []byte, error) {
return oras.FetchBytes(ctx, srcStorage, artifact.VersionedImage(), oras.DefaultFetchBytesOptions)
}
// FetchBlob get named blob.
func (or *OCIRegistryClient) FetchBlob(ctx context.Context, srcStorage orasregistry.Repository, descriptor ocispec.Descriptor) ([]byte, error) {
return content.FetchAll(ctx, srcStorage, descriptor)
}
// CopyGraph copy manifest and all blobs to destination.
func (or *OCIRegistryClient) CopyGraph(ctx context.Context, srcStorage orasregistry.Repository, dstStorage orasregistry.Repository, desc ocispec.Descriptor) error {
extendedCopyOptions := oras.DefaultExtendedCopyOptions
return oras.CopyGraph(ctx, srcStorage, dstStorage, desc, extendedCopyOptions.CopyGraphOptions)
}
| 102 |
eks-anywhere-packages | aws | Go | package registry_test
import (
"context"
"crypto/x509"
"testing"
"github.com/docker/cli/cli/config"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"oras.land/oras-go/v2/registry/remote"
"github.com/aws/eks-anywhere-packages/pkg/registry"
)
var (
ctx = context.Background()
image = registry.Artifact{
Registry: "public.ecr.aws",
Repository: "eks-anywhere/eks-anywhere-packages",
Digest: "sha256:6efe21500abbfbb6b3e37b80dd5dea0b11a0d1b145e84298fee5d7784a77e967",
Tag: "0.2.22-eks-a-24",
}
certificates = &x509.CertPool{}
)
func TestOCIRegistryClient_Destination(t *testing.T) {
sc := newStorageContext(t, "")
sut := registry.NewOCIRegistry(sc, newTestRegistry(t, image.Registry))
destination := sut.Destination(image)
assert.Equal(t, "localhost/eks-anywhere/eks-anywhere-packages@sha256:6efe21500abbfbb6b3e37b80dd5dea0b11a0d1b145e84298fee5d7784a77e967", destination)
sut.SetProject("project/")
destination = sut.Destination(image)
assert.Equal(t, "localhost/project/eks-anywhere/eks-anywhere-packages@sha256:6efe21500abbfbb6b3e37b80dd5dea0b11a0d1b145e84298fee5d7784a77e967", destination)
}
func TestOCIRegistryClient_GetStorage(t *testing.T) {
sc := newStorageContext(t, "")
sut := registry.NewOCIRegistry(sc, newTestRegistry(t, image.Registry))
_, err := sut.GetStorage(context.Background(), image)
assert.NoError(t, err)
bogusImage := registry.Artifact{
Registry: "localhost",
Repository: "!@#$",
Digest: "sha256:6efe21500abbfbb6b3e37b80dd5dea0b11a0d1b145e84298fee5d7784a77e967",
}
_, err = sut.GetStorage(context.Background(), bogusImage)
assert.EqualError(t, err, "error creating repository !@#$: invalid reference: invalid repository")
}
func newStorageContext(t *testing.T, dir string) registry.StorageContext {
configFile, err := config.Load(dir)
require.NoError(t, err)
store := registry.NewDockerCredentialStore(configFile)
return registry.NewStorageContext("localhost", store, certificates, false)
}
func newTestRegistry(t *testing.T, host string) *remote.Registry {
t.Helper()
r, err := remote.NewRegistry(host)
require.NoError(t, err)
return r
}
| 65 |
eks-anywhere-packages | aws | Go | package registry
import (
"github.com/docker/cli/cli/config"
"github.com/docker/cli/cli/config/configfile"
"github.com/docker/cli/cli/config/credentials"
"oras.land/oras-go/v2/registry/remote/auth"
)
// DockerCredentialStore for Docker registry credentials, like ~/.docker/config.json.
type DockerCredentialStore struct {
configFile *configfile.ConfigFile
}
// CredentialsConfigLoad load credentials from directory.
func CredentialsConfigLoad() (*configfile.ConfigFile, error) {
return config.Load(registryConfigPath)
}
// NewDockerCredentialStore creates a DockerCredentialStore.
func NewDockerCredentialStore(configFile *configfile.ConfigFile) *DockerCredentialStore {
if !configFile.ContainsAuth() {
configFile.CredentialsStore = credentials.DetectDefaultStore(configFile.CredentialsStore)
}
return &DockerCredentialStore{
configFile: configFile,
}
}
// Credential get an authentication credential for a given registry.
func (cs *DockerCredentialStore) Credential(registry string) (auth.Credential, error) {
authConf, err := cs.configFile.GetCredentialsStore(registry).Get(registry)
if err != nil {
return auth.EmptyCredential, err
}
cred := auth.Credential{
Username: authConf.Username,
Password: authConf.Password,
AccessToken: authConf.RegistryToken,
RefreshToken: authConf.IdentityToken,
}
return cred, nil
}
| 44 |
eks-anywhere-packages | aws | Go | package registry_test
import (
"testing"
"github.com/docker/cli/cli/config"
"github.com/docker/cli/cli/config/configfile"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"oras.land/oras-go/v2/registry/remote/auth"
"github.com/aws/eks-anywhere-packages/pkg/registry"
)
func TestDockerCredentialStore(t *testing.T) {
configFile := newConfigFile(t, "testdata")
credentialStore := registry.NewDockerCredentialStore(configFile)
result, err := credentialStore.Credential("localhost")
require.NoError(t, err)
assertAuthEqual(t, auth.Credential{Username: "user", Password: "pass"}, result)
result, err = credentialStore.Credential("harbor.eksa.demo:30003")
require.NoError(t, err)
assertAuthEqual(t, auth.Credential{Username: "captain", Password: "haddock"}, result)
result, err = credentialStore.Credential("bogus")
require.NoError(t, err)
assertAuthEqual(t, auth.EmptyCredential, result)
result, err = credentialStore.Credential("5551212.dkr.ecr.us-west-2.amazonaws.com")
// This is a generic error, so using errors.Is won't work, and this is as
// much of the string as we can reliably match against in a cross-platform
// fashion. Until they change it, then everything will break.
require.ErrorContains(t, err, "error getting credentials - err")
assertAuthEqual(t, auth.EmptyCredential, result)
}
func TestCredentialStore_InitEmpty(t *testing.T) {
registry.NewDockerCredentialStore(newConfigFile(t, "testdata/empty"))
}
func newConfigFile(t *testing.T, dir string) *configfile.ConfigFile {
t.Helper()
configFile, err := config.Load(dir)
require.NoError(t, err)
return configFile
}
func assertAuthEqual(t *testing.T, expected, got auth.Credential) {
t.Helper()
assert.Equal(t, expected.Username, got.Username)
assert.Equal(t, expected.Password, got.Password)
assert.Equal(t, expected.AccessToken, got.AccessToken)
assert.Equal(t, expected.RefreshToken, got.RefreshToken)
}
| 57 |
eks-anywhere-packages | aws | Go | package registry
import (
"context"
"encoding/json"
"fmt"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
)
// PullBytes a resource from the registry.
func PullBytes(ctx context.Context, sc StorageClient, artifact Artifact) (data []byte, err error) {
srcStorage, err := sc.GetStorage(ctx, artifact)
if err != nil {
return nil, fmt.Errorf("repository source: %v", err)
}
_, data, err = sc.FetchBytes(ctx, srcStorage, artifact)
if err != nil {
return nil, fmt.Errorf("fetch manifest: %v", err)
}
var mani ocispec.Manifest
if err := json.Unmarshal(data, &mani); err != nil {
return nil, fmt.Errorf("unmarshal manifest: %v", err)
}
if len(mani.Layers) < 1 {
return nil, fmt.Errorf("missing layer")
}
data, err = sc.FetchBlob(ctx, srcStorage, mani.Layers[0])
if err != nil {
return nil, fmt.Errorf("fetch blob: %v", err)
}
return data, err
}
| 37 |
eks-anywhere-packages | aws | Go | package registry_test
import (
_ "embed"
"fmt"
"testing"
"github.com/golang/mock/gomock"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/stretchr/testify/assert"
"github.com/aws/eks-anywhere-packages/pkg/registry"
"github.com/aws/eks-anywhere-packages/pkg/registry/mocks"
)
//go:embed testdata/image-manifest.json
var imageManifest []byte
//go:embed testdata/bad-image-manifest.json
var badImageManifest []byte
//go:embed testdata/no-layer-image-manifest.json
var noLayersImageManifest []byte
//go:embed testdata/package-bundle.yaml
var packageBundle []byte
var srcArtifact = registry.Artifact{
Registry: "public.ecr.aws",
Repository: "l0g8r8j6/kube-vip/kube-vip",
Tag: "v0.5.5-eks-a-v0.0.0-dev-build.4452",
Digest: "sha256:6efe21500abbfbb6b3e37b80dd5dea0b11a0d1b145e84298fee5d7784a77e967",
}
func TestPull(t *testing.T) {
srcClient := mocks.NewMockStorageClient(gomock.NewController(t))
mockSrcRepo := *mocks.NewMockRepository(gomock.NewController(t))
desc := ocispec.Descriptor{
Digest: "sha256:8bc5f46db8c98aedfba4ade0d7ebbdecd8e4130e172d3d62871fc3258c40a910",
}
srcClient.EXPECT().GetStorage(ctx, srcArtifact).Return(&mockSrcRepo, nil)
srcClient.EXPECT().FetchBytes(ctx, &mockSrcRepo, srcArtifact).Return(desc, imageManifest, nil)
srcClient.EXPECT().FetchBlob(ctx, &mockSrcRepo, gomock.Any()).Return(packageBundle, nil)
result, err := registry.PullBytes(ctx, srcClient, srcArtifact)
assert.NotEmpty(t, result)
assert.NoError(t, err)
}
func TestPullFetchBlobFail(t *testing.T) {
srcClient := mocks.NewMockStorageClient(gomock.NewController(t))
mockSrcRepo := *mocks.NewMockRepository(gomock.NewController(t))
desc := ocispec.Descriptor{
Digest: "sha256:8bc5f46db8c98aedfba4ade0d7ebbdecd8e4130e172d3d62871fc3258c40a910",
}
srcClient.EXPECT().GetStorage(ctx, srcArtifact).Return(&mockSrcRepo, nil)
srcClient.EXPECT().FetchBytes(ctx, &mockSrcRepo, srcArtifact).Return(desc, imageManifest, nil)
srcClient.EXPECT().FetchBlob(ctx, &mockSrcRepo, gomock.Any()).Return(packageBundle, fmt.Errorf("oops"))
result, err := registry.PullBytes(ctx, srcClient, srcArtifact)
assert.Nil(t, result)
assert.EqualError(t, err, "fetch blob: oops")
}
func TestPullUnmarshalFail(t *testing.T) {
srcClient := mocks.NewMockStorageClient(gomock.NewController(t))
mockSrcRepo := *mocks.NewMockRepository(gomock.NewController(t))
desc := ocispec.Descriptor{
Digest: "sha256:8bc5f46db8c98aedfba4ade0d7ebbdecd8e4130e172d3d62871fc3258c40a910",
}
srcClient.EXPECT().GetStorage(ctx, srcArtifact).Return(&mockSrcRepo, nil)
srcClient.EXPECT().FetchBytes(ctx, &mockSrcRepo, srcArtifact).Return(desc, badImageManifest, nil)
result, err := registry.PullBytes(ctx, srcClient, srcArtifact)
assert.Nil(t, result)
assert.EqualError(t, err, "unmarshal manifest: unexpected end of JSON input")
}
func TestPullNoLayerFail(t *testing.T) {
srcClient := mocks.NewMockStorageClient(gomock.NewController(t))
mockSrcRepo := *mocks.NewMockRepository(gomock.NewController(t))
desc := ocispec.Descriptor{
Digest: "sha256:8bc5f46db8c98aedfba4ade0d7ebbdecd8e4130e172d3d62871fc3258c40a910",
}
srcClient.EXPECT().GetStorage(ctx, srcArtifact).Return(&mockSrcRepo, nil)
srcClient.EXPECT().FetchBytes(ctx, &mockSrcRepo, srcArtifact).Return(desc, noLayersImageManifest, nil)
result, err := registry.PullBytes(ctx, srcClient, srcArtifact)
assert.Nil(t, result)
assert.EqualError(t, err, "missing layer")
}
func TestPullFetchBytesFail(t *testing.T) {
srcClient := mocks.NewMockStorageClient(gomock.NewController(t))
mockSrcRepo := *mocks.NewMockRepository(gomock.NewController(t))
desc := ocispec.Descriptor{
Digest: "sha256:8bc5f46db8c98aedfba4ade0d7ebbdecd8e4130e172d3d62871fc3258c40a910",
}
srcClient.EXPECT().GetStorage(ctx, srcArtifact).Return(&mockSrcRepo, nil)
srcClient.EXPECT().FetchBytes(ctx, &mockSrcRepo, srcArtifact).Return(desc, imageManifest, fmt.Errorf("oops"))
result, err := registry.PullBytes(ctx, srcClient, srcArtifact)
assert.Nil(t, result)
assert.EqualError(t, err, "fetch manifest: oops")
}
func TestPullGetStorageFail(t *testing.T) {
srcClient := mocks.NewMockStorageClient(gomock.NewController(t))
mockSrcRepo := *mocks.NewMockRepository(gomock.NewController(t))
srcClient.EXPECT().GetStorage(ctx, srcArtifact).Return(&mockSrcRepo, fmt.Errorf("oops"))
result, err := registry.PullBytes(ctx, srcClient, srcArtifact)
assert.Nil(t, result)
assert.EqualError(t, err, "repository source: oops")
}
| 122 |
eks-anywhere-packages | aws | Go | package registry
import (
"context"
"crypto/x509"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
orasregistry "oras.land/oras-go/v2/registry"
)
// StorageContext describes aspects of a registry.
type StorageContext struct {
host string
project string
credentialStore *DockerCredentialStore
certificates *x509.CertPool
insecure bool
}
// NewStorageContext create registry context.
func NewStorageContext(host string, credentialStore *DockerCredentialStore, certificates *x509.CertPool, insecure bool) StorageContext {
return StorageContext{
host: host,
credentialStore: credentialStore,
certificates: certificates,
insecure: insecure,
}
}
// StorageClient interface for general image storage client.
type StorageClient interface {
Resolve(ctx context.Context, srcStorage orasregistry.Repository, versionedImage string) (desc ocispec.Descriptor, err error)
GetStorage(ctx context.Context, image Artifact) (repo orasregistry.Repository, err error)
SetProject(project string)
Destination(image Artifact) string
FetchBytes(ctx context.Context, srcStorage orasregistry.Repository, artifact Artifact) (ocispec.Descriptor, []byte, error)
FetchBlob(ctx context.Context, srcStorage orasregistry.Repository, descriptor ocispec.Descriptor) ([]byte, error)
CopyGraph(ctx context.Context, srcStorage orasregistry.Repository, dstStorage orasregistry.Repository, desc ocispec.Descriptor) error
}
| 40 |
eks-anywhere-packages | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: oras.land/oras-go/v2/registry (interfaces: Repository)
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
io "io"
reflect "reflect"
gomock "github.com/golang/mock/gomock"
v1 "github.com/opencontainers/image-spec/specs-go/v1"
registry "oras.land/oras-go/v2/registry"
)
// MockRepository is a mock of Repository interface.
type MockRepository struct {
ctrl *gomock.Controller
recorder *MockRepositoryMockRecorder
}
// MockRepositoryMockRecorder is the mock recorder for MockRepository.
type MockRepositoryMockRecorder struct {
mock *MockRepository
}
// NewMockRepository creates a new mock instance.
func NewMockRepository(ctrl *gomock.Controller) *MockRepository {
mock := &MockRepository{ctrl: ctrl}
mock.recorder = &MockRepositoryMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder {
return m.recorder
}
// Blobs mocks base method.
func (m *MockRepository) Blobs() registry.BlobStore {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Blobs")
ret0, _ := ret[0].(registry.BlobStore)
return ret0
}
// Blobs indicates an expected call of Blobs.
func (mr *MockRepositoryMockRecorder) Blobs() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Blobs", reflect.TypeOf((*MockRepository)(nil).Blobs))
}
// Delete mocks base method.
func (m *MockRepository) Delete(arg0 context.Context, arg1 v1.Descriptor) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// Delete indicates an expected call of Delete.
func (mr *MockRepositoryMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepository)(nil).Delete), arg0, arg1)
}
// Exists mocks base method.
func (m *MockRepository) Exists(arg0 context.Context, arg1 v1.Descriptor) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Exists", arg0, arg1)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Exists indicates an expected call of Exists.
func (mr *MockRepositoryMockRecorder) Exists(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockRepository)(nil).Exists), arg0, arg1)
}
// Fetch mocks base method.
func (m *MockRepository) Fetch(arg0 context.Context, arg1 v1.Descriptor) (io.ReadCloser, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Fetch", arg0, arg1)
ret0, _ := ret[0].(io.ReadCloser)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Fetch indicates an expected call of Fetch.
func (mr *MockRepositoryMockRecorder) Fetch(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockRepository)(nil).Fetch), arg0, arg1)
}
// FetchReference mocks base method.
func (m *MockRepository) FetchReference(arg0 context.Context, arg1 string) (v1.Descriptor, io.ReadCloser, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FetchReference", arg0, arg1)
ret0, _ := ret[0].(v1.Descriptor)
ret1, _ := ret[1].(io.ReadCloser)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
}
// FetchReference indicates an expected call of FetchReference.
func (mr *MockRepositoryMockRecorder) FetchReference(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchReference", reflect.TypeOf((*MockRepository)(nil).FetchReference), arg0, arg1)
}
// Manifests mocks base method.
func (m *MockRepository) Manifests() registry.ManifestStore {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Manifests")
ret0, _ := ret[0].(registry.ManifestStore)
return ret0
}
// Manifests indicates an expected call of Manifests.
func (mr *MockRepositoryMockRecorder) Manifests() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Manifests", reflect.TypeOf((*MockRepository)(nil).Manifests))
}
// Push mocks base method.
func (m *MockRepository) Push(arg0 context.Context, arg1 v1.Descriptor, arg2 io.Reader) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Push", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// Push indicates an expected call of Push.
func (mr *MockRepositoryMockRecorder) Push(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockRepository)(nil).Push), arg0, arg1, arg2)
}
// PushReference mocks base method.
func (m *MockRepository) PushReference(arg0 context.Context, arg1 v1.Descriptor, arg2 io.Reader, arg3 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PushReference", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
}
// PushReference indicates an expected call of PushReference.
func (mr *MockRepositoryMockRecorder) PushReference(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushReference", reflect.TypeOf((*MockRepository)(nil).PushReference), arg0, arg1, arg2, arg3)
}
// Referrers mocks base method.
func (m *MockRepository) Referrers(arg0 context.Context, arg1 v1.Descriptor, arg2 string, arg3 func([]v1.Descriptor) error) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Referrers", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
}
// Referrers indicates an expected call of Referrers.
func (mr *MockRepositoryMockRecorder) Referrers(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Referrers", reflect.TypeOf((*MockRepository)(nil).Referrers), arg0, arg1, arg2, arg3)
}
// Resolve mocks base method.
func (m *MockRepository) Resolve(arg0 context.Context, arg1 string) (v1.Descriptor, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Resolve", arg0, arg1)
ret0, _ := ret[0].(v1.Descriptor)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Resolve indicates an expected call of Resolve.
func (mr *MockRepositoryMockRecorder) Resolve(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockRepository)(nil).Resolve), arg0, arg1)
}
// Tag mocks base method.
func (m *MockRepository) Tag(arg0 context.Context, arg1 v1.Descriptor, arg2 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Tag", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// Tag indicates an expected call of Tag.
func (mr *MockRepositoryMockRecorder) Tag(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tag", reflect.TypeOf((*MockRepository)(nil).Tag), arg0, arg1, arg2)
}
// Tags mocks base method.
func (m *MockRepository) Tags(arg0 context.Context, arg1 string, arg2 func([]string) error) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Tags", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// Tags indicates an expected call of Tags.
func (mr *MockRepositoryMockRecorder) Tags(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tags", reflect.TypeOf((*MockRepository)(nil).Tags), arg0, arg1, arg2)
}
| 212 |
eks-anywhere-packages | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: storage.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
registry "github.com/aws/eks-anywhere-packages/pkg/registry"
gomock "github.com/golang/mock/gomock"
v1 "github.com/opencontainers/image-spec/specs-go/v1"
registry0 "oras.land/oras-go/v2/registry"
)
// MockStorageClient is a mock of StorageClient interface.
type MockStorageClient struct {
ctrl *gomock.Controller
recorder *MockStorageClientMockRecorder
}
// MockStorageClientMockRecorder is the mock recorder for MockStorageClient.
type MockStorageClientMockRecorder struct {
mock *MockStorageClient
}
// NewMockStorageClient creates a new mock instance.
func NewMockStorageClient(ctrl *gomock.Controller) *MockStorageClient {
mock := &MockStorageClient{ctrl: ctrl}
mock.recorder = &MockStorageClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStorageClient) EXPECT() *MockStorageClientMockRecorder {
return m.recorder
}
// CopyGraph mocks base method.
func (m *MockStorageClient) CopyGraph(ctx context.Context, srcStorage, dstStorage registry0.Repository, desc v1.Descriptor) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CopyGraph", ctx, srcStorage, dstStorage, desc)
ret0, _ := ret[0].(error)
return ret0
}
// CopyGraph indicates an expected call of CopyGraph.
func (mr *MockStorageClientMockRecorder) CopyGraph(ctx, srcStorage, dstStorage, desc interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyGraph", reflect.TypeOf((*MockStorageClient)(nil).CopyGraph), ctx, srcStorage, dstStorage, desc)
}
// Destination mocks base method.
func (m *MockStorageClient) Destination(image registry.Artifact) string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Destination", image)
ret0, _ := ret[0].(string)
return ret0
}
// Destination indicates an expected call of Destination.
func (mr *MockStorageClientMockRecorder) Destination(image interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Destination", reflect.TypeOf((*MockStorageClient)(nil).Destination), image)
}
// FetchBlob mocks base method.
func (m *MockStorageClient) FetchBlob(ctx context.Context, srcStorage registry0.Repository, descriptor v1.Descriptor) ([]byte, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FetchBlob", ctx, srcStorage, descriptor)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// FetchBlob indicates an expected call of FetchBlob.
func (mr *MockStorageClientMockRecorder) FetchBlob(ctx, srcStorage, descriptor interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlob", reflect.TypeOf((*MockStorageClient)(nil).FetchBlob), ctx, srcStorage, descriptor)
}
// FetchBytes mocks base method.
func (m *MockStorageClient) FetchBytes(ctx context.Context, srcStorage registry0.Repository, artifact registry.Artifact) (v1.Descriptor, []byte, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FetchBytes", ctx, srcStorage, artifact)
ret0, _ := ret[0].(v1.Descriptor)
ret1, _ := ret[1].([]byte)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
}
// FetchBytes indicates an expected call of FetchBytes.
func (mr *MockStorageClientMockRecorder) FetchBytes(ctx, srcStorage, artifact interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBytes", reflect.TypeOf((*MockStorageClient)(nil).FetchBytes), ctx, srcStorage, artifact)
}
// GetStorage mocks base method.
func (m *MockStorageClient) GetStorage(ctx context.Context, image registry.Artifact) (registry0.Repository, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetStorage", ctx, image)
ret0, _ := ret[0].(registry0.Repository)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetStorage indicates an expected call of GetStorage.
func (mr *MockStorageClientMockRecorder) GetStorage(ctx, image interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorage", reflect.TypeOf((*MockStorageClient)(nil).GetStorage), ctx, image)
}
// Resolve mocks base method.
func (m *MockStorageClient) Resolve(ctx context.Context, srcStorage registry0.Repository, versionedImage string) (v1.Descriptor, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Resolve", ctx, srcStorage, versionedImage)
ret0, _ := ret[0].(v1.Descriptor)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Resolve indicates an expected call of Resolve.
func (mr *MockStorageClientMockRecorder) Resolve(ctx, srcStorage, versionedImage interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockStorageClient)(nil).Resolve), ctx, srcStorage, versionedImage)
}
// SetProject mocks base method.
func (m *MockStorageClient) SetProject(project string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetProject", project)
}
// SetProject indicates an expected call of SetProject.
func (mr *MockStorageClientMockRecorder) SetProject(project interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProject", reflect.TypeOf((*MockStorageClient)(nil).SetProject), project)
}
| 140 |
eks-anywhere-packages | aws | Go | package signature
type Domain struct {
Name string
Pubkey string
}
| 7 |
eks-anywhere-packages | aws | Go | package signature
import (
"bytes"
"crypto/ecdsa"
"crypto/sha256"
"crypto/x509"
"encoding/base64"
"encoding/json"
"errors"
"path"
"strings"
"text/template"
"github.com/itchyny/gojq"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"sigs.k8s.io/yaml"
)
const (
PublicKey = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnP0Yo+ZxzPUEfohcG3bbJ8987UT4f0tj+XVBjS/s35wkfjrxTKrVZQpz3ta3zi5ZlgXzd7a20B1U1Py/TtPsxw=="
DomainName = "eksa.aws.com"
SignatureAnnotation = "signature"
ExcludesAnnotation = "excludes"
)
var EksaDomain = Domain{Name: DomainName, Pubkey: PublicKey}
type GojqParams struct {
Excludes []string
Domain Domain
}
var (
AlwaysExcluded = []string{
".status",
".metadata.creationTimestamp",
".metadata.generation",
".metadata.managedFields",
".metadata.uid",
".metadata.resourceVersion",
".spec.minControllerVersion",
}
GojqTemplate = template.Must(template.New("gojq_query").Funcs(
template.FuncMap{
"StringsJoin": strings.Join,
"Escape": func(in string) string {
return strings.ReplaceAll(in, ".", "\\\\.")
},
}).Parse(`
del({{ StringsJoin .Excludes ", "}}) | (.metadata.annotations | objects) |= with_entries(select(.key | test("^{{ Escape .Domain.Name }}/(?:includes|excludes)$") ))
`))
)
type Manifest = metav1.ObjectMetaAccessor
func filter(in []string) []string {
filtered := in[:0]
for _, s := range in {
if s != "" {
filtered = append(filtered, s)
}
}
return filtered
}
func decodeSelectors(selectorsB64Encoded string) (selectors []string, err error) {
decoded, err := base64.StdEncoding.DecodeString(selectorsB64Encoded)
if err != nil {
return selectors, err
}
selectors = filter(strings.Split(string(decoded), "\n"))
for _, arg := range selectors {
parsed, err := gojq.Parse(arg)
if err != nil {
return nil, err
}
if parsed.Term == nil || parsed.Term.Type != gojq.TermTypeIndex {
return nil, errors.New("invalid selector(s) provided")
}
}
return selectors, err
}
func GetMetadataInformation(manifest Manifest, domain Domain) (signature string, excludes []string, err error) {
meta := manifest.GetObjectMeta()
annotations := meta.GetAnnotations()
signature = annotations[path.Join(domain.Name, SignatureAnnotation)]
excludesB64, excludesExists := annotations[path.Join(domain.Name, ExcludesAnnotation)]
if excludesExists {
excludes, err = decodeSelectors(excludesB64)
if err != nil {
return signature, excludes, err
}
}
return signature, excludes, err
}
func GetDigest(manifest Manifest, domain Domain) (digest [32]byte, yml []byte, err error) {
var query *gojq.Query
_, excludes, err := GetMetadataInformation(manifest, domain)
if err != nil {
return [32]byte{}, nil, err
}
renderedQuery := &bytes.Buffer{}
err = GojqTemplate.Execute(renderedQuery, GojqParams{
append(excludes, AlwaysExcluded...),
domain,
})
if err != nil {
return [32]byte{}, nil, err
}
query, err = gojq.Parse(renderedQuery.String())
if err != nil {
return [32]byte{}, nil, err
}
// gojq requires running on raw types, marshal and unmarshall to allow it.
asjson, _ := json.Marshal(manifest)
var unmarshalled interface{}
_ = json.Unmarshal(asjson, &unmarshalled)
jsonIt := query.Run(unmarshalled)
filtered, remaining := jsonIt.Next()
if remaining {
second, rem := jsonIt.Next()
if second != nil && !rem {
return [32]byte{}, nil, errors.New("multiple result from the query should never happen")
}
}
yml, err = yaml.Marshal(filtered)
if err != nil {
return [32]byte{}, nil, errors.New("manifest could not be marshaled to yaml")
}
digest = sha256.Sum256(yml)
return digest, yml, err
}
// See ./testdata/sign_file.sh for a shell script implementation.
// This here differs in that it normalizes quoting while the shell script doesnt (yet).
func ValidateSignature(manifest Manifest, domain Domain) (valid bool, digest [32]byte, yml []byte, err error) {
metaSig, _, err := GetMetadataInformation(manifest, domain)
if err != nil {
return false, [32]byte{}, yml, err
}
if metaSig == "" {
return false, [32]byte{}, yml, errors.New("Missing signature")
}
digest, yml, err = GetDigest(manifest, domain)
if err != nil {
return false, [32]byte{}, yml, err
}
sig, err := base64.StdEncoding.DecodeString(metaSig)
if err != nil {
return false, digest, yml, errors.New("signature in metadata isn't base64 encoded")
}
pubdecoded, err := base64.StdEncoding.DecodeString(domain.Pubkey)
if err != nil {
return false, digest, yml, errors.New("unable to decode the public key (not base 64)")
}
pubparsed, err := x509.ParsePKIXPublicKey(pubdecoded)
if err != nil {
return false, digest, yml, errors.New("unable parse the public key (not PKIX)")
}
pubkey := pubparsed.(*ecdsa.PublicKey)
return ecdsa.VerifyASN1(pubkey, digest[:], sig), digest, yml, nil
}
| 172 |
eks-anywhere-packages | aws | Go | package signature_test
import (
"crypto/sha256"
"encoding/base64"
"os"
"path/filepath"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/aws/eks-anywhere-packages/pkg/signature"
"github.com/aws/eks-anywhere-packages/pkg/testutil"
)
const (
TestPublicKey = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvME/v61IfA4ulmgdF10Ae/WCRqtXvrUtF+0nu0dbdP36u3He4GRepYdQGCmbPe0463yAABZs01/Vv/v52ktlmg=="
)
var (
EksaDomain = Domain{Name: "eksa.aws.com", Pubkey: TestPublicKey}
ExcludesAnnotation = signature.ExcludesAnnotation
SignatureAnnotation = signature.SignatureAnnotation
)
type Domain = signature.Domain
var (
ValidateSignature = signature.ValidateSignature
GetDigest = signature.GetDigest
GetMetadataInformation = signature.GetMetadataInformation
)
func encodedSelectors(selectors []string) (encoded string) {
return base64.StdEncoding.EncodeToString([]byte(strings.Join(selectors, "\n")))
}
func TestValidateSignature(t *testing.T) {
t.Run("valid signature on valid manifest", func(t *testing.T) {
bundle, err := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
if err != nil {
t.Fatal("Unable to get bundle", err)
}
valid, _, _, err := ValidateSignature(bundle, EksaDomain)
assert.True(t, valid, "Signature should be valid for the EKS-A domain")
assert.Nilf(t, err, "An error occured validating the signature: %v", err)
})
t.Run("invalid signature on valid manifest", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
annotations := bundle.GetAnnotations()
annotations[EksaDomain.Name+"/"+SignatureAnnotation] = "XEQCIForAHp6tPUhkfqLfAzbmq0v7p/hgJEqrB5ScWNB4rOOAiBlNtJUzTWNKGxpTepnm8co0YzoNX2HjXRTvaBYQy54Tg=="
valid, _, _, err := ValidateSignature(bundle, EksaDomain)
assert.False(t, valid, "Signature should be invalid for the EKS-A domain")
assert.Nilf(t, err, "An error occured validating the signature: %v", err)
})
t.Run("request for different domain, valid eksa signature, missing requested signature", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
valid, _, _, err := ValidateSignature(bundle, Domain{Name: "eksx.amazon.com", Pubkey: "notakey"})
assert.False(t, valid, "Signature should be invalid for the provided domain")
assert.EqualError(t, err, "Missing signature")
})
t.Run("request for different domain, missing eksa signature, requested signature invalid", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
annotations := bundle.GetAnnotations()
domain := Domain{Name: "fakedomain.com", Pubkey: EksaDomain.Pubkey}
annotations[domain.Name+"/signature"] = annotations[EksaDomain.Name+"/signature"]
delete(annotations, EksaDomain.Name+"/signature")
annotations[domain.Name+"/excludes"] = annotations[EksaDomain.Name+"/excludes"]
delete(annotations, EksaDomain.Name+"/excludes")
valid, _, _, err := ValidateSignature(bundle, domain)
assert.False(t, valid, "Signature should be invalid for the provided domain because `excludes` was changed to a different domain")
assert.Nil(t, err, "No error should occur when validating this signature")
valid, _, _, err = ValidateSignature(bundle, EksaDomain)
assert.False(t, valid, "Signature should be invalid for the Eksa domain")
assert.EqualError(t, err, "Missing signature")
})
t.Run("Valid document with all fields excluded must fail signature validation", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
annotations := bundle.GetAnnotations()
excludes := []string{".apiVersion", ".kind", ".metadata", ".spec"}
annotations[EksaDomain.Name+"/excludes"] = encodedSelectors(excludes)
digest, _, err := GetDigest(bundle, EksaDomain)
// An empty object serializes to "{}" in yaml.
assert.Equal(t, sha256.Sum256([]byte("{}\n")), digest, "This tests validates the behavior of an affectively empty document signature made empty via excludes")
assert.NoError(t, err)
valid, _, _, err := ValidateSignature(bundle, EksaDomain)
assert.False(t, valid, "Signature should be invalid as it's signing actual content")
assert.Nil(t, err, "No error should occur when validating this signature")
})
t.Run("Removing the signature causes validation to fail", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
annotations := bundle.GetAnnotations()
delete(annotations, EksaDomain.Name+"/signature")
valid, _, _, err := ValidateSignature(bundle, EksaDomain)
assert.False(t, valid, "Signature should be invalid as it is missing")
assert.EqualError(t, err, "Missing signature")
})
t.Run("Invalid signature format causes validation to fail with an helpful message", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
annotations := bundle.GetAnnotations()
annotations[EksaDomain.Name+"/signature"] = annotations[EksaDomain.Name+"/signature"] + "="
valid, _, _, err := ValidateSignature(bundle, EksaDomain)
assert.False(t, valid, "Signature should be invalid as it is missing")
assert.EqualError(t, err, "signature in metadata isn't base64 encoded")
})
t.Run("An otherwise valid signature invalid for the provided excludes fails verification", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
annotations := bundle.GetAnnotations()
excludes := []string{".spec.packages[].source.repository", ".spec.packages[].source.registry", ".spec.packages[].source.name"}
annotations[EksaDomain.Name+"/excludes"] = encodedSelectors(excludes)
valid, _, _, err := ValidateSignature(bundle, EksaDomain)
assert.False(t, valid, "Signature should be invalid as it is missing")
assert.Nil(t, err, "No error, the signature is simply invalid")
})
t.Run("Any modification to excludes, even no-op renders the signature invalid", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
annotations := bundle.GetAnnotations()
excludes := []string{".spec.packages[].source.repository", ".spec.packages[].source.registry", ".potato"}
annotations[EksaDomain.Name+"/excludes"] = encodedSelectors(excludes)
valid, _, _, err := ValidateSignature(bundle, EksaDomain)
assert.False(t, valid, "Signature is invalid, .potato was added to excludes, invalidating the signature")
assert.Nil(t, err, "No error, the signature is simply invalid")
})
t.Run("A pod could also be signed", func(t *testing.T) {
pod, _, _ := testutil.GivenPod("testdata/pod_valid.yaml")
valid, _, _, err := ValidateSignature(pod, EksaDomain)
assert.True(t, valid, "Signature should be valid")
assert.Nil(t, err, "No error, the signature should be valid")
})
t.Run("A packagebundle with minControllerVersion can be validated", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_minControllerVersion.yaml")
valid, _, _, err := ValidateSignature(bundle, EksaDomain)
assert.True(t, valid, "The signature should be valid")
assert.Nil(t, err, "No error, the signature is simply invalid")
})
}
func TestMetadata(t *testing.T) {
t.Run("Basic metadata on valid manifest", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
sig, excludes, _ := GetMetadataInformation(bundle, EksaDomain)
assert.ElementsMatchf(t, excludes, []string{".spec.packages[].source.registry", ".spec.packages[].source.repository"}, "Excludes doesn't match the expected value")
assert.IsType(t, "", sig)
assert.Len(t, sig, 96, "Signature length is wrong")
})
t.Run("Invalid excludes fails", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
annotations := bundle.GetAnnotations()
annotations[EksaDomain.Name+"/"+ExcludesAnnotation] = encodedSelectors([]string{"invalid"})
_, excludes, err := GetMetadataInformation(bundle, EksaDomain)
assert.EqualError(t, err, "invalid selector(s) provided")
assert.Nil(t, excludes)
annotations[EksaDomain.Name+"/"+ExcludesAnnotation] = annotations[EksaDomain.Name+"/"+ExcludesAnnotation] + "AA" // Invalid b64
_, excludes, err = GetMetadataInformation(bundle, EksaDomain)
var b64Error base64.CorruptInputError = 12
assert.ErrorIs(t, err, b64Error, "Wrong error type")
assert.Nil(t, excludes)
})
t.Run("jq imports fail validation", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
annotations := bundle.GetAnnotations()
annotations[EksaDomain.Name+"/"+ExcludesAnnotation] = encodedSelectors([]string{"import \"test\""})
_, excludes, err := GetMetadataInformation(bundle, EksaDomain)
assert.NotNil(t, err)
assert.Nil(t, excludes)
})
}
func TestDigest(t *testing.T) {
t.Run("Basic digest on valid manifest", func(t *testing.T) {
bundle, err := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
assert.NoError(t, err)
expectedDigest, err := os.ReadFile(filepath.Clean("testdata/packagebundle_valid.yaml") + ".digest")
assert.NoError(t, err)
digest, _, err := GetDigest(bundle, EksaDomain)
if err != nil {
t.Error(err)
}
assert.Equal(t, string(expectedDigest), base64.StdEncoding.EncodeToString(digest[:]), "Digest doesn't match")
})
t.Run("Basic digest on valid manifest with no excludes", func(t *testing.T) {
bundle, expectedDigest, err := testutil.GivenPod("testdata/pod_valid.yaml")
assert.NoError(t, err)
annotations := bundle.GetAnnotations()
delete(annotations, EksaDomain.Name+"/excludes")
digest, _, err := GetDigest(bundle, EksaDomain)
if err != nil {
t.Error(err)
}
assert.Equal(t, expectedDigest, base64.StdEncoding.EncodeToString(digest[:]), "Digest doesn't match")
})
t.Run("Getting digest on manifest with invalid metadata fails", func(t *testing.T) {
bundle, _ := testutil.GivenPackageBundle("testdata/packagebundle_valid.yaml")
annotations := bundle.GetAnnotations()
annotations[EksaDomain.Name+"/"+ExcludesAnnotation] = "X"
digest, _, err := GetDigest(bundle, EksaDomain)
var b64error base64.CorruptInputError = 0
assert.ErrorIs(t, err, b64error)
assert.Equal(t, digest, [32]byte{})
})
}
| 233 |
eks-anywhere-packages | aws | Go | package testutil
import (
"github.com/aws/eks-anywhere-packages/api/v1alpha1"
"github.com/aws/eks-anywhere-packages/pkg/file"
)
func givenFile(filename string, config file.KindAccessor) error {
reader := file.NewFileReader(filename)
err := reader.Initialize(config)
if err != nil {
return err
}
return reader.Parse(config)
}
func GivenPackage(fileName string) (*v1alpha1.Package, error) {
config := &v1alpha1.Package{}
err := givenFile(fileName, config)
return config, err
}
func GivenPackageBundle(filename string) (*v1alpha1.PackageBundle, error) {
config := &v1alpha1.PackageBundle{}
reader := file.NewFileReader(filename + ".signed")
initError := reader.Initialize(config)
if initError != nil {
return nil, initError
}
actual := reader.Parse(config)
if actual != nil {
return nil, actual
}
return config, nil
}
func GivenBundleController(fileName string) (*v1alpha1.PackageBundleController, error) {
config := &v1alpha1.PackageBundleController{}
err := givenFile(fileName, config)
return config, err
}
| 42 |
eks-anywhere-packages | aws | Go | package testutil
import (
"os"
"path/filepath"
v1 "k8s.io/api/core/v1"
"sigs.k8s.io/yaml"
)
func GivenPod(filename string) (*v1.Pod, string, error) {
content, err := os.ReadFile(filepath.Clean(filename) + ".signed")
if err != nil {
return nil, "", err
}
pod := &v1.Pod{}
err = yaml.UnmarshalStrict(content, pod)
if err != nil {
return nil, "", err
}
digest, err := os.ReadFile(filepath.Clean(filename) + ".digest")
if err != nil {
return nil, "", err
}
return pod, string(digest), nil
}
| 27 |
eks-anywhere-packages | aws | Go | package utils
func Map[T, O any](in []T, mapper func(T) O) []O {
out := make([]O, len(in))
for i, v := range in {
out[i] = mapper(v)
}
return out
}
| 10 |
eks-anywhere-packages | aws | Go | // Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
//
// 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 at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed 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 and
// limitations under the License.
package webhook
import (
"context"
"fmt"
"net/http"
admissionv1 "k8s.io/api/admission/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/rest"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/webhook"
"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
"github.com/aws/eks-anywhere-packages/api/v1alpha1"
"github.com/aws/eks-anywhere-packages/pkg/authenticator"
)
type activeBundleValidator struct {
Client client.Client
Config *rest.Config
decoder *admission.Decoder
tcc authenticator.TargetClusterClient
}
func InitPackageBundleControllerValidator(mgr ctrl.Manager) error {
tcc := authenticator.NewTargetClusterClient(mgr.GetLogger(), mgr.GetConfig(), mgr.GetClient())
mgr.GetWebhookServer().
Register("/validate-packages-eks-amazonaws-com-v1alpha1-packagebundlecontroller",
&webhook.Admission{Handler: &activeBundleValidator{
Client: mgr.GetClient(),
Config: mgr.GetConfig(),
tcc: tcc,
}})
return nil
}
func (v *activeBundleValidator) Handle(ctx context.Context, req admission.Request) admission.Response {
pbc := &v1alpha1.PackageBundleController{}
err := v.decoder.Decode(req, pbc)
if err != nil {
return admission.Errored(http.StatusInternalServerError,
fmt.Errorf("decoding request: %w", err))
}
bundles := &v1alpha1.PackageBundleList{}
err = v.Client.List(ctx, bundles, &client.ListOptions{Namespace: v1alpha1.PackageNamespace})
if err != nil {
return admission.Errored(http.StatusInternalServerError,
fmt.Errorf("listing package bundles: %w", err))
}
resp, err := v.handleInner(ctx, pbc, bundles)
if err != nil {
return admission.Errored(http.StatusInternalServerError, err)
}
return *resp
}
func (v *activeBundleValidator) handleInner(ctx context.Context, pbc *v1alpha1.PackageBundleController, bundles *v1alpha1.PackageBundleList) (
*admission.Response, error) {
if pbc.Spec.ActiveBundle == "" {
resp := &admission.Response{
AdmissionResponse: admissionv1.AdmissionResponse{
Allowed: true,
},
}
return resp, nil
}
var found bool
var theBundle v1alpha1.PackageBundle
for _, b := range bundles.Items {
if b.Name == pbc.Spec.ActiveBundle {
theBundle = b
found = true
break
}
}
if !found {
reason := fmt.Sprintf("activeBundle %q not present on cluster", pbc.Spec.ActiveBundle)
resp := &admission.Response{
AdmissionResponse: admissionv1.AdmissionResponse{
Allowed: false,
Result: &metav1.Status{
Status: metav1.StatusFailure,
Code: http.StatusBadRequest,
Message: reason,
Reason: metav1.StatusReason(reason),
},
},
}
return resp, nil
}
info, err := v.tcc.GetServerVersion(ctx, pbc.Name)
if err != nil {
return nil, fmt.Errorf("getting server version for %s: %w", pbc.Name, err)
}
matches, err := theBundle.KubeVersionMatches(info)
if err != nil {
return nil, fmt.Errorf("listing package bundles: %w", err)
}
if !matches {
reason := fmt.Sprintf("kuberneetes version v%s-%s does not match %s", info.Major, info.Minor, pbc.Spec.ActiveBundle)
resp := &admission.Response{
AdmissionResponse: admissionv1.AdmissionResponse{
Allowed: false,
Result: &metav1.Status{
Status: metav1.StatusFailure,
Code: http.StatusBadRequest,
Message: reason,
Reason: metav1.StatusReason(reason),
},
},
}
return resp, nil
}
resp := &admission.Response{
AdmissionResponse: admissionv1.AdmissionResponse{
Allowed: true,
},
}
return resp, nil
}
var _ admission.DecoderInjector = (*activeBundleValidator)(nil)
// InjectDecoder injects the decoder.
func (v *activeBundleValidator) InjectDecoder(d *admission.Decoder) error {
v.decoder = d
return nil
}
| 155 |
eks-anywhere-packages | aws | Go | // Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
//
// 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 at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed 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 and
// limitations under the License.
package webhook
import (
"context"
"encoding/json"
"fmt"
"log"
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
admissionv1 "k8s.io/api/admission/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/version"
"sigs.k8s.io/controller-runtime/pkg/client"
clientfake "sigs.k8s.io/controller-runtime/pkg/client/fake"
"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
"github.com/aws/eks-anywhere-packages/api/v1alpha1"
"github.com/aws/eks-anywhere-packages/pkg/authenticator/mocks"
)
func TestHandleInner(t *testing.T) {
ctx := context.Background()
t.Run("validates successfully", func(t *testing.T) {
tcc := mocks.NewMockTargetClusterClient(gomock.NewController(t))
tcc.EXPECT().GetServerVersion(gomock.Any(), gomock.Any()).Return(&version.Info{Major: "1", Minor: "21"}, nil)
v := &activeBundleValidator{
tcc: tcc,
}
pbc := &v1alpha1.PackageBundleController{
Spec: v1alpha1.PackageBundleControllerSpec{
ActiveBundle: "v1-21-1001",
},
}
bundles := &v1alpha1.PackageBundleList{
Items: []v1alpha1.PackageBundle{
{
TypeMeta: metav1.TypeMeta{},
ObjectMeta: metav1.ObjectMeta{
Name: "v1-21-1001",
},
Spec: v1alpha1.PackageBundleSpec{},
Status: v1alpha1.PackageBundleStatus{},
},
},
}
resp, err := v.handleInner(ctx, pbc, bundles)
if assert.NoError(t, err) {
assert.NotNil(t, resp)
assert.True(t, resp.AdmissionResponse.Allowed)
}
})
t.Run("invalidates successfully", func(t *testing.T) {
tcc := mocks.NewMockTargetClusterClient(gomock.NewController(t))
tcc.EXPECT().GetServerVersion(gomock.Any(), gomock.Any()).Return(&version.Info{Major: "1", Minor: "20"}, nil)
v := &activeBundleValidator{
tcc: tcc,
}
pbc := &v1alpha1.PackageBundleController{
Spec: v1alpha1.PackageBundleControllerSpec{
ActiveBundle: "v1-21-1001",
},
}
bundles := &v1alpha1.PackageBundleList{
Items: []v1alpha1.PackageBundle{
{
TypeMeta: metav1.TypeMeta{},
ObjectMeta: metav1.ObjectMeta{
Name: "v1-21-1001",
},
Spec: v1alpha1.PackageBundleSpec{},
Status: v1alpha1.PackageBundleStatus{},
},
},
}
resp, err := v.handleInner(ctx, pbc, bundles)
if assert.NoError(t, err) {
assert.NotNil(t, resp)
assert.False(t, resp.AdmissionResponse.Allowed)
}
})
t.Run("handles decoder errors", func(t *testing.T) {
v := &activeBundleValidator{}
req := admission.Request{
AdmissionRequest: admissionv1.AdmissionRequest{
Object: runtime.RawExtension{
Raw: nil,
},
},
}
resp := v.Handle(ctx, req)
assert.False(t, resp.Allowed)
assert.Contains(t, resp.Result.Message, "decoding request")
})
t.Run("handles list errors", func(t *testing.T) {
pbc := &v1alpha1.PackageBundleController{
Spec: v1alpha1.PackageBundleControllerSpec{
ActiveBundle: "v1-21-1001",
},
Status: v1alpha1.PackageBundleControllerStatus{},
}
pbcBytes, err := json.Marshal(pbc)
require.NoError(t, err)
scheme := runtime.NewScheme()
require.NoError(t, v1alpha1.AddToScheme(scheme))
decoder, err := admission.NewDecoder(scheme)
require.NoError(t, err)
v := &activeBundleValidator{
decoder: decoder,
Client: newFakeClient(scheme),
}
req := admission.Request{
AdmissionRequest: admissionv1.AdmissionRequest{
Object: runtime.RawExtension{
Raw: pbcBytes,
},
},
}
resp := v.Handle(ctx, req)
assert.False(t, resp.Allowed)
assert.Contains(t, resp.Result.Message, "listing package bundles: testing error")
})
t.Run("rejects unknown bundle names", func(t *testing.T) {
v := &activeBundleValidator{}
pbc := &v1alpha1.PackageBundleController{
Spec: v1alpha1.PackageBundleControllerSpec{
ActiveBundle: "v1-21-1002",
},
}
bundles := &v1alpha1.PackageBundleList{
Items: []v1alpha1.PackageBundle{
{
TypeMeta: metav1.TypeMeta{},
ObjectMeta: metav1.ObjectMeta{
Name: "v1-21-1001",
},
Spec: v1alpha1.PackageBundleSpec{},
Status: v1alpha1.PackageBundleStatus{},
},
},
}
resp, err := v.handleInner(ctx, pbc, bundles)
if assert.NoError(t, err) {
assert.False(t, resp.AdmissionResponse.Allowed)
assert.Equal(t, metav1.StatusFailure, resp.AdmissionResponse.Result.Status)
assert.Equal(t, "activeBundle \"v1-21-1002\" not present on cluster", string(resp.AdmissionResponse.Result.Reason))
}
})
}
//
// Test helpers
//
type fakeClient struct {
client.WithWatch
}
//var _ client.WithWatch = (*fakeClient)(nil)
func newFakeClient(scheme *runtime.Scheme) *fakeClient {
fake := clientfake.NewClientBuilder().WithScheme(scheme).Build()
return &fakeClient{
WithWatch: fake,
}
}
func (c *fakeClient) List(ctx context.Context,
obj client.ObjectList, opts ...client.ListOption) error {
log.Printf("list has been called")
return fmt.Errorf("testing error")
}
| 196 |
eks-anywhere-packages | aws | Go | // Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
//
// 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 at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed 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 and
// limitations under the License.
package webhook
import (
"context"
"encoding/base64"
"fmt"
"net/http"
"os"
"github.com/go-logr/logr"
admissionv1 "k8s.io/api/admission/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/webhook"
"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
"github.com/aws/eks-anywhere-packages/api/v1alpha1"
"github.com/aws/eks-anywhere-packages/pkg/bundle"
"github.com/aws/eks-anywhere-packages/pkg/signature"
)
const (
PublicKeyEnvVar = "EKSA_PUBLIC_KEY"
)
type packageBundleValidator struct {
Client client.Client
BundleClient bundle.Client
decoder *admission.Decoder
log logr.Logger
}
func NewPackageBundleValidator(mgr ctrl.Manager) packageBundleValidator {
client := mgr.GetClient()
return packageBundleValidator{
Client: client,
BundleClient: bundle.NewManagerClient(client),
log: mgr.GetLogger().WithName("webhook"),
}
}
func InitPackageBundleValidator(mgr ctrl.Manager) error {
handler := NewPackageBundleValidator(mgr)
mgr.GetWebhookServer().
Register("/validate-packages-eks-amazonaws-com-v1alpha1-packagebundle",
&webhook.Admission{Handler: &handler})
return nil
}
func (v *packageBundleValidator) Handle(_ context.Context, request admission.Request) admission.Response {
pb := &v1alpha1.PackageBundle{}
err := v.decoder.Decode(request, pb)
if err != nil {
return admission.Errored(http.StatusInternalServerError,
fmt.Errorf("decoding request: %w", err))
}
err = v.isPackageBundleValid(pb)
resp := &admission.Response{
AdmissionResponse: admissionv1.AdmissionResponse{Allowed: err == nil},
}
if err != nil {
reason := fmt.Sprintf("package %s failed validation with error: %v", pb.Name, err.Error())
resp.AdmissionResponse.Result = &metav1.Status{
Status: metav1.StatusFailure,
Code: http.StatusBadRequest,
Message: reason,
Reason: metav1.StatusReason(reason),
}
}
return *resp
}
func (v *packageBundleValidator) isPackageBundleValid(pb *v1alpha1.PackageBundle) error {
if !pb.IsValidVersion() {
v.log.Info("Invalid bundle name (should be in the format vx-xx-xxxx where x is a digit): " + pb.Name)
return fmt.Errorf("Invalid bundle name (should be in the format vx-xx-xxxx where x is a digit): " + pb.Name)
}
keyOverride := os.Getenv(PublicKeyEnvVar)
domain := signature.EksaDomain
if keyOverride != "" {
domain = signature.Domain{Name: signature.DomainName, Pubkey: keyOverride}
}
valid, digest, yml, err := signature.ValidateSignature(pb, domain)
if err != nil {
return err
}
if !valid {
v.log.Info("Invalid signature", "Error", err, "Digest", base64.StdEncoding.EncodeToString(digest[:]), "Manifest", string(yml))
return fmt.Errorf("The signature is invalid for the configured public key: " + domain.Pubkey)
}
return nil
}
// InjectDecoder injects the decoder.
func (v *packageBundleValidator) InjectDecoder(d *admission.Decoder) error {
v.decoder = d
return nil
}
| 119 |
eks-anywhere-packages | aws | Go | package webhook
import (
"testing"
"github.com/go-logr/logr"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"github.com/aws/eks-anywhere-packages/api/v1alpha1"
"github.com/aws/eks-anywhere-packages/controllers/mocks"
"github.com/aws/eks-anywhere-packages/pkg/testutil"
)
func TestBundleValidate(t *testing.T) {
t.Setenv("EKSA_PUBLIC_KEY", "")
mockManager := mocks.NewMockManager(gomock.NewController(t))
mockManager.EXPECT().GetClient().Return(nil)
mockManager.EXPECT().GetLogger().Return(logr.Discard())
sut := NewPackageBundleValidator(mockManager)
t.Run("missing signature", func(t *testing.T) {
myBundle := v1alpha1.PackageBundle{ObjectMeta: metav1.ObjectMeta{Name: "v1-21-003"}}
err := sut.isPackageBundleValid(&myBundle)
assert.EqualError(t, err, "Missing signature")
})
t.Run("invalid name", func(t *testing.T) {
myBundle := v1alpha1.PackageBundle{ObjectMeta: metav1.ObjectMeta{Name: "kevin-morby"}}
err := sut.isPackageBundleValid(&myBundle)
assert.EqualError(t, err, "Invalid bundle name (should be in the format vx-xx-xxxx where x is a digit): kevin-morby")
})
t.Run("invalid key", func(t *testing.T) {
t.Setenv(PublicKeyEnvVar, "asdf")
myBundle, err := testutil.GivenPackageBundle("../../api/testdata/bundle_one.yaml")
require.Nil(t, err)
err = sut.isPackageBundleValid(myBundle)
assert.EqualError(t, err, "unable parse the public key (not PKIX)")
})
t.Run("empty env", func(t *testing.T) {
t.Setenv(PublicKeyEnvVar, "")
myBundle, err := testutil.GivenPackageBundle("../../api/testdata/bundle_one.yaml")
require.Nil(t, err)
err = sut.isPackageBundleValid(myBundle)
assert.EqualError(t, err, "The signature is invalid for the configured public key: MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnP0Yo+ZxzPUEfohcG3bbJ8987UT4f0tj+XVBjS/s35wkfjrxTKrVZQpz3ta3zi5ZlgXzd7a20B1U1Py/TtPsxw==")
})
t.Run("env override", func(t *testing.T) {
t.Setenv(PublicKeyEnvVar, "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEvME/v61IfA4ulmgdF10Ae/WCRqtXvrUtF+0nu0dbdP36u3He4GRepYdQGCmbPe0463yAABZs01/Vv/v52ktlmg==")
myBundle, err := testutil.GivenPackageBundle("../../api/testdata/bundle_one.yaml")
require.Nil(t, err)
err = sut.isPackageBundleValid(myBundle)
assert.Nil(t, err)
})
}
| 70 |
eks-anywhere-packages | aws | Go | // Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
//
// 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 at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed 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 and
// limitations under the License.
package webhook
import (
"bytes"
"context"
"fmt"
"net/http"
"os"
"github.com/xeipuuv/gojsonschema"
admissionv1 "k8s.io/api/admission/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/webhook"
"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
"sigs.k8s.io/yaml"
"github.com/aws/eks-anywhere-packages/api/v1alpha1"
"github.com/aws/eks-anywhere-packages/pkg/bundle"
)
type packageValidator struct {
Client client.Client
BundleClient bundle.Client
decoder *admission.Decoder
}
func InitPackageValidator(mgr ctrl.Manager) error {
mgr.GetWebhookServer().
Register("/validate-packages-eks-amazonaws-com-v1alpha1-package",
&webhook.Admission{Handler: &packageValidator{
Client: mgr.GetClient(),
BundleClient: bundle.NewManagerClient(mgr.GetClient()),
}})
return nil
}
func (v *packageValidator) Handle(ctx context.Context, request admission.Request) admission.Response {
p := &v1alpha1.Package{}
err := v.decoder.Decode(request, p)
if err != nil {
return admission.Errored(http.StatusInternalServerError,
fmt.Errorf("decoding request: %w", err))
}
if p.Annotations["anywhere.eks.aws.com/internal"] == "true" {
return admission.Response{AdmissionResponse: admissionv1.AdmissionResponse{Allowed: true}}
}
clusterName := p.GetClusterName()
if clusterName == "" {
clusterName = os.Getenv("CLUSTER_NAME")
}
activeBundle, err := v.BundleClient.GetActiveBundle(ctx, clusterName)
if err != nil {
return admission.Errored(http.StatusInternalServerError, fmt.Errorf("getting PackageBundle: %v", err))
}
isConfigValid, err := v.isPackageValid(p, activeBundle)
resp := &admission.Response{
AdmissionResponse: admissionv1.AdmissionResponse{Allowed: isConfigValid},
}
if !isConfigValid {
reason := fmt.Sprintf("package %s failed validation with error: %v", p.Name, err)
resp.AdmissionResponse.Result = &metav1.Status{
Status: metav1.StatusFailure,
Code: http.StatusBadRequest,
Message: reason,
Reason: metav1.StatusReason(reason),
}
}
return *resp
}
func (v *packageValidator) isPackageValid(p *v1alpha1.Package, activeBundle *v1alpha1.PackageBundle) (bool, error) {
packageInBundle, err := activeBundle.FindPackage(p.Spec.PackageName)
if err != nil {
return false, err
}
version := p.Spec.PackageVersion
if version == "" {
version = v1alpha1.Latest
}
packageVersion, err := activeBundle.FindVersion(packageInBundle, version)
if err != nil {
return false, err
}
if packageInBundle.WorkloadOnly && !p.IsInstalledOnWorkload() {
return false, fmt.Errorf("package %s should only be installed on a workload cluster", p.Name)
}
jsonSchema, err := packageInBundle.GetJsonSchema(&packageVersion)
if err != nil {
return false, err
}
result, err := validatePackage(p, jsonSchema)
if err != nil {
return false, fmt.Errorf(err.Error())
}
if p.Status.Spec.TargetNamespace != "" && p.Status.Spec.TargetNamespace != p.Spec.TargetNamespace {
return false, fmt.Errorf("package %s targetNamespace is immutable", p.Name)
}
b := new(bytes.Buffer)
if !result.Valid() {
for _, e := range result.Errors() {
fmt.Fprintf(b, "- %s\n", e)
}
return false, fmt.Errorf("error validating configurations %s", b.String())
}
return true, nil
}
func validatePackage(p *v1alpha1.Package, jsonSchema []byte) (*gojsonschema.Result, error) {
sl := gojsonschema.NewSchemaLoader()
loader := gojsonschema.NewStringLoader(string(jsonSchema))
schema, err := sl.Compile(loader)
if err != nil {
return nil, fmt.Errorf("error compiling schema %v", err)
}
packageConfigBytes, err := yaml.YAMLToJSON([]byte(p.Spec.Config))
if err != nil {
return nil, fmt.Errorf("error converting package configurations to yaml %v", err)
}
packageConfigString := string(packageConfigBytes)
if p.Spec.Config == "" {
packageConfigString = "{}"
}
configToValidate := gojsonschema.NewStringLoader(packageConfigString)
return schema.Validate(configToValidate)
}
// InjectDecoder injects the decoder.
func (v *packageValidator) InjectDecoder(d *admission.Decoder) error {
v.decoder = d
return nil
}
| 167 |
eks-anywhere-packages | aws | Go | package webhook
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/aws/eks-anywhere-packages/pkg/testutil"
)
func TestPackageValidate(t *testing.T) {
t.Run("valid package", func(t *testing.T) {
activeBundle, err := testutil.GivenPackageBundle("../../api/testdata/bundle_one.yaml")
require.Nil(t, err)
myPackage, err := testutil.GivenPackage("../../api/testdata/package_webhook_valid_config.yaml")
require.Nil(t, err)
validator := packageValidator{}
result, err := validator.isPackageValid(myPackage, activeBundle)
assert.True(t, result)
assert.Nil(t, err)
})
t.Run("invalid package config", func(t *testing.T) {
activeBundle, err := testutil.GivenPackageBundle("../../api/testdata/bundle_one.yaml")
require.Nil(t, err)
myPackage, err := testutil.GivenPackage("../../api/testdata/package_webhook_invalid_config.yaml")
require.Nil(t, err)
validator := packageValidator{}
result, err := validator.isPackageValid(myPackage, activeBundle)
assert.False(t, result)
assert.EqualError(t, err, "error validating configurations - (root): Additional property fakeConfig is not allowed\n")
})
t.Run("invalid package config type", func(t *testing.T) {
activeBundle, err := testutil.GivenPackageBundle("../../api/testdata/bundle_one.yaml")
require.Nil(t, err)
myPackage, err := testutil.GivenPackage("../../api/testdata/package_webhook_invalid_type.yaml")
require.Nil(t, err)
validator := packageValidator{}
result, err := validator.isPackageValid(myPackage, activeBundle)
assert.False(t, result)
assert.EqualError(t, err, "error validating configurations - title: Invalid type. Expected: string, given: integer\n")
})
t.Run("status targetNamespace not set", func(t *testing.T) {
activeBundle, err := testutil.GivenPackageBundle("../../api/testdata/bundle_one.yaml")
require.Nil(t, err)
myPackage, err := testutil.GivenPackage("../../api/testdata/package_webhook_valid_config.yaml")
require.Nil(t, err)
myPackage.Spec.TargetNamespace = "default"
myPackage.Status.Spec.TargetNamespace = ""
validator := packageValidator{}
result, err := validator.isPackageValid(myPackage, activeBundle)
assert.True(t, result)
assert.Nil(t, err)
})
t.Run("status targetNamespace same", func(t *testing.T) {
activeBundle, err := testutil.GivenPackageBundle("../../api/testdata/bundle_one.yaml")
require.Nil(t, err)
myPackage, err := testutil.GivenPackage("../../api/testdata/package_webhook_valid_config.yaml")
require.Nil(t, err)
myPackage.Spec.TargetNamespace = "default"
myPackage.Status.Spec.TargetNamespace = "default"
validator := packageValidator{}
result, err := validator.isPackageValid(myPackage, activeBundle)
assert.True(t, result)
assert.Nil(t, err)
})
t.Run("status targetNamespace not same", func(t *testing.T) {
activeBundle, err := testutil.GivenPackageBundle("../../api/testdata/bundle_one.yaml")
require.Nil(t, err)
myPackage, err := testutil.GivenPackage("../../api/testdata/package_webhook_valid_config.yaml")
require.Nil(t, err)
myPackage.Spec.TargetNamespace = "new-namespace"
myPackage.Status.Spec.TargetNamespace = "default"
validator := packageValidator{}
result, err := validator.isPackageValid(myPackage, activeBundle)
assert.False(t, result)
assert.EqualError(t, err, "package my-hello-eks-anywhere targetNamespace is immutable")
})
}
| 98 |
eks-anywhere-prow-jobs | aws | Go | package main
import (
_ "embed"
"fmt"
"io/ioutil"
"os"
"os/exec"
"path/filepath"
"strings"
"github.com/aws/eks-anywhere-prow-jobs/templater/jobs"
"github.com/aws/eks-distro-prow-jobs/templater/jobs/types"
"github.com/aws/eks-distro-prow-jobs/templater/jobs/utils"
)
var (
jobsFolder = "jobs"
orgsSupported = []string{"aws"}
jobTypes = []string{"periodic", "postsubmit", "presubmit"}
)
//go:embed templates/presubmits.yaml
var presubmitTemplate string
//go:embed templates/postsubmits.yaml
var postsubmitTemplate string
//go:embed templates/periodics.yaml
var periodicTemplate string
//go:embed templates/warning.txt
var editWarning string
//go:generate cp ../BUILDER_BASE_TAG_FILE ./BUILDER_BASE_TAG_FILE
//go:embed BUILDER_BASE_TAG_FILE
var builderBaseTag string
var buildkitImageTag = "v0.10.5-rootless"
func main() {
jobsFolderPath, err := getJobsFolderPath()
if err != nil {
fmt.Printf("Error getting jobs folder path: %v", err)
os.Exit(1)
}
for _, org := range orgsSupported {
if err = os.RemoveAll(filepath.Join(jobsFolderPath, org)); err != nil {
fmt.Printf("Error removing jobs folder path: %v", err)
os.Exit(1)
}
}
for _, jobType := range jobTypes {
jobList, err := jobs.GetJobList(jobType)
if err != nil {
fmt.Printf("Error getting job list: %v\n", err)
os.Exit(1)
}
template, err := useTemplate(jobType)
if err != nil {
fmt.Printf("Error getting job list: %v\n", err)
os.Exit(1)
}
for repoName, jobConfigs := range jobList {
for fileName, jobConfig := range jobConfigs {
envVars := jobConfig.EnvVars
if jobConfig.UseDockerBuildX {
envVars = append(envVars, &types.EnvVar{Name: "BUILDKITD_IMAGE", Value: "moby/buildkit:" + buildkitImageTag})
envVars = append(envVars, &types.EnvVar{Name: "USE_BUILDX", Value: "true"})
}
cluster, bucket, serviceAccountName := clusterDetails(jobType, jobConfig.Cluster, jobConfig.Bucket, jobConfig.ServiceAccountName)
data := map[string]interface{}{
"architecture": jobConfig.Architecture,
"repoName": repoName,
"prowjobName": jobConfig.JobName,
"runIfChanged": jobConfig.RunIfChanged,
"skipIfOnlyChanged": jobConfig.SkipIfOnlyChanged,
"branches": jobConfig.Branches,
"cronExpression": jobConfig.CronExpression,
"maxConcurrency": jobConfig.MaxConcurrency,
"timeout": jobConfig.Timeout,
"extraRefs": jobConfig.ExtraRefs,
"imageBuild": jobConfig.ImageBuild,
"useDockerBuildX": jobConfig.UseDockerBuildX,
"prCreation": jobConfig.PRCreation,
"runtimeImage": jobConfig.RuntimeImage,
"localRegistry": jobConfig.LocalRegistry,
"serviceAccountName": serviceAccountName,
"command": strings.Join(jobConfig.Commands, "\n&&\n"),
"builderBaseTag": builderBaseTag,
"buildkitImageTag": buildkitImageTag,
"resources": jobConfig.Resources,
"envVars": envVars,
"volumes": jobConfig.Volumes,
"volumeMounts": jobConfig.VolumeMounts,
"editWarning": editWarning,
"automountServiceAccountToken": jobConfig.AutomountServiceAccountToken,
"cluster": cluster,
"bucket": bucket,
"projectPath": jobConfig.ProjectPath,
"diskUsage": true,
}
err := GenerateProwjob(fileName, template, data)
if err != nil {
fmt.Printf("Error generating Prowjob %s: %v\n", fileName, err)
os.Exit(1)
}
}
}
}
}
func GenerateProwjob(prowjobFileName, templateContent string, data map[string]interface{}) error {
bytes, err := utils.ExecuteTemplate(templateContent, data)
if err != nil {
return fmt.Errorf("error executing template: %v", err)
}
jobsFolderPath, err := getJobsFolderPath()
if err != nil {
return fmt.Errorf("error getting jobs folder path: %v", err)
}
prowjobPath := filepath.Join(jobsFolderPath, data["repoName"].(string), prowjobFileName)
if err = os.MkdirAll(filepath.Dir(prowjobPath), 0o755); err != nil {
return fmt.Errorf("error creating Prowjob directory: %v", err)
}
if err = ioutil.WriteFile(prowjobPath, bytes, 0o644); err != nil {
return fmt.Errorf("error writing to path %s: %v", prowjobPath, err)
}
return nil
}
func getJobsFolderPath() (string, error) {
gitRootOutput, err := exec.Command("git", "rev-parse", "--show-toplevel").Output()
if err != nil {
return "", fmt.Errorf("error running the git command: %v", err)
}
gitRoot := strings.Fields(string(gitRootOutput))[0]
return filepath.Join(gitRoot, jobsFolder), nil
}
func useTemplate(jobType string) (string, error) {
switch jobType {
case "periodic":
return periodicTemplate, nil
case "postsubmit":
return postsubmitTemplate, nil
case "presubmit":
return presubmitTemplate, nil
default:
return "", fmt.Errorf("Unsupported job type: %s", jobType)
}
}
func clusterDetails(jobType string, cluster string, bucket string, serviceAccountName string) (string, string, string) {
if jobType == "presubmit" && len(cluster) == 0 {
cluster = "prow-presubmits-cluster"
bucket = "s3://prowpresubmitsdataclusterstack-prowbucket7c73355c-vfwwxd2eb4gp"
serviceAccountName = "presubmits-build-account"
}
if (jobType == "postsubmit" || jobType == "periodic") && len(cluster) == 0 {
cluster = "prow-postsubmits-cluster"
bucket = "s3://prowdataclusterstack-316434458-prowbucket7c73355c-1n9f9v93wpjcm"
serviceAccountName = "postsubmits-build-account"
}
return cluster, bucket, serviceAccountName
}
| 181 |
eks-anywhere-prow-jobs | aws | Go | package jobs
import (
"fmt"
"github.com/aws/eks-distro-prow-jobs/templater/jobs/types"
"github.com/aws/eks-distro-prow-jobs/templater/jobs/utils"
)
func GetJobList(jobType string) (map[string]map[string]types.JobConfig, error) {
switch jobType {
case "periodic":
repos := []string{"eks-anywhere", "eks-anywhere-build-tooling"}
periodicsList, err := utils.GetJobsByType(repos, "periodic")
if err != nil {
return nil, fmt.Errorf("error getting periodic list:%v", err)
}
return periodicsList, nil
case "postsubmit":
repos := []string{"eks-anywhere"}
postsubmitsList, err := utils.GetJobsByType(repos, "postsubmit")
if err != nil {
return nil, fmt.Errorf("error getting postsubmits list:%v", err)
}
return postsubmitsList, nil
case "presubmit":
repos := []string{"eks-anywhere", "eks-anywhere-build-tooling", "eks-anywhere-packages", "eks-anywhere-prow-jobs"}
presubmitsList, err := utils.GetJobsByType(repos, "presubmit")
if err != nil {
return nil, fmt.Errorf("error getting presubmits list:%v", err)
}
return presubmitsList, nil
default:
return nil, fmt.Errorf("Unsupported job type: %s", jobType)
}
}
| 37 |
eks-distro | aws | Go | package main
import (
"flag"
"fmt"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"regexp"
"strings"
)
var (
outputStream io.Writer = os.Stdout
errStream io.Writer = os.Stderr
)
type Command struct {
releaseBranch string
releaseVariant string
gitRoot string
release string
artifactBucket string
makeTarget string
makeArgs []string
dryRun bool
}
func (c *Command) buildProject(projectPath string) error {
commandArgs := []string{
"-C",
filepath.Join(c.gitRoot, "projects", projectPath),
}
allMakeTargets := strings.Split(c.makeTarget, ",")
commandArgs = append(commandArgs, allMakeTargets...)
commandArgs = append(commandArgs, c.makeArgs...)
cmd := exec.Command("make", commandArgs...)
log.Printf("Executing: %s", strings.Join(cmd.Args, " "))
cmd.Stdout = outputStream
cmd.Stderr = errStream
if !c.dryRun {
err := cmd.Run()
if err != nil {
return fmt.Errorf("Error running make: %v", err)
}
}
return nil
}
func main() {
target := flag.String("target", "release", "Make target")
releaseBranch := flag.String("release-branch", "1-19", "Release branch to test")
releaseVariant := flag.String("release-variant", "", "Release variant to test")
release := flag.String("release", "1", "Release to test")
region := flag.String("region", "us-west-2", "AWS region to use")
accountId := flag.String("account-id", "", "AWS Account ID to use")
imageRepo := flag.String("image-repo", "", "Container image repository")
artifactBucket := flag.String("artifact-bucket", "", "S3 bucket for artifacts")
gitRoot := flag.String("git-root", "", "Git root directory")
dryRun := flag.Bool("dry-run", false, "Echo out commands, but don't run them")
rebuildAll := flag.Bool("rebuild-all", false, "Rebuild all projects, regardless of changes present")
buildKubeFirst := flag.Bool("build-kubernetes-first", true, "Build kubernetes projects first then other components")
flag.Parse()
log.Printf("Running postsubmit - dry-run: %t", *dryRun)
c := &Command{
releaseBranch: *releaseBranch,
releaseVariant: *releaseVariant,
release: *release,
artifactBucket: *artifactBucket,
gitRoot: *gitRoot,
makeTarget: *target,
dryRun: *dryRun,
}
if c.gitRoot == "" {
gitRootOutput, err := exec.Command("git", "rev-parse", "--show-toplevel").Output()
if err != nil {
log.Fatalf("Error running finding git root: %v", err)
}
c.gitRoot = strings.Fields(string(gitRootOutput))[0]
}
c.makeArgs = []string{
fmt.Sprintf("RELEASE_BRANCH=%s", c.releaseBranch),
fmt.Sprintf("RELEASE=%s", c.release),
fmt.Sprintf("AWS_REGION=%s", *region),
fmt.Sprintf("AWS_ACCOUNT_ID=%s", *accountId),
fmt.Sprintf("IMAGE_REPO=%s", *imageRepo),
}
cmd := exec.Command("git", "-C", c.gitRoot, "diff", "--name-only", "HEAD^", "HEAD")
log.Printf("Executing command: %s", strings.Join(cmd.Args, " "))
gitDiffOutput, err := cmd.Output()
if err != nil {
log.Fatalf("error running git diff: %v\n%s", err, string(gitDiffOutput))
}
filesChanged := strings.Fields(string(gitDiffOutput))
allChanged := false
buildOrderKube := []string{
"kubernetes/release",
"kubernetes/kubernetes",
"kubernetes/cloud-provider-aws",
}
buildOrder := []string{
"containernetworking/plugins",
"coredns/coredns",
"etcd-io/etcd",
"kubernetes-sigs/aws-iam-authenticator",
"kubernetes-sigs/metrics-server",
"kubernetes-csi/external-attacher",
"kubernetes-csi/external-resizer",
"kubernetes-csi/livenessprobe",
"kubernetes-csi/node-driver-registrar",
"kubernetes-csi/external-snapshotter",
"kubernetes-csi/external-provisioner",
}
if *buildKubeFirst {
buildOrder = append(buildOrderKube[:], buildOrder...)
} else {
buildOrder = append(buildOrder[:], buildOrderKube...)
}
type changedStruct struct {
changed bool
}
projects := make(map[string]*changedStruct)
for _, projectPath := range buildOrder {
projects[projectPath] = &changedStruct{}
}
if *rebuildAll {
allChanged = true
} else {
for _, file := range filesChanged {
for projectPath := range projects {
if strings.Contains(file, projectPath) {
projects[projectPath].changed = true
}
}
r := regexp.MustCompile("^Makefile$|^Common.mk$|cmd/main_postsubmit.go|EKS_DISTRO_.*_TAG_FILE|^release/.*|^build/lib/.*")
if r.MatchString(file) {
allChanged = true
}
}
}
for _, projectPath := range buildOrder {
if projects[projectPath].changed || allChanged {
err = c.buildProject(projectPath)
if err != nil {
log.Fatalf("error building %s: %v", projectPath, err)
}
}
}
}
| 164 |
eks-distro | aws | Go | package main
import (
"fmt"
"log"
"github.com/aws/eks-distro/cmd/release/utils/projects"
"github.com/aws/eks-distro/cmd/release/utils/values"
)
// Prints GitTag and Golang versions for each project and release branch.
// Uses local values, which may differ from what's in the upstream EKS-D repo
// or the versions in the current releases.
func main() {
eksdProjects, err := projects.GetProjects()
if err != nil {
log.Fatalf("getting projects: %v", err)
}
releaseBranches, err := values.GetSupportedReleaseBranchesStrings()
if err != nil {
log.Fatalf("getting suppoerted release branches: %v", err)
}
for _, project := range eksdProjects {
fmt.Printf("\n%s / %s\n", project.GetOrg(), project.GetRepo())
for _, rb := range releaseBranches {
version, err := project.GetVersion(rb)
if err != nil {
log.Fatalf("getting %s/%s versions for %s: %v", project.GetOrg(), project.GetRepo(), rb, err)
}
fmt.Printf(" ◦ %s ➜ %-10s%s\n", rb, version.GetGitTag(), version.GetGolang())
}
fmt.Printf(" %s/tags\n", project.GetGitHubURL())
}
println()
}
| 38 |
eks-distro | aws | Go | package main
import (
"flag"
"log"
"strconv"
"github.com/aws/eks-distro/cmd/release/docs/existingdocs"
"github.com/aws/eks-distro/cmd/release/docs/newdocs"
"github.com/aws/eks-distro/cmd/release/utils/changetype"
"github.com/aws/eks-distro/cmd/release/utils/git"
"github.com/aws/eks-distro/cmd/release/utils/release"
"github.com/aws/eks-distro/cmd/release/utils/values"
)
const (
changeType = changetype.Docs
firstMinorReleaseNumber = "1"
)
// Generates docs for release. The release MUST already be out, and all upstream changes MUST be pulled down locally.
// Value for 'branch' flag must be provided.
//
// !!! IMPORTANT INFO IF GENERATING DOCS FOR A NEW MINOR RELEASE !!!
//
// All releases for the new minor version must be tagged before running. Since there are no docs commits that are
// associated with them, the prod release commit for each should be tagged. This program assumes this is the case and
// the changelog generation will not work correctly if this is not true.
//
// When the release number is 1 (i.e. this is the first time docs will be added for this minor release), you MUST
// manually do the below changes BEFORE running it. See example https://github.com/aws/eks-distro/pull/2070
// - In the root README.md and under the ## Releases section, look for the previous release's section. It
// should start with ### Kubernetes 1-XX, have an empty line, and then have a three row table. Copy all five
// lines. Paste them just above the lines you copied. ONLY change the minor version in the first line to be
// for the new one. Do not change any other lines, even if they are for the previous minor version. This
// program will handle this.
// - In docs/contents/index.md, look for the section ### Release Version Dependencies. Copy ONLY the previous
// releases header section (i.e. #### EKS-D 1.XX Version Dependencies), paste it above the copied line, and
// change the minor release number to be the new one. Do not add anything other than this line.
//
// TODO: fix the hacky code related to opening PRs and git commands. It is bad, and I am sorry.
func main() {
branch := flag.String("branch", "", "Release branch, e.g. 1-23")
hasManageGitAndPR := flag.Bool("manageGitAndOpenPR", true, "If PR and all git should be done")
hasReleaseAnnouncement := flag.Bool("releaseAnnouncement", true, "If changes in changelog should be generated")
overrideNumber := flag.Int("optionalOverrideNumber", release.InvalidNumberUpperLimit,
"USE WITH CAUTION! Value to force override for number. Any value less than or equal to "+
strconv.Itoa(release.InvalidNumberUpperLimit)+" is considered an indication that the number should not be overridden.")
flag.Parse()
//////////// Create Release ////////////////////////////////////
// The actual release MUST already be out, and all upstream changes MUST be pulled down locally.
r, err := func(overrideNum int, branch *string) (*release.Release, error) {
if overrideNum > release.InvalidNumberUpperLimit {
return release.NewReleaseOverrideNumber(*branch, strconv.Itoa(overrideNum))
} else {
return release.NewRelease(*branch, changeType)
}
}(*overrideNumber, branch)
if err != nil {
log.Fatalf("creating release info for docs: %v", err)
}
//////////// Create Git Manager ////////////////////////////////////
var gm *git.Manager
if *hasManageGitAndPR {
gm, err = git.CreateGitManager(r.Branch(), r.Number(), changeType)
if err != nil {
log.Fatalf("creating new git manager: %v", err)
}
}
//////////// Create new docs ////////////////////////////////////
log.Println("Starting to create new docs")
abandon := abandonFunc(gm)
if r.Number() == firstMinorReleaseNumber {
log.Println("Creating new directory for new minor release")
if _, err := values.MakeNewDirectory(values.GetReleaseBranchDocsDirectory(r)); err != nil {
log.Fatalf("creating new minor release docs directory: %v", err)
}
}
docs, err := newdocs.CreateNewDocsInput(r, *hasReleaseAnnouncement)
if err != nil {
abandon()
log.Fatalf("creating new docs input: %v", err)
}
newDocsDir, err := values.MakeNewDirectory(values.GetReleaseDocsDirectory(r))
if err != nil {
abandon()
log.Fatalf("creating new directory for release docs: %v", err)
}
cleanUpDir := cleanUpDirFunc(gm, *newDocsDir)
if err = newdocs.GenerateNewDocs(docs, *newDocsDir); err != nil {
cleanUpDir()
log.Fatalf("creating new docs: %v", err)
}
if *hasManageGitAndPR {
if err = gm.AddAndCommitDirectory(*newDocsDir); err != nil {
cleanUpDir()
log.Fatalf("adding and committing new docs %q\n%v", newDocsDir, err)
}
}
log.Println("Finished creating new docs\n--------------------------")
//////////// Update existing docs ////////////////////////////////////
log.Println("Starting to update existing new docs")
cleanUp := cleanUpFunc(gm)
var existingDocsUpdateFuncs = map[values.AbsolutePath]func(*release.Release, string) error{
values.IndexPath: existingdocs.UpdateDocsIndex,
values.ReadmePath: existingdocs.UpdateREADME,
}
for ap, updateFunc := range existingDocsUpdateFuncs {
log.Printf("Starting update of %v\n", ap)
if err = updateFunc(r, ap.String()); err != nil {
cleanUp(ap)
log.Fatalf("updating %s: %v", ap, err)
}
if *hasManageGitAndPR {
if err = gm.AddAndCommit(ap); err != nil {
cleanUp(ap)
log.Fatalf("adding and committing %s after changes had been made: %v", ap, err)
}
}
log.Printf("Successfully updated %v\n", ap)
}
log.Println("Finished updating existing docs\n--------------------------")
//////////// Open PR ////////////////////////////////////
if *hasManageGitAndPR {
if err = gm.OpenPR(); err != nil {
log.Fatalf("opening PR: %v", err)
}
}
}
func abandonFunc(gm *git.Manager) func() {
if gm == nil {
return func() {}
}
return func() {
if abandonErr := gm.Abandon(); abandonErr != nil {
log.Printf("encountered error while attempting to abandon branch due to earlier error: %v", abandonErr)
}
}
}
func cleanUpDirFunc(gm *git.Manager, nd values.NewDirectory) func() {
if gm == nil {
return func() {}
}
return func() {
if cleanUpErr := gm.DeleteDirectoryAndAbandonAllChanges(&nd); cleanUpErr != nil {
log.Printf("encountered an error while attemptng to clean up due to earlier error: %v", cleanUpErr)
}
}
}
func cleanUpFunc(gm *git.Manager) func(values.AbsolutePath) {
if gm == nil {
return func(values.AbsolutePath) {}
}
return func(ap values.AbsolutePath) {
cleanUpErrs := gm.RestoreFileAndAbandonAllChanges(ap)
if len(cleanUpErrs) > 0 {
log.Printf("encountered %d error(s) while attemptng to clean up due to earlier error: %v",
len(cleanUpErrs), cleanUpErrs)
}
}
}
| 186 |
eks-distro | aws | Go | package existingdocs
import (
"bytes"
"fmt"
"os"
"time"
"github.com/aws/eks-distro/cmd/release/utils/release"
"github.com/aws/eks-distro/cmd/release/utils/values"
)
var linebreak = []byte("\n")
// UpdateDocsIndex updates the doc's directory index.md file for the current release.
func UpdateDocsIndex(r *release.Release, docsIndexPath string) error {
data, err := os.ReadFile(docsIndexPath)
if err != nil {
return fmt.Errorf("reading doc index file: %w", err)
}
splitData := bytes.Split(data, linebreak)
currLineNumber := 0
// Update 'RELEASE=<number>' if branch is default branch
isDefaultBranch, err := values.IsDefaultReleaseBranch(r.Branch())
if err != nil {
return err
}
if isDefaultBranch {
hasFoundLine := false
linePrefix := []byte("RELEASE=")
expectedPreviousLine := []byte("RELEASE_BRANCH=" + r.Branch())
for i := 1; i < len(splitData); i++ {
if bytes.HasPrefix(splitData[i], linePrefix) && bytes.Equal(splitData[i-1], expectedPreviousLine) {
hasFoundLine = true
currLineNumber = i
break
}
}
if !hasFoundLine {
return fmt.Errorf("updating index file because did not find line %q", expectedPreviousLine)
}
splitData[currLineNumber] = append(linePrefix, []byte(r.Number())...)
}
// Adds a link to index.md for the new release in the section for its release branch.
hasFoundSection := false
sectionHeader := []byte(fmt.Sprintf("#### EKS-D %s Version Dependencies", r.KubernetesMinorVersion()))
for j := currLineNumber; j < len(splitData)-1; j++ {
if bytes.Equal(sectionHeader, splitData[j]) {
currLineNumber = j
hasFoundSection = true
break
}
}
if !hasFoundSection {
return fmt.Errorf("updating index file because did not find section for Version Dependencies")
}
newLine := fmt.Sprintf(`* [%s](releases/%s/%s/index.md) (%s)`, r.Tag(), r.Branch(), r.Number(), getDate())
splitData[currLineNumber] = append(append(splitData[currLineNumber], linebreak...), newLine...)
return os.WriteFile(docsIndexPath, bytes.Join(splitData, linebreak), 0644)
}
func getDate() string {
return time.Now().Format("January 02, 2006")
}
| 69 |
eks-distro | aws | Go | package existingdocs
import (
"bytes"
"fmt"
"os"
"github.com/aws/eks-distro/cmd/release/utils/release"
)
// UpdateREADME updates the README to replace release manifest from previous patch release with the new one.
func UpdateREADME(release *release.Release, readmePath string) error {
data, err := os.ReadFile(readmePath)
if err != nil {
return fmt.Errorf("reading README: %w", err)
}
// Example:
// ### Kubernetes 1-23
//
// | Release | Manifest | Kubernetes Version |
// | --- | --- | --- |
// | 4 | [1-23-eks-4](https://distro.eks.amazonaws.com/kubernetes-1-23/kubernetes-1-23-eks-4.yaml) | v1.23.9 | <- line to change
expectedLine := []byte("### Kubernetes " + release.Branch())
lineToUpdate := []byte(fmt.Sprintf("| %s | [%s](%s) | [%s](%s) |", release.Number(), release.Tag(), release.ManifestURL(), release.KubernetesGitTag(), release.KubernetesURL()))
numberOfLinesBetweenExpectedLineAndLineToUpdate := 4
splitData := bytes.Split(data, linebreak)
for i := 0; i < len(splitData)-numberOfLinesBetweenExpectedLineAndLineToUpdate; i++ {
if bytes.Equal(expectedLine, splitData[i]) {
splitData[i+numberOfLinesBetweenExpectedLineAndLineToUpdate] = lineToUpdate
return os.WriteFile(readmePath, bytes.Join(splitData, linebreak), 0644)
}
}
return fmt.Errorf("finding line (%q) needed to update version tag in %s", expectedLine, readmePath)
}
| 37 |
eks-distro | aws | Go | package newdocs
import (
"fmt"
"io"
"log"
"os"
"github.com/aws/eks-distro/cmd/release/utils/values"
)
// GenerateNewDocs writes to each doc in provided docs.
func GenerateNewDocs(newDocsInput []NewDocInput, docsDir values.NewDirectory) error {
for _, doc := range newDocsInput {
fullFilePath := fmt.Sprint(docsDir.String() + "/" + doc.FileName)
err := writeToNewDoc(doc, fullFilePath)
if err != nil {
return fmt.Errorf("writing to new docs: %w", err)
}
log.Printf("Successfully wrote to %v\n", doc.FileName)
}
return nil
}
func writeToNewDoc(doc NewDocInput, fullFilePath string) error {
docFile, err := os.Create(fullFilePath)
if err != nil {
return fmt.Errorf("creating file %s: %w", fullFilePath, err)
}
docsWriter := io.Writer(docFile)
_, err = doc.TemplateWriter.WriteTo(docsWriter)
if err != nil {
return fmt.Errorf("writing to file %s: %w", fullFilePath, err)
}
if doc.AppendToEnd != nil {
additionalText, appendErr := doc.AppendToEnd()
if appendErr != nil {
closeFile(docFile)
return fmt.Errorf("getting additional text append to file: %w", appendErr)
}
if _, err = docFile.WriteString(additionalText + "\n"); err != nil {
closeFile(docFile)
return fmt.Errorf("appending additional text to file: %w", err)
}
}
closeFile(docFile)
return nil
}
func closeFile(f *os.File) {
if err := f.Close(); err != nil {
log.Printf("Encountered error when attempting to close file: %v\n", err)
}
}
| 57 |
eks-distro | aws | Go | package newdocs
import (
"bytes"
"fmt"
"strconv"
"github.com/aws/eks-distro/cmd/release/utils/values"
)
type NewDocInput struct {
FileName string
TemplateWriter bytes.Buffer
AppendToEnd func() (string, error)
}
type releaseInfo interface {
Tag() string
ManifestURL() string
KubernetesMinorVersion() string
Number() string
}
func CreateNewDocsInput(ri releaseInfo, hasAnnouncement bool) ([]NewDocInput, error) {
changeLogWriter, err := getTemplateWriter(ri, changelogTemplateInput)
if err != nil {
return []NewDocInput{}, fmt.Errorf("getting template writer for changelog: %w", err)
}
indexWriter, err := getTemplateWriter(ri, indexTemplateInput)
if err != nil {
return []NewDocInput{}, fmt.Errorf("getting template writer for index: %w", err)
}
newDocInput := []NewDocInput{
{
FileName: values.GetChangelogFileName(ri),
TemplateWriter: changeLogWriter,
AppendToEnd: getPrInfoForChangelogFunc(ri),
},
{
FileName: values.IndexFileName,
TemplateWriter: indexWriter,
AppendToEnd: getComponentsFromReleaseManifestFunc(ri),
},
}
if hasAnnouncement {
releaseAnnouncementWriter, err := getTemplateWriter(ri, releaseAnnouncementTemplateInput)
if err != nil {
return []NewDocInput{}, fmt.Errorf("getting template writer for release announcement: %w", err)
}
newDocInput = append(newDocInput, NewDocInput{
FileName: values.ReleaseAnnouncementFileName,
TemplateWriter: releaseAnnouncementWriter,
AppendToEnd: nil,
})
}
return newDocInput, nil
}
var getComponentsFromReleaseManifestFunc = func(ri releaseInfo) func() (string, error) {
manifestURL := ri.ManifestURL()
return func() (string, error) {
return values.GetComponentsFromReleaseManifest(manifestURL)
}
}
var getPrInfoForChangelogFunc = func(ri releaseInfo) func() (string, error) {
releaseVersion := "v" + ri.KubernetesMinorVersion()
return func() (string, error) {
riNum, err := strconv.Atoi(ri.Number())
if err != nil {
return "", fmt.Errorf("converting release number %v: %w", ri.Number(), err)
}
return values.GetChangelogPRs(releaseVersion, riNum)
}
}
| 80 |
eks-distro | aws | Go | package newdocs
import (
"bytes"
"path/filepath"
"text/template"
"github.com/aws/eks-distro/cmd/release/utils/values"
)
// RELEASE ANNOUNCEMENT
var releaseAnnouncementTemplateInput = templateInput{
templateName: "releaseAnnouncementTemplate",
funcMap: template.FuncMap{},
docTemplate: `Amazon EKS Distro {{.Tag}} is now available. Builds are available through ECR Public Gallery (https://gallery.ecr.aws/eks-distro). The changelog and release manifest are available on GitHub (https://github.com/aws/eks-distro/releases).
`,
}
// CHANGELOG
var changelogTemplateInput = templateInput{
templateName: "changelogTemplate",
funcMap: template.FuncMap{},
docTemplate: `# Changelog for {{.Tag}}
This changelog highlights the changes for [{{.Tag}}](https://github.com/aws/eks-distro/tree/{{.Tag}}).
## Changes
`,
}
// INDEX
var indexTemplateInput = templateInput{
templateName: "indexTemplate",
funcMap: template.FuncMap{
"changelogFileNameFunc": func(ri releaseInfo) string {
return values.GetChangelogFileName(ri)
},
"filepathBaseFunc": func(manifestURL string) string {
return filepath.Base(manifestURL)
},
},
docTemplate: `# EKS-D {{.Tag}} Release
For additional information, see the [changelog]({{changelogFileNameFunc .}}) for this release.
## Release Manifest
Download the release manifest here: [{{filepathBaseFunc .ManifestURL}}]({{.ManifestURL}})
`,
}
type templateInput struct {
docTemplate string
templateName string
funcMap template.FuncMap
}
var getTemplateWriter = func(ri releaseInfo, input templateInput) (bytes.Buffer, error) {
t := template.Must(template.New(input.templateName).Funcs(input.funcMap).Parse(input.docTemplate))
out := bytes.Buffer{}
err := t.Execute(&out, ri)
return out, err
}
| 66 |
eks-distro | aws | Go | package main
import (
"flag"
"fmt"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"strconv"
"github.com/aws/eks-distro/cmd/release/utils/changetype"
"github.com/aws/eks-distro/cmd/release/utils/release"
"github.com/aws/eks-distro/cmd/release/utils/values"
)
var (
outputStream io.Writer = os.Stdout
errStream io.Writer = os.Stderr
ghReleaseScriptPath = filepath.Join(values.GetGitRootDirectory(), "cmd/release/gh-release/create.sh")
)
// Generates a release on GitHub. IMPORTANT! Only run after the prod release is out, you've pulled down the latest
// changes, and the git tag for the release is on GitHub.
func main() {
branch := flag.String("branch", "", "Release branch, e.g. 1-22")
overrideNumber := flag.Int("overrideNumber", release.InvalidNumberUpperLimit, "Optional override number, e.g. 1")
flag.Parse()
var err error
var r = &release.Release{}
if *overrideNumber <= release.InvalidNumberUpperLimit {
r, err = release.NewRelease(*branch, changetype.GHRelease)
if err != nil {
log.Fatalf("creating release values: %v", err)
}
} else {
r, err = release.NewReleaseOverrideNumber(*branch, strconv.Itoa(*overrideNumber))
if err != nil {
log.Fatalf("creating release values with override number: %v", err)
}
}
if err = createGitHubRelease(r); err != nil {
log.Fatalf("creating GitHub release: %v", err)
}
}
func createGitHubRelease(r *release.Release) error {
docsDirectory := values.GetReleaseDocsDirectory(r).String()
cmd := exec.Command(
"/bin/bash",
ghReleaseScriptPath,
r.Tag(),
filepath.Join(docsDirectory, values.GetChangelogFileName(r)),
filepath.Join(docsDirectory, "index.md"),
)
cmd.Stdout = outputStream
cmd.Stderr = errStream
if err := cmd.Run(); err != nil {
return fmt.Errorf("creating release from script: %w", err)
}
log.Printf("Published release!\nYou can view at it https://github.com/aws/eks-distro/releases/tag/%s\n", r.Tag())
return nil
}
| 72 |
eks-distro | aws | Go | package main
import (
"fmt"
"log"
"os"
"path/filepath"
"github.com/aws/eks-distro/cmd/release/minor/projects"
"github.com/aws/eks-distro/cmd/release/utils/changetype"
"github.com/aws/eks-distro/cmd/release/utils/values"
)
func main() {
latestSupportedReleaseBranch, err := values.GetLatestSupportedReleaseBranch()
if err != nil {
log.Fatalf("getting the latest supported release branch to create new minor release: %v", err)
}
// Adds new release branch to SUPPORTED_RELEASE_BRANCHES
addedReleaseBranch, err := values.AddNextReleaseBranch()
if err != nil {
log.Fatalf("getting the new release branch: %v", err)
}
log.Printf("Added %s to SUPPORTED_RELEASE_BRANCHES", addedReleaseBranch)
prevReleaseBranch, nextReleaseBranch := string(latestSupportedReleaseBranch), string(addedReleaseBranch)
// Adds project files new release branch
projectFilesAddedCount, err := projects.CreateFilesAndDirectories(prevReleaseBranch, nextReleaseBranch)
if err != nil {
log.Fatalf("creating project files and directories: %v", err)
}
log.Printf("Generated %d project files", projectFilesAddedCount)
// Adds release directory and sets RELEASE values to "0"
err = createReleaseDirectoryAndFiles(nextReleaseBranch)
if err != nil {
log.Fatalf("creating RELEASE files: %v", err)
}
log.Printf("Generated RELEASE files")
}
func createReleaseDirectoryAndFiles(nextReleaseBranch string) error {
newRBReleasePath := filepath.Join(values.GetGitRootDirectory(), "release", nextReleaseBranch)
if err := os.Mkdir(newRBReleasePath, 0755); err != nil {
return fmt.Errorf("creating new directory for release: %w", err)
}
for _, ct := range []changetype.ChangeType{changetype.Dev, changetype.Prod} {
ctDirPath := filepath.Join(newRBReleasePath, ct.String())
if err := os.Mkdir(ctDirPath, 0755); err != nil {
return fmt.Errorf("creating new directory for %s release: %w", ct.String(), err)
}
if err := os.WriteFile(filepath.Join(ctDirPath, "RELEASE"), []byte("0\n"), 0744); err != nil {
return fmt.Errorf("writing to RELEASE file: %w", err)
}
}
return nil
}
| 61 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.