refactor: use rd_config attribute

Cargo.toml

@@ -24,8 +24,7 @@ pin-project-lite = "0.2.6"
 serde_yaml = "0.8.15"
 yaml-merge-keys = { version = "0.4.1", features = ["serde_yaml"] }
 serde_json = "1.0"
-serde = "1.0.119"
-serde_derive = "1.0.119"
+serde = { version = "1.0.119", features = ["derive"] }
 warp = { version = "0.3.1", default-features = false, features = ["websocket"], optional = true }
 dirs = { version = "3.0.2", optional = true }
 rd-interface = { path = "./rabbit-digger/rd-interface/", version = "0.4" }

protocol/obfs/Cargo.toml

@@ -7,7 +7,6 @@ edition = "2018"
 [dependencies]
 rd-interface = { path = "../../rabbit-digger/rd-interface/", version = "0.4" }
 # rd-interface = "0.3"
-serde_derive = "1.0"
 serde = "1.0"
 tracing = "0.1.26"
 tokio = "1.0"

protocol/obfs/src/http_simple.rs

@@ -10,14 +10,13 @@ use futures::ready;
 use pin_project_lite::pin_project;
 use rand::prelude::*;
 use rd_interface::{
-    async_trait,
-    schemars::{self, JsonSchema},
-    Address, AsyncWrite, Config, ITcpStream, IntoDyn, ReadBuf, Result, TcpStream, NOT_IMPLEMENTED,
+    async_trait, prelude::*, rd_config, Address, AsyncWrite, ITcpStream, IntoDyn, ReadBuf, Result,
+    TcpStream, NOT_IMPLEMENTED,
 };
-use serde_derive::{Deserialize, Serialize};
 use tokio::io::AsyncRead;
 
-#[derive(Debug, Serialize, Deserialize, Config, JsonSchema)]
+#[rd_config]
+#[derive(Debug)]
 pub struct HttpSimple {
     obfs_param: String,
 }

protocol/obfs/src/lib.rs

@@ -2,11 +2,8 @@ use std::net::SocketAddr;
 
 use obfs_net::{ObfsNet, ObfsNetConfig};
 use rd_interface::{
-    registry::NetFactory,
-    schemars::{self, JsonSchema},
-    Address, Config, Context, Registry, Result, TcpStream,
+    prelude::*, registry::NetFactory, Address, Context, Registry, Result, TcpStream,
 };
-use serde_derive::{Deserialize, Serialize};
 
 mod http_simple;
 mod obfs_net;
@@ -38,7 +35,8 @@ pub trait Obfs {
     fn tcp_accept(&self, tcp: TcpStream, addr: SocketAddr) -> Result<TcpStream>;
 }
 
