generated from CubeCraft-Creations/Tracehound
135 lines
3.2 KiB
Go
135 lines
3.2 KiB
Go
// Package main is the entry point for the RemoteRig central hub.
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/cubecraft/remoterig/internal/auth"
|
|
"github.com/cubecraft/remoterig/internal/db"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/go-chi/chi/v5/middleware"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
// Config holds the application configuration.
|
|
type Config struct {
|
|
DBPath string `yaml:"db_path"`
|
|
APIKey string `yaml:"api_key"`
|
|
Port string `yaml:"port"`
|
|
ReadTimeout time.Duration `yaml:"read_timeout"`
|
|
WriteTimeout time.Duration `yaml:"write_timeout"`
|
|
IdleTimeout time.Duration `yaml:"idle_timeout"`
|
|
MQTT struct {
|
|
Broker string `yaml:"broker"`
|
|
ClientID string `yaml:"client_id"`
|
|
} `yaml:"mqtt"`
|
|
Platform struct {
|
|
Type string `yaml:"type"`
|
|
MaxCameras int `yaml:"max_cameras"`
|
|
} `yaml:"platform"`
|
|
}
|
|
|
|
func main() {
|
|
log.Println("RemoteRig hub starting...")
|
|
|
|
// Load config
|
|
cfg, err := loadConfig("config.yaml")
|
|
if err != nil {
|
|
log.Fatalf("Failed to load config: %v", err)
|
|
}
|
|
|
|
// Open database
|
|
db, err := db.Open(cfg.DBPath)
|
|
if err != nil {
|
|
log.Fatalf("Failed to open database: %v", err)
|
|
}
|
|
defer db.Close()
|
|
log.Printf("Database open: %s", cfg.DBPath)
|
|
|
|
// Set up router
|
|
r := chi.NewRouter()
|
|
r.Use(middleware.RequestID)
|
|
r.Use(middleware.RealIP)
|
|
r.Use(middleware.Logger)
|
|
r.Use(middleware.Recoverer)
|
|
r.Use(middleware.Timeout(cfg.WriteTimeout))
|
|
|
|
// Health check (no auth)
|
|
r.Get("/health", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Write([]byte(`{"status":"ok"}`))
|
|
})
|
|
|
|
// API routes (auth required if API key is configured)
|
|
r.Mount("/api/v1", auth.Middleware(cfg.APIKey)(apiRouter(db)))
|
|
|
|
// Create server
|
|
httpServer := &http.Server{
|
|
Addr: ":" + cfg.Port,
|
|
Handler: r,
|
|
ReadTimeout: cfg.ReadTimeout,
|
|
WriteTimeout: cfg.WriteTimeout,
|
|
IdleTimeout: cfg.IdleTimeout,
|
|
}
|
|
|
|
// Graceful shutdown
|
|
go func() {
|
|
sigInt := make(chan os.Signal, 1)
|
|
signal.Notify(sigInt, syscall.SIGINT, syscall.SIGTERM)
|
|
<-sigInt
|
|
log.Println("Shutting down server...")
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
httpServer.Shutdown(ctx)
|
|
}()
|
|
|
|
log.Printf("Server listening on port %s", cfg.Port)
|
|
if err := httpServer.ListenAndServe(); err != nil {
|
|
log.Fatalf("Server failed: %v", err)
|
|
}
|
|
}
|
|
|
|
// apiRouter creates the API route tree.
|
|
func apiRouter(database *db.DB) http.Handler {
|
|
r := chi.NewRouter()
|
|
// TODO: register handler routes here
|
|
// Example: r.Get("/cameras", handlers.ListCameras(database))
|
|
return r
|
|
}
|
|
|
|
func loadConfig(path string) (*Config, error) {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read config file: %w", err)
|
|
}
|
|
|
|
var cfg Config
|
|
if err := yaml.Unmarshal(data, &cfg); err != nil {
|
|
return nil, fmt.Errorf("parse config: %w", err)
|
|
}
|
|
|
|
// Defaults
|
|
if cfg.Port == "" {
|
|
cfg.Port = "8080"
|
|
}
|
|
if cfg.DBPath == "" {
|
|
cfg.DBPath = "remoterig.db"
|
|
}
|
|
if cfg.MQTT.Broker == "" {
|
|
cfg.MQTT.Broker = "localhost:1883"
|
|
}
|
|
if cfg.MQTT.ClientID == "" {
|
|
cfg.MQTT.ClientID = "remoterig-hub"
|
|
}
|
|
|
|
return &cfg, nil
|
|
}
|