skynet框架应用 (十三) 网关服务

最新推荐文章于 2024-05-19 20:23:28 发布

吓人的猿

最新推荐文章于 2024-05-19 20:23:28 发布

阅读量8.6k

点赞数 10

分类专栏： skynet

本文链接：https://blog.csdn.net/qq769651718/article/details/79435075

版权

skynet 专栏收录该内容

18 篇文章 215 订阅

订阅专栏

13 网关服务

skynet 提供了一个通用模板 lualib/snax/gateserver.lua 来启动一个网关服务器，通过 TCP 连接和客户端交换数据。

TCP 基于数据流，但一般我们需要以带长度信息的数据包的结构来做数据交换。gateserver 做的就是这个工作，把数据流切割成包的形式转发到可以处理它的地址。

local gateserver = require "snax.gateserver"

local handler = {}        --必须提供一张表，表里面定义connect、message等相关回调函数

-- register handlers here

gateserver.start(handler)  --网关服务的入口函数

13.1最简单网关服务

13.1.1 编写mygateserver.lua

示例代码：mygateserver.lua

local skynet = require "skynet"
local gateserver = require "snax.gateserver"

local handler = {}

--当一个客户端链接进来，gateserver自动处理链接，并且调用该函数，必须要有
function handler.connect(fd, ipaddr)   
    skynet.error("ipaddr:",ipaddr,"fd:",fd,"connect")
    gateserver.openclient(fd) --链接成功不代表马上可以读到数据，需要打开这个套接字，允许fd接收数据
end

--当一个客户端断开链接后调用该函数，必须要有
function handler.disconnect(fd)   
    skynet.error("fd:", fd, "disconnect")
end


--当fd有数据到达了，会调用这个函数，前提是fd需要调用gateserver.openclient打开
function handler.message(fd, msg, sz)
    skynet.error("recv message from fd:", fd)

end


gateserver.start(handler)

13.1.2 启动mygateserver

可以使用普通服务创建方式来创建一个mygateserver服务，但是这个服务启动后，并不能马上开始工作，

需要你给mygateserver发送一个lua消息open并且告诉gateserver监听的端口、最大连接数、延时等信息来开启mygateserver服务。

代码如下openmygateserver.lua

local skynet = require "skynet"

skynet.start(function()
    skynet.error("Server start")
    local gateserver = skynet.newservice("mygateserver") --启动刚才写的网关服务
    skynet.call(gateserver, "lua", "open", {   --需要给网关服务发送open消息，来启动监听
        port = 8002,            --监听的端口
        maxclient = 64,         --客户端最大连接数
        nodelay = true,         --是否延迟TCP
    })

    skynet.error("gate server setup on", 8002)
    skynet.exit()
end)

运行结果：

$ ./skynet examples/config
openmygateserver                    #启动openmygateserver
[:01000010] LAUNCH snlua openmygateserver
[:01000010] Server start
[:01000012] LAUNCH snlua mygateserver  #启动mygateserver
[:01000012] Listen on 0.0.0.0:8002     #开始监听端口8002
[:01000010] gate server setup on 8002
[:01000010] KILL self               #openmygateserver退出

重开一个终端，启动一个C语言的socketclient客户端（在代码在9.2中）去连接8002端口，观察skynet服务情况：

$ ./skynet examples/config
openmygateserver  
[:01000010] LAUNCH snlua openmygateserver
[:01000010] Server start
[:01000012] LAUNCH snlua mygateserver
[:01000012] Listen on 0.0.0.0:8002
[:01000010] gate server setup on 8002
[:01000010] KILL self
[:01000012] ipaddr: 127.0.0.1:48008 fd: 9 connect  #连接进入
[:01000012] fd: 9 disconnect                       #断开连接

上面的结果可以看连接与断开连接都能执行，但是handler.message并没有执行。这是由于snax.gateserver

基于TCP协议包装了一个两字节数据长度的协议。而现在版本的socketclient并没有按照这种协议发送。

13.2 gateserver应用协议

