chore: rustfmt picolib

picolib/lib.rs

-use slog::{debug, info, o, error};
-use std::os::raw::c_int;
 use ::tarantool::tlua;
 use rmp_serde;
 use serde::{Deserialize, Serialize};
+use slog::{debug, error, info, o};
+use std::os::raw::c_int;
 
 mod tarantool;
 mod traft;
@@ -13,9 +13,9 @@ pub struct InnerTest {
 }
 inventory::collect!(InnerTest);
 
+use std::cell::Ref;
 use std::cell::RefCell;
 use std::cell::RefMut;
-use std::cell::Ref;
 use std::convert::{TryFrom, TryInto};
 use std::rc::Rc;
 
@@ -46,9 +46,9 @@ pub extern "C" fn luaopen_picolib(l: *mut std::ffi::c_void) -> c_int {
     match command.as_deref() {
         Ok("run") => {
             main_run(&stash);
-        },
-        Ok(_) => {},
-        Err(_) => {},
+        }
+        Ok(_) => {}
+        Err(_) => {}
     }
 
     unsafe {
@@ -76,29 +76,29 @@ pub extern "C" fn luaopen_picolib(l: *mut std::ffi::c_void) -> c_int {
             let stash = stash.clone();
             luamod.set(
                 "raft_test_propose",
-                tlua::function1(move |x: String|
-                    raft_propose(&stash, RaftEntryData::Info(format!("{}", x)))),
+                tlua::function1(move |x: String| {
+                    raft_propose(&stash, RaftEntryData::Info(format!("{}", x)))
+                }),
             );
         }
         {
             let stash = stash.clone();
             luamod.set(
                 "broadcast_lua_eval",
-                tlua::function1(
-                    move |x: String| {
-                        raft_propose(&stash, RaftEntryData::EvalLua(x))
-                    }
-                )
+                tlua::function1(move |x: String| raft_propose(&stash, RaftEntryData::EvalLua(x))),
             )
         }
         {
-            l.exec(r#"
+            l.exec(
+                r#"
                 function inspect()
                     return
                         {raft_log = box.space.raft_log:fselect()},
                         {raft_state = box.space.raft_state:fselect()}
                 end
-            "#).unwrap();
+            "#,
+            )
+            .unwrap();
         }
 
         use tlua::AsLua;
@@ -204,9 +204,7 @@ fn handle_committed_data(logger: &slog::Logger, data: &[u8]) {
         Ok(x) => match x {
             EvalLua(code) => crate::tarantool::eval(&code),
             Info(msg) => info!(logger, "{}", msg),
-        }
+        },
         Err(why) => error!(logger, "cannot decode raft entry data: {}", why),
     }
 }
-
-

picolib/traft/mod.rs

@@ -4,8 +4,8 @@ mod storage;
 pub use node::Node;
 pub use storage::Storage;
 
-pub use raft::Ready;
-pub use raft::Config;
-pub use raft::eraftpb::Message;
 pub use raft::eraftpb::Entry;
+pub use raft::eraftpb::Message;
+pub use raft::Config;
+pub use raft::Ready;
 // pub use raft::prelude::*;

picolib/traft/node.rs

-use slog::{
-    info,
-};
-use std::ops::{Deref, DerefMut};
 use raft::prelude::*;
 use raft::Error as RaftError;
+use slog::info;
+use std::ops::{Deref, DerefMut};
 
 use std::cell::RefCell;
 use std::rc::Rc;
 
 use std::time::Duration;
 
-
 use super::storage::Storage;
 use crate::tarantool::SlogDrain;
 use ::tarantool::fiber;
