Add support for closing write ends of streams#84
Open
eandre wants to merge 1 commit intohashicorp:masterfrom
Open
Add support for closing write ends of streams#84eandre wants to merge 1 commit intohashicorp:masterfrom
eandre wants to merge 1 commit intohashicorp:masterfrom
Conversation
When sending payloads of unknown length over a Stream and expecting the server to read it to completion before emitting a response (such as forwarding a byte stream), one difficulty with yamux is communicating that the byte stream's end has been reached. One approach is to introduce a higher-level protocol, but when the byte stream is of unknown size this requires essentially reimplementing large parts of yamux's framing protocol. A simpler solution is to communicate that EOF has been reached. Yamux provides this capability through (*Stream).Close, but it closes both the read and the write ends, which then prevents the client from reading the response from the server. This change introduces a new method, (*Stream).CloseWrite, which only closes the write end of the stream. When encountered on the other end, it sets a flag that the remote's write end has been closed and begins returning EOF from any reads after the receive buffer has been exhausted.
evanphx
suggested changes
Jul 28, 2022
Contributor
evanphx
left a comment
There was a problem hiding this comment.
One comment about the switch, but also can you do a little testing about what happens when a newer yamux sends CloseWrite to an older one that doesn't support the flag? We haven't added new flags to yamux in so many years, it's something we need to consider here.
| case streamEstablished: | ||
| goto SEND_CLOSE | ||
|
|
||
| case streamLocalClose: |
Contributor
There was a problem hiding this comment.
I think you mean that seeing streamLocalClose means we do nothing and continue after the switch but Go makes it hard to here if that's the case or if it's a programming error. Could you add a comment to the bottom saying something like "ok, handle normally" or something? Thanks!
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
When sending payloads of unknown length over a Stream
and expecting the server to read it to completion before
emitting a response (such as forwarding a byte stream),
one difficulty with yamux is communicating that the byte
stream's end has been reached.
One approach is to introduce a higher-level protocol,
but when the byte stream is of unknown size this requires
essentially reimplementing large parts of yamux's framing
protocol.
A simpler solution is to communicate that EOF has been reached.
Yamux provides this capability through (*Stream).Close,
but it closes both the read and the write ends, which then
prevents the client from reading the response from the server.
This change introduces a new method, (*Stream).CloseWrite,
which only closes the write end of the stream. When encountered
on the other end, it sets a flag that the remote's write end has been
closed and begins returning EOF from any reads after the receive
buffer has been exhausted.