first commit

statusClient.go

@@ -0,0 +1,150 @@
+package statusServer
+
+import (
+	"encoding/json"
+	"fmt"
+	"statusServer/models"
+
+	pubSubModels "gitea.tecamino.com/paadi/pubSub/models"
+	logging "gitea.tecamino.com/paadi/tecamino-logger/logging"
+)
+
+// StatusServerClient wraps a websocket client connection to the StatusServer.
+// - `id` is the client identifier (service name)
+// - `client` is the underlying websocket client
+// - `subs` is a map of topic → callback function, used when subscribed messages are received
+type StatusClient struct {
+	id     string
+	client *models.Client
+	subs   map[string]func(data any)
+}
+
+// NewCStatuslient connects to a StatusServer websocket endpoint and sets up callbacks.
+// serviceName: unique ID/name for this client
+// ip, port: target server address
+// debug: enable debug logging
+func NewStatusClient(serviceName, ip string, port uint, debug bool) (*StatusClient, error) {
+	config := models.Config{Log: logging.Config{Debug: debug}}
+	config.Default()
+
+	// create logger for this client
+	logger, err := logging.NewLogger("statusServer.log", &config.Log)
+	if err != nil {
+		return nil, err
+	}
+
+	logger.Debug("NewClient", fmt.Sprintf("initialize new client id:%s to %s:%d", serviceName, ip, port))
+
+	// build client wrapper
+	sc := StatusClient{
+		id:   serviceName,
+		subs: map[string]func(data any){}, // no subscriptions yet
+	}
+
+	// connect underlying websocket client
+	sc.client, err = models.NewClient(ip, serviceName, port, logger)
+	if err != nil {
+		return nil, err
+	}
+
+	// --- EVENT HANDLERS ---
+
+	// connection opened
+	sc.client.OnOpen = func() {
+		logger.Info("Client", fmt.Sprintf("id:%s connected to %s:%d", serviceName, ip, port))
+	}
+
+	// message received from server
+	sc.client.OnMessage = func(data []byte) {
+		var p pubSubModels.Data
+		err := json.Unmarshal(data, &p)
+		if err != nil {
+			logger.Error("OnMessage", err.Error())
+			return
+		}
+
+		// if we have a subscription callback for this topic, call it
+		if f, ok := sc.subs[p.Topic]; ok {
+			f(p.Data)
+		}
+	}
+
+	// warning received
+	sc.client.OnWarning = func(warn string) {
+		logger.Warning("Client", warn)
+	}
+
+	// error received
+	sc.client.OnError = func(err error) {
+		logger.Error("Client", err.Error())
+	}
+
+	// connection closed
+	sc.client.OnClose = func(code int, reason string) {
+		logger.Info("Client", fmt.Sprintf("id:%s closed connection to %s:%d", serviceName, ip, port))
+	}
+
+	return &sc, err
+}
+
+// Subscribe sends a "subscribe" action for a topic to the server and registers
+// a local callback to handle messages for that topic.
+func (sc *StatusClient) Subscribe(topic string, cb func(any)) error {
+	var data pubSubModels.Data
+	data.Action = "subscribe"
+	data.Topic = topic
+
+	// send subscribe request to server
+	b, err := json.Marshal(data)
+	if err != nil {
+		return err
+	}
+	sc.client.SendData(b)
+
+	// register callback for topic
+	sc.subs[topic] = cb
+	return nil
+}
+
+// Publish sends a "publish" action with a payload to the server.
+// The server will then deliver this message to all subscribers of the topic.
+func (sc *StatusClient) Publish(topic string, data any) error {
+	var payload pubSubModels.Data
+	payload.Action = "publish"
+	payload.Topic = topic
+	payload.Data = data
+
+	b, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+	sc.client.SendData(b)
+	return nil
+}
+
+// --- Sending helpers (proxy to server messaging system) ---
+
+// SendInfo sends an "info" message to the server.
+func (sc *StatusClient) SendInfo(data any) error {
+	return sc.client.SendInfo(data)
+}
+
+// SendInfo sends an "status" message to the server.
+func (sc *StatusClient) SendStatus(data any) error {
+	return sc.client.SendStatus(data)
+}
+
+// SendDebug sends a "debug" message to the server.
+func (sc *StatusClient) SendDebug(data any) error {
+	return sc.client.SendDebug(data)
+}
+
+// SendWarning sends a "warning" message to the server.
+func (sc *StatusClient) SendWarning(data any) error {
+	return sc.client.SendWarning(data)
+}
+
+// SendError sends an "error" message to the server.
+func (sc *StatusClient) SendError(data any) error {
+	return sc.client.SendError(data)
+}