feat: add Lua admin client support and metrics subcommand to metactl (#18461)

* feat: add Lua admin client support and metrics subcommand to metactl

- Add MetricsArgs and metrics subcommand to metactl CLI
- Implement LuaAdminClient with admin API methods (metrics, status, transfer_leader, etc.)
- Add new_admin_client function to Lua environment
- Add comprehensive test suite for Lua admin client functionality
- Update utils.py to improve error handling in run_command

* M  tests/metactl/subcommands/cmd_metrics.py

Author: drmingdrmer

src/meta/binaries/metactl/main.rs

@@ -34,6 +34,7 @@ use databend_common_meta_control::args::GlobalArgs;
 use databend_common_meta_control::args::ImportArgs;
 use databend_common_meta_control::args::ListFeatures;
 use databend_common_meta_control::args::LuaArgs;
+use databend_common_meta_control::args::MetricsArgs;
 use databend_common_meta_control::args::SetFeature;
 use databend_common_meta_control::args::StatusArgs;
 use databend_common_meta_control::args::TransferLeaderArgs;
@@ -255,6 +256,26 @@ impl App {
         Ok(())
     }
 
+    async fn get_metrics(&self, args: &MetricsArgs) -> anyhow::Result<()> {
+        let lua_script = format!(
+            r#"
+local admin_client = metactl.new_admin_client("{}")
+local metrics, err = admin_client:metrics()
+if err then
+    return nil, err
+end
+print(metrics)
+return metrics, nil
+"#,
+            args.admin_api_address
+        );
+
+        match lua_support::run_lua_script_with_result(&lua_script).await? {
+            Ok(_result) => Ok(()),
+            Err(error_msg) => Err(anyhow::anyhow!("Failed to get metrics: {}", error_msg)),
+        }
+    }
+
     fn new_grpc_client(&self, addresses: Vec<String>) -> Result<Arc<ClientHandle>, CreationError> {
         lua_support::new_grpc_client(addresses)
     }
@@ -274,6 +295,7 @@ enum CtlCommand {
     Upsert(UpsertArgs),
     Get(GetArgs),
     Lua(LuaArgs),
+    Metrics(MetricsArgs),
 }
 
 /// Usage:
@@ -348,6 +370,9 @@ async fn main() -> anyhow::Result<()> {
             CtlCommand::Lua(args) => {
                 app.run_lua(args).await?;
             }
+            CtlCommand::Metrics(args) => {
+                app.get_metrics(args).await?;
+            }
         },
         // for backward compatibility
         None => {

src/meta/control/src/admin.rs

@@ -15,6 +15,7 @@
 use databend_meta::api::http::v1::features::FeatureResponse;
 use reqwest::Client;
 use serde::Deserialize;
+use serde::Serialize;
 
 pub struct MetaAdminClient {
     client: Client,
@@ -135,14 +136,31 @@ impl MetaAdminClient {
             Err(anyhow::anyhow!("status code: {}, msg: {}", status, msg))
         }
     }
+
+    pub async fn get_metrics(&self) -> anyhow::Result<String> {
+        let resp = self
+            .client
+            .get(format!("{}/v1/metrics", self.endpoint))
+            .send()
+            .await?;
+        let status = resp.status();
+        if status.is_success() {
+            let result = resp.text().await?;
+            Ok(result)
+        } else {
+            let data = resp.bytes().await?;
+            let msg = String::from_utf8_lossy(&data);
+            Err(anyhow::anyhow!("status code: {}, msg: {}", status, msg))
+        }
+    }
 }
 
-#[derive(Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct AdminStatusResponse {
     pub name: String,
 }
 
-#[derive(Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct AdminTransferLeaderResponse {
     pub from: u64,
     pub to: u64,

src/meta/control/src/args.rs

@@ -270,3 +270,9 @@ pub struct LuaArgs {
     #[clap(long)]
     pub file: Option<String>,
 }
+
+#[derive(Debug, Clone, Deserialize, Args)]
+pub struct MetricsArgs {
+    #[clap(long, default_value = "127.0.0.1:28002")]
+    pub admin_api_address: String,
+}

src/meta/control/src/lua_support.rs

@@ -29,6 +29,8 @@ use mlua::UserDataMethods;
 use mlua::Value;
 use tokio::time;
 
+use crate::admin::MetaAdminClient;
+
 const LUA_UTIL: &str = include_str!("../lua_util.lua");
 
 pub struct LuaGrpcClient {
@@ -69,6 +71,77 @@ impl UserData for LuaGrpcClient {
     }
 }
 