-#[derive(Debug, Serialize, Deserialize, Config, JsonSchema)]
+#[rd_config]
+#[derive(Debug)]
 #[serde(rename_all = "snake_case", tag = "obfs_type")]
 pub enum ObfsType {
     HttpSimple(http_simple::HttpSimple),

protocol/obfs/src/obfs_net.rs

@@ -2,17 +2,14 @@ use std::net::SocketAddr;
 
 use crate::{Obfs, ObfsType};
 use rd_interface::{
-    async_trait,
-    registry::NetRef,
-    schemars::{self, JsonSchema},
-    Address, Arc, Config, Context, INet, ITcpListener, IntoDyn, Net, Result, TcpListener,
-    TcpStream, UdpSocket, NOT_IMPLEMENTED,
+    async_trait, prelude::*, registry::NetRef, Address, Arc, Context, INet, ITcpListener, IntoDyn,
+    Net, Result, TcpListener, TcpStream, UdpSocket, NOT_IMPLEMENTED,
 };
-use serde_derive::{Deserialize, Serialize};
 
 type BoxObfs = Arc<dyn Obfs + Send + Sync + 'static>;
 
-#[derive(Debug, Serialize, Deserialize, Config, JsonSchema)]
+#[rd_config]
+#[derive(Debug)]
 pub struct ObfsNetConfig {
     #[serde(default)]
     pub net: NetRef,

protocol/obfs/src/plain.rs

@@ -1,11 +1,8 @@
 use crate::Obfs;
-use rd_interface::{
-    schemars::{self, JsonSchema},
-    Address, Config, Result, TcpStream,
-};
-use serde_derive::{Deserialize, Serialize};
+use rd_interface::{prelude::*, Address, Result, TcpStream};
 
-#[derive(Debug, Serialize, Deserialize, Config, JsonSchema)]
+#[rd_config]
+#[derive(Debug)]
 pub struct Plain;
 
 impl Obfs for Plain {

protocol/raw/Cargo.toml

@@ -7,7 +7,6 @@ edition = "2018"
 [dependencies]
 rd-interface = { path = "../../rabbit-digger/rd-interface/", version = "0.4" }
 # rd-interface = "0.3"
-serde_derive = "1.0"
 serde = "1.0"
 tracing = "0.1.26"
 tokio-smoltcp = "0.1.13"

protocol/raw/src/net.rs

@@ -5,17 +5,13 @@ use crate::{
     wrap::{TcpListenerWrap, TcpStreamWrap, UdpSocketWrap},
 };
 use rd_interface::{
-    async_trait,
-    registry::NetFactory,
-    schemars::{self, JsonSchema},
-    Address, Config, Context, Error, INet, IntoDyn, Result,
+    async_trait, prelude::*, registry::NetFactory, Address, Context, Error, INet, IntoDyn, Result,
 };
-use serde_derive::{Deserialize, Serialize};
 use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr};
 use tokio::sync::Mutex;
 use tokio_smoltcp::{device::FutureDevice, BufferSize, Net, NetConfig};
 
-#[derive(Serialize, Deserialize, JsonSchema, Config)]
+#[rd_config]
 pub struct RawNetConfig {
     device: String,
     mtu: usize,

protocol/raw/src/server.rs

@@ -7,15 +7,9 @@ use std::{
 use futures::{future::ready, StreamExt};
 use lru_time_cache::LruCache;
 use rd_interface::{
-    async_trait,
-    constant::UDP_BUFFER_SIZE,
-    error::map_other,
-    registry::ServerFactory,
-    schemars::{self, JsonSchema},
-    util::connect_tcp,
-    Config, Context, Error, IServer, IntoAddress, Net, Result,
+    async_trait, constant::UDP_BUFFER_SIZE, error::map_other, prelude::*, registry::ServerFactory,
+    util::connect_tcp, Context, Error, IServer, IntoAddress, Net, Result,
 };
-use serde_derive::{Deserialize, Serialize};
 use smoltcp::{
     phy::Checksum,
     wire::{
@@ -42,7 +36,7 @@ use crate::{
     gateway::{GatewayInterface, MapTable},
 };
 
-#[derive(Serialize, Deserialize, JsonSchema, Config)]
+#[rd_config]
 pub struct RawServerConfig {
     device: String,
     mtu: usize,

protocol/remote/Cargo.toml

@@ -7,7 +7,6 @@ edition = "2018"
 [dependencies]
 rd-interface = { path = "../../rabbit-digger/rd-interface/", version = "0.4" }
 # rd-interface = "0.3"
-serde_derive = "1.0"
 serde = "1.0"
 tracing = "0.1.26"
 tokio = { version = "1.5.0", features = ["rt"] }

protocol/remote/src/lib.rs

@@ -1,18 +1,17 @@
 use net::RemoteNet;
 use protocol::get_protocol;
 use rd_interface::{
+    prelude::*,
     registry::{NetFactory, NetRef, ServerFactory},
-    schemars::{self, JsonSchema},
-    Config, Net, Registry, Result,
+    Net, Registry, Result,
 };
-use serde_derive::Deserialize;
 use server::RemoteServer;
 
 mod net;
 mod protocol;
 mod server;
 
-#[derive(Deserialize, JsonSchema, Config)]
+#[rd_config]
 pub struct RemoteNetConfig {
     #[serde(default)]
     net: NetRef,

protocol/remote/src/protocol.rs

@@ -1,22 +1,19 @@
 use std::net::SocketAddr;
 
 use rd_interface::{
-    async_trait,
-    schemars::{self, JsonSchema},
-    Address, Arc, Config, Context, Error, Net, Result, TcpListener, TcpStream,
+    async_trait, prelude::*, Address, Arc, Context, Error, Net, Result, TcpListener, TcpStream,
 };
-use serde_derive::{Deserialize, Serialize};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::sync::RwLock;
 
-#[derive(Deserialize, JsonSchema, Config)]
+#[rd_config]
 #[serde(tag = "mode", rename_all = "lowercase")]
 pub enum Connection {
     Active { remote: Address },
     Passive { bind: Address },
 }
 
-#[derive(Deserialize, JsonSchema, Config)]
+#[rd_config]
 #[schemars(rename = "RemoteProtocolConfig")]
 pub struct Config {
     #[serde(flatten)]
@@ -118,14 +115,16 @@ async fn handshake(channel: &mut TcpStream, token: &str) -> Result<()> {
     Ok(())
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[rd_config]
+#[derive(Debug)]
 pub enum CommandRequest {
     TcpConnect { address: Address },
     TcpBind { address: Address },
     TcpAccept { id: u32 },
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[rd_config]
+#[derive(Debug)]
 pub enum CommandResponse {
     Accept { id: u32, addr: SocketAddr },
     BindAddr { addr: SocketAddr },

protocol/ss/Cargo.toml

@@ -8,7 +8,6 @@ edition = "2018"
 rd-interface = { path = "../../rabbit-digger/rd-interface/", version = "0.4" }
 # rd-interface = "0.3"
 shadowsocks = { version = "1.10.3", features = [ "stream-cipher", "aead-cipher-extra" ] }
-serde_derive = "1.0"
 serde = "1.0"
 bytes = "1.0"
 tracing = "0.1.26"

protocol/ss/src/client.rs

@@ -1,19 +1,16 @@
 use super::wrapper::{Cipher, WrapAddress, WrapSSTcp, WrapSSUdp};
 use rd_interface::{
-    async_trait,
-    registry::NetRef,
-    schemars::{self, JsonSchema},
-    Address, Arc, Config, INet, IntoAddress, IntoDyn, Result, TcpListener, TcpStream, UdpSocket,
-    NOT_ENABLED, NOT_IMPLEMENTED,
+    async_trait, prelude::*, registry::NetRef, Address, Arc, INet, IntoAddress, IntoDyn, Result,
+    TcpListener, TcpStream, UdpSocket, NOT_ENABLED, NOT_IMPLEMENTED,
 };
-use serde_derive::Deserialize;
 use shadowsocks::{
     config::{ServerConfig, ServerType},
     context::Context,
     ProxyClientStream,
 };
 
-#[derive(Debug, Deserialize, Clone, Config, JsonSchema)]
+#[rd_config]
+#[derive(Debug, Clone)]
 pub struct SSNetConfig {
     server: Address,
     password: String,

protocol/ss/src/server.rs

@@ -2,16 +2,13 @@ use std::net::SocketAddr;
 
 use super::wrapper::{Cipher, CryptoStream};
 use rd_interface::{
-    async_trait,
-    schemars::{self, JsonSchema},
-    util::connect_tcp,
-    Address, Arc, Config, IServer, Net, Result, TcpStream,
+    async_trait, prelude::*, util::connect_tcp, Address, Arc, IServer, Net, Result, TcpStream,
 };
-use serde_derive::Deserialize;
 use shadowsocks::{config::ServerType, context::Context, ServerConfig};
 use socks5_protocol::Address as S5Addr;
 
-#[derive(Debug, Deserialize, Clone, Config, JsonSchema)]
+#[rd_config]
+#[derive(Debug, Clone)]
 pub struct SSServerConfig {
     bind: Address,
     password: String,

protocol/ss/src/wrapper.rs

@@ -1,12 +1,9 @@
 use crate::udp::{decrypt_payload, encrypt_payload};
 use bytes::BytesMut;
 use rd_interface::{
-    async_trait, impl_async_read_write, impl_empty_net_resolve,
-    schemars::{self, JsonSchema},
-    Address as RDAddress, AsyncRead, AsyncWrite, ITcpStream, IUdpSocket, ReadBuf, TcpStream,
-    UdpSocket, NOT_IMPLEMENTED,
+    async_trait, impl_async_read_write, prelude::*, Address as RDAddress, AsyncRead, AsyncWrite,
+    ITcpStream, IUdpSocket, ReadBuf, TcpStream, UdpSocket, NOT_IMPLEMENTED,
 };
-use serde_derive::{Deserialize, Serialize};
 use shadowsocks::{
     context::SharedContext,
     crypto::v1::CipherKind,
@@ -32,8 +29,9 @@ impl From<WrapAddress> for SSAddress {
     }
 }
 
+#[rd_config]
 #[allow(non_camel_case_types)]
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Copy, Clone)]
 pub enum Cipher {
     #[serde(rename = "none")]
     NONE,
@@ -127,8 +125,6 @@ pub enum Cipher {
     SM4_CCM,
 }
 
-impl_empty_net_resolve! { Cipher }
-
 impl From<Cipher> for CipherKind {
     fn from(c: Cipher) -> Self {
         let s: serde_json::Value =

protocol/trojan/Cargo.toml

@@ -6,7 +6,6 @@ edition = "2018"
 
 [dependencies]
 rd-interface = { path = "../../rabbit-digger/rd-interface/", version = "0.4" }
-serde_derive = "1.0"
 serde = "1.0"
 tracing = "0.1.26"
 sha2 = "0.9.5"

protocol/trojan/src/client.rs

@@ -2,13 +2,9 @@ use std::io::{Cursor, Write};
 
 use crate::tls::{TlsConnector, TlsConnectorConfig};
 use rd_interface::{
-    async_trait,
-    registry::NetRef,
-    schemars::{self, JsonSchema},
-    Address as RdAddress, Address, Config, INet, IntoDyn, Net, Result, TcpListener, TcpStream,
-    UdpSocket, NOT_ENABLED, NOT_IMPLEMENTED,
+    async_trait, prelude::*, registry::NetRef, Address as RdAddress, Address, INet, IntoDyn, Net,
+    Result, TcpListener, TcpStream, UdpSocket, NOT_ENABLED, NOT_IMPLEMENTED,
 };
-use serde_derive::Deserialize;
 use sha2::{Digest, Sha224};
 use socks5_protocol::{sync::FromIO, Address as S5Addr};
 
@@ -42,7 +38,8 @@ impl TrojanNet {
     }
 }
 
-#[derive(Debug, Deserialize, Clone, Config, JsonSchema)]
+#[rd_config]
+#[derive(Debug, Clone)]
 pub struct TrojanNetConfig {
     #[serde(default)]
     net: NetRef,

src/api_server/reject.rs

@@ -1,4 +1,4 @@
-use serde_derive::Serialize;
+use serde::Serialize;
 use warp::{hyper::StatusCode, Rejection, Reply};
 
 #[derive(Debug)]

src/config.rs

@@ -1,6 +1,6 @@
 use anyhow::{Context, Result};
 use rabbit_digger::Config;
-use serde_derive::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::path::PathBuf;
 

src/select.rs

@@ -1,13 +1,12 @@
 use rd_interface::{
     async_trait,
+    prelude::*,
     registry::{NetFactory, NetRef},
-    schemars::{self, JsonSchema},
-    Address, Config, Context, Error, INet, Net, Registry, Result, TcpListener, TcpStream,
-    UdpSocket,
+    Address, Context, Error, INet, Net, Registry, Result, TcpListener, TcpStream, UdpSocket,
 };
-use serde_derive::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Deserialize, Clone, Config, JsonSchema)]
+#[rd_config]
+#[derive(Debug, Clone)]
 pub struct SelectNetConfig {
     selected: usize,
     list: Vec<NetRef>,

src/translate/clash.rs

@@ -9,7 +9,7 @@ use rabbit_digger::{
     },
     util::topological_sort,
 };
-use serde_derive::Deserialize;
+use serde::Deserialize;
 use serde_json::{from_value, json, Value};
 
 #[derive(Debug, Deserialize)]