init 2

server/main.go

@@ -0,0 +1,167 @@
+package main
+
+import (
+	"context"
+	"embed"
+	"fmt"
+	"io/fs"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	connectcors "connectrpc.com/cors"
+	"github.com/joho/godotenv"
+	"github.com/rs/cors"
+	"golang.org/x/net/http2"
+	"golang.org/x/net/http2/h2c"
+	"gorm.io/gorm"
+
+	"github.com/spotdemo4/trevstack/server/internal/database"
+	"github.com/spotdemo4/trevstack/server/internal/handlers"
+)
+
+//go:embed all:client
+var client embed.FS
+
+type env struct {
+	DBType string
+	DBUser string
+	DBPass string
+	DBHost string
+	DBPort string
+	DBName string
+	Port   string
+	Key    string
+}
+
+func main() {
+	err := godotenv.Load()
+	if err != nil {
+		log.Println("Failed to load .env file, using environment variables")
+	}
+
+	// Get environment variables for server
+	env := env{
+		DBType: os.Getenv("DB_TYPE"),
+		DBUser: os.Getenv("DB_USER"),
+		DBPass: os.Getenv("DB_PASS"),
+		DBHost: os.Getenv("DB_HOST"),
+		DBPort: os.Getenv("DB_PORT"),
+		DBName: os.Getenv("DB_NAME"),
+		Port:   os.Getenv("PORT"),
+		Key:    os.Getenv("KEY"),
+	}
+	if env.Port == "" {
+		env.Port = "8080"
+	}
+	if env.Key == "" {
+		log.Fatal("KEY is required")
+	}
+
+	// Get environment variables for database
+	db := &gorm.DB{}
+	switch env.DBType {
+	case "postgres":
+		log.Println("Using Postgres")
+
+		if env.DBUser == "" {
+			log.Fatal("DB_USER is required")
+		}
+		if env.DBPass == "" {
+			log.Fatal("DB_PASS is required")
+		}
+		if env.DBHost == "" {
+			log.Fatal("DB_HOST is required")
+		}
+		if env.DBPort == "" {
+			log.Fatal("DB_PORT is required")
+		}
+		if env.DBName == "" {
+			log.Fatal("DB_NAME is required")
+		}
+
+		db, err = database.NewPostgresConnection(env.DBUser, env.DBPass, env.DBHost, env.DBPort, env.DBName)
+		if err != nil {
+			log.Fatalf("failed to connect to postgres: %v", err)
+		}
+
+	case "sqlite":
+		log.Println("Using SQLite")
+
+		if env.DBName == "" {
+			log.Fatal("DB_NAME is required")
+		}
+
+		db, err = database.NewSQLiteConnection(env.DBName)
+		if err != nil {
+			log.Fatalf("failed to connect to sqlite: %v", err)
+		}
+
+	default:
+		log.Fatal("DB_TYPE must be either postgres or sqlite")
+	}
+
+	// Init database
+	if err := database.Migrate(db); err != nil {
+		log.Fatalf("failed to migrate database: %v", err)
+	}
+
+	// Serve GRPC Handlers
+	api := http.NewServeMux()
+	api.Handle(withCORS(handlers.NewAuthHandler(db, env.Key)))
+	api.Handle(withCORS(handlers.NewUserHandler(db, env.Key)))
+
+	// Serve web interface
+	mux := http.NewServeMux()
+	clientFs, err := fs.Sub(client, "client")
+	if err != nil {
+		log.Fatalf("failed to get sub filesystem: %v", err)
+	}
+	mux.Handle("/", http.FileServer(http.FS(clientFs)))
+	mux.Handle("/grpc/", http.StripPrefix("/grpc", api))
+
+	// Start server
+	log.Printf("Starting server on :%s", env.Port)
+	server := &http.Server{
+		Addr:    fmt.Sprintf(":%s", env.Port),
+		Handler: h2c.NewHandler(mux, &http2.Server{}),
+	}
+
+	// Gracefully shutdown on SIGINT or SIGTERM
+	sigs := make(chan os.Signal, 1)
+	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		sig := <-sigs
+		log.Printf("Received signal %s", sig)
+		log.Println("Exiting")
+
+		// Close HTTP server
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		if err := server.Shutdown(ctx); err != nil {
+			server.Close()
+		}
+		cancel()
+
+		// Close database connection
+		sqlDB, err := db.DB() // Get underlying SQL database
+		if err == nil {
+			sqlDB.Close()
+		}
+	}()
+
+	server.ListenAndServe()
+}
+
+// withCORS adds CORS support to a Connect HTTP handler.
+func withCORS(pattern string, h http.Handler) (string, http.Handler) {
+	middleware := cors.New(cors.Options{
+		AllowedOrigins: []string{"*"},
+		AllowedMethods: connectcors.AllowedMethods(),
+		AllowedHeaders: connectcors.AllowedHeaders(),
+		ExposedHeaders: connectcors.ExposedHeaders(),
+	})
+	return pattern, middleware.Handler(h)
+}