nodejs的错误处理过程记录

﹏ヽ暗。殇╰゛Y 2022-10-15 00:42 2阅读 0赞

本文以连接错误ECONNREFUSED为例，看看nodejs对错误处理的过程。 假设我们有以下代码

1  
2  
1. const net = require('net');  
2. net.connect(\{port: 9999\})  
如果本机上没有监听9999端口，那么我们会得到以下输出。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
1. events.js:170  
2. throw er; // Unhandled 'error' event  
3. ^  
4.  
5. Error: connect ECONNREFUSED 127.0.0.1:9999  
6. at TCPConnectWrap.afterConnect \[as oncomplete\] (net.js:1088:14)  
7. Emitted 'error' event at:  
8. at emitErrorNT (internal/streams/destroy.js:91:8)  
9. at emitErrorAndCloseNT (internal/streams/destroy.js:59:3)  
10. at processTicksAndRejections (internal/process/task\_queues.js:81:17)  
我们简单看一下connect的调用流程。

1  
2  
3  
4  
5  
6  
7  
8  
1. const req = new TCPConnectWrap();  
2. req.oncomplete = afterConnect;  
3. req.address = address;  
4. req.port = port;  
5. req.localAddress = localAddress;  
6. req.localPort = localPort;  
7. // 开始三次握手建立连接  
8. err = self.\_handle.connect(req, address, port);  
接着我们看一下C++层connect的逻辑

1  
2  
3  
4  
1. err = req\_wrap->Dispatch(uv\_tcp\_connect,  
2. &wrap->handle\_,  
3. reinterpret\_cast<const sockaddr\*>(&addr),  
4. AfterConnect);  
C++层直接调用Libuv的uv\_tcp\_connect，并且设置回调是AfterConnect。接着我们看libuv的实现。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
1. do \{  
2. errno = 0;  
3. // 非阻塞调用  
4. r = connect(uv\_\_stream\_fd(handle), addr, addrlen);  
5. \} while (r == -1 && errno == EINTR);  
6. // 连接错误，判断错误码  
7. if (r == -1 && errno != 0) \{  
8. // 还在连接中，不是错误，等待连接完成，事件变成可读  
9. if (errno == EINPROGRESS)  
10. ; /\* not an error \*/  
11. else if (errno == ECONNREFUSED)  
12. // 连接被拒绝  
13. handle->delayed\_error = UV\_\_ERR(ECONNREFUSED);  
14. else  
15. return UV\_\_ERR(errno);  
16. \}  
17. uv\_\_req\_init(handle->loop, req, UV\_CONNECT);  
18. req->cb = cb;  
19. req->handle = (uv\_stream\_t\*) handle;  
20. QUEUE\_INIT(&req->queue);  
21. // 挂载到handle，等待可写事件  
22. handle->connect\_req = req;  
23. uv\_\_io\_start(handle->loop, &handle->io\_watcher, POLLOUT);  
我们看到Libuv以异步的方式调用操作系统，然后把request挂载到handle中，并且注册等待可写事件，当连接失败的时候，就会执行uv stream\_io回调，我们看一下Libuv的处理（uv stream\_io）。

1  
2  
3  
4  
5  
6  
7  
8  
1. getsockopt(uv\_\_stream\_fd(stream),  
2. SOL\_SOCKET,  
3. SO\_ERROR,  
4. &error,  
5. &errorsize);  
6. error = UV\_\_ERR(error);  
7. if (req->cb)  
8. req->cb(req, error);  
获取错误信息后回调C++层的AfterConnect。

