github.com/cilium/cilium@v1.16.2/api/v1/health/server/server.go

// Code generated by go-swagger; DO NOT EDIT.

// Copyright Authors of Cilium
// SPDX-License-Identifier: Apache-2.0

package server

import (
	"context"
	"crypto/tls"
	"crypto/x509"
	"errors"
	"fmt"
	"log"
	"net"
	"net/http"
	"os"
	"strconv"
	"sync"
	"time"

	"github.com/go-openapi/loads"
	"github.com/go-openapi/runtime/middleware"
	"github.com/go-openapi/swag"
	"github.com/sirupsen/logrus"
	"github.com/spf13/pflag"
	"golang.org/x/net/netutil"

	"github.com/cilium/cilium/api/v1/health/server/restapi"
	"github.com/cilium/cilium/api/v1/health/server/restapi/connectivity"
	"github.com/cilium/hive/cell"

	"github.com/cilium/cilium/pkg/api"
	"github.com/cilium/cilium/pkg/hive"
)

// Cell implements the cilium health API REST API server when provided
// the required request handlers.
var Cell = cell.Module(
	"cilium-health-api-server",
	"cilium health API server",

	cell.Provide(newForCell),
	APICell,
)

// APICell provides the restapi.CiliumHealthAPIAPI type, populated
// with the request handlers. This cell is an alternative to 'Cell' when only
// the API type is required and not the full server implementation.
var APICell = cell.Provide(newAPI)

type apiParams struct {
	cell.In

	Spec *Spec

	Middleware middleware.Builder `name:"cilium-health-api-middleware" optional:"true"`

	GetHealthzHandler                 restapi.GetHealthzHandler
	ConnectivityGetStatusHandler      connectivity.GetStatusHandler
	ConnectivityPutStatusProbeHandler connectivity.PutStatusProbeHandler
}

func newAPI(p apiParams) *restapi.CiliumHealthAPIAPI {
	api := restapi.NewCiliumHealthAPIAPI(p.Spec.Document)

	// Construct the API from the provided handlers

	api.GetHealthzHandler = p.GetHealthzHandler
	api.ConnectivityGetStatusHandler = p.ConnectivityGetStatusHandler
	api.ConnectivityPutStatusProbeHandler = p.ConnectivityPutStatusProbeHandler

	// Inject custom middleware if provided by Hive
	if p.Middleware != nil {
		api.Middleware = func(builder middleware.Builder) http.Handler {
			return p.Middleware(api.Context().APIHandler(builder))
		}
	}

	return api
}

type serverParams struct {
	cell.In

	Lifecycle  cell.Lifecycle
	Shutdowner hive.Shutdowner
	Logger     logrus.FieldLogger
	Spec       *Spec
	API        *restapi.CiliumHealthAPIAPI
}

func newForCell(p serverParams) (*Server, error) {
	s := NewServer(p.API)
	s.shutdowner = p.Shutdowner
	s.logger = p.Logger
	p.Lifecycle.Append(s)
	return s, nil
}

const (
	schemeHTTP  = "http"
	schemeHTTPS = "https"
	schemeUnix  = "unix"
)

var defaultSchemes []string

func init() {
	defaultSchemes = []string{
		schemeUnix,
	}
}

var (
	enabledListeners []string
	gracefulTimeout  time.Duration
	maxHeaderSize    int

	socketPath string

	host         string
	port         int
	listenLimit  int
	keepAlive    time.Duration
	readTimeout  time.Duration
	writeTimeout time.Duration

	tlsHost           string
	tlsPort           int
	tlsListenLimit    int
	tlsKeepAlive      time.Duration
	tlsReadTimeout    time.Duration
	tlsWriteTimeout   time.Duration
	tlsCertificate    string
	tlsCertificateKey string
	tlsCACertificate  string
)

type ServerConfig struct {
	EnableCiliumHealthAPIServerAccess []string
}

var (
	defaultServerConfig = ServerConfig{
		EnableCiliumHealthAPIServerAccess: []string{"*"},
	}
	AdminEnableFlag = "enable-cilium-health-api-server-access"
)

