Files
mtusi2026lab3/cmd/server/main.go
T

171 lines
3.5 KiB
Go

package main
import (
"context"
"errors"
"fmt"
"log"
"net"
"net/http"
"os"
"os/signal"
"strconv"
"sync/atomic"
"syscall"
"time"
"gitflic.ru/project/d-sotnikova5/mtusi2026lab1-fork/internal/cache"
"gitflic.ru/project/d-sotnikova5/mtusi2026lab1-fork/internal/httpapi"
"gitflic.ru/project/d-sotnikova5/mtusi2026lab1-fork/internal/store"
)
func main() {
log.SetFlags(log.LstdFlags | log.LUTC)
if len(os.Args) == 2 && os.Args[1] == "dbcheck" {
if err := checkDatabase(); err != nil {
log.Print(err)
os.Exit(1)
}
return
}
if len(os.Args) == 2 && (os.Args[1] == "healthcheck" || os.Args[1] == "instance-id") {
if err := healthcheck(); err != nil {
log.Print(err)
os.Exit(1)
}
return
}
if err := run(); err != nil {
log.Print(err)
os.Exit(1)
}
}
func run() error {
host := envOrDefault("APP_HOST", "0.0.0.0")
port := envOrDefault("APP_PORT", "8080")
pool, err := store.OpenPostgres(context.Background(), envOrDefault(
"DATABASE_PASSWORD_FILE", "/run/secrets/postgres_password",
))
if err != nil {
return err
}
defer pool.Close()
profiles := cache.NewProfiles(envOrDefault("REDIS_ADDR", "redis:6379"))
defer profiles.Close()
db := store.NewPostgresStore(pool).WithProfiles(profiles)
var stopping atomic.Bool
ttl, err := strconv.ParseInt(envOrDefault("SESSION_TTL_SECONDS", "3600"), 10, 64)
if err != nil {
return errors.New("invalid SESSION_TTL_SECONDS")
}
handler, err := httpapi.NewPostgresHandler(db, &stopping, ttl)
if err != nil {
return err
}
server := &http.Server{
Addr: net.JoinHostPort(host, port),
Handler: handler,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
IdleTimeout: 60 * time.Second,
}
ctx, stop := signal.NotifyContext(
context.Background(),
os.Interrupt,
syscall.SIGTERM,
)
defer stop()
serverErrors := make(chan error, 1)
go func() {
log.Printf("server starting address=%s", server.Addr)
serverErrors <- server.ListenAndServe()
}()
select {
case err := <-serverErrors:
if errors.Is(err, http.ErrServerClosed) {
return nil
}
return err
case <-ctx.Done():
stopping.Store(true)
log.Print("shutdown started timeout=8s")
}
started := time.Now()
shutdownCtx, cancel := context.WithTimeout(
context.Background(),
8*time.Second,
)
defer cancel()
if err := server.Shutdown(shutdownCtx); err != nil {
_ = server.Close()
return fmt.Errorf("shutdown forced: %w", err)
}
log.Printf(
"shutdown completed duration_ms=%d",
time.Since(started).Milliseconds(),
)
return nil
}
func healthcheck() error {
host := envOrDefault("APP_HOST", "0.0.0.0")
port := envOrDefault("APP_PORT", "8080")
switch host {
case "0.0.0.0", "":
host = "127.0.0.1"
case "::":
host = "::1"
}
client := &http.Client{
Timeout: 2 * time.Second,
}
url := "http://" + net.JoinHostPort(host, port) + "/health/ready"
response, err := client.Get(url)
if err != nil {
return fmt.Errorf("healthcheck: %w", err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return fmt.Errorf("healthcheck: status=%d", response.StatusCode)
}
if len(os.Args) == 2 && os.Args[1] == "instance-id" {
id := response.Header.Get("X-Instance-Id")
if id == "" {
return errors.New("missing X-Instance-Id")
}
fmt.Println(id)
}
return nil
}
func envOrDefault(name string, fallback string) string {
if value := os.Getenv(name); value != "" {
return value
}
return fallback
}