1  
2  
3  
4  
5  
6  
7  
8  
9  
1. Local<Value> argv\[5\] = \{  
2. Integer::New(env->isolate(), status),  
3. wrap->object(),  
4. req\_wrap->object(),  
5. Boolean::New(env->isolate(), readable),  
6. Boolean::New(env->isolate(), writable)  
7. \};  
8.  
9. req\_wrap->MakeCallback(env->oncomplete\_string(), arraysize(argv), argv);  
接着调用JS层的oncomplete回调。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
1. const ex = exceptionWithHostPort(status,  
2. 'connect',  
3. req.address,  
4. req.port,  
5. details);  
6. if (details) \{  
7. ex.localAddress = req.localAddress;  
8. ex.localPort = req.localPort;  
9. \}  
10. // 销毁socket  
11. self.destroy(ex);  
exceptionWithHostPort构造错误信息，然后销毁socket并且以ex为参数触发error事件。我们看看uvExceptionWithHostPort的实现。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
1. function uvExceptionWithHostPort(err, syscall, address, port) \{  
2. const \[ code, uvmsg \] = uvErrmapGet(err) || uvUnmappedError;  
3. const message = \`$\{syscall\} $\[code\]: $\{uvmsg\}\`;  
4. let details = '';  
5.  
6. if (port && port > 0) \{  
7. details = \` $\{address\}:$\{port\}\`;  
8. \} else if (address) \{  
9. details = \` $\{address\}\`;  
10. \}  
11. const tmpLimit = Error.stackTraceLimit;  
12. Error.stackTraceLimit = 0;  
13. const ex = new Error(\`$\{message\}$\{details\}\`);  
14. Error.stackTraceLimit = tmpLimit;  
15. ex.code = code;  
16. ex.errno = err;  
17. ex.syscall = syscall;  
18. ex.address = address;  
19. if (port) \{  
20. ex.port = port;  
21. \}  
22. // 获取调用栈信息但不包括当前调用的函数uvExceptionWithHostPort，注入stack字段到ex中  
23. Error.captureStackTrace(ex, excludedStackFn || uvExceptionWithHostPort);  
24. return ex;  
25. \}  
我们看到错误信息主要通过uvErrmapGet获取

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
1. function uvErrmapGet(name) \{  
2. uvBinding = lazyUv();  
3. if (!uvBinding.errmap) \{  
4. uvBinding.errmap = uvBinding.getErrorMap();  
5. \}  
6. return uvBinding.errmap.get(name);  
7. \}  
8.  
9. function lazyUv() \{  
10. if (!uvBinding) \{  
11. uvBinding = internalBinding('uv');  
12. \}  
13. return uvBinding;  
14. \}  
继续往下看，uvErrmapGet调用了C++层的uv模块的getErrorMap。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
1. void GetErrMap(const FunctionCallbackInfo<Value>& args) \{  
2. Environment\* env = Environment::GetCurrent(args);  
3. Isolate\* isolate = env->isolate();  
4. Local<Context> context = env->context();  
5.  
6. Local<Map> err\_map = Map::New(isolate);  
7. // 从per\_process::uv\_errors\_map中获取错误信息  
8. size\_t errors\_len = arraysize(per\_process::uv\_errors\_map);  
9. // 赋值  
10. for (size\_t i = 0; i < errors\_len; ++i) \{  
11. // map的键是 uv\_errors\_map每个元素中的value，值是name和message  
12. const auto& error = per\_process::uv\_errors\_map\[i\];  
13. Local<Value> arr\[\] = \{OneByteString(isolate, error.name),  
14. OneByteString(isolate, error.message)\};  
15. if (err\_map  
16. ->Set(context,  
17. Integer::New(isolate, error.value),  
18. Array::New(isolate, arr, arraysize(arr)))  
19. .IsEmpty()) \{  
20. return;  
21. \}  
22. \}  
23.  
24. args.GetReturnValue().Set(err\_map);  
25. \}  
我们看到错误信息存在per\_process::uv\_errors\_map中，我们看一下uv\_errors\_map的定义。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
1. struct UVError \{  
2. int value;  
3. const char\* name;  
4. const char\* message;  
5. \};  
6.  
7. static const struct UVError uv\_errors\_map\[\] = \{  
8. \#define V(name, message) \{UV\_\#\#name, \#name, message\},  
9. UV\_ERRNO\_MAP(V)  
10. \#undef V  
11. \};  
UV\_ERRNO\_MAP宏展开后如下

1  
2  
3  
4  
1. \{UV\_E2BIG, "E2BIG", "argument list too long"\},  
2. \{UV\_EACCES, "EACCES", "permission denied"\},  
3. \{UV\_EADDRINUSE, "EADDRINUSE", "address already in use"\},  
4. ……  
所以导出到JS层的结果如下

1  
2  
3  
4  
5  
6  
1. \{  
2. // 键是一个数字，由Libuv定义，其实是封装了操作系统的定义  
3. UV\_ECONNREFUSED: \["ECONNREFUSED", "connection refused"\],  
4. UV\_ECONNRESET: \["ECONNRESET", "connection reset by peer"\]  
5. ...  
6. \}  
Node.js最后会组装这些信息返回给调用方。这就是我们输出的错误信息。那么为什么会是ECONNREFUSED呢？我们看一下操作系统对于该错误码的逻辑。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
1. static void tcp\_reset(struct sock \*sk)  
2. \{  
3. switch (sk->sk\_state) \{  
4. case TCP\_SYN\_SENT:  
5. sk->sk\_err = ECONNREFUSED;  
6. break;  
7. // ...  
8. \}  
9.  
10. \}  
当操作系统收到一个发给该socket的rst包的时候会执行tcp\_reset，我们看到当socket处于发送syn包等待ack的时候，如果收到一个fin包，则会设置错误码为ECONNREFUSED。我们输出的正是这个错误码。