Lua ❤ Java：OSGi 环境中的嵌入式脚本

Lua 是一种轻量级、高效、可嵌入的脚本语言，它具有简单的语法和强大的扩展性。Lua 的设计目标是作为一种扩展语言来嵌入到其他应用程序中，以提供灵活的脚本能力。它的特点可以归纳到如下几点：

  • 简洁和灵活的语法：Lua 的语法非常简洁和易于学习，它采用了类似于 Pascal 的语法风格，使用关键字和符号来表示不同的语法结构。这使得 Lua 代码易于编写和阅读。同时，Lua 还支持面向过程和函数式编程风格，可以根据需要进行灵活的编程。

  • 轻量级和高效：Lua 的设计非常注重轻量级和高效性。它的核心库非常小巧，只包含了一些基本的数据结构和操作，这使得 Lua 解释器的内存占用和启动时间都非常低。同时，Lua 的执行速度也非常快，这使得它在嵌入式系统和游戏开发等领域得到广泛应用。

  • 嵌入性：Lua 的设计初衷就是作为一种嵌入式脚本语言，它可以轻松地嵌入到其他应用程序中。通过 Lua 的 C API，开发者可以将 Lua 解释器嵌入到自己的应用程序中，并通过调用 Lua 函数和访问 Lua 变量来实现脚本扩展能力。这种可嵌入性使得 Lua 成为许多应用程序的脚本语言选择。

  • 扩展性：Lua 提供了丰富的扩展机制，开发者可以通过编写 C 代码来扩展 Lua 的功能。Lua 的扩展机制包括通过 C API 添加新的原生函数、创建新的 Lua 模块、修改 Lua 解释器的行为等。这使得开发者可以根据自己的需求来扩展 Lua，使其适应不同的应用场景。

这些特点是基于 ANSI C 开发的 Lua 所具有的。为了和 JVM 生态整合，luaj 项目则提供了基于 Lua 语法的编译器和工具集，能够实现和 JVM 环境的互操作。得益于 Lua table 数据结构极强的正交性，luaj 生成的字节码短小高效，编译速度快且运行效率高，整个 luaj jar 包才不到 300kb，作为对比，clojure jar 包 ~4Mb。

luaj 的 Github 项目参见此处，README.md 中详细介绍了其用法、Java 侧的数据类型 LuaValue，多入参和返回值 Varargs 的处理方法，标准库的实现等。其支持 JSR223，但也提供了自己的 API：

Globals globals = JsePlatform.standardGlobals();
LuaValue sc = globals.loadfile("port_status_check.lua");
LuaValue res = sc.call();
System.out.println(res);

虽然可以为 luaj 提供模块，以便直接 require "some_java_module" 引用和使用，如下所示：

public class hyperbolic extends TwoArgFunction {
	public hyperbolic() {}
	public LuaValue call(LuaValue modname, LuaValue env) {
		LuaValue library = tableOf();
		library.set( "sinh", new sinh() );
		library.set( "cosh", new cosh() );
		env.set( "hyperbolic", library );
		return library;
	}
	static class sinh extends OneArgFunction {
		public LuaValue call(LuaValue x) {
			return LuaValue.valueOf(Math.sinh(x.checkdouble()));
		}
	}
	static class cosh extends OneArgFunction {
		public LuaValue call(LuaValue x) {
			return LuaValue.valueOf(Math.cosh(x.checkdouble()));
		}
	}
}

require 'hyperbolic'
print('sinh',  hyperbolic.sinh)
print('sinh(1.0)',  hyperbolic.sinh(1.0))

但更简单的方法是直接调用 Java 类，创建实例，调用静态或实例方法，luaj 项目中提供了一个 Swing App 展示了互操作。

u = luajava.bindClass('com.abc.LuaUtils')
print(u:ssh('172.20.1.123','admin','pass',true,false,{'show running-config'}))

t = luajava.bindClass('java.time.LocalDateTime') 
print(t:now():toString())

在 OSGi 环境中，由于每个 Bundle 都具有独立的类加载器，因此这种 Java 互操作很可能加载不到目标类 —— luaj 使用系统默认的类加载器，为此可重写 luaj 类加载的逻辑，并提供我们自己的 Globals：

public static Globals adaptOSGiGlobals() {
    Globals globals = new Globals();
    globals.load(new JseBaseLib());
    globals.load(new PackageLib());
    globals.load(new Bit32Lib());
    globals.load(new TableLib());
    globals.load(new StringLib());
    globals.load(new CoroutineLib());
    globals.load(new JseMathLib());
    globals.load(new JseIoLib());
    globals.load(new JseOsLib());
    globals.load(new OsgiBundleLib());
    LoadState.install(globals);
    LuaC.install(globals);
    return globals;
}

public static class OsgiBundleLib extends LuajavaLib {
    @Override
    protected Class classForName(String name) {
        ClassLoader classLoader = SomeClassLoadInThisBundle.class.getClassLoader();
        try {
            Class clazz = Class.forName(name, true, classLoader);
            return clazz;
        } catch (ClassNotFoundException e) {
            log.error("class not found", e);
            return Object.class;
        }
    }
}

