Merge pull request #1613 from input-output-hk/actix_2_0

Upgrade Actix-web to 2.0

Author: vincenthz

Cargo.lock

@@ -12,10 +12,10 @@ Midgard Serpent
 edition = "2018"
 
 [dependencies]
-actix-cors = "0.1.0"
-actix-rt = "0.2.6"
-actix-threadpool = "0.1.2"
-actix-web = { version = "1.0.9", default-features = false, features = [ "rust-tls" ] }
+actix-cors = "0.2.0"
+actix-rt = "^1.0.0"
+actix-threadpool = "^0.3.1"
+actix-web = { version = "2.0.0", default-features = false, features = [ "rustls" ] }
 juniper = "0.13.1"
 bincode = "1.0.1"
 bytes = "0.4"
@@ -30,6 +30,7 @@ cardano-legacy-address = { path = "../chain-deps/cardano-legacy-address" }
 imhamt = { path = "../chain-deps/imhamt" }
 error-chain = "0.12"
 futures    = "0.1"
+futures03 = { package = "futures", version = "0.3.1", features = ["compat"] }
 http = "0.1.16"
 humantime = "1.2"
 hyper = "0.12"
@@ -40,7 +41,7 @@ network-core    = { path = "../chain-deps/network-core" }
 network-grpc    = { path = "../chain-deps/network-grpc" }
 poldercast = "0.11"
 rand = "0.7"
-rustls = "0.15.2"
+rustls = "^0.16.0 "
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0.38"

jormungandr/Cargo.toml

