Add raw pre_send method (#285)

* add raw pre_send method

* introduce `http` crate for shared HTTP types

Author: KodrAus

examples/account_sample/src/ops/commands/ensure_bank_index_exists.rs

@@ -4,6 +4,7 @@ use serde_json::Error as JsonError;
 use elastic::client::requests::IndicesExistsRequest;
 use elastic::client::responses::CommandResponse;
 use elastic::Error as ResponseError;
+use elastic::http::StatusCode;
 
 use model;
 
@@ -19,9 +20,9 @@ impl EnsureBankIndexExists for Client {
 
         match exists.status() {
             // Success, do nothing
-            200 => (),
+            StatusCode::OK => (),
             // Not found, create the index
-            404 => {
+            StatusCode::NOT_FOUND => {
                 self.io
                     .index_create(model::index::name())
                     .body(model::index::body().to_string())

examples/account_sample/src/ops/commands/put_bulk_accounts.rs

@@ -2,8 +2,9 @@ use std::io::{Error as IoError, Result as IoResult};
 use std::fs::File;
 use std::path::Path;
 use ops::Client;
-use elastic::client::requests::{BulkRequest, SyncBody};
+use elastic::client::requests::BulkRequest;
 use elastic::client::responses::bulk::{BulkErrorsResponse, ErrorItem};
+use elastic::http::SyncBody;
 use elastic::Error as ResponseError;
 
 use model;

src/elastic/Cargo.toml

@@ -20,12 +20,14 @@ log = "~0.3.8"
 uuid = { version = "~0.5.1", features = [ "v4" ] }
 url = "~1.5.1"
 bytes = "~0.4.5"
+http = "~0.1.0"
 serde = "~1"
 serde_json = "~1"
 serde_derive = "~1"
 reqwest = { version = "~0.8.0", features = ["unstable"] }
 futures = "~0.1.16"
 tokio-core = "~0.1.9"
+tokio-io = "~0.1.4"
 futures-cpupool = "~0.1.6"
 fluent_builder = "~0.5"
 

src/elastic/examples/custom_response.rs

@@ -33,15 +33,9 @@ struct Hit {
     #[serde(rename = "_source")] pub source: Value,
 }
 
-// Implement `IsOk` for our custom `SearchResponse` so it can be used in the call to `into_response`.
-impl IsOk for SearchResponse {
-    fn is_ok<B: ResponseBody>(head: HttpResponseHead, body: Unbuffered<B>) -> Result<MaybeOkResponse<B>, ParseError> {
-        match head.status() {
-            200...299 => Ok(MaybeOkResponse::ok(body)),
-            _ => Ok(MaybeOkResponse::err(body)),
-        }
-    }
-}
+// Implement `IsOkOnSuccess` for our custom `SearchResponse` so it can be used in the call to `into_response`.
+// `IsOkOnSuccess` will return `Ok` if the response is in the `200` range.
+impl IsOkOnSuccess for SearchResponse { }
 
 fn run() -> Result<(), Box<Error>> {
     // A reqwest HTTP client and default parameters.

src/elastic/examples/pre_send.rs

@@ -0,0 +1,60 @@
+//! Tweak the raw http request before sending.
+//!
+//! NOTE: This sample expects you have a node running on `localhost:9200`.
+
+extern crate elastic;
+extern crate reqwest;
+extern crate env_logger;
+
+use std::error::Error;
+use std::io::Read;
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
+use elastic::prelude::*;
+use elastic::http::SyncHttpRequest;
+
+fn hash_request(request: &mut SyncHttpRequest) -> Result<(), Box<Error + Send + Sync>> {
+    let &mut SyncHttpRequest { ref mut url, ref mut method, ref mut body, ref mut headers, .. } = request;
+
+    // Read the body into a temporary buffer
+    let mut buffered = Vec::new();
+    if let &mut Some(ref mut body) = body {
+        body.reader().read_to_end(&mut buffered)?;
+    }
+
+    // Access the request data
+    let mut hasher = DefaultHasher::new();
+
+    url.hash(&mut hasher);
+    method.hash(&mut hasher);
+    buffered.hash(&mut hasher);
+    
+    for header in headers.iter() {
+        header.to_string().hash(&mut hasher);
+    }
+    
+    // Add a raw header to the request
+    let hash = hasher.finish();
+    headers.set_raw("X-BadHash", hash.to_string());
+
+    Ok(())
+}
+
+fn run() -> Result<(), Box<Error>> {
+    // A HTTP client and request parameters
+    let client = SyncClientBuilder::new()
+        .pre_send_raw(hash_request)
+        .build()?;
+
+    // Ping the cluster
+    let ping = client.ping().send()?;
+
+    println!("{:?}", ping);
+
+    Ok(())
+}
+
+fn main() {
+    env_logger::init().unwrap();
+    run().unwrap()
+}

src/elastic/examples/raw.rs

@@ -27,7 +27,7 @@ fn run() -> Result<(), Box<Error>> {
 
     // Check if the response is in the 200 range
     match res.status() {
-        200...299 => (),
+        status if status.is_success() => (),
         status => panic!("error: {:?}", status),
     }
 

src/elastic/src/client/requests/async.rs

@@ -10,18 +10,13 @@ use fluent_builder::FluentBuilder;
 use client::Client;
 use client::sender::{AsyncSender, RequestParams, Sender};
 
-pub use elastic_requests::{empty_body, DefaultBody, HttpMethod, HttpRequest, Url};
+pub use elastic_requests::{empty_body, DefaultBody, Endpoint, UrlPath};
 pub use elastic_requests::params;
 pub use elastic_requests::endpoints;
 
 pub use self::params::*;
 pub use self::endpoints::*;
 
-mod sync;
-mod async;
-pub use self::sync::*;
-pub use self::async::*;
-
 pub mod raw;
 pub use self::raw::RawRequestBuilder;
 
@@ -173,7 +168,7 @@ where
     */
     pub fn params<I>(mut self, params: I) -> Self
     where
-        I: Into<RequestParams>
+        I: Into<RequestParams>,
     {
         self.params_builder = self.params_builder.value(params.into());
 

src/elastic/src/client/requests/mod.rs

@@ -7,7 +7,7 @@ use fluent_builder::TryIntoValue;
 
 use client::Client;
 use client::sender::{NextParams, NodeAddresses, SendableRequest, SendableRequestParams, Sender};
-use client::requests::{HttpRequest, RequestBuilder};
+use client::requests::{Endpoint, RequestBuilder};
 
 /**
 A raw request builder that can be configured before sending.
@@ -17,18 +17,18 @@ The `send` method will either send the request synchronously or asynchronously,
 
 [Client.request]: ../../struct.Client.html#raw-request
 */
-pub type RawRequestBuilder<TSender, TRequest, TBody> = RequestBuilder<TSender, RawRequestInner<TRequest, TBody>>;
+pub type RawRequestBuilder<TSender, TEndpoint, TBody> = RequestBuilder<TSender, RawRequestInner<TEndpoint, TBody>>;
 
 #[doc(hidden)]
-pub struct RawRequestInner<TRequest, TBody> {
-    req: TRequest,
+pub struct RawRequestInner<TEndpoint, TBody> {
+    endpoint: TEndpoint,
     _marker: PhantomData<TBody>,
 }
 
-impl<TRequest, TBody> RawRequestInner<TRequest, TBody> {
-    pub(crate) fn new(req: TRequest) -> Self {
+impl<TEndpoint, TBody> RawRequestInner<TEndpoint, TBody> {
+    pub(crate) fn new(endpoint: TEndpoint) -> Self {
         RawRequestInner {
-            req: req,
+            endpoint,
             _marker: PhantomData,
         }
     }
@@ -44,7 +44,7 @@ where
     /**
     Create a [`RawRequestBuilder`][RawRequestBuilder] with this `Client` that can be configured before sending.
 
-    The `request` method accepts any type that can be converted into a [`HttpRequest<'static>`][HttpRequest],
+    The `request` method accepts any type that can be converted into a [`Endpoint<'static>`][Endpoint],
     which includes the endpoint types in the [`endpoints`][endpoints-mod] module.
 
     # Examples
@@ -57,7 +57,7 @@ where
     # fn main() { run().unwrap() }
     # fn run() -> Result<(), Box<::std::error::Error>> {
     # let client = SyncClientBuilder::new().build()?;
-    // `PingRequest` implements `Into<HttpRequest>`
+    // `PingRequest` implements `Into<Endpoint>`
     let req = PingRequest::new();
     
     // Turn the `PingRequest` into a `RequestBuilder`
@@ -71,23 +71,23 @@ where
     # }
     ```
 
-    [HttpRequest]: requests/struct.HttpRequest.html
+    [Endpoint]: requests/struct.Endpoint.html
     [RawRequestBuilder]: requests/raw/type.RawRequestBuilder.html
     [endpoints-mod]: requests/endpoints/index.html
     */
-    pub fn request<TRequest, TBody>(&self, req: TRequest) -> RawRequestBuilder<TSender, TRequest, TBody>
+    pub fn request<TEndpoint, TBody>(&self, endpoint: TEndpoint) -> RawRequestBuilder<TSender, TEndpoint, TBody>
     where
-        TRequest: Into<HttpRequest<'static, TBody>>,
+        TEndpoint: Into<Endpoint<'static, TBody>>,
         TBody: Into<TSender::Body>,
     {
-        RequestBuilder::initial(self.clone(), RawRequestInner::new(req))
+        RequestBuilder::initial(self.clone(), RawRequestInner::new(endpoint))
     }
 }
 
-impl<TSender, TRequest, TBody> RawRequestBuilder<TSender, TRequest, TBody>
+impl<TSender, TEndpoint, TBody> RawRequestBuilder<TSender, TEndpoint, TBody>
 where
     TSender: Sender,
-    TRequest: Into<HttpRequest<'static, TBody>>,
+    TEndpoint: Into<Endpoint<'static, TBody>>,
     TBody: Into<<TSender>::Body> + 'static,
     NodeAddresses<TSender>: NextParams,
     <NodeAddresses<TSender> as NextParams>::Params: Into<TSender::Params> + 'static,
@@ -162,22 +162,18 @@ where
     */
     pub fn send(self) -> TSender::Response {
         let client = self.client;
-        let req = self.inner.req.into();
+        let endpoint = self.inner.endpoint.into();
 
         // Only try fetch a next address if an explicit `RequestParams` hasn't been given
         let params = match self.params_builder.try_into_value() {
-            TryIntoValue::Value(value) => {
-                SendableRequestParams::Value(value)
+            TryIntoValue::Value(value) => SendableRequestParams::Value(value),
+            TryIntoValue::Builder(builder) => SendableRequestParams::Builder {
+                params: client.addresses.next(),
+                builder,
             },
-            TryIntoValue::Builder(builder) => {
-                SendableRequestParams::Builder {
-                    params: client.addresses.next(),
-                    builder,
-                }
-            }
         };
 
-        let req = SendableRequest::new(req, params);
+        let req = SendableRequest::new(endpoint, params);
 
         client.sender.send(req)
     }