杰哥胡搞搞之关于类似nginx的mud反向代理的一些探讨

jarlyyn

这两天因为某些原因，捡起了我之前gmcp显示插件，看看能不能弄成mud版的nginx。记录一下。
nginx是一个在网络领域使用的十分广泛的反向代理软件，作用是在实际的运行程序(相当于mud服务)和访问者(相当于客户端)之间进行负责均衡，转发，缓存等功能的重要软件。

可以说是一般网络应用横向扩展的基础。

对于一般的HTTP请求来说，分为4个部分

• 请求头
• 请求正文
• 响应头
• 响应正文
  

这个可以在浏览器F12中查看。

具体来说，请求头和响应头是在正文开始前的一些原信息，在不影响正文的情况下可以在不同的中间件之间传播和维护，实现各种复杂功能。

正文就是服务器和用户之间交互的数据，在mud里相当于各种指令和文字显示。

jarlyyn

实现这样一个功能的意义。
总体来说，参考nginx，就可以知道这种服务的意义。

mud再为一个上古遗留物，可以说发展被单核卡的死死的。

有这么一个服务，可以把原本纹丝不动的100%限制挖出点缝隙来。可能要用本来200%甚至300%的cpu才能实现150%的性能。但总归超过100%了，不是吗？

具体能够实现的可能包括:

1.前后端分离。分担mud主服务器的渲染压力。mud服务器可以直接输出类似hpbrief或者gmcp的信息，由中间件渲染成用户能看到的界面。
2.数据缓存。典型的就是现在gmcp是实时更新数据的，那么只要在中间件把gmcp信息缓存了，那么用户hp或者score时，能直接从中间件缓存的数据中取再渲染，完全不经过mud主服务器
3.请求分流。最典型的就是top榜常客的news和list指令了。news指令上榜对我来说完全优点不可思议。直接中间件直接从cms或者数据里读九好了，压根不需要经过主服务器。用户输入指令 news 117,服务器接受后决定运行显示news 117，直接发一个news 117的gmcp(阅)，中间件接受到服务器返回的指令，从数据库中取得相应新闻，渲染后发送给用户，对服务器来说性能消耗不过相当于一个responser R:。当铺的list同理，只是查询完全没不要从主服务器走一波。
4.文字渲染格式话。和GBK不同，UTF8的显示调整对齐是非常慢的，某些时候也能带来性能瓶颈。有中间件可以把文本带上标记直接抛给中间件，由中间件处理
5.直通副本服务器。目前北侠的架构副本服务器还是要经过主服务器的，top cmd初期很多副本指令上榜就是这个原因。
6.实时监控。中间件可以在不耗费主服务器性能的情况下记录所有输入，传入各种日志服务器，甚至理论上可以管理实时连接，不经过主服务器实现snoop,可以做各种实时指令大屏显示监控。

最关键是，这种技术其实技术要求不高，但凡能做点基础客户端的肯定能做这个。解析ansi,处理指令，通过vm进行编程，本质这就是个跑在服务器端，以telnet接口为显示界面的mini客户端罢了。

jarlyyn

接下来是实现的肉戏。我们要做什么。
作为一个反向代理，第一部也是最重要的一步是认证，替换环境信息。

以nginx为例，nginx最基本的一个功能是
1.认证，最简单的就是在请求头里通过一个预定义指在内部使用的足够长的token认真。复杂点可以加入各种摘要算法。
2.替换ip。nginx一般在请求头里带一个X_Forward_FOR的请求头。一旦通过了认证，服务器就相信这个是用户的真实ip。

也可以说是这个架构的核心基础，实现mud连接的请求头。

一旦实现了请求头，各种功能都能实现，比如session,jwt这种对多副本服务器很好用的东西。

jarlyyn

调整Mud登陆流程。

为了这个我差不多把fluffos和我手头的mudlib读了几遍，终于把这个理顺了。

首先，fluffos这东西本质和客户端一样，有个主脚本入口。定义在config文件中，

比如我手头的mudlib是

1. master file : /adm/kernel/master
   

复制代码

