update a chunk of stuff to the hyper release

Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com>

src/bin/h2client.rs

@@ -35,7 +35,7 @@ impl Future for Process {
             } else {
                 match futures::ready!(Pin::new(&mut this.body).poll_next(cx)) {
                     Some(Ok(chunk)) => {
-                        this.body.release_capacity().release_capacity(chunk.len())?;
+                        this.body.flow_control().release_capacity(chunk.len())?;
                         this.bytes += chunk.len();
                         // println!("GOT FRAME {}", chunk.len());
                     },

src/bin/h2s-client.rs

@@ -34,7 +34,7 @@ impl Future for Process {
             } else {
                 match futures::ready!(Pin::new(&mut this.body).poll_next(cx)) {
                     Some(Ok(chunk)) => {
-                        this.body.release_capacity().release_capacity(chunk.len())?;
+                        this.body.flow_control().release_capacity(chunk.len())?;
                         this.bytes += chunk.len();
                         // println!("GOT FRAME {}", chunk.len());
                     },

src/bin/h2s-server.rs

@@ -24,12 +24,12 @@ async fn main() -> Result<(), Error> {
 
     let acceptor = Arc::new(acceptor.build());
 
-    let listener = TcpListener::bind(std::net::SocketAddr::from(([127,0,0,1], 8008))).await?;
+    let mut listener = TcpListener::bind(std::net::SocketAddr::from(([127,0,0,1], 8008))).await?;
 
     println!("listening on {:?}", listener.local_addr());
 
-    let mut incoming = listener.incoming();
-    while let Some(socket) = incoming.try_next().await? {
+    loop {
+        let (socket, _addr) = listener.accept().await?;
         tokio::spawn(handle_connection(socket, Arc::clone(&acceptor))
             .map(|res| {
                 if let Err(err) = res {
@@ -37,8 +37,6 @@ async fn main() -> Result<(), Error> {
                 }
             }));
     }
-
-    Ok(())
 }
 
 async fn handle_connection(

src/bin/h2server.rs

@@ -10,12 +10,12 @@ use proxmox_backup::client::pipe_to_stream::PipeToSendStream;
 
 #[tokio::main]
 async fn main() -> Result<(), Error> {
-    let listener = TcpListener::bind(std::net::SocketAddr::from(([127,0,0,1], 8008))).await?;
+    let mut listener = TcpListener::bind(std::net::SocketAddr::from(([127,0,0,1], 8008))).await?;
 
     println!("listening on {:?}", listener.local_addr());
 
-    let mut incoming = listener.incoming();
-    while let Some(socket) = incoming.try_next().await? {
+    loop {
+        let (socket, _addr) = listener.accept().await?;
         tokio::spawn(handle_connection(socket)
             .map(|res| {
                 if let Err(err) = res {
@@ -23,8 +23,6 @@ async fn main() -> Result<(), Error> {
                 }
             }));
     }
-
-    Ok(())
 }
 
 async fn handle_connection<T: AsyncRead + AsyncWrite + Unpin>(socket: T) -> Result<(), Error> {

src/bin/proxmox-backup-api.rs

@@ -52,8 +52,9 @@ async fn run() -> Result<(), Error> {
     let server = daemon::create_daemon(
         ([127,0,0,1], 82).into(),
         move |listener, ready| {
+            let incoming = proxmox_backup::tools::async_io::StaticIncoming::from(listener);
             Ok(ready
-                .and_then(|_| hyper::Server::builder(listener.incoming())
+                .and_then(|_| hyper::Server::builder(incoming)
                     .serve(rest_server)
                     .with_graceful_shutdown(server::shutdown_future())
                     .map_err(Error::from)

src/bin/proxmox-backup-client.rs

@@ -186,7 +186,9 @@ async fn backup_directory<P: AsRef<Path>>(
 
     // spawn chunker inside a separate task so that it can run parallel
     tokio::spawn(async move {
-        let _ = tx.send_all(&mut chunk_stream).await;
+        while let Some(v) = chunk_stream.next().await {
+            let _ = tx.send(v).await;
+        }
     });
 
     let stats = client
@@ -210,7 +212,7 @@ async fn backup_image<P: AsRef<Path>>(
 
     let file = tokio::fs::File::open(path).await?;
 
-    let stream = tokio::codec::FramedRead::new(file, tokio::codec::BytesCodec::new())
+    let stream = tokio_util::codec::FramedRead::new(file, tokio_util::codec::BytesCodec::new())
         .map_err(Error::from);
 
     let stream = FixedChunkStream::new(stream, chunk_size.unwrap_or(4*1024*1024));
@@ -2443,8 +2445,9 @@ We do not extraxt '.pxar' archives when writing to stdandard output.
 }
 
 fn async_main<F: Future>(fut: F) -> <F as Future>::Output {
-    let rt = tokio::runtime::Runtime::new().unwrap();
+    let mut rt = tokio::runtime::Runtime::new().unwrap();
     let ret = rt.block_on(fut);
-    rt.shutdown_now();
+    // This does not exist anymore. We need to actually stop our runaways instead...
+    // rt.shutdown_now();
     ret
 }

src/bin/proxmox-backup-proxy.rs

@@ -66,10 +66,9 @@ async fn run() -> Result<(), Error> {
     let server = daemon::create_daemon(
         ([0,0,0,0,0,0,0,0], 8007).into(),
         |listener, ready| {
-            let connections = listener
-                .incoming()
+            let connections = proxmox_backup::tools::async_io::StaticIncoming::from(listener)
                 .map_err(Error::from)
-                .try_filter_map(move |sock| {
+                .try_filter_map(move |(sock, _addr)| {
                     let acceptor = Arc::clone(&acceptor);
                     async move {
                         sock.set_nodelay(true).unwrap();
@@ -81,6 +80,7 @@ async fn run() -> Result<(), Error> {
                         )
                     }
                 });
+            let connections = proxmox_backup::tools::async_io::HyperAccept(connections);
 
             Ok(ready
                 .and_then(|_| hyper::Server::builder(connections)

src/bin/test_chunk_speed2.rs

@@ -23,7 +23,7 @@ async fn run() -> Result<(), Error> {
 
     let file = tokio::fs::File::open("random-test.dat").await?;
 
-    let stream = tokio::codec::FramedRead::new(file, tokio::codec::BytesCodec::new())
+    let stream = tokio_util::codec::FramedRead::new(file, tokio_util::codec::BytesCodec::new())
         .map_ok(|bytes| bytes.to_vec())
         .map_err(Error::from);