fix(go): decouple frame publishing from shutdown context

go/vehicle-gateway/internal/gateway/tcp_server_test.go

@@ -105,6 +105,85 @@ func TestTCPServerWritesProtocolResponseAfterPublish(t *testing.T) {
 	<-done
 }
 
+func TestTCPServerUsesUncancelledFrameContextForAlreadyReadFrame(t *testing.T) {
+	parent, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	resolver := &contextCheckingResolver{}
+	sink := &contextCheckingSink{}
+	server, err := NewTCPServer(TCPServerConfig{
+		Protocol: TCPProtocol{
+			Protocol: envelope.ProtocolJT808,
+			Addr:     ":0",
+			Extract:  jt808.ExtractFrames,
+			Parse: func(_ []byte, receivedAtMS int64, sourceEndpoint string) (envelope.FrameEnvelope, error) {
+				return envelope.FrameEnvelope{
+					Protocol:       envelope.ProtocolJT808,
+					MessageID:      "0x0200",
+					Phone:          "13307795425",
+					SourceEndpoint: sourceEndpoint,
+					ReceivedAtMS:   receivedAtMS,
+					EventTimeMS:    receivedAtMS,
+					ParseStatus:    envelope.ParseOK,
+				}, nil
+			},
+		},
+		Sink:     sink,
+		Resolver: resolver,
+		Logger:   slog.New(slog.NewTextHandler(testWriter{t: t}, nil)),
+	})
+	if err != nil {
+		t.Fatalf("NewTCPServer() error = %v", err)
+	}
+
+	server.handleFrame(parent, nil, []byte{0x01}, "127.0.0.1:808")
+
+	if resolver.ctxErr != nil {
+		t.Fatalf("resolver saw cancelled context: %v", resolver.ctxErr)
+	}
+	if sink.rawCtxErr != nil {
+		t.Fatalf("raw publish saw cancelled context: %v", sink.rawCtxErr)
+	}
+	if sink.unifiedCtxErr != nil {
+		t.Fatalf("unified publish saw cancelled context: %v", sink.unifiedCtxErr)
+	}
+	if sink.rawCount != 1 || sink.unifiedCount != 1 {
+		t.Fatalf("raw=%d unified=%d", sink.rawCount, sink.unifiedCount)
+	}
+}
+
+type contextCheckingResolver struct {
+	ctxErr error
+}
+
+func (r *contextCheckingResolver) Resolve(ctx context.Context, env envelope.FrameEnvelope) (envelope.FrameEnvelope, error) {
+	r.ctxErr = ctx.Err()
+	return env, r.ctxErr
+}
+
+type contextCheckingSink struct {
+	rawCtxErr     error
+	unifiedCtxErr error
+	rawCount      int
+	unifiedCount  int
+}
+
+func (s *contextCheckingSink) PublishRaw(ctx context.Context, _ envelope.FrameEnvelope) error {
+	s.rawCtxErr = ctx.Err()
+	s.rawCount++
+	return s.rawCtxErr
+}
+
+func (s *contextCheckingSink) PublishUnified(ctx context.Context, _ envelope.FrameEnvelope) error {
+	s.unifiedCtxErr = ctx.Err()
+	s.unifiedCount++
+	return s.unifiedCtxErr
+}
+
+func (s *contextCheckingSink) Close() error {
+	return nil
+}
+
 func newTestServer(t *testing.T, protocol TCPProtocol, sink *recordingSink) *TCPServer {
 	t.Helper()
 	server, err := NewTCPServer(TCPServerConfig{