[pdm-devel] [PATCH proxmox-datacenter-manager v4 07/15] api: sdn: add list_controllers endpoint

[Stefan Hanreich <s.hanreich@proxmox.com>]

Add an endpoint for listing the controllers of all configured PVE
remotes. They can be filtered by type / remote and it exposes options
for querying the pending / running configuration.

This call is quite expensive, since it makes a GET call to every
configured PVE remote, which can take awhile depending on the network
connection. For the future we might want to introduce a caching
mechanism for this call.

Signed-off-by: Stefan Hanreich <s.hanreich@proxmox.com>
---
 lib/pdm-api-types/src/sdn.rs      |  23 +++++-
 lib/pdm-client/src/lib.rs         |  21 +++++-
 server/src/api/sdn/controllers.rs | 114 ++++++++++++++++++++++++++++++
 server/src/api/sdn/mod.rs         |   2 +
 4 files changed, 156 insertions(+), 4 deletions(-)
 create mode 100644 server/src/api/sdn/controllers.rs

diff --git a/lib/pdm-api-types/src/sdn.rs b/lib/pdm-api-types/src/sdn.rs
index a291c11..34ab36c 100644
--- a/lib/pdm-api-types/src/sdn.rs
+++ b/lib/pdm-api-types/src/sdn.rs
@@ -1,5 +1,5 @@
-use proxmox_schema::{api, const_regex, ApiStringFormat, IntegerSchema, Schema, StringSchema};
-use pve_api_types::{SdnVnet, SdnZone};
+use proxmox_schema::{api, ApiStringFormat, IntegerSchema, Schema, StringSchema};
+use pve_api_types::{SdnController, SdnVnet, SdnZone};
 use serde::{Deserialize, Serialize};
 
 use crate::remotes::REMOTE_ID_SCHEMA;
@@ -113,6 +113,25 @@ pub struct CreateVnetParams {
     pub remotes: Vec<CreateVnetRemote>,
 }
 
