mirror of
https://github.com/nadoo/glider.git
synced 2026-11-19 07:09:42 +08:00
1 parent
9eadb8d9f4
commit
a7d0421c93
15 files changed
+422
-171
No files matched your search
+99
-36
@@ -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
|
||||
}
|
||||
Reference in new issue
Block a user