Hive 浅析 - 技术栈

Hive是一个简单的LUA沙盒，除了基本的LUA解释器的功能以外，还提供了诸如热加载等功能。了解HIVE的工作原理有利于了解Lua虚拟机的底层实现机理。本文从是什么-怎么用-为什么三个维度介绍HIVE。

Hive

Hive是什么

hive是一个简单的LUA应用框架,目前基于LUA 5.3.4。

主要提供了文件沙盒,文件热加载以及一些基础的服务程序底层支持.

HIVE源码：hive - master - gems / hive-framework - 工蜂内网版 (woa.com)

Hive的使用

编译

编译luna

 # at the hive-framework root directory
 cd luna && make
 cp luan.so ../hive/

编译hive

 # at the hive-framework root directory
 cd hive && make

运行

作为启动器的Hive

Hive本身只提供基础的热加载功能，并没有太多的功能。

你可以把Hive看作是一个简单的lua启动器，正如你使用lua file_name.lua一样，你也可以使用如下的命令行启动你的lua代码------

 # make sure the lua binary is under your PATH
 hive file_name.lua
 # just like lua file_name.lua!

命令行参数

你也可以传递一些命令行参数进去，这些命令行参数会被打包放进一个表里，然后传递给你的脚本文件。

你可以使用hive.args在file_name.lua中来获取这些参数。

 # ok,you can obtain
 hive file_name.lua arg1 arg2 arg3

例如在你自己的业务代码里，你可以写这样的代码：

 -- print the args
 -- test.lua
 for k,v in ipairs(hive.args) do
     print(string.format('%d:%s\n',k,v))
 end

保存为test.lua，然后在命令行中使用：

 hive test.lua arg1 arg2 arg3
 1:arg1
 2:arg2
 3:arg3

业务代码

被Hive启动的Lua的业务代码中，至少应该提供一个hive.run的实现------

 --test.lua
 hive.run = function()
     print('Hello world')

Hive.run会被反复执行，效果如下所示------

 hive test.lua
 hello world
 hello world
 hello world
 hello world
 hello world
 hello world
 hello world
 hello world
 hello world
 hello world
 hello world
 hello world
 ...

除此以外，Hive还提供了一些feature，这些feature可以在Lua的环境中用，即，在你自己的业务代码中使用。

Hive的特性

本章从使用的角度介绍Hive的特性，如果需要详细了解实现原理，欢迎参阅源码剖析和Hive接口手册章节。

文件热加载

所谓文件热加载是指但凡使用import函数引入的文件（包括入口的文件，例如上面的test.lua）都会被Hive检测是否有更新。当Hive检测到文件时间戳改变以后，会自动重新进行读取。

请观察下面的示例------

 -- test.lua
 l = import('lobby.lua')
 hive.run = function() 
     print('in test.lua')
     print('the imported l is:',l.str)
     hive.sleep_ms(2000);
 end

其中lobby.lua是另外一个lua程序

 -- lobby.lua
 str = 'Yes, I am a lobby'

输入hive test.lua运行

 hive test.lua
 the imported l is:  Yes, I am a lobby
 in test.lua
 
 the imported l is:  Yes, I am a lobby
 in test.lua
 
 the imported l is:  Yes, I am a lobby
 in test.lua
 ...

在另外一个终端打开并修改lobby.lua文件，保存

 --lobby.lua
 str = 'No!I am not a lobby!'

原终端中的输出发生改变

 the imported l is:  No, I am not a lobby!
 in test.lua
 the imported l is:  No, I am not a lobby!
 in test.lua
 the imported l is:  No, I am not a lobby!

沙盒环境

使用import导入的文件，Hive会为之创建了一个沙盒环境这使得各个文件中的变量名不会冲突。

下面的例子说明了import函数的行为------

 -- lobby.lua
 function m_add(a,b)
     return a + b
 end 
 
 function m_sub(a,b)
     return a - b
 end
 
 return 1123

在test.lua中引入该文件：

 l = import('lobby.lua')
 print(type(l))
 
 for k,v in pairs(l) do
     print(k,':',v)
 end
 
 -- for k,v in pairs(_G) do
 --     print(k,':',v)
 -- end
 
 print(l.m_add(1,2))
 print(l.m_sub(1000,2))

