ping fixes

client/src/socket.jsx

@@ -28,14 +28,18 @@ function createSocket(events) {
     // -------------
     //   Outgoing
     // -------------
-    let ping = Date.now();
     function send(msg) {
         console.log('outgoing msg', msg);
-        ping = Date.now();
         msg.token = account && account.token && account.token;
         ws.send(cbor.encode(msg));
     }
 
+    let ping;
+    function sendPing() {
+        ping = Date.now();
+        send({ method: 'ping', params: {} });
+    }
+
     function sendAccountLogin(name, password) {
         send({ method: 'account_login', params: { name, password } });
     }
@@ -230,6 +234,11 @@ function createSocket(events) {
         events.setVboxInfo(info);
     }
 
+    function pong() {
+        events.setPing(Date.now() - ping);
+        setTimeout(sendPing, 1000);
+    }
+
     // -------------
     //   Setup
     // -------------
@@ -248,6 +257,7 @@ function createSocket(events) {
         zone_close: res => console.log(res),
         instance_state: instanceState,
         vbox_info: vboxInfo,
+        pong,
     };
 
     function logout() {
@@ -278,7 +288,6 @@ function createSocket(events) {
         const { method, params } = res;
 
         console.log(res);
-        events.setPing(Date.now() - ping);
 
         // check for error and split into response type and data
         if (res.err) return errHandler(res.err);
@@ -303,6 +312,8 @@ function createSocket(events) {
                 sendAccountCryps();
             }
 
+            sendPing();
+
             return true;
         });
 

server/src/net.rs

@@ -1,7 +1,7 @@
+use failure::{Error, err_msg};
 use tungstenite::Message;
 use tungstenite::protocol::WebSocket;
 use tungstenite::server::accept;
-use tungstenite::error::Error;
 use tungstenite::Message::Binary;
 use std::net::{TcpListener, TcpStream};
 use serde_cbor::{to_vec};
@@ -35,18 +35,19 @@ struct RpcErrorResponse {
     err: String
 }
 
-fn receive(db: Db, rpc: &Rpc, msg: Message, client: &mut WebSocket<TcpStream>) -> Result<(), Error> {
+fn receive(db: Db, rpc: &Rpc, msg: Message, client: &mut WebSocket<TcpStream>) -> Result<String, Error> {
     match rpc.receive(msg, &db, client) {
         Ok(reply) => {
             let response = to_vec(&reply)
                 .expect("failed to serialize response");
-            client.write_message(Binary(response))
+            client.write_message(Binary(response))?;
+            return Ok(reply.method);
         },
         Err(e) => {
-            info!("{:?}", e);
             let response = to_vec(&RpcErrorResponse { err: e.to_string() })
                 .expect("failed to serialize error response");
-            client.write_message(Binary(response))
+            client.write_message(Binary(response))?;
+            return Err(err_msg(e));
         }
     }
 }
@@ -120,8 +121,13 @@ pub fn start() {
                         let begin = Instant::now();
                         let db_connection = db.get().expect("unable to get db connection");
                         match receive(db_connection, &rpc, msg, &mut websocket) {
-                            Ok(_r) => info!("response sent. total duration: {:?}", begin.elapsed()),
+                            Ok(method) => {
-                            Err(e) => info!("{:?}", e),
+                                match method.as_ref() {
+                                    "pong" => (),
+                                    _ => info!("response sent. total duration: {:?}", begin.elapsed()),
+                                }
+                            },
+                            Err(e) => warn!("{:?}", e),
                         }
                     },
                     // connection is closed

server/src/rpc.rs

@@ -35,6 +35,10 @@ impl Rpc {
         // cast the msg to this type to receive method name
         match from_slice::<RpcMessage>(&data) {
             Ok(v) => {
+                if v.method == "ping" {
+                    return Ok(RpcResponse { method: "pong".to_string(), params: RpcResult::Pong(()) });
+                }
+
                 info!("message method: {:?}", v.method);
                 let mut tx = db.transaction()?;
 
@@ -382,7 +386,7 @@ impl Rpc {
 
 #[derive(Debug,Clone,Serialize,Deserialize)]
 pub struct RpcResponse {
-    method: String,
+    pub method: String,
     params: RpcResult,
 }
 
@@ -402,6 +406,8 @@ pub enum RpcResult {
 
     InstanceList(Vec<Instance>),
     InstanceState(Instance),
+
+    Pong(()),
 }
 
 #[derive(Debug,Clone,Serialize,Deserialize)]