refactor(metactl): extract Lua runtime setup to dedicated module (#18439)

Move Lua gRPC client functionality from main.rs to a new lua_support
module in databend-common-meta-control. This improves code organization
by separating Lua runtime concerns from the main binary logic.

Changes:
- Create src/meta/control/src/lua_support.rs with LuaGrpcClient and setup functions
- Update main.rs to use lua_support::setup_lua_environment()
- Add mlua and meta-kvapi dependencies to control library
- Remove duplicate Lua implementation code from main.rs

This refactoring makes the Lua functionality more maintainable and
reusable across the codebase while preserving all existing behavior.

Author: drmingdrmer

Cargo.lock

@@ -18,7 +18,6 @@ use std::collections::BTreeMap;
 use std::io::Read;
 use std::io::{self};
 use std::sync::Arc;
-use std::time::Duration;
 
 use clap::CommandFactory;
 use clap::Parser;
@@ -44,6 +43,7 @@ use databend_common_meta_control::args::WatchArgs;
 use databend_common_meta_control::export_from_disk;
 use databend_common_meta_control::export_from_grpc;
 use databend_common_meta_control::import;
+use databend_common_meta_control::lua_support;
 use databend_common_meta_kvapi::kvapi::KVApi;
 use databend_common_meta_types::protobuf::WatchRequest;
 use databend_common_meta_types::UpsertKV;
@@ -54,10 +54,6 @@ use databend_meta::version::METASRV_COMMIT_VERSION;
 use display_more::DisplayOptionExt;
 use futures::stream::TryStreamExt;
 use mlua::Lua;
-use mlua::LuaSerdeExt;
-use mlua::UserData;
-use mlua::UserDataMethods;
-use mlua::Value;
 use serde::Deserialize;
 
 #[derive(Debug, Deserialize, Parser)]
@@ -237,33 +233,8 @@ impl App {
     async fn run_lua(&self, args: &LuaArgs) -> anyhow::Result<()> {
         let lua = Lua::new();
 
-        // Register new_grpc_client function
-        let new_grpc_client = lua
-            .create_function(|_lua, address: String| {
-                let client = MetaGrpcClient::try_create(
-                    vec![address],
-                    "root",
-                    "xxx",
-                    Some(Duration::from_secs(2)),
-                    Some(Duration::from_secs(1)),
-                    None,
-                )
-                .map_err(|e| {
-                    mlua::Error::external(format!("Failed to create gRPC client: {}", e))
-                })?;
-
-                Ok(LuaGrpcClient::new(client))
-            })
-            .map_err(|e| anyhow::anyhow!("Failed to create new_grpc_client function: {}", e))?;
-
-        lua.globals()
-            .set("new_grpc_client", new_grpc_client)
-            .map_err(|e| anyhow::anyhow!("Failed to register new_grpc_client: {}", e))?;
-
-        // Export NULL constant to Lua environment
-        lua.globals()
-            .set("NULL", Value::NULL)
-            .map_err(|e| anyhow::anyhow!("Failed to register NULL constant: {}", e))?;
+        // Setup Lua environment with gRPC client support
+        lua_support::setup_lua_environment(&lua)?;
 
         let script = match &args.file {
             Some(path) => std::fs::read_to_string(path)?,
@@ -281,56 +252,7 @@ impl App {
     }
 
     fn new_grpc_client(&self, addresses: Vec<String>) -> Result<Arc<ClientHandle>, CreationError> {
-        eprintln!(
-            "Using gRPC API address: {}",
-            serde_json::to_string(&addresses).unwrap()
-        );
-        MetaGrpcClient::try_create(
-            addresses,
-            "root",
-            "xxx",
-            Some(Duration::from_secs(2)),
-            Some(Duration::from_secs(1)),
-            None,
-        )
-    }
-}
-
-struct LuaGrpcClient {
-    client: Arc<ClientHandle>,
-}
-
-impl LuaGrpcClient {
-    fn new(client: Arc<ClientHandle>) -> Self {
-        Self { client }
-    }
-}
-
-impl UserData for LuaGrpcClient {
-    fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
-        methods.add_async_method("get", |lua, this, key: String| async move {
-            match this.client.get_kv(&key).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!("gRPC error: {}", e)))),
-            }
-        });
-
-        methods.add_async_method(
-            "upsert",
-            |lua, this, (key, value): (String, String)| async move {
-                let upsert = UpsertKV::update(key, value.as_bytes());
-                match this.client.request(upsert).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!("gRPC error: {}", e)))),
-                }
-            },
-        );
+        lua_support::new_grpc_client(addresses)
     }
 }
 

