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

split register_method calls into proper files

Browse source
This commit is contained in:
Samuel Lorch 2023-10-30 22:49:55 +01:00
parent 77e2430507
commit 1f9c2d62df
8 changed files with 277 additions and 239 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
src/api/config.rs
View file

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

50
src/api/firewall.rs
View file

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

251
src/api/mod.rs
View file

@ -6,24 +6,11 @@ mod service;
mod system;
mod vpn;
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 crate::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
.register_method("system.get_user", system::get_user)
.unwrap();
module
.register_method("system.get_users", system::get_users)
.unwrap();
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();
config::register_methods(&mut module);
firewall::register_methods(&mut module);
network::register_methods(&mut module);
object::register_methods(&mut module);
service::register_methods(&mut module);
system::register_methods(&mut module);
vpn::register_methods(&mut module);
module
}

34
src/api/network.rs
View file

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

31
src/api/object.rs
View file

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

50
src/api/service.rs
View file

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

42
src/api/system.rs
View file

@ -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> {
let u: GetStringID = p.parse().map_err(ParameterDeserialize)?;
#[derive(Deserialize)]
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> {
let mut res: Vec<GetUser> = Vec::new();
pub fn get_users(_: Params, state: &RpcState) -> Result<Vec<GetUserResult>, ApiError> {
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(),
})

43
src/api/vpn.rs
View file

@ -1,8 +1,45 @@
use jsonrpsee::types::Params;
use crate::state::RpcState;
use std::collections::HashMap;
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())