+pub struct LuaAdminClient {
+    client: MetaAdminClient,
+}
+
+impl LuaAdminClient {
+    pub fn new(client: MetaAdminClient) -> Self {
+        Self { client }
+    }
+}
+
+impl UserData for LuaAdminClient {
+    fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
+        methods.add_async_method("metrics", |_lua, this, ()| async move {
+            match this.client.get_metrics().await {
+                Ok(metrics) => Ok((Some(metrics), None::<String>)),
+                Err(e) => Ok((None::<String>, Some(format!("Admin API error: {}", e)))),
+            }
+        });
+
+        methods.add_async_method("status", |lua, this, ()| async move {
+            match this.client.status().await {
+                Ok(result) => match lua.to_value(&result) {
+                    Ok(lua_value) => Ok((Some(lua_value), None::<String>)),
+                    Err(e) => Ok((None::<Value>, Some(format!("Lua conversion error: {}", e)))),
+                },
+                Err(e) => Ok((None::<Value>, Some(format!("Admin API error: {}", e)))),
+            }
+        });
+
+        methods.add_async_method("transfer_leader", |lua, this, to: Option<u64>| async move {
+            match this.client.transfer_leader(to).await {
+                Ok(result) => match lua.to_value(&result) {
+                    Ok(lua_value) => Ok((Some(lua_value), None::<String>)),
+                    Err(e) => Ok((None::<Value>, Some(format!("Lua conversion error: {}", e)))),
+                },
+                Err(e) => Ok((None::<Value>, Some(format!("Admin API error: {}", e)))),
+            }
+        });
+
+        methods.add_async_method("trigger_snapshot", |_lua, this, ()| async move {
+            match this.client.trigger_snapshot().await {
+                Ok(_) => Ok((Some(true), None::<String>)),
+                Err(e) => Ok((None::<bool>, Some(format!("Admin API error: {}", e)))),
+            }
+        });
+
+        methods.add_async_method("list_features", |lua, this, ()| async move {
+            match this.client.list_features().await {
+                Ok(result) => match lua.to_value(&result) {
+                    Ok(lua_value) => Ok((Some(lua_value), None::<String>)),
+                    Err(e) => Ok((None::<Value>, Some(format!("Lua conversion error: {}", e)))),
+                },
+                Err(e) => Ok((None::<Value>, Some(format!("Admin API error: {}", e)))),
+            }
+        });
+
+        methods.add_async_method(
+            "set_feature",
+            |lua, this, (feature, enable): (String, bool)| async move {
+                match this.client.set_feature(&feature, enable).await {
+                    Ok(result) => match lua.to_value(&result) {
+                        Ok(lua_value) => Ok((Some(lua_value), None::<String>)),
+                        Err(e) => Ok((None::<Value>, Some(format!("Lua conversion error: {}", e)))),
+                    },
+                    Err(e) => Ok((None::<Value>, Some(format!("Admin API error: {}", e)))),
+                }
+            },
+        );
+    }
+}
+
 pub struct LuaTask {
     handle: Rc<RefCell<Option<tokio::task::JoinHandle<mlua::Value>>>>,
 }
@@ -121,6 +194,18 @@ pub fn setup_lua_environment(lua: &Lua) -> anyhow::Result<()> {
         .set("new_grpc_client", new_grpc_client)
         .map_err(|e| anyhow::anyhow!("Failed to register new_grpc_client: {}", e))?;
 
+    // Register new_admin_client function
+    let new_admin_client = lua
+        .create_function(|_lua, address: String| {
+            let client = MetaAdminClient::new(&address);
+            Ok(LuaAdminClient::new(client))
+        })
+        .map_err(|e| anyhow::anyhow!("Failed to create new_admin_client function: {}", e))?;
+
+    metactl_table
+        .set("new_admin_client", new_admin_client)
+        .map_err(|e| anyhow::anyhow!("Failed to register new_admin_client: {}", e))?;
+
     // Export NULL constant to metactl namespace
     metactl_table
         .set("NULL", Value::NULL)
@@ -190,3 +275,69 @@ pub fn new_grpc_client(addresses: Vec<String>) -> Result<Arc<ClientHandle>, Crea
         None,
     )
 }
+
+pub fn new_admin_client(addr: &str) -> MetaAdminClient {
+    MetaAdminClient::new(addr)
+}
+
+pub async fn run_lua_script(script: &str) -> anyhow::Result<()> {
+    let lua = Lua::new();
+
+    setup_lua_environment(&lua)?;
+
+    #[allow(clippy::disallowed_types)]
+    let local = tokio::task::LocalSet::new();
+    let res = local.run_until(lua.load(script).exec_async()).await;
+
+    if let Err(e) = res {
+        return Err(anyhow::anyhow!("Lua execution error: {}", e));
+    }
+    Ok(())
+}
+
+pub async fn run_lua_script_with_result(
+    script: &str,
+) -> anyhow::Result<Result<Option<String>, String>> {
+    let lua = Lua::new();
+
+    setup_lua_environment(&lua)?;
+
+    #[allow(clippy::disallowed_types)]
+    let local = tokio::task::LocalSet::new();
+    let res = local
+        .run_until(lua.load(script).eval_async::<mlua::MultiValue>())
+        .await;
+
+    match res {
+        Ok(values) => {
+            let mut iter = values.iter();
+            let first = iter.next();
+            let second = iter.next();
+
+            match (first, second) {
+                // (result, nil) - success with result
+                (Some(Value::String(s)), Some(Value::Nil)) => match s.to_str() {
+                    Ok(str_val) => Ok(Ok(Some(str_val.to_string()))),
+                    Err(_) => Ok(Err("String conversion error".to_string())),
+                },
+                // (nil, nil) - success with no result
+                (Some(Value::Nil), Some(Value::Nil)) => Ok(Ok(None)),
+                // (nil, error) - error case
+                (Some(Value::Nil), Some(Value::String(err))) => match err.to_str() {
+                    Ok(err_str) => Ok(Err(err_str.to_string())),
+                    Err(_) => Ok(Err("Error string conversion failed".to_string())),
+                },
+                // Single return value - treat as result
+                (Some(Value::Nil), None) => Ok(Ok(None)),
+                (Some(Value::String(s)), None) => match s.to_str() {
+                    Ok(str_val) => Ok(Ok(Some(str_val.to_string()))),
+                    Err(_) => Ok(Err("String conversion error".to_string())),
+                },
+                // Other combinations - treat first value as error if second is missing
+                (Some(other), None) => Ok(Err(format!("{:?}", other))),
+                _ => Ok(Ok(None)),
+            }
+        }
+        Err(e) => Err(anyhow::anyhow!("Lua execution error: {}", e)),
+    }
+}