func (cfg ServerConfig) Flags(flags *pflag.FlagSet) {
	flags.StringSlice(AdminEnableFlag, cfg.EnableCiliumHealthAPIServerAccess,
		"List of cilium health API APIs which are administratively enabled. Supports '*'.")
}

var SpecCell = cell.Module(
	"cilium-health-api-spec",
	"cilium health API Specification",

	cell.Config(defaultServerConfig),
	cell.Provide(newSpec),
)

type Spec struct {
	*loads.Document

	// DeniedAPIs is a set of APIs that are administratively disabled.
	DeniedAPIs api.PathSet
}

func newSpec(cfg ServerConfig) (*Spec, error) {
	swaggerSpec, err := loads.Analyzed(SwaggerJSON, "")
	if err != nil {
		return nil, fmt.Errorf("failed to load swagger spec: %w", err)
	}

	deniedAPIs, err := api.AllowedFlagsToDeniedPaths(swaggerSpec, cfg.EnableCiliumHealthAPIServerAccess)
	if err != nil {
		return nil, fmt.Errorf("failed to parse %q flag: %w",
			AdminEnableFlag, err)
	}

	return &Spec{
		Document:   swaggerSpec,
		DeniedAPIs: deniedAPIs,
	}, nil
}

// NewServer creates a new api cilium health API server but does not configure it
func NewServer(api *restapi.CiliumHealthAPIAPI) *Server {
	s := new(Server)
	s.api = api
	return s
}

// ConfigureAPI configures the API and handlers.
func (s *Server) ConfigureAPI() {
	if s.api != nil {
		s.handler = configureAPI(s.api)
	}
}

// ConfigureFlags configures the additional flags defined by the handlers. Needs to be called before the parser.Parse
func (s *Server) ConfigureFlags() {
	if s.api != nil {
		configureFlags(s.api)
	}
}

// Server for the cilium health API API
type Server struct {
	EnabledListeners []string
	CleanupTimeout   time.Duration
	GracefulTimeout  time.Duration
	MaxHeaderSize    int

	SocketPath    string
	domainSocketL *net.UnixListener

	Host         string
	Port         int
	ListenLimit  int
	KeepAlive    time.Duration
	ReadTimeout  time.Duration
	WriteTimeout time.Duration
	httpServerL  net.Listener

	TLSHost           string
	TLSPort           int
	TLSCertificate    string
	TLSCertificateKey string
	TLSCACertificate  string
	TLSListenLimit    int
	TLSKeepAlive      time.Duration
	TLSReadTimeout    time.Duration
	TLSWriteTimeout   time.Duration
	httpsServerL      net.Listener

	api          *restapi.CiliumHealthAPIAPI
	handler      http.Handler
	hasListeners bool
	servers      []*http.Server

	wg         sync.WaitGroup
	shutdowner hive.Shutdowner
	logger     logrus.FieldLogger
}

// Logf logs message either via defined user logger or via system one if no user logger is defined.
func (s *Server) Logf(f string, args ...interface{}) {
	if s.logger != nil {
		s.logger.Infof(f, args...)
	} else if s.api != nil && s.api.Logger != nil {
		s.api.Logger(f, args...)
	} else {
		log.Printf(f, args...)
	}
}

// Fatalf logs message either via defined user logger or via system one if no user logger is defined.
// Exits with non-zero status after printing
func (s *Server) Fatalf(f string, args ...interface{}) {
	if s.shutdowner != nil {
		s.shutdowner.Shutdown(hive.ShutdownWithError(fmt.Errorf(f, args...)))
	} else if s.api != nil && s.api.Logger != nil {
		s.api.Logger(f, args...)
		os.Exit(1)
	} else {
		log.Fatalf(f, args...)
	}
}

// SetAPI configures the server with the specified API. Needs to be called before Serve
func (s *Server) SetAPI(api *restapi.CiliumHealthAPIAPI) {
	if api == nil {
		s.api = nil
		s.handler = nil
		return
	}

	s.api = api
	s.handler = configureAPI(api)
}

