Formatting fixes.

Signed-off-by: Eric Webster <[email protected]>

kube-client/src/api/remote_command.rs

@@ -111,8 +111,7 @@ pub struct AttachedProcess {
 }
 
 impl AttachedProcess {
-    pub(crate) fn new(connection: Connection, ap: &AttachParams) -> Self
-    {
+    pub(crate) fn new(connection: Connection, ap: &AttachParams) -> Self {
         // To simplify the implementation, always create a pipe for stdin.
         // The caller does not have access to it unless they had requested.
         let (stdin_writer, stdin_reader) = tokio::io::duplex(ap.max_stdin_buf_size.unwrap_or(MAX_BUF_SIZE));
@@ -274,8 +273,7 @@ async fn start_message_loop(
     mut stderr: Option<impl AsyncWrite + Unpin>,
     status_tx: StatusSender,
     mut terminal_size_rx: Option<TerminalSizeReceiver>,
-) -> Result<(), Error>
-{
+) -> Result<(), Error> {
     let supports_stream_close = connection.supports_stream_close();
     let stream = connection.into_stream();
     let mut stdin_stream = tokio_util::io::ReaderStream::new(stdin);

kube-client/src/client/mod.rs

@@ -213,10 +213,7 @@ impl Client {
     /// Make WebSocket connection.
     #[cfg(feature = "ws")]
     #[cfg_attr(docsrs, doc(cfg(feature = "ws")))]
-    pub async fn connect(
-        &self,
-        request: Request<Vec<u8>>,
-    ) -> Result<Connection> {
+    pub async fn connect(&self, request: Request<Vec<u8>>) -> Result<Connection> {
         use http::header::HeaderValue;
         let (mut parts, body) = request.into_parts();
         parts
@@ -241,11 +238,13 @@ impl Client {
         match hyper::upgrade::on(res).await {
             Ok(upgraded) => Ok(Connection {
                 stream: WebSocketStream::from_raw_socket(
-                TokioIo::new(upgraded),
-                ws::protocol::Role::Client,
-                None,
-            )
-            .await, protocol}),
+                    TokioIo::new(upgraded),
+                    ws::protocol::Role::Client,
+                    None,
+                )
+                .await,
+                protocol,
+            }),
 
             Err(e) => Err(Error::UpgradeConnection(
                 UpgradeConnectionError::GetPendingUpgrade(e),

kube-client/src/client/upgrade.rs

@@ -18,8 +18,8 @@ pub enum StreamProtocol {
 impl StreamProtocol {
     pub fn as_str(&self) -> &'static str {
         match self {
-            StreamProtocol::V4 => "v4.channel.k8s.io",
-            StreamProtocol::V5 => "v5.channel.k8s.io"
+            Self::V4 => "v4.channel.k8s.io",
+            Self::V5 => "v5.channel.k8s.io",
         }
     }
 
@@ -29,23 +29,23 @@ impl StreamProtocol {
 
     pub fn supports_stream_close(&self) -> bool {
         match self {
-            StreamProtocol::V4 => false,
-            StreamProtocol::V5 => true
+            Self::V4 => false,
+            Self::V5 => true,
         }
     }
 
     /// Add HTTP header SEC_WEBSOCKET_PROTOCOL with a list of supported protocol.
     pub fn add_to_headers(headers: &mut http::HeaderMap) -> Result<()> {
         // Protocols we support in our preferred order.
-        let supported_protocols = vec![
+        let supported_protocols = [
             // v5 supports CLOSE signals.
-            StreamProtocol::V5.as_str(),
+            Self::V5.as_str(),
             // Use the binary subprotocol v4, to get JSON `Status` object in `error` channel (3).
             // There's no official documentation about this protocol, but it's described in
             // [`k8s.io/apiserver/pkg/util/wsstream/conn.go`](https://git.io/JLQED).
             // There's a comment about v4 and `Status` object in
             // [`kublet/cri/streaming/remotecommand/httpstream.go`](https://git.io/JLQEh).
-            StreamProtocol::V4.as_str(),
+            Self::V4.as_str(),
         ];
 
         let header_value_string = supported_protocols.join(", ");
@@ -65,16 +65,19 @@ impl StreamProtocol {
 
         match headers
             .get(http::header::SEC_WEBSOCKET_PROTOCOL)
-            .map(|h| h.as_bytes()) {
-                Some(protocol) => if protocol == StreamProtocol::V4.as_bytes() {
-                    Some(StreamProtocol::V4)
-                } else if protocol == StreamProtocol::V5.as_bytes() {
-                    Some(StreamProtocol::V5)
+            .map(|h| h.as_bytes())
+        {
+            Some(protocol) => {
+                if protocol == Self::V4.as_bytes() {
+                    Some(Self::V4)
+                } else if protocol == Self::V5.as_bytes() {
+                    Some(Self::V5)
                 } else {
                     None
-                },
-                _ => None,
+                }
             }
+            _ => None,
+        }
     }
 }
 
@@ -149,7 +152,7 @@ pub fn verify_response(res: &Response<Body>, key: &str) -> Result<StreamProtocol
     // Make sure that the server returned an expected subprotocol.
     let protocol = match StreamProtocol::get_from_response(res) {
         Some(p) => p,
-        None => return Err(UpgradeConnectionError::SecWebSocketProtocolMismatch)
+        None => return Err(UpgradeConnectionError::SecWebSocketProtocolMismatch),
     };
 
     Ok(protocol)