Update drone module to return airdrop tx signature

Cargo.toml

@@ -68,6 +68,7 @@ atty = "0.2"
 bincode = "1.0.0"
 bs58 = "0.2.0"
 byteorder = "1.2.1"
+bytes = "0.4"
 chrono = { version = "0.4.0", features = ["serde"] }
 clap = "2.31"
 dirs = "1.0.2"

src/bin/drone.rs

@@ -1,4 +1,5 @@
 extern crate bincode;
+extern crate bytes;
 #[macro_use]
 extern crate clap;
 extern crate serde_json;
@@ -6,7 +7,8 @@ extern crate solana;
 extern crate tokio;
 extern crate tokio_codec;
 
-use bincode::deserialize;
+use bincode::{deserialize, serialize};
+use bytes::Bytes;
 use clap::{App, Arg};
 use solana::crdt::NodeInfo;
 use solana::drone::{Drone, DroneRequest, DRONE_PORT};
@@ -18,6 +20,7 @@ use solana::signature::read_keypair;
 use solana::thin_client::poll_gossip_for_leader;
 use std::error;
 use std::fs::File;
+use std::io;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use std::process::exit;
 use std::sync::{Arc, Mutex};
@@ -150,12 +153,10 @@ fn main() -> Result<(), Box<error::Error>> {
             let drone2 = drone.clone();
             // let client_ip = socket.peer_addr().expect("drone peer_addr").ip();
             let framed = BytesCodec::new().framed(socket);
-            let (_writer, reader) = framed.split();
+            let (writer, reader) = framed.split();
 
-            let processor = reader
+            let processor = reader.and_then(move |bytes| {
-                .for_each(move |bytes| {
                 let req: DroneRequest = deserialize(&bytes).or_else(|err| {
-                        use std::io;
                     Err(io::Error::new(
                         io::ErrorKind::Other,
                         format!("deserialize packet in drone: {:?}", err),
@@ -169,13 +170,26 @@ fn main() -> Result<(), Box<error::Error>> {
                     Ok(_) => println!("Airdrop sent!"),
                     Err(_) => println!("Request limit reached for this time slice"),
                 }
-                    Ok(())
+                let response = res1?;
-                })
+                println!("Airdrop tx signature: {:?}", response);
-                .then(|result| {
+                let response_vec = serialize(&response).or_else(|err| {
-                    println!("Socket closed with result: {:?}", result);
+                    Err(io::Error::new(
-                    Ok(())
+                        io::ErrorKind::Other,
+                        format!("serialize signature in drone: {:?}", err),
+                    ))
+                })?;
+                let response_bytes = Bytes::from(response_vec.clone());
+                Ok(response_bytes)
             });
-            tokio::spawn(processor)
+            let server = writer
+                .send_all(processor.or_else(|err| {
+                    Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        format!("Drone response: {:?}", err),
+                    ))
+                }))
+                .then(|_| Ok(()));
+            tokio::spawn(server)
         });
     tokio::run(done);
     Ok(())