refactor(env): seperate env-related code

Author: BobAnkh

Cargo.lock

@@ -9,7 +9,7 @@ default-run = "rattan"
 
 [workspace]
 resolver = "2"
-members = [".", "rattan-core", "rattan-log"]
+members = [".", "rattan-core", "rattan-env", "rattan-log"]
 
 [workspace.package]
 version = "0.1.0"
@@ -27,7 +27,9 @@ ctrlc = "3.5.2"
 figment = { version = "0.10", features = ["env", "json", "toml"] }
 futures = "0.3.32"
 human-bandwidth = { version = "0.1.4", features = ["binary-system", "serde"] }
+ipnet = { version = "2.11.0", features = ["serde"] }
 jiff = "0.2.15"
+libc = "0.2.141"
 netem-trace = { version = "0.4.4", features = [
   "human",
   "mahimahi",
@@ -45,10 +47,14 @@ nix = { version = "0.31.1", features = [
 ] }
 num_enum = "0.7.5"
 once_cell = "1.19"
+parking_lot = "0.12.5"
 pcap-file = { version = "2.0.0" }
 rand = "0.10.0"
+rtnetlink = "0.20.0"
 serde = { version = "1.0.160", features = ["derive"] }
+tempfile = "3"
 test-log = { version = "0.2.18", features = ["trace"] }
+thiserror = "2.0.0"
 tokio = { version = "1.26.0", features = [
   "macros",
   "net",

Cargo.toml

@@ -36,25 +36,23 @@ etherparse = "0.19.0"
 figment = { workspace = true }
 futures = { workspace = true }
 human-bandwidth = { workspace = true }
-ipnet = { version = "2.8.0", features = ["serde"] }
+ipnet = { workspace = true }
 jiff = { workspace = true }
-lazy_static = "1.4.0"
-libc = "0.2.141"
+libc = { workspace = true }
 netem-trace = { workspace = true }
 nix = { workspace = true }
 num_enum = { workspace = true }
 once_cell = { workspace = true }
-parking_lot = "0.12.1"
+parking_lot = { workspace = true }
 pcap-file = { workspace = true }
 rand = { workspace = true }
+rattan-env = { path = "../rattan-env" }
 rattan-log = { path = "../rattan-log" }
 regex = "1.7.3"
-rtnetlink = "0.20.0"
 serde = { workspace = true, optional = true }
 serde_json = { version = "1.0.96", optional = true }
 serde_with = "3"
-tempfile = "3.10.1"
-thiserror = "2.0.0"
+thiserror = { workspace = true }
 tokio = { workspace = true }
 tokio-util = "0.7.7"
 tracing = { workspace = true }
@@ -76,7 +74,9 @@ reqwest = { version = "0.13.2", default-features = false, features = [
   "json",
 ] }
 rstest = "0.26.1"
+rtnetlink = { workspace = true }
 serial_test = "3.2.0"
+tempfile = { workspace = true }
 test-log = { workspace = true }
 tracing-subscriber = { workspace = true }
 
@@ -86,4 +86,10 @@ camellia = ["dep:camellia"]
 first-packet = []
 http = ["dep:axum", "serde"]
 packet-dump = []
-serde = ["bandwidth/serde", "bytesize/serde", "dep:serde", "dep:serde_json"]
+serde = [
+  "bandwidth/serde",
+  "bytesize/serde",
+  "dep:serde",
+  "dep:serde_json",
+  "rattan-env/serde",
+]

rattan-core/Cargo.toml

@@ -12,6 +12,7 @@ use std::{
 use async_trait::async_trait;
 use bitfield::{BitRange, BitRangeMut};
 use parking_lot::RwLock;
+use rattan_env::veth::VethCell;
 use rattan_log::{
     log_entry::general_packet::GeneralPacketType, log_entry::PktAction, FlowDesc, PlainBytes,
     RattanLogOp, RawLogEntry, LOGGING_TX,
@@ -24,10 +25,7 @@ use tracing::{debug, error, instrument, warn};
 use crate::{
     cells::{Cell, ControlInterface, Egress, Ingress, Packet},
     error::{Error, TokioRuntimeError},
-    metal::{
-        io::common::{InterfaceDriver, InterfaceReceiver, InterfaceSender},
-        veth::VethCell,
-    },
+    metal::io::common::{InterfaceDriver, InterfaceReceiver, InterfaceSender},
     radix::{PacketLogMode, BASE_TS, PKT_LOG_MODE},
 };
 

rattan-core/src/cells/external.rs

@@ -6,12 +6,8 @@ pub type Result<T> = std::result::Result<T, Error>;
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[error("MacParseError: {0}")]
-    MacParseError(#[from] MacParseError),
-    #[error("NsError: {0}")]
-    NsError(#[from] NsError),
-    #[error("VethError: {0}")]
-    VethError(#[from] VethError),
+    #[error("RattanEnvError: {0}")]
+    RattanEnvError(#[from] rattan_env::Error),
     #[error("RoutingTableError: {0}")]
     RoutingTableError(#[from] RoutingTableError),
     #[error("Encounter IO error, {0}")]
@@ -44,65 +40,6 @@ pub enum Error {
     Custom(String),
 }
 
-#[derive(Debug, thiserror::Error)]
-pub enum NsError {
-    #[error("Can not create netns directory, {0}")]
-    CreateNsDirError(std::io::Error),
-
-    #[error("Can not create netns, {0}")]
-    CreateNsError(std::io::Error),
-
-    #[error("Can not open netns {0}, {1}")]
-    OpenNsError(std::path::PathBuf, std::io::Error),
-
-    #[error("Failed to close netns, {0}")]
-    CloseNsError(nix::Error),
-
-    #[error("Failed to mount {0}, {1}")]
-    MountError(String, nix::Error),
-
-    #[error("Failed to unmount {0}, {1}")]
-    UnmountError(std::path::PathBuf, nix::Error),
-
-    #[error("Failed to unshare, {0}")]
-    UnshareError(nix::Error),
-
-    #[error("Failed to join thread, {0}")]
-    JoinThreadError(String),
-
-    #[error("Can not setns, {0}")]
-    SetNsError(nix::Error),
-}
-
-/// An error that may occur when parsing a MAC address string.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, thiserror::Error)]
-pub enum MacParseError {
-    /// Parsing of the MAC address contained an invalid digit.
-    #[error("Invalid digit")]
-    InvalidDigit,
-    /// The MAC address did not have the correct length.
-    #[error("Invalid length")]
-    InvalidLength,
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum VethError {
-    #[error("Can not create veth pair, {0}")]
-    CreateVethPairError(String),
-    #[error("Encounter namespace error, {0}")]
-    NsError(#[from] NsError),
-    #[error("Encounter IO error, {0}")]
-    IoError(#[from] std::io::Error),
-    #[error("Encounter system error, {0}")]
-    SystemError(#[from] nix::errno::Errno),
-    #[error("Already in namespace {0}")]
-    AlreadyInNamespace(String),
-    #[error("Set Veth error, {0}")]
-    SetError(String),
-    #[error("Failed to build veth, {0}")]
-    TokioRuntimeError(#[from] TokioRuntimeError),
-}
-
 #[derive(Debug, thiserror::Error)]
 pub enum RoutingTableError {
     #[error("IpNet parse error: {0}")]
@@ -167,6 +104,12 @@ impl From<csv::Error> for VisualizeTraceError {
     }
 }
 
+impl From<rattan_env::NsError> for Error {
+    fn from(e: rattan_env::NsError) -> Self {
+        Error::RattanEnvError(e.into())
+    }
+}
+
 #[cfg(feature = "http")]
 impl axum::response::IntoResponse for Error {
     fn into_response(self) -> axum::response::Response {
@@ -175,9 +118,7 @@ impl axum::response::IntoResponse for Error {
         use serde_json::json;
 
         let status = match self {
-            Error::MacParseError(_) => StatusCode::INTERNAL_SERVER_ERROR,
-            Error::NsError(_) => StatusCode::INTERNAL_SERVER_ERROR,
-            Error::VethError(_) => StatusCode::INTERNAL_SERVER_ERROR,
+            Error::RattanEnvError(_) => StatusCode::INTERNAL_SERVER_ERROR,
             Error::RoutingTableError(_) => StatusCode::INTERNAL_SERVER_ERROR,
             Error::IoError(_) => StatusCode::INTERNAL_SERVER_ERROR,
             Error::MetalError(_) => StatusCode::INTERNAL_SERVER_ERROR,
@@ -204,9 +145,7 @@ impl axum::response::IntoResponse for Error {
 impl Termination for Error {
     fn report(self) -> ExitCode {
         match self {
-            Error::MacParseError(_) => ExitCode::from(78),
-            Error::NsError(_) => ExitCode::from(71),
-            Error::VethError(_) => ExitCode::from(71),
+            Error::RattanEnvError(e) => e.report(),
             Error::RoutingTableError(_) => ExitCode::from(78),
             Error::IoError(_) => ExitCode::from(74),
             Error::MetalError(_) => ExitCode::from(74),

rattan-core/src/error.rs

@@ -2,9 +2,9 @@ pub mod cells;
 pub mod config;
 pub mod control;
 pub mod core;
-pub mod env;
 pub mod error;
 pub mod metal;
 pub mod radix;
 pub mod utils;
 pub use netem_trace;
+pub use rattan_env::env;

rattan-core/src/lib.rs

@@ -10,8 +10,6 @@ pub enum MetalError {
     #[cfg_attr(feature = "camellia", error("Encounter XDP error, {0}"))]
     #[cfg(feature = "camellia")]
     XDPError(#[from] CamelliaError),
-    #[error("Encounter Rtnetlink error, {0}")]
-    RtnetlinkError(#[from] rtnetlink::Error),
     #[error("not interested packet")]
     NotInterestedPacket,
 }

rattan-core/src/metal/error.rs

@@ -8,12 +8,13 @@ use nix::{
     errno::Errno,
     sys::socket::{AddressFamily, SockFlag, SockType},
 };
+use rattan_env::veth::VethCell;
 use tracing::{debug, error, trace, warn};
 
 use super::common::PacketType;
 use crate::cells::{Packet, StdPacket};
+use crate::metal::error::MetalError;
 use crate::metal::io::common::{InterfaceDriver, InterfaceReceiver, InterfaceSender};
-use crate::metal::{error::MetalError, veth::VethCell};
 
 pub struct AfPacketSender {
     raw_fd: Mutex<i32>,

rattan-core/src/metal/io/af_packet.rs

@@ -15,6 +15,7 @@ use camellia::{
 };
 use etherparse::{Ethernet2Header, Ipv4Header};
 use once_cell::sync::Lazy;
+use rattan_env::veth::VethCell;
 use tokio::sync::Mutex;
 use tokio::time::{sleep, Instant};
 use tracing::debug;
@@ -25,9 +26,8 @@ static UMEM: Lazy<Arc<std::sync::Mutex<UMem>>> = Lazy::new(|| {
     ))
 });
 
-use crate::{cells::Packet, metal::veth::VethCell};
-
-use super::common::{InterfaceDriver, InterfaceReceiver, InterfaceSender};
+use crate::cells::Packet;
+use crate::metal::io::common::{InterfaceDriver, InterfaceReceiver, InterfaceSender};
 
 type XDPSocketRef = Arc<Mutex<XskSocket<SharedAccessorRef>>>;
 

rattan-core/src/metal/io/af_xdp.rs

@@ -1,9 +1,8 @@
 use std::sync::Arc;
 
-use crate::{
-    cells::Packet,
-    metal::{error::MetalError, veth::VethCell},
-};
+use rattan_env::veth::VethCell;
+
+use crate::{cells::Packet, metal::error::MetalError};
 
 pub enum PacketType {
     PacketHost = 0,