13.2.1 两字数据长度协议

gateserver应用协议是基于TCP协议做了一层简单的封装，前两个字节表示数据包的长度len（不计算这两个表示长度的字节），高字节在前低字节在后（大端序），后面紧跟len字节数的数据。例如：

\x00\x05    \x31\x32\x33\x34\x35
    |            |
  len           data

由于只用两字节表示数据长度，那么这个包的data最大只能是65535字节。这种协议包方式可以解决TCP粘包的问题，也是TCP通信当中最常用的一种应用层协议包定义方式。

所以如果想通过TCP与gateserver通信必须要按照这种协议进行组包解包。否则gateserver肯定是不识别的。

13.2.2 打包与解包

打包与解包TCP网路数据可以使用skynet.netpack库

local netpack = require "skynet.netpack" --使用netpack
--打包数据str，返回一个C指针msg,sz，申请内存
netpack.pack(str) 

--解包数据，返回一个lua的字符串，会释放内存
netpack.tostring(msg, sz)

13.2.3 client使用长度协议发包

下面我们通过改写socketclient.c文件来组包发送数据：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>

#define MAXLINE 128

void* readthread(void* arg)
{
    pthread_detach(pthread_self());
    int sockfd = (int)arg;
    int n = 0;
    char buf[MAXLINE];
    while (1) 
        {
        n = read(sockfd, buf, MAXLINE);
        if (n == 0)
        {
            printf("the other side has been closed.\n");
            close(sockfd);
            exit(0);
        }
        else
            write(STDOUT_FILENO, buf, n);
    }   
    return (void*)0;
}

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        printf("usage:%s port", argv[0]);
        return -1;
    }
    int port = atoi(argv[1]);
    struct sockaddr_in servaddr;
    int sockfd;
    short size, nsize;
    char buf[MAXLINE];
    unsigned char sendbuf[MAXLINE];

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
    servaddr.sin_port = htons(port);
    connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    pthread_t thid;
    pthread_create(&thid, NULL, readthread, (void*)sockfd);

    while (fgets(buf, MAXLINE, stdin) != NULL) 
    {
        size = (short)strlen(buf);   //计算需要发送的数据包长度
        nsize = htons(size);        //转换成大端序
        memcpy(sendbuf, &nsize, sizeof(nsize));  //nsize先填入sendbuf
        memcpy(sendbuf+sizeof(nsize), buf, size); //再填入buf内容
        write(sockfd, sendbuf, size + sizeof(nsize));
    }
    close(sockfd);
    return 0;
}

先运行skynet服务，然后客户端运行：

$ gcc  socketclient.c -o socketclient -lpthread
./socketclient 8002

切回skynet运行的终端：

$ ./skynet examples/config
testmygateserver
[:01000010] LAUNCH snlua testmygateserver
[:01000010] Server start
[:01000012] LAUNCH snlua mygateserver
[:01000012] Listen on 0.0.0.0:8002
[:01000010] gate server setup on 8002
[:01000010] KILL self
[:01000012] ipaddr: 127.0.0.1:48012 fd: 9 connect
[:01000012] recv message from fd: 9    #已经调用handler.message

13.2.4 gateserver解包

上面的实验中mygateserver.lua中的handler.message已经被调用，并且告诉fd为9的套接字发来了数据，msg表示C数据指针，sz表示数据长度，在lua中无法直接使用，需要转换成lua可识别的数据，需要调用netpack.tostring函数来解包。下面来改写一下mygateserver.lua:

local skynet = require "skynet"
local gateserver = require "snax.gateserver"
local netpack = require "skynet.netpack" --使用netpack

local handler = {}

--当一个客户端链接进来，gateserver自动处理链接，并且调用该函数
function handler.connect(fd, ipaddr)   
    skynet.error("ipaddr:",ipaddr,"fd:",fd,"connect")
    gateserver.openclient(fd)
end

--当一个客户端断开链接后调用该函数
function handler.disconnect(fd)
    skynet.error("fd:", fd, "disconnect")
end


