skynet源码分析之网络层—Lua层

时间 2021-02-18

标签 git github api 网络 session 数据结构 socket tcp 函数 oop 栏目 C&C++ 繁體版

原文原文链接

本篇主要介绍在Lua服务里调用skynet网络层底层接口的流程，Lua层的api主要在lualib/skynet/socket.lua，可参考官方wiki https://github.com/cloudwu/sk...。git

经过一个简单的例子说明Lua服务是如何最终调用到网络层底层接口的：
：github

`local socket = require “socket”
   local skynet = require "skynet"

   local function loop(fd)
       socket.start(fd)
       while true do
           local data = socket.readline('n')
           print(data, #data)
       end
   end

  skynet.start(function()
      local listen_fd = socket.listen(ip, hort)
      socket.start(listen_fd, function(fd, addr)
          print("connect fd[%d], addr[%s]", fd, addr)
          skynet.fork(loop, fd)
      end)
  end)`

api调用流程概述

在服务启动时，调用socket.listen监听。调用流程是：driver.listen（第7行）——>skynet_socket_listen（第17行）——>socket_server_listen（第29行）——>send_request（第47行），最后向发送管道写数据。Lua接口执行流程是：socket.lua -> lua-socket.c ->skynet_socket.c -> socket_server.capi

注：第34行，do_listen依次调用了unix网络系统接口socket，bind，listen。网络

`// lualib/skynet/socket.lua
function socket.listen(host, port, backlog)session

if port == nil then
    host, port = string.match(host, "([^:]+):(.+)$")
    port = tonumber(port)
end
return driver.listen(host, port, backlog)

end数据结构

// lualib-src/lua-socket.c
static int
llisten(lua_State *L) {socket

const char * host = luaL_checkstring(L,1);
int port = luaL_checkinteger(L,2);
int backlog = luaL_optinteger(L,3,BACKLOG);
struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
int id = skynet_socket_listen(ctx, host,port,backlog);
if (id < 0) {
    return luaL_error(L, "Listen error");
}

lua_pushinteger(L,id);
return 1;

}tcp

// skynet-src/skynet_socket.c
skynet_socket_listen(struct skynet_context ctx, const char host, int port, int backlog) {函数

uint32_t source = skynet_context_handle(ctx);
return socket_server_listen(SOCKET_SERVER, source, host, port, backlog);

}oop

// skynet-src/socket_server.c
socket_server_listen(struct socket_server ss, uintptr_t opaque, const char addr, int port, int backlog) {

int fd = do_listen(addr, port, backlog);
if (fd < 0) {
    return -1;
}
struct request_package request;
int id = reserve_id(ss);
if (id < 0) {
    close(fd);
    return id;
}
request.u.listen.opaque = opaque;
request.u.listen.id = id;
request.u.listen.fd = fd;
send_request(ss, &request, 'L', sizeof(request.u.listen));
return id;

socket链接过程

skynet里的socket结构有几种状态：

#define SOCKET_TYPE_INVALID 0 //可以使用
#define SOCKET_TYPE_RESERVE 1 //已占用
#define SOCKET_TYPE_PLISTEN 2 //等待监听(监听套接字拥有)
#define SOCKET_TYPE_LISTEN 3 //监听，可接受客户端的链接（监听套接字才拥有）
#define SOCKET_TYPE_CONNECTING 4 //正在链接（connect失败时状态，tcp会尝试从新connect）
#define SOCKET_TYPE_CONNECTED 5 //已链接，能够收发数据
#define SOCKET_TYPE_HALFCLOSE 6
#define SOCKET_TYPE_PACCEPT 7 //等待链接（链接套接字才拥有）
#define SOCKET_TYPE_BIND 8

当工做线程执行socket.listen后，socket线程从接收管道读取数据，执行ctrl_cmd，调用listen_socket（第6行），此时该socket状态是SOCKET_TYPE_PLISTEN（第18行）

`// skynet-src/socket_server.c
static int
ctrl_cmd(struct socket_server *ss, struct socket_message *result) {
    ...
    case 'L':
        return listen_socket(ss,(struct request_listen *)buffer, result);
    ...
}

