Remove HTTP remnants.

Join the Tim Berners Lee Kicking Club!

Cargo.toml

@@ -61,16 +61,10 @@ async-std = "1.6.2"
 async-rwlock = "1.3.0"
 easy-parallel = "3.1.0"
 
-jsonrpc-core = "18.0.0"
-jsonrpc-derive = "18.0.0"
-jsonrpc-core-client = "18.0.0"
-surf = "2.2.0"
-http-types = "2.9.0"
-async-h1 = "2.3.0"
 async-native-tls = "0.3.3"
+native-tls = "0.2.8"
 toml = "0.5.8"
 
-
 # serde
 serde = { version = "1.0.126", features = ["derive"]}
 

src/error.rs

@@ -1,4 +1,3 @@
-use jsonrpc_core::*;
 use std::fmt;
 
 use crate::client;
@@ -55,7 +54,6 @@ pub enum Error {
     BridgeError(String),
     NotSupportedNetwork,
     SerdeJsonError(String),
-    SurfHttpError(String),
     TomlDeserializeError(String),
     TomlSerializeError(String),
     CashierNoReply,
@@ -110,10 +108,11 @@ impl fmt::Display for Error {
             Error::RocksdbError(ref err) => write!(f, "Rocksdb Error: {}", err),
             Error::JsonRpcError(ref err) => write!(f, "JsonRpc Error: {}", err),
             Error::TreeFull => f.write_str("MerkleTree is full"),
-            Error::NotSupportedNetwork => f.write_str("Not supported network inside cashierd config file"),
+            Error::NotSupportedNetwork => {
+                f.write_str("Not supported network inside cashierd config file")
+            }
             Error::BridgeError(ref err) => write!(f, "Bridge error: {}", err),
             Error::SerdeJsonError(ref err) => write!(f, "Json serialization error: {}", err),
-            Error::SurfHttpError(ref err) => write!(f, "Surf Http error: {}", err),
             Error::TomlDeserializeError(ref err) => write!(f, "Toml parsing error: {}", err),
             Error::TomlSerializeError(ref err) => write!(f, "Toml parsing error: {}", err),
             Error::Base58EncodeError(ref err) => write!(f, "bs58 encode error: {}", err),
@@ -138,19 +137,6 @@ impl From<rocksdb::Error> for Error {
     }
 }
 
-impl From<jsonrpc_core::Error> for Error {
-    fn from(err: jsonrpc_core::Error) -> Error {
-        Error::JsonRpcError(err.to_string())
-    }
-}
-
-// err.fmt();
-impl From<Error> for jsonrpc_core::Error {
-    fn from(err: Error) -> jsonrpc_core::Error {
-        jsonrpc_core::Error::invalid_params(err.to_string())
-    }
-}
-
 impl From<serde_json::Error> for Error {
     fn from(err: serde_json::Error) -> Error {
         Error::SerdeJsonError(err.to_string())
@@ -249,12 +235,6 @@ impl From<crate::service::SolFailed> for Error {
     }
 }
 
-impl From<surf::Error> for Error {
-    fn from(err: surf::Error) -> Error {
-        Error::SurfHttpError(err.to_string())
-    }
-}
-
 impl From<toml::de::Error> for Error {
     fn from(err: toml::de::Error) -> Error {
         Error::TomlDeserializeError(err.to_string())

src/rpc/jsonserver.rs

@@ -1,147 +0,0 @@
-use crate::{Error, Result};
-
-use async_executor::Executor;
-use async_native_tls::TlsAcceptor;
-use async_std::sync::Mutex;
-use http_types::{Request, Response, StatusCode};
-use log::*;
-use smol::Async;
-
-use std::net::TcpListener;
-use std::sync::Arc;
-
-/// Listens for incoming connections and serves them.
-pub async fn listen(
-    executor: Arc<Executor<'_>>,
-    rpc: Arc<RpcInterface>,
-    listener: Async<TcpListener>,
-    tls: Option<TlsAcceptor>,
-    io: Arc<jsonrpc_core::IoHandler>,
-) -> Result<()> {
-    // Format the full host address.
-    let host = match &tls {
-        None => format!("http://{}", listener.get_ref().local_addr()?),
-        Some(_) => format!("https://{}", listener.get_ref().local_addr()?),
-    };
-    debug!(target: "RPC SERVER", "Listening on {}", host);
-
-    loop {
-        // Accept the next connection.
-        debug!(target: "RPC SERVER", "waiting for stream accept [START]");
-        let (stream, _) = listener.accept().await?;
-
-        debug!(target: "RPC SERVER", "stream accepted [END]");
-        // Spawn a background task serving this connection.
-        let task = match &tls {
-            None => {
-                let stream = async_dup::Arc::new(stream);
-                let rpc = rpc.clone();
-                let io2 = io.clone();
-                executor.spawn(async move {
-                    if let Err(err) = async_h1::accept(stream, move |req| {
-                        let rpc = rpc.clone();
-                        rpc.serve(req, io2.clone())
-                    })
-                    .await
-                    {
-                        debug!(target: "RPC SERVER", "Connection error: {:#?}", err);
-                    }
-                })
-            }
-            Some(tls) => {
-                // In case of HTTPS, establish a secure TLS connection first.
-                match tls.accept(stream).await {
-                    Ok(stream) => {
-                        let _stream = async_dup::Arc::new(async_dup::Mutex::new(stream));
-                        executor.spawn(async move {
-                            /*if let Err(err) = async_h1::accept(stream, serve).await {
-                            println!("Connection error: {:#?}", err);
-                            }*/
-                            unimplemented!();
-                        })
-                    }
-                    Err(err) => {
-                        debug!(target: "RPC SERVER", "Failed to establish secure TLS connection: {:#?}", err);
-                        continue;
-                    }
-                }
-            }
-        };
-
-        task.await;
-    }
-}
-
-pub async fn start(
-    executor: Arc<Executor<'_>>,
-    rpc_url: std::net::SocketAddr,
-    io: Arc<jsonrpc_core::IoHandler>,
-) -> Result<()> {
-    let rpc = RpcInterface::new()?;
-    let http = listen(
-        executor.clone(),
-        rpc.clone(),
-        Async::<TcpListener>::bind(rpc_url)?,
-        None,
-        io,
-    );
-
-    executor.spawn(http).detach();
-
-    *rpc.started.lock().await = true;
-
-    Ok(())
-}
-
-#[allow(dead_code)]
-pub struct RpcInterface {
-    pub started: Mutex<bool>,
-    stop_send: async_channel::Sender<()>,
-    stop_recv: async_channel::Receiver<()>,
-}
-
-impl RpcInterface {
-    pub fn new() -> Result<Arc<Self>> {
-        let (stop_send, stop_recv) = async_channel::unbounded::<()>();
-        Ok(Arc::new(Self {
-            started: Mutex::new(false),
-            stop_send,
-            stop_recv,
-        }))
-    }
-
-    pub async fn serve(
-        self: Arc<Self>,
-        mut req: Request,
-        io: Arc<jsonrpc_core::IoHandler>,
-    ) -> http_types::Result<Response> {
-        debug!(target: "RPC INTERFACE", "RPC serving {}", req.url());
-
-        let request = req.body_string().await?;
-
-        debug!(target: "RPC INTERFACE", "JsonRpcInterface::serve() [PROCESSING INPUT]");
-        let response = io
-            .handle_request_sync(&request)
-            .ok_or(Error::BadOperationType)?;
-        debug!(target: "RPC INTERFACE", "JsonRpcInterface::serve() [PROCESSED]");
-
-        let mut res = Response::new(StatusCode::Ok);
-        res.insert_header("Content-Type", "text/plain");
-        res.set_body(response);
-
-        Ok(res)
-    }
-
-    //pub async fn handle_input(self: Arc<Self>) -> Result<jsonrpc_core::IoHandler> {
-    //    debug!(target: "rpc", "JsonRpcInterface::handle_input() [START]");
-    //    let io = jsonrpc_core::IoHandler::new();
-    //    // this is where adapter is needed
-    //    //let io = self.adapter.clone().handle_input(io.clone())?;
-    //    debug!(target: "rpc", "JsonRpcInterface::handle_input() [END]");
-    //    Ok(io)
-    //}
-
-    pub async fn wait_for_quit(self: Arc<Self>) -> Result<()> {
-        Ok(self.stop_recv.recv().await?)
-    }
-}

src/rpc/mod.rs

@@ -1,3 +1,3 @@
 // pub mod adapter;
 pub mod jsonrpc;
-pub mod jsonserver;
+pub mod rpcserver;