Create an option "linera service --pause" (#5927)

## Motivation

Use `linera sync --next-height H` then query the state of the chain
without adding any more blocks.

## Proposal

Create an option `--pause` that skips the chain listener.

## Test Plan

CI + tested manually

## Release Plan

These changes should be backported to the latest `testnet` branch, then
be released in a new SDK,

Author: ma2bd

CLI.md

@@ -781,6 +781,7 @@ Run a GraphQL service to explore and extend the chains of the wallet
 * `--query-cache-size <QUERY_CACHE_SIZE>` — Enable the application query response cache with the given per-chain capacity. Each entry stores a serialized GraphQL response keyed by (application_id, request_bytes). Incompatible with `--long-lived-services`
 * `--allow-subscription <ALLOWED_SUBSCRIPTIONS>` — Allow a named GraphQL subscription query. The operation name is extracted from the query string. Repeatable. Example: `--allow-subscription 'query CounterValue { getCounter { value } }'`
 * `--subscription-ttl-secs <SUBSCRIPTION_TTLS>` — Set a minimum TTL (in seconds) for a subscription query's cached result. When set, invalidations that arrive before the TTL expires are deferred until the remaining time elapses. Format: `Name=Secs`. Repeatable. Example: `--subscription-ttl-secs CounterValue=30`
+* `--pause` — Start in paused mode: do not synchronize chains from the network. The service will serve queries from local state only, without downloading new blocks or processing incoming messages
 
 
 

linera-service/src/cli/command.rs

@@ -787,6 +787,12 @@ pub enum ClientCommand {
         /// Example: `--subscription-ttl-secs CounterValue=30`
         #[arg(long = "subscription-ttl-secs", value_parser = parse_subscription_ttl)]
         subscription_ttls: Vec<(String, u64)>,
+
+        /// Start in paused mode: do not synchronize chains from the network.
+        /// The service will serve queries from local state only, without downloading
+        /// new blocks or processing incoming messages.
+        #[arg(long)]
+        pause: bool,
     },
 
     /// Query an application with a read-only GraphQL query.

linera-service/src/cli/main.rs

@@ -1264,6 +1264,7 @@ impl Runnable for Job {
                 query_cache_size,
                 allowed_subscriptions,
                 subscription_ttls,
+                pause,
             } => {
                 let context = options
                     .create_client_context(storage, wallet, signer.into_value())
@@ -1362,6 +1363,7 @@ impl Runnable for Job {
                     query_subscriptions,
                     cancellation_token.clone(),
                     options.enable_memory_profiling(),
+                    pause,
                 );
                 service.run(cancellation_token, command_receiver).await?;
             }

linera-service/src/node_service.rs

@@ -1249,6 +1249,8 @@ where
     query_subscriptions: Option<Arc<crate::query_subscription::QuerySubscriptionManager>>,
     cancellation_token: CancellationToken,
     enable_memory_profiling: bool,
+    /// If true, do not start the chain listener; serve queries from local state only.
+    pause: bool,
 }
 
 impl<C> Clone for NodeService<C>
@@ -1268,6 +1270,7 @@ where
             query_subscriptions: self.query_subscriptions.clone(),
             cancellation_token: self.cancellation_token.clone(),
             enable_memory_profiling: self.enable_memory_profiling,
+            pause: self.pause,
         }
     }
 }
@@ -1293,6 +1296,7 @@ where
         query_subscriptions: Option<Arc<crate::query_subscription::QuerySubscriptionManager>>,
         cancellation_token: CancellationToken,
         enable_memory_profiling: bool,
+        pause: bool,
     ) -> Self {
         let query_cache = query_cache_size.map(|size| Arc::new(QueryResponseCache::new(size)));
         Self {
@@ -1307,6 +1311,7 @@ where
             query_subscriptions,
             cancellation_token,
             enable_memory_profiling,
+            pause,
         }
     }
 
@@ -1408,28 +1413,33 @@ where
             });
         }
 
-        let storage = self.context.lock().await.storage().clone();
-
-        let chain_listener = ChainListener::new(
-            self.config,
-            self.context,
-            storage,
-            cancellation_token.clone(),
-            command_receiver,
-            true,
-        )
-        .run()
-        .await?;
-        let mut chain_listener = Box::pin(chain_listener).fuse();
         let tcp_listener =
             tokio::net::TcpListener::bind(SocketAddr::from(([0, 0, 0, 0], port))).await?;
         let server = axum::serve(tcp_listener, app)
-            .with_graceful_shutdown(cancellation_token.cancelled_owned())
+            .with_graceful_shutdown(cancellation_token.clone().cancelled_owned())
             .into_future();
-        futures::select! {
-            result = chain_listener => result?,
-            result = Box::pin(server).fuse() => result?,
-        };
+
+        if self.pause {
+            info!("Running in paused mode: chain synchronization is disabled");
+            server.await?;
+        } else {
+            let storage = self.context.lock().await.storage().clone();
+            let chain_listener = ChainListener::new(
+                self.config,
+                self.context,
+                storage,
+                cancellation_token.clone(),
+                command_receiver,
+                true,
+            )
+            .run()
+            .await?;
+            let mut chain_listener = Box::pin(chain_listener).fuse();
+            futures::select! {
+                result = chain_listener => result?,
+                result = Box::pin(server).fuse() => result?,
+            };
+        }
 
         Ok(())
     }

linera-service/src/schema_export.rs

@@ -256,6 +256,7 @@ async fn main() -> std::io::Result<()> {
         None,
         tokio_util::sync::CancellationToken::new(),
         false, // memory profiling disabled for schema export
+        false, // not paused
     );
     let schema = service.schema().sdl();
     print!("{}", schema);