static int
listen_socket(struct socket_server *ss, struct request_listen * request, struct socket_message *result) {
    int id = request->id;
    int listen_fd = request->fd;
    struct socket *s = new_fd(ss, id, listen_fd, PROTOCOL_TCP, request->opaque, false);
    if (s == NULL) {
        goto _failed;
    }
    s->type = SOCKET_TYPE_PLISTEN;
    return -1;
    ...
}`

接着，Lua服务调用socket.start，最终socket线程执行start_socket，此时socket状态是SOCKET_TYPE_LISTEN，等待客户端的链接请求。

`// skynet-src/socket_server.c
  static int
  start_socket(struct socket_server *ss, struct request_start *request, struct socket_message *result) {
      ...
      if (s->type == SOCKET_TYPE_PACCEPT || s->type == SOCKET_TYPE_PLISTEN) {
          if (sp_add(ss->event_fd, s->fd, s)) {
              force_close(ss, s, &l, result);
              result->data = strerror(errno);
              return SOCKET_ERR;
          }
         s->type = (s->type == SOCKET_TYPE_PACCEPT) ? SOCKET_TYPE_CONNECTED : SOCKET_TYPE_LISTEN;
         s->opaque = request->opaque;
         result->data = "start";
         return SOCKET_OPEN;
     }
     ...
 }`

当客户端发起链接请求后，epoll事件返回，调用report_accept（第5行）

第14行，调用unix网络系统接口accept，接受客户端的请求。因为客户端已发起链接，因此不会阻塞。

第16行，从socket池中获取可用的socket id

17-22行，初始化该socket，此时socket状态是SOCKET_TYPE_PACCEPT

`int
socket_server_poll(struct socket_server *ss, struct socket_message * result, int * more) {
    ...
    case SOCKET_TYPE_LISTEN: {
        int ok = report_accept(ss, s, result);
    ...
}

// return 0 when failed, or -1 when file limit
static int
report_accept(struct socket_server *ss, struct socket *s, struct socket_message *result) {
    union sockaddr_all u;
    socklen_t len = sizeof(u);
    int client_fd = accept(s->fd, &u.s, &len);
    ...
    int id = reserve_id(ss);
    struct socket *ns = new_fd(ss, id, client_fd, PROTOCOL_TCP, s->opaque, false);
    ns->type = SOCKET_TYPE_PACCEPT;
    result->opaque = s->opaque;
    result->id = s->id;
    result->ud = id;
    result->data = NULL;

    ...
    return 1;
}`

接着，Lua服务再次调用socket.start(id)，此时id是链接的socket，而不是监听的socket。此时，socket状态是SOCKET_TYPE_CONNECTED，链接已经创建，能够收发数据。这就是整个socket链接过程。

至于怎么通知到 Lua服务稍后分析。

`// skynet-src/socket_server.c
 static int
 start_socket(struct socket_server *ss, struct request_start *request, struct socket_message *result) {
     ...
     s->type = (s->type == SOCKET_TYPE_PACCEPT) ? SOCKET_TYPE_CONNECTED : SOCKET_TYPE_LISTEN;
     ...
 }`

关闭socket，socket.close

发送数据有两个api，正常发送socket.write, 低优先级发送socket.lwrite。

网络层如何通知给Lua服务

socket线程在运行过程(socket_server_poll)中，当收到网络数据会调用forward_message_tcp

第19行，调用unix系统接口读取socket上的数据

21-24行，采用args-value形式构造result，opaque是Lua服务的地址，id是该socket在池中的索引，ud是实际读取到的字节数，data是数据

第25行，返回SOCKET_DATA，表示接收到数据。

`// skynet-src/socket_server.c
int
socket_server_poll(struct socket_server *ss, struct socket_message * result, int * more) {
    ...
    default:
        if (e->read) {
            int type;
            if (s->protocol == PROTOCOL_TCP) {
                type = forward_message_tcp(ss, s, &l, result);
        ...
    return type
}

static int
forward_message_tcp(struct socket_server *ss, struct socket *s, struct socket_lock *l, struct socket_message * resu
lt) {
    int sz = s->p.size;
    char * buffer = MALLOC(sz);
    int n = (int)read(s->fd, buffer, sz);
    ...
    result->opaque = s->opaque;
    result->id = s->id;
    result->ud = n;
    result->data = buffer;
    return SOCKET_DATA;
}`

因为socket_server_poll返回的是SOCKET_DATA，调用forward_message（第11行），

23-26行，构造即将要发送的消息数据，用到了上面返回的result

28-32行，构造skynet消息结构，由于是在网络层发送的，不是具体的某个服务，因此source，session字段都设置成0便可

第34行，把消息发送给与socket对应的服务地址。

至此，网络消息通知给具体的Lua服务。

`// skynet-src/skynet_socket.c
int
skynet_socket_poll() {
    struct socket_server *ss = SOCKET_SERVER;
    assert(ss);
    struct socket_message result;
    int more = 1;
    int type = socket_server_poll(ss, &result, &more);
    switch (type) {
    case SOCKET_DATA:
        forward_message(SKYNET_SOCKET_TYPE_DATA, false, &result);
        break;
        ...
    return 1；
}

// mainloop thread
static void
forward_message(int type, bool padding, struct socket_message * result) {
    struct skynet_socket_message *sm;
    size_t sz = sizeof(*sm);
    ...
    sm = (struct skynet_socket_message *)skynet_malloc(sz);
    sm->type = type;
    sm->id = result->id;
    sm->ud = result->ud;
    ...
    struct skynet_message message;
    message.source = 0;
    message.session = 0;
    message.data = sm;
    message.sz = sz | ((size_t)PTYPE_SOCKET << MESSAGE_TYPE_SHIFT);

    if (skynet_context_push((uint32_t)result->opaque, &message)) {
        // todo: report somewhere to close socket
        // don't call skynet_socket_close here (It will block mainloop)
        skynet_free(sm->buffer);
        skynet_free(sm);
    }
}`

Lua服务处理流程

当网络数据到达Lua服务时，lualib/skynet/socket.lua中提供了相应的处理方案。调用消息分发函数socket_message，网络数据类型包含正常数据传输(DATA)，链接(CONNECT)，关闭(CLOSE)，错误(ERROR)等。

第15行，把客户端发过来的数据push到该socket的缓冲池中。

`-- lualib/skynet/socket.lua
 skynet.register_protocol {
     name = "socket",
     id = skynet.PTYPE_SOCKET,       -- PTYPE_SOCKET = 6
     unpack = driver.unpack,
     dispatch = function (_, _, t, ...)
         socket_message[t](...)
     end
 }

 -- SKYNET_SOCKET_TYPE_DATA = 1
 socket_message[1] = function(id, size, data)
     local s = socket_pool[id]
     ...
     local sz = driver.push(s.buffer, buffer_pool, data, size)
     ...
 }`

socket.read(id, sz)，从一个socket上读sz指定的字节数，若是缓冲池里有足够多的数据，从缓冲池里pop出直接返回(第5行)，不然，暂停当前协程（第15行），当数据够或者链接断开时重启协程。

`-- lualib/skynet/socket.lua
 function socket.read(id, sz)
     local s = socket_pool[id]
     assert(s)
     ...
     local ret = driver.pop(s.buffer, buffer_pool, sz)
     if ret then
         return ret
     end
     if not s.connected then
         return false, driver.readall(s.buffer, buffer_pool)
     end

     assert(not s.read_required)
     s.read_required = sz
     suspend(s)
     ret = driver.pop(s.buffer, buffer_pool, sz)
     if ret then
         return ret
     else
         return false, driver.readall(s.buffer, buffer_pool)
     end
 end`

socket.readline(id, sep)，从一个socket上读以sep分割的数据，默认是"n"，即读一行数据。注：该api能够指定分隔符，不仅仅是一行数据。

socket.abandon(id)，清除socket id在本服务内的数据结构，但不并关闭这个socket，用于把id转给其余服务控制。一般，会设计一个master服务接收外部链接，等链接上后再将socket分配给一个slave服务控制，减小master服务的压力。

总结

socket库的使用流程通常是：

-- master服务
local listen_fd = socket.listen(ip, port)  //监听一个地址
socket.start(listen_fd, function(fd, addr)
     slave.post.start(fd)  //客户端链接上，转交给slave
     socket.abandon(fd)
end)

-- slave服务
function accept.start(fd)
      socket.start(fd) //接管socket
       ...
end

最后，小编推荐本身的Linux、C/C++技术交流群:【960994558】整理了一些我的以为比较好的学习书籍、视频资料共享在里面（包括C/C++，Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等等.），有须要的能够自行添加哦！~