库-libuv：概述
From：?http://blog.chinaunix.net/uid-28458801-id-4464173.html
libuv 是 Node 的新跨平臺抽象層，用于抽象 Windows 的 IOCP 及 Unix 的 libev。作者打算在這個庫的包含所有平臺的差異性。特性：非阻塞 TCP 套接字非阻塞命名管道UDP定時器子進程生成通過 uv_getaddrinfo 實現異步 DNS異步文件系統 API：uv_fs_* 高分辨率時間：uv_hrtime正在運行程序路徑查找：uv_exepath線程池調度：uv_queue_workTTY控制的ANSI轉義代碼: uv_tty_t文件系統事件現在支持 inotify, ReadDirectoryChangesW 和 kqueue。很快會支持事件端口：uv_fs_event_t進程間的 IPC 與套接字共享：uv_write2已受支持的平臺：Microsoft Windows 操作系統，如 Windows XP SP2。使用 Visual Studio 或 MinGW 構建Linux 2.6 使用 GCC 工具鏈MacOS 使用 GCC 或 XCode 工具鏈Solaris 121 或之后版本，使用 GCC 工具鏈序言
本書由一系列?libuv?教程組成，?libuv?是一個高性能事件驅動的程序庫，封裝了 Windows 和 Unix 平臺一些底層特性，為開發者提供了統一的 API.
本書旨在涵蓋 libuv 的主要特性, 并不是一份完整介紹 libuv 內部每個 API 和數據結構的指南, 官方文檔?official libuv documentation?可以直接在 libuv 源碼提供的頭文件中找到.
本書還沒有完成，某些章節可能不完整，但我希望在我不斷完善本書同時，你也能夠從中獲益 :-)
本書為誰而寫?
如果你正在閱讀本書，你或許是:
本書假設你對 C 語言有了一定的了解。
背景
node.js?最初發起于 2009 年, 是一個可以讓 Javascript 代碼脫離瀏覽器的執行環境, libuv 使用了 Google 的?V8?執行引擎 和 Marc Lehmann 的?libev. Node.js 將事件驅動的 I/O 模型與適合該模型的編程語言(Javascript)融合在了一起, 隨著 node.js 的日益流行, node.js 的開發者們也意識到應該讓 node.js 在 Windows 平臺下也能工作, 但是 libev 只能在 Unix 環境下運行. Windows 平臺上與 kqueue(FreeBSD) 或者 (e)poll(Linux) 等內核事件通知相應的機制 是 IOCP, libuv 依據不同平臺的特性(Unix 平臺為 libev, Windows 平臺為 IOCP) 給上層應用提供了統一基于 libev API 的抽象, 不過 node-v0.9.0 版本的 libuv 中 libev 的依賴已被移除, 參見:?libev has been removed?libuv 直接與 Unix 平臺交互.
本書代碼
本書所有代碼均可以在 Github 上獲取,?Clone/Download?本書源碼，然后進入到?code/?目錄執行?make?編譯本書的例子. 書中的代碼基于?node-v0.9.8?版本的 libuv, 為了方便讀者學習，本書的源碼中也附帶了相應版本的 libuv，你可以在?libuv/?目錄中找到源碼，libuv 會在你編譯書中的例子時被自動編譯。
Libuv 基礎
libuv 采用了?異步?(asynchronous),?事件驅動?(event-driven)的編程風格, 其主要任務是為開人員提供了一套事件循環和基于I/O(或其他活動)通知的回調函數, libuv 提供了一套核心的工具集, 例如定時器, 非阻塞網絡編程的支持, 異步訪問文件系統, 子進程以及其他功能.
事件循環(Event loops)
在事件編程模型中, 應用程序通常會關注某些特定的事件, 并在事件發生后對其作出響應. 而收集事件或監控其他事件源則是 libuv 的職責, 編程人員只需要對感興趣的事件注冊回調函數, 在事件發生后 libuv 將會調用相應的回調函數. 只要程序不退出(被系統管理人員 kill 掉), 事件循環通常會一直運行, 下面是事件驅動編程模型的偽代碼:
while there are still events to process:e = get the next event if there is a callback associated with e:call the callback適用于事件驅動編程模型的例子如下:
- 文件已經準備好可寫入數據.
- 某一 socket 上存在數據可讀.
- 定時器已超時.
事件循環由?uv_run?函數封裝, 在使用 libuv 編程時, 該函數通常在最后才被調用.
計算機程序最基本的活動是輸入輸出的處理, 而不是大量的數值計算, 而使用傳統輸入輸出函數(read,?fprintf?等)的問題是它們都是?阻塞?的. 將數據寫入磁盤或者從網絡讀取數據都會消耗大量時間, 而阻塞函數直到任務完成后才返回, 在此期間你的程序什么也沒有做, 浪費了大量的 CPU 時間. 對于追求高性能的程序而言, 在其他活動或者 I/O 操作在進行盡量讓 CPU 不被阻塞.
標準的解決方案是使用線程, 每個阻塞的 I/O 操作都在一個單獨的線程(或線程池)中啟動, 當阻塞函數被調用時, 處理器可以調度另外一個真正需要 CPU 的線程來執行任務.
Libuv 采用另外一種方式處理阻塞任務, 即?異步?和?非阻塞?方式.大多數現代操作系統都提供了事件通知功能, 例如, 調用?read讀取網絡套接字時程序會阻塞, 直到發送者最終發送了數據(read?才返回). 但是, 應用程序可以要求操作系統監控套接字, 并在套接字上注冊事件通知. 應用程序可以在適當的時候查看它所監視的事件并獲取數據(若有). 整個過程是?異步?的, 因為程序在某一時刻關注了它感興趣的事件, 并在另一個時刻獲取(使用)數據, 這也是?非阻塞?的, 因為該進程還可以處理另外的任務. Libuv 的事件循環方式很好地與該模型匹配, 因為操作系統事件可以視為另外一種 libuv 事件. 非阻塞方式可以保證在其他事件到來時被盡快處理?[1].
Note
I/O 是如何在后臺運行的不是我們所關心的, 但是由于我們計算機硬件的工作方式, 線程是處理器最基本的執行單元, thread as the basic unit of the , libuv 和操作系統通常會運行后臺/工作者線程, 或者采用非阻塞方式來輪流執行任務.
Hello World
具備了上面最基本的知識后, 我們就來編寫一個簡單 libuv 的程序吧.該程序并沒有做任何具體的事情, 只是簡單的啟動了一個會退出的事件循環.
#include #include int main() {uv_loop_t *loop = uv_loop_new();printf("Now quitting.\n");uv_run(loop, UV_RUN_DEFAULT); return 0; }該程序啟動后就會直接退出, 因為你沒有事件可處理. 我們可以使用 libuv 提供了各種 API 來告知 libuv 我們感興趣的事件.
libuv 的默認事件循環(Default loop)
libuv 提供了一個默認的事件循環, 你可以通過?uv_default_loop?來獲得該事件循環, 如果你的程序中只有一個事件循環, 你就應該使用 libuv 為我們提供的默認事件循環.
Note
node.js 使用默認事件循環作為它的主循環,如果你正在編寫 node.js 的綁定, 你應該意識到這一點.
監視器(Watchers)
libuv 通過監視器(Watcher)來對特定事件進行監控, 監視器通常是類似?uv_TYPE_t?結構體的封裝,?TYPE?代表該監視器的用途, libuv 所有的監視器類型如下:
typedef struct uv_loop_s uv_loop_t; typedef struct uv_err_s uv_err_t; typedef struct uv_handle_s uv_handle_t; typedef struct uv_stream_s uv_stream_t; typedef struct uv_tcp_s uv_tcp_t; typedef struct uv_udp_s uv_udp_t; typedef struct uv_pipe_s uv_pipe_t; typedef struct uv_tty_s uv_tty_t; typedef struct uv_poll_s uv_poll_t; typedef struct uv_timer_s uv_timer_t; typedef struct uv_prepare_s uv_prepare_t; typedef struct uv_check_s uv_check_t; typedef struct uv_idle_s uv_idle_t; typedef struct uv_async_s uv_async_t; typedef struct uv_process_s uv_process_t; typedef struct uv_fs_event_s uv_fs_event_t; typedef struct uv_fs_poll_s uv_fs_poll_t; typedef struct uv_signal_s uv_signal_t;所有監視器的結構都是?uv_handle_t?的”子類”， 在 libuv 和本文中都稱之為句柄(?handlers?).
監視器由相應類型的初始化函數設置, 如下:
uv_TYPE_init(uv_TYPE_t*)某些監視器初始化函數的第一個參數為事件循環的句柄.
監視器再通過調用如下類型的函數來設置事件回調函數并監聽相應事件:
uv_TYPE_start(uv_TYPE_t*, callback)而停止監聽應調用如下類型的函數:
uv_TYPE_stop(uv_TYPE_t*)當 libuv 所監聽事件發生后, 回調函數就會被調用. 應用程序特定的邏輯通常都是在回調函數中實現的, 例如, 定時器回調函數在發生超時事件后也會被調用, 另外回調函被調用時傳入的相關參數都與特定類型的事件有關, 例如, IO 監視器的回調函數在發生了IO事件后將會收到從文件讀取的數據.
空轉(Idling)
接下來我們通過例子來講述監視器的使用. 例子中空轉監視器回調函數被不斷地重復調用, 當然其中也有一些深層次的語言，我們將會在?工具集?進一步討論, 但現在我們只是跳過具體細節. 我們只是使用了一個空轉監視器回調來看看監視器的生命周期, 通過例子我們也可以了解到： 由于設置了監視器, 所以調用?uv_run()?是程序會阻塞, 空轉監視器將會在計數器達到設定的值時停止(監視),?uv_run()?會退出因為此時程序中沒有活動的監視器了.
#include #include int64_t counter = 0; void wait_for_a_while(uv_idle_t* handle, int status) {counter++; if (counter >= 10e6)uv_idle_stop(handle); } int main() {uv_idle_t idler;uv_idle_init(uv_default_loop(), &idler);uv_idle_start(&idler, wait_for_a_while);printf("Idling...\n");uv_run(uv_default_loop(), UV_RUN_DEFAULT); return 0; }文件系統
簡單的文件讀寫是通過?uv_fs_*?函數族和與之相關的?uv_fs_t?結構體完成的.
libuv 提供的文件操作和?socket operations?并不相同. 套接字操作使用了操作系統本身提供了非阻塞操作, 而文件操作內部使用了阻塞函數, 但是 libuv 是在線程池中調用這些函數, 并在應用程序需要交互時通知在事件循環中注冊的監視器.
所有的文件操作函數都有兩種形式 - 同步?synchronous?和?asynchronous.
同步?synchronous?形式如果沒有指定回調函數則會被自動調用(?阻塞的?), 函數的返回值和 Unix 系統的函數調用返回值相同(調用成功通常返回 0, 若出現錯誤則返回 -1).
而異步?asynchronous?形式則會在傳入回調函數時被調用, 并且返回 0.
讀寫文件
文件描述符可以采用如下方式獲得:
int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, int mode, uv_fs_cb cb)?
參數?flags?與?mode?和標準的?Unix flags?相同. libuv 會小心地處理 Windows 環境下的相關標志位(flags)的轉換, 所以編寫跨平臺程序時你不用擔心不同平臺上文件打開的標志位不同。
關閉文件描述符可以使用:
int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb)與文件系統相關的操作的回調函數具有如下簽名:
void callback(uv_fs_t* req);讓我們來看看?cat?命令的一個簡單實現吧: 我們首先注冊一個在文件打開時的回調函數 (顧名思義, 該函數將在文件打開時被調用).
void on_open(uv_fs_t *req) { if (req->result != -1) {uv_fs_read(uv_default_loop(), &read_req, req->result,buffer, sizeof(buffer), -1, on_read);} else {fprintf(stderr, "error opening file: %d\n", req->errorno);}uv_fs_req_cleanup(req); }uv_fs_t?的?result?字段在執行?us_fs_open?時代表一個文件描述符, 如果文件成功被打開, 我們開始讀取文件.
必須調用?uv_fs_req_cleanup()?來釋放 libuv 內部使用的內存空間.
void on_read(uv_fs_t *req) {uv_fs_req_cleanup(req); if (req->result < 0) {fprintf(stderr, "Read error: %s\n", uv_strerror(uv_last_error(uv_default_loop())));} else if (req->result == 0) {uv_fs_t close_req; // synchronous uv_fs_close(uv_default_loop(), &close_req, open_req.result, NULL);} else {uv_fs_write(uv_default_loop(), &write_req, 1, buffer, req->result, -1, on_write);} }在調用 read 時, 你應該傳遞一個初始化的緩沖區, 在 read 回調函數被觸發(調用之前), 該緩沖區將會被填滿數據.
在 read 的回調函數中?result?如果是 0, 則讀取文件時遇到了文件尾(EOF), -1 則代表出現了錯誤, 而正整數則是表示成功讀取的字節數.
此處給你展示了編寫異步程序的通用模式,?uv_fs_close()?是異步調用的.?通常如果任務是一次性的, 或者只在程序啟動和關閉時被執行的話都可以采用同步方式執行, 因為我們期望提高 I/O 效率, 采用異步編程時程序也可以做一些基本的任務并處理多路 I/O.. 對于單個任務而言性能差異可以忽略, 但是代碼卻能大大簡化.
我們可以總結出真正的系統調用返回值一般是存放在?uv_fs_t.result.
寫入文件與上述過程類似, 使用?uv_fs_write?即可.?write 的回調函數在寫入完成時被調用.. 在我們的程序中回調函數只是只是簡單地發起了下一次讀操作, 因此, 讀寫操作會通過回調函數連續進行下去.
void on_write(uv_fs_t *req) {uv_fs_req_cleanup(req); if (req->result < 0) {fprintf(stderr, "Write error: %s\n", uv_strerror(uv_last_error(uv_default_loop())));} else {uv_fs_read(uv_default_loop(), &read_req, open_req.result, buffer, sizeof(buffer), -1, on_read);} }錯誤值通常保存在?errno?并可以通過?uv_fs_t.errorno?獲取, 但是被轉換成了標準的?UV_*?錯誤碼. 目前還沒有方法直接從?errorno?解析得到錯誤消息的字符串表示.
由于文件系統和磁盤通常為了提高性能吞吐率而配置了緩沖區, libuv 中一次 ‘成功’ 的寫操作可能不會被立刻提交到磁盤上, 你可以通過?uv_fs_fsync?來保證一致性.
我們再來看看?main?函數中設置的多米諾骨牌吧(原作者意指在 main 中設置回調函數后會觸發整個程序開始執行):
int main(int argc, char **argv) {uv_fs_open(uv_default_loop(), &open_req, argv[1], O_RDONLY, 0, on_open);uv_run(uv_default_loop(), UV_RUN_DEFAULT); return 0; }文件系統相關操作(Filesystem operations)
所有的標準文件系統操作, 例如?unlink,?rmdir,?stat?都支持異步操作, 并且各個函數的參數非常直觀. 他們和 read/write/open 的調用模式一致, 返回值都存放在?uv_fs_t.result?域. 完整的列表如下:
UV_EXTERN int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file,uv_fs_cb cb);UV_EXTERN int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, int mode, uv_fs_cb cb);UV_EXTERN int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf, size_t length, int64_t offset, uv_fs_cb cb);UV_EXTERN int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path,uv_fs_cb cb);UV_EXTERN int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf, size_t length, int64_t offset, uv_fs_cb cb);UV_EXTERN int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, uv_fs_cb cb);UV_EXTERN int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path,uv_fs_cb cb);UV_EXTERN int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, uv_fs_cb cb);UV_EXTERN int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path,uv_fs_cb cb);UV_EXTERN int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file,uv_fs_cb cb);UV_EXTERN int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, uv_fs_cb cb);UV_EXTERN int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file,uv_fs_cb cb);UV_EXTERN int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file,uv_fs_cb cb);UV_EXTERN int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file,int64_t offset, uv_fs_cb cb);UV_EXTERN int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file out_fd,uv_file in_fd, int64_t in_offset, size_t length, uv_fs_cb cb);UV_EXTERN int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, uv_fs_cb cb);UV_EXTERN int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime, double mtime, uv_fs_cb cb);UV_EXTERN int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file file, double atime, double mtime, uv_fs_cb cb);UV_EXTERN int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path,uv_fs_cb cb);UV_EXTERN int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, uv_fs_cb cb);?
回調函數中應該調用?uv_fs_req_cleanup()?函數來釋放?uv_fs_t?參數占用的內存.
緩沖區與流(Buffers and Streams)
libuv 中基本的 I/O 工具是流(uv_stream_t). TCP 套接字, UDP 套接字, 文件, 管道, 和進程間通信都可以作為?流?的子類.
流?(Streams) 通過每個子類特定的函數來初始化, 然后可以通過如下函數進行操作:
int uv_read_start(uv_stream_t*, uv_alloc_cb alloc_cb, uv_read_cb read_cb); int uv_read_stop(uv_stream_t*); int uv_write(uv_write_t* req, uv_stream_t* handle,uv_buf_t bufs[], int bufcnt, uv_write_cb cb);?
基于流的函數比上面介紹的文件系統相關的函數更容易使用, libuv 在調用?uv_read_start?后會自動從流中讀取數據, 直到調用了?uv_read_stop.
用于保存數據的單元被抽象成了 buffer 結構 –?uv_buf_t. 它其實只保存了指向真實數據的指針(uv_buf_t.base) 以及真實數據的長度 (uv_buf_t.len).?uv_buf_t?本身是輕量級的, 通常作為值被傳遞給函數, 真正需要進行內存管理的是 buffer 結構中的指針所指向的真實數據, 通常由應用程序申請分配并釋放.
為了示范流的用法, 我們借助了(管道)?uv_pipe_t?, 這使得我們把本地文件變成了流[#]_. 下面是利用 libuv 實現的一個簡單的?tee?. 將所有的操作變成了異步方式后, 事件 I/O 的強大能力便展現出來. 兩個寫操作并不會阻塞對方, 但是我們必須小心地拷貝數據至緩沖區, 并確保在寫入數據之前緩沖區不被釋放.
該程序按照如下方式執行:
./uvtee <output_file>我們在指定的文件上打開了一個管道, libuv 的文件管道默認是雙向打開的.
int main(int argc, char **argv) {loop = uv_default_loop();uv_pipe_init(loop, &stdin_pipe, 0);uv_pipe_open(&stdin_pipe, 0);uv_pipe_init(loop, &stdout_pipe, 0);uv_pipe_open(&stdout_pipe, 1);uv_fs_t file_req; int fd = uv_fs_open(loop, &file_req, argv[1], O_CREAT | O_RDWR, 0644, NULL);uv_pipe_init(loop, &file_pipe, 0);uv_pipe_open(&file_pipe, fd);uv_read_start((uv_stream_t*)&stdin_pipe, alloc_buffer, read_stdin);uv_run(loop, UV_RUN_DEFAULT); return 0; }若是 IPC 或命名管道,?uv_pipe_init()?的第三個參數應該設置為 1, 我們會在?進程?一節對此作出詳細解釋. 調用?uv_pipe_open()?將文件描述符和文件關聯在了一起.
我們開始監控標準輸入?stdin. 回調函數?alloc_buffer?為程序開辟了一個新的緩沖區來容納新到來的數據.?read_stdin?也會被調用, 并且?uv_buf_t?作為調用參數.
uv_buf_t alloc_buffer(uv_handle_t *handle, size_t suggested_size) { return uv_buf_init((char*) malloc(suggested_size), suggested_size); } void read_stdin(uv_stream_t *stream, ssize_t nread, uv_buf_t buf) { if (nread == -1) { if (uv_last_error(loop).code == UV_EOF) {uv_close((uv_handle_t*)&stdin_pipe, NULL);uv_close((uv_handle_t*)&stdout_pipe, NULL);uv_close((uv_handle_t*)&file_pipe, NULL);}} else { if (nread > 0) {write_data((uv_stream_t*)&stdout_pipe, nread, buf, on_stdout_write);write_data((uv_stream_t*)&file_pipe, nread, buf, on_file_write);}} if (buf.base)free(buf.base); }?
此處使用標準的?malloc?已經可以足夠, 但是你也可以指定其他的內存分配策略. 例如, node.js 使用自己特定的 slab 分配器.
在任何情況下出錯, read 回調函數?nread?參數都為 -1. 出錯原因可能是 EOF(遇到文件尾), 在此種情況下我們使用 ‘’uv_close()’’ 函數關閉所有的流,?uv_close()?會根據所傳遞進來句柄的內部類型來自動處理. 如果沒有出現錯誤,?nread?是一個非負數, 意味著我們可以向輸出流中寫入?nread?字節的數據. 最后記住一點, 緩沖區 buffer 的分配和釋放是由應用程序負責的, 所以記得釋放不再使用的內存空間.
typedef struct {uv_write_t req;uv_buf_t buf; } write_req_t; void free_write_req(uv_write_t *req) {write_req_t *wr = (write_req_t*) req;free(wr->buf.base);free(wr); } void on_stdout_write(uv_write_t *req, int status) {free_write_req(req); } void on_file_write(uv_write_t *req, int status) {free_write_req(req); } void write_data(uv_stream_t *dest, size_t size, uv_buf_t buf, uv_write_cb callback) {write_req_t *req = (write_req_t*) malloc(sizeof(write_req_t));req->buf = uv_buf_init((char*) malloc(size), size);memcpy(req->buf.base, buf.base, size);uv_write((uv_write_t*) req, (uv_stream_t*)dest, &req->buf, 1, callback); }write_data()?將讀取的數據拷貝一份至緩沖區?req->buf.base, 同樣地, 當 write 完成后回調函數被調用時, 該緩沖區也并不會被傳遞到回調函數中, 所以, 為了繞過這一缺點, 我們將寫請求和緩沖區封裝在?write_req_t?結構體中, 然后在回調函數中解封該結構體來獲取相關參數.
文件變更事件(File change events)
現代操作系統都提供了 API 用來在單獨的文件或文件夾上設置監視器, 當文件被修改時應用程序會得到通知, libuv 也封裝了常用的文件變更通知程序庫?[1]. 這是 libuv 中最不一致的部分了, 文件變更通知系統本身在不同的系統中實現起來差別非常大, 因此讓所有的事情在每個平臺上都完美地工作將變得異常困難, 為了給出一個示例，我寫了一個簡單的工具, 該函數按照如下命令行運行， 并監視指定的文件.
./onchange?[file2] ...文件變更通知通過?uv_fs_event_init()?啟動:
while (argc-- > 2) {fprintf(stderr, "Adding watch on %s\n", argv[argc]);uv_fs_event_init(loop, (uv_fs_event_t*) malloc(sizeof(uv_fs_event_t)), argv[argc], run_command, 0);}第三個參數是實際監控的文件或者文件夾, 最后一個參數?flags?可取值如下:
UV_FS_EVENT_WATCH_ENTRY = 1,UV_FS_EVENT_STAT = 2,UV_FS_EVENT_RECURSIVE = 3?
若設置?UV_FS_EVENT_WATCH_ENTRY?和?UV_FS_EVENT_STAT?不做任何事情(目前). 設置了?UV_FS_EVENT_RECURSIVE?將會監視子文件夾(需 libuv 支持).
回調函數將接受以下參數:
字段是該監視器需要監視的文件.
在 Linux 和 Windows 平臺上可以是非?null.
int?flags?-?UV_RENAME?或?UV_CHANGE.
int?status?- 目前為 0.
我們的例子只是簡單地打印出參數, 并通過?system?函數運行指定命令.
void run_command(uv_fs_event_t *handle, const char *filename, int events, int status) {fprintf(stderr, "Change detected in %s: ", handle->filename); if (events == UV_RENAME)fprintf(stderr, "renamed"); if (events == UV_CHANGE)fprintf(stderr, "changed");fprintf(stderr, " %s\n", filename ? filename : "");system(command); }?
網絡
libuv 的網絡接口與 BSD 套接字接口存在很大的不同, 某些事情在 libuv 下變得更簡單了, 并且所有接口都是都是非阻塞的, 但是原則上還是一致的. 另外 libuv 也提供了一些工具類的函數抽象了一些讓人生厭的, 重復而底層的任務,比如使用 BSD 套接字結構來建立套接字, DNS 查詢, 或者其他各種參數的設置.
libuv 中在網絡 I/O 中使用了?uv_tcp_t?和?uv_udp_t?兩個結構體.
TCP
TCP 是一種面向連接的流式協議, 因此是基于 libuv 的流式基礎架構上的.
服務器(Server)
服務器端的 sockets 處理流程如下:
以下是一個簡單的 echo 服務器的例子:
int main() {loop = uv_default_loop();uv_tcp_t server;uv_tcp_init(loop, &server); struct sockaddr_in bind_addr = uv_ip4_addr("0.0.0.0", 7000);uv_tcp_bind(&server, bind_addr); int r = uv_listen((uv_stream_t*) &server, 128, on_new_connection); if (r) {fprintf(stderr, "Listen error %s\n", uv_err_name(uv_last_error(loop))); return 1;} return uv_run(loop, UV_RUN_DEFAULT); }你可以看到輔助函數?uv_ip4_addr?用來將人為可讀的字符串類型的 IP 地址和端口號轉換成 BSD 套接字 API 所需要的?struct?sockaddr_in?類型的結構. 逆變換可以使用?uv_ip4_name?來完成.
對于 IPv6 來說應該使用?uv_ip6_*?形式的函數.
大部分的設置(setup)函數都是普通函數, 因為他們都是?計算密集型(CPU-bound), 直到調用了?uv_listen?我們才回到 libuv 中回調函數風格.?uv_listen?的第二個參數 backlog 隊列長度 – 即連接隊列最大長度.
當客戶端發起了新的連接時, 回調函數需要為客戶端套接字設置一個監視器, 并調用?uv_accept?函數將客戶端套接字與新的監視器在關聯一起. 在例子中我們將從流中讀取數據.
void on_new_connection(uv_stream_t *server, int status) { if (status == -1) { // error! return;}uv_tcp_t *client = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));uv_tcp_init(loop, client); if (uv_accept(server, (uv_stream_t*) client) == 0) {uv_read_start((uv_stream_t*) client, alloc_buffer, echo_read);} else {uv_close((uv_handle_t*) client, NULL);} }剩余部分的函數與上一節流式例子中的代碼相似, 你可以在例子程序中找到具體代碼, 如果套接字不再使用記得調用?uv_close?關閉該套接字. 如果你不再接受連接, 你可以在?uv_listen?的回調函數中關閉套接字.
客戶端(Client)
在服務器端你需要調用 bind/listen/accept, 而在客戶端你只需要調用?uv_tcp_connect.?uv_tcp_connect?使用了與?uv_listen?風格相似的回調函數?uv_connect_cb?如下:
uv_tcp_t socket; uv_tcp_init(loop, &socket);uv_connect_t connect; struct sockaddr_in dest = uv_ip4_addr("127.0.0.1", 80);uv_tcp_connect(&connect, &socket, dest, on_connect);建立連接后會調用?on_connect.
UDP
User Datagram Protocol?提供了無連接, 不可靠網絡通信協議, 因此 libuv 并不提供流式 UDP 服務, 而是通過?uv_udp_t?結構體(用于接收)和?uv_udp_send_t?結構體(用于發送)以及相關的函數給開發人員提供了非阻塞的 UDP 服務. 所以, 真正讀寫 UDP 的函數與普通的流式讀寫非常相似.為了示范如何使用 UDP, 下面提供了一個簡單的例子用來從?DHCP?獲取 IP 地址. – DHCP 發現.
Note
你應該以?root?用戶運行?udp-dhcp, 因為該程序使用了端口號低于 1024 的端口.
uv_loop_t *loop; uv_udp_t send_socket; uv_udp_t recv_socket; int main() {loop = uv_default_loop();uv_udp_init(loop, &recv_socket); struct sockaddr_in recv_addr = uv_ip4_addr("0.0.0.0", 68);uv_udp_bind(&recv_socket, recv_addr, 0);uv_udp_recv_start(&recv_socket, alloc_buffer, on_read);uv_udp_init(loop, &send_socket);uv_udp_bind(&send_socket, uv_ip4_addr("0.0.0.0", 0), 0);uv_udp_set_broadcast(&send_socket, 1);uv_udp_send_t send_req;uv_buf_t discover_msg = make_discover_msg(&send_req); struct sockaddr_in send_addr = uv_ip4_addr("255.255.255.255", 67);uv_udp_send(&send_req, &send_socket, &discover_msg, 1, send_addr, on_send); return uv_run(loop, UV_RUN_DEFAULT); }0.0.0.0?地址可以綁定本機所有網口.?255.255.255.255?是廣播地址, 意味著網絡包可以發送給子網中所有網口, 端口?0?說明操作系統可以任意指定端口進行綁定.
首先我們在 68 號端口上設置了綁定本機所有網口的接收套接字(DHCP 客戶端), 并且設置了讀監視器. 然后我們利用相同的方法設置了一個用于發送消息的套接字. 并使用?uv_udp_send?在 67 號端口上(DHCP 服務器)發送?廣播消息.
設置廣播標志也是?必要?的, 不然你會得到?EACCES?錯誤?[1]. 發送的具體消息與本書無關, 如果你對此感興趣, 可以參考源碼. 若出錯, 則讀寫回調函數會收到 -1 狀態碼.
由于 UDP 套接字并不和特定的對等方保持連接, 所以 read 回調函數中將會收到用于標識發送者的額外信息. 如果緩沖區是由你自己的分配的, 并且不夠容納接收的數據, 則``flags`` 標志位可能是?UV_UDP_PARTIAL.?在這種情況下, 操作系統會丟棄不能容納的數據.?(這也是 UDP 為你提供的特性).
void on_read(uv_udp_t *req, ssize_t nread, uv_buf_t buf, struct sockaddr *addr, unsigned flags) { if (nread == -1) {fprintf(stderr, "Read error %s\n", uv_err_name(uv_last_error(loop)));uv_close((uv_handle_t*) req, NULL);free(buf.base); return;} char sender[17] = { 0 };uv_ip4_name((struct sockaddr_in*) addr, sender, 16);fprintf(stderr, "Recv from %s\n", sender); // ... DHCP specific code free(buf.base);uv_udp_recv_stop(req); }UDP 選項(UDP Options)
生存時間TTL(Time-to-live)
可以通過?uv_udp_set_ttl?來設置網絡數據包的生存時間(TTL).
僅使用 IPv6 協議
IPv6 套接字可以同時在 IPv4 和 IPv6 協議下進行通信. 如果你只想使用 IPv6 套接字, 在調用?uv_udp_bind6?[2]?時請傳遞?UV_UDP_IPV6ONLY?參數.
多播(Multicast)
套接字可以使用如下函數訂閱(取消訂閱)一個多播組:
UV_EXTERN int uv_udp_set_membership(uv_udp_t* handle, const char* multicast_addr, const char* interface_addr,uv_membership membership);membership?取值可以是?UV_JOIN_GROUP?或?UV_LEAVE_GROUP.
多播包的本地回路是默認開啟的?[3], 可以使用?uv_udp_set_multicast_loop?來開啟/關閉該特性.
多播包的生存時間可以使用?uv_udp_set_multicast_ttl?來設置.
DNS 查詢(Querying DNS)
libuv 提供了異步解析 DNS 的功能, 用于替代?getaddrinfo?[4]. 在回調函數中, 你可以在獲得的 IP 地址上執行普通的套接字操作. 讓我們通過一個簡單的 DNS 解析的例子來看看怎么連接?Freenode?吧:
int main() {loop = uv_default_loop(); struct addrinfo hints;hints.ai_family = PF_INET;hints.ai_socktype = SOCK_STREAM;hints.ai_protocol = IPPROTO_TCP;hints.ai_flags = 0;uv_getaddrinfo_t resolver;fprintf(stderr, "irc.freenode.net is... "); int r = uv_getaddrinfo(loop, &resolver, on_resolved, "irc.freenode.net", "6667", &hints); if (r) {fprintf(stderr, "getaddrinfo call error %s\n", uv_err_name(uv_last_error(loop))); return 1;} return uv_run(loop, UV_RUN_DEFAULT); }如果?uv_getaddrinfo?返回非零, 表示在建立連接時出錯, 你設置的回調函數不會被調用, 所有的參數將會在?uv_getaddrinfo?返回后被立即釋放. 有關?hostname,?servname?和?hints?結構體的文檔可以在?getaddrinfo?幫助頁面中找到.
在解析回調函數中, 你可以在?struct?addrinfo(s)?結構的鏈表中任取一個 IP. 這個例子也演示了如何使用?uv_tcp_connect. 你在回調函數中有必要調用?uv_freeaddrinfo.
void on_resolved(uv_getaddrinfo_t *resolver, int status, struct addrinfo *res) { if (status == -1) {fprintf(stderr, "getaddrinfo callback error %s\n", uv_err_name(uv_last_error(loop))); return;} char addr[17] = {'\0'};uv_ip4_name((struct sockaddr_in*) res->ai_addr, addr, 16);fprintf(stderr, "%s\n", addr);uv_connect_t *connect_req = (uv_connect_t*) malloc(sizeof(uv_connect_t));uv_tcp_t *socket = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));uv_tcp_init(loop, socket);connect_req->data = (void*) socket;uv_tcp_connect(connect_req, socket, *(struct sockaddr_in*) res->ai_addr, on_connect);uv_freeaddrinfo(res); }網絡接口(Network interfaces)
系統網絡接口信息可以通過調用?uv_interface_addresses?來獲得, 下面的示例程序將打印出機器上所有網絡接口的細節信息, 因此你可以獲知網口的哪些域的信息是可以得到的, 這在你的程序啟動時綁定 IP 很方便.
#include #include int main() { char buf[512];uv_interface_address_t *info; int count, i;uv_interface_addresses(&info, &count);i = count;printf("Number of interfaces: %d\n", count); while (i--) {uv_interface_address_t interface = info[i];printf("Name: %s\n", interface.name);printf("Internal? %s\n", interface.is_internal ? "Yes" : "No"); if (interface.address.address4.sin_family == AF_INET) {uv_ip4_name(&interface.address.address4, buf, sizeof(buf));printf("IPv4 address: %s\n", buf);} else if (interface.address.address4.sin_family == AF_INET6) {uv_ip6_name(&interface.address.address6, buf, sizeof(buf));printf("IPv6 address: %s\n", buf);}printf("\n");}uv_free_interface_addresses(info, count); return 0; }is_internal?對于回環接口來說為 true. 請注意如果物理網口使用了多個 IPv4/IPv6 地址, 那么它的名稱將會被多次報告, 因為每個地址都會報告一次.
總結
以上是生活随笔為你收集整理的库-libuv：概述的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Linux文件I/O编程（二）lseek
- 下一篇： 性能分析工具System Trace