Add realtime gateway and simulator bridge

realtime-gateway/cmd/mock-producer/main.go

@@ -0,0 +1,190 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"log"
+	"os"
+	"os/signal"
+	"strconv"
+	"syscall"
+	"time"
+
+	"github.com/coder/websocket"
+	"github.com/coder/websocket/wsjson"
+
+	"realtime-gateway/internal/model"
+)
+
+func main() {
+	url := flag.String("url", "ws://127.0.0.1:8080/ws", "gateway websocket url")
+	token := flag.String("token", "dev-producer-token", "producer token")
+	channelID := flag.String("channel-id", "", "channel id to join before publish")
+	deviceID := flag.String("device-id", "child-001", "target device id")
+	groupID := flag.String("group-id", "", "target group id")
+	sourceID := flag.String("source-id", "mock-producer-001", "source id")
+	mode := flag.String("mode", "mock", "source mode")
+	topic := flag.String("topic", "telemetry.location", "publish topic")
+	lat := flag.Float64("lat", 31.2304, "start latitude")
+	lng := flag.Float64("lng", 121.4737, "start longitude")
+	speed := flag.Float64("speed", 1.2, "speed value")
+	accuracy := flag.Float64("accuracy", 6, "accuracy value")
+	bpm := flag.Int("bpm", 120, "heart rate value when topic is telemetry.heart_rate")
+	confidence := flag.Float64("confidence", 0, "heart rate confidence when topic is telemetry.heart_rate")
+	interval := flag.Duration("interval", time.Second, "publish interval")
+	count := flag.Int("count", 0, "number of messages to send, 0 means unlimited")
+	flag.Parse()
+
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	conn, _, err := websocket.Dial(ctx, *url, nil)
+	if err != nil {
+		log.Fatalf("dial gateway: %v", err)
+	}
+	defer conn.Close(websocket.StatusNormalClosure, "producer closed")
+
+	var welcome model.ServerMessage
+	if err := wsjson.Read(ctx, conn, &welcome); err != nil {
+		log.Fatalf("read welcome: %v", err)
+	}
+	log.Printf("connected: session=%s", welcome.SessionID)
+
+	authReq := model.ClientMessage{
+		Type:  "authenticate",
+		Role:  model.RoleProducer,
+		Token: *token,
+	}
+	if *channelID != "" {
+		authReq.Type = "join_channel"
+		authReq.ChannelID = *channelID
+	}
+	if err := wsjson.Write(ctx, conn, authReq); err != nil {
+		log.Fatalf("send authenticate: %v", err)
+	}
+
+	var authResp model.ServerMessage
+	if err := wsjson.Read(ctx, conn, &authResp); err != nil {
+		log.Fatalf("read authenticate response: %v", err)
+	}
+	if authResp.Type == "error" {
+		log.Fatalf("authenticate failed: %s", authResp.Error)
+	}
+	log.Printf("authenticated: session=%s", authResp.SessionID)
+
+	ticker := time.NewTicker(*interval)
+	defer ticker.Stop()
+
+	sent := 0
+	for {
+		select {
+		case <-ctx.Done():
+			log.Println("producer stopping")
+			return
+		case <-ticker.C:
+			envelope := model.Envelope{
+				SchemaVersion: 1,
+				MessageID:     messageID(sent + 1),
+				Timestamp:     time.Now().UnixMilli(),
+				Topic:         *topic,
+				Source: model.Source{
+					Kind: model.RoleProducer,
+					ID:   *sourceID,
+					Mode: *mode,
+				},
+				Target: model.Target{
+					DeviceID: *deviceID,
+					GroupID:  *groupID,
+				},
+				Payload: payloadForTopic(*topic, *lat, *lng, *speed, *accuracy, *bpm, *confidence, sent),
+			}
+
+			req := model.ClientMessage{
+				Type:     "publish",
+				Envelope: &envelope,
+			}
+			if err := wsjson.Write(ctx, conn, req); err != nil {
+				log.Fatalf("publish failed: %v", err)
+			}
+
+			var resp model.ServerMessage
+			if err := wsjson.Read(ctx, conn, &resp); err != nil {
+				log.Fatalf("read publish response: %v", err)
+			}
+			if resp.Type == "error" {
+				log.Fatalf("publish rejected: %s", resp.Error)
+			}
+
+			sent++
+			log.Printf("published #%d %s", sent, describePublished(*topic, *deviceID, *lat, *lng, *speed, *accuracy, *bpm, *confidence, sent))
+			if *count > 0 && sent >= *count {
+				log.Println("producer completed")
+				return
+			}
+		}
+	}
+}
+
+func payloadForTopic(topic string, baseLat, baseLng, speed, accuracy float64, bpm int, confidence float64, step int) []byte {
+	if topic == "telemetry.heart_rate" {
+		return heartRatePayload(bpm, confidence)
+	}
+	return locationPayload(baseLat, baseLng, speed, accuracy, step)
+}
+
+func locationPayload(baseLat, baseLng, speed, accuracy float64, step int) []byte {
+	lat := currentLat(baseLat, step)
+	lng := currentLng(baseLng, step)
+	return []byte(
+		`{"lat":` + formatFloat(lat) +
+			`,"lng":` + formatFloat(lng) +
+			`,"speed":` + formatFloat(speed) +
+			`,"bearing":90` +
+			`,"accuracy":` + formatFloat(accuracy) +
+			`,"coordSystem":"GCJ02"}`,
+	)
+}
+
+func heartRatePayload(bpm int, confidence float64) []byte {
+	if confidence > 0 {
+		return []byte(
+			`{"bpm":` + strconv.Itoa(maxInt(1, bpm)) +
+				`,"confidence":` + formatFloat(confidence) +
+				`}`,
+		)
+	}
+	return []byte(`{"bpm":` + strconv.Itoa(maxInt(1, bpm)) + `}`)
+}
+
+func currentLat(base float64, step int) float64 {
+	return base + float64(step)*0.00002
+}
+
+func currentLng(base float64, step int) float64 {
+	return base + float64(step)*0.00003
+}
+
+func messageID(step int) string {
+	return "msg-" + strconv.Itoa(step)
+}
+
+func formatFloat(v float64) string {
+	return strconv.FormatFloat(v, 'f', 6, 64)
+}
+
+func describePublished(topic string, deviceID string, lat, lng, speed, accuracy float64, bpm int, confidence float64, step int) string {
+	if topic == "telemetry.heart_rate" {
+		if confidence > 0 {
+			return "device=" + deviceID + " topic=" + topic + " bpm=" + strconv.Itoa(maxInt(1, bpm)) + " confidence=" + formatFloat(confidence)
+		}
+		return "device=" + deviceID + " topic=" + topic + " bpm=" + strconv.Itoa(maxInt(1, bpm))
+	}
+	return "device=" + deviceID + " topic=" + topic + " lat=" + formatFloat(currentLat(lat, step)) + " lng=" + formatFloat(currentLng(lng, step)) + " speed=" + formatFloat(speed) + " accuracy=" + formatFloat(accuracy)
+}
+
+func maxInt(left int, right int) int {
+	if left > right {
+		return left
+	}
+	return right
+}