[RFC datacenter-manager 1/6] connection: store client factory in an Arc and add public getter

[Lukas Wagner <l.wagner@proxmox.com>]

This will be useful to truly ensure that everybody is using the same
factory.

Signed-off-by: Lukas Wagner <l.wagner@proxmox.com>
---
 server/src/connection.rs                      | 29 ++++++++++++-------
 server/src/context.rs                         |  4 ++-
 .../src/metric_collection/collection_task.rs  |  2 +-
 3 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/server/src/connection.rs b/server/src/connection.rs
index 7e366719..f144f9cf 100644
--- a/server/src/connection.rs
+++ b/server/src/connection.rs
@@ -26,7 +26,7 @@ use pve_api_types::client::PveClientImpl;
 
 use crate::pbs_client::PbsClient;
 
-static INSTANCE: OnceLock<Box<dyn ClientFactory + Send + Sync>> = OnceLock::new();
+static INSTANCE: OnceLock<Arc<dyn ClientFactory + Send + Sync>> = OnceLock::new();
 
 /// Connection Info returned from [`prepare_connect_client`]
 struct ConnectInfo {
@@ -396,7 +396,8 @@ impl ClientFactory for DefaultClientFactory {
     }
 }
 
-fn instance() -> &'static (dyn ClientFactory + Send + Sync) {
+/// Get a handle to the global client factory (as an reference).
+pub fn client_factory_ref() -> &'static (dyn ClientFactory + Send + Sync) {
     // Not initializing the connection factory instance is
     // entirely in our responsibility and not something we can recover from,
     // so it should be okay to panic in this case.
@@ -406,9 +407,17 @@ fn instance() -> &'static (dyn ClientFactory + Send + Sync) {
         .as_ref()
 }
 
+/// Get a handle to the global client factory (as an Arc).
+pub fn client_factory() -> Arc<dyn ClientFactory + Send + Sync> {
+    // Not initializing the connection factory instance is
+    // entirely in our responsibility and not something we can recover from,
+    // so it should be okay to panic in this case.
+    Arc::clone(INSTANCE.get().expect("client factory instance not set"))
+}
+
 /// Create a new API client for PVE remotes
 pub fn make_pve_client(remote: &Remote) -> Result<Arc<PveClient>, Error> {
-    instance().make_pve_client(remote)
+    client_factory_ref().make_pve_client(remote)
 }
 
 /// Create a new API client for PVE remotes, but for a specific endpoint
@@ -416,21 +425,21 @@ pub fn make_pve_client_with_endpoint(
     remote: &Remote,
     target_endpoint: Option<&str>,
 ) -> Result<Arc<PveClient>, Error> {
-    instance().make_pve_client_with_endpoint(remote, target_endpoint)
+    client_factory_ref().make_pve_client_with_endpoint(remote, target_endpoint)
 }
 
 /// Create a new API client for PVE remotes and try to make it connect to a specific *node*.
 pub fn make_pve_client_with_node(remote: &Remote, node: &str) -> Result<Arc<PveClient>, Error> {
-    instance().make_pve_client_with_node(remote, node)
+    client_factory_ref().make_pve_client_with_node(remote, node)
 }
 
 /// Create a new API client for PBS remotes
 pub fn make_pbs_client(remote: &Remote) -> Result<Box<PbsClient>, Error> {
-    instance().make_pbs_client(remote)
+    client_factory_ref().make_pbs_client(remote)
 }
 
 pub fn make_raw_client(remote: &Remote) -> Result<Box<Client>, Error> {
-    instance().make_raw_client(remote)
+    client_factory_ref().make_raw_client(remote)
 }
 
 /// Create a new API client for PVE remotes.
@@ -443,7 +452,7 @@ pub fn make_raw_client(remote: &Remote) -> Result<Box<Client>, Error> {
 ///
 /// Note: currently does not support two factor authentication.
 pub async fn make_pve_client_and_login(remote: &Remote) -> Result<Arc<PveClient>, Error> {
-    instance().make_pve_client_and_login(remote).await
+    client_factory_ref().make_pve_client_and_login(remote).await
 }
 
 /// Create a new API client for PBS remotes.
@@ -456,13 +465,13 @@ pub async fn make_pve_client_and_login(remote: &Remote) -> Result<Arc<PveClient>
 ///
 /// Note: currently does not support two factor authentication.
 pub async fn make_pbs_client_and_login(remote: &Remote) -> Result<Box<PbsClient>, Error> {
-    instance().make_pbs_client_and_login(remote).await
+    client_factory_ref().make_pbs_client_and_login(remote).await
 }
 
 /// Initialize the [`ClientFactory`] instance.
 ///
 /// Will panic if the instance has already been set.
-pub fn init(instance: Box<dyn ClientFactory + Send + Sync>) {
+pub fn init(instance: Arc<dyn ClientFactory + Send + Sync>) {
     if INSTANCE.set(instance).is_err() {
         panic!("connection factory instance already set");
     }
diff --git a/server/src/context.rs b/server/src/context.rs
index c5da0afd..8c841eec 100644
--- a/server/src/context.rs
+++ b/server/src/context.rs
@@ -2,6 +2,8 @@
 //!
 //! Make sure to call `init` *once* when starting up the API server.
 
+use std::sync::Arc;
+
 use anyhow::Error;
 
 use crate::connection;
@@ -10,7 +12,7 @@ use crate::connection;
 #[allow(dead_code)]
 fn default_remote_setup() {
     pdm_config::remotes::init(Box::new(pdm_config::remotes::DefaultRemoteConfig));
-    connection::init(Box::new(connection::DefaultClientFactory));
+    connection::init(Arc::new(connection::DefaultClientFactory));
 }
 
 /// Dependency-inject concrete implementations needed at runtime.
diff --git a/server/src/metric_collection/collection_task.rs b/server/src/metric_collection/collection_task.rs
index cc1a460e..00ab2cc0 100644
--- a/server/src/metric_collection/collection_task.rs
+++ b/server/src/metric_collection/collection_task.rs
@@ -553,7 +553,7 @@ pub(super) mod tests {
             // TODO: the client factory is currently stored in a OnceLock -
             // we can only set it from one test... Ideally we'd like to have the
             // option to set it in every single test if needed - task/thread local?
-            connection::init(Box::new(TestClientFactory { now }));
+            connection::init(Arc::new(TestClientFactory { now }));
         });
 
         now
-- 
2.47.3