1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
/*! Builders for raw requests. */ use std::marker::PhantomData; use client::{Client, Sender}; use client::requests::{HttpRequest, RequestBuilder}; /** A raw request builder that can be configured before sending. Call [`Client.request`][Client.request] to get an `IndexRequest`. The `send` method will either send the request synchronously or asynchronously, depending on the `Client` it was created from. [Client.request]: ../../struct.Client.html#raw-request */ pub type RawRequestBuilder<TSender, TRequest, TBody> = RequestBuilder<TSender, RawRequestInner<TRequest, TBody>>; #[doc(hidden)] pub struct RawRequestInner<TRequest, TBody> { req: TRequest, _marker: PhantomData<TBody>, } impl<TRequest, TBody> RawRequestInner<TRequest, TBody> { pub(crate) fn new(req: TRequest) -> Self { RawRequestInner { req: req, _marker: PhantomData, } } } /** # Raw request */ impl<TSender> Client<TSender> where TSender: Sender, { /** 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], which includes the endpoint types in the [`endpoints`][endpoints-mod] module. # Examples Send a cluster ping and read the returned metadata: ```no_run # extern crate elastic; # use elastic::prelude::*; # fn main() { run().unwrap() } # fn run() -> Result<(), Box<::std::error::Error>> { # let client = SyncClientBuilder::new().build()?; // `PingRequest` implements `Into<HttpRequest>` let req = PingRequest::new(); // Turn the `PingRequest` into a `RequestBuilder` let builder = client.request(req); // Send the `RequestBuilder` and parse as a `PingResponse` let ping = builder.send()?.into_response::<PingResponse>()?; println!("cluster: {}", ping.name()); # Ok(()) # } ``` [HttpRequest]: requests/struct.HttpRequest.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> where TRequest: Into<HttpRequest<'static, TBody>>, TBody: Into<TSender::Body>, { RequestBuilder::new(self.clone(), None, RawRequestInner::new(req)) } } impl<TSender, TRequest, TBody> RawRequestBuilder<TSender, TRequest, TBody> where TSender: Sender, TRequest: Into<HttpRequest<'static, TBody>>, TBody: Into<<TSender>::Body>, { /** Send a `RawRequestBuilder`. If this request is for a [`SyncClient`][SyncClient], then `send` will block the current thread until a response arrives and is deserialised. The returned [`SyncResponseBuilder`][SyncResponseBuilder] can be used to parse the response. If this request is for an [`AsyncClient`][AsyncClient], then `send` will return a future that will resolve to the deserialised index response. The returned [`AsyncResponseBuilder`][AsyncResponseBuilder] can be used to parse the response. # Examples Send a raw request synchronously and parse it to a concrete response type: ```no_run # extern crate elastic; # extern crate serde_json; # use serde_json::Value; # use elastic::prelude::*; # fn main() { run().unwrap() } # fn run() -> Result<(), Box<::std::error::Error>> { # let client = SyncClientBuilder::new().build()?; let response = client.request(SimpleSearchRequest::for_index_ty("myindex", "mytype")) .send()? .into_response::<SearchResponse<Value>>()?; // Iterate through the hits (of type `MyType`) for hit in response.hits() { println!("{:?}", hit); } # Ok(()) # } ``` Send a raw request asynchronously and parse it to a concrete response type: ```no_run # extern crate tokio_core; # extern crate futures; # extern crate elastic; # extern crate serde_json; # use serde_json::Value; # use elastic::prelude::*; # use futures::Future; # fn main() { run().unwrap() } # fn run() -> Result<(), Box<::std::error::Error>> { # let core = tokio_core::reactor::Core::new()?; # let client = AsyncClientBuilder::new().build(&core.handle())?; let future = client.request(SimpleSearchRequest::for_index_ty("myindex", "mytype")) .send() .and_then(|res| res.into_response::<SearchResponse<Value>>()); future.and_then(|response| { // Iterate through the hits (of type `MyType`) for hit in response.hits() { println!("{:?}", hit); } Ok(()) }); # Ok(()) # } ``` [SyncClient]: ../../type.SyncClient.html [SyncResponseBuilder]: ../../responses/struct.SyncResponseBuilder.html [AsyncClient]: ../../type.AsyncClient.html [AsyncResponseBuilder]: ../../responses/struct.AsyncResponseBuilder.html */ pub fn send(self) -> TSender::Response { let client = self.client; let req = self.inner.req.into(); let params = self.params.as_ref().unwrap_or(&client.params); client.sender.send(req, params) } }