Remove stratum_common::url

Use `hyper::Uri` exported from `rpc_sv2` instead.

Author: jbesraa

common/src/lib.rs

@@ -5,4 +5,3 @@
 #[cfg(feature = "bitcoin")]
 pub use bitcoin;
 pub use secp256k1;
-pub mod url;

roles/jd-server/src/lib/config.rs

@@ -185,18 +185,11 @@ mod tests {
         settings.try_deserialize().expect("Failed to parse config")
     }
 
-    #[tokio::test]
-    async fn test_invalid_rpc_url() {
-        let mut config = load_config("config-examples/jds-config-hosted-example.toml");
-        config.set_core_rpc_url("invalid".to_string());
-        assert!(JobDeclaratorServer::new(config).is_err());
-    }
-
     #[tokio::test]
     async fn test_offline_rpc_url() {
         let mut config = load_config("config-examples/jds-config-hosted-example.toml");
         config.set_core_rpc_url("http://127.0.0.1".to_string());
-        let jd = JobDeclaratorServer::new(config).unwrap();
+        let jd = JobDeclaratorServer::new(config);
         assert!(jd.start().await.is_err());
     }
 

roles/jd-server/src/lib/mempool/mod.rs

@@ -19,15 +19,15 @@ pub struct TransactionWithHash {
 pub struct JDsMempool {
     pub mempool: HashMap<Txid, Option<(Transaction, u32)>>,
     auth: mini_rpc_client::Auth,
-    url: String,
+    url: rpc_sv2::Uri,
     new_block_receiver: Receiver<String>,
 }
 
 impl JDsMempool {
     pub fn get_client(&self) -> Option<mini_rpc_client::MiniRpcClient> {
-        let url = self.url.as_str();
+        let url = self.url.to_string();
         if url.contains("http") {
-            let client = mini_rpc_client::MiniRpcClient::new(url.to_string(), self.auth.clone());
+            let client = mini_rpc_client::MiniRpcClient::new(self.url.clone(), self.auth.clone());
             Some(client)
         } else {
             None
@@ -44,7 +44,7 @@ impl JDsMempool {
     }
 
     pub fn new(
-        url: String,
+        url: rpc_sv2::Uri,
         username: String,
         password: String,
         new_block_receiver: Receiver<String>,

roles/jd-server/src/lib/mod.rs

@@ -11,8 +11,8 @@ use error_handling::handle_result;
 use job_declarator::JobDeclarator;
 use mempool::error::JdsMempoolError;
 use roles_logic_sv2::{parsers::AnyMessage as JdsMessages, utils::Mutex};
-use std::{ops::Sub, sync::Arc};
-use stratum_common::url::is_valid_url;
+pub use rpc_sv2::Uri;
+use std::{ops::Sub, str::FromStr, sync::Arc};
 use tokio::{select, task};
 use tracing::{error, info, warn};
 
@@ -26,23 +26,25 @@ pub struct JobDeclaratorServer {
 }
 
 impl JobDeclaratorServer {
-    pub fn new(config: JobDeclaratorServerConfig) -> Result<Self, Box<JdsError>> {
-        let url = config.core_rpc_url().to_string() + ":" + &config.core_rpc_port().to_string();
-        if !is_valid_url(&url) {
-            return Err(Box::new(JdsError::InvalidRPCUrl));
-        }
-        Ok(Self { config })
+    pub fn new(config: JobDeclaratorServerConfig) -> Self {
+        Self { config }
     }
     pub async fn start(&self) -> Result<(), JdsError> {
-        let config = self.config.clone();
+        let mut config = self.config.clone();
+        // In case the url came with a trailing slash, we remove it to make sure we end up with
+        // `{scheme}://{host}:{port}` format.
+        if config.core_rpc_url().ends_with('/') {
+            config.set_core_rpc_url(config.core_rpc_url().trim_end_matches('/').to_string());
+        }
         let url = config.core_rpc_url().to_string() + ":" + &config.core_rpc_port().to_string();
         let username = config.core_rpc_user();
         let password = config.core_rpc_pass();
         // TODO should we manage what to do when the limit is reaced?
         let (new_block_sender, new_block_receiver): (Sender<String>, Receiver<String>) =
             bounded(10);
+        let url = Uri::from_str(&url.clone()).expect("Invalid core rpc url");
         let mempool = Arc::new(Mutex::new(mempool::JDsMempool::new(
-            url.clone(),
+            url,
             username.to_string(),
             password.to_string(),
             new_block_receiver,
@@ -51,7 +53,7 @@ impl JobDeclaratorServer {
         let mempool_cloned_ = mempool.clone();
         let mempool_cloned_1 = mempool.clone();
         if let Err(e) = mempool::JDsMempool::health(mempool_cloned_1.clone()).await {
-            error!("{:?}", e);
+            error!("JDS Connection with bitcoin core failed {:?}", e);
             return Err(JdsError::MempoolError(e));
         }
         let (status_tx, status_rx) = unbounded();

roles/jd-server/src/main.rs

@@ -104,8 +104,5 @@ async fn main() {
         }
     };
 
-    let _ = lib::JobDeclaratorServer::new(config)
-        .expect("Failed to start JDS")
-        .start()
-        .await;
+    let _ = lib::JobDeclaratorServer::new(config).start().await;
 }

roles/roles-utils/rpc/src/lib.rs

@@ -10,3 +10,5 @@ pub struct Amount(f64);
 
 #[derive(Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct BlockHash(Hash);
+
+pub use hyper::Uri;

roles/roles-utils/rpc/src/mini_rpc_client.rs

@@ -21,12 +21,12 @@ use super::BlockHash;
 #[derive(Clone, Debug)]
 pub struct MiniRpcClient {
     client: Client<HttpConnector, Full<Bytes>>,
-    url: String,
+    url: hyper::Uri,
     auth: Auth,
 }
 
 impl MiniRpcClient {
-    pub fn new(url: String, auth: Auth) -> MiniRpcClient {
+    pub fn new(url: hyper::Uri, auth: Auth) -> MiniRpcClient {
         let client: Client<_, Full<Bytes>> = Client::builder(TokioExecutor::new()).build_http();
         MiniRpcClient { client, url, auth }
     }
@@ -120,7 +120,7 @@ impl MiniRpcClient {
 
         let req = Request::builder()
             .method("POST")
-            .uri(self.url.as_str())
+            .uri(self.url.clone())
             .header(CONTENT_TYPE, "application/json")
             .header(
                 AUTHORIZATION,

roles/tests-integration/lib/mod.rs

@@ -184,8 +184,15 @@ pub async fn start_jds(tp_rpc_connection: &ConnectParams) -> (JobDeclaratorServe
         "036adc3bdf21e6f9a0f0fb0066bf517e5b7909ed1563d6958a10993849a7554075".to_string(),
     )];
     if let Ok(Some(CookieValues { user, password })) = tp_rpc_connection.get_cookie_values() {
+        let ip = tp_rpc_connection.rpc_socket.ip().to_string();
+        let url = jd_server::Uri::builder()
+            .scheme("http")
+            .authority(ip)
+            .path_and_query("")
+            .build()
+            .unwrap();
         let core_rpc = CoreRpc::new(
-            format!("http://{}", tp_rpc_connection.rpc_socket.ip()).to_string(),
+            url.to_string(),
             tp_rpc_connection.rpc_socket.port(),
             user,
             password,
@@ -199,7 +206,7 @@ pub async fn start_jds(tp_rpc_connection: &ConnectParams) -> (JobDeclaratorServe
             core_rpc,
             std::time::Duration::from_secs(1),
         );
-        let job_declarator_server = JobDeclaratorServer::new(config).unwrap();
+        let job_declarator_server = JobDeclaratorServer::new(config);
         let job_declarator_server_clone = job_declarator_server.clone();
         tokio::spawn(async move {
             job_declarator_server_clone.start().await.unwrap();