draft: server: rpc client

backend/Cargo.toml

@@ -22,4 +22,4 @@ features = ["chrono"]
 
 [dependencies.rocket]
 version = "^0.5.0-rc.1"
-features = ["json", "secrets", "tls"]
+features = ["json", "secrets", "tls"]

backend/src/daemon/rpc.rs

@@ -1,27 +1,36 @@
-use crate::models::status::DaemonStatus;
+use crate::models::status::Status;
 use crate::rpc::WeywotRpc;
-use chrono::Local;
+use chrono::{DateTime, Local};
 use jsonrpc_core::Result as JsonRpcResult;
 use procfs::process::Process;
 use std::convert::TryInto;
-use std::error::Error;
+use std::num::TryFromIntError;
 use std::process;
 
 pub struct RpcDaemon;
 
 impl WeywotRpc for RpcDaemon {
-    fn status(&self) -> JsonRpcResult<DaemonStatus> {
-        Ok(DaemonStatus {
+    fn status(&self) -> JsonRpcResult<Status> {
+        let pid: Result<i32, TryFromIntError> = process::id().try_into();
+        let runtime: i64 = if let Ok(pid) = pid {
+            if let Ok(proc) = Process::new(pid) {
+                let now: DateTime<Local> = Local::now();
+                if let Ok(starttime) = proc.stat.starttime() {
+                    let etime = now - starttime;
+                    etime.num_seconds()
+                } else {
+                    0
+                }
+            } else {
+                0
+            }
+        } else {
+            0
+        };
+
+        Ok(Status {
             version: env!("CARGO_PKG_VERSION").into(),
-            runtime: proc_runtime().unwrap_or(0),
+            runtime: runtime,
         })
     }
 }
-
-fn proc_runtime() -> Result<i64, Box<dyn Error>> {
-    let pid: i32 = process::id().try_into()?;
-    let proc = Process::new(pid)?;
-    let starttime = proc.stat.starttime()?;
-    let now = Local::now();
-    Ok((now - starttime).num_seconds())
-}

backend/src/models/status.rs

@@ -1,18 +1,7 @@
 use serde::{Deserialize, Serialize};
-
 #[derive(Debug, Deserialize, Serialize)]
-pub struct DaemonStatus {
+pub struct Status {
     pub version: String,
     pub runtime: i64,
 }
 
-#[derive(Debug, Serialize)]
-pub struct WebServerStatus {
-    pub version: String,
-}
-
-#[derive(Debug, Serialize)]
-pub struct StatusResponse {
-    pub daemon: DaemonStatus,
-    pub web: WebServerStatus,
-}

backend/src/rpc.rs

@@ -1,9 +1,9 @@
-use crate::models::status::DaemonStatus;
+use crate::models::status::Status;
 use jsonrpc_core::Result;
 use jsonrpc_derive::rpc;
 
 #[rpc]
 pub trait WeywotRpc {
     #[rpc(name = "status")]
-    fn status(&self) -> Result<DaemonStatus>;
+    fn status(&self) -> Result<Status>;
 }

backend/src/server/context.rs

@@ -1,8 +1,5 @@
 use crate::rpc::gen_client::Client;
-use crate::server::error::{ApiError, ErrorResponse};
 use jsonrpc_core_client::transports::ipc::connect;
-use rocket::http::Status as HttpStatus;
-use rocket::serde::json::Json;
 use std::path::PathBuf;
 
 pub struct Context {
@@ -16,16 +13,13 @@ impl Context {
         }
     }
 
-    pub async fn client(&self) -> Result<Client, ApiError> {
+    pub async fn client(&self) -> Option<Client> {
         match connect(&self.socket_path).await {
-            Ok(client) => Ok(client),
-            Err(e) => Err((
-                HttpStatus::ServiceUnavailable,
-                Json(ErrorResponse::new(format!(
-                    "Cannot connect to daemon: {}",
-                    e
-                ))),
-            )),
+            Ok(client) => Some(client),
+            Err(e) => {
+                eprintln!("{}", e);
+                None
+            }
         }
     }
 }

backend/src/server/error.rs

@@ -1,18 +0,0 @@
-use rocket::http::Status as HttpStatus;
-use rocket::serde::json::Json;
-use rocket::serde::Serialize;
-
-#[derive(Serialize)]
-pub struct ErrorResponse {
-    pub error: String,
-}
-
-pub type ApiError = (HttpStatus, Json<ErrorResponse>);
-
-impl ErrorResponse {
-    pub fn new<S: Into<String>>(message: S) -> Self {
-        Self {
-            error: message.into(),
-        }
-    }
-}

backend/src/server/mod.rs

@@ -1,6 +1,5 @@
 mod config;
 mod context;
-mod error;
 mod routes;
 use config::Config;
 

backend/src/server/routes/status.rs

@@ -1,18 +1,16 @@
-use crate::models::status::{StatusResponse, WebServerStatus};
+use crate::models::status::Status;
 use crate::server::context::Context;
-use crate::server::error::ApiError;
+use rocket::http::Status as HttpStatus;
 use rocket::serde::json::Json;
 use rocket::State;
 
 #[rocket::get("/status")]
 pub async fn get_status(
     state: &State<Context>,
-) -> Result<Json<StatusResponse>, ApiError> {
-    let client = state.client().await?;
-    Ok(Json(StatusResponse {
-        daemon: client.status().await.unwrap(),
-        web: WebServerStatus {
-            version: env!("CARGO_PKG_VERSION").into(),
-        },
-    }))
+) -> Result<Json<Status>, HttpStatus> {
+    if let Some(client) = state.client().await {
+        Ok(Json(client.status().await.unwrap()))
+    } else {
+        Err(HttpStatus::ServiceUnavailable)
+    }
 }