GRIN/grin-node
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Upgrade Tokio to v1.x and Hyper to v0.14 (#3804)

Browse Source 
* update of tokio and related dependencies to 1.x

* update to hyper 0.14

* fixes to http connector for tests
This commit is contained in:
Yeastplume
2025-03-08 11:54:13 +00:00
committed by GitHub
parent b93d88b58c
commit 8e79856168
12 changed files with 324 additions and 461 deletions
Download Patch File Download Diff File Expand all files Collapse all files
api/Cargo.toml
+9 -7
View File
@@ -11,7 +11,7 @@ edition = "2018"
[dependencies]
easy-jsonrpc-mw = "0.5.4"
hyper = "0.13"
hyper = { version = "0.14", features = ["full"] }
lazy_static = "1"
regex = "1"
ring = "0.16"
@@ -20,15 +20,17 @@ serde_derive = "1"
serde_json = "1"
thiserror = "1"
log = "0.4"
tokio = { version = "0.2", features = ["full"] }
tokio-rustls = "0.13"
tokio = { version = "1", features = ["full"] }
tokio-rustls = "0.23"
http = "0.2"
hyper-rustls = "0.20"
hyper-timeout = "0.3"
hyper-rustls = "0.23"
hyper-timeout = "0.4"
futures = "0.3"
rustls = "0.17"
rustls = "0.20"
rustls-pemfile = "1.0"
async-stream = "0.3"
url = "2.1"
bytes = "0.5"
bytes = "1"
grin_core = { path = "../core", version = "5.4.0-alpha.0" }
grin_chain = { path = "../chain", version = "5.4.0-alpha.0" }
api/src/client.rs
+8 -4
View File
@@ -216,7 +216,12 @@ where
}
async fn send_request_async(req: Request<Body>, timeout: TimeOut) -> Result<String, Error> {
let https = hyper_rustls::HttpsConnector::new();
let https = hyper_rustls::HttpsConnectorBuilder::new()
.with_native_roots()
.https_or_http()
.enable_http1()
.build();
let (connect, read, write) = (
Some(timeout.connect),
Some(timeout.read),
@@ -242,7 +247,7 @@ async fn send_request_async(req: Request<Body>, timeout: TimeOut) -> Result<Stri
.into());
}
let raw = body::to_bytes(resp)
let raw = body::to_bytes(resp.into_body())
.await
.map_err(|e| Error::RequestError(format!("Cannot read response body: {}", e)))?;
@@ -250,8 +255,7 @@ async fn send_request_async(req: Request<Body>, timeout: TimeOut) -> Result<Stri
}
pub fn send_request(req: Request<Body>, timeout: TimeOut) -> Result<String, Error> {
let mut rt = Builder::new()
.basic_scheduler()
let rt = Builder::new_current_thread()
.enable_all()
.build()
.map_err(|e| Error::RequestError(format!("{}", e)))?;
api/src/json_rpc.rs
+3 -3
View File
@@ -97,7 +97,7 @@ pub enum Error {
/// Json error
Json(serde_json::Error),
/// Client error
Hyper(hyper::error::Error),
Hyper(hyper::Error),
/// Error response
Rpc(RpcError),
/// Response to a request did not have the expected nonce
@@ -120,8 +120,8 @@ impl From<serde_json::Error> for Error {
}
}
impl From<hyper::error::Error> for Error {
fn from(e: hyper::error::Error) -> Error {
impl From<hyper::Error> for Error {
fn from(e: hyper::Error) -> Error {
Error::Hyper(e)
}
}
api/src/rest.rs
+33 -16
View File
@@ -21,11 +21,10 @@
use crate::router::{Handler, HandlerObj, ResponseFuture, Router, RouterError};
use crate::web::response;
use futures::channel::oneshot;
use futures::TryStreamExt;
use hyper::server::accept;
use hyper::service::make_service_fn;
use hyper::{Body, Request, Server, StatusCode};
use rustls::internal::pemfile;
use rustls_pemfile as pemfile;
use std::convert::Infallible;
use std::fs::File;
use std::net::SocketAddr;
@@ -33,7 +32,6 @@ use std::sync::Arc;
use std::{io, thread};
use tokio::net::TcpListener;
use tokio::runtime::Runtime;
use tokio::stream::StreamExt;
use tokio_rustls::TlsAcceptor;
/// Errors that can be returned by an ApiEndpoint implementation.
@@ -83,8 +81,10 @@ impl TLSConfig {
})?;
let mut reader = io::BufReader::new(certfile);
pemfile::certs(&mut reader)
.map_err(|_| Error::Internal("failed to load certificate".to_string()))
let certs = pemfile::certs(&mut reader)
.map_err(|_| Error::Internal("failed to load certificate".to_string()))?;
Ok(certs.into_iter().map(rustls::Certificate).collect())
}
fn load_private_key(&self) -> Result<rustls::PrivateKey, Error> {
@@ -97,15 +97,19 @@ impl TLSConfig {
if keys.len() != 1 {
return Err(Error::Internal("expected a single private key".to_string()));
}
Ok(keys[0].clone())
Ok(rustls::PrivateKey(keys[0].clone()))
}
pub fn build_server_config(&self) -> Result<Arc<rustls::ServerConfig>, Error> {
let certs = self.load_certs()?;
let key = self.load_private_key()?;
let mut cfg = rustls::ServerConfig::new(rustls::NoClientAuth::new());
cfg.set_single_cert(certs, key)
let cfg = rustls::ServerConfig::builder()
.with_safe_defaults()
.with_no_client_auth()
.with_single_cert(certs, key)
.map_err(|e| Error::Internal(format!("set single certificate failed {}", e)))?;
Ok(Arc::new(cfg))
}
}
@@ -175,7 +179,7 @@ impl ApiServer {
server.await
};
let mut rt = Runtime::new()
let rt = Runtime::new()
.map_err(|e| eprintln!("HTTP API server error: {}", e))
.unwrap();
if let Err(e) = rt.block_on(server) {
@@ -214,13 +218,26 @@ impl ApiServer {
.name("apis".to_string())
.spawn(move || {
let server = async move {
let mut listener = TcpListener::bind(&addr).await.expect("failed to bind");
let listener = listener
.incoming()
.and_then(move |s| acceptor.accept(s))
.filter(|r| r.is_ok());
let listener = TcpListener::bind(&addr).await.expect("failed to bind");
let server = Server::builder(accept::from_stream(listener))
let tls_stream = async_stream::stream! {
loop {
let (socket, _addr) = match listener.accept().await {
Ok(conn) => conn,
Err(e) => {
eprintln!("Error accepting connection: {}", e);
continue;
}
};
match acceptor.accept(socket).await {
Ok(stream) => yield Ok::<_, std::io::Error>(stream),
Err(_) => continue,
}
}
};
let server = Server::builder(accept::from_stream(tls_stream))
.serve(make_service_fn(move |_| {
let router = router.clone();
async move { Ok::<_, Infallible>(router) }
@@ -232,7 +249,7 @@ impl ApiServer {
server.await
};
let mut rt = Runtime::new()
let rt = Runtime::new()
.map_err(|e| eprintln!("HTTP API server error: {}", e))
.unwrap();
if let Err(e) = rt.block_on(server) {
api/src/web.rs
+3 -2
View File
@@ -1,12 +1,12 @@
use crate::rest::*;
use crate::router::ResponseFuture;
use bytes::Buf;
use futures::future::ok;
use hyper::body;
use hyper::{Body, Request, Response, StatusCode};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fmt::Debug;
use std::io::Cursor;
use url::form_urlencoded;
/// Parse request body
@@ -18,7 +18,8 @@ where
.await
.map_err(|e| Error::RequestError(format!("Failed to read request: {}", e)))?;
serde_json::from_reader(raw.bytes())
let cursor = Cursor::new(raw);
serde_json::from_reader(cursor)
.map_err(|e| Error::RequestError(format!("Invalid request body: {}", e)))
}