Apply code auto-format for pool service.

Signed-off-by: Sergey Minaev <[email protected]>

Author: jovfer

libindy/src/services/pool/catchup.rs

@@ -1,12 +1,11 @@
-use std::collections::HashMap;
-use std::collections::HashSet;
-use errors::pool::PoolError;
 use errors::common::CommonError;
+use errors::pool::PoolError;
 use services::ledger::merkletree::merkletree::MerkleTree;
 use services::pool::merkle_tree_factory;
 use services::pool::rust_base58::{FromBase58, ToBase58};
-use services::pool::types::{Message, CatchupReq};
-
+use services::pool::types::{CatchupReq, Message};
+use std::collections::HashMap;
+use std::collections::HashSet;
 use super::indy_crypto::utils::json::JsonEncodable;
 
 pub enum CatchupProgress {
@@ -50,7 +49,7 @@ pub fn check_nodes_responses_on_status(nodes_votes: &HashMap<(String, usize, Opt
     if let Some((most_popular_vote, votes_cnt)) = nodes_votes.iter().map(|(key, val)| (key, val.len())).max_by_key(|entry| entry.1) {
         if votes_cnt == node_count - f {
             if most_popular_vote.0.eq("timeout") {
-                return Err(PoolError::Timeout)
+                return Err(PoolError::Timeout);
             }
             return _try_to_catch_up(most_popular_vote, merkle_tree).or_else(|err| {
                 if merkle_tree_factory::drop_cache(pool_name).is_ok() {

libindy/src/services/pool/commander.rs

@@ -1,10 +1,9 @@
 extern crate byteorder;
 
-use self::byteorder::{ByteOrder, LittleEndian};
-
-use super::zmq;
 use errors::common::CommonError;
+use self::byteorder::{ByteOrder, LittleEndian};
 use services::pool::events::PoolEvent;
+use super::zmq;
 
 pub struct Commander {
     cmd_socket: zmq::Socket,
@@ -30,15 +29,15 @@ impl Commander {
                 CommonError::InvalidState(format!("Invalid command received: {:?}", err)))
             .map_err(map_err_trace!()) {
             Ok(cmd) => cmd,
-            Err(_) => {return None;}
+            Err(_) => { return None; }
         };
         let id = cmd.get(1).map(|cmd: &Vec<u8>| LittleEndian::read_i32(cmd.as_slice()))
             .unwrap_or(-1);
         if "exit".eq(cmd_s.as_str()) {
             Some(PoolEvent::Close(id))
         } else if "refresh".eq(cmd_s.as_str()) {
             Some(PoolEvent::Refresh(id))
-        } else if "connect".eq(cmd_s.as_str()){
+        } else if "connect".eq(cmd_s.as_str()) {
             Some(PoolEvent::CheckCache(id))
         } else {
             Some(PoolEvent::SendRequest(id, cmd_s))

libindy/src/services/pool/events.rs

@@ -1,17 +1,15 @@
-use services::pool::types::*;
-use errors::common::CommonError;
 use domain::ledger::constants;
-
+use errors::common::CommonError;
+use errors::pool::PoolError;
+use self::indy_crypto::utils::json::JsonEncodable;
 use serde_json;
 use serde_json::Value as SJsonValue;
-use std::error::Error;
 use services::ledger::merkletree::merkletree::MerkleTree;
-use errors::pool::PoolError;
+use services::pool::types::*;
+use std::error::Error;
 
 extern crate indy_crypto;
 
-use self::indy_crypto::utils::json::JsonEncodable;
-
 
 pub const REQUESTS_FOR_STATE_PROOFS: [&'static str; 7] = [
     constants::GET_NYM,
@@ -84,20 +82,20 @@ pub enum PoolEvent {
     Timeout(
         String, //req_id
         String, //node alias
-    )
+    ),
 }
 
 #[derive(Clone, Debug)]
 pub enum RequestEvent {
     LedgerStatus(
         LedgerStatus,
         Option<String>, //node alias
-        Option<MerkleTree>
+        Option<MerkleTree>,
     ),
     CatchupReq(
         MerkleTree,
         usize, // target mt size
-        Vec<u8> // target mt root
+        Vec<u8>, // target mt root
     ),
     Timeout(
         String, //req_id
@@ -182,7 +180,7 @@ impl Into<Option<RequestEvent>> for PoolEvent {
                         Message::ConsistencyProof(cp) => RequestEvent::ConsistencyProof(cp, node_alias),
                         Message::Reply(rep) => {
                             let req_id = rep.req_id();
-                            RequestEvent::Reply(rep, msg, node_alias,req_id.to_string())
+                            RequestEvent::Reply(rep, msg, node_alias, req_id.to_string())
                         }
                         Message::ReqACK(rep) => {
                             let req_id = rep.req_id();
@@ -191,16 +189,16 @@ impl Into<Option<RequestEvent>> for PoolEvent {
                         Message::ReqNACK(rep) => {
                             let req_id = rep.req_id();
                             RequestEvent::ReqNACK(rep, msg, node_alias, req_id.to_string())
-                        },
+                        }
                         Message::Reject(rep) => {
                             let req_id = rep.req_id();
                             RequestEvent::Reject(rep, msg, node_alias, req_id.to_string())
-                        },
+                        }
                         Message::PoolLedgerTxns(_) => RequestEvent::PoolLedgerTxns,
                         Message::Ping => RequestEvent::Ping,
                         Message::Pong => RequestEvent::Pong,
                     })
-            },
+            }
             PoolEvent::SendRequest(_, msg) => {
                 let req_id = _parse_req_id_and_op(&msg);
                 match req_id {
@@ -223,7 +221,7 @@ impl Into<Option<NetworkerEvent>> for RequestEvent {
             RequestEvent::LedgerStatus(ls, _, _) => {
                 let req_id = ls.merkleRoot.clone();
                 Some(NetworkerEvent::SendAllRequest(Message::LedgerStatus(ls).to_json().expect("FIXME"), req_id))
-            },
+            }
             _ => None
         }
     }

libindy/src/services/pool/merkle_tree_factory.rs

@@ -1,23 +1,20 @@
 extern crate byteorder;
 extern crate rmp_serde;
 
-use errors::pool::PoolError;
-use std::path::PathBuf;
-use services::ledger::merkletree::merkletree::MerkleTree;
-use std::fs;
-use std::str::from_utf8;
-use self::byteorder::{LittleEndian, WriteBytesExt, ReadBytesExt};
+use domain::ledger::request::ProtocolVersion;
 use errors::common::CommonError;
-use std::io;
-use std::io::{Read, BufRead, Write};
-use utils::environment::EnvironmentUtils;
+use errors::pool::PoolError;
+use self::byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 use serde_json;
 use serde_json::Value as SJsonValue;
+use services::ledger::merkletree::merkletree::MerkleTree;
+use services::pool::types::{NodeTransaction, NodeTransactionV0, NodeTransactionV1};
+use std::{fs, io};
 use std::collections::HashMap;
-use services::pool::types::NodeTransactionV1;
-use services::pool::types::NodeTransaction;
-use domain::ledger::request::ProtocolVersion;
-use services::pool::types::NodeTransactionV0;
+use std::io::{BufRead, Read, Write};
+use std::path::PathBuf;
+use std::str::from_utf8;
+use utils::environment::EnvironmentUtils;
 
 pub fn create(pool_name: &str) -> Result<MerkleTree, PoolError> {
     let mut p = EnvironmentUtils::pool_path(pool_name);
@@ -93,7 +90,7 @@ fn _from_genesis(file_name: &PathBuf) -> Result<MerkleTree, PoolError> {
     Ok(mt)
 }
 
-pub fn dump_new_txns(pool_name: &str, txns: &Vec<Vec<u8>>) -> Result<(), PoolError>{
+pub fn dump_new_txns(pool_name: &str, txns: &Vec<Vec<u8>>) -> Result<(), PoolError> {
     let mut p = EnvironmentUtils::pool_path(pool_name);
 
     p.push("stored");
@@ -127,7 +124,7 @@ fn _dump_genesis_to_stored(p: &PathBuf, pool_name: &str) -> Result<(), PoolError
     _dump_vec_to_file(&genesis_vec, &mut file)
 }
 
-fn _dump_vec_to_file(v: &Vec<Vec<u8>>, file : &mut fs::File) -> Result<(), PoolError> {
+fn _dump_vec_to_file(v: &Vec<Vec<u8>>, file: &mut fs::File) -> Result<(), PoolError> {
     v.into_iter().map(|vec| {
         file.write_u64::<LittleEndian>(vec.len() as u64).map_err(map_err_trace!())?;
         file.write_all(vec).map_err(map_err_trace!())
@@ -220,14 +217,13 @@ pub fn from_file(txn_file: &str) -> Result<MerkleTree, PoolError> {
 }
 
 
-
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use utils::test::TestUtils;
-    use std::fs;
     use byteorder::LittleEndian;
     use domain::ledger::request::ProtocolVersion;
+    use std::fs;
+    use super::*;
+    use utils::test::TestUtils;
 
     fn _set_protocol_version(version: usize) {
         ProtocolVersion::set(version);
@@ -376,8 +372,8 @@ mod tests {
 
         _write_genesis_txns(&txns_src);
 
-        let merkle_tree =super::create("test").unwrap();
-        let res =super::build_node_state(&merkle_tree);
+        let merkle_tree = super::create("test").unwrap();
+        let res = super::build_node_state(&merkle_tree);
         assert_match!(Err(PoolError::PoolIncompatibleProtocolVersion(_)), res);
     }
 }

libindy/src/services/pool/mod.rs

@@ -1,26 +1,23 @@
-mod types;
 mod catchup;
-//mod transaction_handler;
-mod state_proof;
-//mod pool_worker;
-
-mod pool;
-mod merkle_tree_factory;
-mod networker;
 mod commander;
 mod events;
+mod merkle_tree_factory;
+mod networker;
+mod pool;
 mod request_handler;
+mod state_proof;
+mod types;
 
 extern crate byteorder;
 extern crate digest;
 extern crate hex;
+extern crate indy_crypto;
 extern crate rand;
 extern crate rust_base58;
+extern crate rmp_serde;
 extern crate sha2;
 extern crate time;
 extern crate zmq;
-extern crate rmp_serde;
-extern crate indy_crypto;
 
 
 use self::byteorder::{ByteOrder, LittleEndian};
@@ -503,73 +500,6 @@ mod tests {
         drop_test();
         TestUtils::cleanup_storage();
     }
-//
-//    impl Default for PoolWorker {
-//        fn default() -> Self {
-//            PoolWorker {
-//                pool_id: 0,
-//                cmd_sock: zmq::Context::new().socket(zmq::SocketType::PAIR).unwrap(),
-//                open_cmd_id: 0,
-//                name: "".to_string(),
-//                handler: PoolWorkerHandler::CatchupHandler(CatchupHandler {
-//                    timeout: time::now_utc().add(Duration::seconds(2)),
-//                    ..Default::default()
-//                }),
-//            }
-//        }
-//    }
-
-//    #[test]
-//    fn pool_worker_get_zmq_poll_items_works() {
-//        TestUtils::cleanup_storage();
-//
-//        let pw: PoolWorker = Default::default();
-//
-//        let poll_items = pw.get_zmq_poll_items().unwrap();
-//
-//        assert_eq!(poll_items.len(), pw.handler.nodes().len() + 1);
-//        //TODO compare poll items
-//    }
-
-//    #[test]
-//    fn catchup_handler_start_catchup_works() {
-//        TestUtils::cleanup_storage();
-//
-//        let mut ch: CatchupHandler = Default::default();
-//        let (gt, handle) = nodes_emulator::start();
-//        ch.merkle_tree.append(rmp_serde::to_vec_named(&gt).unwrap()).unwrap();
-//        let mut rn: RemoteNode = RemoteNode::new(&gt).unwrap();
-//        rn.connect(&zmq::Context::new(), &zmq::CurveKeyPair::new().unwrap()).unwrap();
-//        ch.nodes.push(rn);
-//        ch.target_mt_size = 2;
-//
-//        ch.start_catchup().unwrap();
-//
-//        let emulator_msgs: Vec<String> = handle.join().unwrap();
-//        assert_eq!(1, emulator_msgs.len());
-//        let expected_resp: CatchupReq = CatchupReq {
-//            ledgerId: 0,
-//            seqNoStart: 2,
-//            seqNoEnd: 2,
-//            catchupTill: 2,
-//        };
-//        let act_resp = CatchupReq::from_json(emulator_msgs[0].as_str()).unwrap();
-//        assert_eq!(expected_resp, act_resp);
-//    }
-
-//    #[test]
-//    fn remote_node_connect_works_and_can_ping_pong() {
-//        TestUtils::cleanup_storage();
-//
-//        let (gt, handle) = nodes_emulator::start();
-//        let mut rn: RemoteNode = RemoteNode::new(&gt).unwrap();
-//        let ctx = zmq::Context::new();
-//        rn.connect(&ctx, &zmq::CurveKeyPair::new().unwrap()).unwrap();
-//        rn.send_str("pi").expect("send");
-//        rn.zsock.as_ref().expect("sock").poll(zmq::POLLIN, nodes_emulator::POLL_TIMEOUT).expect("poll");
-//        assert_eq!("po", rn.zsock.as_ref().expect("sock").recv_string(zmq::DONTWAIT).expect("recv").expect("string").as_str());
-//        handle.join().expect("join");
-//    }
 
     pub mod nodes_emulator {
         extern crate sodiumoxide;

libindy/src/services/pool/networker.rs

@@ -1,18 +1,17 @@
 extern crate zmq;
 extern crate time;
 
-use self::zmq::PollItem;
-use self::zmq::Socket as ZSocket;
-
 use errors::common::CommonError;
 use errors::pool::PoolError;
+use self::zmq::PollItem;
+use self::zmq::Socket as ZSocket;
 use services::pool::events::*;
 use services::pool::types::*;
-use std::collections::{BTreeMap, HashMap};
 use std::cell::RefCell;
+use std::collections::{BTreeMap, HashMap};
 use super::time::Duration;
-use utils::sequence::SequenceUtils;
 use time::Tm;
+use utils::sequence::SequenceUtils;
 
 pub trait Networker {
     fn new() -> Self;
@@ -354,12 +353,12 @@ impl Networker for MockNetworker {
 
 #[cfg(test)]
 pub mod networker_tests {
-    use super::*;
-    use services::pool::tests::nodes_emulator;
-    use utils::crypto::box_::CryptoBox;
     use services::pool::rust_base58::FromBase58;
+    use services::pool::tests::nodes_emulator;
     use std;
     use std::thread;
+    use super::*;
+    use utils::crypto::box_::CryptoBox;
 
     const REQ_ID: &'static str = "1";
     const MESSAGE: &'static str = "msg";
@@ -634,8 +633,8 @@ pub mod networker_tests {
 
     #[cfg(test)]
     mod pool_connection {
-        use super::*;
         use std::ops::Sub;
+        use super::*;
 
         #[test]
         fn pool_connection_new_works() {