111 lines
3.5 KiB
Go
111 lines
3.5 KiB
Go
package storage
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"k8s.io/apimachinery/pkg/api/meta"
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
genericrequest "k8s.io/apiserver/pkg/endpoints/request"
|
|
"k8s.io/apiserver/pkg/registry/rest"
|
|
"k8s.io/klog/v2"
|
|
|
|
searchapis "github.com/karmada-io/karmada/pkg/apis/search"
|
|
clusterlister "github.com/karmada-io/karmada/pkg/generated/listers/cluster/v1alpha1"
|
|
"github.com/karmada-io/karmada/pkg/util/fedinformer/genericmanager"
|
|
)
|
|
|
|
// SearchREST implements a RESTStorage for search resource.
|
|
type SearchREST struct {
|
|
multiClusterInformerManager genericmanager.MultiClusterInformerManager
|
|
clusterLister clusterlister.ClusterLister
|
|
restMapper meta.RESTMapper
|
|
|
|
// add needed parameters here
|
|
}
|
|
|
|
var _ rest.Scoper = &SearchREST{}
|
|
var _ rest.Storage = &SearchREST{}
|
|
var _ rest.Connecter = &SearchREST{}
|
|
var _ rest.SingularNameProvider = &SearchREST{}
|
|
|
|
// NewSearchREST returns a RESTStorage object that will work against search.
|
|
func NewSearchREST(
|
|
multiClusterInformerManager genericmanager.MultiClusterInformerManager,
|
|
clusterLister clusterlister.ClusterLister,
|
|
restMapper meta.RESTMapper) *SearchREST {
|
|
return &SearchREST{
|
|
multiClusterInformerManager: multiClusterInformerManager,
|
|
clusterLister: clusterLister,
|
|
restMapper: restMapper,
|
|
}
|
|
}
|
|
|
|
// New return empty Search object.
|
|
func (r *SearchREST) New() runtime.Object {
|
|
return &searchapis.Search{}
|
|
}
|
|
|
|
// NamespaceScoped returns false because Search is not namespaced.
|
|
func (r *SearchREST) NamespaceScoped() bool {
|
|
return false
|
|
}
|
|
|
|
// ConnectMethods returns the list of HTTP methods handled by Connect.
|
|
func (r *SearchREST) ConnectMethods() []string {
|
|
return []string{"GET"}
|
|
}
|
|
|
|
// NewConnectOptions returns an empty options object that will be used to pass options to the Connect method.
|
|
func (r *SearchREST) NewConnectOptions() (runtime.Object, bool, string) {
|
|
return nil, true, ""
|
|
}
|
|
|
|
// Connect returns a handler for search.
|
|
func (r *SearchREST) Connect(ctx context.Context, id string, _ runtime.Object, responder rest.Responder) (http.Handler, error) {
|
|
info, ok := genericrequest.RequestInfoFrom(ctx)
|
|
if !ok {
|
|
return nil, fmt.Errorf("no RequestInfo found in the context")
|
|
}
|
|
|
|
if len(info.Parts) < 3 {
|
|
return nil, fmt.Errorf("invalid requestInfo parts: %v", info.Parts)
|
|
}
|
|
|
|
// reqParts are slices split by the k8s-native URL that include
|
|
// APIPrefix, APIGroup, APIVersion, Namespace and Resource.
|
|
// For example, the whole request URL is /apis/search.karmada.io/v1alpha1/search/cache/api/v1/nodes
|
|
// info.Parts is [search cache api v1 nodes], so reParts is [api v1 nodes]
|
|
reqParts := info.Parts[2:]
|
|
nativeResourceInfo, err := parseK8sNativeResourceInfo(reqParts)
|
|
if err != nil {
|
|
klog.Errorf("Failed to parse k8s native RequestInfo, err: %v", err)
|
|
return nil, err
|
|
}
|
|
if !nativeResourceInfo.IsResourceRequest {
|
|
return nil, fmt.Errorf("k8s native Request URL(%s) is not a resource request", strings.Join(reqParts, "/"))
|
|
}
|
|
|
|
switch id {
|
|
case "cache":
|
|
return r.newCacheHandler(nativeResourceInfo, responder)
|
|
case "opensearch":
|
|
return r.newOpenSearchHandler(nativeResourceInfo, responder)
|
|
default:
|
|
return nil, fmt.Errorf("connect with unrecognized search category %s", id)
|
|
}
|
|
}
|
|
|
|
// Destroy cleans up its resources on shutdown.
|
|
func (r *SearchREST) Destroy() {
|
|
// Given no underlying store, so we don't
|
|
// need to destroy anything.
|
|
}
|
|
|
|
// GetSingularName returns singular name of resources
|
|
func (r *SearchREST) GetSingularName() string {
|
|
return "search"
|
|
}
|