@@ -25,11 +22,15 @@ pub struct Node {
 }
 
 impl Node {
-    pub fn new(cfg: &raft::Config) -> Result<Self, RaftError>  {
+    pub fn new(cfg: &raft::Config) -> Result<Self, RaftError> {
         let logger = slog::Logger::root(SlogDrain, slog::o!());
         let raw_node = RawNode::new(cfg, Storage, &logger)?;
         let raw_node = Rc::from(RefCell::from(raw_node));
-        let ret = Node {logger, raw_node, main_loop: None};
+        let ret = Node {
+            logger,
+            raw_node,
+            main_loop: None,
+        };
         Ok(ret)
     }
 

picolib/traft/storage.rs

-use slog::{debug, o};
+use ::tarantool::index::IteratorType;
+use ::tarantool::space::Space;
+use ::tarantool::tuple::Tuple;
 use raft::eraftpb::ConfState;
 use raft::StorageError;
 use serde::{Deserialize, Serialize};
-use ::tarantool::space::Space;
-use ::tarantool::tuple::Tuple;
-use ::tarantool::index::IteratorType;
+use slog::{debug, o};
 
 use raft::prelude::*;
 use raft::Error as RaftError;
@@ -104,10 +104,13 @@ impl Storage {
         space.replace(&("applied", applied)).unwrap();
     }
 
-    pub fn entries(low: u64, high: u64,) -> Vec<Entry> {
+    pub fn entries(low: u64, high: u64) -> Vec<Entry> {
         let mut ret: Vec<Entry> = vec![];
         let space = Space::find("raft_log").unwrap();
-        let iter = space.primary_key().select(IteratorType::GE, &(low,)).unwrap();
+        let iter = space
+            .primary_key()
+            .select(IteratorType::GE, &(low,))
+            .unwrap();
 
         for tuple in iter {
             let row: LogRow = tuple.into_struct().unwrap();
@@ -177,13 +180,12 @@ impl raft::Storage for Storage {
         let space = Space::find("raft_log").unwrap();
 
         let tuple = space.primary_key().get(&(idx,)).unwrap();
-        let row: Option<LogRow> = tuple
-            .and_then(|t| t.into_struct().unwrap());
+        let row: Option<LogRow> = tuple.and_then(|t| t.into_struct().unwrap());
 
         let logger = slog::Logger::root(crate::tarantool::SlogDrain, o!());
         if let Some(row) = row {
             debug!(logger, "+++ term(idx={}) -> {:?}", idx, row.raft_term);
-            return Ok(row.raft_term)
+            return Ok(row.raft_term);
         } else {
             debug!(logger, "+++ term(idx={}) -> Unavailable", idx);
             return Err(RaftError::Store(StorageError::Unavailable));
@@ -197,11 +199,8 @@ impl raft::Storage for Storage {
     fn last_index(&self) -> Result<u64, RaftError> {
         let space: Space = Space::find("raft_log").unwrap();
         let tuple: Option<Tuple> = space.primary_key().max(&()).unwrap();
-        let row: Option<LogRow> = tuple
-            .and_then(|t| t.into_struct().unwrap());
-        let ret: u64 = row
-            .map(|row| row.raft_index)
-            .unwrap_or(0);
+        let row: Option<LogRow> = tuple.and_then(|t| t.into_struct().unwrap());
+        let ret: u64 = row.map(|row| row.raft_index).unwrap_or(0);
 
         let logger = slog::Logger::root(crate::tarantool::SlogDrain, o!());
         debug!(logger, "+++ last_index() -> {:?}", ret);
@@ -210,7 +209,10 @@ impl raft::Storage for Storage {
 
     fn snapshot(&self, request_index: u64) -> Result<Snapshot, RaftError> {
         let logger = slog::Logger::root(crate::tarantool::SlogDrain, o!());
-        debug!(logger, "+++ snapshot(idx={}) -> unimplemented", request_index);
+        debug!(
+            logger,
+            "+++ snapshot(idx={}) -> unimplemented", request_index
+        );
         unimplemented!();
     }
 }
@@ -251,7 +253,6 @@ impl From<LogRow> for Entry {
         ret.set_data(row.data.into());
         ret
     }
-
 }
 
 impl ::tarantool::tuple::AsTuple for LogRow {}