Rewrite Strix from scratch as single binary
Complete architecture rewrite following go2rtc patterns: - pkg/ for pure logic (camdb, tester, probe, generate) - internal/ for application glue with Init() modules - Single HTTP server on :4567 with all endpoints - zerolog with password masking and memory ring buffer - Environment-based config only (no YAML files) API endpoints: /api/search, /api/streams, /api/test, /api/probe, /api/generate, /api/health, /api/log Dependencies: go2rtc v1.9.14, go-sqlite3, miekg/dns, zerolog
This commit is contained in:
eduard256
@@ -0,0 +1,126 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"embed"
|
||||
"encoding/json"
|
||||
"io/fs"
|
||||
"net"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"github.com/eduard256/strix/internal/app"
|
||||
"github.com/rs/zerolog"
|
||||
)
|
||||
|
||||
var log zerolog.Logger
|
||||
|
||||
var Handler http.Handler
|
||||
|
||||
func Init() {
|
||||
listen := app.Env("STRIX_LISTEN", ":4567")
|
||||
|
||||
log = app.GetLogger("api")
|
||||
|
||||
HandleFunc("api", apiHandler)
|
||||
HandleFunc("api/health", apiHealth)
|
||||
HandleFunc("api/log", apiLog)
|
||||
|
||||
// serve frontend from embedded web/ directory
|
||||
if sub, err := fs.Sub(webFS, "web"); err == nil {
|
||||
http.Handle("/", http.FileServer(http.FS(sub)))
|
||||
}
|
||||
|
||||
Handler = middlewareCORS(http.DefaultServeMux)
|
||||
|
||||
if log.Trace().Enabled() {
|
||||
Handler = middlewareLog(Handler)
|
||||
}
|
||||
|
||||
go listen_serve("tcp", listen)
|
||||
}
|
||||
|
||||
//go:embed web
|
||||
var webFS embed.FS
|
||||
|
||||
func listen_serve(network, address string) {
|
||||
ln, err := net.Listen(network, address)
|
||||
if err != nil {
|
||||
log.Error().Err(err).Msg("[api] listen")
|
||||
return
|
||||
}
|
||||
|
||||
log.Info().Str("addr", address).Msg("[api] listen")
|
||||
|
||||
server := http.Server{
|
||||
Handler: Handler,
|
||||
ReadTimeout: 5 * time.Second,
|
||||
WriteTimeout: 5 * time.Minute, // long for test sessions
|
||||
}
|
||||
if err = server.Serve(ln); err != nil {
|
||||
log.Fatal().Err(err).Msg("[api] serve")
|
||||
}
|
||||
}
|
||||
|
||||
// HandleFunc registers handler on http.DefaultServeMux with "/" prefix
|
||||
func HandleFunc(pattern string, handler http.HandlerFunc) {
|
||||
if len(pattern) == 0 || pattern[0] != '/' {
|
||||
pattern = "/" + pattern
|
||||
}
|
||||
log.Trace().Str("path", pattern).Msg("[api] register")
|
||||
http.HandleFunc(pattern, handler)
|
||||
}
|
||||
|
||||
// ResponseJSON writes JSON response with Content-Type header
|
||||
func ResponseJSON(w http.ResponseWriter, v any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(v)
|
||||
}
|
||||
|
||||
// Error logs error and writes HTTP error response
|
||||
func Error(w http.ResponseWriter, err error, code int) {
|
||||
log.Error().Err(err).Caller(1).Send()
|
||||
http.Error(w, err.Error(), code)
|
||||
}
|
||||
|
||||
func middlewareCORS(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Access-Control-Allow-Origin", "*")
|
||||
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS")
|
||||
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
||||
if r.Method == "OPTIONS" {
|
||||
return
|
||||
}
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
func middlewareLog(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
log.Trace().Msgf("[api] %s %s %s", r.Method, r.URL, r.RemoteAddr)
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
func apiHandler(w http.ResponseWriter, r *http.Request) {
|
||||
ResponseJSON(w, app.Info)
|
||||
}
|
||||
|
||||
func apiHealth(w http.ResponseWriter, r *http.Request) {
|
||||
ResponseJSON(w, map[string]any{
|
||||
"version": app.Version,
|
||||
"uptime": time.Since(app.StartTime).String(),
|
||||
})
|
||||
}
|
||||
|
||||
func apiLog(w http.ResponseWriter, r *http.Request) {
|
||||
switch r.Method {
|
||||
case "GET":
|
||||
w.Header().Set("Content-Type", "application/jsonlines")
|
||||
app.MemoryLog.WriteTo(w)
|
||||
case "DELETE":
|
||||
app.MemoryLog.Reset()
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
default:
|
||||
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
|
||||
}
|
||||
}
|
||||
@@ -1,141 +0,0 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
|
||||
"github.com/go-playground/validator/v10"
|
||||
"github.com/eduard256/Strix/internal/camera/discovery"
|
||||
"github.com/eduard256/Strix/internal/models"
|
||||
"github.com/eduard256/Strix/internal/utils/logger"
|
||||
"github.com/eduard256/Strix/pkg/sse"
|
||||
)
|
||||
|
||||
// DiscoverHandler handles stream discovery requests
|
||||
type DiscoverHandler struct {
|
||||
scanner *discovery.Scanner
|
||||
sseServer *sse.Server
|
||||
validator *validator.Validate
|
||||
secrets *logger.SecretStore
|
||||
logger interface{ Debug(string, ...any); Error(string, error, ...any); Info(string, ...any) }
|
||||
}
|
||||
|
||||
// NewDiscoverHandler creates a new discover handler
|
||||
func NewDiscoverHandler(
|
||||
scanner *discovery.Scanner,
|
||||
sseServer *sse.Server,
|
||||
secrets *logger.SecretStore,
|
||||
logger interface{ Debug(string, ...any); Error(string, error, ...any); Info(string, ...any) },
|
||||
) *DiscoverHandler {
|
||||
return &DiscoverHandler{
|
||||
scanner: scanner,
|
||||
sseServer: sseServer,
|
||||
secrets: secrets,
|
||||
validator: validator.New(),
|
||||
logger: logger,
|
||||
}
|
||||
}
|
||||
|
||||
// ServeHTTP handles discovery requests
|
||||
func (h *DiscoverHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != http.MethodPost {
|
||||
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
|
||||
// Parse request body
|
||||
var req models.StreamDiscoveryRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
h.logger.Error("failed to decode discovery request", err)
|
||||
h.sendErrorResponse(w, "Invalid request body", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
// Set defaults
|
||||
if req.ModelLimit <= 0 {
|
||||
req.ModelLimit = 6
|
||||
}
|
||||
if req.Timeout <= 0 {
|
||||
req.Timeout = 240 // 4 minutes
|
||||
}
|
||||
if req.MaxStreams <= 0 {
|
||||
req.MaxStreams = 10
|
||||
}
|
||||
|
||||
// Validate request
|
||||
if err := h.validator.Struct(req); err != nil {
|
||||
h.logger.Error("discovery request validation failed", err)
|
||||
h.sendErrorResponse(w, "Validation failed: "+err.Error(), http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
// Register password as a secret so it gets masked in all log output.
|
||||
// The secret is automatically unregistered when the request completes.
|
||||
if req.Password != "" {
|
||||
h.secrets.Add(req.Password)
|
||||
defer h.secrets.Remove(req.Password)
|
||||
}
|
||||
|
||||
h.logger.Info("stream discovery requested",
|
||||
"target", req.Target,
|
||||
"model", req.Model,
|
||||
"timeout", req.Timeout,
|
||||
"max_streams", req.MaxStreams,
|
||||
"remote_addr", r.RemoteAddr,
|
||||
)
|
||||
|
||||
// Check if SSE is supported
|
||||
flusher, ok := w.(http.Flusher)
|
||||
if !ok {
|
||||
h.logger.Info("SSE not supported by client", "remote_addr", r.RemoteAddr)
|
||||
h.sendErrorResponse(w, "SSE not supported", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
// Set SSE headers
|
||||
w.Header().Set("Content-Type", "text/event-stream")
|
||||
w.Header().Set("Cache-Control", "no-cache")
|
||||
w.Header().Set("Connection", "keep-alive")
|
||||
w.Header().Set("Access-Control-Allow-Origin", "*")
|
||||
w.Header().Set("X-Accel-Buffering", "no") // Disable Nginx buffering
|
||||
|
||||
// Flush headers
|
||||
flusher.Flush()
|
||||
|
||||
// Create SSE stream writer
|
||||
streamWriter, err := h.sseServer.NewStreamWriter(w, r)
|
||||
if err != nil {
|
||||
h.logger.Error("failed to create SSE stream", err)
|
||||
return
|
||||
}
|
||||
defer streamWriter.Close()
|
||||
|
||||
// Perform discovery
|
||||
result, err := h.scanner.Scan(r.Context(), req, streamWriter)
|
||||
if err != nil {
|
||||
h.logger.Error("discovery failed", err)
|
||||
_ = streamWriter.SendError(err)
|
||||
return
|
||||
}
|
||||
|
||||
h.logger.Info("discovery completed",
|
||||
"target", req.Target,
|
||||
"tested", result.TotalTested,
|
||||
"found", result.TotalFound,
|
||||
"duration", result.Duration,
|
||||
)
|
||||
}
|
||||
|
||||
// sendErrorResponse sends an error response for non-SSE requests
|
||||
func (h *DiscoverHandler) sendErrorResponse(w http.ResponseWriter, message string, statusCode int) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(statusCode)
|
||||
|
||||
response := map[string]interface{}{
|
||||
"error": true,
|
||||
"message": message,
|
||||
"code": statusCode,
|
||||
}
|
||||
|
||||
_ = json.NewEncoder(w).Encode(response)
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"runtime"
|
||||
"time"
|
||||
)
|
||||
|
||||
// HealthResponse represents health check response
|
||||
type HealthResponse struct {
|
||||
Status string `json:"status"`
|
||||
Version string `json:"version"`
|
||||
Uptime int64 `json:"uptime"` // seconds
|
||||
Timestamp string `json:"timestamp"`
|
||||
System SystemInfo `json:"system"`
|
||||
Services map[string]string `json:"services"`
|
||||
}
|
||||
|
||||
// SystemInfo contains system information
|
||||
type SystemInfo struct {
|
||||
GoVersion string `json:"go_version"`
|
||||
NumGoroutine int `json:"num_goroutines"`
|
||||
NumCPU int `json:"num_cpu"`
|
||||
MemoryMB uint64 `json:"memory_mb"`
|
||||
}
|
||||
|
||||
var startTime = time.Now()
|
||||
|
||||
// HealthHandler handles health check endpoint
|
||||
type HealthHandler struct {
|
||||
version string
|
||||
logger interface{ Info(string, ...any) }
|
||||
}
|
||||
|
||||
// NewHealthHandler creates a new health handler
|
||||
func NewHealthHandler(version string, logger interface{ Info(string, ...any) }) *HealthHandler {
|
||||
return &HealthHandler{
|
||||
version: version,
|
||||
logger: logger,
|
||||
}
|
||||
}
|
||||
|
||||
// ServeHTTP handles health check requests
|
||||
func (h *HealthHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != http.MethodGet && r.Method != http.MethodHead {
|
||||
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
|
||||
h.logger.Info("health check requested", "remote_addr", r.RemoteAddr)
|
||||
|
||||
// Get memory stats
|
||||
var memStats runtime.MemStats
|
||||
runtime.ReadMemStats(&memStats)
|
||||
|
||||
response := HealthResponse{
|
||||
Status: "healthy",
|
||||
Version: h.version,
|
||||
Uptime: int64(time.Since(startTime).Seconds()),
|
||||
Timestamp: time.Now().Format(time.RFC3339),
|
||||
System: SystemInfo{
|
||||
GoVersion: runtime.Version(),
|
||||
NumGoroutine: runtime.NumGoroutine(),
|
||||
NumCPU: runtime.NumCPU(),
|
||||
MemoryMB: memStats.Alloc / 1024 / 1024,
|
||||
},
|
||||
Services: map[string]string{
|
||||
"api": "running",
|
||||
"database": "loaded",
|
||||
"scanner": "ready",
|
||||
"sse": "active",
|
||||
},
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
|
||||
if err := json.NewEncoder(w).Encode(response); err != nil {
|
||||
h.logger.Info("failed to encode health response", "error", err.Error())
|
||||
}
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net"
|
||||
"net/http"
|
||||
|
||||
"github.com/eduard256/Strix/internal/camera/discovery"
|
||||
)
|
||||
|
||||
// ProbeHandler handles device probe requests.
|
||||
// GET /api/v1/probe?ip=192.168.1.50
|
||||
type ProbeHandler struct {
|
||||
probeService *discovery.ProbeService
|
||||
logger interface {
|
||||
Debug(string, ...any)
|
||||
Error(string, error, ...any)
|
||||
Info(string, ...any)
|
||||
}
|
||||
}
|
||||
|
||||
// NewProbeHandler creates a new probe handler.
|
||||
func NewProbeHandler(
|
||||
probeService *discovery.ProbeService,
|
||||
logger interface {
|
||||
Debug(string, ...any)
|
||||
Error(string, error, ...any)
|
||||
Info(string, ...any)
|
||||
},
|
||||
) *ProbeHandler {
|
||||
return &ProbeHandler{
|
||||
probeService: probeService,
|
||||
logger: logger,
|
||||
}
|
||||
}
|
||||
|
||||
// ServeHTTP handles probe requests.
|
||||
func (h *ProbeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != http.MethodGet {
|
||||
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
|
||||
ip := r.URL.Query().Get("ip")
|
||||
if ip == "" {
|
||||
h.sendError(w, "Missing required parameter: ip", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
// Validate IP format
|
||||
if net.ParseIP(ip) == nil {
|
||||
h.sendError(w, "Invalid IP address: "+ip, http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
h.logger.Info("probe requested", "ip", ip, "remote_addr", r.RemoteAddr)
|
||||
|
||||
// Run probe
|
||||
result := h.probeService.Probe(r.Context(), ip)
|
||||
|
||||
// Send response
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
|
||||
if err := json.NewEncoder(w).Encode(result); err != nil {
|
||||
h.logger.Error("failed to encode probe response", err)
|
||||
}
|
||||
}
|
||||
|
||||
// sendError sends a JSON error response.
|
||||
func (h *ProbeHandler) sendError(w http.ResponseWriter, message string, statusCode int) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(statusCode)
|
||||
|
||||
response := map[string]interface{}{
|
||||
"error": true,
|
||||
"message": message,
|
||||
"code": statusCode,
|
||||
}
|
||||
|
||||
_ = json.NewEncoder(w).Encode(response)
|
||||
}
|
||||
@@ -1,99 +0,0 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
|
||||
"github.com/go-playground/validator/v10"
|
||||
"github.com/eduard256/Strix/internal/camera/database"
|
||||
"github.com/eduard256/Strix/internal/models"
|
||||
)
|
||||
|
||||
// SearchHandler handles camera search requests
|
||||
type SearchHandler struct {
|
||||
searchEngine *database.SearchEngine
|
||||
validator *validator.Validate
|
||||
logger interface{ Debug(string, ...any); Error(string, error, ...any); Info(string, ...any) }
|
||||
}
|
||||
|
||||
// NewSearchHandler creates a new search handler
|
||||
func NewSearchHandler(
|
||||
searchEngine *database.SearchEngine,
|
||||
logger interface{ Debug(string, ...any); Error(string, error, ...any); Info(string, ...any) },
|
||||
) *SearchHandler {
|
||||
return &SearchHandler{
|
||||
searchEngine: searchEngine,
|
||||
validator: validator.New(),
|
||||
logger: logger,
|
||||
}
|
||||
}
|
||||
|
||||
// ServeHTTP handles search requests
|
||||
func (h *SearchHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != http.MethodPost {
|
||||
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
|
||||
// Parse request body
|
||||
var req models.CameraSearchRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
h.logger.Error("failed to decode search request", err)
|
||||
h.sendErrorResponse(w, "Invalid request body", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
// Set default limit if not provided
|
||||
if req.Limit <= 0 {
|
||||
req.Limit = 10
|
||||
}
|
||||
|
||||
// Validate request
|
||||
if err := h.validator.Struct(req); err != nil {
|
||||
h.logger.Error("search request validation failed", err)
|
||||
h.sendErrorResponse(w, "Validation failed: "+err.Error(), http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
h.logger.Info("camera search requested",
|
||||
"query", req.Query,
|
||||
"limit", req.Limit,
|
||||
"remote_addr", r.RemoteAddr,
|
||||
)
|
||||
|
||||
// Perform search
|
||||
response, err := h.searchEngine.Search(req.Query, req.Limit)
|
||||
if err != nil {
|
||||
h.logger.Error("search failed", err)
|
||||
h.sendErrorResponse(w, "Search failed", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
// Send response
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
|
||||
if err := json.NewEncoder(w).Encode(response); err != nil {
|
||||
h.logger.Error("failed to encode search response", err)
|
||||
}
|
||||
|
||||
h.logger.Info("search completed",
|
||||
"query", req.Query,
|
||||
"returned", response.Returned,
|
||||
"total", response.Total,
|
||||
)
|
||||
}
|
||||
|
||||
// sendErrorResponse sends an error response
|
||||
func (h *SearchHandler) sendErrorResponse(w http.ResponseWriter, message string, statusCode int) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(statusCode)
|
||||
|
||||
response := map[string]interface{}{
|
||||
"error": true,
|
||||
"message": message,
|
||||
"code": statusCode,
|
||||
}
|
||||
|
||||
_ = json.NewEncoder(w).Encode(response)
|
||||
}
|
||||
@@ -1,168 +0,0 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
"github.com/go-chi/chi/v5/middleware"
|
||||
"github.com/eduard256/Strix/internal/api/handlers"
|
||||
"github.com/eduard256/Strix/internal/camera/database"
|
||||
"github.com/eduard256/Strix/internal/camera/discovery"
|
||||
"github.com/eduard256/Strix/internal/camera/stream"
|
||||
"github.com/eduard256/Strix/internal/config"
|
||||
logutil "github.com/eduard256/Strix/internal/utils/logger"
|
||||
"github.com/eduard256/Strix/pkg/sse"
|
||||
)
|
||||
|
||||
// Server represents the API server
|
||||
type Server struct {
|
||||
router chi.Router
|
||||
config *config.Config
|
||||
loader *database.Loader
|
||||
searchEngine *database.SearchEngine
|
||||
scanner *discovery.Scanner
|
||||
probeService *discovery.ProbeService
|
||||
sseServer *sse.Server
|
||||
secrets *logutil.SecretStore
|
||||
logger interface{ Debug(string, ...any); Error(string, error, ...any); Info(string, ...any) }
|
||||
}
|
||||
|
||||
// NewServer creates a new API server
|
||||
func NewServer(
|
||||
cfg *config.Config,
|
||||
secrets *logutil.SecretStore,
|
||||
logger interface{ Debug(string, ...any); Error(string, error, ...any); Info(string, ...any) },
|
||||
) (*Server, error) {
|
||||
// Initialize database loader
|
||||
loader := database.NewLoader(
|
||||
cfg.Database.BrandsPath,
|
||||
cfg.Database.PatternsPath,
|
||||
cfg.Database.ParametersPath,
|
||||
logger,
|
||||
)
|
||||
|
||||
// Load query parameters for URL builder
|
||||
queryParams, err := loader.LoadQueryParameters()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Initialize search engine
|
||||
searchEngine := database.NewSearchEngine(loader, logger)
|
||||
|
||||
// Initialize stream components
|
||||
builder := stream.NewBuilder(queryParams, logger)
|
||||
tester := stream.NewTester(cfg.Scanner.FFProbeTimeout, logger)
|
||||
|
||||
// Initialize ONVIF discovery
|
||||
onvif := discovery.NewONVIFDiscovery(logger)
|
||||
|
||||
// Initialize scanner
|
||||
scannerConfig := discovery.ScannerConfig{
|
||||
WorkerPoolSize: cfg.Scanner.WorkerPoolSize,
|
||||
DefaultTimeout: cfg.Scanner.DefaultTimeout,
|
||||
MaxStreams: cfg.Scanner.MaxStreams,
|
||||
ModelSearchLimit: cfg.Scanner.ModelSearchLimit,
|
||||
FFProbeTimeout: cfg.Scanner.FFProbeTimeout,
|
||||
}
|
||||
|
||||
scanner := discovery.NewScanner(
|
||||
loader,
|
||||
searchEngine,
|
||||
builder,
|
||||
tester,
|
||||
onvif,
|
||||
scannerConfig,
|
||||
logger,
|
||||
)
|
||||
|
||||
// Initialize SSE server
|
||||
sseServer := sse.NewServer(logger)
|
||||
|
||||
// Initialize OUI database for vendor identification
|
||||
ouiDB := discovery.NewOUIDatabase()
|
||||
if err := ouiDB.LoadFromFile(cfg.Database.OUIPath); err != nil {
|
||||
logger.Error("failed to load OUI database, vendor lookup will be unavailable", err)
|
||||
} else {
|
||||
logger.Info("OUI database loaded", "entries", ouiDB.Size())
|
||||
}
|
||||
|
||||
// Initialize ProbeService with all probers
|
||||
probers := []discovery.Prober{
|
||||
&discovery.DNSProber{},
|
||||
discovery.NewARPProber(ouiDB),
|
||||
&discovery.MDNSProber{},
|
||||
&discovery.HTTPProber{},
|
||||
}
|
||||
probeService := discovery.NewProbeService(probers, logger)
|
||||
|
||||
// Create server
|
||||
server := &Server{
|
||||
router: chi.NewRouter(),
|
||||
config: cfg,
|
||||
loader: loader,
|
||||
searchEngine: searchEngine,
|
||||
scanner: scanner,
|
||||
probeService: probeService,
|
||||
sseServer: sseServer,
|
||||
secrets: secrets,
|
||||
logger: logger,
|
||||
}
|
||||
|
||||
// Setup routes
|
||||
server.setupRoutes()
|
||||
|
||||
return server, nil
|
||||
}
|
||||
|
||||
// setupRoutes configures all routes and middleware
|
||||
func (s *Server) setupRoutes() {
|
||||
// Global middleware
|
||||
s.router.Use(middleware.RequestID)
|
||||
s.router.Use(middleware.RealIP)
|
||||
s.router.Use(middleware.Logger)
|
||||
s.router.Use(middleware.Recoverer)
|
||||
// Note: No global timeout middleware - endpoints use context-based timeouts from request parameters
|
||||
|
||||
// CORS middleware
|
||||
s.router.Use(func(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Access-Control-Allow-Origin", "*")
|
||||
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
|
||||
w.Header().Set("Access-Control-Allow-Headers", "Accept, Authorization, Content-Type, X-Request-ID")
|
||||
w.Header().Set("Access-Control-Max-Age", "3600")
|
||||
|
||||
if r.Method == "OPTIONS" {
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
return
|
||||
}
|
||||
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
})
|
||||
|
||||
// API routes (mounted at /api/v1 in main.go)
|
||||
// Health check (GET + HEAD for Docker/CasaOS healthcheck compatibility)
|
||||
healthHandler := handlers.NewHealthHandler(s.config.Version, s.logger).ServeHTTP
|
||||
s.router.Get("/health", healthHandler)
|
||||
s.router.Head("/health", healthHandler)
|
||||
|
||||
// Camera search
|
||||
s.router.Post("/cameras/search", handlers.NewSearchHandler(s.searchEngine, s.logger).ServeHTTP)
|
||||
|
||||
// Stream discovery (SSE)
|
||||
s.router.Post("/streams/discover", handlers.NewDiscoverHandler(s.scanner, s.sseServer, s.secrets, s.logger).ServeHTTP)
|
||||
|
||||
// Device probe (ping + DNS + ARP/OUI + mDNS)
|
||||
s.router.Get("/probe", handlers.NewProbeHandler(s.probeService, s.logger).ServeHTTP)
|
||||
}
|
||||
|
||||
// ServeHTTP implements http.Handler
|
||||
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
s.router.ServeHTTP(w, r)
|
||||
}
|
||||
|
||||
// GetRouter returns the chi router
|
||||
func (s *Server) GetRouter() chi.Router {
|
||||
return s.router
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>Strix</title>
|
||||
<style>
|
||||
* { margin: 0; padding: 0; box-sizing: border-box; }
|
||||
body { font-family: monospace; background: #1a1a1a; color: #e0e0e0; display: flex; align-items: center; justify-content: center; height: 100vh; }
|
||||
h1 { font-size: 24px; color: #888; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<h1>Strix 2.0</h1>
|
||||
</body>
|
||||
</html>
|
||||
Reference in New Issue
Block a user