chore: optimize code
Build / Build (push) Has been cancelled

This commit is contained in:
nadoo committed 2026-11-16 21:08:27 +08:00
1 parent 9eadb8d9f4
commit a7d0421c93
15 files changed
+422 -171

No files matched your search

+99 -36
View File
@@ -4,6 +4,7 @@ import (
"errors"
"io"
"net"
"os"
"sync"
"time"
)
@@ -14,80 +15,142 @@ type stream struct {
id uint32
s *session
in chan []byte
readBuf []byte
closeIn sync.Once
closeOut sync.Once
in chan []byte
readBuf []byte
readDone chan struct{}
done chan struct{}
closeIn sync.Once
closeOnce sync.Once
fin *frameWrite // published by closeOnce
readMu sync.Mutex
writeMu sync.Mutex
mu sync.Mutex
closed bool
readDeadline streamDeadline
writeDeadline streamDeadline
}
func newStream(id uint32, s *session) *stream {
return &stream{id: id, s: s, in: make(chan []byte, 32)}
return &stream{
id: id, s: s, in: make(chan []byte, 32),
readDone: make(chan struct{}), done: make(chan struct{}),
}
}
func (st *stream) Read(p []byte) (int, error) {
for len(st.readBuf) == 0 {
b, ok := <-st.in
if !ok {
return 0, io.EOF
st.readMu.Lock()
defer st.readMu.Unlock()
for {
if channelClosed(st.done) {
return 0, net.ErrClosed
}
deadline := st.readDeadline.wait()
if channelClosed(deadline) {
return 0, os.ErrDeadlineExceeded
}
if len(p) == 0 {
return 0, nil
}
if len(st.readBuf) > 0 {
n := copy(p, st.readBuf)
st.readBuf = st.readBuf[n:]
return n, nil
}
// A peer FIN ends input after previously received data has been read.
select {
case st.readBuf = <-st.in:
continue
default:
}
select {
case st.readBuf = <-st.in:
case <-st.readDone:
select {
case st.readBuf = <-st.in:
default:
return 0, io.EOF
}
case <-st.done:
return 0, net.ErrClosed
case <-st.s.done:
return 0, st.s.Err()
case <-deadline:
return 0, os.ErrDeadlineExceeded
}
st.readBuf = b
}
n := copy(p, st.readBuf)
st.readBuf = st.readBuf[n:]
return n, nil
}
func (st *stream) Write(p []byte) (int, error) {
st.mu.Lock()
closed := st.closed
st.mu.Unlock()
if closed {
st.writeMu.Lock()
defer st.writeMu.Unlock()
if channelClosed(st.done) {
return 0, errStreamClosed
}
if channelClosed(st.writeDeadline.wait()) {
return 0, os.ErrDeadlineExceeded
}
written := 0
for len(p) > 0 {
n := min(len(p), maxFrameData)
if err := st.s.writeFrame(frame{command: cmdPSH, streamID: st.id, data: p[:n]}); err != nil {
accepted, err := st.s.writeStreamFrame(st, frame{command: cmdPSH, streamID: st.id, data: p[:n]})
written += accepted
if err != nil {
return written, err
}
written += n
p = p[n:]
}
return written, nil
}
func (st *stream) Close() error {
st.mu.Lock()
already := st.closed
st.closed = true
st.mu.Unlock()
if !already {
st.closeOut.Do(func() {
_ = st.s.writeFrame(frame{command: cmdFIN, streamID: st.id})
})
st.closeOnce.Do(func() {
close(st.done)
st.readDeadline.stop()
st.writeDeadline.stop()
st.s.removeStream(st.id)
}
// FIN is queued behind any frame already being written. Closing a stream
// must not wait for a stalled transport or interrupt another stream.
st.fin, _ = st.s.queueFrame(frame{command: cmdFIN, streamID: st.id}, nil, nil)
})
return nil
}
func (st *stream) closeRead() {
st.closeIn.Do(func() { close(st.in) })
st.closeIn.Do(func() { close(st.readDone) })
}
func (st *stream) push(data []byte) {
if channelClosed(st.done) || channelClosed(st.readDone) || channelClosed(st.s.done) {
return
}
cp := make([]byte, len(data))
copy(cp, data)
select {
case st.in <- cp:
case <-st.done:
case <-st.readDone:
case <-st.s.done:
}
}
func (st *stream) LocalAddr() net.Addr { return st.s.conn.LocalAddr() }
func (st *stream) RemoteAddr() net.Addr { return st.s.conn.RemoteAddr() }
func (st *stream) SetDeadline(t time.Time) error { return st.s.conn.SetDeadline(t) }
func (st *stream) SetReadDeadline(t time.Time) error { return st.s.conn.SetReadDeadline(t) }
func (st *stream) SetWriteDeadline(t time.Time) error { return st.s.conn.SetWriteDeadline(t) }
func (st *stream) LocalAddr() net.Addr { return st.s.conn.LocalAddr() }
func (st *stream) RemoteAddr() net.Addr { return st.s.conn.RemoteAddr() }
func (st *stream) SetDeadline(t time.Time) error {
if err := st.SetReadDeadline(t); err != nil {
return err
}
return st.SetWriteDeadline(t)
}
func (st *stream) SetReadDeadline(t time.Time) error {
if channelClosed(st.done) || channelClosed(st.s.done) {
return net.ErrClosed
}
st.readDeadline.set(t)
return nil
}
func (st *stream) SetWriteDeadline(t time.Time) error {
if channelClosed(st.done) || channelClosed(st.s.done) {
return net.ErrClosed
}
st.writeDeadline.set(t)
return nil
}