//usage:
Globals globals = adaptOSGiGlobals();
LuaValue scriptFunc = globals.load(scriptContent);
scriptFunc.call();

下面是和一个庞大的 OSGi 工程集成的 Lua 函数管理器以及动态实验游乐场：

注意，实际接受不受信任脚本时，可能需要 SandBox 特性，限制可访问的标准库、Java 类库、编译和 Debug 能力，甚至限制脚本执行的指令数，luaj 在这方面充分发挥了 lua 的嵌入灵活性，参见文档，下面是一个简单的示例：

public class SampleSandboxed {
	static Globals server_globals;
	
	public static void main(String[] args) {
        // for script compile
		server_globals = new Globals();
		server_globals.load(new JseBaseLib());
		server_globals.load(new PackageLib());
		server_globals.load(new JseStringLib());
		server_globals.load(new JseMathLib());
		LoadState.install(server_globals);
		LuaC.install(server_globals);

        // make string safe
		LuaString.s_metatable = new ReadOnlyLuaTable(LuaString.s_metatable);

		runScriptInSandbox( "return 'foo'" );
		runScriptInSandbox( "return ('abc'):len()" );
		runScriptInSandbox( "return getmetatable('abc')" );
		runScriptInSandbox( "return getmetatable('abc').len" );
		runScriptInSandbox( "return getmetatable('abc').__index" );
        
        runScriptInSandbox( "return setmetatable('abc', {})" );
		runScriptInSandbox( "getmetatable('abc').len = function() end" );
		runScriptInSandbox( "getmetatable('abc').__index = {}" );
		runScriptInSandbox( "getmetatable('abc').__index.x = 1" );
		runScriptInSandbox( "while true do print('loop') end" );
		
        // custom: allows booleans to be added to numbers
		runScriptInSandbox( "return 5 + 6, 5 + true, false + 6" );
		LuaBoolean.s_metatable = new ReadOnlyLuaTable(LuaValue.tableOf(new LuaValue[] {
				LuaValue.ADD, new TwoArgFunction() {
					public LuaValue call(LuaValue x, LuaValue y) {
						return LuaValue.valueOf(
								(x == TRUE ? 1.0 : x.todouble()) +
								(y == TRUE ? 1.0 : y.todouble()) );
					}
				},
		}));
		runScriptInSandbox( "return 5 + 6, 5 + true, false + 6" );
	}
	
    // Run a script in a lua thread and limit it to a certain number
	// of instructions by setting a hook function.
	// Give each script its own copy of globals, but leave out libraries
	// that contain functions that can be abused.
	static void runScriptInSandbox(String script) {
		Globals user_globals = new Globals();
		user_globals.load(new JseBaseLib());
		user_globals.load(new PackageLib());
		user_globals.load(new Bit32Lib());
		user_globals.load(new TableLib());
		user_globals.load(new JseStringLib());
		user_globals.load(new JseMathLib());
        // not allow those libs:
        // user_globals.load(new LuajavaLib());
        // user_globals.load(new CoroutineLib());
        // user_globals.load(new JseIoLib());
		// user_globals.load(new JseOsLib());
        // LoadState.install(user_globals);
		// LuaC.install(user_globals);

        // not abllow use debug hook
		user_globals.load(new DebugLib());
		LuaValue sethook = user_globals.get("debug").get("sethook");
		user_globals.set("debug", LuaValue.NIL);

        // use server_globals compile script, and run in user_gloabls
        // call in luaThread with limit instruction count
		LuaValue chunk = server_globals.load(script, "main", user_globals);
		LuaThread thread = new LuaThread(user_globals, chunk);

		LuaValue hookfunc = new ZeroArgFunction() {
			public LuaValue call() {
				throw new Error("Script overran resource limits.");
			}
		};
		final int instruction_count = 20;
		sethook.invoke(LuaValue.varargsOf(new LuaValue[] { thread, hookfunc,
						LuaValue.EMPTYSTRING, LuaValue.valueOf(instruction_count) }));

		Varargs result = thread.resume(LuaValue.NIL);
		System.out.println("[["+script+"]] -> "+result);
	}

	static class ReadOnlyLuaTable extends LuaTable {
		public ReadOnlyLuaTable(LuaValue table) {
			presize(table.length(), 0);
			for (Varargs n = table.next(LuaValue.NIL); !n.arg1().isnil(); n = table
					.next(n.arg1())) {
				LuaValue key = n.arg1();
				LuaValue value = n.arg(2);
				super.rawset(key, value.istable() ? new ReadOnlyLuaTable(value) : value);
			}
		}
		public LuaValue setmetatable(LuaValue metatable) { return error("table is read-only"); }
		public void set(int key, LuaValue value) { error("table is read-only"); }
		public void rawset(int key, LuaValue value) { error("table is read-only"); }
		public void rawset(LuaValue key, LuaValue value) { error("table is read-only"); }
		public LuaValue remove(int pos) { return error("table is read-only"); }
	}
}

Happy hacking!