error handling + minor cleanup + rpc script

Author: anoushk1234

rpc

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+ssh [email protected] "cd diet-rpc-validator && ./v"
+
+ssh -f -T -N -L 8899:0.0.0.0:8899 [email protected]
+
+ssh -f -T -N -L 8900:0.0.0.0:8900 [email protected]

tinydancer/src/main.rs

@@ -29,6 +29,12 @@
 #![allow(dead_code)]
 #![feature(mutex_unlock)]
 mod tinydancer;
+use crossterm::style::Stylize;
+use reqwest::header::{ACCEPT, CONTENT_TYPE};
+use sampler::{pull_and_verify_shreds, ArchiveConfig};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use spinoff::{spinners, Color, Spinner};
 use std::{
     f32::consts::E,
     fs::{self, File, OpenOptions},
@@ -37,23 +43,17 @@ use std::{
     thread::sleep,
     time::Duration,
 };
-
-use crossterm::style::Stylize;
-use sampler::{pull_and_verify_shreds, ArchiveConfig};
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use spinoff::{spinners, Color, Spinner};
 use tinydancer::{endpoint, Cluster, TinyDancer, TinyDancerConfig};
 mod macros;
 use colored::Colorize;
 mod rpc_wrapper;
 mod sampler;
 mod ui;
 
-use tracing::{info};
-use tracing_subscriber;
-use anyhow::{Result, anyhow};
+use anyhow::{anyhow, Result};
 use clap::{ArgGroup, Parser, Subcommand, *};
+use tracing::info;
+use tracing_subscriber;
 
 #[derive(Parser, Debug)]
 #[clap(author, version, about, long_about = None)]
@@ -93,19 +93,20 @@ pub enum Commands {
     },
     /// Stream the client logs to your terminal
     Logs {
-        #[clap(long, required = false, default_value = "client.log")]
+        #[clap(long, required = false, default_value = "/tmp/client.log")]
         log_path: String,
     },
     /// Edit your client config
     #[clap(subcommand)]
     Config(ConfigSubcommands),
+    // Get the latest slot
     Slot,
 }
 
 #[derive(Debug, Subcommand)]
 pub enum ConfigSubcommands {
     Set {
-        #[clap(long, required = false, default_value = "client.log")]
+        #[clap(long, required = false, default_value = "/tmp/client.log")]
         log_path: String,
         /// The cluster you want to run the client on (Mainnet, Localnet,Devnet, <custom-url>)
         #[clap(long, short, required = false, default_value = "Localnet")]
@@ -114,14 +115,13 @@ pub enum ConfigSubcommands {
     Get,
 }
 
-pub fn get_config_file() -> Result<ConfigSchema> { 
+pub fn get_config_file() -> Result<ConfigSchema> {
     let home_path = std::env::var("HOME")?;
-    let path =  home_path + "/.config/tinydancer/config.json";
+    let path = home_path + "/.config/tinydancer/config.json";
     let config_str = std::fs::read_to_string(path)?;
     Ok(serde_json::from_str::<ConfigSchema>(&config_str)?)
 }
 
-// ~/.config/
 #[tokio::main]
 async fn main() -> Result<()> {
     let args = Args::parse();
@@ -143,7 +143,8 @@ async fn main() -> Result<()> {
             shred_archive_duration,
             tui_monitor,
         } => {
-            let config_file = get_config_file().map_err(|_| anyhow!("tinydancer config not set"))?;
+            let config_file =
+                get_config_file().map_err(|_| anyhow!("tinydancer config not set"))?;
             let config = TinyDancerConfig {
                 enable_ui_service,
                 rpc_endpoint: get_cluster(config_file.cluster),
@@ -162,16 +163,39 @@ async fn main() -> Result<()> {
         }
 
         Commands::Slot => {
-            let config_file = get_config_file().map_err(|_| anyhow!("tinydancer config not set"))?;
-            let slot_res = send_rpc_call!(
-                get_endpoint(config_file.cluster),
-                serde_json::json!({"jsonrpc":"2.0","id":1, "method":"getSlot"}).to_string()
-            );
-            let slot = serde_json::from_str::<GetSlotResponse>(slot_res.as_str());
+            let config_file =
+                get_config_file().map_err(|_| anyhow!("tinydancer config not set"))?;
+            let slot_res = {
+                let req_client = reqwest::Client::new();
+                let res = req_client
+                    .post(get_endpoint(config_file.cluster))
+                    .body(
+                        serde_json::json!({"jsonrpc":"2.0","id":1, "method":"getSlot"}).to_string(),
+                    )
+                    .header(CONTENT_TYPE, "application/json")
+                    .header(ACCEPT, "application/json")
+                    .send()
+                    .await;
+
+                res
+            };
+
+            match slot_res {
+                Ok(get_slot_response) => {
+                    let slot_text = get_slot_response.text().await.map_err(|e| {
+                        anyhow!("Failed to get slot due to error: {}", e.to_string())
+                    })?;
 
-            match slot {
-                Ok(slot) => {
-                    println!("Slot: {}", slot.result.to_string().green(),);
+                    let slot = serde_json::from_str::<GetSlotResponse>(&slot_text.as_str());
+
+                    match slot {
+                        Ok(slot) => {
+                            println!("Slot: {}", slot.result.to_string().green(),);
+                        }
+                        Err(e) => {
+                            println!("Failed to get slot due to error: {}", e.to_string().red());
+                        }
+                    }
                 }
                 Err(e) => {
                     println!("Failed to get slot,due to error: {}", e.to_string().red());
@@ -223,24 +247,21 @@ async fn main() -> Result<()> {
                 }
                 sleep(Duration::from_secs(1));
 
-                let config_file = get_config_file(); 
+                let config_file = get_config_file();
                 match config_file {
                     Ok(mut config_file) => {
                         // overwrite
                         config_file.log_path = log_path;
                         config_file.cluster = cluster;
-                        std::fs::write(
-                            config_path,
-                            serde_json::to_string_pretty(&config_file)?,
-                        )?;
+                        std::fs::write(config_path, serde_json::to_string_pretty(&config_file)?)?;
                     }
                     Err(_) => {
                         // initialize
                         std::fs::write(
                             config_path,
                             serde_json::to_string_pretty(&serde_json::json!({
                                 "cluster":"Localnet",
-                                "logPath":"client.log"
+                                "logPath":"/tmp/client.log"
                             }))?,
                         )?;
                     }
@@ -254,7 +275,8 @@ async fn main() -> Result<()> {
                 Color::Green,
             );
 
-            let config_file = get_config_file().map_err(|_| anyhow!("tinydancer config not set"))?;
+            let config_file =
+                get_config_file().map_err(|_| anyhow!("tinydancer config not set"))?;
             let is_verified = pull_and_verify_shreds(slot, get_endpoint(config_file.cluster)).await;
 
             if is_verified {

tinydancer/src/tinydancer.rs

@@ -58,26 +58,6 @@ use std::io;
 use std::io::ErrorKind;
 use std::path::PathBuf;
 
-// use tiny_logger::logs::info;
-pub fn get_project_root() -> io::Result<PathBuf> {
-    let path = env::current_dir()?;
-    let path_ancestors = path.as_path().ancestors();
-
-    for p in path_ancestors {
-        let has_cargo = read_dir(p)?.any(|p| p.unwrap().file_name() == *"Cargo.lock");
-        if has_cargo {
-            let mut path = PathBuf::from(p);
-            // path.push("log");
-            path.push("client.log");
-            return Ok(path);
-        }
-    }
-    Err(io::Error::new(
-        ErrorKind::NotFound,
-        "Ran out of places to find Cargo.toml",
-    ))
-}
-
 impl TinyDancer {
     pub async fn start(config: TinyDancerConfig) -> Result<()> {
         let status = ClientStatus::Initializing(String::from("Starting Up Tinydancer"));