rustfmt everything

I want to make the project more accessible by not expecting folks to
match my idiosyncratic style. Now almost [1] everything is written
in the "standard" style. CI enforces this.

[1] "Almost": I used #[rustfmt::skip] in a few sections where I felt
aligning things in columns significantly improves readability.

server/base/clock.rs

@@ -35,13 +35,13 @@ use libc;
 use log::warn;
 use parking_lot::Mutex;
 use std::mem;
-use std::sync::{Arc, mpsc};
+use std::sync::{mpsc, Arc};
 use std::thread;
 use std::time::Duration as StdDuration;
 use time::{Duration, Timespec};
 
 /// Abstract interface to the system clocks. This is for testability.
-pub trait Clocks : Send + Sync + 'static {
+pub trait Clocks: Send + Sync + 'static {
     /// Gets the current time from `CLOCK_REALTIME`.
     fn realtime(&self) -> Timespec;
 
@@ -52,19 +52,29 @@ pub trait Clocks : Send + Sync + 'static {
     fn sleep(&self, how_long: Duration);
 
     /// Calls `rcv.recv_timeout` or substitutes a test implementation.
-    fn recv_timeout<T>(&self, rcv: &mpsc::Receiver<T>,
-                       timeout: StdDuration) -> Result<T, mpsc::RecvTimeoutError>;
+    fn recv_timeout<T>(
+        &self,
+        rcv: &mpsc::Receiver<T>,
+        timeout: StdDuration,
+    ) -> Result<T, mpsc::RecvTimeoutError>;
 }
 
 pub fn retry_forever<C, T, E>(clocks: &C, f: &mut dyn FnMut() -> Result<T, E>) -> T
-where C: Clocks, E: Into<Error> {
+where
+    C: Clocks,
+    E: Into<Error>,
+{
     loop {
         let e = match f() {
             Ok(t) => return t,
             Err(e) => e.into(),
         };
         let sleep_time = Duration::seconds(1);
-        warn!("sleeping for {:?} after error: {}", sleep_time, crate::error::prettify_failure(&e));
+        warn!(
+            "sleeping for {:?} after error: {}",
+            sleep_time,
+            crate::error::prettify_failure(&e)
+        );
         clocks.sleep(sleep_time);
     }
 }
@@ -84,8 +94,12 @@ impl RealClocks {
 }
 
 impl Clocks for RealClocks {
-    fn realtime(&self) -> Timespec { self.get(libc::CLOCK_REALTIME) }
-    fn monotonic(&self) -> Timespec { self.get(libc::CLOCK_MONOTONIC) }
+    fn realtime(&self) -> Timespec {
+        self.get(libc::CLOCK_REALTIME)
+    }
+    fn monotonic(&self) -> Timespec {
+        self.get(libc::CLOCK_MONOTONIC)
+    }
 
     fn sleep(&self, how_long: Duration) {
         match how_long.to_std() {
@@ -94,8 +108,11 @@ impl Clocks for RealClocks {
         };
     }
 
-    fn recv_timeout<T>(&self, rcv: &mpsc::Receiver<T>,
-                       timeout: StdDuration) -> Result<T, mpsc::RecvTimeoutError> {
+    fn recv_timeout<T>(
+        &self,
+        rcv: &mpsc::Receiver<T>,
+        timeout: StdDuration,
+    ) -> Result<T, mpsc::RecvTimeoutError> {
         rcv.recv_timeout(timeout)
     }
 }
@@ -119,7 +136,11 @@ impl<'a, C: Clocks + ?Sized, S: AsRef<str>, F: FnOnce() -> S + 'a> TimerGuard<'a
 }
 
 impl<'a, C, S, F> Drop for TimerGuard<'a, C, S, F>
-where C: Clocks + ?Sized, S: AsRef<str>, F: FnOnce() -> S + 'a {
+where
+    C: Clocks + ?Sized,
+    S: AsRef<str>,
+    F: FnOnce() -> S + 'a,
+{
     fn drop(&mut self) {
         let elapsed = self.clocks.monotonic() - self.start;
         if elapsed.num_seconds() >= 1 {
@@ -148,8 +169,12 @@ impl SimulatedClocks {
 }
 
 impl Clocks for SimulatedClocks {
-    fn realtime(&self) -> Timespec { self.0.boot + *self.0.uptime.lock() }
-    fn monotonic(&self) -> Timespec { Timespec::new(0, 0) + *self.0.uptime.lock() }
+    fn realtime(&self) -> Timespec {
+        self.0.boot + *self.0.uptime.lock()
+    }
+    fn monotonic(&self) -> Timespec {
+        Timespec::new(0, 0) + *self.0.uptime.lock()
+    }
 
     /// Advances the clock by the specified amount without actually sleeping.
     fn sleep(&self, how_long: Duration) {
@@ -158,8 +183,11 @@ impl Clocks for SimulatedClocks {
     }
 
     /// Advances the clock by the specified amount if data is not immediately available.
-    fn recv_timeout<T>(&self, rcv: &mpsc::Receiver<T>,
-                       timeout: StdDuration) -> Result<T, mpsc::RecvTimeoutError> {
+    fn recv_timeout<T>(
+        &self,
+        rcv: &mpsc::Receiver<T>,
+        timeout: StdDuration,
+    ) -> Result<T, mpsc::RecvTimeoutError> {
         let r = rcv.recv_timeout(StdDuration::new(0, 0));
         if let Err(_) = r {
             self.sleep(Duration::from_std(timeout).unwrap());