--接收消息
function handler.message(fd, msg, sz)
    skynet.error("recv message from fd:", fd)
    skynet.error(netpack.tostring(msg, sz))   --把 handler.message 方法收到的 msg,sz 转换成一个 lua string，并释放 msg 占用的 C 内存。
end

gateserver.start(handler)

运行结果：

$ ./skynet examples/config
openmygateserver
[:01000010] LAUNCH snlua openmygateserver
[:01000010] Server start
[:01000012] LAUNCH snlua mygateserver
[:01000012] Listen on 0.0.0.0:8002
[:01000010] gate server setup on 8002
[:01000010] KILL self
[:01000012] ipaddr: 127.0.0.1:48018 fd: 9 connect
[:01000012] recv message from fd: 9
[:01000012] aaaaaaaaaaa     #正常接收到数据。

[:01000012] fd: 9 disconnect

需要注意的是：msg是一个C指针指向了一块堆空间，如果你不进行任何处理，那么也要调用skynet.trash来释放底层的内存。

13.3 控制客户端连接数

网关服务最重要的任务就是控制客户端连接数，避免大量客户登录到这个服务上。

修改openmygateserver.lua

local skynet = require "skynet"

skynet.start(function()
    skynet.error("Server start")
    local gateserver = skynet.newservice("mygateserver") 
    skynet.call(gateserver, "lua", "open", {   
        port = 8002,            --监听的端口
        maxclient = 2,          --客户端最大连接数改为2个
        nodelay = true,         --是否延迟TCP
    })

    skynet.error("gate server setup on", 8002)
    skynet.exit()
end)

运行openmygateserver.lua，再运行三个socketclient，结果如下：

openmygateserver
[:0100000a] LAUNCH snlua openmygateserver
[:0100000a] Server start
[:0100000b] LAUNCH snlua mygateserver
[:0100000b] Listen on 0.0.0.0:8002
[:0100000b] open by  :0100000a
[:0100000b] listen on 8002
[:0100000b] client max 2
[:0100000b] nodelay true
[:0100000a] gate server setup on 8002
[:0100000a] KILL self
[:0100000b] ipaddr: 127.0.0.1:46650 fd: 7 connect  #第一个客户端连接成功
[:0100000b] ipaddr: 127.0.0.1:46652 fd: 8 connect  #第二个客户端连接成功
[:0100000b] fd: 9 disconnect                     #第三个客户端连接成功后，马上关闭

13.4 gateserver其他回调函数

--如果你希望在监听端口打开的时候，做一些初始化操作，可以提供 open 这个方法。
--source 是请求来源地址，conf 是开启 gate 服务的参数表（端口，连接数，是否延迟）。
function handler.open(source, conf)
end


--当一个连接异常（通常意味着断开），error 被调用，除了 fd ，还会拿到错误信息 msg（通常用于 log 输出）。
function handler.error(fd, msg)
end

--当 fd 上待发送的数据累积超过 1M 字节后，将回调这个方法。你也可以忽略这个消息。
function handler.warning(fd, size)
end

代码如下：

mygateserver.lua

local skynet = require "skynet"
local gateserver = require "snax.gateserver"
local netpack = require "skynet.netpack"

local handler = {}

--当一个客户端链接进来，gateserver自动处理链接，并且调用该函数
function handler.connect(fd, ipaddr)   
    skynet.error("ipaddr:",ipaddr,"fd:",fd,"connect")
    gateserver.openclient(fd)
end

--当一个客户端断开链接后调用该函数
function handler.disconnect(fd)
    skynet.error("fd:", fd, "disconnect")
end


--接收数据
function handler.message(fd, msg, sz)
    skynet.error("recv message from fd:", fd)
    --把 handler.message 方法收到的 msg,sz 转换成一个 lua string，并释放 msg 占用的 C 内存。
    skynet.error(netpack.tostring(msg, sz))   
end

--如果报错就关闭该套接字
function handler.error(fd, msg)
    gateserver.closeclient(fd)
end

