split register_method calls into proper files

src/api/config.rs

@@ -1,4 +1,5 @@
 use jsonrpsee::types::Params;
+use jsonrpsee::RpcModule;
 
 use crate::config_manager::Change;
 use crate::state::RpcState;
@@ -6,6 +7,20 @@ use crate::state::RpcState;
 use super::ApiError;
 use super::ApiError::ConfigError;
 
+pub fn register_methods(module: &mut RpcModule<RpcState>) {
+    module
+        .register_method("config.get_pending_changelog", get_pending_changelog)
+        .unwrap();
+
+    module
+        .register_method("config.apply_pending_changes", apply_pending_changes)
+        .unwrap();
+
+    module
+        .register_method("config.discard_pending_changes", discard_pending_changes)
+        .unwrap();
+}
+
 pub fn get_pending_changelog(_: Params, state: &RpcState) -> Result<Vec<Change>, ApiError> {
     Ok(state.config_manager.clone().get_pending_changelog())
 }

src/api/firewall.rs

@@ -1 +1,51 @@
+use super::ApiError;
+use crate::{
+    definitions::firewall::{DestinationNATRule, ForwardRule, SourceNATRule},
+    get_things, get_vec_thing,
+    state::RpcState,
+};
+use jsonrpsee::RpcModule;
 
+pub fn register_methods(module: &mut RpcModule<RpcState>) {
+    module
+        .register_method(
+            "firewall.get_forward_rule",
+            get_vec_thing!(firewall.forward_rules),
+        )
+        .unwrap();
+
+    module
+        .register_method::<Result<Vec<ForwardRule>, ApiError>, _>(
+            "firewall.get_forward_rules",
+            get_things!(firewall.forward_rules),
+        )
+        .unwrap();
+
+    module
+        .register_method(
+            "firewall.get_destination_nat_rule",
+            get_vec_thing!(firewall.destination_nat_rules),
+        )
+        .unwrap();
+
+    module
+        .register_method::<Result<Vec<DestinationNATRule>, ApiError>, _>(
+            "firewall.get_destination_nat_rules",
+            get_things!(firewall.destination_nat_rules),
+        )
+        .unwrap();
+
+    module
+        .register_method(
+            "firewall.get_source_nat_rule",
+            get_vec_thing!(firewall.source_nat_rules),
+        )
+        .unwrap();
+
+    module
+        .register_method::<Result<Vec<SourceNATRule>, ApiError>, _>(
+            "firewall.get_source_nat_rules",
+            get_things!(firewall.source_nat_rules),
+        )
+        .unwrap();
+}

src/api/mod.rs

@@ -6,24 +6,11 @@ mod service;
 mod system;
 mod vpn;
 
-use std::collections::HashMap;
+use crate::state::RpcState;
-
-use crate::{
-    definitions::{
-        firewall::{DestinationNATRule, ForwardRule, SourceNATRule},
-        network::{NetworkInterface, StaticRoute},
-        object::{Address, Service},
-        service::{DHCPServer, DNSServer, NTPServer},
-        vpn::{WireguardInterface, WireguardPeer},
-    },
-    state::RpcState,
-};
 use jsonrpsee::{
     types::{error::ErrorCode, ErrorObject},
     RpcModule,
 };
-
-use serde::Deserialize;
 use thiserror::Error;
 use tracing::info;
 
@@ -53,20 +40,17 @@ impl Into<ErrorObject<'static>> for ApiError {
     }
 }
 
