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

rename all rpc methods to new schema

Browse source
This commit is contained in:
Samuel Lorch 2023-11-01 03:37:45 +01:00
parent eecdb51509
commit 7eb8b87952
8 changed files with 67 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/api/config.rs
View file

@ -9,15 +9,15 @@ use super::ApiError::ConfigError;
pub fn register_methods(module: &mut RpcModule<RpcState>) { pub fn register_methods(module: &mut RpcModule<RpcState>) {
module module
.register_method("config.get_pending_changelog", get_pending_changelog) .register_method("config.pending_changes.log", get_pending_changelog)
.unwrap(); .unwrap();
module module
.register_method("config.apply_pending_changes", apply_pending_changes) .register_method("config.pending_changes.apply", apply_pending_changes)
.unwrap(); .unwrap();
module module
.register_method("config.discard_pending_changes", discard_pending_changes) .register_method("config.pending_changes.discard", discard_pending_changes)
.unwrap(); .unwrap();
} }

26
src/api/firewall.rs
View file

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

2
src/api/mod.rs
View file

@ -93,7 +93,7 @@ macro_rules! get_vec_thing {
} }
#[macro_export] #[macro_export]
macro_rules! get_things { macro_rules! list_things {
($( $sub_system:ident ).+) => { ($( $sub_system:ident ).+) => {
|_, state| { |_, state| {
Ok(state Ok(state

18
src/api/network.rs
View file

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

18
src/api/object.rs
View file

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

26
src/api/service.rs
View file

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

14
src/api/system.rs
View file

@ -17,22 +17,24 @@ use super::ApiError;
const USER_CHANGE_PATH: &str = "system.user"; const USER_CHANGE_PATH: &str = "system.user";
pub fn register_methods(module: &mut RpcModule<RpcState>) { pub fn register_methods(module: &mut RpcModule<RpcState>) {
module.register_method("system.get_user", get_user).unwrap();
module module
.register_method("system.get_users", get_users) .register_method("system.users.get", get_user)
.unwrap(); .unwrap();
module module
.register_method("system.create_user", create_user) .register_method("system.users.list", get_users)
.unwrap(); .unwrap();
module module
.register_method("system.update_user", update_user) .register_method("system.users.create", create_user)
.unwrap(); .unwrap();
module module
.register_method("system.delete_user", delete_user) .register_method("system.users.update", update_user)
.unwrap();
module
.register_method("system.users.delete", delete_user)
.unwrap(); .unwrap();
} }

22
src/api/vpn.rs
View file

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