--fd中待发送数据超过1M时调用该函数，可以不处理
function handler.warning(fd, size)
    skynet.skynet("warning fd=", fd , "unsent data over 1M")
end

--一旦gateserver打开监听成功后就会调用该接口
--testmygateserver.lua通过给mygateserver.lua发送lua消息open触发该函数调用
function handler.open(source, conf) 
    skynet.error("open by ", skynet.address(source))
    skynet.error("listen on", conf.port)
    skynet.error("client max", conf.maxclient)
    skynet.error("nodelay", conf.nodelay)
end

gateserver.start(handler)

运行结果：

$ ./skynet examples/config
openmygateserver
[:01000010] LAUNCH snlua openmygateserver
[:01000010] Server start
[:01000012] LAUNCH snlua mygateserver
[:01000012] Listen on 0.0.0.0:8002
[:01000012] open by  :01000010
[:01000012] listen on 8002
[:01000012] client max 64
[:01000012] nodelay true
[:01000010] gate server setup on 8002
[:01000010] KILL self

13.5 给gateserver发送lua消息

gateserver除了能接收socket消息以为，当然也是可以接受skynet的lua消息，并且gateserver还对lua消息注册函数进行了封装，只需提供handler.command回调函数就能处理lua消息，不需要我们自己调用skynet.dispatch来注册。

继续改写mygateserver.lua

local skynet = require "skynet"
local gateserver = require "snax.gateserver"
local netpack = require "skynet.netpack"


local handler = {}
local CMD = {}

--当一个客户端链接进来，gateserver自动处理链接，并且调用该函数
function handler.connect(fd, ipaddr)   
    skynet.error("ipaddr:",ipaddr,"fd:",fd,"connect")
    gateserver.openclient(fd)
end

--当一个客户端断开链接后调用该函数
function handler.disconnect(fd)
    skynet.error("fd:", fd, "disconnect")
end


--
function handler.message(fd, msg, sz)
    skynet.error("recv message from fd:", fd)
    --把 handler.message 方法收到的 msg,sz 转换成一个 lua string，并释放 msg 占用的 C 内存。
    skynet.error(netpack.tostring(msg, sz))   
end


function handler.error(fd, msg)
    skynet.closeclient(fd)
end


function handler.warning(fd, size)
    skynet.skynet("warning fd=", fd , "unsend data over 1M")
end


function handler.open(source, conf) --testmygateserver
    skynet.error("open by ", skynet.address(source))
    skynet.error("listen on", conf.port)
    skynet.error("client max", conf.maxclient)
    skynet.error("nodelay", conf.nodelay)
end


function CMD.kick(source, fd)
    skynet.error("source:", skynet.address(source), "kick fd:", fd)
    gateserver.closeclient(fd)
end


function handler.command(cmd, source, ...)
    local f = assert(CMD[cmd])
    return f(source, ...)
end

gateserver.start(handler)

再编写一个给mygateserver发送命令的服务：kickmygateserver.lua

local skynet = require "skynet"

local gateserver, fd= ...
fd = tonumber(fd) --必须要转换成整形数，skynet命令行传入的参数都是字符串
skynet.start(function()
    skynet.call(gateserver, "lua",  "kick", fd)
    skynet.exit()
end)

运行

1、先运行openmygateserver。

2、再在另一个终端运行socketclient。

3、然后回到skynet这边启动kickmygateserver关闭连接。

$ ./skynet examples/config
openmygateserver   #终端输入
[:01000010] LAUNCH snlua openmygateserver
[:01000010] Server start
[:01000012] LAUNCH snlua mygateserver  #网关启动
[:01000012] Listen on 0.0.0.0:8002
[:01000012] open by  :01000010
[:01000012] listen on 8002
[:01000012] client max 64
[:01000012] nodelay true
[:01000010] gate server setup on 8002
[:01000010] KILL self
[:01000012] ipaddr: 127.0.0.1:49038 fd: 9 connect #一个先的客户端连接进来，fd为9
kickmygateserver :01000012 9   #终端输入给网关服务也就是:01000012发送lua消息关闭9号fd
[:01000020] LAUNCH snlua kickmygateserver :01000012 9
[:01000012] source: :01000020 kick fd: 9
[:01000020] KILL self
[:01000012] fd: 9 disconnect  #fd 9关闭收到反馈。

