first commit

statusServer.go

@@ -0,0 +1,164 @@
+package statusServer
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"runtime"
+	"statusServer/utils"
+	"strings"
+	"time"
+
+	"statusServer/models"
+
+	logging "gitea.tecamino.com/paadi/tecamino-logger/logging"
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+)
+
+// StatusServer wraps an HTTP server with PubSub over websockets.
+// It manages HTTP routes, PubSub broadcasting, and runtime metrics publishing.
+type StatusServer struct {
+	Ip     string           // listen address (defaults to all interfaces)
+	Port   int              // server port
+	Routes *gin.Engine      // Gin router for HTTP endpoints
+	pubSub *StatusWebsocket // websocket-enabled PubSub system
+	log    *logging.Logger  // application logger
+}
+
+// NewStatusServer initializes and configures a new StatusServer instance.
+//
+// Setup steps:
+//   - Apply default values to the config.
+//   - Initialize logging.
+//   - Configure CORS middleware (including localhost + detected local IP).
+//   - Create PubSubWebsocket with worker/message limits.
+//   - Register the /status websocket endpoint.
+//
+// Returns the server instance or an error if initialization fails.
+func NewStatusServer(config models.Config) (*StatusServer, error) {
+	config.Default()
+
+	// initialize logger
+	logger, err := logging.NewLogger("statusServer.log", &config.Log)
+	if err != nil {
+		return nil, err
+	}
+
+	logger.Debug("NewStatusServer", "initialize new server with allowOrigins: "+
+		strings.Join(config.AllowOrigins, ", ")+" listening on port: "+fmt.Sprint(config.Port))
+
+	r := gin.Default()
+
+	// always allow local dev origins (http://localhost:PORT)
+	config.AllowOrigins = append(config.AllowOrigins, fmt.Sprintf("http://localhost:%d", config.Port))
+
+	// detect and allow local IP in CORS origins
+	localIP, err := utils.GetLocalIP()
+	if err != nil {
+		logger.Error("NewStatusServer", "get local ip: "+err.Error())
+	} else {
+		config.AllowOrigins = append(config.AllowOrigins, fmt.Sprintf("http://%s:%d", localIP, config.Port))
+	}
+
+	// configure CORS middleware
+	r.Use(cors.New(cors.Config{
+		AllowOrigins:     config.AllowOrigins,
+		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
+		AllowHeaders:     []string{"Origin", "Content-Type", "Accept"},
+		ExposeHeaders:    []string{"Content-Length"},
+		AllowCredentials: true,
+		MaxAge:           12 * time.Hour,
+	}))
+
+	// build the server
+	s := &StatusServer{
+		Ip:     "0.0.0.0", // listen on all interfaces
+		Port:   config.Port,
+		Routes: r,
+		log:    logger,
+	}
+
+	// initialize PubSub websocket service
+	logger.Debug("NewStatusServer", fmt.Sprintf(
+		"initialize new PubSubWebsocket service with %d workers %d messages",
+		config.PubSub.Workers, config.PubSub.MaxMessages,
+	))
+	s.pubSub, err = NewStatusWebsocket(config.PubSub.Workers, config.PubSub.MaxMessages, logger)
+	if err != nil {
+		logger.Error("NewPubSubWebsocket", err.Error())
+	}
+
+	// register websocket endpoint
+	r.GET("/status", s.pubSub.NewConection)
+	r.GET("/info", s.pubSub.NewConection)
+
+	return s, nil
+}
+
+// ServeHttp starts the HTTP server and continuously publishes runtime metrics
+// (memory allocation + GC count) to the "info" topic.
+//
+// It blocks until the HTTP server stops. Resources are cleaned up on shutdown:
+// PubSub is closed and a shutdown message is logged.
+func (s *StatusServer) ServeHttp() error {
+	s.log.Debug("ServeHttp", "start publishing runtime metrics (memory + GC count)")
+
+	// create cancellable context for metrics goroutine
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// metrics publisher goroutine
+	go func() {
+		for {
+			var init bool
+			var m runtime.MemStats
+			var oldM uint64
+			var oldGc uint32
+			var info struct {
+				Memory uint64 `json:"memory"`
+				GC     uint32 `json:"gc"`
+			}
+
+			ticker := time.NewTicker(500 * time.Millisecond)
+			defer ticker.Stop()
+
+			for {
+				select {
+				case <-ctx.Done():
+					// stop publishing if context is canceled
+					return
+				case <-ticker.C:
+					// read runtime memory statistics
+					runtime.ReadMemStats(&m)
+					info.GC = m.NumGC
+
+					// publish only when values changed or first run
+					if oldGc != m.NumGC || oldM != m.Alloc/1024 || !init {
+						info.Memory = m.Alloc / 1024
+						s.pubSub.Publish("info", info)
+						oldGc = m.NumGC
+						oldM = m.Alloc / 1024
+						init = true
+					}
+				}
+			}
+		}
+	}()
+
+	// log startup
+	s.log.Info("ServeHttp", fmt.Sprintf("start listening on %s:%d", s.Ip, s.Port))
+
+	// configure HTTP server
+	srv := &http.Server{
+		Addr:    fmt.Sprintf("%s:%d", s.Ip, s.Port),
+		Handler: s.Routes,
+	}
+
+	// log shutdown + close PubSub on exit
+	defer s.log.Info("ServeHttp", fmt.Sprintf("close server listening on %s:%d", s.Ip, s.Port))
+	defer s.pubSub.Close()
+
+	// blocking call
+	return srv.ListenAndServe()
+}