Nodejs error handling process record

1. const net = require('net');  
2. net.connect({port: 9999})

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)

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. // Start three-way handshake to establish connection 8. err = self._handle.connect(req, address, port);

1. err = req_wrap->Dispatch(uv_tcp_connect,  
2. &wrap->handle_,  
3. reinterpret_cast<const sockaddr*>(&addr),  
4. AfterConnect);

1. do {  
2. errno = 0;  
3. // Non-blocking call 4. r = connect(uv__stream_fd(handle), addr, addrlen);  
5. } while (r == -1 && errno == EINTR);  
6. // Connection error, determine the error code 7. if (r == -1 && errno != 0) {  
8. // Still connecting, not an error, waiting for the connection to complete and the event to become readable 9. if (errno == EINPROGRESS)  
10. ; /* not an error */  
11. else if (errno == ECONNREFUSED)  
12. // Connection refused 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. // Mount to handle and wait for writable event 22. handle->connect_req = req;  
23. uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);

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

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

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. // Destroy the socket  
11. self.destroy(ex);

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;  
twenty one. }  
22. // Get the call stack information but exclude the currently called function uvExceptionWithHostPort, and inject the stack field into ex23. Error.captureStackTrace(ex, excludedStackFn || uvExceptionWithHostPort);  
24. return ex;  
25. }

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. }

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. // Get error information from per_process::uv_errors_map8. size_t errors_len = arraysize(per_process::uv_errors_map);  
9. // Assignment 10. for (size_t i = 0; i < errors_len; ++i) {  
11. // The key of the map is the value in each element of uv_errors_map, and the value is name and 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;  
twenty one. }  
twenty two. }  
twenty three.   
24. args.GetReturnValue().Set(err_map);  
25. }

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

1. {UV_E2BIG, "E2BIG", "argument list too long"},  
2. {UV_EACCES, "EACCES", "permission denied"},  
3. {UV_EADDRINUSE, "EADDRINUSE", "address already in use"},  
4. …

1. {  
2. // The key is a number, defined by Libuv, which actually encapsulates the definition of the operating system 3. UV_ECONNREFUSED: ["ECONNREFUSED", "connection refused"],    
4. UV_ECONNRESET: ["ECONNRESET", "connection reset by peer"]   
5. ...   
6. }

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. }