得到结果如下所示：可见，之前的定义都放在一个表中，且返回值被忽略了。

 table
 m_add   :   function: 0x228faa0
 m_sub   :   function: 0x229be80
 3
 998

如果使用require，则有所不同

 > require('lobby')
 1123
 > v = require('lobby')
 > m_add
 function: 0xa5c340
 > m_sub
 function: 0xa5c010

有何不同？

如果使用自带的require函数，这里会有两个区别。

你可以获取到require的返回值

全局的作用域被影响，即这里的_G

本章节不涉及原理部分的阐述，如有需要，请参阅Hive接口手册。

源码剖析

热加载实现原理

这个主要和Hive::run代码有关：

 ...
 if(!lua_call_object_function(L, &err, this, "import", std::tie(), filename))
         die(err);
 
     while (lua_get_object_function(L, this, "run")) {
         if(!lua_call_function(L, &err, 0, 0))
             die(err);
 
         int64_t now = ::get_time_ms();
         if (m_reload_time > 0 && now > last_check + m_reload_time) {
             lua_call_object_function(L, nullptr, this, "reload");
             last_check = now;
         }
         lua_settop(L, top);
     }
 
     lua_close(L);
 }

首先将用户的代码（#2），使用import函数进行加载。如果没有错，则继续进入一个循环。这个import函数，是Hive提前定义好的一个函数。后面还会介绍。
循环（#5）不断地从Lua环境中获取到Run函数的地址，然后去调用，如果获取不到函数地址，则循环直接中止，执行完毕。
否则则直接进行调用获取到的Run函数。
执行完毕以后，检查import的文件是否有更新，如果有，则调用reload函数重新进行加载。

因此，我们可以说，如果业务代码中没有定义RUN函数，则系统会直接返回。

沙盒环境实现原理

所谓沙盒环境，其实就是不管怎么加载代码，都用一个table给装起来，而不污染全局的环境（详情可见上面的特性章节）。

沙盒的实现原理主要和Hive提前定义的load函数有关。

 static const char* g_sandbox = u8R"__(
 hive.files = {};
 hive.meta = {__index=function(t, k) return _G[k]; end};
 hive.print = function(...) end; --do nothing
 
 local get_filenode = function(filename)
     local rootpath = os.getenv("LUA_ROOT");
     local withroot = rootpath and hive.get_full_path(rootpath).."/"..filename or filename;
     local fullpath = hive.get_full_path(withroot) or withroot;
 
     local node = hive.files[fullpath];
     if node then
         return node;
     end
 
     local env = {};
     setmetatable(env, hive.meta);
     node = {env=env, fullpath=fullpath, filename=filename};
     hive.files[fullpath] = node;
     return node;
 end
 
 function import(filename)
     local node = get_filenode(filename);
     if not node.time then
         node.time = hive.get_file_time(node.fullpath);
         try_load(node);
     end
     return node.env;
 end
 
 hive.reload = function()
     local now = os.time();
     local update = true;
     while update do
         update = false;
         for path, node in pairs(hive.files) do
             local filetime = hive.get_file_time(node.fullpath);
             if filetime ~= node.time and filetime ~= 0 and math.abs(now - filetime) > 1 then
                 node.time = filetime;
                 update = true;
                 try_load(node);
             end
         end
     end
 end
 )__";

上面的定义，是Hive在加载用户的文件之前会调用的。

主要关注import函数------

函数首先执行get_filenode函数。该函数首先到全局的hive.files表中进行查找，如果找到了，则直接返回该node，这里的node，其实就是一个表，一个虚拟的沙箱。否则就新建一张表，这张表的元表是固定的hive.meta，即如果在该表中无法找到，则到_G中进行查找。这里的_G事实上就是导入的文件的环境。
如果是新导入的文件，则对其进行加载即可，记录下导入的时间（方便后面检查是否有更新）

Hive接口手册

除了前面章节中所提到的内容，Hive其实还有一些其他的接口暴露给了用户。使用hive.xxx即可访问。

API	作用
get_version	返回版本号
get_file_time	获取文件的修改时间
get_full_path	获取文件的绝对路径
get_time_ms/get_time_ns	获取当前的时间(Epoch格式)
sleep_ms	睡眠
daemon	服务作为后台运行