@@ -3,50 +3,43 @@ use actix_web::error::{ErrorBadRequest, ErrorInternalServerError, ErrorServiceUn
 use actix_web::web::{Data, Json};
 use actix_web::{http, Error, HttpResponse, Responder};
 
-use futures::Future;
-
 use crate::explorer::graphql::GraphQLRequest;
 pub use crate::rest::Context;
 
-macro_rules! ActixFuture {
-    () => { impl Future<Item = impl Responder + 'static, Error = impl Into<Error> + 'static> + 'static }
-}
-
-pub fn graphiql(_context: Data<Context>) -> impl Responder {
+pub async fn graphiql() -> impl Responder {
     let html = juniper::http::graphiql::graphiql_source("/explorer/graphql");
     HttpResponse::Ok()
         .content_type("text/html; charset=utf-8")
         .body(html)
 }
 
-pub fn graphql(context: Data<Context>, data: Json<GraphQLRequest>) -> ActixFuture!() {
-    context
-        .try_full_fut()
-        .and_then(|context| {
-            context
-                .explorer
-                .clone()
-                .ok_or(ErrorServiceUnavailable("Explorer not enabled"))
-        })
-        .and_then(move |explorer|
-            // Run the query in a threadpool, as Juniper is synchronous
-            actix_threadpool::run(move || {
-                let response = data.execute(&explorer.schema, &explorer.context());
-                match response.is_ok() {
-                    true => serde_json::to_string(&response).map(Some),
-                    false => Ok(None),
-                }})
-            .then(|res| match res {
-                Ok(Some(response)) => Ok(response),
-                Ok(None) => Err(ErrorBadRequest("Error processing query")),
-                Err(BlockingError::Canceled) => Err(ErrorInternalServerError("Data execution cancelled")),
-                Err(BlockingError::Error(serde_err)) => Err(ErrorInternalServerError(serde_err)),
-            }
-        ))
-        .map(|response| {
-            HttpResponse::Ok()
-                .header(http::header::CONTENT_TYPE, "application/json")
-                .body(response)
-        })
-        .map_err(|err| ErrorInternalServerError(err))
+pub async fn graphql(
+    context: Data<Context>,
+    data: Json<GraphQLRequest>,
+) -> Result<impl Responder, Error> {
+    let explorer = context
+        .try_full()?
+        .explorer
+        .clone()
+        .ok_or(ErrorServiceUnavailable("Explorer not enabled"))?;
+    // Run the query in a threadpool, as Juniper is synchronous
+    let res = actix_threadpool::run(move || {
+        let response = data.execute(&explorer.schema, &explorer.context());
+        match response.is_ok() {
+            true => serde_json::to_string(&response).map(Some),
+            false => Ok(None),
+        }
+    })
+    .await;
+    let response = match res {
+        Ok(Some(response)) => response,
+        Ok(None) => return Err(ErrorBadRequest("Error processing query")),
+        Err(BlockingError::Canceled) => {
+            return Err(ErrorInternalServerError("Data execution cancelled"))
+        }
+        Err(BlockingError::Error(serde_err)) => return Err(ErrorInternalServerError(serde_err)),
+    };
+    Ok(HttpResponse::Ok()
+        .header(http::header::CONTENT_TYPE, "application/json")
+        .body(response))
 }

jormungandr/src/rest/explorer/handlers.rs

@@ -7,6 +7,6 @@ use actix_web::{
 
 pub fn service(root_path: &str) -> impl HttpServiceFactory {
     scope(root_path)
-        .route("/graphql", post().to_async(handlers::graphql))
+        .route("/graphql", post().to(handlers::graphql))
         .route("/graphiql", get().to(handlers::graphiql))
 }

jormungandr/src/rest/explorer/mod.rs

@@ -10,7 +10,6 @@ pub use self::server::{Error, Server, ServerStopper};
 use actix_web::error::{Error as ActixError, ErrorInternalServerError, ErrorServiceUnavailable};
 use actix_web::web::ServiceConfig;
 
-use futures::{Future, IntoFuture};
 use slog::Logger;
 use std::sync::{Arc, RwLock};
 
@@ -49,10 +48,6 @@ impl Context {
         *self.full.write().expect("Context state poisoned") = Some(Arc::new(full_context));
     }
 
-    pub fn try_full_fut(&self) -> impl Future<Item = Arc<FullContext>, Error = ActixError> {
-        self.try_full().into_future()
-    }
-
     pub fn try_full(&self) -> Result<Arc<FullContext>, ActixError> {
         self.full
             .read()

jormungandr/src/rest/mod.rs

@@ -6,7 +6,7 @@ mod error;
 pub use self::error::Error;
 
 use crate::settings::start::{Cors as CorsConfig, Rest, Tls as TlsConfig};
-use actix_cors::Cors;
+use actix_cors::{Cors, CorsFactory};
 use actix_rt::System;
 use actix_web::{dev::Server as ActixServer, web::ServiceConfig, App, HttpServer};
 use futures::sync::oneshot::{self, Receiver};
@@ -120,26 +120,26 @@ fn load_priv_key(path: &str) -> ServerResult<PrivateKey> {
     Ok(priv_keys.pop().unwrap())
 }
 
-fn create_cors_factory(cors_cfg: CorsConfig) -> impl Fn() -> Cors + Clone + Send + 'static {
+fn create_cors_factory(cors_cfg: CorsConfig) -> impl Fn() -> CorsFactory + Clone + Send + 'static {
     let cors_cfg_shared = Arc::new(cors_cfg);
     move || create_cors(&*cors_cfg_shared)
 }
 
-fn create_cors(cors_cfg: &CorsConfig) -> Cors {
+fn create_cors(cors_cfg: &CorsConfig) -> CorsFactory {
     let mut cors = Cors::new();
     if let Some(max_age_secs) = cors_cfg.max_age_secs {
         cors = cors.max_age(max_age_secs as usize);
     }
     for origin in &cors_cfg.allowed_origins {
         cors = cors.allowed_origin(origin);
     }
-    cors
+    cors.finish()
 }
 
 fn start_server_curr_sys(
     address: impl ToSocketAddrs,
     tls_config_opt: Option<ServerConfig>,
-    cors_factory: Option<impl Fn() -> Cors + Clone + Send + 'static>,
+    cors_factory: Option<impl Fn() -> CorsFactory + Clone + Send + 'static>,
     app_config: impl FnOnce(&mut ServiceConfig) + Clone + Send + 'static,
 ) -> ServerResult<ActixServer> {
     // This macro-based pseud generic is needed because addition of CORS changes server type.
@@ -163,8 +163,8 @@ fn start_server_curr_sys(
                 None => server.bind(address),
             }
             .map_err(Error::BindFailed)?;
-            let server_addr = server.start();
-            Ok(server_addr)
+            let actix_server = server.run();
+            Ok(actix_server)
         }}
     }