From 455050e19c2952b6378f368bf70cd6e7b586b43c Mon Sep 17 00:00:00 2001
From: Greg Fitzgerald <garious@gmail.com>
Date: Mon, 14 May 2018 07:16:39 -0600
Subject: [PATCH] Expose the server-side transaction count

---
 src/request.rs           |  2 ++
 src/request_processor.rs |  6 ++++++
 src/thin_client.rs       | 28 ++++++++++++++++++++++++++++
 3 files changed, 36 insertions(+)

diff --git a/src/request.rs b/src/request.rs
index 7575010ad8..402aafc27b 100644
--- a/src/request.rs
+++ b/src/request.rs
@@ -12,6 +12,7 @@ use transaction::Transaction;
 pub enum Request {
     Transaction(Transaction),
     GetBalance { key: PublicKey },
+    GetTransactionCount,
     Subscribe { subscriptions: Vec<Subscription> },
 }
 
@@ -40,6 +41,7 @@ impl Request {
 #[derive(Serialize, Deserialize, Debug)]
 pub enum Response {
     Balance { key: PublicKey, val: Option<i64> },
+    TransactionCount { transaction_count: u64 },
     EntryInfo(EntryInfo),
 }
 
diff --git a/src/request_processor.rs b/src/request_processor.rs
index 6f2f3bd7c9..ad7f76183b 100644
--- a/src/request_processor.rs
+++ b/src/request_processor.rs
@@ -46,6 +46,12 @@ impl RequestProcessor {
                 info!("Response::Balance {:?}", rsp);
                 Some(rsp)
             }
+            Request::GetTransactionCount => {
+                let transaction_count = self.accountant.transaction_count() as u64;
+                let rsp = (Response::TransactionCount { transaction_count }, rsp_addr);
+                info!("Response::TransactionCount {:?}", rsp);
+                Some(rsp)
+            }
             Request::Transaction(_) => unreachable!(),
             Request::Subscribe { subscriptions } => {
                 for subscription in subscriptions {
diff --git a/src/thin_client.rs b/src/thin_client.rs
index 230b2d729e..b5337e75d1 100644
--- a/src/thin_client.rs
+++ b/src/thin_client.rs
@@ -19,6 +19,7 @@ pub struct ThinClient {
     pub events_socket: UdpSocket,
     last_id: Option<Hash>,
     num_events: u64,
+    transaction_count: u64,
     balances: HashMap<PublicKey, Option<i64>>,
 }
 
@@ -33,6 +34,7 @@ impl ThinClient {
             events_socket,
             last_id: None,
             num_events: 0,
+            transaction_count: 0,
             balances: HashMap::new(),
         };
         client.init();
@@ -62,6 +64,10 @@ impl ThinClient {
                 info!("Response balance {:?} {:?}", key, val);
                 self.balances.insert(key, val);
             }
+            Response::TransactionCount { transaction_count } => {
+                info!("Response transaction count {:?}", transaction_count);
+                self.transaction_count = transaction_count;
+            }
             Response::EntryInfo(entry_info) => {
                 trace!("Response entry_info {:?}", entry_info.id);
                 self.last_id = Some(entry_info.id);
@@ -113,6 +119,28 @@ impl ThinClient {
         self.balances[pubkey].ok_or(io::Error::new(io::ErrorKind::Other, "nokey"))
     }
 
+    /// Request the transaction count.  If the response packet is dropped by the network,
+    /// this method will hang.
+    pub fn server_transaction_count(&mut self) -> io::Result<u64> {
+        info!("server_transaction_count");
+        let req = Request::GetTransactionCount;
+        let data =
+            serialize(&req).expect("serialize GetTransactionCount in pub fn transaction_count");
+        self.requests_socket
+            .send_to(&data, &self.addr)
+            .expect("buffer error in pub fn transaction_count");
+        let mut done = false;
+        while !done {
+            let resp = self.recv_response()?;
+            info!("recv_response {:?}", resp);
+            if let &Response::TransactionCount { .. } = &resp {
+                done = true;
+            }
+            self.process_response(resp);
+        }
+        Ok(self.transaction_count)
+    }
+
     /// Request the last Entry ID from the server. This method blocks
     /// until the server sends a response.
     pub fn get_last_id(&mut self) -> FutureResult<Hash, ()> {