forked from projectcalico/calico
-
Notifications
You must be signed in to change notification settings - Fork 0
/
ipamconfig_storage.go
127 lines (112 loc) · 5.24 KB
/
ipamconfig_storage.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
// Copyright (c) 2022 Tigera, Inc. All rights reserved.
package calico
import (
"fmt"
"reflect"
"golang.org/x/net/context"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apiserver/pkg/registry/generic/registry"
"k8s.io/apiserver/pkg/storage"
"k8s.io/apiserver/pkg/storage/storagebackend/factory"
"github.com/dtest11/calico/libcalico-go/lib/clientv3"
"github.com/dtest11/calico/libcalico-go/lib/options"
"github.com/dtest11/calico/libcalico-go/lib/watch"
libapi "github.com/dtest11/calico/libcalico-go/lib/apis/v3"
aapi "github.com/projectcalico/api/pkg/apis/projectcalico/v3"
)
// NewIPAMConfigurationStorage creates a new libcalico-based storage.Interface implementation for IPAMConfig
func NewIPAMConfigurationStorage(opts Options) (registry.DryRunnableStorage, factory.DestroyFunc) {
c := CreateClientFromConfig()
createFn := func(ctx context.Context, c clientv3.Interface, obj resourceObject, opts clientOpts) (resourceObject, error) {
oso := opts.(options.SetOptions)
res := obj.(*libapi.IPAMConfig)
if res.Name != libapi.GlobalIPAMConfigName {
return nil, fmt.Errorf("IPAM config resource name has to be default")
}
return c.IPAMConfig().Create(ctx, res, oso)
}
updateFn := func(ctx context.Context, c clientv3.Interface, obj resourceObject, opts clientOpts) (resourceObject, error) {
oso := opts.(options.SetOptions)
res := obj.(*libapi.IPAMConfig)
return c.IPAMConfig().Update(ctx, res, oso)
}
getFn := func(ctx context.Context, c clientv3.Interface, ns string, name string, opts clientOpts) (resourceObject, error) {
ogo := opts.(options.GetOptions)
return c.IPAMConfig().Get(ctx, name, ogo)
}
deleteFn := func(ctx context.Context, c clientv3.Interface, ns string, name string, opts clientOpts) (resourceObject, error) {
odo := opts.(options.DeleteOptions)
return c.IPAMConfig().Delete(ctx, name, odo)
}
listFn := func(ctx context.Context, c clientv3.Interface, opts clientOpts) (resourceListObject, error) {
olo := opts.(options.ListOptions)
return c.IPAMConfig().List(ctx, olo)
}
watchFn := func(ctx context.Context, c clientv3.Interface, opts clientOpts) (watch.Interface, error) {
olo := opts.(options.ListOptions)
return c.IPAMConfig().Watch(ctx, olo)
}
dryRunnableStorage := registry.DryRunnableStorage{Storage: &resourceStore{
client: c,
codec: opts.RESTOptions.StorageConfig.Codec,
versioner: APIObjectVersioner{},
aapiType: reflect.TypeOf(aapi.IPAMConfiguration{}),
aapiListType: reflect.TypeOf(aapi.IPAMConfigurationList{}),
libCalicoType: reflect.TypeOf(libapi.IPAMConfig{}),
libCalicoListType: reflect.TypeOf(libapi.IPAMConfigList{}),
isNamespaced: false,
create: createFn,
update: updateFn,
get: getFn,
delete: deleteFn,
list: listFn,
watch: watchFn,
resourceName: "IPAMConfiguration",
converter: IPAMConfigConverter{},
}, Codec: opts.RESTOptions.StorageConfig.Codec}
return dryRunnableStorage, func() {}
}
type IPAMConfigConverter struct{}
func (gc IPAMConfigConverter) convertToLibcalico(aapiObj runtime.Object) resourceObject {
aapiIPAMConfig := aapiObj.(*aapi.IPAMConfiguration)
lcgIPAMConfig := &libapi.IPAMConfig{}
lcgIPAMConfig.TypeMeta = aapiIPAMConfig.TypeMeta
lcgIPAMConfig.ObjectMeta = aapiIPAMConfig.ObjectMeta
lcgIPAMConfig.Kind = libapi.KindIPAMConfig
lcgIPAMConfig.APIVersion = aapi.GroupVersionCurrent
lcgIPAMConfig.Spec.StrictAffinity = aapiIPAMConfig.Spec.StrictAffinity
lcgIPAMConfig.Spec.MaxBlocksPerHost = int(aapiIPAMConfig.Spec.MaxBlocksPerHost)
// AutoAllocatBlocks is an internal field and should be set to true.
lcgIPAMConfig.Spec.AutoAllocateBlocks = true
return lcgIPAMConfig
}
func (gc IPAMConfigConverter) convertToAAPI(libcalicoObject resourceObject, aapiObj runtime.Object) {
lcgIPAMConfig := libcalicoObject.(*libapi.IPAMConfig)
aapiIPAMConfig := aapiObj.(*aapi.IPAMConfiguration)
// Copy spec but ignore internal field AutoAllocateBlocks.
aapiIPAMConfig.Spec.StrictAffinity = lcgIPAMConfig.Spec.StrictAffinity
aapiIPAMConfig.Spec.MaxBlocksPerHost = int32(lcgIPAMConfig.Spec.MaxBlocksPerHost)
aapiIPAMConfig.TypeMeta = lcgIPAMConfig.TypeMeta
aapiIPAMConfig.ObjectMeta = lcgIPAMConfig.ObjectMeta
// libcalico uses a different Kind for these resources - IPAMConfig.
aapiIPAMConfig.TypeMeta.APIVersion = aapi.GroupVersionCurrent
aapiIPAMConfig.Kind = aapi.KindIPAMConfiguration
}
func (gc IPAMConfigConverter) convertToAAPIList(libcalicoListObject resourceListObject, aapiListObj runtime.Object, pred storage.SelectionPredicate) {
lcgIPAMConfigList := libcalicoListObject.(*libapi.IPAMConfigList)
aapiIPAMConfigList := aapiListObj.(*aapi.IPAMConfigurationList)
if libcalicoListObject == nil {
aapiIPAMConfigList.Items = []aapi.IPAMConfiguration{}
return
}
aapiIPAMConfigList.TypeMeta = lcgIPAMConfigList.TypeMeta
aapiIPAMConfigList.TypeMeta.Kind = aapi.KindIPAMConfigurationList
aapiIPAMConfigList.ListMeta = lcgIPAMConfigList.ListMeta
for _, item := range lcgIPAMConfigList.Items {
aapiIPAMConfig := aapi.IPAMConfiguration{}
gc.convertToAAPI(&item, &aapiIPAMConfig)
if matched, err := pred.Matches(&aapiIPAMConfig); err == nil && matched {
aapiIPAMConfigList.Items = append(aapiIPAMConfigList.Items, aapiIPAMConfig)
}
}
}