Debian Codegraph @

pkg/util/webhook/client.go

raw
1 /*
2 Copyright 2017 The Kubernetes Authors.
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17 package webhook
18
19 import (
20 "context"
21 "encoding/json"
22 "errors"
23 "fmt"
24 "net"
25 "net/url"
26 "strconv"
27 "strings"
28
29 "k8s.io/apimachinery/pkg/runtime"
30 "k8s.io/apimachinery/pkg/runtime/schema"
31 "k8s.io/apimachinery/pkg/runtime/serializer"
32 utilerrors "k8s.io/apimachinery/pkg/util/errors"
33 "k8s.io/apiserver/pkg/util/x509metrics"
34 "k8s.io/client-go/rest"
35 "k8s.io/utils/lru"
36 netutils "k8s.io/utils/net"
37 )
38
39 const (
40 defaultCacheSize = 200
41 )
42
43 // ClientConfig defines parameters required for creating a hook client.
44 type ClientConfig struct {
45 Name string
46 URL string
47 CABundle []byte
48 Service *ClientConfigService
49 }
50
51 // ClientConfigService defines service discovery parameters of the webhook.
52 type ClientConfigService struct {
53 Name string
54 Namespace string
55 Path string
56 Port int32
57 }
58
59 // ClientManager builds REST clients to talk to webhooks. It caches the clients
60 // to avoid duplicate creation.
61 type ClientManager struct {
62 authInfoResolver AuthenticationInfoResolver
63 serviceResolver ServiceResolver
64 negotiatedSerializer runtime.NegotiatedSerializer
65 cache *lru.Cache
66 }
67
68 // NewClientManager creates a clientManager.
69 func NewClientManager(gvs []schema.GroupVersion, addToSchemaFuncs ...func(s *runtime.Scheme) error) (ClientManager, error) {
70 cache := lru.New(defaultCacheSize)
71 hookScheme := runtime.NewScheme()
72 for _, addToSchemaFunc := range addToSchemaFuncs {
73 if err := addToSchemaFunc(hookScheme); err != nil {
74 return ClientManager{}, err
75 }
76 }
77 return ClientManager{
78 cache: cache,
79 negotiatedSerializer: serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{
80 Serializer: serializer.NewCodecFactory(hookScheme).LegacyCodec(gvs...),
81 }),
82 }, nil
83 }
84
85 // SetAuthenticationInfoResolverWrapper sets the
86 // AuthenticationInfoResolverWrapper.
87 func (cm *ClientManager) SetAuthenticationInfoResolverWrapper(wrapper AuthenticationInfoResolverWrapper) {
88 if wrapper != nil {
89 cm.authInfoResolver = wrapper(cm.authInfoResolver)
90 }
91 }
92
93 // SetAuthenticationInfoResolver sets the AuthenticationInfoResolver.
94 func (cm *ClientManager) SetAuthenticationInfoResolver(resolver AuthenticationInfoResolver) {
95 cm.authInfoResolver = resolver
96 }
97
98 // SetServiceResolver sets the ServiceResolver.
99 func (cm *ClientManager) SetServiceResolver(sr ServiceResolver) {
100 if sr != nil {
101 cm.serviceResolver = sr
102 }
103 }
104
105 // Validate checks if ClientManager is properly set up.
106 func (cm *ClientManager) Validate() error {
107 var errs []error
108 if cm.negotiatedSerializer == nil {
109 errs = append(errs, fmt.Errorf("the clientManager requires a negotiatedSerializer"))
110 }
111 if cm.serviceResolver == nil {
112 errs = append(errs, fmt.Errorf("the clientManager requires a serviceResolver"))
113 }
114 if cm.authInfoResolver == nil {
115 errs = append(errs, fmt.Errorf("the clientManager requires an authInfoResolver"))
116 }
117 return utilerrors.NewAggregate(errs)
118 }
119
120 // HookClient get a RESTClient from the cache, or constructs one based on the
121 // webhook configuration.
122 func (cm *ClientManager) HookClient(cc ClientConfig) (*rest.RESTClient, error) {
123 ccWithNoName := cc
124 ccWithNoName.Name = ""
125 cacheKey, err := json.Marshal(ccWithNoName)
126 if err != nil {
127 return nil, err
128 }
129 if client, ok := cm.cache.Get(string(cacheKey)); ok {
130 return client.(*rest.RESTClient), nil
131 }
132
133 cfg, err := cm.hookClientConfig(cc)
134 if err != nil {
135 return nil, err
136 }
137
138 client, err := rest.UnversionedRESTClientFor(cfg)
139 if err == nil {
140 cm.cache.Add(string(cacheKey), client)
141 }
142 return client, err
143 }
144
145 func (cm *ClientManager) hookClientConfig(cc ClientConfig) (*rest.Config, error) {
146 complete := func(cfg *rest.Config) (*rest.Config, error) {
147 // Avoid client-side rate limiting talking to the webhook backend.
148 // Rate limiting should happen when deciding how many requests to serve.
149 cfg.QPS = -1
150
151 // Combine CAData from the config with any existing CA bundle provided
152 if len(cfg.TLSClientConfig.CAData) > 0 {
153 cfg.TLSClientConfig.CAData = append(cfg.TLSClientConfig.CAData, '\n')
154 }
155 cfg.TLSClientConfig.CAData = append(cfg.TLSClientConfig.CAData, cc.CABundle...)
156
157 cfg.ContentConfig.NegotiatedSerializer = cm.negotiatedSerializer
158 cfg.ContentConfig.ContentType = runtime.ContentTypeJSON
159
160 // Add a transport wrapper that allows detection of TLS connections to
161 // servers with serving certificates with deprecated characteristics
162 cfg.Wrap(x509metrics.NewDeprecatedCertificateRoundTripperWrapperConstructor(
163 x509MissingSANCounter,
164 x509InsecureSHA1Counter,
165 ))
166 return cfg, nil
167 }
168
169 if cc.Service != nil {
170 port := cc.Service.Port
171 if port == 0 {
172 // Default to port 443 if no service port is specified
173 port = 443
174 }
175
176 restConfig, err := cm.authInfoResolver.ClientConfigForService(cc.Service.Name, cc.Service.Namespace, int(port))
177 if err != nil {
178 return nil, err
179 }
180 cfg := rest.CopyConfig(restConfig)
181
182 // Use http/1.1 instead of http/2.
183 // This is a workaround for http/2-enabled clients not load-balancing concurrent requests to multiple backends.
184 // See https://issue.k8s.io/75791 for details.
185 cfg.NextProtos = []string{"http/1.1"}
186
187 serverName := cc.Service.Name + "." + cc.Service.Namespace + ".svc"
188
189 host := net.JoinHostPort(serverName, strconv.Itoa(int(port)))
190 cfg.Host = "https://" + host
191 cfg.APIPath = cc.Service.Path
192 // Set the server name if not already set
193 if len(cfg.TLSClientConfig.ServerName) == 0 {
194 cfg.TLSClientConfig.ServerName = serverName
195 }
196
197 delegateDialer := cfg.Dial
198 if delegateDialer == nil {
199 var d net.Dialer
200 delegateDialer = d.DialContext
201 }
202 cfg.Dial = func(ctx context.Context, network, addr string) (net.Conn, error) {
203 if addr == host {
204 u, err := cm.serviceResolver.ResolveEndpoint(cc.Service.Namespace, cc.Service.Name, port)
205 if err != nil {
206 return nil, err
207 }
208 addr = u.Host
209 }
210 return delegateDialer(ctx, network, addr)
211 }
212
213 return complete(cfg)
214 }
215
216 if cc.URL == "" {
217 return nil, &ErrCallingWebhook{WebhookName: cc.Name, Reason: errors.New("webhook configuration must have either service or URL")}
218 }
219
220 u, err := url.Parse(cc.URL)
221 if err != nil {
222 return nil, &ErrCallingWebhook{WebhookName: cc.Name, Reason: fmt.Errorf("Unparsable URL: %v", err)}
223 }
224
225 hostPort := u.Host
226 if len(u.Port()) == 0 {
227 // Default to port 443 if no port is specified
228 hostPort = net.JoinHostPort(hostPort, "443")
229 }
230
231 restConfig, err := cm.authInfoResolver.ClientConfigFor(hostPort)
232 if err != nil {
233 return nil, err
234 }
235
236 cfg := rest.CopyConfig(restConfig)
237 cfg.Host = u.Scheme + "://" + u.Host
238 cfg.APIPath = u.Path
239 if !isLocalHost(u) {
240 cfg.NextProtos = []string{"http/1.1"}
241 }
242
243 return complete(cfg)
244 }
245
246 func isLocalHost(u *url.URL) bool {
247 host := u.Hostname()
248 if strings.EqualFold(host, "localhost") {
249 return true
250 }
251
252 netIP := netutils.ParseIPSloppy(host)
253 if netIP != nil {
254 return netIP.IsLoopback()
255 }
256 return false
257 }