// GetAPI returns the configured API. Modifications on the API must be performed
// before server is started.
func (s *Server) GetAPI() *restapi.CiliumHealthAPIAPI {
	return s.api
}

func (s *Server) hasScheme(scheme string) bool {
	schemes := s.EnabledListeners
	if len(schemes) == 0 {
		schemes = defaultSchemes
	}

	for _, v := range schemes {
		if v == scheme {
			return true
		}
	}
	return false
}

func (s *Server) Serve() error {
	// TODO remove when this is not needed for compatibility anymore
	if err := s.Start(context.TODO()); err != nil {
		return err
	}
	s.wg.Wait()
	return nil
}

// Start the server
func (s *Server) Start(cell.HookContext) (err error) {
	if !s.hasListeners {
		if err = s.Listen(); err != nil {
			return err
		}
	}

	if len(s.servers) != 0 {
		return errors.New("already started")
	}

	// set default handler, if none is set
	if s.handler == nil {
		if s.api == nil {
			return errors.New("can't create the default handler, as no api is set")
		}

		s.ConfigureAPI()
		s.SetHandler(s.api.Serve(nil))
	}

	if s.hasScheme(schemeUnix) {
		domainSocket := new(http.Server)
		domainSocket.MaxHeaderBytes = s.MaxHeaderSize
		domainSocket.Handler = s.handler
		if int64(s.CleanupTimeout) > 0 {
			domainSocket.IdleTimeout = s.CleanupTimeout
		}

		configureServer(domainSocket, "unix", s.SocketPath)

		if os.Getuid() == 0 {
			err := api.SetDefaultPermissions(s.SocketPath)
			if err != nil {
				return err
			}
		}
		s.servers = append(s.servers, domainSocket)
		s.wg.Add(1)
		s.Logf("Serving cilium health API at unix://%s", s.SocketPath)
		go func(l net.Listener) {
			defer s.wg.Done()
			if err := domainSocket.Serve(l); err != nil && err != http.ErrServerClosed {
				s.Fatalf("%v", err)
			}
			s.Logf("Stopped serving cilium health API at unix://%s", s.SocketPath)
		}(s.domainSocketL)
	}

	if s.hasScheme(schemeHTTP) {
		httpServer := new(http.Server)
		httpServer.MaxHeaderBytes = s.MaxHeaderSize
		httpServer.ReadTimeout = s.ReadTimeout
		httpServer.WriteTimeout = s.WriteTimeout
		httpServer.SetKeepAlivesEnabled(int64(s.KeepAlive) > 0)
		if s.ListenLimit > 0 {
			s.httpServerL = netutil.LimitListener(s.httpServerL, s.ListenLimit)
		}

		if int64(s.CleanupTimeout) > 0 {
			httpServer.IdleTimeout = s.CleanupTimeout
		}

		httpServer.Handler = s.handler

		configureServer(httpServer, "http", s.httpServerL.Addr().String())

		s.servers = append(s.servers, httpServer)
		s.wg.Add(1)
		s.Logf("Serving cilium health API at http://%s", s.httpServerL.Addr())
		go func(l net.Listener) {
			defer s.wg.Done()
			if err := httpServer.Serve(l); err != nil && err != http.ErrServerClosed {
				s.Fatalf("%v", err)
			}
			s.Logf("Stopped serving cilium health API at http://%s", l.Addr())
		}(s.httpServerL)
	}

	if s.hasScheme(schemeHTTPS) {
		httpsServer := new(http.Server)
		httpsServer.MaxHeaderBytes = s.MaxHeaderSize
		httpsServer.ReadTimeout = s.TLSReadTimeout
		httpsServer.WriteTimeout = s.TLSWriteTimeout
		httpsServer.SetKeepAlivesEnabled(int64(s.TLSKeepAlive) > 0)
		if s.TLSListenLimit > 0 {
			s.httpsServerL = netutil.LimitListener(s.httpsServerL, s.TLSListenLimit)
		}
		if int64(s.CleanupTimeout) > 0 {
			httpsServer.IdleTimeout = s.CleanupTimeout
		}
		httpsServer.Handler = s.handler

		// Inspired by https://blog.bracebin.com/achieving-perfect-ssl-labs-score-with-go
		httpsServer.TLSConfig = &tls.Config{
			// Causes servers to use Go's default ciphersuite preferences,
			// which are tuned to avoid attacks. Does nothing on clients.
			PreferServerCipherSuites: true,
			// Only use curves which have assembly implementations
			// https://github.com/golang/go/tree/master/src/crypto/elliptic
			CurvePreferences: []tls.CurveID{tls.CurveP256},
			// Use modern tls mode https://wiki.mozilla.org/Security/Server_Side_TLS#Modern_compatibility
			NextProtos: []string{"h2", "http/1.1"},
			// https://www.owasp.org/index.php/Transport_Layer_Protection_Cheat_Sheet#Rule_-_Only_Support_Strong_Protocols
			MinVersion: tls.VersionTLS12,
			// These ciphersuites support Forward Secrecy: https://en.wikipedia.org/wiki/Forward_secrecy
			CipherSuites: []uint16{
				tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
				tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
				tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
				tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
				tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
				tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
			},
		}

		// build standard config from server options
		if s.TLSCertificate != "" && s.TLSCertificateKey != "" {
			httpsServer.TLSConfig.Certificates = make([]tls.Certificate, 1)
			httpsServer.TLSConfig.Certificates[0], err = tls.LoadX509KeyPair(s.TLSCertificate, s.TLSCertificateKey)
			if err != nil {
				return err
			}
		}

		if s.TLSCACertificate != "" {
			// include specified CA certificate
			caCert, caCertErr := os.ReadFile(s.TLSCACertificate)
			if caCertErr != nil {
				return caCertErr
			}
			caCertPool := x509.NewCertPool()
			ok := caCertPool.AppendCertsFromPEM(caCert)
			if !ok {
				return fmt.Errorf("cannot parse CA certificate")
			}
			httpsServer.TLSConfig.ClientCAs = caCertPool
			httpsServer.TLSConfig.ClientAuth = tls.RequireAndVerifyClientCert
		}

		// call custom TLS configurator
		configureTLS(httpsServer.TLSConfig)

		if len(httpsServer.TLSConfig.Certificates) == 0 && httpsServer.TLSConfig.GetCertificate == nil {
			// after standard and custom config are passed, this ends up with no certificate
			if s.TLSCertificate == "" {
				if s.TLSCertificateKey == "" {
					s.Fatalf("the required flags `--tls-certificate` and `--tls-key` were not specified")
				}
				s.Fatalf("the required flag `--tls-certificate` was not specified")
			}
			if s.TLSCertificateKey == "" {
				s.Fatalf("the required flag `--tls-key` was not specified")
			}
			// this happens with a wrong custom TLS configurator
			s.Fatalf("no certificate was configured for TLS")
		}

		// must have at least one certificate or panics
		httpsServer.TLSConfig.BuildNameToCertificate()

		configureServer(httpsServer, "https", s.httpsServerL.Addr().String())

		s.servers = append(s.servers, httpsServer)
		s.wg.Add(1)
		s.Logf("Serving cilium health API at https://%s", s.httpsServerL.Addr())
		go func(l net.Listener) {
			defer s.wg.Done()
			if err := httpsServer.Serve(l); err != nil && err != http.ErrServerClosed {
				s.Fatalf("%v", err)
			}
			s.Logf("Stopped serving cilium health API at https://%s", l.Addr())
		}(tls.NewListener(s.httpsServerL, httpsServer.TLSConfig))
	}

	return nil
}

