From cd968436992d72e99c74df65a4e1f9a7f32a7179 Mon Sep 17 00:00:00 2001
From: Greg Fitzgerald <garious@gmail.com>
Date: Fri, 11 May 2018 23:07:44 -0600
Subject: [PATCH] Free up name ThinClientService

---
 src/entry_writer.rs        | 11 +++++------
 src/thin_client_service.rs |  6 +++---
 src/tpu.rs                 | 14 +++++++-------
 3 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/src/entry_writer.rs b/src/entry_writer.rs
index 38421a72e0..274e1ac344 100644
--- a/src/entry_writer.rs
+++ b/src/entry_writer.rs
@@ -12,22 +12,22 @@ use std::io::sink;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use streamer;
-use thin_client_service::ThinClientService;
+use thin_client_service::RequestProcessor;
 
 pub struct EntryWriter<'a> {
     accounting_stage: &'a AccountingStage,
-    thin_client_service: &'a ThinClientService,
+    request_processor: &'a RequestProcessor,
 }
 
 impl<'a> EntryWriter<'a> {
     /// Create a new Tpu that wraps the given Accountant.
     pub fn new(
         accounting_stage: &'a AccountingStage,
-        thin_client_service: &'a ThinClientService,
+        request_processor: &'a RequestProcessor,
     ) -> Self {
         EntryWriter {
             accounting_stage,
-            thin_client_service,
+            request_processor,
         }
     }
 
@@ -41,8 +41,7 @@ impl<'a> EntryWriter<'a> {
             "{}",
             serde_json::to_string(&entry).expect("'entry' to_strong in fn write_entry")
         ).expect("writeln! in fn write_entry");
-        self.thin_client_service
-            .notify_entry_info_subscribers(&entry);
+        self.request_processor.notify_entry_info_subscribers(&entry);
     }
 
     fn write_entries<W: Write>(&self, writer: &Mutex<W>) -> Result<Vec<Entry>> {
diff --git a/src/thin_client_service.rs b/src/thin_client_service.rs
index f86ff01426..e6eda81334 100644
--- a/src/thin_client_service.rs
+++ b/src/thin_client_service.rs
@@ -62,18 +62,18 @@ pub enum Response {
     EntryInfo(EntryInfo),
 }
 
-pub struct ThinClientService {
+pub struct RequestProcessor {
     //pub output: Mutex<Receiver<Response>>,
     //response_sender: Mutex<Sender<Response>>,
     accountant: Arc<Accountant>,
     entry_info_subscribers: Mutex<Vec<SocketAddr>>,
 }
 
-impl ThinClientService {
+impl RequestProcessor {
     /// Create a new Tpu that wraps the given Accountant.
     pub fn new(accountant: Arc<Accountant>) -> Self {
         //let (response_sender, output) = channel();
-        ThinClientService {
+        RequestProcessor {
             //output: Mutex::new(output),
             //response_sender: Mutex::new(response_sender),
             accountant,
diff --git a/src/tpu.rs b/src/tpu.rs
index 4e25e4e275..dec9116e08 100644
--- a/src/tpu.rs
+++ b/src/tpu.rs
@@ -17,11 +17,11 @@ use std::sync::{Arc, Mutex, RwLock};
 use std::thread::{spawn, JoinHandle};
 use std::time::Duration;
 use streamer;
-use thin_client_service::ThinClientService;
+use thin_client_service::RequestProcessor;
 
 pub struct Tpu {
     accounting_stage: AccountingStage,
-    thin_client_service: ThinClientService,
+    request_processor: RequestProcessor,
 }
 
 type SharedTpu = Arc<Tpu>;
@@ -29,10 +29,10 @@ type SharedTpu = Arc<Tpu>;
 impl Tpu {
     /// Create a new Tpu that wraps the given Accountant.
     pub fn new(accounting_stage: AccountingStage) -> Self {
-        let thin_client_service = ThinClientService::new(accounting_stage.accountant.clone());
+        let request_processor = RequestProcessor::new(accounting_stage.accountant.clone());
         Tpu {
             accounting_stage,
-            thin_client_service,
+            request_processor,
         }
     }
 
@@ -44,7 +44,7 @@ impl Tpu {
         writer: Mutex<W>,
     ) -> JoinHandle<()> {
         spawn(move || loop {
-            let entry_writer = EntryWriter::new(&obj.accounting_stage, &obj.thin_client_service);
+            let entry_writer = EntryWriter::new(&obj.accounting_stage, &obj.request_processor);
             let _ = entry_writer.write_and_send_entries(&broadcast, &blob_recycler, &writer);
             if exit.load(Ordering::Relaxed) {
                 info!("broadcat_service exiting");
@@ -55,7 +55,7 @@ impl Tpu {
 
     pub fn drain_service(obj: SharedTpu, exit: Arc<AtomicBool>) -> JoinHandle<()> {
         spawn(move || {
-            let entry_writer = EntryWriter::new(&obj.accounting_stage, &obj.thin_client_service);
+            let entry_writer = EntryWriter::new(&obj.accounting_stage, &obj.request_processor);
             loop {
                 let _ = entry_writer.drain_entries();
                 if exit.load(Ordering::Relaxed) {
@@ -75,7 +75,7 @@ impl Tpu {
         blob_recycler: packet::BlobRecycler,
     ) -> JoinHandle<()> {
         spawn(move || loop {
-            let e = obj.thin_client_service.process_request_packets(
+            let e = obj.request_processor.process_request_packets(
                 &obj.accounting_stage,
                 &verified_receiver,
                 &responder_sender,