Run cargo fmt on the whole code base (#9394)

* Run cargo fmt on the whole code base

* Second run

* Add CI check

* Fix compilation

* More unnecessary braces

* Handle weights

* Use --all

* Use correct attributes...

* Fix UI tests

* AHHHHHHHHH

* 🤦

* Docs

* Fix compilation

* 🤷

* Please stop

* 🤦 x 2

* More

* make rustfmt.toml consistent with polkadot

Co-authored-by: André Silva <andrerfosilva@gmail.com>

substrate/client/telemetry/src/endpoints.rs

@@ -25,8 +25,7 @@ use serde::{Deserialize, Deserializer, Serialize};
 /// The URL string can be either a URL or a multiaddress.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
 pub struct TelemetryEndpoints(
-	#[serde(deserialize_with = "url_or_multiaddr_deser")]
-	pub(crate) Vec<(Multiaddr, u8)>,
+	#[serde(deserialize_with = "url_or_multiaddr_deser")] pub(crate) Vec<(Multiaddr, u8)>,
 );
 
 /// Custom deserializer for TelemetryEndpoints, used to convert urls or multiaddr to multiaddr.
@@ -36,21 +35,15 @@ where
 {
 	Vec::<(String, u8)>::deserialize(deserializer)?
 		.iter()
-		.map(|e| {
-			url_to_multiaddr(&e.0)
-				.map_err(serde::de::Error::custom)
-				.map(|m| (m, e.1))
-		})
+		.map(|e| url_to_multiaddr(&e.0).map_err(serde::de::Error::custom).map(|m| (m, e.1)))
 		.collect()
 }
 
 impl TelemetryEndpoints {
 	/// Create a `TelemetryEndpoints` based on a list of `(String, u8)`.
 	pub fn new(endpoints: Vec<(String, u8)>) -> Result<Self, libp2p::multiaddr::Error> {
-		let endpoints: Result<Vec<(Multiaddr, u8)>, libp2p::multiaddr::Error> = endpoints
-			.iter()
-			.map(|e| Ok((url_to_multiaddr(&e.0)?, e.1)))
-			.collect();
+		let endpoints: Result<Vec<(Multiaddr, u8)>, libp2p::multiaddr::Error> =
+			endpoints.iter().map(|e| Ok((url_to_multiaddr(&e.0)?, e.1))).collect();
 		endpoints.map(Self)
 	}
 }
@@ -72,7 +65,7 @@ fn url_to_multiaddr(url: &str) -> Result<Multiaddr, libp2p::multiaddr::Error> {
 
 	// If not, try the `ws://path/url` format.
 	if let Ok(ma) = libp2p::multiaddr::from_url(url) {
-		return Ok(ma);
+		return Ok(ma)
 	}
 
 	// If we have no clue about the format of that string, assume that we were expecting a
@@ -82,8 +75,7 @@ fn url_to_multiaddr(url: &str) -> Result<Multiaddr, libp2p::multiaddr::Error> {
 
 #[cfg(test)]
 mod tests {
-	use super::url_to_multiaddr;
-	use super::TelemetryEndpoints;
+	use super::{url_to_multiaddr, TelemetryEndpoints};
 	use libp2p::Multiaddr;
 
 	#[test]
@@ -96,10 +88,7 @@ mod tests {
 			TelemetryEndpoints::new(endp.clone()).expect("Telemetry endpoint should be valid");
 		let mut res: Vec<(Multiaddr, u8)> = vec![];
 		for (a, b) in endp.iter() {
-			res.push((
-				url_to_multiaddr(a).expect("provided url should be valid"),
-				*b,
-			))
+			res.push((url_to_multiaddr(a).expect("provided url should be valid"), *b))
 		}
 		assert_eq!(telem.0, res);
 	}

substrate/client/telemetry/src/lib.rs

@@ -41,8 +41,10 @@ use libp2p::Multiaddr;
 use log::{error, warn};
 use parking_lot::Mutex;
 use serde::Serialize;
-use std::collections::HashMap;
-use std::sync::{atomic, Arc};
+use std::{
+	collections::HashMap,
+	sync::{atomic, Arc},
+};
 
 pub use libp2p::wasm_ext::ExtTransport;
 pub use log;
@@ -191,11 +193,7 @@ impl TelemetryWorker {
 		let input = input.expect("the stream is never closed; qed");
 
 		match input {
-			Register::Telemetry {
-				id,
-				endpoints,
-				connection_message,
-			} => {
+			Register::Telemetry { id, endpoints, connection_message } => {
 				let endpoints = endpoints.0;
 
 				let connection_message = match serde_json::to_value(&connection_message) {
@@ -205,10 +203,10 @@ impl TelemetryWorker {
 						obj.insert("id".to_string(), id.into());
 						obj.insert("payload".to_string(), value.into());
 						Some(obj)
-					}
+					},
 					Ok(_) => {
 						unreachable!("ConnectionMessage always serialize to an object; qed")
-					}
+					},
 					Err(err) => {
 						log::error!(
 							target: "telemetry",
@@ -216,7 +214,7 @@ impl TelemetryWorker {
 							err,
 						);
 						None
-					}
+					},
 				};
 
 				for (addr, verbosity) in endpoints {
@@ -225,10 +223,7 @@ impl TelemetryWorker {
 						"Initializing telemetry for: {:?}",
 						addr,
 					);
-					node_map
-						.entry(id.clone())
-						.or_default()
-						.push((verbosity, addr.clone()));
+					node_map.entry(id.clone()).or_default().push((verbosity, addr.clone()));
 
 					let node = node_pool.entry(addr.clone()).or_insert_with(|| {
 						Node::new(transport.clone(), addr.clone(), Vec::new(), Vec::new())
@@ -238,32 +233,27 @@ impl TelemetryWorker {
 
 					pending_connection_notifications.retain(|(addr_b, connection_message)| {
 						if *addr_b == addr {
-							node.telemetry_connection_notifier
-								.push(connection_message.clone());
+							node.telemetry_connection_notifier.push(connection_message.clone());
 							false
 						} else {
 							true
 						}
 					});
 				}
-			}
-			Register::Notifier {
-				addresses,
-				connection_notifier,
-			} => {
+			},
+			Register::Notifier { addresses, connection_notifier } => {
 				for addr in addresses {
 					// If the Node has been initialized, we directly push the connection_notifier.
 					// Otherwise we push it to a queue that will be consumed when the connection
 					// initializes, thus ensuring that the connection notifier will be sent to the
 					// Node when it becomes available.
 					if let Some(node) = node_pool.get_mut(&addr) {
-						node.telemetry_connection_notifier
-							.push(connection_notifier.clone());
+						node.telemetry_connection_notifier.push(connection_notifier.clone());
 					} else {
 						pending_connection_notifications.push((addr, connection_notifier.clone()));
 					}
 				}
-			}
+			},
 		}
 	}
 
@@ -297,12 +287,12 @@ impl TelemetryWorker {
 						message,
 					)),
 			);
-			return;
+			return
 		};
 
 		for (node_max_verbosity, addr) in nodes {
 			if verbosity > *node_max_verbosity {
-				continue;
+				continue
 			}
 
 			if let Some(node) = node_pool.get_mut(&addr) {
@@ -376,11 +366,7 @@ impl Telemetry {
 		let endpoints = self.endpoints.take().ok_or_else(|| Error::TelemetryAlreadyInitialized)?;
 
 		self.register_sender
-			.unbounded_send(Register::Telemetry {
-				id: self.id,
-				endpoints,
-				connection_message,
-			})
+			.unbounded_send(Register::Telemetry { id: self.id, endpoints, connection_message })
 			.map_err(|_| Error::TelemetryWorkerDropped)
 	}
 
@@ -407,12 +393,8 @@ pub struct TelemetryHandle {
 impl TelemetryHandle {
 	/// Send telemetry messages.
 	pub fn send_telemetry(&self, verbosity: VerbosityLevel, payload: TelemetryPayload) {
-		match self
-			.message_sender
-			.lock()
-			.try_send((self.id, verbosity, payload))
-		{
-			Ok(()) => {}
+		match self.message_sender.lock().try_send((self.id, verbosity, payload)) {
+			Ok(()) => {},
 			Err(err) if err.is_full() => log::trace!(
 				target: "telemetry",
 				"Telemetry channel full.",
@@ -461,15 +443,8 @@ impl TelemetryConnectionNotifier {
 
 #[derive(Debug)]
 enum Register {
-	Telemetry {
-		id: Id,
-		endpoints: TelemetryEndpoints,
-		connection_message: ConnectionMessage,
-	},
-	Notifier {
-		addresses: Vec<Multiaddr>,
-		connection_notifier: ConnectionNotifierSender,
-	},
+	Telemetry { id: Id, endpoints: TelemetryEndpoints, connection_message: ConnectionMessage },
+	Notifier { addresses: Vec<Multiaddr>, connection_notifier: ConnectionNotifierSender },
 }
 
 /// Report a telemetry.

substrate/client/telemetry/src/node.rs

@@ -17,12 +17,15 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 use crate::TelemetryPayload;
-use futures::channel::mpsc;
-use futures::prelude::*;
-use libp2p::core::transport::Transport;
-use libp2p::Multiaddr;
+use futures::{channel::mpsc, prelude::*};
+use libp2p::{core::transport::Transport, Multiaddr};
 use rand::Rng as _;
-use std::{fmt, mem, pin::Pin, task::Context, task::Poll, time::Duration};
+use std::{
+	fmt, mem,
+	pin::Pin,
+	task::{Context, Poll},
+	time::Duration,
+};
 use wasm_timer::Delay;
 
 pub(crate) type ConnectionNotifierSender = mpsc::Sender<()>;
@@ -122,7 +125,7 @@ where
 	) -> Poll<Result<(), TSinkErr>> {
 		while let Some(item) = conn.buf.pop() {
 			if let Err(e) = conn.sink.start_send_unpin(item) {
-				return Poll::Ready(Err(e));
+				return Poll::Ready(Err(e))
 			}
 			futures::ready!(conn.sink.poll_ready_unpin(cx))?;
 		}
@@ -152,25 +155,25 @@ where
 							Poll::Ready(Err(err)) => {
 								log::warn!(target: "telemetry", "⚠️  Disconnected from {}: {:?}", self.addr, err);
 								socket = NodeSocket::wait_reconnect();
-							}
+							},
 							Poll::Ready(Ok(())) => {
 								self.socket = NodeSocket::Connected(conn);
-								return Poll::Ready(Ok(()));
-							}
+								return Poll::Ready(Ok(()))
+							},
 							Poll::Pending => {
 								self.socket = NodeSocket::Connected(conn);
-								return Poll::Pending;
-							}
+								return Poll::Pending
+							},
 						}
-					}
+					},
 					Poll::Ready(Err(err)) => {
 						log::warn!(target: "telemetry", "⚠️  Disconnected from {}: {:?}", self.addr, err);
 						socket = NodeSocket::wait_reconnect();
-					}
+					},
 					Poll::Pending => {
 						self.socket = NodeSocket::Connected(conn);
-						return Poll::Pending;
-					}
+						return Poll::Pending
+					},
 				},
 				NodeSocket::Dialing(mut s) => match Future::poll(Pin::new(&mut s), cx) {
 					Poll::Ready(Ok(sink)) => {
@@ -201,39 +204,39 @@ where
 										err,
 									);
 									None
-								}
+								},
 							})
 							.collect();
 
 						socket = NodeSocket::Connected(NodeSocketConnected { sink, buf });