13.6 open与close两个lua消息

gateserver保留了open与close两个lua消息用来打开关闭监听的端口，所以大家在定义命令的时候不要再使用open与close了。通过这两个消息，我们可以轻松的管理gateserver的开关。

其实在openmygateserver.lua中我们已经发送过一个lua消息open给mygateserver。下面我们来试一试发送lua消息close给mygateserver看看。

代码示例：closemygateserver.lua

local skynet = require "skynet"

local gateserver = ...
skynet.start(function()
    skynet.call(gateserver, "lua",  "close")
    skynet.exit()
end)

先运行openmygateserver再运行closemygateserver：

$ ./skynet examples/config
openmygateserver    
[:01000010] LAUNCH snlua openmygateserver
[:01000010] Server start
[:01000012] LAUNCH snlua mygateserver
[:01000012] Listen on 0.0.0.0:8002
[:01000012] open by  :01000010
[:01000012] listen on 8002
[:01000012] client max 64
[:01000012] nodelay true
[:01000010] gate server setup on 8002
[:01000010] KILL self
[:01000012] ipaddr: 127.0.0.1:49048 fd: 9 connect #可以正常连接
closemygateserver :01000012
[:01000019] LAUNCH snlua closemygateserver :01000012 #发送完CLOSE命令后无法连接新的客户端
[:01000019] KILL self

13.7 agent服务

前面几节我们讲到gateserver的网络数据的读取，那么是不是也可以通过gateserver来发送网络数据呢？很遗憾gateserver并没有提供相关的写函数，因为gateserver本身就只负责管理网络连接（即 TCP连接的处理），涉及到请求处理与答复一般是交给一个叫agent的服务，agent可以由一个普通服务来充当。

来写一个简单的agent.lua服务

local skynet = require "skynet"
local netpack = require "skynet.netpack"
local socket = require "skynet.socket"

local client_fd = ...
client_fd = tonumber(client_fd)

skynet.register_protocol {   
    name = "client",
    id = skynet.PTYPE_CLIENT,
    --需要将网路数据转换成lua字符串，不需要打包，所以不用注册pack函数
    unpack = netpack.tostring,  
}

local function task(msg)
    print("recv from fd", client_fd, msg)
    --响应消息的时候直接通过fd发送出去
    socket.write(client_fd, netpack.pack(string.upper(msg))) 
end

skynet.start(function()
    --注册client消息专门用来接收网络数据
    skynet.dispatch("client", function(_,_, msg) 
        task(msg)
    end)

    skynet.dispatch("lua", function(_,_, cmd) --注册lua消息，来退出服务
        if cmd == "quit" then
            skynet.error(fd,"agent quit")
            skynet.exit()
        end
    end)
end)

改写一下mygateserver.lua，让它处理好一个链接后就创建一个agent服务，并且把fd传给agent，一旦收到数据就转发给agent服务。其他与客户端的交流工作都通过agent来解决。

local skynet = require "skynet"
local gateserver = require "snax.gateserver"
local netpack = require "skynet.netpack"

local handler = {}
local CMD = {}
local agents = {}
--注册client消息专门用来将接收到的网络数据转发给agent,不需要解包，也不需要打包
skynet.register_protocol {   
    name = "client",
    id = skynet.PTYPE_CLIENT,
}

function handler.connect(fd, ipaddr)   
    skynet.error("ipaddr:",ipaddr,"fd:",fd,"connect")
    gateserver.openclient(fd)
    local agent = skynet.newservice("myagent", fd) --连接成功就启动一个agent来代理
    agents[fd] = agent
end

