index-node: Refactor away IndexNodeResponse

Author: leoyvens

graph/src/components/server/query.rs

@@ -1,6 +1,5 @@
 use crate::data::query::QueryError;
 use futures::prelude::*;
-use serde::ser::*;
 use std::error::Error;
 use std::fmt;
 
@@ -48,22 +47,6 @@ impl Error for GraphQLServerError {
     }
 }
 
-impl Serialize for GraphQLServerError {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if let GraphQLServerError::QueryError(ref e) = *self {
-            serializer.serialize_some(e)
-        } else {
-            let mut map = serializer.serialize_map(Some(1))?;
-            let msg = format!("{}", self);
-            map.serialize_entry("message", msg.as_str())?;
-            map.end()
-        }
-    }
-}
-
 /// Common trait for GraphQL server implementations.
 pub trait GraphQLServer {
     type ServeError;

server/index-node/src/lib.rs

@@ -1,11 +1,9 @@
 mod request;
 mod resolver;
-mod response;
 mod schema;
 mod server;
 mod service;
 
 pub use self::request::IndexNodeRequest;
-pub use self::response::IndexNodeResponse;
 pub use self::server::IndexNodeServer;
 pub use self::service::{IndexNodeService, IndexNodeServiceResponse};

server/index-node/src/response.rs

@@ -3,15 +3,13 @@ use hyper::service::Service;
 use hyper::{Body, Method, Request, Response, StatusCode};
 use std::task::Context;
 use std::task::Poll;
-use std::time::Instant;
 
 use graph::components::server::query::GraphQLServerError;
 use graph::prelude::*;
 use graph_graphql::prelude::{execute_query, Query as PreparedQuery, QueryExecutionOptions};
 
 use crate::request::IndexNodeRequest;
 use crate::resolver::IndexNodeResolver;
-use crate::response::IndexNodeResponse;
 use crate::schema::SCHEMA;
 
 /// An asynchronous response to a GraphQL request.
@@ -95,14 +93,11 @@ where
     fn handle_graphql_query(&self, request_body: Body) -> IndexNodeServiceResponse {
         let logger = self.logger.clone();
         let store = self.store.clone();
-        let result_logger = self.logger.clone();
         let graphql_runner = self.graphql_runner.clone();
 
         // Obtain the schema for the index node GraphQL API
         let schema = SCHEMA.clone();
 
-        let start = Instant::now();
-
         hyper::body::to_bytes(request_body)
             .map_err(|_| GraphQLServerError::InternalError("Failed to read request body".into()))
             .and_then(move |body| IndexNodeRequest::new(body, schema).compat())
@@ -128,18 +123,8 @@ where
                     futures03::future::ok(QueryResult::from(result))
                 })
             })
-            .then(move |result| {
-                let elapsed = start.elapsed().as_millis();
-                if let Err(e) = &result {
-                    error!(
-                        result_logger,
-                        "GraphQL query failed";
-                        "error" => e.to_string(),
-                        "query_time_ms" => elapsed,
-                        "code" => LogCode::GraphQlQueryFailure,
-                    )
-                }
-                IndexNodeResponse::new(result).compat()
+            .map_ok(|result| {
+                result.as_http_response()
             })
             .boxed()
     }