-					}
+					},
 					Poll::Pending => break NodeSocket::Dialing(s),
 					Poll::Ready(Err(err)) => {
 						log::warn!(target: "telemetry", "❌ Error while dialing {}: {:?}", self.addr, err);
 						socket = NodeSocket::wait_reconnect();
-					}
+					},
 				},
 				NodeSocket::ReconnectNow => match self.transport.clone().dial(self.addr.clone()) {
 					Ok(d) => {
 						log::trace!(target: "telemetry", "Re-dialing {}", self.addr);
 						socket = NodeSocket::Dialing(d);
-					}
+					},
 					Err(err) => {
 						log::warn!(target: "telemetry", "❌ Error while re-dialing {}: {:?}", self.addr, err);
 						socket = NodeSocket::wait_reconnect();
-					}
+					},
 				},
 				NodeSocket::WaitingReconnect(mut s) => {
 					if let Poll::Ready(_) = Future::poll(Pin::new(&mut s), cx) {
 						socket = NodeSocket::ReconnectNow;
 					} else {
-						break NodeSocket::WaitingReconnect(s);
+						break NodeSocket::WaitingReconnect(s)
 					}
-				}
+				},
 				NodeSocket::Poisoned => {
 					log::error!(target: "telemetry", "‼️ Poisoned connection with {}", self.addr);
-					break NodeSocket::Poisoned;
-				}
+					break NodeSocket::Poisoned
+				},
 			}
 		};
 