function handler.disconnect(fd) --断开连接后，agent服务退出
    skynet.error("fd:", fd, "disconnect")
    local agent = agents[fd]
    if(agent) then
        --通过发送消息的方式来退出不要使用skynet.kill(agent)
        skynet.send(agent, "lua", "quit")
        agents[fd] = nil
    end
end

function handler.message(fd, msg, sz)
    local agent = agents[fd]
    skynet.redirect(agent, 0, "client", 0, msg, sz) --收到消息就转发给agent
end

function handler.error(fd, msg)
    skynet.closeclient(fd)
end

function handler.warning(fd, size)
    skynet.skynet("warning fd=", fd , "unsend data over 1M")
end

function handler.open(source, conf) 
    skynet.error("open by ", skynet.address(source))
    skynet.error("listen on", conf.port)
    skynet.error("client max", conf.maxclient)
    skynet.error("nodelay", conf.nodelay)
end

function CMD.kick(source, fd)
    skynet.error("source:", skynet.address(source), "kick fd:", fd)
    gateserver.closeclient(fd)
end

function handler.command(cmd, source, ...)
    local f = assert(CMD[cmd])
    return f(source, ...)
end

gateserver.start(handler)

直接在skynet上运行openmygateserver,然后再另一个终端启动socketclient：

$ ./skynet examples/config
openmygateserver
[:01000010] LAUNCH snlua openmygateserver
[:01000010] Server start
[:01000012] LAUNCH snlua mygateserver
[:01000012] Listen on 0.0.0.0:8002
[:01000012] open by  :01000010
[:01000012] listen on 8002
[:01000012] client max 64
[:01000012] nodelay true
[:01000010] gate server setup on 8002
[:01000010] KILL self
[:01000012] ipaddr: 127.0.0.1:49076 fd: 9 connect  #socketclient链接进来
[:01000019] LAUNCH snlua myagent 9      #启动一个新的myagent来处理
recv from fd    9   aaaaaaaaaaaaaa

[:01000012] fd: 9 disconnect            #socketclient退出后
[:01000019] 9 agent quit                #对应的agent服务也退出了
[:01000019] KILL self

13.8 skynet自带网关服务

skynet有自带的网关服务代码，在service/gate.lua，这个网关代码写的足够好了，完全可以直接使用，

使用这个网关服务的例子代码在examples/watchdog.lua，watchdog.lua中使用到examples/agent.lua文件。

三个代码需要结合则去看。启动watchdog服务的代码在main.lua。

它们的大致关系：

1、newservice watchdog启动看门狗服务，lua start conf给看门狗发送lua消息start参数为conf。

2、newservice gate启动网关服务，lua open conf给网关发送lua消息open参数为 conf。

3、new connection客户端连接进来。

4、lua socket open fd addr给看门狗发送lua消息socket参数为open fd addr。

5、newservice agent启动一个客户端代理服务，lua start {gate，fd, watchdog}给代理发送lua消息start参数为{gate，fd, watchdog}。

6、lua forward fd给网关发送lua消息forward参数为fd。（到此，连接建立成功，可以进行网络通信了）

7、send requst客户端发送请求给看门狗。

8、client 1 msg sz 看门狗把请求转发成client消息，session为1。

9、send response 代理直接给客户端发送响应。

按照从1到9的依次去查看代码，需要强调的是：

1、gate主要负责的是client连接创建与断开以及接受到消息转发给agent。

2、watchdog主要负责gate的创建，agent的创建与退出。

3、agentt主要负责接受gate转发的请求，处理业务，然后直接把应答发送给client。

吓人的猿

关注

10
点赞
踩
21

收藏

觉得还不错? 一键收藏
11
评论
skynet框架应用 (十三) 网关服务

13 网关服务 skynet 提供了一个通用模板 lualib/snax/gateserver.lua 来启动一个网关服务器，通过 TCP 连接和客户端交换数据。 TCP 基于数据流，但一般我们需要以带长度信息的数据包的结构来做数据交换。gateserver 做的就是这个工作，把数据流切割成包的形式转发到可以处理它的地址。local gateserver = require "snax.ga...
复制链接

扫一扫