speatzle/nfsense
1
0
Fork 0
mirror of https://github.com/speatzle/nfsense.git synced 2025-05-10 10:38:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Replace duplicate get functions with macros

Browse source
This commit is contained in:
Samuel Lorch 2023-10-30 22:11:17 +01:00
parent b90e56c508
commit a9b99899c0
6 changed files with 206 additions and 182 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
src/api/firewall.rs
View file

@ -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)
}

244
src/api/mod.rs
View file

@ -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",
firewall::get_destination_nat_rules,
"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",
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::get_wireguard_interfaces,
"vpn.wireguard.get_interface",
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

24
src/api/network.rs
View file

@ -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)
}

17
src/api/object.rs
View file

@ -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)
}

33
src/api/service.rs
View file

@ -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)
}

36
src/api/vpn.rs
View file

@ -1,41 +1,9 @@
use std::collections::HashMap;
use jsonrpsee::types::Params;
use crate::{
definitions::{
service::{DHCPServer, DNSServer, NTPServer},
vpn::{WireguardInterface, WireguardPeer},
},
state::RpcState,
};
use crate::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)
}