mirror of
https://github.com/refraction-networking/uquic.git
synced 2025-04-03 20:27:35 +03:00
refactor stream to support canceling Read and Write
This commit is contained in:
Marten Seemann
parent
15af2c6e41
commit
d0b22e3439
6 changed files with 570 additions and 523 deletions
730
stream_test.go
730
stream_test.go
|
|
@ -74,7 +74,7 @@ var _ = Describe("Stream", func() {
|
|||
})
|
||||
|
||||
Context("reading", func() {
|
||||
It("reads a single StreamFrame", func() {
|
||||
It("reads a single STREAM frame", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(4), false)
|
||||
mockFC.EXPECT().AddBytesRead(protocol.ByteCount(4))
|
||||
frame := wire.StreamFrame{
|
||||
|
|
@ -90,7 +90,7 @@ var _ = Describe("Stream", func() {
|
|||
Expect(b).To(Equal([]byte{0xDE, 0xAD, 0xBE, 0xEF}))
|
||||
})
|
||||
|
||||
It("reads a single StreamFrame in multiple goes", func() {
|
||||
It("reads a single STREAM frame in multiple goes", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(4), false)
|
||||
mockFC.EXPECT().AddBytesRead(protocol.ByteCount(2))
|
||||
mockFC.EXPECT().AddBytesRead(protocol.ByteCount(2))
|
||||
|
|
@ -268,6 +268,7 @@ var _ = Describe("Stream", func() {
|
|||
It("the deadline error has the right net.Error properties", func() {
|
||||
Expect(errDeadline.Temporary()).To(BeTrue())
|
||||
Expect(errDeadline.Timeout()).To(BeTrue())
|
||||
Expect(errDeadline).To(MatchError("deadline exceeded"))
|
||||
})
|
||||
|
||||
It("returns an error when Read is called after the deadline", func() {
|
||||
|
|
@ -477,341 +478,6 @@ var _ = Describe("Stream", func() {
|
|||
})
|
||||
})
|
||||
|
||||
Context("resetting", func() {
|
||||
Context("reset by the peer", func() {
|
||||
It("continues reading after receiving a remote error", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(4), false)
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(10), true)
|
||||
frame := wire.StreamFrame{
|
||||
Offset: 0,
|
||||
Data: []byte{0xDE, 0xAD, 0xBE, 0xEF},
|
||||
}
|
||||
str.HandleStreamFrame(&frame)
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 10,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
b := make([]byte, 4)
|
||||
n, err := strWithTimeout.Read(b)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(n).To(Equal(4))
|
||||
})
|
||||
|
||||
It("reads a delayed STREAM frame that arrives after receiving a remote error", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(4), true)
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(4), false)
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 4,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
frame := wire.StreamFrame{
|
||||
Offset: 0,
|
||||
Data: []byte{0xDE, 0xAD, 0xBE, 0xEF},
|
||||
}
|
||||
err = str.HandleStreamFrame(&frame)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
b := make([]byte, 4)
|
||||
n, err := strWithTimeout.Read(b)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(n).To(Equal(4))
|
||||
})
|
||||
|
||||
It("returns the error if reading past the offset of the frame received", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(4), false)
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(8), true)
|
||||
frame := wire.StreamFrame{
|
||||
Offset: 0,
|
||||
Data: []byte{0xDE, 0xAD, 0xBE, 0xEF},
|
||||
}
|
||||
str.HandleStreamFrame(&frame)
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 8,
|
||||
ErrorCode: 1337,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
b := make([]byte, 10)
|
||||
n, err := strWithTimeout.Read(b)
|
||||
Expect(b[0:4]).To(Equal(frame.Data))
|
||||
Expect(err).To(MatchError("RST_STREAM received with code 1337"))
|
||||
Expect(n).To(Equal(4))
|
||||
})
|
||||
|
||||
It("returns an EOF when reading past the offset, if the stream received a FIN bit", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(4), true)
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(8), true)
|
||||
frame := wire.StreamFrame{
|
||||
Offset: 0,
|
||||
Data: []byte{0xDE, 0xAD, 0xBE, 0xEF},
|
||||
FinBit: true,
|
||||
}
|
||||
str.HandleStreamFrame(&frame)
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 8,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
b := make([]byte, 10)
|
||||
n, err := strWithTimeout.Read(b)
|
||||
Expect(b[:4]).To(Equal(frame.Data))
|
||||
Expect(err).To(MatchError(io.EOF))
|
||||
Expect(n).To(Equal(4))
|
||||
})
|
||||
|
||||
It("continues reading in small chunks after receiving a remote error", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(4), true)
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(4), true)
|
||||
frame := wire.StreamFrame{
|
||||
Offset: 0,
|
||||
Data: []byte{0xDE, 0xAD, 0xBE, 0xEF},
|
||||
FinBit: true,
|
||||
}
|
||||
str.HandleStreamFrame(&frame)
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 4,
|
||||
})
|
||||
b := make([]byte, 3)
|
||||
_, err = strWithTimeout.Read(b)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(b).To(Equal([]byte{0xde, 0xad, 0xbe}))
|
||||
b = make([]byte, 3)
|
||||
n, err := strWithTimeout.Read(b)
|
||||
Expect(err).To(MatchError(io.EOF))
|
||||
Expect(b[:1]).To(Equal([]byte{0xef}))
|
||||
Expect(n).To(Equal(1))
|
||||
})
|
||||
|
||||
It("doesn't inform the flow controller about bytes read after receiving the remote error", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(4), false)
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(10), true)
|
||||
// No AddBytesRead()
|
||||
frame := wire.StreamFrame{
|
||||
Offset: 0,
|
||||
StreamID: 5,
|
||||
Data: []byte{0xDE, 0xAD, 0xBE, 0xEF},
|
||||
}
|
||||
str.HandleStreamFrame(&frame)
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 10,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
b := make([]byte, 3)
|
||||
_, err = strWithTimeout.Read(b)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
})
|
||||
|
||||
It("stops writing after receiving a remote error", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(8), true)
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
n, err := strWithTimeout.Write([]byte("foobar"))
|
||||
Expect(n).To(BeZero())
|
||||
Expect(err).To(MatchError("RST_STREAM received with code 1337"))
|
||||
close(done)
|
||||
}()
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 8,
|
||||
ErrorCode: 1337,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Eventually(done).Should(BeClosed())
|
||||
})
|
||||
|
||||
It("returns how much was written when receiving a remote error", func() {
|
||||
frameHeaderSize := protocol.ByteCount(4)
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(10), true)
|
||||
mockFC.EXPECT().SendWindowSize().Return(protocol.ByteCount(9999))
|
||||
mockFC.EXPECT().AddBytesSent(protocol.ByteCount(4))
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
n, err := strWithTimeout.Write([]byte("foobar"))
|
||||
Expect(err).To(MatchError("RST_STREAM received with code 1337"))
|
||||
Expect(n).To(Equal(4))
|
||||
close(done)
|
||||
}()
|
||||
|
||||
var frame *wire.StreamFrame
|
||||
Eventually(func() *wire.StreamFrame { frame = str.PopStreamFrame(4 + frameHeaderSize); return frame }).ShouldNot(BeNil())
|
||||
Expect(frame).ToNot(BeNil())
|
||||
Expect(frame.DataLen()).To(BeEquivalentTo(4))
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 10,
|
||||
ErrorCode: 1337,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Eventually(done).Should(BeClosed())
|
||||
})
|
||||
|
||||
It("calls queues a RST_STREAM frame when receiving a remote error", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(10), true)
|
||||
done := make(chan struct{})
|
||||
str.writeOffset = 0x1000
|
||||
go func() {
|
||||
_, _ = strWithTimeout.Write([]byte("foobar"))
|
||||
close(done)
|
||||
}()
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 10,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(Equal([]wire.Frame{
|
||||
&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 0x1000,
|
||||
},
|
||||
}))
|
||||
Eventually(done).Should(BeClosed())
|
||||
})
|
||||
|
||||
It("doesn't call onReset if it already sent a FIN", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(10), true)
|
||||
str.Close()
|
||||
f := str.PopStreamFrame(100)
|
||||
Expect(f.FinBit).To(BeTrue())
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 10,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(BeEmpty())
|
||||
})
|
||||
|
||||
It("doesn't queue a RST_STREAM if the stream was reset locally before", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(10), true)
|
||||
str.Reset(errors.New("reset"))
|
||||
Expect(queuedControlFrames).To(HaveLen(1))
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 10,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(HaveLen(1)) // no additional queued frame
|
||||
})
|
||||
|
||||
It("doesn't queue two RST_STREAMs twice, when it gets two remote errors", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(8), true)
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 8,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(HaveLen(1))
|
||||
err = str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 9,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(HaveLen(1))
|
||||
})
|
||||
})
|
||||
|
||||
Context("reset locally", func() {
|
||||
testErr := errors.New("test error")
|
||||
|
||||
It("stops writing", func() {
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
n, err := strWithTimeout.Write([]byte("foobar"))
|
||||
Expect(n).To(BeZero())
|
||||
Expect(err).To(MatchError(testErr))
|
||||
close(done)
|
||||
}()
|
||||
Consistently(done).ShouldNot(BeClosed())
|
||||
str.Reset(testErr)
|
||||
Expect(str.PopStreamFrame(1000)).To(BeNil())
|
||||
Eventually(done).Should(BeClosed())
|
||||
})
|
||||
|
||||
It("doesn't allow further writes", func() {
|
||||
str.Reset(testErr)
|
||||
n, err := strWithTimeout.Write([]byte("foobar"))
|
||||
Expect(n).To(BeZero())
|
||||
Expect(err).To(MatchError(testErr))
|
||||
Expect(str.PopStreamFrame(1000)).To(BeNil())
|
||||
})
|
||||
|
||||
It("stops reading", func() {
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
b := make([]byte, 4)
|
||||
n, err := strWithTimeout.Read(b)
|
||||
Expect(n).To(BeZero())
|
||||
Expect(err).To(MatchError(testErr))
|
||||
close(done)
|
||||
}()
|
||||
Consistently(done).ShouldNot(BeClosed())
|
||||
str.Reset(testErr)
|
||||
Eventually(done).Should(BeClosed())
|
||||
})
|
||||
|
||||
It("doesn't allow further reads", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(6), false)
|
||||
str.HandleStreamFrame(&wire.StreamFrame{
|
||||
Data: []byte("foobar"),
|
||||
})
|
||||
str.Reset(testErr)
|
||||
b := make([]byte, 6)
|
||||
n, err := strWithTimeout.Read(b)
|
||||
Expect(n).To(BeZero())
|
||||
Expect(err).To(MatchError(testErr))
|
||||
})
|
||||
|
||||
It("queues a RST_STREAM frame", func() {
|
||||
str.writeOffset = 0x1000
|
||||
str.Reset(testErr)
|
||||
Expect(queuedControlFrames).To(Equal([]wire.Frame{
|
||||
&wire.RstStreamFrame{
|
||||
StreamID: 1337,
|
||||
ByteOffset: 0x1000,
|
||||
},
|
||||
}))
|
||||
})
|
||||
|
||||
It("doesn't queue a RST_STREAM if it already sent a FIN", func() {
|
||||
str.Close()
|
||||
f := str.PopStreamFrame(1000)
|
||||
Expect(f.FinBit).To(BeTrue())
|
||||
str.Reset(testErr)
|
||||
Expect(queuedControlFrames).To(BeEmpty())
|
||||
})
|
||||
|
||||
It("doesn't queue a new RST_STREAM, if the stream was reset remotely before", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(10), true)
|
||||
err := str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 10,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
str.Reset(testErr)
|
||||
Expect(queuedControlFrames).To(HaveLen(1))
|
||||
})
|
||||
|
||||
It("doesn't call onReset twice", func() {
|
||||
str.Reset(testErr)
|
||||
Expect(queuedControlFrames).To(HaveLen(1))
|
||||
str.Reset(testErr)
|
||||
Expect(queuedControlFrames).To(HaveLen(1)) // no additional queued frame
|
||||
})
|
||||
|
||||
It("cancels the context", func() {
|
||||
Expect(str.Context().Done()).ToNot(BeClosed())
|
||||
str.Reset(testErr)
|
||||
Expect(str.Context().Done()).To(BeClosed())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Context("writing", func() {
|
||||
It("writes and gets all data at once", func() {
|
||||
mockFC.EXPECT().SendWindowSize().Return(protocol.ByteCount(9999))
|
||||
|
|
@ -910,6 +576,12 @@ var _ = Describe("Stream", func() {
|
|||
Expect(err).ToNot(HaveOccurred())
|
||||
})
|
||||
|
||||
It("cancels the context when Close is called", func() {
|
||||
Expect(str.Context().Done()).ToNot(BeClosed())
|
||||
str.Close()
|
||||
Expect(str.Context().Done()).To(BeClosed())
|
||||
})
|
||||
|
||||
Context("deadlines", func() {
|
||||
It("returns an error when Write is called after the deadline", func() {
|
||||
str.SetWriteDeadline(time.Now().Add(-time.Second))
|
||||
|
|
@ -1069,18 +741,329 @@ var _ = Describe("Stream", func() {
|
|||
})
|
||||
})
|
||||
|
||||
It("errors when a StreamFrames causes a flow control violation", func() {
|
||||
testErr := errors.New("flow control violation")
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(8), false).Return(testErr)
|
||||
frame := wire.StreamFrame{
|
||||
Offset: 2,
|
||||
Data: []byte("foobar"),
|
||||
}
|
||||
err := str.HandleStreamFrame(&frame)
|
||||
Expect(err).To(MatchError(testErr))
|
||||
Context("stream cancelations", func() {
|
||||
Context("canceling writing", func() {
|
||||
It("queues a RST_STREAM frame", func() {
|
||||
str.writeOffset = 1234
|
||||
err := str.CancelWrite(9876)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(Equal([]wire.Frame{
|
||||
&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 1234,
|
||||
ErrorCode: 9876,
|
||||
},
|
||||
}))
|
||||
})
|
||||
|
||||
It("unblocks Write", func() {
|
||||
mockFC.EXPECT().SendWindowSize().Return(protocol.MaxByteCount)
|
||||
mockFC.EXPECT().AddBytesSent(gomock.Any())
|
||||
writeReturned := make(chan struct{})
|
||||
var n int
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
var err error
|
||||
n, err = strWithTimeout.Write(bytes.Repeat([]byte{0}, 100))
|
||||
Expect(err).To(MatchError("Write on stream 1337 canceled with error code 1234"))
|
||||
close(writeReturned)
|
||||
}()
|
||||
var frame *wire.StreamFrame
|
||||
Eventually(func() *wire.StreamFrame {
|
||||
defer GinkgoRecover()
|
||||
frame = str.PopStreamFrame(50)
|
||||
return frame
|
||||
}).ShouldNot(BeNil())
|
||||
err := str.CancelWrite(1234)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Eventually(writeReturned).Should(BeClosed())
|
||||
Expect(n).To(BeEquivalentTo(frame.DataLen()))
|
||||
})
|
||||
|
||||
It("cancels the context", func() {
|
||||
Expect(str.Context().Done()).ToNot(BeClosed())
|
||||
str.CancelWrite(1234)
|
||||
Expect(str.Context().Done()).To(BeClosed())
|
||||
})
|
||||
|
||||
It("doesn't allow further calls to Write", func() {
|
||||
err := str.CancelWrite(1234)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
_, err = strWithTimeout.Write([]byte("foobar"))
|
||||
Expect(err).To(MatchError("Write on stream 1337 canceled with error code 1234"))
|
||||
})
|
||||
|
||||
It("only cancels once", func() {
|
||||
err := str.CancelWrite(1234)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(HaveLen(1))
|
||||
err = str.CancelWrite(4321)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(HaveLen(1))
|
||||
})
|
||||
|
||||
It("doesn't cancel when the stream was already closed", func() {
|
||||
err := str.Close()
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
err = str.CancelWrite(123)
|
||||
Expect(err).To(MatchError("CancelWrite for closed stream 1337"))
|
||||
})
|
||||
})
|
||||
|
||||
Context("canceling read", func() {
|
||||
It("unblocks Read", func() {
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
_, err := strWithTimeout.Read([]byte{0})
|
||||
Expect(err).To(MatchError("Read on stream 1337 canceled with error code 1234"))
|
||||
close(done)
|
||||
}()
|
||||
Consistently(done).ShouldNot(BeClosed())
|
||||
err := str.CancelRead(1234)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Eventually(done).Should(BeClosed())
|
||||
})
|
||||
|
||||
It("doesn't allow further calls to Read", func() {
|
||||
err := str.CancelRead(1234)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
_, err = strWithTimeout.Read([]byte{0})
|
||||
Expect(err).To(MatchError("Read on stream 1337 canceled with error code 1234"))
|
||||
})
|
||||
|
||||
It("does nothing when CancelRead is called twice", func() {
|
||||
err := str.CancelRead(1234)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
err = str.CancelRead(2345)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
_, err = strWithTimeout.Read([]byte{0})
|
||||
Expect(err).To(MatchError("Read on stream 1337 canceled with error code 1234"))
|
||||
})
|
||||
|
||||
Context("for gQUIC", func() {
|
||||
It("sends a RST_STREAM with error code 0, after the stream is closed", func() {
|
||||
str.version = versionGQUICFrames
|
||||
mockFC.EXPECT().SendWindowSize().Return(protocol.MaxByteCount).AnyTimes()
|
||||
mockFC.EXPECT().AddBytesSent(protocol.ByteCount(6))
|
||||
err := str.CancelRead(1234)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(BeEmpty()) // no RST_STREAM frame queued yet
|
||||
writeReturned := make(chan struct{})
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
_, err := strWithTimeout.Write([]byte("foobar"))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
close(writeReturned)
|
||||
}()
|
||||
Eventually(func() *wire.StreamFrame { return str.PopStreamFrame(1000) }).ShouldNot(BeNil())
|
||||
Eventually(writeReturned).Should(BeClosed())
|
||||
Expect(queuedControlFrames).To(BeEmpty()) // no RST_STREAM frame queued yet
|
||||
err = str.Close()
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(Equal([]wire.Frame{
|
||||
&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 6,
|
||||
ErrorCode: 0,
|
||||
},
|
||||
}))
|
||||
})
|
||||
|
||||
It("doesn't send a RST_STREAM frame, if the FIN was already read", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(6), true)
|
||||
mockFC.EXPECT().AddBytesRead(protocol.ByteCount(6))
|
||||
err := str.HandleStreamFrame(&wire.StreamFrame{
|
||||
StreamID: streamID,
|
||||
Data: []byte("foobar"),
|
||||
FinBit: true,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
_, err = strWithTimeout.Read(make([]byte, 100))
|
||||
Expect(err).To(MatchError(io.EOF))
|
||||
err = str.CancelRead(1234)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(BeEmpty()) // no RST_STREAM frame queued yet
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Context("receiving RST_STREAM frames", func() {
|
||||
rst := &wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 42,
|
||||
ErrorCode: 1234,
|
||||
}
|
||||
|
||||
It("unblocks Read", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(42), true)
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
_, err := strWithTimeout.Read([]byte{0})
|
||||
Expect(err).To(MatchError("Stream 1337 was reset with error code 1234"))
|
||||
Expect(err).To(BeAssignableToTypeOf(streamCanceledError{}))
|
||||
Expect(err.(streamCanceledError).Canceled()).To(BeTrue())
|
||||
Expect(err.(streamCanceledError).ErrorCode()).To(Equal(protocol.ApplicationErrorCode(1234)))
|
||||
close(done)
|
||||
}()
|
||||
Consistently(done).ShouldNot(BeClosed())
|
||||
str.HandleRstStreamFrame(rst)
|
||||
Eventually(done).Should(BeClosed())
|
||||
})
|
||||
|
||||
It("doesn't allow further calls to Read", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(42), true)
|
||||
err := str.HandleRstStreamFrame(rst)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
_, err = strWithTimeout.Read([]byte{0})
|
||||
Expect(err).To(MatchError("Stream 1337 was reset with error code 1234"))
|
||||
Expect(err).To(BeAssignableToTypeOf(streamCanceledError{}))
|
||||
Expect(err.(streamCanceledError).Canceled()).To(BeTrue())
|
||||
Expect(err.(streamCanceledError).ErrorCode()).To(Equal(protocol.ApplicationErrorCode(1234)))
|
||||
})
|
||||
|
||||
It("errors when receiving a RST_STREAM with an inconsistent offset", func() {
|
||||
testErr := errors.New("already received a different final offset before")
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(42), true).Return(testErr)
|
||||
err := str.HandleRstStreamFrame(rst)
|
||||
Expect(err).To(MatchError(testErr))
|
||||
})
|
||||
|
||||
It("ignores duplicate RST_STREAM frames", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(42), true).Times(2)
|
||||
err := str.HandleRstStreamFrame(rst)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
err = str.HandleRstStreamFrame(rst)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
})
|
||||
|
||||
It("doesn't do anyting when it was closed for shutdown", func() {
|
||||
str.CloseForShutdown(nil)
|
||||
err := str.HandleRstStreamFrame(rst)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
})
|
||||
|
||||
Context("for gQUIC", func() {
|
||||
BeforeEach(func() {
|
||||
str.version = versionGQUICFrames
|
||||
})
|
||||
|
||||
It("unblocks Read when receiving a RST_STREAM frame with non-zero error code", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(42), true)
|
||||
readReturned := make(chan struct{})
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
_, err := strWithTimeout.Read([]byte{0})
|
||||
Expect(err).To(MatchError("Stream 1337 was reset with error code 1234"))
|
||||
Expect(err).To(BeAssignableToTypeOf(streamCanceledError{}))
|
||||
Expect(err.(streamCanceledError).Canceled()).To(BeTrue())
|
||||
Expect(err.(streamCanceledError).ErrorCode()).To(Equal(protocol.ApplicationErrorCode(1234)))
|
||||
close(readReturned)
|
||||
}()
|
||||
Consistently(readReturned).ShouldNot(BeClosed())
|
||||
err := str.HandleRstStreamFrame(rst)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Eventually(readReturned).Should(BeClosed())
|
||||
})
|
||||
|
||||
It("unblocks Write when receiving a RST_STREAM frame with non-zero error code", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(6), true)
|
||||
str.writeOffset = 1000
|
||||
f := &wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 6,
|
||||
ErrorCode: 123,
|
||||
}
|
||||
writeReturned := make(chan struct{})
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
_, err := strWithTimeout.Write([]byte("foobar"))
|
||||
Expect(err).To(MatchError("Stream 1337 was reset with error code 123"))
|
||||
Expect(err).To(BeAssignableToTypeOf(streamCanceledError{}))
|
||||
Expect(err.(streamCanceledError).Canceled()).To(BeTrue())
|
||||
Expect(err.(streamCanceledError).ErrorCode()).To(Equal(protocol.ApplicationErrorCode(123)))
|
||||
close(writeReturned)
|
||||
}()
|
||||
Consistently(writeReturned).ShouldNot(BeClosed())
|
||||
err := str.HandleRstStreamFrame(f)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(Equal([]wire.Frame{
|
||||
&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 1000,
|
||||
ErrorCode: errorCodeStoppingGQUIC,
|
||||
},
|
||||
}))
|
||||
Eventually(writeReturned).Should(BeClosed())
|
||||
})
|
||||
|
||||
It("sends a RST_STREAM and continues reading until the end when receiving a RST_STREAM frame with error code 0", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(6), true).Times(2)
|
||||
mockFC.EXPECT().AddBytesRead(protocol.ByteCount(4))
|
||||
mockFC.EXPECT().AddBytesRead(protocol.ByteCount(2))
|
||||
readReturned := make(chan struct{})
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
n, err := strWithTimeout.Read(make([]byte, 4))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(n).To(Equal(4))
|
||||
n, err = strWithTimeout.Read(make([]byte, 4))
|
||||
Expect(err).To(MatchError(io.EOF))
|
||||
Expect(n).To(Equal(2))
|
||||
close(readReturned)
|
||||
}()
|
||||
Consistently(readReturned).ShouldNot(BeClosed())
|
||||
err := str.HandleStreamFrame(&wire.StreamFrame{
|
||||
StreamID: streamID,
|
||||
Data: []byte("foobar"),
|
||||
FinBit: true,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
err = str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 6,
|
||||
ErrorCode: 0,
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Eventually(readReturned).Should(BeClosed())
|
||||
})
|
||||
|
||||
It("unblocks Write when receiving a RST_STREAM frame with error code 0", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(6), true)
|
||||
str.writeOffset = 1000
|
||||
f := &wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 6,
|
||||
ErrorCode: 0,
|
||||
}
|
||||
writeReturned := make(chan struct{})
|
||||
go func() {
|
||||
defer GinkgoRecover()
|
||||
_, err := strWithTimeout.Write([]byte("foobar"))
|
||||
Expect(err).To(MatchError("Stream 1337 was reset with error code 0"))
|
||||
Expect(err).To(BeAssignableToTypeOf(streamCanceledError{}))
|
||||
Expect(err.(streamCanceledError).Canceled()).To(BeTrue())
|
||||
Expect(err.(streamCanceledError).ErrorCode()).To(Equal(protocol.ApplicationErrorCode(0)))
|
||||
close(writeReturned)
|
||||
}()
|
||||
Consistently(writeReturned).ShouldNot(BeClosed())
|
||||
err := str.HandleRstStreamFrame(f)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(queuedControlFrames).To(Equal([]wire.Frame{
|
||||
&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 1000,
|
||||
ErrorCode: errorCodeStoppingGQUIC,
|
||||
},
|
||||
}))
|
||||
Eventually(writeReturned).Should(BeClosed())
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Context("closing", func() {
|
||||
Context("saying if it is finished", func() {
|
||||
testErr := errors.New("testErr")
|
||||
|
||||
finishReading := func() {
|
||||
|
|
@ -1092,7 +1075,7 @@ var _ = Describe("Stream", func() {
|
|||
Expect(err).To(MatchError(io.EOF))
|
||||
}
|
||||
|
||||
It("is finished after it is canceled", func() {
|
||||
It("is finished after it is closed for shutdown", func() {
|
||||
str.CloseForShutdown(testErr)
|
||||
Expect(str.Finished()).To(BeTrue())
|
||||
})
|
||||
|
|
@ -1116,38 +1099,6 @@ var _ = Describe("Stream", func() {
|
|||
Expect(str.Finished()).To(BeFalse())
|
||||
})
|
||||
|
||||
It("is finished after receiving a RST and sending one", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(0), true)
|
||||
// this directly sends a rst
|
||||
str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 0,
|
||||
})
|
||||
Expect(str.rstSent.Get()).To(BeTrue())
|
||||
Expect(str.Finished()).To(BeTrue())
|
||||
})
|
||||
|
||||
It("cancels the context after receiving a RST", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(0), true)
|
||||
Expect(str.Context().Done()).ToNot(BeClosed())
|
||||
str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 0,
|
||||
})
|
||||
Expect(str.Context().Done()).To(BeClosed())
|
||||
})
|
||||
|
||||
It("is finished after being locally reset and receiving a RST in response", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(13), true)
|
||||
str.Reset(testErr)
|
||||
Expect(str.Finished()).To(BeFalse())
|
||||
str.HandleRstStreamFrame(&wire.RstStreamFrame{
|
||||
StreamID: streamID,
|
||||
ByteOffset: 13,
|
||||
})
|
||||
Expect(str.Finished()).To(BeTrue())
|
||||
})
|
||||
|
||||
It("is finished after finishing writing and receiving a RST", func() {
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(13), true)
|
||||
str.Close()
|
||||
|
|
@ -1159,17 +1110,20 @@ var _ = Describe("Stream", func() {
|
|||
})
|
||||
Expect(str.Finished()).To(BeTrue())
|
||||
})
|
||||
|
||||
It("is finished after finishing reading and being locally reset", func() {
|
||||
mockFC.EXPECT().AddBytesRead(protocol.ByteCount(0))
|
||||
finishReading()
|
||||
Expect(str.Finished()).To(BeFalse())
|
||||
str.Reset(testErr)
|
||||
Expect(str.Finished()).To(BeTrue())
|
||||
})
|
||||
})
|
||||
|
||||
Context("flow control", func() {
|
||||
It("errors when a STREAM frame causes a flow control violation", func() {
|
||||
testErr := errors.New("flow control violation")
|
||||
mockFC.EXPECT().UpdateHighestReceived(protocol.ByteCount(8), false).Return(testErr)
|
||||
frame := wire.StreamFrame{
|
||||
Offset: 2,
|
||||
Data: []byte("foobar"),
|
||||
}
|
||||
err := str.HandleStreamFrame(&frame)
|
||||
Expect(err).To(MatchError(testErr))
|
||||
})
|
||||
|
||||
It("says when it's flow control blocked", func() {
|
||||
mockFC.EXPECT().IsBlocked().Return(false, protocol.ByteCount(0))
|
||||
blocked, _ := str.IsFlowControlBlocked()
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue