Initial revisin of healthchecker, inspired by HAProxy

internal/grpcapi/server.go

@@ -0,0 +1,167 @@
+package grpcapi
+
+import (
+	"context"
+	"fmt"
+	"net"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"git.ipng.ch/ipng/vpp-maglev/internal/checker"
+	"git.ipng.ch/ipng/vpp-maglev/internal/config"
+	"git.ipng.ch/ipng/vpp-maglev/internal/health"
+)
+
+// Server implements the HealthCheckerServer gRPC interface.
+type Server struct {
+	UnimplementedHealthCheckerServer
+	checker *checker.Checker
+}
+
+// NewServer creates a Server backed by the given Checker.
+func NewServer(c *checker.Checker) *Server {
+	return &Server{checker: c}
+}
+
+// ListVIPs returns the names of all configured VIPs.
+func (s *Server) ListVIPs(_ context.Context, _ *ListVIPsRequest) (*ListVIPsResponse, error) {
+	return &ListVIPsResponse{VipNames: s.checker.ListVIPs()}, nil
+}
+
+// GetVIP returns configuration details for a single VIP.
+func (s *Server) GetVIP(_ context.Context, req *GetVIPRequest) (*VIPInfo, error) {
+	vip, ok := s.checker.GetVIP(req.VipName)
+	if !ok {
+		return nil, status.Errorf(codes.NotFound, "vip %q not found", req.VipName)
+	}
+	return vipToProto(req.VipName, vip), nil
+}
+
+// ListBackends returns health state for all backends of a VIP.
+func (s *Server) ListBackends(_ context.Context, req *ListBackendsRequest) (*ListBackendsResponse, error) {
+	if _, ok := s.checker.GetVIP(req.VipName); !ok {
+		return nil, status.Errorf(codes.NotFound, "vip %q not found", req.VipName)
+	}
+	backends := s.checker.ListBackends(req.VipName)
+	resp := &ListBackendsResponse{}
+	for _, b := range backends {
+		resp.Backends = append(resp.Backends, backendToProto(b))
+	}
+	return resp, nil
+}
+
+// GetBackend returns health state for a specific VIP:backend tuple.
+func (s *Server) GetBackend(_ context.Context, req *GetBackendRequest) (*BackendInfo, error) {
+	b, ok := s.checker.GetBackend(req.VipName, req.BackendAddress)
+	if !ok {
+		return nil, status.Errorf(codes.NotFound, "backend %q in vip %q not found",
+			req.BackendAddress, req.VipName)
+	}
+	return backendToProto(b), nil
+}
+
+// PauseBackend pauses health checking for a specific backend.
+func (s *Server) PauseBackend(_ context.Context, req *PauseResumeRequest) (*BackendInfo, error) {
+	b, ok := s.checker.PauseBackend(req.VipName, req.BackendAddress)
+	if !ok {
+		return nil, status.Errorf(codes.NotFound, "backend %q in vip %q not found",
+			req.BackendAddress, req.VipName)
+	}
+	return backendToProto(b), nil
+}
+
+// ResumeBackend resumes health checking for a specific backend.
+func (s *Server) ResumeBackend(_ context.Context, req *PauseResumeRequest) (*BackendInfo, error) {
+	b, ok := s.checker.ResumeBackend(req.VipName, req.BackendAddress)
+	if !ok {
+		return nil, status.Errorf(codes.NotFound, "backend %q in vip %q not found",
+			req.BackendAddress, req.VipName)
+	}
+	return backendToProto(b), nil
+}
+
+// WatchTransitions streams the current state of all backends on connect, then
+// streams live state transitions until the client disconnects.
+func (s *Server) WatchTransitions(_ *WatchRequest, stream HealthChecker_WatchTransitionsServer) error {
+	// Send current state of all backends as synthetic events.
+	for _, vipName := range s.checker.ListVIPs() {
+		for _, b := range s.checker.ListBackends(vipName) {
+			ev := &TransitionEvent{
+				VipName:       vipName,
+				BackendAddress: b.Address.String(),
+				Transition: &TransitionRecord{
+					From:      b.State.String(),
+					To:        b.State.String(),
+					AtUnixNs:  0,
+				},
+			}
+			if err := stream.Send(ev); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Subscribe to live transitions.
+	ch, unsub := s.checker.Subscribe()
+	defer unsub()
+
+	for {
+		select {
+		case <-stream.Context().Done():
+			return nil
+		case e, ok := <-ch:
+			if !ok {
+				return nil
+			}
+			ev := &TransitionEvent{
+				VipName:       e.VIPName,
+				BackendAddress: e.Backend.String(),
+				Transition:    transitionToProto(e.Transition),
+			}
+			if err := stream.Send(ev); err != nil {
+				return err
+			}
+		}
+	}
+}
+
+// ---- conversion helpers ----------------------------------------------------
+
+func vipToProto(name string, v config.VIP) *VIPInfo {
+	info := &VIPInfo{
+		Name:        name,
+		Address:     v.Address.String(),
+		Protocol:    v.Protocol,
+		Port:        uint32(v.Port),
+		Description: v.Description,
+	}
+	for _, b := range v.Backends {
+		info.Backends = append(info.Backends, b.String())
+	}
+	return info
+}
+
+func backendToProto(b *health.Backend) *BackendInfo {
+	info := &BackendInfo{
+		VipName: b.VIPName,
+		Address: b.Address.String(),
+		State:   b.State.String(),
+	}
+	for _, t := range b.Transitions {
+		info.Transitions = append(info.Transitions, transitionToProto(t))
+	}
+	return info
+}
+
+func transitionToProto(t health.Transition) *TransitionRecord {
+	return &TransitionRecord{
+		From:     t.From.String(),
+		To:       t.To.String(),
+		AtUnixNs: t.At.UnixNano(),
+	}
+}
+
+// Ensure net.IP is imported (used via b.Address.String()).
+var _ = net.IP{}
+var _ = fmt.Sprintf