feat(gl): scaffold general ledger grpc service

interface/grpc/health.go

@@ -0,0 +1,26 @@
+package grpcadapter
+
+import (
+	"context"
+
+	"gl/application/health"
+	basev1 "gl/gen/base/v1"
+	ledgerv1 "gl/gen/ledger/v1"
+)
+
+type HealthHandler struct {
+	ledgerv1.UnimplementedGeneralLedgerServiceServer
+	service *health.Service
+}
+
+func NewHealthHandler(service *health.Service) *HealthHandler {
+	return &HealthHandler{service: service}
+}
+
+func (h *HealthHandler) Health(ctx context.Context, _ *basev1.Empty) (*ledgerv1.HealthResponse, error) {
+	result := h.service.Check(ctx)
+	return &ledgerv1.HealthResponse{
+		Serving:       result.Serving,
+		DatabaseReady: result.DatabaseReady,
+	}, nil
+}

interface/grpc/health_test.go

@@ -0,0 +1,19 @@
+package grpcadapter
+
+import (
+	"context"
+	"testing"
+
+	"gl/application/health"
+	basev1 "gl/gen/base/v1"
+)
+
+func TestHealth(t *testing.T) {
+	response, err := NewHealthHandler(health.NewService(nil)).Health(context.Background(), &basev1.Empty{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !response.Serving || response.DatabaseReady {
+		t.Fatalf("unexpected response: %+v", response)
+	}
+}

interface/grpc/server.go

@@ -0,0 +1,69 @@
+package grpcadapter
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"time"
+
+	ledgerv1 "gl/gen/ledger/v1"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/reflection"
+)
+
+type ServerConfig struct {
+	Host            string
+	Port            int
+	ShutdownTimeout time.Duration
+}
+
+func Run(ctx context.Context, cfg ServerConfig, handler ledgerv1.GeneralLedgerServiceServer) error {
+	listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", cfg.Host, cfg.Port))
+	if err != nil {
+		return fmt.Errorf("listen for grpc: %w", err)
+	}
+	return runWithListener(ctx, cfg.ShutdownTimeout, listener, handler)
+}
+
+func runWithListener(ctx context.Context, shutdownTimeout time.Duration, listener net.Listener, handler ledgerv1.GeneralLedgerServiceServer) error {
+	defer listener.Close()
+
+	server := grpc.NewServer()
+	ledgerv1.RegisterGeneralLedgerServiceServer(server, handler)
+	reflection.Register(server)
+
+	serveErr := make(chan error, 1)
+	go func() { serveErr <- server.Serve(listener) }()
+
+	select {
+	case err := <-serveErr:
+		if errors.Is(err, grpc.ErrServerStopped) {
+			return nil
+		}
+		return fmt.Errorf("serve grpc: %w", err)
+	case <-ctx.Done():
+	}
+
+	stopped := make(chan struct{})
+	go func() {
+		server.GracefulStop()
+		close(stopped)
+	}()
+
+	timer := time.NewTimer(shutdownTimeout)
+	defer timer.Stop()
+	select {
+	case <-stopped:
+	case <-timer.C:
+		server.Stop()
+		<-stopped
+	}
+
+	err := <-serveErr
+	if err != nil && !errors.Is(err, grpc.ErrServerStopped) {
+		return fmt.Errorf("serve grpc: %w", err)
+	}
+	return nil
+}

interface/grpc/server_test.go

@@ -0,0 +1,26 @@
+package grpcadapter
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"gl/application/health"
+
+	"google.golang.org/grpc/test/bufconn"
+)
+
+func TestRunStopsWhenContextIsCancelled(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	err := runWithListener(
+		ctx,
+		time.Second,
+		bufconn.Listen(1024),
+		NewHealthHandler(health.NewService(nil)),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+}