Replace duplicate get functions with macros

src/api/firewall.rs

@@ -1,35 +1 @@
-use jsonrpsee::types::Params;
 
-use crate::{
-    definitions::firewall::{DestinationNATRule, ForwardRule, SourceNATRule},
-    state::RpcState,
-};
-
-use super::ApiError;
-
-pub fn get_forward_rules(_: Params, state: &RpcState) -> Result<Vec<ForwardRule>, ApiError> {
-    Ok(state
-        .config_manager
-        .get_pending_config()
-        .firewall
-        .forward_rules)
-}
-
-pub fn get_source_nat_rules(_: Params, state: &RpcState) -> Result<Vec<SourceNATRule>, ApiError> {
-    Ok(state
-        .config_manager
-        .get_pending_config()
-        .firewall
-        .source_nat_rules)
-}
-
-pub fn get_destination_nat_rules(
-    _: Params,
-    state: &RpcState,
-) -> Result<Vec<DestinationNATRule>, ApiError> {
-    Ok(state
-        .config_manager
-        .get_pending_config()
-        .firewall
-        .destination_nat_rules)
-}

src/api/mod.rs

@@ -6,7 +6,18 @@ mod service;
 mod system;
 mod vpn;
 
-use crate::state::RpcState;
+use std::collections::HashMap;
+
+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,
@@ -36,6 +47,7 @@ pub enum ApiError {
 
 impl Into<ErrorObject<'static>> for ApiError {
     fn into(self) -> ErrorObject<'static> {
+        info!("Converting Error {:?}", self);
         match self {
             // Todo Add Proper mappings
             // ApiError::ParameterDeserialize => ErrorCode::InvalidParams,
@@ -56,6 +68,56 @@ struct GetIntID {
     id: i64,
 }
 
+#[macro_export]
+macro_rules! get_map_thing {
+    ($( $sub_system:ident ).+) => {
+        |params, state| {
+            let t: GetStringID = params.parse().map_err(ApiError::ParameterDeserialize)?;
+
+            match state
+                .config_manager
+                .get_pending_config()
+                .$($sub_system).+
+                .get(&t.id)
+            {
+                Some(thing) => Ok(thing.clone()),
+                None => Err(ApiError::NotFound),
+            }
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! get_vec_thing {
+    ($( $sub_system:ident ).+) => {
+        |params, state| {
+            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{
+                Ok(things[t.id as usize].clone())
+            } else {
+                Err(ApiError::NotFound)
+            }
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! get_things {
+    ($( $sub_system:ident ).+) => {
+        |_, state| {
+            Ok(state
+            .config_manager
+            .get_pending_config()
+            .$($sub_system).+)
+        }
+    };
+}
+
 pub fn new_rpc_module(state: RpcState) -> RpcModule<RpcState> {
     let mut module = RpcModule::new(state);
 
@@ -79,49 +141,134 @@ pub fn new_rpc_module(state: RpcState) -> RpcModule<RpcState> {
         .register_method("system.delete_user", system::delete_user)
         .unwrap();
 
-    module
-        .register_method("network.get_static_routes", network::get_static_routes)
-        .unwrap();
-
-    module
-        .register_method("network.get_interfaces", network::get_interfaces)
-        .unwrap();
-
-    module
-        .register_method("object.get_services", object::get_services)
-        .unwrap();
-
-    module
-        .register_method("object.get_addresses", object::get_addresses)
-        .unwrap();
-
-    module
-        .register_method("service.get_dhcp_servers", service::get_dhcp_servers)
-        .unwrap();
-
-    module
-        .register_method("service.get_dns_servers", service::get_dns_servers)
-        .unwrap();
-
-    module
-        .register_method("service.get_ntp_servers", service::get_ntp_servers)
-        .unwrap();
-
-    module
-        .register_method("firewall.get_forward_rules", firewall::get_forward_rules)
-        .unwrap();
-
     module
         .register_method(
-            "firewall.get_destination_nat_rules",
+            "network.get_static_route",
-            firewall::get_destination_nat_rules,
+            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",
-            firewall::get_source_nat_rules,
+            get_things!(firewall.source_nat_rules),
         )
         .unwrap();
 
@@ -147,18 +294,35 @@ pub fn new_rpc_module(state: RpcState) -> RpcModule<RpcState> {
         .unwrap();
 
     module
-        .register_method("vpn.get_wireguard_status", vpn::get_wireguard_status)
+        .register_method("vpn.wireguard.get_status", vpn::get_wireguard_status)
         .unwrap();
 
     module
         .register_method(
-            "vpn.get_wireguard_interfaces",
+            "vpn.wireguard.get_interface",
-            vpn::get_wireguard_interfaces,
+            get_map_thing!(vpn.wireguard.interfaces),
         )
         .unwrap();
 
     module
-        .register_method("vpn.get_wireguard_peers", vpn::get_wireguard_peers)
+        .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,25 +1 @@
-use std::collections::HashMap;
 
-use jsonrpsee::types::Params;
-
-use crate::{
-    definitions::network::{NetworkInterface, StaticRoute},
-    state::RpcState,
-};
-
-use super::ApiError;
-
-pub fn get_static_routes(_: Params, state: &RpcState) -> Result<Vec<StaticRoute>, ApiError> {
-    Ok(state
-        .config_manager
-        .get_pending_config()
-        .network
-        .static_routes)
-}
-
-pub fn get_interfaces(
-    _: Params,
-    state: &RpcState,
-) -> Result<HashMap<String, NetworkInterface>, ApiError> {
-    Ok(state.config_manager.get_pending_config().network.interfaces)
-}

src/api/object.rs

@@ -1,18 +1 @@
-use std::collections::HashMap;
 
-use jsonrpsee::types::Params;
-
-use crate::{
-    definitions::object::{Address, Service},
-    state::RpcState,
-};
-
-use super::ApiError;
-
-pub fn get_services(_: Params, state: &RpcState) -> Result<HashMap<String, Service>, ApiError> {
-    Ok(state.config_manager.get_pending_config().object.services)
-}
-
-pub fn get_addresses(_: Params, state: &RpcState) -> Result<HashMap<String, Address>, ApiError> {
-    Ok(state.config_manager.get_pending_config().object.addresses)
-}

src/api/service.rs

@@ -1,34 +1 @@
-use std::collections::HashMap;
 
-use jsonrpsee::types::Params;
-
-use crate::{
-    definitions::service::{DHCPServer, DNSServer, NTPServer},
-    state::RpcState,
-};
-
-use super::ApiError;
-
-pub fn get_dhcp_servers(_: Params, state: &RpcState) -> Result<Vec<DHCPServer>, ApiError> {
-    Ok(state
-        .config_manager
-        .get_pending_config()
-        .service
-        .dhcp_servers)
-}
-
-pub fn get_dns_servers(_: Params, state: &RpcState) -> Result<Vec<DNSServer>, ApiError> {
-    Ok(state
-        .config_manager
-        .get_pending_config()
-        .service
-        .dns_servers)
-}
-
-pub fn get_ntp_servers(_: Params, state: &RpcState) -> Result<Vec<NTPServer>, ApiError> {
-    Ok(state
-        .config_manager
-        .get_pending_config()
-        .service
-        .ntp_servers)
-}

src/api/vpn.rs

@@ -1,41 +1,9 @@
-use std::collections::HashMap;
-
 use jsonrpsee::types::Params;
 
-use crate::{
+use crate::state::RpcState;
-    definitions::{
-        service::{DHCPServer, DNSServer, NTPServer},
-        vpn::{WireguardInterface, WireguardPeer},
-    },
-    state::RpcState,
-};
 
 use super::ApiError;
 
-pub fn get_wireguard_status(_: Params, state: &RpcState) -> Result<String, ApiError> {
+pub fn get_wireguard_status(_: Params, _: &RpcState) -> Result<String, ApiError> {
     Ok("ok".to_string())
 }
-
-pub fn get_wireguard_interfaces(
-    _: Params,
-    state: &RpcState,
-) -> Result<HashMap<String, WireguardInterface>, ApiError> {
-    Ok(state
-        .config_manager
-        .get_pending_config()
-        .vpn
-        .wireguard
-        .interfaces)
-}
-
-pub fn get_wireguard_peers(
-    _: Params,
-    state: &RpcState,
-) -> Result<HashMap<String, WireguardPeer>, ApiError> {
-    Ok(state
-        .config_manager
-        .get_pending_config()
-        .vpn
-        .wireguard
-        .peers)
-}