Connect to microgrid API lazily so startup tolerates absent server

Replace the eager Channel::connect call in MicrogridClientHandle::try_new
with Endpoint::connect_lazy, so a missing server at startup no longer
causes the calling app to exit immediately.  Connection errors now
surface per-RPC, where the actor's existing per-stream retry loop can
recover once the server becomes reachable.

Signed-off-by: Sahas Subramanian <sahas.subramanian@proton.me>

Author: shsms

src/client/microgrid_client_handle.rs

@@ -8,7 +8,7 @@
 
 use chrono::TimeDelta;
 use tokio::sync::{broadcast, mpsc, oneshot};
-use tonic::transport::Channel;
+use tonic::transport::{Channel, Endpoint};
 
 use crate::{
     Bounds, Error,
@@ -36,20 +36,25 @@ pub struct MicrogridClientHandle {
 }
 
 impl MicrogridClientHandle {
-    /// Creates a new `MicrogridClientHandle` that connects to the microgrid API
-    /// at the specified URL.
+    /// Creates a new `MicrogridClientHandle` for the microgrid API at the
+    /// specified URL.
+    ///
+    /// The connection is established lazily on the first RPC, so this method
+    /// succeeds even when no server is reachable yet.  Per-call errors will
+    /// surface from the individual RPC methods, and the actor's per-stream
+    /// retry loop will keep attempting to reconnect telemetry streams.
+    ///
+    /// Returns an error only if `url` is not a valid endpoint URL.
     pub async fn try_new(url: impl Into<String>) -> Result<Self, Error> {
-        let client = match MicrogridClient::<Channel>::connect(url.into()).await {
-            Ok(t) => t,
-            Err(e) => {
-                tracing::error!("Could not connect to server: {e}");
-                return Err(Error::connection_failure(format!(
-                    "Could not connect to server: {e}"
-                )));
-            }
-        };
-
-        Ok(Self::new_from_client(client))
+        let url = url.into();
+        let channel = Endpoint::from_shared(url.clone())
+            .map_err(|e| {
+                Error::connection_failure(format!("Invalid microgrid API URL {url}: {e}"))
+            })?
+            .connect_lazy();
+        Ok(Self::new_from_client(MicrogridClient::<Channel>::new(
+            channel,
+        )))
     }
 
     pub fn new_from_client(client: impl MicrogridApiClient) -> Self {

src/microgrid.rs

@@ -21,8 +21,11 @@ impl Microgrid {
     /// Creates a new `Microgrid` instance with the given microgrid API URL and
     /// logical meter configuration.
     ///
-    /// Returns an error if the URL is unreachable, or if the component graph
-    /// cannot be created with the given configuration.
+    /// The microgrid API connection is established lazily and connection or
+    /// component-graph build errors during setup are retried indefinitely, so
+    /// this call blocks until the server is reachable and returns valid data.
+    /// Returns an error only if the URL is malformed or if the provided
+    /// logical meter configuration is invalid.
     pub async fn try_new(
         url: impl Into<String>,
         config: LogicalMeterConfig,