mirrors/uquic
1
0
Fork 0
mirror of https://github.com/refraction-networking/uquic.git synced 2025-04-04 20:57:36 +03:00
Code Issues Projects Releases Packages Wiki Activity

set the offset in BLOCKED and STREAM_BLOCKED frames

Browse source
This commit is contained in:
Marten Seemann 2017-12-14 15:19:55 +07:00
parent 69998c19cb
commit 00edfb7461
12 changed files with 51 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crypto_stream.go
View file

@ -19,7 +19,7 @@ type cryptoStreamI interface {
// methods needed for flow control
GetWindowUpdate() protocol.ByteCount
HandleMaxStreamDataFrame(*wire.MaxStreamDataFrame)
IsFlowControlBlocked() bool
IsFlowControlBlocked() (bool, protocol.ByteCount)
}
type cryptoStream struct {

9
internal/flowcontrol/base_flow_controller.go
View file

@ -79,11 +79,16 @@ func (c *baseFlowController) getWindowUpdate() protocol.ByteCount {
return c.receiveWindow
}
func (c *baseFlowController) IsBlocked() bool {
// IsBlocked says if it is blocked by flow control.
// If it is blocked, the offset is returned.
func (c *baseFlowController) IsBlocked() (bool, protocol.ByteCount) {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.sendWindowSize() == 0
if c.sendWindowSize() != 0 {
return false, 0
}
return true, c.sendWindow
}
// maybeAdjustWindowIncrement increases the receiveWindowIncrement if we're sending updates too often.

4
internal/flowcontrol/base_flow_controller_test.go
View file

@ -54,7 +54,9 @@ var _ = Describe("Base Flow controller", func() {
controller.UpdateSendWindow(100)
Expect(controller.IsBlocked()).To(BeFalse())
controller.AddBytesSent(100)
Expect(controller.IsBlocked()).To(BeTrue())
blocked, offset := controller.IsBlocked()
Expect(blocked).To(BeTrue())
Expect(offset).To(Equal(protocol.ByteCount(100)))
})
})

2
internal/flowcontrol/interface.go
View file

@ -5,7 +5,7 @@ import "github.com/lucas-clemente/quic-go/internal/protocol"
type flowController interface {
// for sending
SendWindowSize() protocol.ByteCount
IsBlocked() bool
IsBlocked() (bool, protocol.ByteCount)
UpdateSendWindow(protocol.ByteCount)
AddBytesSent(protocol.ByteCount)
// for receiving

3
internal/flowcontrol/stream_flow_controller_test.go
View file

@ -233,7 +233,8 @@ var _ = Describe("Stream Flow controller", func() {
controller.connection.UpdateSendWindow(50)
controller.UpdateSendWindow(100)
controller.AddBytesSent(50)
Expect(controller.connection.IsBlocked()).To(BeTrue())
blocked, _ := controller.connection.IsBlocked()
Expect(blocked).To(BeTrue())
Expect(controller.IsBlocked()).To(BeFalse())
})
})

5
internal/mocks/connection_flow_controller.go
View file

