lingniu-vehicle-ingest/go/vehicle-gateway/cmd/gateway/main.go

package main

import (
	"context"
	"database/sql"
	"log/slog"
	"os"
	"os/signal"
	"strings"
	"sync"
	"syscall"
	"time"

	_ "github.com/go-sql-driver/mysql"

	"lingniu-vehicle-ingest/go/vehicle-gateway/internal/envelope"
	"lingniu-vehicle-ingest/go/vehicle-gateway/internal/eventbus"
	"lingniu-vehicle-ingest/go/vehicle-gateway/internal/gateway"
	"lingniu-vehicle-ingest/go/vehicle-gateway/internal/identity"
	"lingniu-vehicle-ingest/go/vehicle-gateway/internal/observability"
	"lingniu-vehicle-ingest/go/vehicle-gateway/internal/protocol/gb32960"
	"lingniu-vehicle-ingest/go/vehicle-gateway/internal/protocol/jt808"
)

func main() {
	logger := observability.NewLogger("vehicle-gateway")
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()

	sink, err := buildSink(logger)
	if err != nil {
		logger.Error("build sink failed", "error", err)
		os.Exit(1)
	}
	defer sink.Close()
	resolver, closeResolver, err := buildIdentityResolver(ctx, logger)
	if err != nil {
		logger.Error("build identity resolver failed", "error", err)
		os.Exit(1)
	}
	defer closeResolver()

	protocols := []gateway.TCPProtocol{
		{
			Protocol: envelope.ProtocolGB32960,
			Addr:     env("GB32960_TCP_ADDR", ":32960"),
			Extract:  gb32960.ExtractFrames,
			Parse:    gb32960.ParseFrame,
		},
		{
			Protocol: envelope.ProtocolJT808,
			Addr:     env("JT808_TCP_ADDR", ":808"),
			Extract:  jt808.ExtractFrames,
			Parse:    jt808.ParseFrame,
		},
	}

	var wg sync.WaitGroup
	errs := make(chan error, len(protocols))
	for _, protocol := range protocols {
		server, err := gateway.NewTCPServer(gateway.TCPServerConfig{
			Protocol:       protocol,
			Sink:           sink,
			Resolver:       resolver,
			Logger:         logger,
			ReadBufferSize: envInt("TCP_READ_BUFFER_BYTES", 64*1024),
			IdleTimeout:    time.Duration(envInt("TCP_IDLE_TIMEOUT_SECONDS", 180)) * time.Second,
			MaxConnections: envInt("TCP_MAX_CONNECTIONS", 20_000),
		})
		if err != nil {
			logger.Error("build tcp server failed", "protocol", protocol.Protocol, "error", err)
			os.Exit(1)
		}
		wg.Add(1)
		go func() {
			defer wg.Done()
			if err := server.ListenAndServe(ctx); err != nil {
				errs <- err
			}
		}()
	}
	if envBool("YUTONG_MQTT_ENABLED", false) {
		client, err := gateway.NewMQTTClient(gateway.MQTTClientConfig{
			EndpointName: env("YUTONG_MQTT_ENDPOINT", "yutong"),
			Broker:       env("YUTONG_MQTT_URI", ""),
			ClientID:     env("YUTONG_MQTT_CLIENT_ID", "lingniu-go-yutong-mqtt"),
			Username:     env("YUTONG_MQTT_USERNAME", ""),
			Password:     env("YUTONG_MQTT_PASSWORD", ""),
			Topics:       splitCSV(env("YUTONG_MQTT_TOPICS", env("YUTONG_MQTT_TOPIC", "/ytforward/shln/+"))),
			QoS:          byte(envInt("YUTONG_MQTT_QOS", 2)),
			Sink:         sink,
			Resolver:     resolver,
			Logger:       logger,
		})
		if err != nil {
			logger.Error("build yutong mqtt client failed", "error", err)
			os.Exit(1)
		}
		if err := client.Start(ctx); err != nil {
			logger.Error("start yutong mqtt client failed", "error", err)
			os.Exit(1)
		}
		logger.Info("yutong mqtt client started")
	}

	logger.Info("vehicle gateway started")
	select {
	case <-ctx.Done():
	case err := <-errs:
		logger.Error("vehicle gateway listener failed", "error", err)
		stop()
	}
	wg.Wait()
}

func buildIdentityResolver(ctx context.Context, logger *slog.Logger) (identity.Resolver, func(), error) {
	dsn := env("IDENTITY_MYSQL_DSN", strings.TrimSpace(os.Getenv("MYSQL_DSN")))
	if strings.TrimSpace(dsn) == "" {
		logger.Warn("identity mysql dsn is empty; using noop identity resolver")
		return identity.NoopResolver{}, func() {}, nil
	}
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		return nil, nil, err
	}
	if err := db.PingContext(ctx); err != nil {
		_ = db.Close()
		return nil, nil, err
	}
	table := env("VEHICLE_IDENTITY_TABLE", "vehicle_identity_binding")
	logger.Info("identity mysql resolver enabled", "table", table)
	return identity.NewMySQLResolver(db, table), func() { _ = db.Close() }, nil
}

func buildSink(logger *slog.Logger) (eventbus.Sink, error) {
	brokers := splitCSV(os.Getenv("KAFKA_BROKERS"))
	if len(brokers) == 0 {
		logger.Warn("KAFKA_BROKERS is empty; using log sink")
		return eventbus.NewLogSink(logger), nil
	}
	sink, err := eventbus.NewKafkaSink(eventbus.KafkaConfig{
		Brokers: brokers,
		RawTopics: map[envelope.Protocol]string{
			envelope.ProtocolGB32960:    env("KAFKA_TOPIC_GB32960_RAW", "vehicle.raw.gb32960.v1"),
			envelope.ProtocolJT808:      env("KAFKA_TOPIC_JT808_RAW", "vehicle.raw.jt808.v1"),
			envelope.ProtocolYutongMQTT: env("KAFKA_TOPIC_YUTONG_MQTT_RAW", "vehicle.raw.yutong-mqtt.v1"),
		},
		UnifiedTopic: env("KAFKA_TOPIC_UNIFIED", "vehicle.event.unified.v1"),
	})
	if err != nil {
		return nil, err
	}
	return eventbus.NewRetryingSink(sink, eventbus.RetryConfig{
		Attempts:       envInt("KAFKA_PUBLISH_ATTEMPTS", 3),
		Backoff:        time.Duration(envInt("KAFKA_PUBLISH_BACKOFF_MS", 100)) * time.Millisecond,
		AttemptTimeout: time.Duration(envInt("KAFKA_PUBLISH_TIMEOUT_MS", 3000)) * time.Millisecond,
	}), nil
}

func env(key string, fallback string) string {
	value := strings.TrimSpace(os.Getenv(key))
	if value == "" {
		return fallback
	}
	return value
}

func envInt(key string, fallback int) int {
	value := strings.TrimSpace(os.Getenv(key))
	if value == "" {
		return fallback
	}
	var out int
	for _, r := range value {
		if r < '0' || r > '9' {
			return fallback
		}
		out = out*10 + int(r-'0')
	}
	if out <= 0 {
		return fallback
	}
	return out
}

func envBool(key string, fallback bool) bool {
	value := strings.ToLower(strings.TrimSpace(os.Getenv(key)))
	if value == "" {
		return fallback
	}
	return value == "1" || value == "true" || value == "yes" || value == "on"
}

func splitCSV(value string) []string {
	var out []string
	for _, item := range strings.Split(value, ",") {
		item = strings.TrimSpace(item)
		if item != "" {
			out = append(out, item)
		}
	}
	return out
}