RESTful API Implementation for Kubesphere

type APIServer struct {
   ServerCount int
   Server *http.Server
   Config *apiserverconfig.Config
   // webservice container, where all webservice defines
   container *restful.Container
   KubernetesClient k8s.Client
}

func (s *ServerRunOptions) NewAPIServer(stopCh <-chan struct{}) (*apiserver.APIServer, error) {
   apiServer := &apiserver.APIServer{
      Config:     s.Config,
   }
   kubernetesClient, err := k8s.NewKubernetesClient(s.KubernetesOptions)
   if err != nil {
      return nil, err
   }
   apiServer.KubernetesClient = kubernetesClient
   server := &http.Server{
      Addr: fmt.Sprintf(":%d", s.GenericServerRunOptions.InsecurePort),
   }
   apiServer.Server = server
   return apiServer, nil
}

func (s *APIServer) PrepareRun(stopCh <-chan struct{}) error {
   s.container = restful.NewContainer()

   // 设定路由为CurlyRouter(快速路由)
   s.container.Router(restful.CurlyRouter{})

   for _, ws := range s.container.RegisteredWebServices() {
      klog.V(2).Infof("%s", ws.RootPath())
   }
   
   // container作为http server的handler
   s.Server.Handler = s.container

   // 注册服务
   s.installAIscopeAPIs()

   // handler chain
   s.buildHandlerChain(stopCh)

   return nil
}

func (s *APIServer) installAIscopeAPIs() {
   urlruntime.Must(version.AddToContainer(s.container, s.KubernetesClient.Discovery()))
}

func AddToContainer(container *restful.Container, k8sDiscovery discovery.DiscoveryInterface) error {
   webservice := runtime.NewWebService(schema.GroupVersion{})
   webservice.Route(webservice.GET("/version").
      To(func(request *restful.Request, response *restful.Response) {
         ksVersion := version.Get()
         if k8sDiscovery != nil {
            k8sVersion, err := k8sDiscovery.ServerVersion()
            if err == nil {
               ksVersion.Kubernetes = k8sVersion
            } else {
               klog.Errorf("Failed to get kubernetes version, error %v", err)
            }
         }
         response.WriteAsJson(ksVersion)
      })).
      Doc("AIScope version")
   container.Add(webservice)
   return nil
}

const (
   ApiRootPath = "/aiapis"
)

func NewWebService(gv schema.GroupVersion) *restful.WebService {
   webservice := restful.WebService{}
   webservice.Path(ApiRootPath + "/" + gv.String()).
      Produces(restful.MIME_JSON)

   return &webservice
}

func (s *APIServer) buildHandlerChain(stopCh <-chan struct{}) {
   requestInfoResolver := &request.RequestInfoFactory{
      APIPrefixes:          sets.NewString("api", "apis"),
   }
   handler := s.Server.Handler
   handler = filters.WithKubeAPIServer(handler, s.KubernetesClient.Config(), &errorResponder{})
   handler = filters.WithRequestInfo(handler, requestInfoResolver)
   s.Server.Handler = handler
}

func WithRequestInfo(handler http.Handler, resolver request.RequestInfoResolver) http.Handler {
   return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
      ctx := req.Context()
      info, err := resolver.NewRequestInfo(req)
      if err != nil {
         responsewriters.InternalError(w, req, fmt.Errorf("failed to crate RequestInfo: %v", err))
         return
      }
      req = req.WithContext(request.WithRequestInfo(ctx, info))
      handler.ServeHTTP(w, req)
   })
}

var kubernetesAPIPrefixes = sets.NewString("api", "apis")
func (r *RequestInfoFactory) NewRequestInfo(req *http.Request) (*RequestInfo, error) {
   requestInfo := RequestInfo{
      IsKubernetesRequest: false,
      RequestInfo: &k8srequest.RequestInfo{
         Path: req.URL.Path,
         Verb: req.Method,
      },
      Workspace: api.WorkspaceNone,
      Cluster:   api.ClusterNone,
      SourceIP:  iputil.RemoteIp(req),
      UserAgent: req.UserAgent(),
   }
   defer func() {
      prefix := requestInfo.APIPrefix
      if prefix == "" {
         currentParts := splitPath(requestInfo.Path)
         // Proxy discovery API
         if len(currentParts) > 0 && len(currentParts) < 3 {
            prefix = currentParts[0]
         }
      }
      if kubernetesAPIPrefixes.Has(prefix) {
         requestInfo.IsKubernetesRequest = true
      }
   }()
   currentParts := splitPath(req.URL.Path)
   if len(currentParts) < 3 {
      return &requestInfo, nil
   }
   if !r.APIPrefixes.Has(currentParts[0]) {
      // return a non-resource request
      return &requestInfo, nil
   }
   requestInfo.APIPrefix = currentParts[0]
   return &requestInfo, nil
}

func WithKubeAPIServer(handler http.Handler, config *rest.Config, failed proxy.ErrorResponder) http.Handler {
   kubernetes, _ := url.Parse(config.Host)
   defaultTransport, err := rest.TransportFor(config)
   if err != nil {
      klog.Errorf("Unable to create transport from rest.Config: %v", err)
      return handler
   }
   return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
      info, ok := request.RequestInfoFrom(req.Context())
      if !ok {
         err := errors.New("Unable to retrieve request info from request")
         klog.Error(err)
         responsewriters.InternalError(w, req, err)
      }
      if info.IsKubernetesRequest {
         s := *req.URL
         s.Host = kubernetes.Host
         s.Scheme = kubernetes.Scheme
         // make sure we don't override kubernetes's authorization
         req.Header.Del("Authorization")
         httpProxy := proxy.NewUpgradeAwareHandler(&s, defaultTransport, true, false, failed)
         httpProxy.UpgradeTransport = proxy.NewUpgradeRequestRoundTripper(defaultTransport, defaultTransport)
         httpProxy.ServeHTTP(w, req)
         return
      }
      handler.ServeHTTP(w, req)
   })
}

func (s *APIServer) Run(ctx context.Context) (err error) {
	shutdownCtx, cancel := context.WithCancel(context.Background())
	defer cancel()
	go func() {
		<-ctx.Done()
		_ = s.Server.Shutdown(shutdownCtx)
	}()
	klog.V(0).Infof("Start listening on %s", s.Server.Addr)
	if s.Server.TLSConfig != nil {
		err = s.Server.ListenAndServeTLS("", "")
	} else {
		err = s.Server.ListenAndServe()
	}
	return err
}