fix: failure to open a single table does not interrupt the shard's opening process

server/src/grpc/meta_event_service/mod.rs

@@ -2,7 +2,7 @@
 
 // Meta event rpc service implementation.
 
-use std::{sync::Arc, time::Instant};
+use std::{collections::HashMap, sync::Arc, time::Instant};
 
 use analytic_engine::setup::OpenedWals;
 use async_trait::async_trait;
@@ -41,7 +41,7 @@ use self::shard_operation::WalCloserAdapter;
 use crate::{
     grpc::{
         meta_event_service::{
-            error::{ErrNoCause, ErrWithCause, Result, StatusCode},
+            error::{ErrNoCause, ErrWithCause, Error, Result, StatusCode},
             shard_operation::WalRegionCloserRef,
         },
         metrics::META_EVENT_GRPC_HANDLER_DURATION_HISTOGRAM_VEC,
@@ -210,6 +210,7 @@ impl HandlerContext {
 // implementation.
 
 async fn handle_open_shard(ctx: HandlerContext, request: OpenShardRequest) -> Result<()> {
+    let instant = Instant::now();
     let tables_of_shard =
         ctx.cluster
             .open_shard(&request)
@@ -236,6 +237,9 @@ async fn handle_open_shard(ctx: HandlerContext, request: OpenShardRequest) -> Re
         table_engine: ctx.table_engine,
     };
 
+    let mut success = 0;
+    let mut err_map = HashMap::new();
+
     for table in tables_of_shard.tables {
         let schema = find_schema(default_catalog.clone(), &table.schema_name)?;
 
@@ -249,21 +253,42 @@ async fn handle_open_shard(ctx: HandlerContext, request: OpenShardRequest) -> Re
             shard_id: shard_info.id,
             cluster_version: topology.cluster_topology_version,
         };
-        schema
-            .open_table(open_request.clone(), opts.clone())
-            .await
-            .box_err()
-            .with_context(|| ErrWithCause {
-                code: StatusCode::Internal,
-                msg: format!("fail to open table, open_request:{open_request:?}"),
-            })?
-            .with_context(|| ErrNoCause {
-                code: StatusCode::Internal,
-                msg: format!("no table is opened, open_request:{open_request:?}"),
-            })?;
+        let result = schema.open_table(open_request.clone(), opts.clone()).await;
+
+        match result {
+            Ok(Some(_)) => {
+                success += 1;
+            }
+            Ok(None) => {
+                error!("no table is opened, open_request:{open_request:?}");
+                err_map.insert(table.name, "no table is opened");
+            }
+            Err(e) => {
+                error!("fail to open table, open_request:{open_request:?}, err:{e}");
+                err_map.insert(table.name, "fail to open table");
+            }
+        };
     }
 
-    Ok(())
+    info!(
+        "Open shard finish, shard id:{}, cost:{}ms, successful tables:{}, failed tables:{}",
+        shard_info.id,
+        instant.saturating_elapsed().as_millis(),
+        success,
+        err_map.len(),
+    );
+
+    if err_map.is_empty() {
+        Ok(())
+    } else {
+        Err(Error::ErrNoCause {
+            code: StatusCode::Internal,
+            msg: format!(
+                "Failed to open shard:{}, because of failed tables:{err_map:?}",
+                shard_info.id
+            ),
+        })
+    }
 }
 
 async fn handle_close_shard(ctx: HandlerContext, request: CloseShardRequest) -> Result<()> {