From 0c401e87d86edef873ca1a9d6d88bcb6aadf81a8 Mon Sep 17 00:00:00 2001
From: XadillaX <i@2333.moe>
Date: Tue, 9 Apr 2019 17:22:58 +0800
Subject: [PATCH 1/2] process: add libuvHandlesCount()

This method is to count libuv handles of current tick.
---
 doc/api/process.md                            | 25 +++++++++++++
 lib/internal/bootstrap/node.js                | 30 ++++++++++++++++
 src/node_process_methods.cc                   | 36 +++++++++++++++++++
 .../test-process-libuv-handles-count.js       | 17 +++++++++
 4 files changed, 108 insertions(+)
 create mode 100644 test/parallel/test-process-libuv-handles-count.js

diff --git a/doc/api/process.md b/doc/api/process.md
index 888c0af660568c..4ad90eff144987 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -1400,6 +1400,30 @@ process.kill(process.pid, 'SIGHUP');
 When `SIGUSR1` is received by a Node.js process, Node.js will start the
 debugger. See [Signal Events][].
 
+## process.LIBUV\_HANDLE\_TYPES
+
+This object indicates type enums for [libuv handles][] types.
+
+## process.libuvHandlesCount()
+
+Get [libuv handles][] count for current tick.
+
+The returned object contains two fileds:
+
+```js
+{
+  total: <TOTAL_COUNT>,
+  each: [ <TYPE_1_COUNT>, <TYPE_2_COUNT>, ... ]
+}
+```
+
+You may get type enum via `process.LIBUV_HANDLE_TYPES`. e.g.
+
+```js
+const result = process.libuvHandlesCount();
+result.each[process.LIBUV_HANDLE_TYPES.ASYNC]; // count of `uv_async_t`
+```
+
 ## process.mainModule
 <!-- YAML
 added: v0.1.17
@@ -2328,3 +2352,4 @@ cases:
 [process_emit_warning]: #process_process_emitwarning_warning_type_code_ctor
 [process_warning]: #process_event_warning
 [report documentation]: report.html