@@ -250,7 +253,7 @@ where
 				Ok(data) => {
 					log::trace!(target: "telemetry", "Sending {} bytes", data.len());
 					let _ = conn.sink.start_send_unpin(data);
-				}
+				},
 				Err(err) => log::debug!(
 					target: "telemetry",
 					"Could not serialize payload: {}",
@@ -262,7 +265,7 @@ where
 			// A new connection should be started as soon as possible.
 			NodeSocket::ReconnectNow => log::trace!(target: "telemetry", "Reconnecting"),
 			// Waiting before attempting to dial again.
-			NodeSocket::WaitingReconnect(_) => {}
+			NodeSocket::WaitingReconnect(_) => {},
 			// Temporary transition state.
 			NodeSocket::Poisoned => log::trace!(target: "telemetry", "Poisoned"),
 		}
@@ -280,7 +283,7 @@ where
 					log::trace!(target: "telemetry", "[poll_flush] Error: {:?}", e);
 					self.socket = NodeSocket::wait_reconnect();
 					Poll::Ready(Ok(()))
-				}
+				},
 				Poll::Ready(Ok(())) => Poll::Ready(Ok(())),
 				Poll::Pending => Poll::Pending,
 			},

substrate/client/telemetry/src/transport.rs

@@ -26,9 +26,7 @@ use libp2p::{
 	core::transport::{timeout::TransportTimeout, OptionalTransport},
 	wasm_ext, Transport,
 };
-use std::io;
-use std::pin::Pin;
-use std::time::Duration;
+use std::{io, pin::Pin, time::Duration};
 
 /// Timeout after which a connection attempt is considered failed. Includes the WebSocket HTTP
 /// upgrading.
@@ -111,7 +109,7 @@ impl<T: AsyncRead> Stream for StreamSink<T> {
 			Ok(n) => {
 				buf.truncate(n);
 				Poll::Ready(Some(Ok(buf)))
-			}
+			},
 			Err(err) => Poll::Ready(Some(Err(err))),
 		}
 	}
@@ -126,7 +124,7 @@ impl<T: AsyncWrite> StreamSink<T> {
 				log::error!(target: "telemetry",
 					"Detected some internal buffering happening in the telemetry");
 				let err = io::Error::new(io::ErrorKind::Other, "Internal buffering detected");
-				return Poll::Ready(Err(err));
+				return Poll::Ready(Err(err))
 			}
 		}