File size: 2,878 Bytes
f0f4f2b |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 |
use futures::{AsyncRead, AsyncWrite};
use libp2p_core::muxing::SubstreamBox;
use libp2p_core::Negotiated;
use std::{
io::{IoSlice, IoSliceMut},
pin::Pin,
sync::Arc,
task::{Context, Poll},
};
/// Counter for the number of active streams on a connection.
#[derive(Debug, Clone)]
pub(crate) struct ActiveStreamCounter(Arc<()>);
impl ActiveStreamCounter {
pub(crate) fn default() -> Self {
Self(Arc::new(()))
}
pub(crate) fn has_no_active_streams(&self) -> bool {
self.num_alive_streams() == 1
}
fn num_alive_streams(&self) -> usize {
Arc::strong_count(&self.0)
}
}
#[derive(Debug)]
pub struct Stream {
stream: Negotiated<SubstreamBox>,
counter: Option<ActiveStreamCounter>,
}
impl Stream {
pub(crate) fn new(stream: Negotiated<SubstreamBox>, counter: ActiveStreamCounter) -> Self {
Self {
stream,
counter: Some(counter),
}
}
/// Ignore this stream in the [Swarm](crate::Swarm)'s connection-keep-alive algorithm.
///
/// By default, any active stream keeps a connection alive. For most protocols,
/// this is a good default as it ensures that the protocol is completed before
/// a connection is shut down.
/// Some protocols like libp2p's [ping](https://github.com/libp2p/specs/blob/master/ping/ping.md)
/// for example never complete and are of an auxiliary nature.
/// These protocols should opt-out of the keep alive algorithm using this method.
pub fn ignore_for_keep_alive(&mut self) {
self.counter.take();
}
}
impl AsyncRead for Stream {
fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut [u8],
) -> Poll<std::io::Result<usize>> {
Pin::new(&mut self.get_mut().stream).poll_read(cx, buf)
}
fn poll_read_vectored(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &mut [IoSliceMut<'_>],
) -> Poll<std::io::Result<usize>> {
Pin::new(&mut self.get_mut().stream).poll_read_vectored(cx, bufs)
}
}
impl AsyncWrite for Stream {
fn poll_write(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<std::io::Result<usize>> {
Pin::new(&mut self.get_mut().stream).poll_write(cx, buf)
}
fn poll_write_vectored(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>],
) -> Poll<std::io::Result<usize>> {
Pin::new(&mut self.get_mut().stream).poll_write_vectored(cx, bufs)
}
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Pin::new(&mut self.get_mut().stream).poll_flush(cx)
}
fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Pin::new(&mut self.get_mut().stream).poll_close(cx)
}
}
|