Running a Server

go get github.com/skyoo2003/acor/server
go get github.com/skyoo2003/acor/pkg/acor@latest

package main

import (
	"context"
	"errors"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/skyoo2003/acor/pkg/acor"
	"github.com/skyoo2003/acor/server"
	"github.com/skyoo2003/acor/server/health"
)

// redisChecker reports whether the collection can still reach Redis.
//
// Info() is the only exported call that proves the Redis path works, and it is
// not free: on V2 it HGETALLs the trie hash and unmarshals the whole keyword and
// prefix arrays just to count them. See "Readiness costs what Info() costs".
//
// The timeout is load-bearing: Check() runs inline in both probe paths, so a
// checker that blocks blocks the prober.
type redisChecker struct{ ac *acor.AhoCorasick }

func (c redisChecker) Check() health.CheckResult {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	if _, err := c.ac.InfoContext(ctx); err != nil {
		return health.CheckResult{Status: health.StatusUnhealthy, Details: err.Error()}
	}
	return health.CheckResult{Status: health.StatusHealthy}
}

func main() {
	ac, err := acor.Create(&acor.AhoCorasickArgs{
		Addr:     os.Getenv("REDIS_ADDR"),
		Password: os.Getenv("REDIS_PASSWORD"),
		Name:     "production",
	})
	if err != nil {
		log.Fatalf("create collection: %v", err)
	}
	defer ac.Close()

	checker := health.NewChecker()
	checker.Register("redis", redisChecker{ac})

	mux := http.NewServeMux()
	health.RegisterHTTPHandlers(mux, checker)  // /healthz and /readyz
	mux.Handle("/", server.NewHTTPHandler(ac)) // /v1/*

	srv := &http.Server{
		Addr:    ":8080",
		Handler: mux,
		// ReadHeaderTimeout alone leaves the body unbounded in time: a client
		// that sends good headers and then trickles bytes holds a goroutine
		// indefinitely. The 1 MiB cap bounds size, not duration.
		ReadHeaderTimeout: 5 * time.Second,
		ReadTimeout:       15 * time.Second,
		WriteTimeout:      15 * time.Second,
		IdleTimeout:       60 * time.Second,
	}

	go func() {
		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Fatalf("serve: %v", err)
		}
	}()
	log.Println("listening on", srv.Addr)

	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()
	<-ctx.Done()

	shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	if err := srv.Shutdown(shutdownCtx); err != nil {
		log.Printf("shutdown: %v", err)
	}
}

package main

import (
	"context"
	"log"
	"net"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/skyoo2003/acor/pkg/acor"
	"github.com/skyoo2003/acor/server"
	"github.com/skyoo2003/acor/server/health"
	"github.com/skyoo2003/acor/server/logging"
	"github.com/skyoo2003/acor/server/metrics"
)

// The deadline matters more here than over HTTP: the gRPC health poller calls
// Check() inline on its ticker, so a checker that blocks stalls every later poll
// and the poller's own response to cancellation.
type redisChecker struct{ ac *acor.AhoCorasick }

func (c redisChecker) Check() health.CheckResult {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	if _, err := c.ac.InfoContext(ctx); err != nil {
		return health.CheckResult{Status: health.StatusUnhealthy, Details: err.Error()}
	}
	return health.CheckResult{Status: health.StatusHealthy}
}

func main() {
	// This ctx bounds the background health-status poller as well as shutdown:
	// cancelling it stops that goroutine and marks the server NOT_SERVING.
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()

	ac, err := acor.Create(&acor.AhoCorasickArgs{
		Addr:     os.Getenv("REDIS_ADDR"),
		Password: os.Getenv("REDIS_PASSWORD"),
		Name:     "production",
	})
	if err != nil {
		log.Fatalf("create collection: %v", err)
	}
	defer ac.Close()

	checker := health.NewChecker()
	checker.Register("redis", redisChecker{ac})

	srv := server.NewGRPCServerWithObservability(ctx, ac, &server.Observability{
		Metrics: metrics.NewRegistry(nil),
		Logger:  logging.NewLogger(os.Stdout, "info"),
		Health:  checker,
		// Tracer is nil here, which skips tracing. See Operations → Monitoring.
	})

	lis, err := net.Listen("tcp", ":9090")
	if err != nil {
		log.Fatalf("listen: %v", err)
	}

	go func() {
		<-ctx.Done()
		// GracefulStop waits for every in-flight RPC with no deadline, and
		// grpc.health.v1.Watch is a stream that stays open: the health server's
		// Shutdown only pushes NOT_SERVING to watchers, it does not close them.
		// One connected watcher would otherwise block shutdown forever.
		stopped := make(chan struct{})
		go func() {
			srv.GracefulStop()
			close(stopped)
		}()
		select {
		case <-stopped:
		case <-time.After(15 * time.Second):
			srv.Stop()
		}
	}()

	log.Println("gRPC listening on", lis.Addr())
	if err := srv.Serve(lis); err != nil {
		log.Fatalf("serve: %v", err)
	}
}