[mixnode] replace rocket with axum

common/mixnode-common/src/verloc/measurement.rs

@@ -9,6 +9,7 @@ use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::RwLock;
 
+#[derive(Clone)]
 pub struct AtomicVerlocResult {
     inner: Arc<RwLock<VerlocResult>>,
 }
@@ -35,13 +36,6 @@ impl AtomicVerlocResult {
         }
     }
 
-    // this could have also been achieved with a normal #[derive(Clone)] but I prefer to be explicit about it
-    pub(crate) fn clone_data_pointer(&self) -> Self {
-        AtomicVerlocResult {
-            inner: Arc::clone(&self.inner),
-        }
-    }
-
     pub(crate) async fn reset_results(&self, new_tested: usize) {
         let mut write_permit = self.inner.write().await;
         write_permit.total_tested = new_tested;

common/mixnode-common/src/verloc/mod.rs

@@ -226,7 +226,7 @@ impl VerlocMeasurer {
     }
 
     pub fn get_verloc_results_pointer(&self) -> AtomicVerlocResult {
-        self.results.clone_data_pointer()
+        self.results.clone()
     }
 
     fn start_listening(&self) -> JoinHandle<()> {

gateway/Cargo.toml

@@ -52,7 +52,7 @@ tokio = { workspace = true, features = [
 tokio-stream = { version = "0.1.11", features = ["fs"] }
 tokio-tungstenite = { version = "0.20.1" }
 tokio-util = { version = "0.7.4", features = ["codec"] }
-url = { version = "2.2", features = ["serde"] }
+url = { workspace = true, features = ["serde"] }
 zeroize = { workspace = true }
 
 # internal

mixnode/Cargo.toml

@@ -16,6 +16,7 @@ rust-version = "1.58.1"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+axum = { workspace = true }
 anyhow = "1.0.40"
 bs58 = "0.4.0"
 clap = { version = "4.0", features = ["cargo", "derive"] }
@@ -28,22 +29,24 @@ lazy_static = "1.4.0"
 log = { workspace = true }
 pretty_env_logger = "0.4.0"
 rand = "0.7.3"
-rocket = { version = "0.5.0-rc.2", features = ["json"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 sysinfo = "0.27.7"
 tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal"] }
 tokio-util = { version = "0.7.3", features = ["codec"] }
 toml = "0.5.8"
-url = { version = "2.2", features = ["serde"] }
+url = { workspace = true, features = ["serde"] }
 cfg-if = "1.0.0"
+thiserror = { workspace = true }
 
 ## tracing
 tracing = { version = "0.1.37", optional = true }
 opentelemetry = { version = "0.19.0", optional = true }
 
 
-## internal
+# internal
+nym-node = { path = "../nym-node" }
+
 nym-config = { path = "../common/config" }
 nym-crypto = { path = "../common/crypto" }
 nym-contracts-common = { path = "../common/cosmwasm-smart-contracts/contracts-common" }

mixnode/src/commands/mod.rs

@@ -7,6 +7,7 @@ use anyhow::anyhow;
 use clap::CommandFactory;
 use clap::Subcommand;
 use colored::Colorize;
+use log::{error, info, warn};
 use nym_bin_common::completions::{fig_generate, ArgShell};
 use nym_bin_common::version_checker;
 use nym_config::defaults::var_names::{BECH32_PREFIX, NYM_API};

mixnode/src/commands/run.rs

@@ -6,11 +6,11 @@ use crate::commands::{override_config, try_load_current_config, version_check};
 use crate::node::MixNode;
 use anyhow::bail;
 use clap::Args;
+use log::error;
 use nym_bin_common::output_format::OutputFormat;
 use nym_config::helpers::SPECIAL_ADDRESSES;
 use nym_validator_client::nyxd;
 use std::net::IpAddr;
-
 #[derive(Args, Clone)]
 pub(crate) struct Run {
     /// Id of the nym-mixnode we want to run

mixnode/src/commands/sign.rs

@@ -5,15 +5,13 @@ use crate::commands::{try_load_current_config, validate_bech32_address_or_exit};
 use crate::node::MixNode;
 use anyhow::{bail, Result};
 use clap::{ArgGroup, Args};
+use log::error;
 use nym_bin_common::output_format::OutputFormat;
 use nym_crypto::asymmetric::identity;
 use nym_types::helpers::ConsoleSigningOutput;
 use nym_validator_client::nyxd;
 use std::convert::TryFrom;
 
-#[cfg(feature = "cpucycles")]
-use tracing::error;
-
 use super::version_check;
 
 #[derive(Args, Clone)]

mixnode/src/error.rs

@@ -0,0 +1,11 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub(crate) enum MixnodeError {
+    // TODO: in the future this should work the other way, i.e. NymNode depending on Gateway errors
+    #[error(transparent)]
+    NymNodeError(#[from] nym_node::error::NymNodeError),
+}

mixnode/src/main.rs

@@ -1,12 +1,10 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-#[macro_use]
-extern crate rocket;
-
 use ::nym_config::defaults::setup_env;
 use clap::{crate_name, crate_version, Parser};
 use lazy_static::lazy_static;
+use log::info;
 use nym_bin_common::bin_info;
 
 #[allow(unused_imports)]
@@ -20,6 +18,7 @@ use tracing::instrument;
 
 mod commands;
 mod config;
+pub(crate) mod error;
 mod node;
 
 lazy_static! {

mixnode/src/node/http/description.rs

@@ -1,9 +1,14 @@
 use crate::node::node_description::NodeDescription;
-use rocket::serde::json::Json;
-use rocket::State;
+use axum::extract::Query;
+use nym_node::http::api::{FormattedResponse, OutputParams};
 
 /// Returns a description of the node and why someone might want to delegate stake to it.
-#[get("/description")]
-pub(crate) fn description(description: &State<NodeDescription>) -> Json<NodeDescription> {
-    Json(description.inner().clone())
+pub(crate) async fn description(
+    description: NodeDescription,
+    Query(output): Query<OutputParams>,
+) -> MixnodeDescriptionResponse {
+    let output = output.output.unwrap_or_default();
+    output.to_response(description)
 }
+
+pub type MixnodeDescriptionResponse = FormattedResponse<NodeDescription>;

mixnode/src/node/http/hardware.rs

@@ -1,18 +1,18 @@
+use axum::extract::Query;
 use cupid::TopologyType;
-use rocket::serde::{json::Json, Serialize};
+use nym_node::http::api::{FormattedResponse, OutputParams};
+use serde::Serialize;
 use sysinfo::{System, SystemExt};
 
 #[derive(Serialize, Debug)]
-#[serde(crate = "rocket::serde")]
-pub(crate) struct Hardware {
+pub struct Hardware {
     ram: String,
     num_cores: usize,
     crypto_hardware: Option<CryptoHardware>,
 }
 
 #[allow(clippy::struct_excessive_bools)]
 #[derive(Serialize, Debug)]
-#[serde(crate = "rocket::serde")]
 pub(crate) struct CryptoHardware {
     aesni: bool,
     avx2: bool,
@@ -24,11 +24,13 @@ pub(crate) struct CryptoHardware {
 }
 
 /// Provides hardware information which Nym can use to optimize mixnet speed over time (memory, crypto hardware, CPU, cores, etc).
-#[get("/hardware")]
-pub(crate) fn hardware() -> Json<Option<Hardware>> {
-    Json(hardware_info())
+pub(crate) async fn hardware(Query(output): Query<OutputParams>) -> MixnodeHardwareResponse {
+    let output = output.output.unwrap_or_default();
+    output.to_response(hardware_info())
 }
 
+pub type MixnodeHardwareResponse = FormattedResponse<Option<Hardware>>;
+
 /// Gives back a summary report of whatever system hardware info we can get for this platform.
 fn hardware_info() -> Option<Hardware> {
     let crypto_hardware = hardware_info_from_cupid();

mixnode/src/node/http/mod.rs

@@ -1,11 +1,15 @@
 pub(crate) mod description;
 pub(crate) mod hardware;
+pub(crate) mod state;
 pub(crate) mod stats;
 pub(crate) mod verloc;
 
-use rocket::Request;
+use axum::http::{StatusCode, Uri};
+use axum::response::IntoResponse;
 
-#[catch(404)]
-pub(crate) fn not_found(req: &Request<'_>) -> String {
-    format!("I couldn't find '{}'. Try something else?", req.uri())
+pub(crate) async fn not_found(uri: Uri) -> impl IntoResponse {
+    (
+        StatusCode::NOT_FOUND,
+        format!("I couldn't find '{uri}'. Try something else?"),
+    )
 }

mixnode/src/node/http/state.rs

@@ -0,0 +1,25 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::node::http::verloc::VerlocState;
+use crate::node::node_statistics::SharedNodeStats;
+use axum::extract::FromRef;
+
+// this is a temporary thing for the transition period
+#[derive(Clone)]
+pub(crate) struct MixnodeAppState {
+    pub(crate) verloc: VerlocState,
+    pub(crate) stats: SharedNodeStats,
+}
+
+impl FromRef<MixnodeAppState> for VerlocState {
+    fn from_ref(app_state: &MixnodeAppState) -> Self {
+        app_state.verloc.clone()
+    }
+}
+
+impl FromRef<MixnodeAppState> for SharedNodeStats {
+    fn from_ref(app_state: &MixnodeAppState) -> Self {
+        app_state.stats.clone()
+    }
+}

mixnode/src/node/http/stats.rs

@@ -1,29 +1,38 @@
 use crate::node::node_statistics::{NodeStats, NodeStatsSimple, SharedNodeStats};
-use rocket::serde::json::Json;
-use rocket::State;
-use serde::Serialize;
+use axum::extract::{Query, State};
+use nym_node::http::api::{FormattedResponse, Output};
+use serde::{Deserialize, Serialize};
 
 #[derive(Serialize)]
 #[serde(untagged)]
-pub(crate) enum NodeStatsResponse {
+pub enum NodeStatsResponse {
     Full(NodeStats),
     Simple(NodeStatsSimple),
 }
 
-/// Returns a running stats of the node.
-#[get("/stats?<debug>")]
 pub(crate) async fn stats(
-    stats: &State<SharedNodeStats>,
-    debug: Option<bool>,
-) -> Json<NodeStatsResponse> {
+    Query(params): Query<StatsQueryParams>,
+    State(stats): State<SharedNodeStats>,
+) -> MixnodeStatsResponse {
+    let output = params.output.unwrap_or_default();
+
     let snapshot_data = stats.clone_data().await;
 
     // there's no point in returning the entire hashmap of sending destinations in regular mode
-    if let Some(debug) = debug {
-        if debug {
-            return Json(NodeStatsResponse::Full(snapshot_data));
-        }
-    }
+    let response = if params.debug {
+        NodeStatsResponse::Full(snapshot_data)
+    } else {
+        NodeStatsResponse::Simple(snapshot_data.simplify())
+    };
+    output.to_response(response)
+}
+
+pub type MixnodeStatsResponse = FormattedResponse<NodeStatsResponse>;
 
-    Json(NodeStatsResponse::Simple(snapshot_data.simplify()))
+#[derive(Default, Debug, Serialize, Deserialize, Copy, Clone)]
+// #[derive(Default, Debug, Serialize, Deserialize, Copy, Clone, IntoParams, ToSchema)]
+#[serde(default)]
+pub(crate) struct StatsQueryParams {
+    debug: bool,
+    pub output: Option<Output>,
 }

mixnode/src/node/http/verloc.rs

@@ -1,7 +1,8 @@
+use axum::extract::{Query, State};
 use nym_mixnode_common::verloc::{AtomicVerlocResult, VerlocResult};
-use rocket::serde::json::Json;
-use rocket::State;
+use nym_node::http::api::{FormattedResponse, OutputParams};
 
+#[derive(Clone)]
 pub(crate) struct VerlocState {
     shared: AtomicVerlocResult,
 }
@@ -16,8 +17,12 @@ impl VerlocState {
 
 /// Provides verifiable location (verloc) measurements for this mixnode - a list of the
 /// round-trip times, in milliseconds, for all other mixnodes that this node knows about.
-#[get("/verloc")]
-pub(crate) async fn verloc(state: &State<VerlocState>) -> Json<VerlocResult> {
-    // since it's impossible to get a mutable reference to the state, we can't cache any results outside the lock : (
-    Json(state.shared.clone_data().await)
+pub(crate) async fn verloc(
+    State(verloc): State<VerlocState>,
+    Query(output): Query<OutputParams>,
+) -> MixnodeVerlocResponse {
+    let output = output.output.unwrap_or_default();
+    output.to_response(verloc.shared.clone_data().await)
 }
+
+pub type MixnodeVerlocResponse = FormattedResponse<VerlocResult>;

mixnode/src/node/listener/connection_handler/mod.rs

@@ -7,6 +7,8 @@ use crate::node::listener::connection_handler::packet_processing::{
 use crate::node::packet_delayforwarder::PacketDelayForwardSender;
 use crate::node::TaskClient;
 use futures::StreamExt;
+use log::debug;
+use log::{error, info, warn};
 use nym_mixnode_common::measure;
 use nym_sphinx::forwarding::packet::MixPacket;
 use nym_sphinx::framing::codec::NymCodec;
@@ -16,8 +18,9 @@ use std::net::SocketAddr;
 use tokio::net::TcpStream;
 use tokio::time::Instant;
 use tokio_util::codec::Framed;
+
 #[cfg(feature = "cpucycles")]
-use tracing::{error, info, instrument};
+use tracing::instrument;
 
 pub(crate) mod packet_processing;
 

mixnode/src/node/listener/mod.rs

@@ -2,12 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::node::listener::connection_handler::ConnectionHandler;
+use log::{error, info, warn};
 use std::net::SocketAddr;
 use std::process;
 use tokio::net::TcpListener;
 use tokio::task::JoinHandle;
-#[cfg(feature = "cpucycles")]
-use tracing::error;
 
 use super::TaskClient;