forked from projectcalico/libcalico-go
-
Notifications
You must be signed in to change notification settings - Fork 0
/
systemnetworkpolicies.go
211 lines (188 loc) · 6.77 KB
/
systemnetworkpolicies.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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
// Copyright (c) 2017 Tigera, Inc. 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 resources
import (
log "github.com/Sirupsen/logrus"
"github.com/projectcalico/libcalico-go/lib/backend/api"
"github.com/projectcalico/libcalico-go/lib/backend/k8s/thirdparty"
"github.com/projectcalico/libcalico-go/lib/backend/model"
"github.com/projectcalico/libcalico-go/lib/errors"
kerrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/kubernetes"
extensions "k8s.io/client-go/pkg/apis/extensions/v1beta1"
"k8s.io/client-go/rest"
)
const (
SystemNetworkPolicyResourceName = "systemnetworkpolicies"
SystemNetworkPolicyTPRName = "system-network-policy.projectcalico.org"
SystemNetworkPolicyNamePrefix = "snp.projectcalico.org/"
)
func NewSystemNetworkPolicies(c *kubernetes.Clientset, r *rest.RESTClient) api.Client {
return &snpClient{
clientSet: c,
tprClient: r,
}
}
// Implements the api.Client interface for System Network Policies.
type snpClient struct {
clientSet *kubernetes.Clientset
tprClient *rest.RESTClient
}
// Create implements the Create method for System Network Policies (exposed
// through the libcalico-go API as standard Policy resources)
func (c *snpClient) Create(kvp *model.KVPair) (*model.KVPair, error) {
log.WithField("KV", kvp).Debug("Performing System Network Policy Create")
tpr := SystemNetworkPolicyToThirdParty(kvp)
res := thirdparty.SystemNetworkPolicy{}
req := c.tprClient.Post().
Resource(SystemNetworkPolicyResourceName).
Namespace("kube-system").
Body(tpr)
err := req.Do().Into(&res)
if err != nil {
return nil, K8sErrorToCalico(err, kvp.Key)
}
kvp.Revision = res.Metadata.ResourceVersion
return kvp, nil
}
// Update implements the Update method for System Network Policies (exposed
// through the libcalico-go API as standard Policy resources)
func (c *snpClient) Update(kvp *model.KVPair) (*model.KVPair, error) {
log.WithField("KV", kvp).Debug("Performing System Network Policy Update")
tpr := SystemNetworkPolicyToThirdParty(kvp)
res := thirdparty.SystemNetworkPolicy{}
req := c.tprClient.Put().
Resource(SystemNetworkPolicyResourceName).
Namespace("kube-system").
Body(tpr).
Name(tpr.Metadata.Name)
err := req.Do().Into(&res)
if err != nil {
return nil, K8sErrorToCalico(err, kvp.Key)
}
kvp.Revision = tpr.Metadata.ResourceVersion
return kvp, nil
}
// Apply implements the Apply method for System Network Policies (exposed
// through the libcalico-go API as standard Policy resources)
func (c *snpClient) Apply(kvp *model.KVPair) (*model.KVPair, error) {
log.WithField("KV", kvp).Debug("Performing System Network Policy Apply")
updated, err := c.Update(kvp)
if err != nil {
if _, ok := err.(errors.ErrorResourceDoesNotExist); !ok {
return nil, err
}
// It doesn't exist - create it.
updated, err = c.Create(kvp)
if err != nil {
return nil, err
}
}
return updated, nil
}
// Delete implements the Delete method for System Network Policies (exposed
// through the libcalico-go API as standard Policy resources)
func (c *snpClient) Delete(kvp *model.KVPair) error {
log.WithField("KV", kvp).Debug("Performing System Network Policy Delete")
result := c.tprClient.Delete().
Resource(SystemNetworkPolicyResourceName).
Namespace("kube-system").
Name(systemNetworkPolicyTPRName(kvp.Key)).
Do()
return K8sErrorToCalico(result.Error(), kvp.Key)
}
// Get implements the Get method for System Network Policies (exposed
// through the libcalico-go API as standard Policy resources)
func (c *snpClient) Get(key model.Key) (*model.KVPair, error) {
log.WithField("Key", key).Debug("Performing System Network Policy Delete")
tpr := thirdparty.SystemNetworkPolicy{}
err := c.tprClient.Get().
Resource(SystemNetworkPolicyResourceName).
Namespace("kube-system").
Name(systemNetworkPolicyTPRName(key)).
Do().Into(&tpr)
if err != nil {
return nil, K8sErrorToCalico(err, key)
}
return ThirdPartyToSystemNetworkPolicy(&tpr), nil
}
// List implements the List method for System Network Policies (exposed
// through the libcalico-go API as standard Policy resources)
func (c *snpClient) List(list model.ListInterface) ([]*model.KVPair, error) {
kvps := []*model.KVPair{}
l := list.(model.PolicyListOptions)
// If the Name is specified, k8s will return a single resource
// rather than a list, so handle this case separately, using our
// Get method to return the single result.
if l.Name != "" {
log.Debug("Performing System Network Policy List with name")
if kvp, err := c.Get(model.PolicyKey{Name: l.Name}); err == nil {
kvps = append(kvps, kvp)
} else {
if _, ok := err.(errors.ErrorResourceDoesNotExist); !ok {
return nil, err
}
}
return kvps, nil
}
log.Debug("Performing System Network Policy List without name")
// Since we are not performing an exact Get, Kubernetes will return a list
// of resources.
tprs := thirdparty.SystemNetworkPolicyList{}
// Perform the request.
err := c.tprClient.Get().
Resource(SystemNetworkPolicyResourceName).
Namespace("kube-system").
Do().Into(&tprs)
if err != nil {
// Don't return errors for "not found". This just
// means there are no SystemNetworkPolicies, and we should return
// an empty list.
if !kerrors.IsNotFound(err) {
return nil, K8sErrorToCalico(err, l)
}
}
// Convert them to KVPairs.
for _, tpr := range tprs.Items {
kvps = append(kvps, ThirdPartyToSystemNetworkPolicy(&tpr))
}
return kvps, nil
}
// EnsureInitalized ensures Kubernetes is correctly configured to handle the
// System Network Policy Third Party Resources.
func (c *snpClient) EnsureInitialized() error {
log.Info("Ensuring System Network Policy ThirdPartyResource exists")
tpr := extensions.ThirdPartyResource{
ObjectMeta: metav1.ObjectMeta{
Name: SystemNetworkPolicyTPRName,
Namespace: "kube-system",
},
Description: "Calico System Network Policies",
Versions: []extensions.APIVersion{{Name: "v1"}},
}
_, err := c.clientSet.Extensions().ThirdPartyResources().Create(&tpr)
if err != nil {
// Don't care if it already exists.
if !kerrors.IsAlreadyExists(err) {
return K8sErrorToCalico(err, tpr)
}
}
return nil
}
func (c *snpClient) EnsureCalicoNodeInitialized(node string) error {
return nil
}
func (c *snpClient) Syncer(callbacks api.SyncerCallbacks) api.Syncer {
return nil
}