Tests and code for various SPDY close scenarios. #46
Conversation
This file contains 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
Writing this change has led me to believe that the concurrency here is just plain awful, and I need to find a better solution than what I have. In particular, there are too many threads: - the internal reader thread - application reader threads - application writer threads And too many locks: - the SpdyWriter I/O write lock - the SpdyConnection internal state lock - each SpdyStream's internal state lock What's currently very wrong is the internal reader thread is updating state in the SpdyStream, and reading bytes from the network into a particular stream. It is an error to hold the SpdyStream's lock while reading, but we're doing it because we need to hold the state on the buffer, position and limit. We need to rethink this! Chrome doesn't run into this problem because it can 'fire and forget' events. We can't do that because SPDY writes need to throw IOExceptions if the writes fail.
JakeWharton
added a commit
that referenced
this pull request
Oct 7, 2012
Tests and code for various SPDY close scenarios.
swankjesse
added a commit
that referenced
this pull request
Apr 23, 2023
As described in UTS #46, https://www.unicode.org/reports/tr46 This is working towards OkHttp's own implementation of what IDN.toASCII() does on the JVM.
swankjesse
added a commit
that referenced
this pull request
Apr 23, 2023
As described in UTS #46, https://www.unicode.org/reports/tr46 This is working towards OkHttp's own implementation of what IDN.toASCII() does on the JVM.
swankjesse
added a commit
that referenced
this pull request
Apr 23, 2023
* Straightforward implementation of IDNA mapping, for tests only As described in UTS #46, https://www.unicode.org/reports/tr46 This is working towards OkHttp's own implementation of what IDN.toASCII() does on the JVM. * Address code review feedback * Comment the mapping for ¼ * TM should be tm
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.
Writing this change has led me to believe that the
concurrency here is just plain awful, and I need to
find a better solution than what I have. In particular,
there are too many threads:
And too many locks:
What's currently very wrong is the internal reader thread
is updating state in the SpdyStream, and reading bytes from
the network into a particular stream. It is an error to hold
the SpdyStream's lock while reading, but we're doing it because
we need to hold the state on the buffer, position and limit.
We need to rethink this!
Chrome doesn't run into this problem because it can 'fire and
forget' events. We can't do that because SPDY writes need to
throw IOExceptions if the writes fail.