Luvref

简介 luv luv-intro uv

local uv = vim.uv
local server = uv.new_tcp()
server:bind("127.0.0.1", 1337)
server:listen(128, function (err)
  assert(not err, err)
  local client = uv.new_tcp()
  server:accept(client)
  client:read_start(function (err, chunk)
    assert(not err, err)
    if chunk then
      client:write(chunk)
    else
      client:shutdown()
      client:close()
    end
  end)
end)
print("TCP server listening at 127.0.0.1 port 1337")
uv.run() -- an explicit run call is necessary outside of luvit

内容 luv-contents

错误处理 luv-error-handling

版本检查 luv-version-checking

uv_loop_t — 事件循环 luv-event-loop uv_loop_t

uv.loop_configure("block_signal", "sigprof")

-- Example usage of uv.walk to close all handles that
-- aren't already closing.
uv.walk(function (handle)
  if not handle:is_closing() then
    handle:close()
  end
end)

uv_req_t — 基本请求 luv-base-request uv_req_t

uv_handle_t — 基本句柄 luv-base-handle uv_handle_t

引用计数 luv-reference-counting

uv_timer_t — 定时器句柄 luv-timer-handle uv_timer_t

-- Creating a simple setTimeout wrapper
local function setTimeout(timeout, callback)
  local timer = uv.new_timer()
  timer:start(timeout, 0, function ()
    timer:stop()
    timer:close()
    callback()
  end)
  return timer
end
-- Creating a simple setInterval wrapper
local function setInterval(interval, callback)
  local timer = uv.new_timer()
  timer:start(interval, interval, function ()
    callback()
  end)
  return timer
end
-- And clearInterval
local function clearInterval(timer)
  timer:stop()
  timer:close()
end

uv_prepare_t — 预备句柄 luv-prepare-handle uv_prepare_t

local prepare = uv.new_prepare()
prepare:start(function()
  print("Before I/O polling")
end)

uv_check_t — 检查句柄 luv-check-handle uv_check_t

local check = uv.new_check()
check:start(function()
  print("After I/O polling")
end)

uv_idle_t — 空闲句柄 luv-idle-handle uv_idle_t

local idle = uv.new_idle()
idle:start(function()
  print("Before I/O polling, no blocking")
end)

uv_async_t — 异步句柄 luv-async-handle uv_async_t

local async
async = uv.new_async(function()
  print("async operation ran")
  async:close()
end)
async:send()

uv_poll_t — 轮询句柄 luv-poll-handle uv_poll_t

uv_signal_t — 信号句柄 luv-signal-handle uv_signal_t

-- Create a new signal handler
local signal = uv.new_signal()
-- Define a handler function
uv.signal_start(signal, "sigint", function(signal)
  print("got " .. signal .. ", shutting down")
  os.exit(1)
end)

uv_process_t — 进程句柄 luv-process-handle uv_process_t

local stdin = uv.new_pipe()
local stdout = uv.new_pipe()
local stderr = uv.new_pipe()
print("stdin", stdin)
print("stdout", stdout)
print("stderr", stderr)
local handle, pid = uv.spawn("cat", {
  stdio = {stdin, stdout, stderr}
}, function(code, signal) -- on exit
  print("exit code", code)
  print("exit signal", signal)
end)
print("process opened", handle, pid)
uv.read_start(stdout, function(err, data)
  assert(not err, err)
  if data then
    print("stdout chunk", stdout, data)
  else
    print("stdout end", stdout)
  end
end)
uv.read_start(stderr, function(err, data)
  assert(not err, err)
  if data then
    print("stderr chunk", stderr, data)
  else
    print("stderr end", stderr)
  end
end)
uv.write(stdin, "Hello World")
uv.shutdown(stdin, function()
  print("stdin shutdown", stdin)
  uv.close(handle, function()
    print("process closed", handle, pid)
  end)
end)

uv_stream_t — 流句柄 luv-stream-handle uv_stream_t

server:listen(128, function (err)
  local client = uv.new_tcp()
  server:accept(client)
end)

stream:read_start(function (err, chunk)
  if err then
    -- handle read error
  elseif chunk then
    -- handle data
  else
    -- handle disconnect
  end
end)

uv_tcp_t — TCP 处理程序 luv-tcp-handle uv_tcp_t

local client = uv.new_tcp()
client:connect("127.0.0.1", 8080, function (err)
  -- check error and carry on.
end)

-- Simple read/write with tcp
local fds = uv.socketpair(nil, nil, {nonblock=true}, {nonblock=true})
local sock1 = uv.new_tcp()
sock1:open(fds[1])
local sock2 = uv.new_tcp()
sock2:open(fds[2])
sock1:write("hello")
sock2:read_start(function(err, chunk)
  assert(not err, err)
  print(chunk)
end)

uv_pipe_t — 管道处理程序 luv-pipe-handle uv_pipe_t

local pipe = uv.new_pipe(false)
pipe:bind('/tmp/sock.test')
pipe:listen(128, function()
  local client = uv.new_pipe(false)
  pipe:accept(client)
  client:write("hello!\n")
  client:close()
end)

-- Simple read/write with pipe_open
local fds = uv.pipe({nonblock=true}, {nonblock=true})
local read_pipe = uv.new_pipe()
read_pipe:open(fds.read)
local write_pipe = uv.new_pipe()
write_pipe:open(fds.write)
write_pipe:write("hello")
read_pipe:read_start(function(err, chunk)
  assert(not err, err)
  print(chunk)
end)

uv_tty_t — TTY 句柄 luv-tty-handle uv_tty_t

-- Simple echo program
local stdin = uv.new_tty(0, true)
local stdout = uv.new_tty(1, false)
stdin:read_start(function (err, data)
  assert(not err, err)
  if data then
    stdout:write(data)
  else
    stdin:close()
    stdout:close()
  end
end)

uv_udp_t — UDP 句柄 luv-udp-handle uv_udp_t

uv_fs_event_t — FS 事件句柄 luv-fs-event-handle uv_fs_event_t

uv_fs_poll_t — FS 轮询句柄 luv-fs-poll-handle uv_fs_poll_t

文件系统操作 luv-file-system-operations uv_fs_t

local function readFileSync(path)
  local fd = assert(uv.fs_open(path, "r", 438))
  local stat = assert(uv.fs_fstat(fd))
  local data = assert(uv.fs_read(fd, stat.size, 0))
  assert(uv.fs_close(fd))
  return data
end
local data = readFileSync("main.lua")
print("synchronous read", data)

local function readFile(path, callback)
  uv.fs_open(path, "r", 438, function(err, fd)
    assert(not err, err)
    uv.fs_fstat(fd, function(err, stat)
      assert(not err, err)
      uv.fs_read(fd, stat.size, 0, function(err, data)
        assert(not err, err)
        uv.fs_close(fd, function(err)
          assert(not err, err)
          return callback(data)
        end)
      end)
    end)
  end)
end
readFile("main.lua", function(data)
  print("asynchronous read", data)
end)

线程池工作调度 luv-thread-pool-work-scheduling

local function work_callback(a, b)
  return a + b
end
local function after_work_callback(c)
  print("The result is: " .. c)
end
local work = uv.new_work(work_callback, after_work_callback)
work:queue(1, 2)
-- output: "The result is: 3"

DNS 实用函数 luv-dns-utility-functions

线程和同步实用程序 luv-threading-and-synchronization-utilities

uv.thread_create({entry} [, {args}]) uv.thread_create()

指标操作 luv-metrics-operations

致谢 luv-credits