131 lines
3.4 KiB
Go
131 lines
3.4 KiB
Go
// Package bridge provides a local HTTP server on MONITOR_PORT for
|
|
// communication between the HarborForge OpenClaw plugin and Monitor.
|
|
//
|
|
// The plugin queries this endpoint to enrich its telemetry with
|
|
// host/hardware data. The bridge is optional: if monitorPort is 0
|
|
// or not set, the bridge is not started and Monitor operates normally.
|
|
package bridge
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"sync"
|
|
"time"
|
|
|
|
"git.hangman-lab.top/zhi/HarborForge.Monitor/internal/config"
|
|
"git.hangman-lab.top/zhi/HarborForge.Monitor/internal/telemetry"
|
|
)
|
|
|
|
// Server is the local bridge HTTP server.
|
|
type Server struct {
|
|
cfg config.Config
|
|
logger *log.Logger
|
|
srv *http.Server
|
|
|
|
mu sync.RWMutex
|
|
lastPayload *telemetry.Payload
|
|
lastUpdated time.Time
|
|
}
|
|
|
|
// New creates a bridge server. It does not start listening.
|
|
func New(cfg config.Config, logger *log.Logger) *Server {
|
|
return &Server{
|
|
cfg: cfg,
|
|
logger: logger,
|
|
}
|
|
}
|
|
|
|
// UpdatePayload stores the latest telemetry payload so the bridge can
|
|
// serve it to plugin queries without re-collecting.
|
|
func (s *Server) UpdatePayload(p telemetry.Payload) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.lastPayload = &p
|
|
s.lastUpdated = time.Now()
|
|
}
|
|
|
|
// bridgeResponse is the JSON structure served to the plugin.
|
|
type bridgeResponse struct {
|
|
Status string `json:"status"`
|
|
MonitorVer string `json:"monitor_version"`
|
|
Identifier string `json:"identifier"`
|
|
Telemetry *telemetry.Payload `json:"telemetry,omitempty"`
|
|
LastUpdated *time.Time `json:"last_updated,omitempty"`
|
|
}
|
|
|
|
func (s *Server) handler() http.Handler {
|
|
mux := http.NewServeMux()
|
|
|
|
// Health / discovery endpoint
|
|
mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(map[string]string{
|
|
"status": "ok",
|
|
"monitor_version": telemetry.Version,
|
|
"identifier": s.cfg.Identifier,
|
|
})
|
|
})
|
|
|
|
// Telemetry endpoint — returns the latest cached payload
|
|
mux.HandleFunc("/telemetry", func(w http.ResponseWriter, r *http.Request) {
|
|
s.mu.RLock()
|
|
payload := s.lastPayload
|
|
updated := s.lastUpdated
|
|
s.mu.RUnlock()
|
|
|
|
resp := bridgeResponse{
|
|
Status: "ok",
|
|
MonitorVer: telemetry.Version,
|
|
Identifier: s.cfg.Identifier,
|
|
}
|
|
if payload != nil {
|
|
resp.Telemetry = payload
|
|
resp.LastUpdated = &updated
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(resp)
|
|
})
|
|
|
|
return mux
|
|
}
|
|
|
|
// Start begins listening on 127.0.0.1:<monitorPort>. It blocks until
|
|
// the context is cancelled or an error occurs.
|
|
func (s *Server) Start(ctx context.Context) error {
|
|
if s.cfg.MonitorPort <= 0 {
|
|
return nil // bridge disabled
|
|
}
|
|
|
|
addr := fmt.Sprintf("127.0.0.1:%d", s.cfg.MonitorPort)
|
|
listener, err := net.Listen("tcp", addr)
|
|
if err != nil {
|
|
return fmt.Errorf("bridge listen on %s: %w", addr, err)
|
|
}
|
|
|
|
s.srv = &http.Server{
|
|
Handler: s.handler(),
|
|
ReadTimeout: 5 * time.Second,
|
|
WriteTimeout: 5 * time.Second,
|
|
IdleTimeout: 30 * time.Second,
|
|
}
|
|
|
|
s.logger.Printf("bridge listening on %s", addr)
|
|
|
|
go func() {
|
|
<-ctx.Done()
|
|
shutCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
s.srv.Shutdown(shutCtx)
|
|
}()
|
|
|
|
if err := s.srv.Serve(listener); err != nil && err != http.ErrServerClosed {
|
|
return fmt.Errorf("bridge serve: %w", err)
|
|
}
|
|
return nil
|
|
}
|