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

その他ユーティリティ luv-miscellaneous-utilities

メトリクス操作 luv-metrics-operations

クレジット luv-credits