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

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

Add an endpoint for listing the vnets 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, but for now we decided against it.

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

diff --git a/lib/pdm-api-types/src/sdn.rs b/lib/pdm-api-types/src/sdn.rs
index ca5a21e..c102bba 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::SdnZone;
+use pve_api_types::{SdnVnet, SdnZone};
 use serde::{Deserialize, Serialize};
 
 use crate::remotes::REMOTE_ID_SCHEMA;
@@ -68,6 +68,25 @@ pub struct CreateZoneParams {
     pub remotes: Vec<CreateZoneRemote>,
 }
 
+#[api(
+    properties: {
+        remote: {
+            schema: REMOTE_ID_SCHEMA,
+        },
+        vnet: {
+            type: pve_api_types::SdnVnet,
+            flatten: true,
+        }
+    }
+)]
+/// SDN controller with additional information about which remote it belongs to
+#[derive(Serialize, Deserialize, Clone, PartialEq, Debug)]
+pub struct ListVnet {
+    pub remote: String,
+    #[serde(flatten)]
+    pub vnet: SdnVnet,
+}
+
 #[api(
     properties: {
         remote: {
diff --git a/lib/pdm-client/src/lib.rs b/lib/pdm-client/src/lib.rs
index 9da18c9..37961be 100644
--- a/lib/pdm-client/src/lib.rs
+++ b/lib/pdm-client/src/lib.rs
@@ -8,7 +8,7 @@ use pdm_api_types::resource::{PveResource, RemoteResources, TopEntities};
 use pdm_api_types::rrddata::{
     LxcDataPoint, NodeDataPoint, PbsDatastoreDataPoint, PbsNodeDataPoint, QemuDataPoint,
 };
-use pdm_api_types::sdn::ListZone;
+use pdm_api_types::sdn::{ListVnet, ListZone};
 use pdm_api_types::BasicRealmInfo;
 use pve_api_types::StartQemuMigrationType;
 use serde::{Deserialize, Serialize};
@@ -986,6 +986,19 @@ impl<T: HttpApiClient> PdmClient<T> {
         Ok(self.0.get(&path).await?.expect_json()?.data)
     }
 
+    pub async fn pve_sdn_list_vnets(
+        &self,
+        pending: impl Into<Option<bool>>,
+        running: impl Into<Option<bool>>,
+    ) -> Result<Vec<ListVnet>, Error> {
+        let path = ApiPathBuilder::new("/api2/extjs/sdn/vnets".to_string())
+            .maybe_arg("pending", &pending.into())
+            .maybe_arg("running", &running.into())
+            .build();
+
+        Ok(self.0.get(&path).await?.expect_json()?.data)
+    }
+
     pub async fn pve_sdn_create_zone(&self, params: CreateZoneParams) -> Result<String, Error> {
         let path = "/api2/extjs/sdn/zones";
 
diff --git a/server/src/api/sdn/mod.rs b/server/src/api/sdn/mod.rs
index 2abdaf6..ccf7123 100644
--- a/server/src/api/sdn/mod.rs
+++ b/server/src/api/sdn/mod.rs
@@ -1,10 +1,12 @@
 use proxmox_router::{list_subdirs_api_method, Router, SubdirMap};
 use proxmox_sortable_macro::sortable;
 
+pub mod vnets;
 pub mod zones;
 
 #[sortable]
 pub const SUBDIRS: SubdirMap = &sorted!([
+    ("vnets", &vnets::ROUTER),
     ("zones", &zones::ROUTER),
 ]);
 
diff --git a/server/src/api/sdn/vnets.rs b/server/src/api/sdn/vnets.rs
new file mode 100644
index 0000000..899c486
--- /dev/null
+++ b/server/src/api/sdn/vnets.rs
@@ -0,0 +1,107 @@
+use std::collections::HashSet;
+
+use anyhow::{format_err, Error};
+
+use pbs_api_types::REMOTE_ID_SCHEMA;
+use pdm_api_types::{remotes::RemoteType, sdn::ListVnet};
+use proxmox_router::Router;
+use proxmox_schema::api;
+
+use crate::{
+    api::pve,
+    parallel_fetcher::{NodeResults, ParallelFetcher},
+    sdn_client::LockedSdnClients,
+};
+
+pub const ROUTER: Router = Router::new().get(&API_METHOD_LIST_VNETS);
+
+#[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.",
+            },
+            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: ListVnet,
+        },
+    },
+)]
+/// Query VNets of PVE remotes with optional filtering options
+async fn list_vnets(
+    pending: Option<bool>,
+    running: Option<bool>,
+    remotes: Option<HashSet<String>>,
+) -> Result<Vec<ListVnet>, 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));
+
+    let results = fetcher
+        .do_for_all_remotes(filtered_remotes, async |ctx, r, _| {
+            Ok(pve::connect(&r)?.list_vnets(ctx.0, ctx.1).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(|vnet| ListVnet {
+                                remote: remote.clone(),
+                                vnet,
+                            }))
+                        }
+                        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)
+}
-- 
2.47.2


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