133 lines
4.0 KiB
Go
133 lines
4.0 KiB
Go
// Command server runs the iam microservice: a gRPC server exposing
|
|
// api/proto/iam/v1 over ENKLY_IAM_GRPC_ADDR, backed by its own Postgres
|
|
// database. Replaces the auth-related slice of the monolith's
|
|
// cmd/server/main.go + internal/handlers/auth.go.
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"net"
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
"time"
|
|
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/health"
|
|
healthpb "google.golang.org/grpc/health/grpc_health_v1"
|
|
"google.golang.org/grpc/reflection"
|
|
|
|
iamv1 "enkly/gen/iam/v1"
|
|
"enkly/pkg/authsupport"
|
|
"enkly/pkg/envkit"
|
|
"enkly/pkg/eventbus"
|
|
"enkly/pkg/pgkit"
|
|
"enkly/services/iam/internal/application"
|
|
"enkly/services/iam/internal/infrastructure/postgres"
|
|
grpcsrv "enkly/services/iam/internal/interfaces/grpc"
|
|
)
|
|
|
|
func main() {
|
|
logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
|
|
|
|
if err := envkit.LoadDotEnv(".env"); err != nil {
|
|
logger.Error("load .env", "err", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
var (
|
|
grpcAddr = envkit.String("ENKLY_IAM_GRPC_ADDR", ":9001")
|
|
postgresDSN = envkit.String("ENKLY_IAM_POSTGRES_DSN", "postgres://enkly:enkly@localhost:5432/enkly_iam?sslmode=disable")
|
|
rabbitURL = envkit.String("ENKLY_RABBITMQ_URL", "amqp://enkly:enkly@localhost:5672/")
|
|
baseURL = envkit.String("ENKLY_BASE_URL", "http://localhost:8080")
|
|
migrationsPath = envkit.String("ENKLY_IAM_MIGRATIONS", "migrations/0001_init.sql")
|
|
|
|
smtpUsername = envkit.String("ENKLY_SMTP_USERNAME", "")
|
|
smtpPassword = envkit.String("ENKLY_SMTP_PASSWORD", "")
|
|
)
|
|
|
|
db, err := pgkit.Open(postgresDSN)
|
|
if err != nil {
|
|
logger.Error("open postgres", "err", err)
|
|
os.Exit(1)
|
|
}
|
|
defer db.Close()
|
|
migrationSQL, err := os.ReadFile(migrationsPath)
|
|
if err != nil {
|
|
logger.Error("read migrations", "path", migrationsPath, "err", err)
|
|
os.Exit(1)
|
|
}
|
|
if err := db.Migrate(context.Background(), string(migrationSQL)); err != nil {
|
|
logger.Error("migrate", "err", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
bus, err := eventbus.Connect(rabbitURL, logger)
|
|
if err != nil {
|
|
logger.Error("connect rabbitmq", "err", err)
|
|
os.Exit(1)
|
|
}
|
|
defer bus.Close()
|
|
|
|
svc := &application.Service{
|
|
Users: postgres.NewUserRepo(db),
|
|
Sessions: postgres.NewSessionRepo(db),
|
|
Verification: postgres.NewVerificationRepo(db),
|
|
PasswordReset: postgres.NewPasswordResetRepo(db),
|
|
Events: bus,
|
|
Logger: logger,
|
|
BaseURL: baseURL,
|
|
MailConfigured: smtpUsername != "" && smtpPassword != "",
|
|
// Same windows/backoffs as the monolith's cmd/server/main.go —
|
|
// progressive delay, not a hard lockout; see authsupport.Limiter.
|
|
LoginLimiter: authsupport.NewLimiter(15*time.Minute, 500*time.Millisecond, 8*time.Second),
|
|
ResendLimiter: authsupport.NewLimiter(1*time.Hour, 2*time.Second, 30*time.Second),
|
|
VerifyLimiter: authsupport.NewLimiter(15*time.Minute, 500*time.Millisecond, 8*time.Second),
|
|
}
|
|
|
|
// Periodic cleanup of expired sessions/codes/tokens — replaces the
|
|
// goroutine cmd/server/main.go started around db.CleanupExpired.
|
|
go func() {
|
|
t := time.NewTicker(1 * time.Hour)
|
|
defer t.Stop()
|
|
for range t.C {
|
|
n, err := postgres.CleanupExpired(context.Background(), db)
|
|
if err != nil {
|
|
logger.Error("cleanup expired", "err", err)
|
|
continue
|
|
}
|
|
if n > 0 {
|
|
logger.Info("cleanup expired", "rows_deleted", n)
|
|
}
|
|
}
|
|
}()
|
|
|
|
lis, err := net.Listen("tcp", grpcAddr)
|
|
if err != nil {
|
|
logger.Error("listen", "addr", grpcAddr, "err", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
grpcServer := grpc.NewServer()
|
|
iamv1.RegisterIAMServiceServer(grpcServer, grpcsrv.New(svc))
|
|
healthSrv := health.NewServer()
|
|
healthpb.RegisterHealthServer(grpcServer, healthSrv)
|
|
healthSrv.SetServingStatus("", healthpb.HealthCheckResponse_SERVING)
|
|
reflection.Register(grpcServer)
|
|
|
|
go func() {
|
|
logger.Info("iam service listening", "addr", grpcAddr)
|
|
if err := grpcServer.Serve(lis); err != nil {
|
|
logger.Error("serve", "err", err)
|
|
os.Exit(1)
|
|
}
|
|
}()
|
|
|
|
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
|
|
defer stop()
|
|
<-ctx.Done()
|
|
logger.Info("shutting down")
|
|
grpcServer.GracefulStop()
|
|
}
|