fix: close stream adaptive gaps and switch notify to stario v0.1.1

- make stream fast path honor adaptive soft payload limits end-to-end - split oversized fast-stream payloads into sequential frames before batching - use adaptive soft cap when encoding stream batch payloads - move timeout-like error detection into production code for adaptive tx - tune notify FrameReader read size explicitly to avoid throughput regression - drop local stario replace and depend on released b612.me/stario v0.1.1
2026-04-18 16:05:57 +08:00
parent 4f760f2807
commit f038a89771
76 changed files with 12656 additions and 906 deletions
@@ -1,6 +1,7 @@
 package notify

 import (
+	"b612.me/stario"
 	"context"
 	"net"
 	"os"
@@ -15,6 +16,10 @@ type serverInboundSourcePusher interface {
 	pushMessageSource([]byte, interface{})
 }

+type serverInboundSourceFastPusher interface {
+	pushTransportPayloadSourceFast([]byte, func(), interface{}) bool
+}
+
 func (c *LogicalConn) readTUMessage() {
 	rt := c.clientConnSessionRuntimeSnapshot()
 	if rt == nil {
@@ -37,6 +42,23 @@ func (c *LogicalConn) readTUMessageLoop(rt *clientConnSessionRuntime) {
 	conn := rt.tuConn
 	generation := rt.transportGeneration
 	defer closeClientConnSessionRuntimeTransportDone(rt)
+	if conn != nil && !isPacketTransportConn(conn) {
+		reader := newTransportFrameReader(conn, nil)
+		for {
+			select {
+			case <-sessionStopChan(stopCtx):
+				if c.shouldCloseTransportOnStop(conn) {
+					_ = conn.Close()
+				}
+				return
+			default:
+			}
+			payload, release, err := c.readTUTransportPayloadPooled(conn, reader)
+			if !c.handleTUTransportPayloadReadResultWithSessionPooled(stopCtx, conn, generation, payload, release, err) {
+				return
+			}
+		}
+	}
 	buf := streamReadBuffer()
 	for {
 		select {
@@ -54,6 +76,55 @@ func (c *LogicalConn) readTUMessageLoop(rt *clientConnSessionRuntime) {
 	}
 }

+func (c *LogicalConn) readTUTransportPayloadPooled(conn net.Conn, reader *stario.FrameReader) ([]byte, func(), error) {
+	if reader == nil {
+		return nil, nil, net.ErrClosed
+	}
+	if conn == nil {
+		return nil, nil, net.ErrClosed
+	}
+	if timeout := c.clientConnMaxReadTimeoutSnapshot(); timeout > 0 {
+		_ = conn.SetReadDeadline(time.Now().Add(timeout))
+	}
+	return reader.NextPooled()
+}
+
+func (c *LogicalConn) handleTUTransportPayloadReadResultWithSessionPooled(stopCtx context.Context, conn net.Conn, generation uint64, payload []byte, release func(), err error) bool {
+	if transportReadShouldStop(stopCtx) || !c.ownsTransportRead(conn, generation) {
+		if release != nil {
+			release()
+		}
+		if c.shouldCloseTransportOnStop(conn) {
+			_ = conn.Close()
+		}
+		return false
+	}
+	if err == os.ErrDeadlineExceeded {
+		return true
+	}
+	if err != nil {
+		if release != nil {
+			release()
+		}
+		select {
+		case <-sessionStopChan(stopCtx):
+			if c.shouldCloseTransportOnStop(conn) {
+				_ = conn.Close()
+			}
+			return false
+		default:
+		}
+		if detacher, ok := c.Server().(serverLogicalTransportDetacher); ok && c.shouldPreserveLogicalPeerOnTransportLoss() {
+			detacher.detachLogicalSessionTransport(c, "read error", err)
+			return false
+		}
+		c.stopServerOwnedSession("read error", err)
+		return false
+	}
+	c.pushServerOwnedTransportPayload(payload, release, conn, generation)
+	return true
+}
+
 func (c *LogicalConn) readFromTUTransportConnWithBuffer(conn net.Conn, data []byte) (int, []byte, error) {
 	if len(data) == 0 {
 		data = streamReadBuffer()
@@ -140,6 +211,29 @@ func (c *LogicalConn) pushServerOwnedTransportMessage(data []byte, conn net.Conn
 	server.pushMessage(data, c.clientConnIDSnapshot())
 }

+func (c *LogicalConn) pushServerOwnedTransportPayload(payload []byte, release func(), conn net.Conn, generation uint64) {
+	if c == nil || len(payload) == 0 {
+		if release != nil {
+			release()
+		}
+		return
+	}
+	server := c.Server()
+	if server == nil {
+		if release != nil {
+			release()
+		}
+		return
+	}
+	if pusher, ok := server.(serverInboundSourceFastPusher); ok {
+		pusher.pushTransportPayloadSourceFast(payload, release, newServerInboundSource(c, conn, nil, generation))
+		return
+	}
+	if release != nil {
+		release()
+	}
+}
+
 func (c *LogicalConn) shouldCloseTransportOnStop(conn net.Conn) bool {
 	if c == nil || conn == nil {
 		return false
@@ -185,10 +279,65 @@ func (c *ClientConn) readFromTUTransportConnWithBuffer(conn net.Conn, data []byt
 	return num, data, err
 }

+func (c *ClientConn) readTUTransportPayloadPooled(conn net.Conn, reader *stario.FrameReader) ([]byte, func(), error) {
+	if logical := c.LogicalConn(); logical != nil {
+		return logical.readTUTransportPayloadPooled(conn, reader)
+	}
+	if reader == nil {
+		return nil, nil, net.ErrClosed
+	}
+	if conn == nil {
+		return nil, nil, net.ErrClosed
+	}
+	if timeout := c.clientConnMaxReadTimeoutSnapshot(); timeout > 0 {
+		_ = conn.SetReadDeadline(time.Now().Add(timeout))
+	}
+	return reader.NextPooled()
+}
+
 func (c *ClientConn) handleTUTransportReadResult(num int, data []byte, err error) bool {
 	return c.handleTUTransportReadResultWithSession(c.clientConnTransportStopContextSnapshot(), c.clientConnTransportSnapshot(), c.clientConnTransportGenerationSnapshot(), num, data, err)
 }

+func (c *ClientConn) handleTUTransportPayloadReadResultWithSessionPooled(stopCtx context.Context, conn net.Conn, generation uint64, payload []byte, release func(), err error) bool {
+	if logical := c.LogicalConn(); logical != nil {
+		return logical.handleTUTransportPayloadReadResultWithSessionPooled(stopCtx, conn, generation, payload, release, err)
+	}
+	if transportReadShouldStop(stopCtx) || !c.ownsTransportRead(conn, generation) {
+		if release != nil {
+			release()
+		}
+		if c.shouldCloseClientConnTransportOnStop(conn) {
+			_ = conn.Close()
+		}
+		return false
+	}
+	if err == os.ErrDeadlineExceeded {
+		return true
+	}
+	if err != nil {
+		if release != nil {
+			release()
+		}
+		select {
+		case <-sessionStopChan(stopCtx):
+			if c.shouldCloseClientConnTransportOnStop(conn) {
+				_ = conn.Close()
+			}
+			return false
+		default:
+		}
+		if detacher, ok := c.server.(serverLogicalTransportDetacher); ok && c.shouldPreserveLogicalPeerOnTransportLoss() {
+			detacher.detachLogicalSessionTransport(logicalConnFromClient(c), "read error", err)
+			return false
+		}
+		c.stopServerOwnedSession("read error", err)
+		return false
+	}
+	c.pushServerOwnedTransportPayload(payload, release, conn, generation)
+	return true
+}
+
 func (c *ClientConn) handleTUTransportReadResultWithSession(stopCtx context.Context, conn net.Conn, generation uint64, num int, data []byte, err error) bool {
 	if logical := c.LogicalConn(); logical != nil {
 		return logical.handleTUTransportReadResultWithSession(stopCtx, conn, generation, num, data, err)
@@ -255,6 +404,26 @@ func (c *ClientConn) pushServerOwnedTransportMessage(data []byte, conn net.Conn,
 	c.server.pushMessage(data, c.clientConnIDSnapshot())
 }

+func (c *ClientConn) pushServerOwnedTransportPayload(payload []byte, release func(), conn net.Conn, generation uint64) {
+	if logical := c.LogicalConn(); logical != nil {
+		logical.pushServerOwnedTransportPayload(payload, release, conn, generation)
+		return
+	}
+	if c == nil || c.server == nil || len(payload) == 0 {
+		if release != nil {
+			release()
+		}
+		return
+	}
+	if pusher, ok := c.server.(serverInboundSourceFastPusher); ok {
+		pusher.pushTransportPayloadSourceFast(payload, release, newServerInboundSource(logicalConnFromClient(c), conn, nil, generation))
+		return
+	}
+	if release != nil {
+		release()
+	}
+}
+
 func (c *ClientConn) shouldCloseClientConnTransportOnStop(conn net.Conn) bool {
 	if logical := c.LogicalConn(); logical != nil {
 		return logical.shouldCloseTransportOnStop(conn)