johnandersen777.bsky.social/socialweb-computer-console
console.socialweb.computer: kcp, kubectl and ssh compiled to wasm in a browser tab with a terminal; a kcp fork
0
0
/*
Copyright 2022 The kcp Authors.
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 client
import (
"bytes"
"fmt"
"net/http"
"net/url"
"regexp"
"strings"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/client-go/rest"
clientshard "github.com/kcp-dev/kcp/pkg/cache/client/shard"
)
var (
// matches shards/name/remainder, capturing name.
//
// Example: shards/name/remainder
// Example: /shards/name/remainder
// Example: prefix/shards/name/remainder.
shardNameRegex = regexp.MustCompile(`shards/([^/]+)/.+`)
)
// WithShardNameFromContextRoundTripper wraps an existing config's with ShardRoundTripper.
//
// Note: it is the caller responsibility to make a copy of the rest config.
func WithShardNameFromContextRoundTripper(cfg *rest.Config) *rest.Config {
cfg.Wrap(func(rt http.RoundTripper) http.RoundTripper {
return NewShardRoundTripper(rt)
})
return cfg
}
// ShardRoundTripper is a shard aware wrapper around http.RoundTripper.
// It changes the URL path to target a shard from the context.
//
// For example given "amber" shard name in the context it will change
// apis/apis.kcp.io/v1alpha1/apiexports to /shards/amber/apis/apis.kcp.io/v1alpha1/apiexports.
type ShardRoundTripper struct {
delegate http.RoundTripper
}
// NewShardRoundTripper creates a new shard aware round tripper.
func NewShardRoundTripper(delegate http.RoundTripper) *ShardRoundTripper {
return &ShardRoundTripper{
delegate: delegate,
}
}
func (c *ShardRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
shard := ShardFromContext(req.Context())
if !shard.Empty() {
req = req.Clone(req.Context())
req.URL.Path = generatePath(req.URL.Path, shard)
req.URL.RawPath = generatePath(req.URL.RawPath, shard)
}
return c.delegate.RoundTrip(req)
}
func (c *ShardRoundTripper) WrappedRoundTripper() http.RoundTripper {
return c.delegate
}
// generatePath formats the request path to target the specified shard.
func generatePath(originalPath string, shard clientshard.Name) string {
// if the originalPath already has the shard then the path was already modified and no change needed
if strings.HasPrefix(originalPath, shard.Path()) {
return originalPath
}
// if the originalPath already has a shard set just overwrite it to the given one
if strings.HasPrefix(originalPath, "/shards") {
matches := shardNameRegex.FindStringSubmatch(originalPath)
if len(matches) >= 2 {
// replace /shards/$oldName/reminder with /shards/$newName/reminder
return strings.Replace(originalPath, clientshard.New(matches[1]).Path(), shard.Path(), 1)
} else {
// the path is either /shards/name/ or /shards/name
path := shard.Path()
if originalPath[len(originalPath)-1] == '/' {
path += "/"
}
return path
}
}
// otherwise the path doesn't contain a shard name prepend /shards/name
path := shard.Path()
// if the original path is relative, add a / separator
if len(originalPath) > 0 && originalPath[0] != '/' {
path += "/"
}
// finally append the original path
path += originalPath
return path
}
// WithDefaultShardRoundTripper wraps an existing config's with DefaultShardRoundTripper
//
// Note: it is the caller responsibility to make a copy of the rest config.
func WithDefaultShardRoundTripper(cfg *rest.Config, shard clientshard.Name) *rest.Config {
cfg.Wrap(func(rt http.RoundTripper) http.RoundTripper {
return NewDefaultShardRoundTripper(rt, shard)
})
return cfg
}
// DefaultShardRoundTripper is a http.RoundTripper that sets a default shard name if not specified in the context.
type DefaultShardRoundTripper struct {
delegate http.RoundTripper
shard clientshard.Name
}
// NewDefaultShardRoundTripper creates a new round tripper that sets a default shard name.
func NewDefaultShardRoundTripper(delegate http.RoundTripper, shard clientshard.Name) *DefaultShardRoundTripper {
return &DefaultShardRoundTripper{
delegate: delegate,
shard: shard,
}
}
func (c *DefaultShardRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
if ShardFromContext(req.Context()).Empty() {
req = req.WithContext(WithShardInContext(req.Context(), c.shard))
}
return c.delegate.RoundTrip(req)
}
func (c *DefaultShardRoundTripper) WrappedRoundTripper() http.RoundTripper {
return c.delegate
}
// WithShardNameFromObjectRoundTripper wraps an existing config with ShardNameFromObjectRoundTripper.
//
// Note: it is the caller responsibility to make a copy of the rest config.
func WithShardNameFromObjectRoundTripper(cfg *rest.Config, requestInfoResolver func(*http.Request) (string, string, error), supportedResources ...string) *rest.Config {
cfg.Wrap(func(rt http.RoundTripper) http.RoundTripper {
return NewShardNameFromObjectRoundTripper(rt, requestInfoResolver, supportedResources...)
})
return cfg
}
// NewShardNameFromObjectRoundTripper creates a new ShardNameFromObjectRoundTripper for the given resources.
func NewShardNameFromObjectRoundTripper(delegate http.RoundTripper, requestInfoResolver func(*http.Request) (string, string, error), supportedResources ...string) *ShardNameFromObjectRoundTripper {
return &ShardNameFromObjectRoundTripper{
delegate: delegate,
requestInfoResolver: requestInfoResolver,
supportedResources: sets.New[string](supportedResources...),
supportedVerbs: sets.New[string]("create", "update", "patch"),
}
}
// ShardNameFromObjectRoundTripper knows how to read a shard name
// from an object and store it in the context.
// it should be only used by the internal kube-clients that are not aware of a shard name.
type ShardNameFromObjectRoundTripper struct {
delegate http.RoundTripper
requestInfoResolver func(*http.Request) (string, string, error) /*res, verb, err*/
supportedResources sets.Set[string]
supportedVerbs sets.Set[string]
}
func (c *ShardNameFromObjectRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
// no-op if we already have a shard name in the cxt
if shard := ShardFromContext(req.Context()); !shard.Empty() {
return c.delegate.RoundTrip(req)
}
resource, verb, err := c.requestInfoResolver(req)
if err != nil {
return nil, err
}
if !c.supportedResources.Has(resource) || !c.supportedVerbs.Has(verb) {
return c.delegate.RoundTrip(req)
}
bodyReader, err := req.GetBody()
if err != nil {
return nil, err
}
defer bodyReader.Close()
rawBody := new(bytes.Buffer)
_, err = rawBody.ReadFrom(bodyReader)
if err != nil {
return nil, err
}
rawObject := rawBody.Bytes()
unstructuredObject, _, err := unstructured.UnstructuredJSONScheme.Decode(rawObject, nil, nil)
if err != nil {
return nil, err
}
if object, ok := unstructuredObject.(metav1.Object); ok {
annotations := object.GetAnnotations()
if shardName, ok := annotations[clientshard.AnnotationKey]; ok {
req = req.WithContext(WithShardInContext(req.Context(), clientshard.New(shardName)))
}
}
return c.delegate.RoundTrip(req)
}
func (c *ShardNameFromObjectRoundTripper) WrappedRoundTripper() http.RoundTripper {
return c.delegate
}
// WithCacheServiceRoundTripper wraps an existing config's with CacheServiceRoundTripper.
func WithCacheServiceRoundTripper(cfg *rest.Config) *rest.Config {
cfg.Wrap(func(rt http.RoundTripper) http.RoundTripper {
return NewCacheServiceRoundTripper(rt)
})
return cfg
}
// CacheServiceRoundTripper is a http.RoundTripper that appends "/services/cache" prefix to a request.
type CacheServiceRoundTripper struct {
delegate http.RoundTripper
}
// NewCacheServiceRoundTripper creates a new CacheServiceRoundTripper.
func NewCacheServiceRoundTripper(delegate http.RoundTripper) *CacheServiceRoundTripper {
return &CacheServiceRoundTripper{
delegate: delegate,
}
}
func (c *CacheServiceRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
cacheServicePrefix := "/services/cache"
if !strings.HasPrefix(req.URL.Path, cacheServicePrefix) {
req = req.Clone(req.Context())
// if the original path is relative, add a / separator
if len(req.URL.Path) > 0 && req.URL.Path[0] != '/' {
cacheServicePrefix += "/"
}
// now simply append the cache service prefix to original path
// and regenerate the URL address so that the RawPath gets updated as well
req.URL.Path = fmt.Sprintf("%s%s", cacheServicePrefix, req.URL.Path)
newURL, err := url.Parse(req.URL.String())
if err != nil {
return nil, err
}
req.URL = newURL
}
return c.delegate.RoundTrip(req)
}
func (c *CacheServiceRoundTripper) WrappedRoundTripper() http.RoundTripper {
return c.delegate
}