html-to-markdown 2.27.2 → 2.27.3

data/rust-vendor/tokio/Cargo.toml

@@ -13,9 +13,10 @@
 edition = "2021"
 rust-version = "1.71"
 name = "tokio"
-version = "1.49.0"
+version = "1.50.0"
 authors = ["Tokio Contributors <team@tokio.rs>"]
 build = false
+autolib = false
 autobins = false
 autoexamples = false
 autotests = false
@@ -39,25 +40,18 @@ categories = [
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
 
-[package.metadata.cargo_check_external_types]
-allowed_external_types = [
-    "bytes::buf::buf_impl::Buf",
-    "bytes::buf::buf_mut::BufMut",
-    "tokio_macros::*",
-]
-
 [package.metadata.docs.rs]
 all-features = true
-rustc-args = [
-    "--cfg",
-    "tokio_unstable",
-]
 rustdoc-args = [
     "--cfg",
     "docsrs",
     "--cfg",
     "tokio_unstable",
 ]
+rustc-args = [
+    "--cfg",
+    "tokio_unstable",
+]
 
 [package.metadata.playground]
 features = [
@@ -65,6 +59,83 @@ features = [
     "test-util",
 ]
 
+[package.metadata.cargo_check_external_types]
+allowed_external_types = [
+    "bytes::buf::buf_impl::Buf",
+    "bytes::buf::buf_mut::BufMut",
+    "tokio_macros::*",
+]
+
+[features]
+default = []
+fs = []
+full = [
+    "fs",
+    "io-util",
+    "io-std",
+    "macros",
+    "net",
+    "parking_lot",
+    "process",
+    "rt",
+    "rt-multi-thread",
+    "signal",
+    "sync",
+    "time",
+]
+io-std = []
+io-uring = [
+    "dep:io-uring",
+    "libc",
+    "mio/os-poll",
+    "mio/os-ext",
+    "dep:slab",
+]
+io-util = ["bytes"]
+macros = ["tokio-macros"]
+net = [
+    "libc",
+    "mio/os-poll",
+    "mio/os-ext",
+    "mio/net",
+    "socket2",
+    "windows-sys/Win32_Foundation",
+    "windows-sys/Win32_Security",
+    "windows-sys/Win32_Storage_FileSystem",
+    "windows-sys/Win32_System_Pipes",
+    "windows-sys/Win32_System_SystemServices",
+]
+process = [
+    "bytes",
+    "libc",
+    "mio/os-poll",
+    "mio/os-ext",
+    "mio/net",
+    "signal-hook-registry",
+    "windows-sys/Win32_Foundation",
+    "windows-sys/Win32_System_Threading",
+    "windows-sys/Win32_System_WindowsProgramming",
+]
+rt = []
+rt-multi-thread = ["rt"]
+signal = [
+    "libc",
+    "mio/os-poll",
+    "mio/net",
+    "mio/os-ext",
+    "signal-hook-registry",
+    "windows-sys/Win32_Foundation",
+    "windows-sys/Win32_System_Console",
+]
+sync = []
+taskdump = ["dep:backtrace"]
+test-util = [
+    "rt",
+    "sync",
+    "time",
+]
+time = []
+
 [lib]
 name = "tokio"
 path = "src/lib.rs"
@@ -165,6 +236,10 @@ path = "tests/fs_write.rs"
 name = "io_async_fd"
 path = "tests/io_async_fd.rs"
 
+[[test]]
+name = "io_async_fd_memory_leak"
+path = "tests/io_async_fd_memory_leak.rs"
+
 [[test]]
 name = "io_async_read"
 path = "tests/io_async_read.rs"
@@ -389,6 +464,10 @@ path = "tests/rt_basic.rs"
 name = "rt_common"
 path = "tests/rt_common.rs"
 
+[[test]]
+name = "rt_common_before_park"
+path = "tests/rt_common_before_park.rs"
+
 [[test]]
 name = "rt_handle"
 path = "tests/rt_handle.rs"
@@ -413,6 +492,10 @@ path = "tests/rt_panic.rs"
 name = "rt_poll_callbacks"
 path = "tests/rt_poll_callbacks.rs"
 
+[[test]]
+name = "rt_shutdown_err"
+path = "tests/rt_shutdown_err.rs"
+
 [[test]]
 name = "rt_threaded"
 path = "tests/rt_threaded.rs"
@@ -751,76 +834,6 @@ version = "0.4.0"
 version = "0.7"
 features = ["rt"]
 
-[features]
-default = []
-fs = []
-full = [
-    "fs",
-    "io-util",
-    "io-std",
-    "macros",
-    "net",
-    "parking_lot",
-    "process",
-    "rt",
-    "rt-multi-thread",
-    "signal",
-    "sync",
-    "time",
-]
-io-std = []
-io-uring = [
-    "dep:io-uring",
-    "libc",
-    "mio/os-poll",
-    "mio/os-ext",
-    "dep:slab",
-]
-io-util = ["bytes"]
-macros = ["tokio-macros"]
-net = [
-    "libc",
-    "mio/os-poll",
-    "mio/os-ext",
-    "mio/net",
-    "socket2",
-    "windows-sys/Win32_Foundation",
-    "windows-sys/Win32_Security",
-    "windows-sys/Win32_Storage_FileSystem",
-    "windows-sys/Win32_System_Pipes",
-    "windows-sys/Win32_System_SystemServices",
-]
-process = [
-    "bytes",
-    "libc",
-    "mio/os-poll",
-    "mio/os-ext",
-    "mio/net",
-    "signal-hook-registry",
-    "windows-sys/Win32_Foundation",
-    "windows-sys/Win32_System_Threading",
-    "windows-sys/Win32_System_WindowsProgramming",
-]
-rt = []
-rt-multi-thread = ["rt"]
-signal = [
-    "libc",
-    "mio/os-poll",
-    "mio/net",
-    "mio/os-ext",
-    "signal-hook-registry",
-    "windows-sys/Win32_Foundation",
-    "windows-sys/Win32_System_Console",
-]
-sync = []
-taskdump = ["dep:backtrace"]
-test-util = [
-    "rt",
-    "sync",
-    "time",
-]
-time = []
-
 [target.'cfg(all(target_family = "wasm", not(target_os = "wasi")))'.dev-dependencies.wasm-bindgen-test]
 version = "0.3.0"
 
@@ -832,7 +845,7 @@ version = "0.3.58"
 optional = true
 
 [target.'cfg(all(tokio_unstable, target_os = "linux"))'.dependencies.io-uring]
-version = "0.7.6"
+version = "0.7.11"
 optional = true
 default-features = false
 

data/rust-vendor/tokio/Cargo.toml.orig

@@ -1,12 +1,12 @@
 [package]
 name = "tokio"
 # When releasing to crates.io:
-# - Remove path dependencies
+# - Remove path dependencies (if any)
 # - Update doc url
 #   - README.md
 # - Update CHANGELOG.md.
 # - Create "v1.x.y" git tag.
-version = "1.49.0"
+version = "1.50.0"
 edition = "2021"
 rust-version = "1.71"
 authors = ["Tokio Contributors <team@tokio.rs>"]
@@ -90,7 +90,7 @@ io-uring = ["dep:io-uring", "libc", "mio/os-poll", "mio/os-ext", "dep:slab"]
 taskdump = ["dep:backtrace"]
 
 [dependencies]
-tokio-macros = { version = "~2.6.0", path = "../tokio-macros", optional = true }
+tokio-macros = { version = "~2.6.0", optional = true }
 
 pin-project-lite = "0.2.11"
 
@@ -110,7 +110,7 @@ tracing = { version = "0.1.29", default-features = false, features = ["std"], op
 # Currently unstable. The API exposed by these features may be broken at any time.
 # Requires `--cfg tokio_unstable` to enable.
 [target.'cfg(all(tokio_unstable, target_os = "linux"))'.dependencies]
-io-uring = { version = "0.7.6", default-features = false, optional = true }
+io-uring = { version = "0.7.11", default-features = false, optional = true }
 libc = { version = "0.2.168", optional = true }
 mio = { version = "1.0.1", default-features = false, features = ["os-poll", "os-ext"], optional = true }
 slab = { version = "0.4.9", optional = true }
@@ -136,9 +136,9 @@ features = [
 ]
 
 [dev-dependencies]
-tokio-test = { version = "0.4.0", path = "../tokio-test" }
-tokio-stream = { version = "0.1", path = "../tokio-stream" }
-tokio-util = { version = "0.7", path = "../tokio-util", features = ["rt"] }
+tokio-test = "0.4.0"
+tokio-stream = "0.1"
+tokio-util = { version = "0.7", features = ["rt"] }
 futures = { version = "0.3.0", features = ["async-await"] }
 futures-test = "0.3.31"
 mockall = "0.13.0"

data/rust-vendor/tokio/README.md

@@ -56,7 +56,7 @@ Make sure you enable the full features of the tokio crate on Cargo.toml:
 
 ```toml
 [dependencies]
-tokio = { version = "1.49.0", features = ["full"] }
+tokio = { version = "1.50.0", features = ["full"] }
 ```
 Then, on your main.rs:
 

data/rust-vendor/tokio/src/fs/open_options.rs

@@ -531,7 +531,10 @@ impl OpenOptions {
                 let handle = crate::runtime::Handle::current();
                 let driver_handle = handle.inner.driver().io();
 
-                if driver_handle.check_and_init()? {
+                if driver_handle
+                    .check_and_init(io_uring::opcode::OpenAt::CODE)
+                    .await?
+                {
                     Op::open(path.as_ref(), opts)?.await
                 } else {
                     let opts = opts.clone().into();

data/rust-vendor/tokio/src/fs/read.rs

@@ -68,7 +68,10 @@ pub async fn read(path: impl AsRef<Path>) -> io::Result<Vec<u8>> {
 
         let handle = crate::runtime::Handle::current();
         let driver_handle = handle.inner.driver().io();
-        if driver_handle.check_and_init()? {
+        if driver_handle
+            .check_and_init(io_uring::opcode::Read::CODE)
+            .await?
+        {
             return read_uring(&path).await;
         }
     }

data/rust-vendor/tokio/src/fs/write.rs

@@ -37,7 +37,10 @@ pub async fn write(path: impl AsRef<Path>, contents: impl AsRef<[u8]>) -> io::Re
     {
         let handle = crate::runtime::Handle::current();
         let driver_handle = handle.inner.driver().io();
-        if driver_handle.check_and_init()? {
+        if driver_handle
+            .check_and_init(io_uring::opcode::Write::CODE)
+            .await?
+        {
             return write_uring(path, contents).await;
         }
     }

data/rust-vendor/tokio/src/io/async_write.rs

@@ -27,11 +27,10 @@ use std::task::{Context, Poll};
 /// * `Poll::Ready(Err(e))` for other errors are standard I/O errors coming from the
 ///   underlying object.
 ///
-/// This trait importantly means that the `write` method only works in the
-/// context of a future's task. The object may panic if used outside of a task.
-///
 /// Utilities for working with `AsyncWrite` values are provided by
-/// [`AsyncWriteExt`].
+/// [`AsyncWriteExt`]. Most users will interact with `AsyncWrite` types through
+/// these extension methods, which provide ergonomic async functions such as
+/// `write_all` and `flush`.
 ///
 /// [`std::io::Write`]: std::io::Write
 /// [`Write::write`]: std::io::Write::write()

data/rust-vendor/tokio/src/io/poll_evented.rs

@@ -188,6 +188,7 @@ feature! {
                         // Read more:
                         // https://github.com/tokio-rs/tokio/issues/5866
                         #[cfg(all(
+                            // keep in sync with poll_write
                             not(mio_unsupported_force_poll_poll),
                             any(
                                 // epoll
@@ -240,7 +241,28 @@ feature! {
                         // that the socket buffer is full.  Unfortunately this assumption
                         // fails for level-triggered selectors (like on Windows or poll even for
                         // UNIX): https://github.com/tokio-rs/tokio/issues/5866
-                        if n > 0 && (!cfg!(windows) && !cfg!(mio_unsupported_force_poll_poll) && n < buf.len()) {
+                        #[cfg(all(
+                            // keep in sync with poll_read
+                            not(mio_unsupported_force_poll_poll),
+                            any(
+                                // epoll
+                                target_os = "android",
+                                target_os = "illumos",
+                                target_os = "linux",
+                                target_os = "redox",
+                                // kqueue
+                                target_os = "dragonfly",
+                                target_os = "freebsd",
+                                target_os = "ios",
+                                target_os = "macos",
+                                target_os = "netbsd",
+                                target_os = "openbsd",
+                                target_os = "tvos",
+                                target_os = "visionos",
+                                target_os = "watchos",
+                            )
+                        ))]
+                        if 0 < n && n < buf.len() {
                             self.registration.clear_readiness(evt);
                         }
 

data/rust-vendor/tokio/src/io/stderr.rs

@@ -29,7 +29,7 @@ cfg_io_std! {
     ///
     /// #[tokio::main]
     /// async fn main() -> io::Result<()> {
-    ///     let mut stderr = io::stdout();
+    ///     let mut stderr = io::stderr();
     ///     stderr.write_all(b"Print some error here.").await?;
     ///     Ok(())
     /// }
@@ -50,6 +50,20 @@ cfg_io_std! {
     /// to occur as a single write, so multiple threads writing data with
     /// [`write_all`] may result in interleaved output.
     ///
+    /// Note that unlike [`std::io::stderr`], each call to this `stderr()`
+    /// produces a new writer, so for example, this program does **not** flush stderr:
+    ///
+    /// ```no_run
+    /// # use tokio::io::AsyncWriteExt;
+    /// # #[tokio::main]
+    /// # async fn main() -> std::io::Result<()> {
+    /// tokio::io::stderr().write_all(b"aa").await?;
+    /// tokio::io::stderr().flush().await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// [`std::io::stderr`]: std::io::stderr
     /// [`AsyncWrite`]: AsyncWrite
     /// [`write_all`]: crate::io::AsyncWriteExt::write_all()
     ///

data/rust-vendor/tokio/src/io/stdout.rs

@@ -74,6 +74,20 @@ cfg_io_std! {
     /// to occur as a single write, so multiple threads writing data with
     /// [`write_all`] may result in interleaved output.
     ///
+    /// Note that unlike [`std::io::stdout`], each call to this `stdout()`
+    /// produces a new writer, so for example, this program does **not** flush stdout:
+    ///
+    /// ```no_run
+    /// # use tokio::io::AsyncWriteExt;
+    /// # #[tokio::main]
+    /// # async fn main() -> std::io::Result<()> {
+    /// tokio::io::stdout().write_all(b"aa").await?;
+    /// tokio::io::stdout().flush().await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// [`std::io::stdout`]: std::io::stdout
     /// [`AsyncWrite`]: AsyncWrite
     /// [`write_all`]: crate::io::AsyncWriteExt::write_all()
     ///

data/rust-vendor/tokio/src/io/util/async_write_ext.rs

@@ -1294,8 +1294,8 @@ cfg_io_util! {
         /// async fn shutdown(&mut self) -> io::Result<()>;
         /// ```
         ///
-        /// Similar to [`flush`], all intermediately buffered is written to the
-        /// underlying stream. Once the operation completes, the caller should
+        /// Similar to [`flush`], all intermediately buffered content is written to
+        /// the underlying stream. Once the operation completes, the caller should
         /// no longer attempt to write to the stream. For example, the
         /// `TcpStream` implementation will issue a `shutdown(Write)` sys call.
         ///

data/rust-vendor/tokio/src/io/util/write_buf.rs

@@ -3,7 +3,7 @@ use crate::io::AsyncWrite;
 use bytes::Buf;
 use pin_project_lite::pin_project;
 use std::future::Future;
-use std::io;
+use std::io::{self, IoSlice};
 use std::marker::PhantomPinned;
 use std::pin::Pin;
 use std::task::{ready, Context, Poll};
@@ -42,13 +42,22 @@ where
     type Output = io::Result<usize>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        const MAX_VECTOR_ELEMENTS: usize = 64;
+
         let me = self.project();
 
         if !me.buf.has_remaining() {
             return Poll::Ready(Ok(0));
         }
 
-        let n = ready!(Pin::new(me.writer).poll_write(cx, me.buf.chunk()))?;
+        let n = if me.writer.is_write_vectored() {
+            let mut slices = [IoSlice::new(&[]); MAX_VECTOR_ELEMENTS];
+            let cnt = me.buf.chunks_vectored(&mut slices);
+            ready!(Pin::new(&mut *me.writer).poll_write_vectored(cx, &slices[..cnt]))?
+        } else {
+            ready!(Pin::new(&mut *me.writer).poll_write(cx, me.buf.chunk()))?
+        };
+
         me.buf.advance(n);
         Poll::Ready(Ok(n))
     }

data/rust-vendor/tokio/src/lib.rs

@@ -320,7 +320,7 @@
 //! Beware though that this will pull in many extra dependencies that you may not
 //! need.
 //!
-//! - `full`: Enables all features listed below except `test-util` and `tracing`.
+//! - `full`: Enables all features listed below except `test-util` and unstable features.
 //! - `rt`: Enables `tokio::spawn`, the current-thread scheduler,
 //!   and non-scheduler utilities.
 //! - `rt-multi-thread`: Enables the heavier, multi-threaded, work-stealing scheduler.
@@ -330,7 +330,7 @@
 //!   `UdpSocket`, as well as (on Unix-like systems) `AsyncFd` and (on
 //!   FreeBSD) `PollAio`.
 //! - `time`: Enables `tokio::time` types and allows the schedulers to enable
-//!   the built in timer.
+//!   the built-in timer.
 //! - `process`: Enables `tokio::process` types.
 //! - `macros`: Enables `#[tokio::main]` and `#[tokio::test]` macros.
 //! - `sync`: Enables all `tokio::sync` types.
@@ -351,16 +351,10 @@
 //! Some feature flags are only available when specifying the `tokio_unstable` flag:
 //!
 //! - `tracing`: Enables tracing events.
+//! - `io-uring`: Enables `io-uring` (Linux only).
+//! - `taskdump`: Enables `taskdump` (Linux only).
 //!
-//! Likewise, some parts of the API are only available with the same flag:
-//!
-//! - [`task::Builder`]
-//! - Some methods on [`task::JoinSet`]
-//! - [`runtime::RuntimeMetrics`]
-//! - [`runtime::Builder::on_task_spawn`]
-//! - [`runtime::Builder::on_task_terminate`]
-//! - [`runtime::Builder::unhandled_panic`]
-//! - [`runtime::TaskMeta`]
+//! Likewise, this flag enables access to unstable APIs.
 //!
 //! This flag enables **unstable** features. The public API of these features
 //! may break in 1.x releases. To enable these features, the `--cfg
@@ -555,6 +549,11 @@ cfg_not_sync! {
     mod sync;
 }
 
+// Currently, task module does not expose any public API outside `rt`
+// feature, so we mark it in the docs. This happens only to docs to
+// avoid introducing breaking changes by restricting the visibility
+// of the task module.
+#[cfg_attr(docsrs, doc(cfg(feature = "rt")))]
 pub mod task;
 cfg_rt! {
     pub use task::spawn;
@@ -565,10 +564,6 @@ cfg_time! {
 }
 
 mod trace {
-    use std::future::Future;
-    use std::pin::Pin;
-    use std::task::{Context, Poll};
-
     cfg_taskdump! {
         pub(crate) use crate::runtime::task::trace::trace_leaf;
     }
@@ -582,19 +577,8 @@ mod trace {
     }
 
     #[cfg_attr(not(feature = "sync"), allow(dead_code))]
-    pub(crate) fn async_trace_leaf() -> impl Future<Output = ()> {
-        struct Trace;
-
-        impl Future for Trace {
-            type Output = ();
-
-            #[inline(always)]
-            fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
-                trace_leaf(cx)
-            }
-        }
-
-        Trace
+    pub(crate) async fn async_trace_leaf() {
+        std::future::poll_fn(trace_leaf).await
     }
 }
 

data/rust-vendor/tokio/src/macros/select.rs

@@ -615,9 +615,7 @@ doc! {macro_rules! select {
 
         // `tokio::macros::support` is a public, but doc(hidden) module
         // including a re-export of all types needed by this macro.
-        use $crate::macros::support::Future;
         use $crate::macros::support::Pin;
-        use $crate::macros::support::Poll::{Ready, Pending};
 
         const BRANCHES: u32 = $crate::count!( $($count)* );
 
@@ -704,9 +702,9 @@ doc! {macro_rules! select {
                                 let mut fut = unsafe { Pin::new_unchecked(fut) };
 
                                 // Try polling it
-                                let out = match Future::poll(fut, cx) {
-                                    Ready(out) => out,
-                                    Pending => {
+                                let out = match $crate::macros::support::Future::poll(fut, cx) {
+                                    $crate::macros::support::Poll::Ready(out) => out,
+                                    $crate::macros::support::Poll::Pending => {
                                         // Track that at least one future is
                                         // still pending and continue polling.
                                         is_pending = true;
@@ -727,7 +725,7 @@ doc! {macro_rules! select {
                                 }
 
                                 // The select is complete, return the value
-                                return Ready($crate::select_variant!(__tokio_select_util::Out, ($($skip)*))(out));
+                                return $crate::macros::support::Poll::Ready($crate::select_variant!(__tokio_select_util::Out, ($($skip)*))(out));
                             }
                         )*
                         _ => unreachable!("reaching this means there probably is an off by one bug"),
@@ -735,10 +733,10 @@ doc! {macro_rules! select {
                 }
 
                 if is_pending {
-                    Pending
+                    $crate::macros::support::Poll::Pending
                 } else {
                     // All branches have been disabled.
-                    Ready(__tokio_select_util::Out::Disabled)
+                    $crate::macros::support::Poll::Ready(__tokio_select_util::Out::Disabled)
                 }
             }).await
         };

data/rust-vendor/tokio/src/net/tcp/socket.rs

@@ -429,17 +429,41 @@ impl TcpSocket {
     /// > it. Rely on the `shutdown()`-followed-by-`read()`-eof technique instead.
     /// >
     /// > From [The ultimate `SO_LINGER` page, or: why is my tcp not reliable](https://blog.netherlabs.nl/articles/2009/01/18/the-ultimate-so_linger-page-or-why-is-my-tcp-not-reliable)
+    ///
+    /// Although this method is deprecated, it will not be removed from Tokio.
+    ///
+    /// Note that the special case of setting `SO_LINGER` to zero does not lead to blocking. Tokio
+    /// provides [`set_zero_linger`](Self::set_zero_linger) for this purpose.
     #[deprecated = "`SO_LINGER` causes the socket to block the thread on drop"]
     pub fn set_linger(&self, dur: Option<Duration>) -> io::Result<()> {
         self.inner.set_linger(dur)
     }
 
+    /// Sets a linger duration of zero on this socket by setting the `SO_LINGER` option.
+    ///
+    /// This causes the connection to be forcefully aborted ("abortive close") when the socket is
+    /// dropped or closed. Instead of the normal TCP shutdown handshake (`FIN`/`ACK`), a TCP `RST`
+    /// (reset) segment is sent to the peer, and the socket immediately discards any unsent data
+    /// residing in the socket send buffer. This prevents the socket from entering the `TIME_WAIT`
+    /// state after closing it.
+    ///
+    /// This is a destructive action. Any data currently buffered by the OS but not yet transmitted
+    /// will be lost. The peer will likely receive a "Connection Reset" error rather than a clean
+    /// end-of-stream.
+    ///
+    /// See the documentation for [`set_linger`](Self::set_linger) for additional details on how
+    /// `SO_LINGER` works.
+    pub fn set_zero_linger(&self) -> io::Result<()> {
+        self.inner.set_linger(Some(Duration::ZERO))
+    }
+
     /// Reads the linger duration for this socket by getting the `SO_LINGER`
     /// option.
     ///
-    /// For more information about this option, see [`set_linger`].
+    /// For more information about this option, see [`set_zero_linger`] and [`set_linger`].
     ///
     /// [`set_linger`]: TcpSocket::set_linger
+    /// [`set_zero_linger`]: TcpSocket::set_zero_linger
     pub fn linger(&self) -> io::Result<Option<Duration>> {
         self.inner.linger()
     }