@encharm/cws 4.3.0 → 4.4.1

package/src/headers/20/histogram-inl.h

@@ -0,0 +1,107 @@
+#ifndef SRC_HISTOGRAM_INL_H_
+#define SRC_HISTOGRAM_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "histogram.h"
+#include "base_object-inl.h"
+#include "node_internals.h"
+
+namespace node {
+
+void Histogram::Reset() {
+  Mutex::ScopedLock lock(mutex_);
+  hdr_reset(histogram_.get());
+  exceeds_ = 0;
+  count_ = 0;
+  prev_ = 0;
+}
+
+double Histogram::Add(const Histogram& other) {
+  Mutex::ScopedLock lock(mutex_);
+  count_ += other.count_;
+  exceeds_ += other.exceeds_;
+  if (other.prev_ > prev_)
+    prev_ = other.prev_;
+  return static_cast<double>(hdr_add(histogram_.get(), other.histogram_.get()));
+}
+
+size_t Histogram::Count() const {
+  Mutex::ScopedLock lock(mutex_);
+  return count_;
+}
+
+int64_t Histogram::Min() const {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_min(histogram_.get());
+}
+
+int64_t Histogram::Max() const {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_max(histogram_.get());
+}
+
+double Histogram::Mean() const {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_mean(histogram_.get());
+}
+
+double Histogram::Stddev() const {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_stddev(histogram_.get());
+}
+
+int64_t Histogram::Percentile(double percentile) const {
+  Mutex::ScopedLock lock(mutex_);
+  CHECK_GT(percentile, 0);
+  CHECK_LE(percentile, 100);
+  return hdr_value_at_percentile(histogram_.get(), percentile);
+}
+
+template <typename Iterator>
+void Histogram::Percentiles(Iterator&& fn) {
+  Mutex::ScopedLock lock(mutex_);
+  hdr_iter iter;
+  hdr_iter_percentile_init(&iter, histogram_.get(), 1);
+  while (hdr_iter_next(&iter)) {
+    double key = iter.specifics.percentiles.percentile;
+    fn(key, iter.value);
+  }
+}
+
+bool Histogram::Record(int64_t value) {
+  Mutex::ScopedLock lock(mutex_);
+  bool recorded = hdr_record_value(histogram_.get(), value);
+  if (!recorded)
+    exceeds_++;
+  else
+    count_++;
+  return recorded;
+}
+
+uint64_t Histogram::RecordDelta() {
+  Mutex::ScopedLock lock(mutex_);
+  uint64_t time = uv_hrtime();
+  int64_t delta = 0;
+  if (prev_ > 0) {
+    CHECK_GE(time, prev_);
+    delta = time - prev_;
+    if (hdr_record_value(histogram_.get(), delta))
+      count_++;
+    else
+      exceeds_++;
+  }
+  prev_ = time;
+  return delta;
+}
+
+size_t Histogram::GetMemorySize() const {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_get_memory_size(histogram_.get());
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_HISTOGRAM_INL_H_

package/src/headers/20/histogram.h

@@ -0,0 +1,240 @@
+#ifndef SRC_HISTOGRAM_H_
+#define SRC_HISTOGRAM_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <hdr/hdr_histogram.h>
+#include "base_object.h"
+#include "memory_tracker.h"
+#include "node_messaging.h"
+#include "util.h"
+#include "uv.h"
+#include "v8.h"
+
+#include <functional>
+#include <limits>
+#include <map>
+#include <string>
+
+namespace node {
+
+class ExternalReferenceRegistry;
+
+constexpr int kDefaultHistogramFigures = 3;
+
+class Histogram : public MemoryRetainer {
+ public:
+  struct Options {
+    int64_t lowest = 1;
+    int64_t highest = std::numeric_limits<int64_t>::max();
+    int figures = kDefaultHistogramFigures;
+  };
+
+  explicit Histogram(const Options& options);
+  virtual ~Histogram() = default;
+
+  inline bool Record(int64_t value);
+  inline void Reset();
+  inline int64_t Min() const;
+  inline int64_t Max() const;
+  inline double Mean() const;
+  inline double Stddev() const;
+  inline int64_t Percentile(double percentile) const;
+  inline size_t Exceeds() const { return exceeds_; }
+  inline size_t Count() const;
+
+  inline uint64_t RecordDelta();
+
+  inline double Add(const Histogram& other);
+
+  // Iterator is a function type that takes two doubles as argument, one for
+  // percentile and one for the value at that percentile.
+  template <typename Iterator>
+  inline void Percentiles(Iterator&& fn);
+
+  inline size_t GetMemorySize() const;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(Histogram)
+  SET_SELF_SIZE(Histogram)
+
+ private:
+  using HistogramPointer = DeleteFnPtr<hdr_histogram, hdr_close>;
+  HistogramPointer histogram_;
+  uint64_t prev_ = 0;
+  size_t exceeds_ = 0;
+  size_t count_ = 0;
+  Mutex mutex_;
+};
+
+class HistogramImpl {
+ public:
+  explicit HistogramImpl(
+      const Histogram::Options& options = Histogram::Options {});
+  explicit HistogramImpl(std::shared_ptr<Histogram> histogram);
+
+  Histogram* operator->() { return histogram_.get(); }
+
+  const std::shared_ptr<Histogram>& histogram() const { return histogram_; }
+
+ private:
+  std::shared_ptr<Histogram> histogram_;
+};
+
+class HistogramBase : public BaseObject, public HistogramImpl {
+ public:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      IsolateData* isolate_data);
+  static void Initialize(IsolateData* isolate_data,
+                         v8::Local<v8::ObjectTemplate> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static BaseObjectPtr<HistogramBase> Create(
+      Environment* env,
+      const Histogram::Options& options = Histogram::Options {});
+
+  static BaseObjectPtr<HistogramBase> Create(
+      Environment* env,
+      std::shared_ptr<Histogram> histogram);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(HistogramBase)
+  SET_SELF_SIZE(HistogramBase)
+
+  static void GetCountBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMinBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMaxBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceedsBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void GetCount(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMax(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMean(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceeds(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetStddev(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentile(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentileBigInt(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentiles(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentilesBigInt(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Record(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RecordDelta(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Add(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  HistogramBase(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      const Histogram::Options& options = Histogram::Options {});
+
+  HistogramBase(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      std::shared_ptr<Histogram> histogram);
+
+  TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  class HistogramTransferData : public worker::TransferData {
+   public:
+    explicit HistogramTransferData(const HistogramBase* histogram)
+        : histogram_(histogram->histogram()) {}
+
+    explicit HistogramTransferData(std::shared_ptr<Histogram> histogram)
+        : histogram_(std::move(histogram)) {}
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<worker::TransferData> self) override;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(HistogramTransferData)
+    SET_SELF_SIZE(HistogramTransferData)
+
+   private:
+    std::shared_ptr<Histogram> histogram_;
+  };
+};
+
+class IntervalHistogram : public HandleWrap, public HistogramImpl {
+ public:
+  enum class StartFlags {
+    NONE,
+    RESET
+  };
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+
+  static BaseObjectPtr<IntervalHistogram> Create(
+      Environment* env,
+      int32_t interval,
+      std::function<void(Histogram&)> on_interval,
+      const Histogram::Options& options);
+
+  IntervalHistogram(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      AsyncWrap::ProviderType type,
+      int32_t interval,
+      std::function<void(Histogram&)> on_interval,
+      const Histogram::Options& options = Histogram::Options {});
+
+  static void GetCountBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMinBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMaxBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceedsBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void GetCount(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMax(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMean(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceeds(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetStddev(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentile(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentileBigInt(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentiles(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentilesBigInt(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(IntervalHistogram)
+  SET_SELF_SIZE(IntervalHistogram)
+
+ private:
+  static void TimerCB(uv_timer_t* handle);
+  void OnStart(StartFlags flags = StartFlags::RESET);
+  void OnStop();
+
+  bool enabled_ = false;
+  int32_t interval_ = 0;
+  std::function<void(Histogram&)> on_interval_;
+  uv_timer_t timer_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_HISTOGRAM_H_

package/src/headers/20/inspector_agent.h

@@ -0,0 +1,144 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include "node_options.h"
+#include "v8.h"
+
+#include <cstddef>
+#include <memory>
+
+namespace v8_inspector {
+class StringView;
+}  // namespace v8_inspector
+
+namespace node {
+// Forward declaration to break recursive dependency chain with src/env.h.
+class Environment;
+struct ContextInfo;
+
+namespace inspector {
+class InspectorIo;
+class ParentInspectorHandle;
+class NodeInspectorClient;
+class WorkerManager;
+
+class InspectorSession {
+ public:
+  virtual ~InspectorSession() = default;
+  virtual void Dispatch(const v8_inspector::StringView& message) = 0;
+};
+
+class InspectorSessionDelegate {
+ public:
+  virtual ~InspectorSessionDelegate() = default;
+  virtual void SendMessageToFrontend(const v8_inspector::StringView& message)
+                                     = 0;
+};
+
+class Agent {
+ public:
+  explicit Agent(node::Environment* env);
+  ~Agent();
+
+  // Create client_, may create io_ if option enabled
+  bool Start(const std::string& path,
+             const DebugOptions& options,
+             std::shared_ptr<ExclusiveAccess<HostPort>> host_port,
+             bool is_main);
+  // Stop and destroy io_
+  void Stop();
+
+  bool IsListening() { return io_ != nullptr; }
+  // Returns true if the Node inspector is actually in use. It will be true
+  // if either the user explicitly opted into inspector (e.g. with the
+  // --inspect command line flag) or if inspector JS API had been used.
+  bool IsActive();
+
+  // Blocks till frontend connects and sends "runIfWaitingForDebugger"
+  void WaitForConnect();
+  // Blocks till all the sessions with "WaitForDisconnectOnShutdown" disconnect
+  void WaitForDisconnect();
+  void ReportUncaughtException(v8::Local<v8::Value> error,
+                               v8::Local<v8::Message> message);
+
+  // Async stack traces instrumentation.
+  void AsyncTaskScheduled(const v8_inspector::StringView& taskName, void* task,
+                          bool recurring);
+  void AsyncTaskCanceled(void* task);
+  void AsyncTaskStarted(void* task);
+  void AsyncTaskFinished(void* task);
+  void AllAsyncTasksCanceled();
+
+  void RegisterAsyncHook(v8::Isolate* isolate,
+    v8::Local<v8::Function> enable_function,
+    v8::Local<v8::Function> disable_function);
+  void EnableAsyncHook();
+  void DisableAsyncHook();
+
+  void SetParentHandle(std::unique_ptr<ParentInspectorHandle> parent_handle);
+  std::unique_ptr<ParentInspectorHandle> GetParentHandle(
+      uint64_t thread_id, const std::string& url, const std::string& name);
+
+  // Called to create inspector sessions that can be used from the same thread.
+  // The inspector responds by using the delegate to send messages back.
+  std::unique_ptr<InspectorSession> Connect(
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
+
+  // Called from the worker to create inspector sessions that is connected
+  // to the main thread.
+  // The inspector responds by using the delegate to send messages back.
+  std::unique_ptr<InspectorSession> ConnectToMainThread(
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
+
+  void PauseOnNextJavascriptStatement(const std::string& reason);
+
+  std::string GetWsUrl() const;
+
+  // Can only be called from the main thread.
+  bool StartIoThread();
+
+  // Calls StartIoThread() from off the main thread.
+  void RequestIoThreadStart();
+
+  const DebugOptions& options() { return debug_options_; }
+  std::shared_ptr<ExclusiveAccess<HostPort>> host_port() { return host_port_; }
+  void ContextCreated(v8::Local<v8::Context> context, const ContextInfo& info);
+
+  // Interface for interacting with inspectors in worker threads
+  std::shared_ptr<WorkerManager> GetWorkerManager();
+
+  inline Environment* env() const { return parent_env_; }
+
+ private:
+  void ToggleAsyncHook(v8::Isolate* isolate, v8::Local<v8::Function> fn);
+
+  node::Environment* parent_env_;
+  // Encapsulates majority of the Inspector functionality
+  std::shared_ptr<NodeInspectorClient> client_;
+  // Interface for transports, e.g. WebSocket server
+  std::unique_ptr<InspectorIo> io_;
+  std::unique_ptr<ParentInspectorHandle> parent_handle_;
+  std::string path_;
+
+  // This is a copy of the debug options parsed from CLI in the Environment.
+  // Do not use the host_port in that, instead manipulate the shared host_port_
+  // pointer which is meant to store the actual host and port of the inspector
+  // server.
+  DebugOptions debug_options_;
+  std::shared_ptr<ExclusiveAccess<HostPort>> host_port_;
+
+  bool pending_enable_async_hook_ = false;
+  bool pending_disable_async_hook_ = false;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/20/inspector_io.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include "inspector_socket_server.h"
+#include "node_mutex.h"
+
+#include "uv.h"
+
+#include <cstddef>
+#include <memory>
+
+namespace node {
+// Forward declaration to break recursive dependency chain with src/env.h.
+class Environment;
+namespace inspector {
+
+class MainThreadHandle;
+class RequestQueue;
+
+class InspectorIo {
+ public:
+  // Start the inspector agent thread, waiting for it to initialize
+  // bool Start();
+  // Returns empty pointer if thread was not started
+  static std::unique_ptr<InspectorIo> Start(
+      std::shared_ptr<MainThreadHandle> main_thread,
+      const std::string& path,
+      std::shared_ptr<ExclusiveAccess<HostPort>> host_port,
+      const InspectPublishUid& inspect_publish_uid);
+
+  // Will block till the transport thread shuts down
+  ~InspectorIo();
+
+  void StopAcceptingNewConnections();
+  std::string GetWsUrl() const;
+
+ private:
+  InspectorIo(std::shared_ptr<MainThreadHandle> handle,
+              const std::string& path,
+              std::shared_ptr<ExclusiveAccess<HostPort>> host_port,
+              const InspectPublishUid& inspect_publish_uid);
+
+  // Wrapper for agent->ThreadMain()
+  static void ThreadMain(void* agent);
+
+  // Runs a uv_loop_t
+  void ThreadMain();
+
+  // This is a thread-safe object that will post async tasks. It lives as long
+  // as an Inspector object lives (almost as long as an Isolate).
+  std::shared_ptr<MainThreadHandle> main_thread_;
+  // Used to post on a frontend interface thread, lives while the server is
+  // running
+  std::shared_ptr<RequestQueue> request_queue_;
+  std::shared_ptr<ExclusiveAccess<HostPort>> host_port_;
+  InspectPublishUid inspect_publish_uid_;
+
+  // The IO thread runs its own uv_loop to implement the TCP server off
+  // the main thread.
+  uv_thread_t thread_;
+
+  // For setting up interthread communications
+  Mutex thread_start_lock_;
+  ConditionVariable thread_start_condition_;
+  std::string script_name_;
+  // May be accessed from any thread
+  const std::string id_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS