skynet源碼分析之網絡層——Lua層介紹

本篇主要介紹在Lua服務里調用skynet網絡層底層接口的流程，Lua層的api主要在lualib/skynet/socket.lua，可參考官方wiki https://github.com/cloudwu/skynet/wiki/Socket。

通過一個簡單的例子說明Lua服務是如何最終調用到網絡層底層接口的：

   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)

1. 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.c

注：第34行，do_listen依次調用了unix網絡系統接口socket，bind，listen。

// lualib/skynet/socket.lua
function socket.listen(host, port, backlog)
    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) {
    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;
}

// 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);
}

// 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;
}

2. 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。

3. 網絡層如何通知給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);
    }
}

 4. 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服務的壓力。

5. 總結

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