@ -66,10 +66,11 @@ func (_mr *MockConnectionFlowControllerMockRecorder) GetWindowUpdate() *gomock.C
}
// IsBlocked mocks base method
func (_m *MockConnectionFlowController) IsBlocked() bool {
func (_m *MockConnectionFlowController) IsBlocked() (bool, protocol.ByteCount) {
ret := _m.ctrl.Call(_m, "IsBlocked")
ret0, _ := ret[0].(bool)
return ret0
ret1, _ := ret[1].(protocol.ByteCount)
return ret0, ret1
}
// IsBlocked indicates an expected call of IsBlocked

5
internal/mocks/stream.go
View file

@ -129,10 +129,11 @@ func (_mr *MockStreamIMockRecorder) HandleStreamFrame(arg0 interface{}) *gomock.
}
// IsFlowControlBlocked mocks base method
func (_m *MockStreamI) IsFlowControlBlocked() bool {
func (_m *MockStreamI) IsFlowControlBlocked() (bool, protocol.ByteCount) {
ret := _m.ctrl.Call(_m, "IsFlowControlBlocked")
ret0, _ := ret[0].(bool)
return ret0
ret1, _ := ret[1].(protocol.ByteCount)
return ret0, ret1
}
// IsFlowControlBlocked indicates an expected call of IsFlowControlBlocked

5
internal/mocks/stream_flow_controller.go
View file

@ -66,10 +66,11 @@ func (_mr *MockStreamFlowControllerMockRecorder) GetWindowUpdate() *gomock.Call
}
// IsBlocked mocks base method
func (_m *MockStreamFlowController) IsBlocked() bool {
func (_m *MockStreamFlowController) IsBlocked() (bool, protocol.ByteCount) {
ret := _m.ctrl.Call(_m, "IsBlocked")
ret0, _ := ret[0].(bool)
return ret0
ret1, _ := ret[1].(protocol.ByteCount)
return ret0, ret1
}
// IsBlocked indicates an expected call of IsBlocked

4
stream.go
View file

@ -25,7 +25,7 @@ type streamI interface {
// methods needed for flow control
GetWindowUpdate() protocol.ByteCount
HandleMaxStreamDataFrame(*wire.MaxStreamDataFrame)
IsFlowControlBlocked() bool
IsFlowControlBlocked() (bool, protocol.ByteCount)
}
// A Stream assembles the data from StreamFrames and provides a super-convenient Read-Interface
@ -484,7 +484,7 @@ func (s *stream) HandleMaxStreamDataFrame(frame *wire.MaxStreamDataFrame) {
s.flowController.UpdateSendWindow(frame.ByteOffset)
}
func (s *stream) IsFlowControlBlocked() bool {
func (s *stream) IsFlowControlBlocked() (bool, protocol.ByteCount) {
return s.flowController.IsBlocked()
}

13
stream_framer.go
View file

@ -105,11 +105,16 @@ func (f *streamFramer) maybePopNormalFrames(maxTotalLen protocol.ByteCount) (res
}
// Finally, check if we are now FC blocked and should queue a BLOCKED frame
if !frame.FinBit && s.IsFlowControlBlocked() {
f.blockedFrameQueue = append(f.blockedFrameQueue, &wire.StreamBlockedFrame{StreamID: s.StreamID()})
if !frame.FinBit {
if blocked, offset := s.IsFlowControlBlocked(); blocked {
f.blockedFrameQueue = append(f.blockedFrameQueue, &wire.StreamBlockedFrame{
StreamID: s.StreamID(),
Offset: offset,
})
}
}
if f.connFlowController.IsBlocked() {
f.blockedFrameQueue = append(f.blockedFrameQueue, &wire.BlockedFrame{})
if blocked, offset := f.connFlowController.IsBlocked(); blocked {
f.blockedFrameQueue = append(f.blockedFrameQueue, &wire.BlockedFrame{Offset: offset})
}
res = append(res, frame)

21
stream_framer_test.go
View file

@ -72,8 +72,8 @@ var _ = Describe("Stream Framer", func() {
BeforeEach(func() {
// nothing is blocked here
connFC.EXPECT().IsBlocked().AnyTimes()
stream1.EXPECT().IsFlowControlBlocked().Return(false).AnyTimes()
stream2.EXPECT().IsFlowControlBlocked().Return(false).AnyTimes()
stream1.EXPECT().IsFlowControlBlocked().Return(false, protocol.ByteCount(0)).AnyTimes()
stream2.EXPECT().IsFlowControlBlocked().Return(false, protocol.ByteCount(0)).AnyTimes()
})
It("returns nil when popping an empty framer", func() {
@ -272,13 +272,13 @@ var _ = Describe("Stream Framer", func() {
StreamID: id1,
Data: []byte("foobar"),
})
stream1.EXPECT().IsFlowControlBlocked().Return(true)
stream1.EXPECT().IsFlowControlBlocked().Return(true, protocol.ByteCount(0x1234))
frames := framer.PopStreamFrames(1000)
Expect(frames).To(HaveLen(1))
f := framer.PopBlockedFrame()
Expect(f).To(BeAssignableToTypeOf(&wire.StreamBlockedFrame{}))
bf := f.(*wire.StreamBlockedFrame)
Expect(bf.StreamID).To(Equal(stream1.StreamID()))
Expect(framer.PopBlockedFrame()).To(Equal(&wire.StreamBlockedFrame{
StreamID: stream1.StreamID(),
Offset: 0x1234,
}))
Expect(framer.PopBlockedFrame()).To(BeNil())
})
@ -300,15 +300,14 @@ var _ = Describe("Stream Framer", func() {
It("queues and pops BLOCKED frames for connection blocked streams", func() {
setNoData(stream2)
connFC.EXPECT().IsBlocked().Return(true)
connFC.EXPECT().IsBlocked().Return(true, protocol.ByteCount(0x4321))
stream1.EXPECT().PopStreamFrame(gomock.Any()).Return(&wire.StreamFrame{
StreamID: id1,
Data: []byte("foo"),
})
stream1.EXPECT().IsFlowControlBlocked().Return(false)
stream1.EXPECT().IsFlowControlBlocked().Return(false, protocol.ByteCount(0))
framer.PopStreamFrames(1000)
f := framer.PopBlockedFrame()
Expect(f).To(BeAssignableToTypeOf(&wire.BlockedFrame{}))
Expect(framer.PopBlockedFrame()).To(Equal(&wire.BlockedFrame{Offset: 0x4321}))
Expect(framer.PopBlockedFrame()).To(BeNil())
})
})

11
stream_test.go
View file

@ -1146,10 +1146,13 @@ var _ = Describe("Stream", func() {
Context("flow control", func() {
It("says when it's flow control blocked", func() {
mockFC.EXPECT().IsBlocked().Return(false)
Expect(str.IsFlowControlBlocked()).To(BeFalse())
mockFC.EXPECT().IsBlocked().Return(true)
Expect(str.IsFlowControlBlocked()).To(BeTrue())
mockFC.EXPECT().IsBlocked().Return(false, protocol.ByteCount(0))
blocked, _ := str.IsFlowControlBlocked()
Expect(blocked).To(BeFalse())
mockFC.EXPECT().IsBlocked().Return(true, protocol.ByteCount(0x1337))
blocked, offset := str.IsFlowControlBlocked()
Expect(blocked).To(BeTrue())
Expect(offset).To(Equal(protocol.ByteCount(0x1337)))
})
It("updates the flow control window", func() {