Code formatting.

Signed-off-by: Marvin Hansen <marvin.hansen@gmail.com>

Author: marvin-hansen

arancini-lib/src/processor.rs

@@ -11,7 +11,7 @@ use crate::sender::UpdateSender;
 use crate::state::AsyncState;
 use crate::state::{peer_up_withdraws_handler, process_updates, synthesize_withdraw_update};
 use crate::state_store::store::StateStore;
-use crate::update::{decode_updates, UpdateMetadata};
+use crate::update::{UpdateMetadata, decode_updates};
 
 pub fn decode_bmp_message(bytes: &mut Bytes) -> Result<BmpMessage> {
     let message = match parse_bmp_msg(bytes) {
@@ -120,15 +120,15 @@ pub async fn peer_down_notification<T: StateStore, S: UpdateSender>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::state::{new_state, State};
+    use crate::state::{State, new_state};
     use crate::state_store::memory::MemoryStore;
-    use crate::update::{map_to_ipv6, Update, UpdateAttributes};
+    use crate::update::{Update, UpdateAttributes, map_to_ipv6};
     use chrono::Utc;
     use std::net::{IpAddr, Ipv4Addr, SocketAddr};
-    use std::sync::atomic::{AtomicUsize, Ordering};
     use std::sync::Arc;
+    use std::sync::atomic::{AtomicUsize, Ordering};
     use tokio::sync::{Notify, Semaphore};
-    use tokio::time::{timeout, Duration};
+    use tokio::time::{Duration, timeout};
 
     #[derive(Clone)]
     struct BlockingSender {

arancini-lib/src/state.rs

@@ -12,7 +12,7 @@ use tracing::{debug, trace};
 
 use crate::sender::UpdateSender;
 use crate::state_store::store::StateStore;
-use crate::update::{map_to_ipv6, Update, UpdateAttributes, UpdateMetadata};
+use crate::update::{Update, UpdateAttributes, UpdateMetadata, map_to_ipv6};
 
 pub type AsyncState<T> = Arc<Mutex<State<T>>>;
 pub type RouterPeerUpdate = (IpAddr, IpAddr, TimedPrefix);
@@ -243,7 +243,7 @@ mod tests {
     use std::net::{IpAddr, Ipv4Addr, SocketAddr};
     use std::sync::atomic::{AtomicUsize, Ordering};
     use tokio::sync::{Notify, Semaphore};
-    use tokio::time::{sleep, timeout, Duration};
+    use tokio::time::{Duration, sleep, timeout};
 
     #[derive(Clone)]
     struct BlockingSender {

arancini/src/arancini.rs

@@ -1,10 +1,10 @@
 use anyhow::Result;
 use arancini_lib::processor::decode_bmp_message;
 use arancini_lib::sender::UpdateSender;
-use arancini_lib::state::{synthesize_withdraw_update, State};
+use arancini_lib::state::{State, synthesize_withdraw_update};
 use arancini_lib::state_store::memory::MemoryStore;
 use arancini_lib::state_store::store::StateStore;
-use arancini_lib::update::{decode_updates, new_metadata, Update, UpdateMetadata};
+use arancini_lib::update::{Update, UpdateMetadata, decode_updates, new_metadata};
 use async_nats::jetstream;
 use bgpkit_parser::bmp::messages::{PeerDownNotification, RouteMonitoring};
 use bgpkit_parser::parser::bmp::messages::BmpMessageBody;
@@ -20,8 +20,8 @@ use monoio::io::AsyncReadRent;
 use monoio::net::{ListenerOpts, TcpListener, TcpStream};
 use monoio::time::sleep;
 use monoio::{FusionDriver, RuntimeBuilder};
-use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::collections::hash_map::Entry;
 use std::net::{IpAddr, SocketAddr};
 use std::sync::Arc;
 use std::sync::Mutex;
@@ -665,8 +665,7 @@ async fn handle_connection<S: UpdateSender>(
 
             trace!(
                 "{}: arancini read BMP packet ({} bytes)",
-                socket,
-                packet_length
+                socket, packet_length
             );
             let mut bytes = frame_buffer.split_to(packet_length).freeze();
             if let Err(err) =
@@ -1472,7 +1471,7 @@ mod tests {
     use std::net::{Ipv4Addr, SocketAddr};
     use std::sync::atomic::{AtomicUsize, Ordering};
     use tokio::sync::{Notify, Semaphore};
-    use tokio::time::{timeout, Duration};
+    use tokio::time::{Duration, timeout};
 
     #[derive(Clone)]
     struct BlockingSender {

arancini/src/bin/arancini_bench.rs

@@ -5,7 +5,7 @@ mod update_capnp;
 
 use arancini_lib::state::State;
 use arancini_lib::state_store::memory::MemoryStore;
-use arancini_lib::update::{map_to_ipv6, Update, UpdateAttributes};
+use arancini_lib::update::{Update, UpdateAttributes, map_to_ipv6};
 use bytes::BytesMut;
 use chrono::Utc;
 use core_affinity::CoreId;

arancini/src/bridge.rs

@@ -4,8 +4,8 @@ use arancini_lib::update::Update;
 use async_nats::jetstream;
 use crossfire::mpsc;
 use crossfire::{AsyncRxTrait, AsyncTxTrait};
-use futures::stream::{FuturesUnordered, StreamExt};
 use futures::FutureExt;
+use futures::stream::{FuturesUnordered, StreamExt};
 use metrics::{counter, gauge, histogram};
 use std::future::Future;
 use std::net::IpAddr;
@@ -300,7 +300,7 @@ mod tests {
     use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
     use std::sync::Arc;
     use tokio::sync::mpsc;
-    use tokio::time::{timeout, Duration};
+    use tokio::time::{Duration, timeout};
 
     fn test_update(router_addr: IpAddr, prefix_addr: IpAddr, announced: bool) -> Update {
         Update {

arancini/src/main.rs

@@ -10,14 +10,14 @@ use anyhow::Result;
 use futures::future::pending;
 use std::sync::Arc;
 use std::time::Duration;
-use tokio::sync::mpsc::{channel, Receiver};
+use tokio::sync::mpsc::{Receiver, channel};
 use tokio_graceful::Shutdown;
 use tracing::{debug, error, trace, warn};
 
 use arancini_lib::update::Update;
 
 use crate::bridge::BridgeSender;
-use crate::config::{configure, AppConfig};
+use crate::config::{AppConfig, configure};
 
 async fn arancini_handler(cfg: Arc<AppConfig>, tx: BridgeSender) {
     if let Err(err) = arancini::spawn_workers(cfg, tx) {

arancini/src/producer.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use arancini_lib::update::Update;
-use futures::stream::{FuturesUnordered, StreamExt};
 use futures::FutureExt;
+use futures::stream::{FuturesUnordered, StreamExt};
 use metrics::counter;
 use rdkafka::config::ClientConfig;
 use rdkafka::error::{KafkaError, RDKafkaErrorCode};