Remove sender from SniffedNodes

It's not needed anymore, now that the Sender itself is responsible for querying
for nodes.

src/elastic/src/client/asynchronous.rs

@@ -293,7 +293,7 @@ impl AsyncClientBuilder {
             pre_send: self.pre_send,
         };
 
-        let addresses = self.nodes.build(params, sender.clone());
+        let addresses = self.nodes.build(params);
 
         Ok(AsyncClient {
             sender: sender,

src/elastic/src/client/mod.rs

@@ -634,7 +634,7 @@ tokio::runtime::current_thread::block_on_all(response_future)?;
 #[derive(Clone)]
 pub struct Client<TSender> {
     sender: TSender,
-    addresses: NodeAddresses<TSender>,
+    addresses: NodeAddresses,
 }
 
 impl<TSender> Client<TSender>
@@ -667,7 +667,7 @@ where
     /**
     Creates a new client with a manually created sender and list of node addresses.
     */
-    pub fn from_sender(sender: TSender, addresses: NodeAddresses<TSender>) -> Self {
+    pub fn from_sender(sender: TSender, addresses: NodeAddresses) -> Self {
         Self {
             sender,
             addresses,

src/elastic/src/client/synchronous.rs

@@ -261,7 +261,7 @@ impl SyncClientBuilder {
             pre_send: self.pre_send,
         };
 
-        let addresses = self.nodes.build(params, sender.clone());
+        let addresses = self.nodes.build(params);
 
         Ok(SyncClient {
             sender: sender,

src/elastic/src/http/sender/asynchronous.rs

@@ -199,7 +199,7 @@ impl Sender for AsyncSender {
 
     fn next_params(
         &self,
-        addresses: &NodeAddresses<Self>
+        addresses: &NodeAddresses,
     ) -> Self::Params {
         match addresses {
             NodeAddresses::Static(ref nodes) => PendingParams::new(nodes.next().into_future()),

src/elastic/src/http/sender/mod.rs

@@ -136,7 +136,7 @@ pub trait Sender: Clone {
     */
     fn next_params(
         &self,
-        addresses: &NodeAddresses<Self>
+        addresses: &NodeAddresses,
     ) -> Self::Params;
 }
 /**
@@ -214,21 +214,21 @@ where
 A common container for a source of node addresses.
 */
 #[derive(Clone)]
-pub enum NodeAddresses<TSender> {
+pub enum NodeAddresses {
     /** Static list of nodes */
     Static(StaticNodes),
     /** Fetch set of nodes from a single node of the cluster */
-    Sniffed(SniffedNodes<TSender>),
+    Sniffed(SniffedNodes),
 }
 
-impl<TSender> NodeAddresses<TSender> {
+impl NodeAddresses {
     /** Static set of nodes to connect to */
     pub fn static_nodes(nodes: StaticNodes) -> Self {
         NodeAddresses::Static(nodes)
     }
 
     /** Fetch set of nodes from a single node of the cluster */
-    pub fn sniffed_nodes(nodes: SniffedNodes<TSender>) -> Self {
+    pub fn sniffed_nodes(nodes: SniffedNodes) -> Self {
         NodeAddresses::Sniffed(nodes)
     }
 }
@@ -281,11 +281,10 @@ impl Default for NodeAddressesBuilder {
 
 impl NodeAddressesBuilder {
     /** Builds the node addresses */
-    pub fn build<TSender>(
+    pub fn build(
         self,
         params: PreRequestParams,
-        sender: TSender,
-    ) -> NodeAddresses<TSender> {
+    ) -> NodeAddresses {
         match self {
             NodeAddressesBuilder::Static(nodes) => {
                 let nodes = StaticNodes::round_robin(nodes, params);
@@ -295,7 +294,7 @@ impl NodeAddressesBuilder {
             NodeAddressesBuilder::Sniffed(builder) => {
                 let nodes = builder
                     .into_value(|node| SniffedNodesBuilder::new(node))
-                    .build(params, sender);
+                    .build(params);
 
                 NodeAddresses::sniffed_nodes(nodes)
             }

src/elastic/src/http/sender/sniffed_nodes.rs

@@ -53,7 +53,6 @@ use crate::{
         },
         DefaultBody,
     },
-    private,
 };
 
 /**
@@ -68,8 +67,7 @@ If updating the nodes fails for some reason then the request itself will also fa
 [node info request]: https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster-nodes-info.html
 */
 #[derive(Clone)]
-pub struct SniffedNodes<TSender> {
-    sender: TSender,
+pub struct SniffedNodes {
     refresh_params: RequestParams,
     inner: Arc<RwLock<SniffedNodesInner>>,
 }
@@ -123,15 +121,14 @@ impl SniffedNodesBuilder {
     }
 
     /**
-    Build a cluster sniffer using the given sender and parameters.
+    Build a cluster sniffer using the given parameters.
 
     A `filter_path` url parameter will be added to the `refresh_parameters`.
     */
-    pub fn build<TSender>(
+    pub fn build(
         self,
         base_params: PreRequestParams,
-        sender: TSender,
-    ) -> SniffedNodes<TSender> {
+    ) -> SniffedNodes {
         let nodes = StaticNodes::round_robin(vec![self.base_url.clone()], base_params.clone());
         let wait = self.wait.unwrap_or_else(|| Duration::from_secs(90));
 
@@ -145,7 +142,6 @@ impl SniffedNodesBuilder {
             .url_param("filter_path", "nodes.*.http.publish_address");
 
         SniffedNodes {
-            sender: sender,
             refresh_params: refresh_params,
             inner: Arc::new(RwLock::new(SniffedNodesInner {
                 last_update: None,
@@ -172,12 +168,7 @@ Shared logic between sync and async methods.
 These methods definitely aren't intended to be made public.
 There are invariants that are shared between them that require they're called in specific ways.
 */
-impl<TSender> SniffedNodes<TSender> {
-    /** Gets the sender */
-    pub fn sender(&self) -> &TSender {
-        &self.sender
-    }
-
+impl SniffedNodes {
     /**
     Return a node address if the set of nodes is still current.
 
@@ -259,8 +250,6 @@ impl SniffedNodesInner {
     }
 }
 
-impl<TSender> private::Sealed for SniffedNodes<TSender> {}
-
 /** Result of `SniffedNodes::next_or_start_refresh`. */
 pub enum NextOrRefresh {
     /** Don't need to refresh, an address is available. */
@@ -317,8 +306,8 @@ mod tests {
     use super::*;
     use serde_json;
 
-    fn sender() -> SniffedNodes<()> {
-        SniffedNodesBuilder::new(initial_address()).build(PreRequestParams::default(), ())
+    fn sender() -> SniffedNodes {
+        SniffedNodesBuilder::new(initial_address()).build(PreRequestParams::default())
     }
 
     fn expected_nodes() -> NodesInfoResponse {
@@ -352,7 +341,7 @@ mod tests {
     }
 
     fn assert_node_addresses_equal(
-        nodes: &SniffedNodes<()>,
+        nodes: &SniffedNodes,
         expected_addresses: Vec<&'static str>,
     ) {
         let inner = nodes.inner.read().expect("lock poisoned");
@@ -361,12 +350,12 @@ mod tests {
         assert_eq!(expected_addresses, actual);
     }
 
-    fn assert_refreshing_equal(nodes: &SniffedNodes<()>, refreshing: bool) {
+    fn assert_refreshing_equal(nodes: &SniffedNodes, refreshing: bool) {
         let inner = nodes.inner.read().expect("lock poisoned");
         assert_eq!(refreshing, inner.refreshing);
     }
 
-    fn assert_should_refresh_equal(nodes: &SniffedNodes<()>, should_refresh: bool) {
+    fn assert_should_refresh_equal(nodes: &SniffedNodes, should_refresh: bool) {
         let inner = nodes.inner.read().expect("lock poisoned");
         assert_eq!(should_refresh, inner.should_refresh());
     }

src/elastic/src/http/sender/synchronous.rs

@@ -133,7 +133,7 @@ impl Sender for SyncSender {
 
     fn next_params(
         &self,
-        addresses: &NodeAddresses<Self>
+        addresses: &NodeAddresses,
     ) -> Self::Params {
         match addresses {
             NodeAddresses::Static(ref nodes) => Params::new(nodes.next()),