+[libuv handles]: http://docs.libuv.org/en/v1.x/handle.html
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index a9fff289371e91..5481d6a2e9a5e4 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -66,9 +66,39 @@ if (ownsProcessState) {
 // process.config is serialized config.gypi
 process.config = JSON.parse(internalBinding('native_module').config);
 
+function libuvHandlesCount() {
+  const arr = rawMethods.libuvHandlesCount();
+  return {
+    total: arr.reduce((sum, v) => sum + v, 0),
+    each: arr,
+  };
+}
+
+process.LIBUV_HANDLE_TYPES = {
+  UNKNOWN_HANDLE: 0,
+  ASYNC: 1,
+  CHECK: 2,
+  FS_EVENT: 3,
+  FS_POLL: 4,
+  HANDLE: 5,
+  IDLE: 6,
+  NAMED_PIPE: 7,
+  POLL: 8,
+  PREPARE: 9,
+  PROCESS: 10,
+  STREAM: 11,
+  TCP: 12,
+  TIMER: 13,
+  TTY: 14,
+  UDP: 15,
+  SIGNAL: 16,
+  FILE: 17,
+};
+
 const rawMethods = internalBinding('process_methods');
 // Set up methods and events on the process object for the main thread
 if (isMainThread) {
+  process.libuvHandlesCount = libuvHandlesCount;
   process.abort = rawMethods.abort;
   const wrapped = mainThreadSetup.wrapProcessMethods(rawMethods);
   process.umask = wrapped.umask;
diff --git a/src/node_process_methods.cc b/src/node_process_methods.cc
index e53a5a7015c8e3..75ed4ca443c680 100644
--- a/src/node_process_methods.cc
+++ b/src/node_process_methods.cc
@@ -28,6 +28,10 @@ typedef int mode_t;
 #include <termios.h>  // tcgetattr, tcsetattr
 #endif
 
+typedef std::vector<uv_handle_t*> libuv_handle_array;
+unsigned int _libuv_handles_each_count[UV_HANDLE_TYPE_MAX];
+unsigned int _libuv_handles_each_count_size = sizeof(unsigned int) * UV_HANDLE_TYPE_MAX;
+
 namespace node {
 
 using v8::Array;
@@ -399,6 +403,37 @@ static void ReallyExit(const FunctionCallbackInfo<Value>& args) {
   env->Exit(code);
 }
 
+void uv_handle_count_walk(uv_handle_t* handle, void* arg)
+{
+    libuv_handle_array* array = (libuv_handle_array*)arg;
+    array->push_back(handle);
+}
+
+static void LibuvCount(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = env->isolate();
+
+  uv_handle_type temp_type;
+  libuv_handle_array handles;
+  uv_walk(env->event_loop(), uv_handle_count_walk, (void*)&handles);
+
+  memset(_libuv_handles_each_count, 0, _libuv_handles_each_count_size);
+  for (unsigned int i = 0; i < handles.size(); i++) {
+    temp_type = handles[i]->type;
+    if(temp_type >= UV_HANDLE_TYPE_MAX || temp_type < 0) {
+      temp_type = UV_UNKNOWN_HANDLE;
+    }
+    _libuv_handles_each_count[(unsigned int)temp_type]++;
+  }
+
+  std::vector<Local<Value>> result(UV_HANDLE_TYPE_MAX);
+  for (unsigned int i = 0; i < UV_HANDLE_TYPE_MAX; i++) {
+    result[i] = Number::New(isolate, _libuv_handles_each_count[i]);
+  }
+
+  args.GetReturnValue().Set(Array::New(isolate, result.data(), result.size()));
+}
+
 static void InitializeProcessMethods(Local<Object> target,
                                      Local<Value> unused,
                                      Local<Context> context,
@@ -428,6 +463,7 @@ static void InitializeProcessMethods(Local<Object> target,
   env->SetMethod(target, "_getActiveHandles", GetActiveHandles);
   env->SetMethod(target, "_kill", Kill);
 
+  env->SetMethod(target, "libuvHandlesCount", LibuvCount);
   env->SetMethodNoSideEffect(target, "cwd", Cwd);
   env->SetMethod(target, "dlopen", binding::DLOpen);
   env->SetMethod(target, "reallyExit", ReallyExit);
diff --git a/test/parallel/test-process-libuv-handles-count.js b/test/parallel/test-process-libuv-handles-count.js
new file mode 100644
index 00000000000000..437e435b20fe93
--- /dev/null
+++ b/test/parallel/test-process-libuv-handles-count.js
@@ -0,0 +1,17 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+if (!common.isMainThread)
+  common.skip('process.libuvHandlesCount is not available in Workers');
+
+const count = process.libuvHandlesCount();
+
+assert(typeof count.total === 'number');
+assert(count.each.length === 18);
+
+const sum = count.each.reduce((sum, c) => sum + c, 0);
+assert(sum === count.total);

From a9fb4db2a93d07b314d03d21c4ab63d087b83929 Mon Sep 17 00:00:00 2001
From: XadillaX <i@2333.moe>
Date: Tue, 9 Apr 2019 23:53:44 +0800
Subject: [PATCH 2/2] fix lint

---
 doc/api/process.md                                |  4 ++--
 src/node_process_methods.cc                       | 15 +++++++++------
 test/parallel/test-process-libuv-handles-count.js |  8 +++-----
 3 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/doc/api/process.md b/doc/api/process.md
index 4ad90eff144987..b3c98e9e3daada 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -1410,7 +1410,7 @@ Get [libuv handles][] count for current tick.
 
 The returned object contains two fileds:
 
-```js
+```json
 {
   total: <TOTAL_COUNT>,
   each: [ <TYPE_1_COUNT>, <TYPE_2_COUNT>, ... ]
@@ -1421,7 +1421,7 @@ You may get type enum via `process.LIBUV_HANDLE_TYPES`. e.g.
 
 ```js
 const result = process.libuvHandlesCount();
-result.each[process.LIBUV_HANDLE_TYPES.ASYNC]; // count of `uv_async_t`
+result.each[process.LIBUV_HANDLE_TYPES.ASYNC]; // Count of `uv_async_t`
 ```
 
 ## process.mainModule
diff --git a/src/node_process_methods.cc b/src/node_process_methods.cc
index 75ed4ca443c680..67bf21d70fa0f5 100644
--- a/src/node_process_methods.cc
+++ b/src/node_process_methods.cc
@@ -30,7 +30,8 @@ typedef int mode_t;
 
 typedef std::vector<uv_handle_t*> libuv_handle_array;
 unsigned int _libuv_handles_each_count[UV_HANDLE_TYPE_MAX];
-unsigned int _libuv_handles_each_count_size = sizeof(unsigned int) * UV_HANDLE_TYPE_MAX;
+unsigned int _libuv_handles_each_count_size =
+    sizeof(unsigned int) * UV_HANDLE_TYPE_MAX;
 
 namespace node {
 
@@ -403,9 +404,8 @@ static void ReallyExit(const FunctionCallbackInfo<Value>& args) {
   env->Exit(code);
 }
 
-void uv_handle_count_walk(uv_handle_t* handle, void* arg)
-{
-    libuv_handle_array* array = (libuv_handle_array*)arg;
+void uv_handle_count_walk(uv_handle_t* handle, void* arg) {
+    libuv_handle_array* array = reinterpret_cast<libuv_handle_array*>arg;
     array->push_back(handle);
 }
 
@@ -415,12 +415,15 @@ static void LibuvCount(const FunctionCallbackInfo<Value>& args) {
 
   uv_handle_type temp_type;
   libuv_handle_array handles;
-  uv_walk(env->event_loop(), uv_handle_count_walk, (void*)&handles);
+  uv_walk(
+      env->event_loop(),
+      uv_handle_count_walk,
+      reinterpret_cast<void*>&handles);
 
   memset(_libuv_handles_each_count, 0, _libuv_handles_each_count_size);
   for (unsigned int i = 0; i < handles.size(); i++) {
     temp_type = handles[i]->type;
-    if(temp_type >= UV_HANDLE_TYPE_MAX || temp_type < 0) {
+    if (temp_type >= UV_HANDLE_TYPE_MAX || temp_type < 0) {
       temp_type = UV_UNKNOWN_HANDLE;
     }
     _libuv_handles_each_count[(unsigned int)temp_type]++;
diff --git a/test/parallel/test-process-libuv-handles-count.js b/test/parallel/test-process-libuv-handles-count.js
index 437e435b20fe93..d9b86a6cd460cf 100644
--- a/test/parallel/test-process-libuv-handles-count.js
+++ b/test/parallel/test-process-libuv-handles-count.js
@@ -2,16 +2,14 @@
 
 const common = require('../common');
 const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
 
 if (!common.isMainThread)
   common.skip('process.libuvHandlesCount is not available in Workers');
 
 const count = process.libuvHandlesCount();
 
-assert(typeof count.total === 'number');
-assert(count.each.length === 18);
+assert.strictEqual(typeof count.total, 'number');
+assert.strictEqual(count.each.length, 18);
 
 const sum = count.each.reduce((sum, c) => sum + c, 0);
-assert(sum === count.total);
+assert.strictEqual(sum, count.total);