-#[derive(Deserialize)]
-struct GetStringID {
-    id: String,
-}
-
-#[derive(Deserialize)]
-struct GetIntID {
-    id: i64,
-}
-
 #[macro_export]
 macro_rules! get_map_thing {
     ($( $sub_system:ident ).+) => {
         |params, state| {
+            use serde::Deserialize;
+
+            #[derive(Deserialize)]
+            struct GetStringID {
+                id: String,
+            }
+
             let t: GetStringID = params.parse().map_err(ApiError::ParameterDeserialize)?;
 
             match state
@@ -86,13 +70,20 @@ macro_rules! get_map_thing {
 macro_rules! get_vec_thing {
     ($( $sub_system:ident ).+) => {
         |params, state| {
+            use serde::{Deserialize, Serialize};
+
+            #[derive(Deserialize, Serialize)]
+            struct GetIntID {
+                id: i64,
+            }
+
             let t: GetIntID = params.parse().map_err(ApiError::ParameterDeserialize)?;
             let things = state
             .config_manager
             .get_pending_config()
             .$($sub_system).+;
 
-            if things.len() > t.id as usize{
+            if things.len() > t.id as usize {
                 Ok(things[t.id as usize].clone())
             } else {
                 Err(ApiError::NotFound)
@@ -116,209 +107,13 @@ macro_rules! get_things {
 pub fn new_rpc_module(state: RpcState) -> RpcModule<RpcState> {
     let mut module = RpcModule::new(state);
 
-    module
+    config::register_methods(&mut module);
-        .register_method("system.get_user", system::get_user)
+    firewall::register_methods(&mut module);
-        .unwrap();
+    network::register_methods(&mut module);
-
+    object::register_methods(&mut module);
-    module
+    service::register_methods(&mut module);
-        .register_method("system.get_users", system::get_users)
+    system::register_methods(&mut module);
-        .unwrap();
+    vpn::register_methods(&mut module);
-
-    module
-        .register_method("system.create_user", system::create_user)
-        .unwrap();
-
-    module
-        .register_method("system.update_user", system::update_user)
-        .unwrap();
-
-    module
-        .register_method("system.delete_user", system::delete_user)
-        .unwrap();
-
-    module
-        .register_method(
-            "network.get_static_route",
-            get_vec_thing!(network.static_routes),
-        )
-        .unwrap();
-
-    module
-        .register_method::<Result<Vec<StaticRoute>, ApiError>, _>(
-            "network.get_static_routes",
-            get_things!(network.static_routes),
-        )
-        .unwrap();
-
-    module
-        .register_method("network.get_interface", get_map_thing!(network.interfaces))
-        .unwrap();
-
-    module
-        .register_method::<Result<HashMap<String, NetworkInterface>, ApiError>, _>(
-            "network.get_interfaces",
-            get_things!(network.interfaces),
-        )
-        .unwrap();
-
-    module
-        .register_method("object.get_service", get_map_thing!(object.services))
-        .unwrap();
-
-    module
-        .register_method::<Result<HashMap<String, Service>, ApiError>, _>(
-            "object.get_services",
-            get_things!(object.services),
-        )
-        .unwrap();
-
-    module
-        .register_method("object.get_address", get_map_thing!(object.addresses))
-        .unwrap();
-
-    module
-        .register_method::<Result<HashMap<String, Address>, ApiError>, _>(
-            "object.get_addresses",
-            get_things!(object.addresses),
-        )
-        .unwrap();
-
-    module
-        .register_method(
-            "service.get_dhcp_server",
-            get_vec_thing!(service.dhcp_servers),
-        )
-        .unwrap();
-
-    module
-        .register_method::<Result<Vec<DHCPServer>, ApiError>, _>(
-            "service.get_dhcp_servers",
-            get_things!(service.dhcp_servers),
-        )
-        .unwrap();
-
-    module
-        .register_method(
-            "service.get_dns_server",
-            get_vec_thing!(service.dns_servers),
-        )
-        .unwrap();
-
-    module
-        .register_method::<Result<Vec<DNSServer>, ApiError>, _>(
-            "service.get_dns_servers",
-            get_things!(service.dns_servers),
-        )
-        .unwrap();
-
-    module
-        .register_method(
-            "service.get_ntp_server",
-            get_vec_thing!(service.ntp_servers),
-        )
-        .unwrap();
-
-    module
-        .register_method::<Result<Vec<NTPServer>, ApiError>, _>(
-            "service.get_ntp_servers",
-            get_things!(service.ntp_servers),
-        )
-        .unwrap();
-
-    module
-        .register_method(
-            "firewall.get_forward_rule",
-            get_vec_thing!(firewall.forward_rules),
-        )
-        .unwrap();
-
-    module
-        .register_method::<Result<Vec<ForwardRule>, ApiError>, _>(
-            "firewall.get_forward_rules",
-            get_things!(firewall.forward_rules),
-        )
-        .unwrap();
-
-    module
-        .register_method(
-            "firewall.get_destination_nat_rule",
-            get_vec_thing!(firewall.destination_nat_rules),
-        )
-        .unwrap();
-
-    module
-        .register_method::<Result<Vec<DestinationNATRule>, ApiError>, _>(
-            "firewall.get_destination_nat_rules",
-            get_things!(firewall.destination_nat_rules),
-        )
-        .unwrap();
-
-    module
-        .register_method(
-            "firewall.get_source_nat_rule",
-            get_vec_thing!(firewall.source_nat_rules),
-        )
-        .unwrap();
-
-    module
-        .register_method::<Result<Vec<SourceNATRule>, ApiError>, _>(
-            "firewall.get_source_nat_rules",
-            get_things!(firewall.source_nat_rules),
-        )
-        .unwrap();
-
-    module
-        .register_method(
-            "config.get_pending_changelog",
-            config::get_pending_changelog,
-        )
-        .unwrap();
-
-    module
-        .register_method(
-            "config.apply_pending_changes",
-            config::apply_pending_changes,
-        )
-        .unwrap();
-
-    module
-        .register_method(
-            "config.discard_pending_changes",
-            config::discard_pending_changes,
-        )
-        .unwrap();
-
-    module
-        .register_method("vpn.wireguard.get_status", vpn::get_wireguard_status)
-        .unwrap();
-
-    module
-        .register_method(
-            "vpn.wireguard.get_interface",
-            get_map_thing!(vpn.wireguard.interfaces),
-        )
-        .unwrap();
-
-    module
-        .register_method::<Result<HashMap<String, WireguardInterface>, ApiError>, _>(
-            "vpn.wireguard.get_interfaces",
-            get_things!(vpn.wireguard.interfaces),
-        )
-        .unwrap();
-
-    module
-        .register_method(
-            "vpn.wireguard.get_peer",
-            get_map_thing!(vpn.wireguard.peers),
-        )
-        .unwrap();
-
-    module
-        .register_method::<Result<HashMap<String, WireguardPeer>, ApiError>, _>(
-            "vpn.wireguard.get_peers",
-            get_things!(vpn.wireguard.peers),
-        )
-        .unwrap();
 
     module
 }

src/api/network.rs

@@ -1 +1,35 @@
+use super::ApiError;
+use crate::{
+    definitions::network::{NetworkInterface, StaticRoute},
+    get_map_thing, get_things, get_vec_thing,
+    state::RpcState,
+};
+use jsonrpsee::RpcModule;
+use std::collections::HashMap;
 
+pub fn register_methods(module: &mut RpcModule<RpcState>) {
+    module
+        .register_method(
+            "network.get_static_route",
+            get_vec_thing!(network.static_routes),
+        )
+        .unwrap();
+
+    module
+        .register_method::<Result<Vec<StaticRoute>, ApiError>, _>(
+            "network.get_static_routes",
+            get_things!(network.static_routes),
+        )
+        .unwrap();
+
+    module
+        .register_method("network.get_interface", get_map_thing!(network.interfaces))
+        .unwrap();
+
+    module
+        .register_method::<Result<HashMap<String, NetworkInterface>, ApiError>, _>(
+            "network.get_interfaces",
+            get_things!(network.interfaces),
+        )
+        .unwrap();
+}

src/api/object.rs

@@ -1 +1,32 @@
+use super::ApiError;
+use crate::{
+    definitions::object::{Address, Service},
+    get_map_thing, get_things,
+    state::RpcState,
+};
+use jsonrpsee::RpcModule;
+use std::collections::HashMap;
 
+pub fn register_methods(module: &mut RpcModule<RpcState>) {
+    module
+        .register_method("object.get_service", get_map_thing!(object.services))
+        .unwrap();
+
+    module
+        .register_method::<Result<HashMap<String, Service>, ApiError>, _>(
+            "object.get_services",
+            get_things!(object.services),
+        )
+        .unwrap();
+
+    module
+        .register_method("object.get_address", get_map_thing!(object.addresses))
+        .unwrap();
+
+    module
+        .register_method::<Result<HashMap<String, Address>, ApiError>, _>(
+            "object.get_addresses",
+            get_things!(object.addresses),
+        )
+        .unwrap();
+}

src/api/service.rs

@@ -1 +1,51 @@
+use super::ApiError;
+use crate::{
+    definitions::service::{DHCPServer, DNSServer, NTPServer},
+    get_things, get_vec_thing,
+    state::RpcState,
+};
+use jsonrpsee::RpcModule;
 
+pub fn register_methods(module: &mut RpcModule<RpcState>) {
+    module
+        .register_method(
+            "service.get_dhcp_server",
+            get_vec_thing!(service.dhcp_servers),
+        )
+        .unwrap();
+
+    module
+        .register_method::<Result<Vec<DHCPServer>, ApiError>, _>(
+            "service.get_dhcp_servers",
+            get_things!(service.dhcp_servers),
+        )
+        .unwrap();
+
+    module
+        .register_method(
+            "service.get_dns_server",
+            get_vec_thing!(service.dns_servers),
+        )
+        .unwrap();
+
+    module
+        .register_method::<Result<Vec<DNSServer>, ApiError>, _>(
+            "service.get_dns_servers",
+            get_things!(service.dns_servers),
+        )
+        .unwrap();
+
+    module
+        .register_method(
+            "service.get_ntp_server",
+            get_vec_thing!(service.ntp_servers),
+        )
+        .unwrap();
+
+    module
+        .register_method::<Result<Vec<NTPServer>, ApiError>, _>(
+            "service.get_ntp_servers",
+            get_things!(service.ntp_servers),
+        )
+        .unwrap();
+}

src/api/system.rs

@@ -3,6 +3,7 @@ use crate::config_manager::{
 };
 use crate::{definitions::system::User, state::RpcState};
 use jsonrpsee::types::Params;
+use jsonrpsee::RpcModule;
 use pwhash::sha512_crypt;
 use serde::{Deserialize, Serialize};
 
@@ -11,18 +12,43 @@ use ApiError::HashError;
 use ApiError::NotFound;
 use ApiError::ParameterDeserialize;
 
-use super::{ApiError, GetStringID};
+use super::ApiError;
 
 const USER_CHANGE_PATH: &str = "system.user";
 
+pub fn register_methods(module: &mut RpcModule<RpcState>) {
+    module.register_method("system.get_user", get_user).unwrap();
+
+    module
+        .register_method("system.get_users", get_users)
+        .unwrap();
+
+    module
+        .register_method("system.create_user", create_user)
+        .unwrap();
+
+    module
+        .register_method("system.update_user", update_user)
+        .unwrap();
+
+    module
+        .register_method("system.delete_user", delete_user)
+        .unwrap();
+}
+
 #[derive(Serialize, Clone)]
-pub struct GetUser {
+pub struct GetUserResult {
     name: String,
     comment: String,
 }
 
-pub fn get_user(p: Params, state: &RpcState) -> Result<GetUser, ApiError> {
+#[derive(Deserialize)]
-    let u: GetStringID = p.parse().map_err(ParameterDeserialize)?;
+pub struct GetUser {
+    id: String,
+}
+
+pub fn get_user(p: Params, state: &RpcState) -> Result<GetUserResult, ApiError> {
+    let u: GetUser = p.parse().map_err(ParameterDeserialize)?;
 
     match state
         .config_manager
@@ -31,7 +57,7 @@ pub fn get_user(p: Params, state: &RpcState) -> Result<GetUser, ApiError> {
         .users
         .get(&u.id)
     {
-        Some(user) => Ok(GetUser {
+        Some(user) => Ok(GetUserResult {
             name: u.id,
             comment: user.comment.clone(),
         }),
@@ -39,8 +65,8 @@ pub fn get_user(p: Params, state: &RpcState) -> Result<GetUser, ApiError> {
     }
 }
 
-pub fn get_users(_: Params, state: &RpcState) -> Result<Vec<GetUser>, ApiError> {
+pub fn get_users(_: Params, state: &RpcState) -> Result<Vec<GetUserResult>, ApiError> {
-    let mut res: Vec<GetUser> = Vec::new();
+    let mut res: Vec<GetUserResult> = Vec::new();
     for u in state
         .config_manager
         .get_pending_config()
@@ -48,7 +74,7 @@ pub fn get_users(_: Params, state: &RpcState) -> Result<Vec<GetUser>, ApiError>
         .users
         .iter()
     {
-        res.push(GetUser {
+        res.push(GetUserResult {
             name: u.0.to_string(),
             comment: u.1.comment.clone(),
         })

src/api/vpn.rs

@@ -1,8 +1,45 @@
-use jsonrpsee::types::Params;
+use std::collections::HashMap;
-
-use crate::state::RpcState;
 
 use super::ApiError;
+use crate::definitions::vpn::{WireguardInterface, WireguardPeer};
+use crate::state::RpcState;
+use crate::{get_map_thing, get_things};
+use jsonrpsee::types::Params;
+use jsonrpsee::RpcModule;
+
+pub fn register_methods(module: &mut RpcModule<RpcState>) {
+    module
+        .register_method("vpn.wireguard.get_status", get_wireguard_status)
+        .unwrap();
+
+    module
+        .register_method(
+            "vpn.wireguard.get_interface",
+            get_map_thing!(vpn.wireguard.interfaces),
+        )
+        .unwrap();
+
+    module
+        .register_method::<Result<HashMap<String, WireguardInterface>, ApiError>, _>(
+            "vpn.wireguard.get_interfaces",
+            get_things!(vpn.wireguard.interfaces),
+        )
+        .unwrap();
+
+    module
+        .register_method(
+            "vpn.wireguard.get_peer",
+            get_map_thing!(vpn.wireguard.peers),
+        )
+        .unwrap();
+
+    module
+        .register_method::<Result<HashMap<String, WireguardPeer>, ApiError>, _>(
+            "vpn.wireguard.get_peers",
+            get_things!(vpn.wireguard.peers),
+        )
+        .unwrap();
+}
 
 pub fn get_wireguard_status(_: Params, _: &RpcState) -> Result<String, ApiError> {
     Ok("ok".to_string())