// Listen creates the listeners for the server
func (s *Server) Listen() error {
	if s.hasListeners { // already done this
		return nil
	}

	if s.hasScheme(schemeHTTPS) {
		// Use http host if https host wasn't defined
		if s.TLSHost == "" {
			s.TLSHost = s.Host
		}
		// Use http listen limit if https listen limit wasn't defined
		if s.TLSListenLimit == 0 {
			s.TLSListenLimit = s.ListenLimit
		}
		// Use http tcp keep alive if https tcp keep alive wasn't defined
		if int64(s.TLSKeepAlive) == 0 {
			s.TLSKeepAlive = s.KeepAlive
		}
		// Use http read timeout if https read timeout wasn't defined
		if int64(s.TLSReadTimeout) == 0 {
			s.TLSReadTimeout = s.ReadTimeout
		}
		// Use http write timeout if https write timeout wasn't defined
		if int64(s.TLSWriteTimeout) == 0 {
			s.TLSWriteTimeout = s.WriteTimeout
		}
	}

	if s.hasScheme(schemeUnix) {
		addr, err := net.ResolveUnixAddr("unix", s.SocketPath)
		if err != nil {
			return err
		}
		domSockListener, err := net.ListenUnix("unix", addr)
		if err != nil {
			return err
		}
		s.domainSocketL = domSockListener
	}

	if s.hasScheme(schemeHTTP) {
		listener, err := net.Listen("tcp", net.JoinHostPort(s.Host, strconv.Itoa(s.Port)))
		if err != nil {
			return err
		}

		h, p, err := swag.SplitHostPort(listener.Addr().String())
		if err != nil {
			return err
		}
		s.Host = h
		s.Port = p
		s.httpServerL = listener
	}

	if s.hasScheme(schemeHTTPS) {
		tlsListener, err := net.Listen("tcp", net.JoinHostPort(s.TLSHost, strconv.Itoa(s.TLSPort)))
		if err != nil {
			return err
		}

		sh, sp, err := swag.SplitHostPort(tlsListener.Addr().String())
		if err != nil {
			return err
		}
		s.TLSHost = sh
		s.TLSPort = sp
		s.httpsServerL = tlsListener
	}

	s.hasListeners = true
	return nil
}