+#[api(
+    properties: {
+        remote: {
+            schema: REMOTE_ID_SCHEMA,
+        },
+        controller: {
+            type: pve_api_types::SdnController,
+            flatten: true,
+        }
+    }
+)]
+/// SDN controller with additional information about which remote it belongs to
+#[derive(Serialize, Deserialize, Clone, PartialEq)]
+pub struct ListController {
+    pub remote: String,
+    #[serde(flatten)]
+    pub controller: SdnController,
+}
+
 #[api(
     properties: {
         remote: {
diff --git a/lib/pdm-client/src/lib.rs b/lib/pdm-client/src/lib.rs
index a17a045..9314559 100644
--- a/lib/pdm-client/src/lib.rs
+++ b/lib/pdm-client/src/lib.rs
@@ -59,8 +59,10 @@ pub mod types {
 
     pub use pve_api_types::PveUpid;
 
-    pub use pdm_api_types::sdn::{CreateVnetParams, CreateZoneParams, ListVnet, ListZone};
-    pub use pve_api_types::ListZonesType;
+    pub use pdm_api_types::sdn::{
+        CreateVnetParams, CreateZoneParams, ListController, ListVnet, ListZone,
+    };
+    pub use pve_api_types::{ListControllersType, ListZonesType, SdnObjectState};
 }
 
 pub struct PdmClient<T: HttpApiClient>(pub T);
@@ -971,6 +973,21 @@ impl<T: HttpApiClient> PdmClient<T> {
             .data)
     }
 
+    pub async fn pve_sdn_list_controllers(
+        &self,
+        pending: impl Into<Option<bool>>,
+        running: impl Into<Option<bool>>,
+        ty: impl Into<Option<ListControllersType>>,
+    ) -> Result<Vec<ListController>, Error> {
+        let path = ApiPathBuilder::new("/api2/extjs/sdn/controllers".to_string())
+            .maybe_arg("pending", &pending.into())
+            .maybe_arg("running", &running.into())
+            .maybe_arg("ty", &ty.into())
+            .build();
+
+        Ok(self.0.get(&path).await?.expect_json()?.data)
+    }
+
     pub async fn pve_sdn_list_zones(
         &self,
         pending: impl Into<Option<bool>>,
diff --git a/server/src/api/sdn/controllers.rs b/server/src/api/sdn/controllers.rs
new file mode 100644
index 0000000..271397a
--- /dev/null
+++ b/server/src/api/sdn/controllers.rs
@@ -0,0 +1,114 @@
+use std::collections::HashSet;
+
+use anyhow::Error;
+
+use pbs_api_types::REMOTE_ID_SCHEMA;
+use pdm_api_types::{remotes::RemoteType, sdn::ListController};
+use proxmox_router::Router;
+use proxmox_schema::api;
+use pve_api_types::ListControllersType;
+
+use crate::{
+    api::pve,
+    parallel_fetcher::{NodeResults, ParallelFetcher},
+};
+
+pub const ROUTER: Router = Router::new().get(&API_METHOD_LIST_CONTROLLERS);
+
+#[api(
+    input: {
+        properties: {
+            pending: {
+                type: Boolean,
+                optional: true,
+                description: "Include a list of attributes whose changes are currently pending.",
+            },
+            running: {
+                type: Boolean,
+                optional: true,
+                description: "If true shows the running configuration, otherwise the pending configuration.",
+            },
+            ty: {
+                type: ListControllersType,
+                optional: true,
+            },
+            remotes: {
+                type: Array,
+                optional: true,
+                description: "Only return controllers from the specified remotes.",
+                items: {
+                    schema: REMOTE_ID_SCHEMA,
+                }
+            },
+        }
+    },
+    returns: {
+        type: Array,
+        description: "Get a list of controllers fitting the filtering criteria.",
+        items: {
+            type: ListController,
+        },
+    },
+)]
+/// Query controllers of remotes with optional filtering options
+pub async fn list_controllers(
+    pending: Option<bool>,
+    running: Option<bool>,
+    ty: Option<ListControllersType>,
+    remotes: Option<HashSet<String>>,
+) -> Result<Vec<ListController>, Error> {
+    let (remote_config, _) = pdm_config::remotes::config()?;
+
+    let filtered_remotes = remote_config.into_iter().filter_map(|(_, remote)| {
+        if remote.ty == RemoteType::Pve
+            && remotes
+                .as_ref()
+                .map(|remotes| remotes.contains(&remote.id))
+                .unwrap_or(true)
+        {
+            return Some(remote);
+        }
+
+        None
+    });
+
+    let mut vnets = Vec::new();
+    let fetcher = ParallelFetcher::new((pending, running, ty));
+
+    let results = fetcher
+        .do_for_all_remotes(filtered_remotes, async |ctx, r, _| {
+            Ok(pve::connect(&r)?
+                .list_controllers(ctx.0, ctx.1, ctx.2)
+                .await?)
+        })
+        .await;
+
+    for (remote, remote_result) in results.remote_results.into_iter() {
+        match remote_result {
+            Ok(remote_result) => {
+                for (node, node_result) in remote_result.node_results.into_iter() {
+                    match node_result {
+                        Ok(NodeResults { data, .. }) => {
+                            vnets.extend(data.into_iter().map(|controller| ListController {
+                                remote: remote.clone(),
+                                controller,
+                            }))
+                        }
+                        Err(error) => {
+                            log::error!(
+                                "could not fetch vnets from remote {} node {}: {error:#}",
+                                remote,
+                                node
+                            );
+                        }
+                    }
+                }
+            }
+            Err(error) => {
+                log::error!("could not fetch vnets from remote {}: {error:#}", remote)
+            }
+        }
+    }
+
+    Ok(vnets)
+}
diff --git a/server/src/api/sdn/mod.rs b/server/src/api/sdn/mod.rs
index ccf7123..ef0f8b9 100644
--- a/server/src/api/sdn/mod.rs
+++ b/server/src/api/sdn/mod.rs
@@ -1,11 +1,13 @@
 use proxmox_router::{list_subdirs_api_method, Router, SubdirMap};
 use proxmox_sortable_macro::sortable;
 
+pub mod controllers;
 pub mod vnets;
 pub mod zones;
 
 #[sortable]
 pub const SUBDIRS: SubdirMap = &sorted!([
+    ("controllers", &controllers::ROUTER),
     ("vnets", &vnets::ROUTER),
     ("zones", &zones::ROUTER),
 ]);
-- 
2.47.2


_______________________________________________
pdm-devel mailing list
pdm-devel@lists.proxmox.com
https://lists.proxmox.com/cgi-bin/mailman/listinfo/pdm-devel