mirror of
https://github.com/fluencelabs/rust-libp2p
synced 2025-04-25 11:02:12 +00:00
589d280bb5
* Remove tokio-codec dependency from multistream-select. In preparation for the eventual switch from tokio to std futures. Includes some initial refactoring in preparation for further work in the context of https://github.com/libp2p/rust-libp2p/issues/659. * Reduce default buffer sizes. * Allow more than one frame to be buffered for sending. * Doc tweaks. * Remove superfluous (duplicated) Message types. * Reduce roundtrips in multistream-select negotiation. 1. Enable 0-RTT: If the dialer only supports a single protocol, it can send protocol data (e.g. the actual application request) together with the multistream-select header and protocol proposal. Similarly, if the listener supports a proposed protocol, it can send protocol data (e.g. the actual application response) together with the multistream-select header and protocol confirmation. 2. In general, the dialer "settles on" an expected protocol as soon as it runs out of alternatives. Furthermore, both dialer and listener do not immediately flush the final protocol confirmation, allowing it to be sent together with application protocol data. Attempts to read from the negotiated I/O stream implicitly flushes any pending data. 3. A clean / graceful shutdown of an I/O stream always completes protocol negotiation. The publich API of multistream-select changed slightly, requiring both AsyncRead and AsyncWrite bounds for async reading and writing due to the implicit buffering and "lazy" negotiation. The error types have also been changed, but they were not previously fully exported. Includes some general refactoring with simplifications and some more tests, e.g. there was an edge case relating to a possible ambiguity when parsing multistream-select protocol messages. * Further missing commentary. * Remove unused test dependency. * Adjust commentary. * Cleanup NegotiatedComplete::poll() * Fix deflate protocol tests. * Stabilise network_simult test. The test implicitly relied on "slow" connection establishment in order to have a sufficient probability of passing. With the removal of roundtrips in multistream-select, it is now more likely that within the up to 50ms duration between swarm1 and swarm2 dialing, the connection is already established, causing the expectation of step == 1 to fail when receiving a Connected event, since the step may then still be 0. This commit aims to avoid these spurious errors by detecting runs during which a connection is established "too quickly", repeating the test run. It still seems theoretically possible that, if connections are always established "too quickly", the test runs forever. However, given that the delta between swarm1 and swarm2 dialing is 0-50ms and that the TCP transport is used, that seems probabilistically unlikely. Nevertheless, the purpose of the artificial dialing delay between swarm1 and swarm2 should be re-evaluated and possibly at least the maximum delay further reduced. * Complete negotiation between upgrades in libp2p-core. While multistream-select, as a standalone library and providing an API at the granularity of a single negotiation, supports lazy negotiation (and in particular 0-RTT negotiation), in the context of libp2p-core where any number of negotiations are composed generically within the concept of composable "upgrades", it is necessary to wait for protocol negotiation between upgrades to complete. * Clarify docs. Simplify listener upgrades. Since reading from a Negotiated I/O stream implicitly flushes any pending negotiation data, there is no pitfall involved in not waiting for completion.
48 lines
1.0 KiB
Rust
48 lines
1.0 KiB
Rust
|
|
#![allow(dead_code)]
|
|
|
|
use futures::prelude::*;
|
|
use libp2p_core::muxing::StreamMuxer;
|
|
|
|
pub struct CloseMuxer<M> {
|
|
state: CloseMuxerState<M>,
|
|
}
|
|
|
|
impl<M> CloseMuxer<M> {
|
|
pub fn new(m: M) -> CloseMuxer<M> {
|
|
CloseMuxer {
|
|
state: CloseMuxerState::Close(m)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub enum CloseMuxerState<M> {
|
|
Close(M),
|
|
Done,
|
|
}
|
|
|
|
impl<M> Future for CloseMuxer<M>
|
|
where
|
|
M: StreamMuxer,
|
|
M::Error: From<std::io::Error>
|
|
{
|
|
type Item = M;
|
|
type Error = M::Error;
|
|
|
|
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
|
|
loop {
|
|
match std::mem::replace(&mut self.state, CloseMuxerState::Done) {
|
|
CloseMuxerState::Close(muxer) => {
|
|
if muxer.close()?.is_not_ready() {
|
|
self.state = CloseMuxerState::Close(muxer);
|
|
return Ok(Async::NotReady)
|
|
}
|
|
return Ok(Async::Ready(muxer))
|
|
}
|
|
CloseMuxerState::Done => panic!()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|