feat(metactl): add lua subcommand with file and stdin support (#18437)

Add new `lua` subcommand to databend-metactl that executes Lua scripts
from either files or stdin input. This enables scripting capabilities
for meta service operations and automation.

- Add mlua dependency with Lua 5.4 and vendored features
- Create comprehensive lua test suite with file and stdin tests
- Enhance test runner with selective test execution support

Usage examples:
```
databend-metactl lua --file script.lua
echo 'print("hello")' | databend-metactl lua
```

`databend-metactl lua` will be used for complicated benchmark scripting.

Author: drmingdrmer

Cargo.lock

@@ -387,6 +387,7 @@ match-template = "0.0.1"
 md-5 = "0.10.5"
 memchr = { version = "2", default-features = false }
 micromarshal = "0.7.0"
+mlua = { version = "0.11", features = ["lua54", "vendored"] }
 mockall = "0.11.2"
 mysql_async = { version = "0.34", default-features = false, features = ["native-tls-tls"] }
 naive-cityhash = "0.2.0"

Cargo.toml

@@ -47,6 +47,7 @@ display-more = { workspace = true }
 fastrace = { workspace = true }
 futures = { workspace = true }
 log = { workspace = true }
+mlua = { workspace = true }
 rand = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

src/meta/binaries/Cargo.toml

@@ -15,6 +15,8 @@
 #![allow(clippy::uninlined_format_args)]
 
 use std::collections::BTreeMap;
+use std::io::Read;
+use std::io::{self};
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -32,6 +34,7 @@ use databend_common_meta_control::args::GetArgs;
 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::SetFeature;
 use databend_common_meta_control::args::StatusArgs;
 use databend_common_meta_control::args::TransferLeaderArgs;
@@ -50,6 +53,7 @@ use databend_common_tracing::FileConfig;
 use databend_meta::version::METASRV_COMMIT_VERSION;
 use display_more::DisplayOptionExt;
 use futures::stream::TryStreamExt;
+use mlua::Lua;
 use serde::Deserialize;
 
 #[derive(Debug, Deserialize, Parser)]
@@ -226,6 +230,24 @@ impl App {
         Ok(())
     }
 
+    async fn run_lua(&self, args: &LuaArgs) -> anyhow::Result<()> {
+        let lua = Lua::new();
+
+        let script = match &args.file {
+            Some(path) => std::fs::read_to_string(path)?,
+            None => {
+                let mut buffer = String::new();
+                io::stdin().read_to_string(&mut buffer)?;
+                buffer
+            }
+        };
+
+        if let Err(e) = lua.load(&script).exec() {
+            return Err(anyhow::anyhow!("Lua execution error: {}", e));
+        }
+        Ok(())
+    }
+
     fn new_grpc_client(&self, addresses: Vec<String>) -> Result<Arc<ClientHandle>, CreationError> {
         eprintln!(
             "Using gRPC API address: {}",
@@ -255,6 +277,7 @@ enum CtlCommand {
     Watch(WatchArgs),
     Upsert(UpsertArgs),
     Get(GetArgs),
+    Lua(LuaArgs),
 }
 
 /// Usage:
@@ -326,6 +349,9 @@ async fn main() -> anyhow::Result<()> {
             CtlCommand::Get(args) => {
                 app.get(args).await?;
             }
+            CtlCommand::Lua(args) => {
+                app.run_lua(args).await?;
+            }
         },
         // for backward compatibility
         None => {

src/meta/binaries/metactl/main.rs

@@ -263,3 +263,10 @@ pub struct TriggerSnapshotArgs {
     #[clap(long, default_value = "127.0.0.1:28101")]
     pub admin_api_address: String,
 }
+
+#[derive(Debug, Clone, Deserialize, Args)]
+pub struct LuaArgs {
+    /// Path to the Lua script file. If not provided, script is read from stdin
+    #[clap(long)]
+    pub file: Option<String>,
+}

src/meta/control/src/args.rs

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+
+import subprocess
+import tempfile
+import os
+from metactl_utils import metactl_bin
+from utils import print_title
+
+
+def test_lua_file():
+    """Test lua subcommand with file input."""
+    print_title("Test lua subcommand with file")
+
+    # Create a temporary Lua script
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.lua', delete=False) as f:
+        f.write('print(2 + 3)\n')
+        lua_file = f.name
+
+    print("file name:", lua_file)
+    with open(lua_file, 'r') as ff:
+        print("file content:", ff.read())
+
+    # Run metactl lua with file
+    result = subprocess.run([
+        metactl_bin, "lua",
+        "--file", lua_file
+    ], capture_output=True, text=True, check=True)
+
+    output = result.stdout.strip()
+    assert "5" == output
+    print("✓ Lua file execution test passed")
+
+
+
+def test_lua_stdin():
+    """Test lua subcommand with stdin input."""
+    print_title("Test lua subcommand with stdin")
+
+    lua_script = 'print("Hello from stdin!")\nprint(5 * 6)\n'
+
+    # Run metactl lua with stdin
+    result = subprocess.run([
+        metactl_bin, "lua"
+    ], input=lua_script, capture_output=True, text=True, check=True)
+
+    output = result.stdout.strip()
+    assert "Hello from stdin!" in output
+    assert "30" in output
+    print("✓ Lua stdin execution test passed")
+
+
+def main():
+    """Main function to run all lua tests."""
+    test_lua_file()
+    test_lua_stdin()
+
+
+if __name__ == "__main__":
+    main()

tests/metactl/subcommands/cmd_lua.py

@@ -7,10 +7,13 @@
 
 Usage:
     python tests/metactl/test_all_subcommands.py           # Run all tests
+    python tests/metactl/test_all_subcommands.py lua       # Run only lua test
+    python tests/metactl/test_all_subcommands.py status get # Run status and get tests
 """
 
 import sys
 import time
+import argparse
 from utils import print_title, kill_databend_meta
 import shutil
 
@@ -24,6 +27,7 @@
 from subcommands import cmd_export_from_raft_dir
 from subcommands import cmd_import
 from subcommands import cmd_transfer_leader
+from subcommands import cmd_lua
 
 
 def cleanup_environment():
@@ -36,17 +40,17 @@ def cleanup_environment():
 
 def main():
     """Main test execution function."""
+    parser = argparse.ArgumentParser(description="Run metactl subcommand tests")
+    parser.add_argument("tests", nargs="*", help="Specific test names to run (default: all)")
+    args = parser.parse_args()
 
     print_title("Metactl Subcommand Test Suite")
 
     passed_tests = 0
     failed_tests = []
 
-    print("📋 Executing 9 test suites sequentially...")
-    print("=" * 60)
-
-    # Run each test directly
-    test_functions = [
+    # All available test functions
+    all_test_functions = [
         ("status", cmd_status.main),
         ("upsert", cmd_upsert.main),
         ("get", cmd_get.main),
@@ -56,8 +60,29 @@ def main():
         ("export_from_raft_dir", cmd_export_from_raft_dir.main),
         ("import", cmd_import.main),
         ("transfer_leader", cmd_transfer_leader.main),
+        ("lua", cmd_lua.main),
     ]
 
+    # Filter tests based on command line arguments
+    if args.tests:
+        # Create a mapping for easier lookup
+        test_map = {name: func for name, func in all_test_functions}
+        test_functions = []
+
+        for test_name in args.tests:
+            if test_name in test_map:
+                test_functions.append((test_name, test_map[test_name]))
+            else:
+                available_tests = ", ".join(test_map.keys())
+                print(f"❌ Unknown test '{test_name}'. Available tests: {available_tests}")
+                return 1
+    else:
+        test_functions = all_test_functions
+
+    total_tests = len(test_functions)
+    print(f"📋 Executing {total_tests} test suite{'s' if total_tests != 1 else ''} sequentially...")
+    print("=" * 60)
+
     for name, test_func in test_functions:
         cleanup_environment()
 
@@ -77,10 +102,10 @@ def main():
 
     # Print summary
     print_title("Test Suite Summary")
-    print(f"📊 Total test suites: 9")
+    print(f"📊 Total test suites: {total_tests}")
     print(f"✅ Passed: {passed_tests}")
     print(f"❌ Failed: {len(failed_tests)}")
-    print(f"📈 Success rate: {(passed_tests/9*100):.1f}%")
+    print(f"📈 Success rate: {(passed_tests/total_tests*100):.1f}%")
 
     if failed_tests:
         print(f"\n🚨 Failed test suites:")