-
Notifications
You must be signed in to change notification settings - Fork 76
/
scheme.go
161 lines (138 loc) · 6.15 KB
/
scheme.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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
// SPDX-FileCopyrightText: 2024 SAP SE or an SAP affiliate company and Gardener contributors
//
// SPDX-License-Identifier: Apache-2.0
package helper
import (
"fmt"
"github.com/gardener/gardener/extensions/pkg/controller"
extensionsv1alpha1 "github.com/gardener/gardener/pkg/apis/extensions/v1alpha1"
kutil "github.com/gardener/gardener/pkg/utils/kubernetes"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/serializer"
utilruntime "k8s.io/apimachinery/pkg/util/runtime"
api "github.com/gardener/gardener-extension-provider-azure/pkg/apis/azure"
"github.com/gardener/gardener-extension-provider-azure/pkg/apis/azure/install"
apiv1alpha1 "github.com/gardener/gardener-extension-provider-azure/pkg/apis/azure/v1alpha1"
)
var (
// Scheme is a scheme with the types relevant for Azure actuators.
Scheme *runtime.Scheme
decoder runtime.Decoder
// lenientDecoder is a decoder that does not use strict mode.
lenientDecoder runtime.Decoder
// InfrastructureStateTypeMeta is the TypeMeta of the Azure InfrastructureStatus
InfrastructureStateTypeMeta = metav1.TypeMeta{
APIVersion: apiv1alpha1.SchemeGroupVersion.String(),
Kind: "InfrastructureState",
}
)
func init() {
Scheme = runtime.NewScheme()
utilruntime.Must(install.AddToScheme(Scheme))
decoder = serializer.NewCodecFactory(Scheme, serializer.EnableStrict).UniversalDecoder()
lenientDecoder = serializer.NewCodecFactory(Scheme).UniversalDecoder()
}
// InfrastructureConfigFromInfrastructure extracts the InfrastructureConfig from the
// ProviderConfig section of the given Infrastructure.
func InfrastructureConfigFromInfrastructure(infra *extensionsv1alpha1.Infrastructure) (*api.InfrastructureConfig, error) {
config := &api.InfrastructureConfig{}
if infra.Spec.ProviderConfig != nil && infra.Spec.ProviderConfig.Raw != nil {
if _, _, err := decoder.Decode(infra.Spec.ProviderConfig.Raw, nil, config); err != nil {
return nil, err
}
return config, nil
}
return nil, fmt.Errorf("provider config is not set on the infrastructure resource")
}
// InfrastructureStatusFromRaw extracts the InfrastructureStatus from the
// ProviderStatus section of the given Infrastructure.
func InfrastructureStatusFromRaw(raw *runtime.RawExtension) (*api.InfrastructureStatus, error) {
status := &api.InfrastructureStatus{}
if raw != nil && raw.Raw != nil {
if _, _, err := lenientDecoder.Decode(raw.Raw, nil, status); err != nil {
return nil, err
}
return status, nil
}
return nil, fmt.Errorf("provider status is not set on the infrastructure resource")
}
// CloudProfileConfigFromCluster decodes the provider specific cloud profile configuration for a cluster
func CloudProfileConfigFromCluster(cluster *controller.Cluster) (*api.CloudProfileConfig, error) {
var cloudProfileConfig *api.CloudProfileConfig
if cluster != nil && cluster.CloudProfile != nil && cluster.CloudProfile.Spec.ProviderConfig != nil && cluster.CloudProfile.Spec.ProviderConfig.Raw != nil {
cloudProfileConfig = &api.CloudProfileConfig{}
if _, _, err := decoder.Decode(cluster.CloudProfile.Spec.ProviderConfig.Raw, nil, cloudProfileConfig); err != nil {
return nil, fmt.Errorf("could not decode providerConfig of cloudProfile for '%s': %w", kutil.ObjectName(cluster.CloudProfile), err)
}
}
return cloudProfileConfig, nil
}
// BackupConfigFromBackupBucket decodes the provider specific config from a given BackupBucket object.
func BackupConfigFromBackupBucket(backupBucket *extensionsv1alpha1.BackupBucket) (api.BackupConfig, error) {
backupConfig := api.BackupConfig{}
if backupBucket != nil && backupBucket.Spec.ProviderConfig != nil {
bucketJson, err := backupBucket.Spec.ProviderConfig.MarshalJSON()
if err != nil {
return backupConfig, err
}
if _, _, err := decoder.Decode(bucketJson, nil, &backupConfig); err != nil {
return backupConfig, err
}
}
return backupConfig, nil
}
// BackupConfigFromBackupEntry decodes the provider specific config from a given BackupEntry object.
func BackupConfigFromBackupEntry(backupEntry *extensionsv1alpha1.BackupEntry) (api.BackupConfig, error) {
backupConfig := api.BackupConfig{}
if backupEntry != nil && backupEntry.Spec.DefaultSpec.ProviderConfig != nil {
entryJson, err := backupEntry.Spec.ProviderConfig.MarshalJSON()
if err != nil {
return backupConfig, err
}
if _, _, err := decoder.Decode(entryJson, nil, &backupConfig); err != nil {
return backupConfig, err
}
}
return backupConfig, nil
}
// DNSRecordConfigFromDNSRecord decodes the provider specific config from a given DNSRecord object.
func DNSRecordConfigFromDNSRecord(dnsRecord *extensionsv1alpha1.DNSRecord) (api.DNSRecordConfig, error) {
dnsRecordConfig := api.DNSRecordConfig{}
if dnsRecord != nil && dnsRecord.Spec.ProviderConfig != nil {
dnsJson, err := dnsRecord.Spec.ProviderConfig.MarshalJSON()
if err != nil {
return dnsRecordConfig, err
}
if _, _, err := decoder.Decode(dnsJson, nil, &dnsRecordConfig); err != nil {
return dnsRecordConfig, err
}
}
return dnsRecordConfig, nil
}
// InfrastructureStateFromRaw extracts the state from the Infrastructure. If no state was available, it returns a "zero" value InfrastructureState object.
func InfrastructureStateFromRaw(raw *runtime.RawExtension) (*api.InfrastructureState, error) {
state := &api.InfrastructureState{}
if raw != nil && raw.Raw != nil {
if _, _, err := lenientDecoder.Decode(raw.Raw, nil, state); err != nil {
return nil, err
}
}
if state.Data == nil {
state.Data = make(map[string]string)
}
if state.ManagedItems == nil {
state.ManagedItems = make([]api.AzureResource, 0)
}
return state, nil
}
// InfrastructureStatusFromInfrastructure extracts the InfrastructureStatus from the
// ProviderStatus section of the given Infrastructure.
// If the providerConfig is missing from the status, it will return a zero-value InfrastructureStatus.
func InfrastructureStatusFromInfrastructure(infra *extensionsv1alpha1.Infrastructure) (*api.InfrastructureStatus, error) {
status := &api.InfrastructureStatus{}
if infra.Status.ProviderStatus != nil && infra.Status.ProviderStatus.Raw != nil {
return InfrastructureStatusFromRaw(infra.Status.ProviderStatus)
}
return status, nil
}