// Shutdown server and clean up resources
func (s *Server) Shutdown() error {
	ctx, cancel := context.WithTimeout(context.TODO(), s.GracefulTimeout)
	defer cancel()
	return s.Stop(ctx)
}

func (s *Server) Stop(ctx cell.HookContext) error {
	// first execute the pre-shutdown hook
	s.api.PreServerShutdown()

	shutdownChan := make(chan bool)
	for i := range s.servers {
		server := s.servers[i]
		go func() {
			var success bool
			defer func() {
				shutdownChan <- success
			}()
			if err := server.Shutdown(ctx); err != nil {
				s.Logf("HTTP server Shutdown: %v", err)

				// Forcefully close open connections.
				server.Close()
			} else {
				success = true
			}
		}()
	}

	// Wait until all listeners have successfully shut down before calling ServerShutdown
	success := true
	for range s.servers {
		success = success && <-shutdownChan
	}
	if success {
		s.api.ServerShutdown()
	}

	s.wg.Wait()
	s.servers = nil

	return nil
}

// GetHandler returns a handler useful for testing
func (s *Server) GetHandler() http.Handler {
	return s.handler
}

// SetHandler allows for setting a http handler on this server
func (s *Server) SetHandler(handler http.Handler) {
	s.handler = handler
}

// UnixListener returns the domain socket listener
func (s *Server) UnixListener() (*net.UnixListener, error) {
	if !s.hasListeners {
		if err := s.Listen(); err != nil {
			return nil, err
		}
	}
	return s.domainSocketL, nil
}

// HTTPListener returns the http listener
func (s *Server) HTTPListener() (net.Listener, error) {
	if !s.hasListeners {
		if err := s.Listen(); err != nil {
			return nil, err
		}
	}
	return s.httpServerL, nil
}

// TLSListener returns the https listener
func (s *Server) TLSListener() (net.Listener, error) {
	if !s.hasListeners {
		if err := s.Listen(); err != nil {
			return nil, err
		}
	}
	return s.httpsServerL, nil
}