forked from mirror/async-std
fix(net): ensure the reactor and runtime are running
If this is not done, then reactor is not running, resulting in the sockets not actually connecting. Closes #818
This commit is contained in:
parent
a602a91d83
commit
093d640ad7
6 changed files with 39 additions and 2 deletions
|
@ -75,6 +75,8 @@ impl TcpListener {
|
|||
///
|
||||
/// [`local_addr`]: #method.local_addr
|
||||
pub async fn bind<A: ToSocketAddrs>(addrs: A) -> io::Result<TcpListener> {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
let mut last_err = None;
|
||||
let addrs = addrs.to_socket_addrs().await?;
|
||||
|
||||
|
@ -200,6 +202,8 @@ impl<'a> Stream for Incoming<'a> {
|
|||
impl From<std::net::TcpListener> for TcpListener {
|
||||
/// Converts a `std::net::TcpListener` into its asynchronous equivalent.
|
||||
fn from(listener: std::net::TcpListener) -> TcpListener {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
TcpListener {
|
||||
watcher: Async::new(listener).expect("TcpListener is known to be good"),
|
||||
}
|
||||
|
|
|
@ -71,6 +71,8 @@ impl TcpStream {
|
|||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub async fn connect<A: ToSocketAddrs>(addrs: A) -> io::Result<TcpStream> {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
let mut last_err = None;
|
||||
let addrs = addrs.to_socket_addrs().await?;
|
||||
|
||||
|
@ -356,6 +358,8 @@ impl Write for &TcpStream {
|
|||
impl From<std::net::TcpStream> for TcpStream {
|
||||
/// Converts a `std::net::TcpStream` into its asynchronous equivalent.
|
||||
fn from(stream: std::net::TcpStream) -> TcpStream {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
TcpStream {
|
||||
watcher: Arc::new(Async::new(stream).expect("TcpStream is known to be good")),
|
||||
}
|
||||
|
|
|
@ -68,6 +68,8 @@ impl UdpSocket {
|
|||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub async fn bind<A: ToSocketAddrs>(addrs: A) -> io::Result<UdpSocket> {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
let mut last_err = None;
|
||||
let addrs = addrs.to_socket_addrs().await?;
|
||||
|
||||
|
@ -479,6 +481,8 @@ impl UdpSocket {
|
|||
impl From<std::net::UdpSocket> for UdpSocket {
|
||||
/// Converts a `std::net::UdpSocket` into its asynchronous equivalent.
|
||||
fn from(socket: std::net::UdpSocket) -> UdpSocket {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
UdpSocket {
|
||||
watcher: Async::new(socket).expect("UdpSocket is known to be good"),
|
||||
}
|
||||
|
|
|
@ -45,6 +45,8 @@ pub struct UnixDatagram {
|
|||
|
||||
impl UnixDatagram {
|
||||
fn new(socket: StdUnixDatagram) -> UnixDatagram {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
UnixDatagram {
|
||||
watcher: Async::new(socket).expect("UnixDatagram is known to be good"),
|
||||
}
|
||||
|
@ -64,6 +66,8 @@ impl UnixDatagram {
|
|||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub async fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixDatagram> {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
let path = path.as_ref().to_owned();
|
||||
let socket = Async::<StdUnixDatagram>::bind(path)?;
|
||||
Ok(UnixDatagram { watcher: socket })
|
||||
|
@ -305,6 +309,8 @@ impl fmt::Debug for UnixDatagram {
|
|||
impl From<StdUnixDatagram> for UnixDatagram {
|
||||
/// Converts a `std::os::unix::net::UnixDatagram` into its asynchronous equivalent.
|
||||
fn from(datagram: StdUnixDatagram) -> UnixDatagram {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
UnixDatagram {
|
||||
watcher: Async::new(datagram).expect("UnixDatagram is known to be good"),
|
||||
}
|
||||
|
@ -319,6 +325,8 @@ impl AsRawFd for UnixDatagram {
|
|||
|
||||
impl FromRawFd for UnixDatagram {
|
||||
unsafe fn from_raw_fd(fd: RawFd) -> UnixDatagram {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
let raw = StdUnixDatagram::from_raw_fd(fd);
|
||||
let datagram = Async::<StdUnixDatagram>::new(raw).expect("invalid file descriptor");
|
||||
UnixDatagram { watcher: datagram }
|
||||
|
|
|
@ -68,6 +68,8 @@ impl UnixListener {
|
|||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub async fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixListener> {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
let path = path.as_ref().to_owned();
|
||||
let listener = Async::<StdUnixListener>::bind(path)?;
|
||||
|
||||
|
@ -93,7 +95,12 @@ impl UnixListener {
|
|||
pub async fn accept(&self) -> io::Result<(UnixStream, SocketAddr)> {
|
||||
let (stream, addr) = self.watcher.accept().await?;
|
||||
|
||||
Ok((UnixStream { watcher: Arc::new(stream) }, addr))
|
||||
Ok((
|
||||
UnixStream {
|
||||
watcher: Arc::new(stream),
|
||||
},
|
||||
addr,
|
||||
))
|
||||
}
|
||||
|
||||
/// Returns a stream of incoming connections.
|
||||
|
@ -187,6 +194,8 @@ impl Stream for Incoming<'_> {
|
|||
impl From<StdUnixListener> for UnixListener {
|
||||
/// Converts a `std::os::unix::net::UnixListener` into its asynchronous equivalent.
|
||||
fn from(listener: StdUnixListener) -> UnixListener {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
UnixListener {
|
||||
watcher: Async::new(listener).expect("UnixListener is known to be good"),
|
||||
}
|
||||
|
|
|
@ -57,6 +57,8 @@ impl UnixStream {
|
|||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub async fn connect<P: AsRef<Path>>(path: P) -> io::Result<UnixStream> {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
let path = path.as_ref().to_owned();
|
||||
let stream = Arc::new(Async::<StdUnixStream>::connect(path).await?);
|
||||
|
||||
|
@ -79,6 +81,8 @@ impl UnixStream {
|
|||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn pair() -> io::Result<(UnixStream, UnixStream)> {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
let (a, b) = Async::<StdUnixStream>::pair()?;
|
||||
let a = UnixStream {
|
||||
watcher: Arc::new(a),
|
||||
|
@ -224,8 +228,12 @@ impl fmt::Debug for UnixStream {
|
|||
impl From<StdUnixStream> for UnixStream {
|
||||
/// Converts a `std::os::unix::net::UnixStream` into its asynchronous equivalent.
|
||||
fn from(stream: StdUnixStream) -> UnixStream {
|
||||
once_cell::sync::Lazy::force(&crate::rt::RUNTIME);
|
||||
|
||||
let stream = Async::new(stream).expect("UnixStream is known to be good");
|
||||
UnixStream { watcher: Arc::new(stream) }
|
||||
UnixStream {
|
||||
watcher: Arc::new(stream),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in a new issue