src/meta/binaries/metactl/main.rs

@@ -11,6 +11,7 @@ edition = { workspace = true }
 
 [dependencies]
 databend-common-meta-client = { workspace = true }
+databend-common-meta-kvapi = { workspace = true }
 databend-common-meta-raft-store = { workspace = true }
 databend-common-meta-sled-store = { workspace = true }
 databend-common-meta-types = { workspace = true }
@@ -20,6 +21,7 @@ databend-meta = { workspace = true }
 anyhow = { workspace = true }
 clap = { workspace = true }
 futures = { workspace = true }
+mlua = { workspace = true }
 raft-log = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }

src/meta/control/Cargo.toml

@@ -20,5 +20,6 @@ pub mod export_from_disk;
 pub mod export_from_grpc;
 pub mod import;
 mod import_v004;
+pub mod lua_support;
 pub(crate) mod reading;
 mod upgrade;

src/meta/control/src/lib.rs

@@ -0,0 +1,110 @@
+// Copyright 2021 Datafuse Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::sync::Arc;
+use std::time::Duration;
+
+use databend_common_meta_client::errors::CreationError;
+use databend_common_meta_client::ClientHandle;
+use databend_common_meta_client::MetaGrpcClient;
+use databend_common_meta_kvapi::kvapi::KVApi;
+use databend_common_meta_types::UpsertKV;
+use mlua::Lua;
+use mlua::LuaSerdeExt;
+use mlua::UserData;
+use mlua::UserDataMethods;
+use mlua::Value;
+
+pub struct LuaGrpcClient {
+    client: Arc<ClientHandle>,
+}
+
+impl LuaGrpcClient {
+    pub fn new(client: Arc<ClientHandle>) -> Self {
+        Self { client }
+    }
+}
+
+impl UserData for LuaGrpcClient {
+    fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
+        methods.add_async_method("get", |lua, this, key: String| async move {
+            match this.client.get_kv(&key).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!("gRPC error: {}", e)))),
+            }
+        });
+
+        methods.add_async_method(
+            "upsert",
+            |lua, this, (key, value): (String, String)| async move {
+                let upsert = UpsertKV::update(key, value.as_bytes());
+                match this.client.request(upsert).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!("gRPC error: {}", e)))),
+                }
+            },
+        );
+    }
+}
+
+pub fn setup_lua_environment(lua: &Lua) -> anyhow::Result<()> {
+    // Register new_grpc_client function
+    let new_grpc_client = lua
+        .create_function(|_lua, address: String| {
+            let client = MetaGrpcClient::try_create(
+                vec![address],
+                "root",
+                "xxx",
+                Some(Duration::from_secs(2)),
+                Some(Duration::from_secs(1)),
+                None,
+            )
+            .map_err(|e| mlua::Error::external(format!("Failed to create gRPC client: {}", e)))?;
+
+            Ok(LuaGrpcClient::new(client))
+        })
+        .map_err(|e| anyhow::anyhow!("Failed to create new_grpc_client function: {}", e))?;
+
+    lua.globals()
+        .set("new_grpc_client", new_grpc_client)
+        .map_err(|e| anyhow::anyhow!("Failed to register new_grpc_client: {}", e))?;
+
+    // Export NULL constant to Lua environment
+    lua.globals()
+        .set("NULL", Value::NULL)
+        .map_err(|e| anyhow::anyhow!("Failed to register NULL constant: {}", e))?;
+
+    Ok(())
+}
+
+pub fn new_grpc_client(addresses: Vec<String>) -> Result<Arc<ClientHandle>, CreationError> {
+    eprintln!(
+        "Using gRPC API address: {}",
+        serde_json::to_string(&addresses).unwrap()
+    );
+    MetaGrpcClient::try_create(
+        addresses,
+        "root",
+        "xxx",
+        Some(Duration::from_secs(2)),
+        Some(Duration::from_secs(1)),
+        None,
+    )
+}