Charandas
309 lines
9.5 KiB
Go
309 lines
9.5 KiB
Go
package builder
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/emicklei/go-restful/v3"
|
|
"github.com/gorilla/mux"
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
serverstorage "k8s.io/apiserver/pkg/server/storage"
|
|
klog "k8s.io/klog/v2"
|
|
"k8s.io/kube-openapi/pkg/spec3"
|
|
)
|
|
|
|
// convertHandlerToRouteFunction converts an http.HandlerFunc to a restful.RouteFunction
|
|
// It extracts path parameters from restful.Request and populates them in the request context
|
|
// so that mux.Vars can read them (for backward compatibility with handlers that use mux.Vars)
|
|
func convertHandlerToRouteFunction(handler http.HandlerFunc) restful.RouteFunction {
|
|
return func(req *restful.Request, resp *restful.Response) {
|
|
// Extract path parameters from restful.Request and populate mux.Vars
|
|
// This is needed for backward compatibility with handlers that use mux.Vars(r)
|
|
vars := make(map[string]string)
|
|
|
|
// Get all path parameters from the restful.Request
|
|
// The restful.Request has PathParameters() method that returns a map
|
|
pathParams := req.PathParameters()
|
|
for key, value := range pathParams {
|
|
vars[key] = value
|
|
}
|
|
|
|
// Set the vars in the request context using mux.SetURLVars
|
|
// This makes mux.Vars(r) work correctly
|
|
if len(vars) > 0 {
|
|
req.Request = mux.SetURLVars(req.Request, vars)
|
|
}
|
|
|
|
handler(resp.ResponseWriter, req.Request)
|
|
}
|
|
}
|
|
|
|
// AugmentWebServicesWithCustomRoutes adds custom routes from builders to existing WebServices
|
|
// in the container.
|
|
func AugmentWebServicesWithCustomRoutes(
|
|
container *restful.Container,
|
|
builders []APIGroupBuilder,
|
|
metricsRegistry prometheus.Registerer,
|
|
apiResourceConfig *serverstorage.ResourceConfig,
|
|
) error {
|
|
if container == nil {
|
|
return fmt.Errorf("container cannot be nil")
|
|
}
|
|
|
|
metrics := NewCustomRouteMetrics(metricsRegistry)
|
|
|
|
// Build a map of existing WebServices by root path
|
|
existingWebServices := make(map[string]*restful.WebService)
|
|
for _, ws := range container.RegisteredWebServices() {
|
|
existingWebServices[ws.RootPath()] = ws
|
|
}
|
|
|
|
for _, b := range builders {
|
|
provider, ok := b.(APIGroupRouteProvider)
|
|
if !ok || provider == nil {
|
|
continue
|
|
}
|
|
|
|
for _, gv := range GetGroupVersions(b) {
|
|
// Filter out disabled API groups
|
|
gvr := gv.WithResource("")
|
|
if apiResourceConfig != nil && !apiResourceConfig.ResourceEnabled(gvr) {
|
|
klog.InfoS("Skipping custom routes for disabled group version", "gv", gv.String())
|
|
continue
|
|
}
|
|
|
|
routes := provider.GetAPIRoutes(gv)
|
|
if routes == nil {
|
|
continue
|
|
}
|
|
|
|
// Find or create WebService for this group version
|
|
rootPath := "/apis/" + gv.String()
|
|
ws, exists := existingWebServices[rootPath]
|
|
if !exists {
|
|
// Create a new WebService if one doesn't exist
|
|
ws = new(restful.WebService)
|
|
ws.Path(rootPath)
|
|
container.Add(ws)
|
|
existingWebServices[rootPath] = ws
|
|
}
|
|
|
|
// Add root handlers using OpenAPI specs
|
|
for _, route := range routes.Root {
|
|
instrumentedHandler := metrics.InstrumentHandler(
|
|
gv.Group,
|
|
gv.Version,
|
|
route.Path,
|
|
route.Handler,
|
|
)
|
|
routeFunction := convertHandlerToRouteFunction(instrumentedHandler)
|
|
|
|
// Use OpenAPI spec to configure routes properly
|
|
if err := addRouteFromSpec(ws, route.Path, route.Spec, routeFunction, false); err != nil {
|
|
return fmt.Errorf("failed to add root route %s: %w", route.Path, err)
|
|
}
|
|
}
|
|
|
|
// Add namespace handlers using OpenAPI specs
|
|
for _, route := range routes.Namespace {
|
|
instrumentedHandler := metrics.InstrumentHandler(
|
|
gv.Group,
|
|
gv.Version,
|
|
route.Path,
|
|
route.Handler,
|
|
)
|
|
routeFunction := convertHandlerToRouteFunction(instrumentedHandler)
|
|
|
|
// Use OpenAPI spec to configure routes properly
|
|
if err := addRouteFromSpec(ws, route.Path, route.Spec, routeFunction, true); err != nil {
|
|
return fmt.Errorf("failed to add namespace route %s: %w", route.Path, err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// addRouteFromSpec adds routes to a WebService using OpenAPI specs
|
|
func addRouteFromSpec(ws *restful.WebService, routePath string, pathProps *spec3.PathProps, handler restful.RouteFunction, isNamespaced bool) error {
|
|
if pathProps == nil {
|
|
return fmt.Errorf("pathProps cannot be nil for route %s", routePath)
|
|
}
|
|
|
|
// Build the full path (relative to WebService root)
|
|
var fullPath string
|
|
if isNamespaced {
|
|
fullPath = "/namespaces/{namespace}/" + routePath
|
|
} else {
|
|
fullPath = "/" + routePath
|
|
}
|
|
|
|
// Add routes for each HTTP method defined in the OpenAPI spec
|
|
operations := map[string]*spec3.Operation{
|
|
"GET": pathProps.Get,
|
|
"POST": pathProps.Post,
|
|
"PUT": pathProps.Put,
|
|
"PATCH": pathProps.Patch,
|
|
"DELETE": pathProps.Delete,
|
|
}
|
|
|
|
for method, operation := range operations {
|
|
if operation == nil {
|
|
continue
|
|
}
|
|
|
|
// Create route builder for this method
|
|
var routeBuilder *restful.RouteBuilder
|
|
switch method {
|
|
case "GET":
|
|
routeBuilder = ws.GET(fullPath)
|
|
case "POST":
|
|
routeBuilder = ws.POST(fullPath)
|
|
case "PUT":
|
|
routeBuilder = ws.PUT(fullPath)
|
|
case "PATCH":
|
|
routeBuilder = ws.PATCH(fullPath)
|
|
case "DELETE":
|
|
routeBuilder = ws.DELETE(fullPath)
|
|
}
|
|
|
|
// Set operation ID from OpenAPI spec (with K8s verb prefix if needed)
|
|
operationID := operation.OperationId
|
|
if operationID == "" {
|
|
// Generate from path if not specified
|
|
operationID = generateOperationNameFromPath(routePath)
|
|
}
|
|
operationID = prefixRouteIDWithK8sVerbIfNotPresent(operationID, method)
|
|
routeBuilder = routeBuilder.Operation(operationID)
|
|
|
|
// Add description from OpenAPI spec
|
|
if operation.Description != "" {
|
|
routeBuilder = routeBuilder.Doc(operation.Description)
|
|
}
|
|
|
|
// Check if namespace parameter is already in the OpenAPI spec
|
|
hasNamespaceParam := false
|
|
if operation.Parameters != nil {
|
|
for _, param := range operation.Parameters {
|
|
if param.Name == "namespace" && param.In == "path" {
|
|
hasNamespaceParam = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add namespace parameter for namespaced routes if not already in spec
|
|
if isNamespaced && !hasNamespaceParam {
|
|
routeBuilder = routeBuilder.Param(restful.PathParameter("namespace", "object name and auth scope, such as for teams and projects"))
|
|
}
|
|
|
|
// Add parameters from OpenAPI spec
|
|
if operation.Parameters != nil {
|
|
for _, param := range operation.Parameters {
|
|
switch param.In {
|
|
case "path":
|
|
routeBuilder = routeBuilder.Param(restful.PathParameter(param.Name, param.Description))
|
|
case "query":
|
|
routeBuilder = routeBuilder.Param(restful.QueryParameter(param.Name, param.Description))
|
|
case "header":
|
|
routeBuilder = routeBuilder.Param(restful.HeaderParameter(param.Name, param.Description))
|
|
}
|
|
}
|
|
}
|
|
|
|
// Note: Request/response schemas are already defined in the OpenAPI spec from builders
|
|
// and will be added to the OpenAPI document via addBuilderRoutes in openapi.go.
|
|
// We don't duplicate that information here since restful uses the route metadata
|
|
// for OpenAPI generation, which is handled separately in this codebase.
|
|
|
|
// Register the route with handler
|
|
ws.Route(routeBuilder.To(handler))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func prefixRouteIDWithK8sVerbIfNotPresent(operationID string, method string) string {
|
|
for _, verb := range allowedK8sVerbs {
|
|
if len(operationID) > len(verb) && operationID[:len(verb)] == verb {
|
|
return operationID
|
|
}
|
|
}
|
|
return fmt.Sprintf("%s%s", httpMethodToK8sVerb[strings.ToUpper(method)], operationID)
|
|
}
|
|
|
|
var allowedK8sVerbs = []string{
|
|
"get", "log", "read", "replace", "patch", "delete", "deletecollection", "watch", "connect", "proxy", "list", "create", "patch",
|
|
}
|
|
|
|
var httpMethodToK8sVerb = map[string]string{
|
|
http.MethodGet: "get",
|
|
http.MethodPost: "create",
|
|
http.MethodPut: "replace",
|
|
http.MethodPatch: "patch",
|
|
http.MethodDelete: "delete",
|
|
http.MethodConnect: "connect",
|
|
http.MethodOptions: "connect", // No real equivalent to options and head
|
|
http.MethodHead: "connect",
|
|
}
|
|
|
|
// generateOperationNameFromPath creates an operation name from a route path.
|
|
// The operation name is used by the OpenAPI generator and should be descriptive.
|
|
// It uses meaningful path segments to create readable yet unique operation names.
|
|
// Examples:
|
|
// - "/search" -> "Search"
|
|
// - "/snapshots/create" -> "SnapshotsCreate"
|
|
// - "ofrep/v1/evaluate/flags" -> "OfrepEvaluateFlags"
|
|
// - "ofrep/v1/evaluate/flags/{flagKey}" -> "OfrepEvaluateFlagsFlagKey"
|
|
func generateOperationNameFromPath(routePath string) string {
|
|
// Remove leading slash and split by path segments
|
|
parts := strings.Split(strings.TrimPrefix(routePath, "/"), "/")
|
|
|
|
// Filter to keep meaningful segments and path parameters
|
|
var nameParts []string
|
|
skipPrefixes := map[string]bool{
|
|
"namespaces": true,
|
|
"apis": true,
|
|
}
|
|
|
|
for _, part := range parts {
|
|
if part == "" {
|
|
continue
|
|
}
|
|
|
|
// Extract parameter name from {paramName} format
|
|
if strings.HasPrefix(part, "{") && strings.HasSuffix(part, "}") {
|
|
paramName := part[1 : len(part)-1]
|
|
// Skip generic parameters like {namespace}, but keep specific ones like {flagKey}
|
|
if paramName != "namespace" && paramName != "name" {
|
|
nameParts = append(nameParts, strings.ToUpper(paramName[:1])+paramName[1:])
|
|
}
|
|
continue
|
|
}
|
|
|
|
// Skip common prefixes
|
|
if skipPrefixes[strings.ToLower(part)] {
|
|
continue
|
|
}
|
|
|
|
// Skip version segments like v1, v0alpha1, v2beta1, etc.
|
|
if strings.HasPrefix(strings.ToLower(part), "v") &&
|
|
(len(part) <= 3 || strings.Contains(strings.ToLower(part), "alpha") || strings.Contains(strings.ToLower(part), "beta")) {
|
|
continue
|
|
}
|
|
|
|
// Capitalize first letter and add to parts
|
|
if len(part) > 0 {
|
|
nameParts = append(nameParts, strings.ToUpper(part[:1])+part[1:])
|
|
}
|
|
}
|
|
|
|
if len(nameParts) == 0 {
|
|
return "Route"
|
|
}
|
|
|
|
return strings.Join(nameParts, "")
|
|
}
|