-
Notifications
You must be signed in to change notification settings - Fork 279
/
fetch.go
142 lines (118 loc) Β· 5.17 KB
/
fetch.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package cluster
import (
"context"
"fmt"
eksdv1alpha1 "github.com/aws/eks-distro-build-tooling/release/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/constants"
v1alpha1release "github.com/aws/eks-anywhere/release/api/v1alpha1"
)
func bundlesNamespacedKey(cluster *v1alpha1.Cluster, release *v1alpha1release.EKSARelease) (name, namespace string) {
if release != nil && release.Spec.BundlesRef.Name != "" {
name = release.Spec.BundlesRef.Name
namespace = release.Spec.BundlesRef.Namespace
} else if cluster.Spec.BundlesRef != nil {
name = cluster.Spec.BundlesRef.Name
namespace = cluster.Spec.BundlesRef.Namespace
} else {
// Handles old clusters that don't contain a reference yet to the Bundles
// For those clusters, the Bundles was created with the same name as the cluster
// and in the same namespace
name = cluster.Name
namespace = cluster.Namespace
}
return name, namespace
}
// GetVersionsBundle gets the VersionsBundle that corresponds to KubernetesVersion.
func GetVersionsBundle(version v1alpha1.KubernetesVersion, bundles *v1alpha1release.Bundles) (*v1alpha1release.VersionsBundle, error) {
return getVersionsBundleForKubernetesVersion(version, bundles)
}
func getVersionsBundleForKubernetesVersion(kubernetesVersion v1alpha1.KubernetesVersion, bundles *v1alpha1release.Bundles) (*v1alpha1release.VersionsBundle, error) {
for _, versionsBundle := range bundles.Spec.VersionsBundles {
if versionsBundle.KubeVersion == string(kubernetesVersion) {
return &versionsBundle, nil
}
}
return nil, fmt.Errorf("kubernetes version %s is not supported by bundles manifest %d", kubernetesVersion, bundles.Spec.Number)
}
// BuildSpec constructs a cluster.Spec for an eks-a cluster by retrieving all
// necessary objects from the cluster using a kubernetes client.
func BuildSpec(ctx context.Context, client Client, cluster *v1alpha1.Cluster) (*Spec, error) {
configBuilder := NewDefaultConfigClientBuilder()
config, err := configBuilder.Build(ctx, client, cluster)
if err != nil {
return nil, err
}
return BuildSpecFromConfig(ctx, client, config)
}
// BuildSpecFromConfig constructs a cluster.Spec for an eks-a cluster config by retrieving all dependencies objects from the cluster using a kubernetes client.
func BuildSpecFromConfig(ctx context.Context, client Client, config *Config) (*Spec, error) {
eksaRelease, err := eksaReleaseForCluster(ctx, client, config.Cluster)
if err != nil {
return nil, err
}
bundles, err := bundlesForEksaRelease(ctx, client, config.Cluster, eksaRelease)
if err != nil {
return nil, err
}
eksdReleases, err := fetchAllEksdReleases(ctx, client, config.Cluster, bundles)
if err != nil {
return nil, err
}
return NewSpec(config, bundles, eksdReleases, eksaRelease)
}
func fetchAllEksdReleases(ctx context.Context, client Client, cluster *v1alpha1.Cluster, bundles *v1alpha1release.Bundles) ([]eksdv1alpha1.Release, error) {
versions := cluster.KubernetesVersions()
m := make([]eksdv1alpha1.Release, 0, len(versions))
for _, version := range versions {
eksd, err := getEksdRelease(ctx, client, version, bundles)
if err != nil {
return nil, err
}
m = append(m, *eksd)
}
return m, nil
}
func getEksdRelease(ctx context.Context, client Client, version v1alpha1.KubernetesVersion, bundles *v1alpha1release.Bundles) (*eksdv1alpha1.Release, error) {
versionsBundle, err := GetVersionsBundle(version, bundles)
if err != nil {
return nil, err
}
// Ideally we would use the same namespace as the Bundles, but Bundles can be in any namespace and
// the eksd release is always in eksa-system
eksdRelease := &eksdv1alpha1.Release{}
if err = client.Get(ctx, versionsBundle.EksD.Name, constants.EksaSystemNamespace, eksdRelease); err != nil {
return nil, err
}
return eksdRelease, nil
}
// BundlesForCluster returns a bundles resource for the cluster.
func BundlesForCluster(ctx context.Context, client Client, cluster *v1alpha1.Cluster) (*v1alpha1release.Bundles, error) {
release, err := eksaReleaseForCluster(ctx, client, cluster)
if err != nil {
return nil, err
}
return bundlesForEksaRelease(ctx, client, cluster, release)
}
func eksaReleaseForCluster(ctx context.Context, client Client, cluster *v1alpha1.Cluster) (*v1alpha1release.EKSARelease, error) {
eksaRelease := &v1alpha1release.EKSARelease{}
if cluster.Spec.BundlesRef == nil {
if cluster.Spec.EksaVersion == nil {
return nil, fmt.Errorf("either cluster's EksaVersion or BundlesRef need to be set")
}
version := string(*cluster.Spec.EksaVersion)
eksaReleaseName := v1alpha1release.GenerateEKSAReleaseName(version)
if err := client.Get(ctx, eksaReleaseName, constants.EksaSystemNamespace, eksaRelease); err != nil {
return nil, fmt.Errorf("error getting EKSARelease %s", eksaReleaseName)
}
}
return eksaRelease, nil
}
func bundlesForEksaRelease(ctx context.Context, client Client, cluster *v1alpha1.Cluster, eksaRelease *v1alpha1release.EKSARelease) (*v1alpha1release.Bundles, error) {
bundlesName, bundlesNamespace := bundlesNamespacedKey(cluster, eksaRelease)
bundles := &v1alpha1release.Bundles{}
if err := client.Get(ctx, bundlesName, bundlesNamespace, bundles); err != nil {
return nil, err
}
return bundles, nil
}