这个具体由fluffos的src/comm.cc负责

用户请求连入后，会先在调用comm.cc里的new_conn_handler

1.     auto *user = new_user(port, fd, addr, addrlen);
   
2.     new_user_event_listener(base, user);
   
3. 
   
4.     if (user->connection_type == PORT_TYPE_TELNET) {
   
5.       user->telnet = net_telnet_init(user);
   
6.       send_initial_telnet_negotiations(user);
   
7.     }
   
8. 
   
9.     event_base_once(
   
10.         base, -1, EV_TIMEOUT,
    
11.         [](evutil_socket_t /*fd*/, short /*what*/, void *arg) {
    
12.           auto *user = reinterpret_cast(arg);
    
13.           on_user_logon(user);
    
14.         },
    
15.         (void *)user, nullptr);
    

复制代码

new_user是一个interactive_t对象，本质代表了一个连接
这代码就是初始化新连接，初始化telnet的一些协商，然后调用on_user_login方法，开始尝试登陆

on_user_logon的代码为

1. void on_user_logon(interactive_t *user) {
   
2.   set_command_giver(master_ob);
   
3.   master_ob->flags |= O_ONCE_INTERACTIVE;
   
4.   master_ob->interactive = user;
   
5. 
   
6.   /*
   
7.    * The user object has one extra reference. It is asserted that the
   
8.    * master_ob is loaded.  Save a pointer to the master ob incase it
   
9.    * changes during APPLY_CONNECT.  We want to free the reference on
   
10.    * the right copy of the object.
    
11.    */
    
12.   object_t *master, *ob;
    
13.   svalue_t *ret;
    
14. 
    
15.   master = master_ob;
    
16.   add_ref(master_ob, "new_user");
    
17.   push_number(user->local_port);
    
18.   set_eval(max_eval_cost);
    
19.   ret = safe_apply_master_ob(APPLY_CONNECT, 1);
    
20.   /* master_ob->interactive can be zero if the master object self
    
21.    destructed in the above (don't ask) */
    
22.   set_command_giver(nullptr);
    

复制代码

这个一眼看上去就和lua差不多……

里面其实有个重要的地方，就是master_ob->interactive = user;，连接所有权的转交。之前没接触过mudos,fluffos的文档又不全，这东西看代码卡了我很久……

代码很明显，压入一个数字参数 local port,调用 APPLY_CONNECT方法初始化。

这一段在我的mudlib里是这样的

1. object connect(int port)
   
2. {
   
3.         object login_ob;
   
4.         mixed err;
   
5. 
   
6.         err = catch(login_ob = new(LOGIN_OB));
   
7.         set_encoding("GBK");
   
8. 
   
9.         //if(port == GBK_PORT)
   
10.         //{
    
11.         //        login_ob->set_temp("GBK",1);
    
12.         //        set_encoding("GBK");
    
13.         //}
    
14.    
    
15.         if (err)
    
16.         {
    
17.                 write("现在有人正在修改使用者连线部份的程式，请待会再来。\n");
    
18.                 write(err);
    
19.                 destruct(this_object());
    
20.         }
    
21.         return login_ob;
    
22. }
    

复制代码

master.c作为入口负责接受新请求，然后初始化一个登陆对象抛会去。

登陆对象定义在include/globals.h里

1. #define LOGIN_OB        "/clone/user/login"
   

复制代码

指向了clone/user/login文件。


这是一个登陆对象，指的是登陆中的用户。很明显，初始化后，用户登陆前，这是我们需要接入的地方。


回到fluffos源代码，初始化后

1.   ob = ret->u.ob;
   
2.   ob->interactive = master_ob->interactive;
   
3.   ob->interactive->ob = ob;
   
4.   ob->flags |= O_ONCE_INTERACTIVE;
   
5.   /*
   
6.    * assume the existance of write_prompt and process_input in user.c
   
7.    * until proven wrong (after trying to call them).
   
8.    */
   
9.   ob->interactive->iflags |= (HAS_WRITE_PROMPT | HAS_PROCESS_INPUT);
   
10. 
    
11.   free_object(&master, "new_user");
    
12. 
    
13.   master_ob->flags &= ~O_ONCE_INTERACTIVE;
    
14.   master_ob->interactive = nullptr;
    
15.   add_ref(ob, "new_user");
    
16. 
    
17.   // start reverse DNS probing.
    
18.   query_name_by_addr(ob);
    
19. 
    
20.   set_command_giver(ob);
    
21. 
    
22.   set_prompt("> ");
    
23. 
    
24.   // Call logon() on the object.
    
25.   set_eval(max_eval_cost);
    
26.   ret = safe_apply(APPLY_LOGON, ob, 0, ORIGIN_DRIVER);
    
27.   if (ret == nullptr) {
    
28.     debug_message("new_conn_handler: logon() on object %s has failed, the user is disconnected.\n",
    
29.                   ob->obname);
    
30.     remove_interactive(ob, false);
    

复制代码

主对象把输入接口转交给登陆对象，一次交接，然后开始调用登陆对象logon函数

1. void logon()
   
2. {
   
3.         remove_call_out("time_out");
   
4.         call_out("time_out", LOGIN_TIMEOUT);
   
5. 
   
6.         if (interactive(this_object()))
   
7.         {
   
8.                 //log_file("static/logon", sprintf("%s %s\n", ctime(time()), query_ip_number(this_object())));
   
9.                 set_temp("ip_number", query_ip_number(this_object()));
   
10.         }
    
11. 
    
12.         LOGIN_D->logon(this_object());
    
13. }
    

复制代码

很明显，设置ip地址，然后调用登陆服务(根据登陆信息生成玩家对象，转移输入接口所有权，这里坑了我一天，我用登陆对象发gmcp怎么都发不出去，拉最新的fluffos编译再调整兼容性都不行)

我们要改的必然又是这里。目标找到，开始改。

jarlyyn

我们既然目标是nginx,那就从学nginx开始。

nginx是先和主机交互http请求头，知道明确的终止标志，再开始处理正文。

刚刚这段代码，明显调用LogonD是开始处理正文。

所以，我们开始定义 请求头 和 请求头结束的标志。

有个input_to的efun(内建api)很简单好用，就是把等待用户输出传给指定函数。

所以，我这里定义的是三个指令

• auth xxxxx 认证身份
• ipadress xxxxxx 试图指定ip地址
• finish 请求头结束
  

首先，我把logon函数改名，叫raw_logon

其次，写一个新的logon

1. void logon(){
   
2.                 input_to( "waiting", this_object(),1,this_object());
   
3. }

复制代码

指定了请求头处理函数"waiting"

1. void waiting(string message,object ob){
   
2.         if (strlen(message)>4 && message[0..4]=="Auth "){
   
3.                 if (proxy_auth(ob,message[5..<1])!=1){
   
4.                                 destruct(this_object());
   
5.                                 return;
   
6.                 }
   
7.         }
   
8.         else if(strlen(message)>9 && message[0..9]="IPAddress "){
   
9.                         proxy_set_ipaddress(ob,message[10..<1]);
   
10.         }else if (message=="Finish"){
    
11.                 if (proxy_authed(ob)!=1){
    
12.                                 destruct(this_object());
    
13.                                 return;
    
14.                 }
    
15.                 evaluate(bind((:raw_logon:),ob));
    
16.                 return;
    
17.         }
    
18.         input_to( "waiting",1,ob);
    

复制代码

很简单。

里面用来很多proxy开头的函数，那是我自定义的simul_efun,就是脚本框架接口，由mudlib(相当于机器人)提供，用LPC写的。对应的efun，由driver(相当于客户端)提供，由C写的，

1. string ProxyToken="12345";
   
2. 
   
3. string query_ip_proxy_token(){
   
4.     return ProxyToken;
   
5. }
   
6. 
   
7. 
   
8. int proxy_set_ipaddress(object ob,string val){
   
9.     if (undefinedp(ob)){
   
10.         ob=this_object();
    
11.     }
    
12.     if (objectp(ob->query_temp("link_ob"))){
    
13.         ob=ob->query_temp("link_ob");
    
14.     }
    
15.     if (ob->query_temp("proxy_verified")){
    
16.             ob->set_temp("ipaddress",val);
    
17.             return 1;
    
18.     }
    
19.     return 0;
    
20. }
    
21. int proxy_auth(object ob,string token){
    
22.     if (undefinedp(ob)){
    
23.         ob=this_object();
    
24.     }
    
25.     if (objectp(ob->query_temp("link_ob"))){
    
26.         ob=ob->query_temp("link_ob");
    
27.     }
    
28.     if (ProxyToken==token){
    
29.         ob->set_temp("proxy_verified",1);
    
30.         return 1;
    
31.     }
    
32.     return 0;
    
33. }
    
34. int proxy_authed(object ob){
    
35.         if (undefinedp(ob)){
    
36.         ob=this_object();
    
37.     }
    
38.     if (objectp(ob->query_temp("link_ob"))){
    
39.         ob=ob->query_temp("link_ob");
    
40.     }
    
41.     if (ob->query_temp("proxy_verified")){
    
42.         return 1;
    
43.     }
    
44.     return 0;
    
45. 
    
46. }
    
47. void proxy_set_token(string token){
    
48.     ProxyToken=token;
    
49. }
    
50. void proxy_command(object ob, string data){
    
51.     ob->gmcp_command("Proxy.Command "+data+"\n");
    
52. }
    
53. string query_ip_number(object ob){
    
54.     if (undefinedp(ob)){
    
55.         ob=this_object();
    
56.     }
    
57.     if (objectp(ob->query_temp("link_ob"))){
    
58.         ob=ob->query_temp("link_ob");
    
59.     }
    
60.     if (ProxyToken==""){
    
61.         return efun::query_ip_number(ob);
    
62.     }
    
63.     return ob->query_temp("ipaddress");
    
64. }
    

复制代码

proxy.c的内容就是这些。

里面有一个query_ip_number的覆盖。把实际ip储存在连接对象(这是个大坑，这不是连接对象，是码上失效的登陆对象)里。每次查ip就直接查这个值。

很好，nginx的请求头部分做好了。

我的中间件会给每个请求开一个javascript的vm。

请求初始化后的回调会直接发这些信息

1. OnConnectReady = function () {
   
2.     Connect.WriteSendBufferEscaped(Text(`Auth ${Token}\nIPAddress ${RemoteAddr}\nFinish\n`))
   
3. }
   

复制代码

然后写了个proxy测试的指令

1. inherit F_CLEAN_UP;
   
2. 
   
3. void create() { seteuid(getuid()); }
   
4. 
   
5. int main(object me, string arg)
   
6. {
   
7.                     write("ip："+query_ip_number(me)+"\n");
   
8.                     write("ip2: "+me->query_temp("ipaddress")+"\n");
   
9.                     write("id: "+me->query("id")+"\n");
   
10.                     write("gmcp "+ has_gmcp(this_player())+"\n");
    
11.                             proxy_command(me,"proxytest");
    
12.                     return 1;
    
13. 
    
14. }
    
15. 
    
16. int help(object me){
    
17.     return 1;
    
18. }
    

复制代码

很好，第一部，伪造(认证)ip地址完成了。

jarlyyn

完成了请求头部分的工作，就该完成响应部分了。

响应很简单，由于已经完成了认证，所以直接利用gmcp或者类似的SubNegotiation实现就好。
fluffos默认只有一个send_gmcp,(很坑，害得我所有相关的代码和mudlib看了好几遍)，但可以参考send_gmcp写一个efun，应该也不难。

用send_gmcp最大的坑就是，只有当前有交互所有权的对象才能发。当交互所有权转出去后，可能处于一个不报错，也不发的状态。

我在可能交互的交互所有权的clone/login和clone/user里都加了相应发送函数

1. void gmcp_command(string data){
   
2.                 send_gmcp(data);
   
3. }

复制代码

这样在不同的情况都能用proxy_command接口统一发送gmcp了。

然后中间件相应gmcp内容,我有个配置表

1. #脚本引擎.可为空或js
   
2. Engine = "js"
   
3. # DaemonScript="scripts/gmcpdaemon.js"
   
4. #连接脚本主程序
   
5. ConnectScript = "gmcp.js"
   
6. #连接启动函数
   
7. OnConnectStart = "OnConnectStart"
   
8. OnConnectReady = "OnConnectReady"
   
9. #连接用户输入处理函数
   
10. OnConnectUserInput = "OnConnectUserInput"
    
11. #系统指令命令处理函数表
    
12. [OnConnectServerCommand]
    
13. #IAC Will 处理函数
    
14. "251" = "OnConnectServerCommandWill"
    
15. #用户指令命令处理函数表
    
16. [OnConnectUserCommand]
    
17. #IAC DONT 处理函数
    
18. "254" = "OnConnectUserCommandDont"
    
19. #IAC WONT 处理函数
    
20. "252" = "OnConnectUserCommandWont"
    
21. #系统子协议 SubNegotiation 处理函数表
    
22. [OnConnectMainServerSubNegotiation]
    
23. #GMCP 处理函数
    
24. "201" = "OnGMCP"
    

复制代码

然后就能处理gmcp数据了。

1. OnGMCP = (output, opt, data) => {
   
2.     let text = Decode(data)
   
3.     if (text.startsWith("Proxy.Command sort_message ")) {
   
4.         Connect.WriteDisplayBufferEscaped(Text(`${sort_message(text.slice(27))}`))
   
5.         return true
   
6.     }
   
7. }

复制代码

好了，接下来就是怎么根据gmcp指令来渲染界面了，这就是我这个外挂程序的本职工作。

剩下的就是扩展了。

能通过请求头指定ip,之然根据请求头指定用户id,这样可以实现通过js控制的，登陆主服务器，获取session,断开主服务器，连接副服务器，通过session免重复登陆的工作了。

剩下的可以通过fluffos的开启socker端口服务功能，将主服务器与副本服务器/中间件进行直接的数据互通，更好的从主服务器上卸工作，降低主服务器cpu占有率，甚至开发更多更好玩的功能。

jarlyyn

写完了。

fluffos的文档内容实在有点单薄，大部分内容是我爬代码和一点一点测试出来的。

毕竟对mudlib/mudos这块不熟悉，也花了我两三天功夫了，记录下，备忘，当然能帮助到有同样想法的人自然最好。

ppmm

虽然看不懂，看着好像这个有助于解决现在北侠的cpu负载过高问题？

man

老一辈的程序员超过35岁就会被优化，因为跟不上自己的技术了啊，新技术至少mudos里心跳和网络接发不是一个cpu吧，然而老的人都不会了

jarlyyn

ppmm 发表于 2024-11-16 06:30 AM
虽然看不懂，看着好像这个有助于解决现在北侠的cpu负载过高问题？

只能说是一个思路吧。

毕竟我对nginx模式比较熟悉，第一反应就是套下这个模式，也算路径依赖了。

搁网络游戏里这应该就属于网关服务器的范畴了，参考。

其实我很早就对网关服务器就很感兴趣，自己的go框架也早早实现了连接网关的模块，然后做客户端的时候就拿这个网关降级了下使，意外的好用。

这个只是一个原型验证，验证driver和mudlib是否能实现这样的功能。这个可行的话，思路就能打开很多了。

我熟悉go js,有成熟的代码可以复用,所以马上能糊一个网关框架。

你对python熟，其实利用现成的库，写一个简单网关也不难。

只有有成熟的网络支持，有脚本支持，弄一个网关都容易。

甚至其实fluffos本身跑一个极简的mudlib做网关可能也不错。

现在的北侠的主服务器就是同时负担了网关服务器和游戏服务器的双重责任，那么把网关部分提出来，应该能很简单的就给服务器起到了减负作用。

而且有很多基础telnet/ansi的工具，解析mud文件也异常顺手。

别的不说，网关服务器实现news和当铺的list部分，不需要主服务器查找/渲染，怎么看都简单的不行，搞不好ln几个文件过来就行了。