@encharm/cws 4.3.0 → 4.4.0

package/src/headers/20/tcp_wrap.h

@@ -0,0 +1,105 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_TCP_WRAP_H_
+#define SRC_TCP_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "connection_wrap.h"
+
+namespace node {
+
+class ExternalReferenceRegistry;
+class Environment;
+
+class TCPWrap : public ConnectionWrap<TCPWrap, uv_tcp_t> {
+ public:
+  enum SocketType {
+    SOCKET,
+    SERVER
+  };
+
+  static v8::MaybeLocal<v8::Object> Instantiate(Environment* env,
+                                                AsyncWrap* parent,
+                                                SocketType type);
+  static void Initialize(v8::Local<v8::Object> target,
+                         v8::Local<v8::Value> unused,
+                         v8::Local<v8::Context> context,
+                         void* priv);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  SET_NO_MEMORY_INFO()
+  SET_SELF_SIZE(TCPWrap)
+  const char* MemoryInfoName() const override {
+    switch (provider_type()) {
+      case ProviderType::PROVIDER_TCPWRAP:
+        return "TCPSocketWrap";
+      case ProviderType::PROVIDER_TCPSERVERWRAP:
+        return "TCPServerWrap";
+      default:
+        UNREACHABLE();
+    }
+  }
+
+ private:
+  typedef uv_tcp_t HandleType;
+
+  template <typename T,
+            int (*F)(const typename T::HandleType*, sockaddr*, int*)>
+  friend void GetSockOrPeerName(const v8::FunctionCallbackInfo<v8::Value>&);
+
+  TCPWrap(Environment* env, v8::Local<v8::Object> object,
+          ProviderType provider);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetNoDelay(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetKeepAlive(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Bind(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Bind6(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Listen(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Connect(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Connect6(const v8::FunctionCallbackInfo<v8::Value>& args);
+  template <typename T>
+  static void Connect(const v8::FunctionCallbackInfo<v8::Value>& args,
+      std::function<int(const char* ip_address, T* addr)> uv_ip_addr);
+  static void Open(const v8::FunctionCallbackInfo<v8::Value>& args);
+  template <typename T>
+  static void Bind(
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      int family,
+      std::function<int(const char* ip_address, int port, T* addr)> uv_ip_addr);
+  static void Reset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  int Reset(v8::Local<v8::Value> close_callback = v8::Local<v8::Value>());
+
+#ifdef _WIN32
+  static void SetSimultaneousAccepts(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+#endif
+};
+
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TCP_WRAP_H_

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

@@ -0,0 +1,70 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_THREADPOOLWORK_INL_H_
+#define SRC_THREADPOOLWORK_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+#include "tracing/trace_event.h"
+#include "util-inl.h"
+
+namespace node {
+
+void ThreadPoolWork::ScheduleWork() {
+  env_->IncreaseWaitingRequestCounter();
+  TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(
+      TRACING_CATEGORY_NODE2(threadpoolwork, async), type_, this);
+  int status = uv_queue_work(
+      env_->event_loop(),
+      &work_req_,
+      [](uv_work_t* req) {
+        ThreadPoolWork* self = ContainerOf(&ThreadPoolWork::work_req_, req);
+        TRACE_EVENT_BEGIN0(TRACING_CATEGORY_NODE2(threadpoolwork, sync),
+                           self->type_);
+        self->DoThreadPoolWork();
+        TRACE_EVENT_END0(TRACING_CATEGORY_NODE2(threadpoolwork, sync),
+                         self->type_);
+      },
+      [](uv_work_t* req, int status) {
+        ThreadPoolWork* self = ContainerOf(&ThreadPoolWork::work_req_, req);
+        self->env_->DecreaseWaitingRequestCounter();
+        TRACE_EVENT_NESTABLE_ASYNC_END1(
+            TRACING_CATEGORY_NODE2(threadpoolwork, async),
+            self->type_,
+            self,
+            "result",
+            status);
+        self->AfterThreadPoolWork(status);
+      });
+  CHECK_EQ(status, 0);
+}
+
+int ThreadPoolWork::CancelWork() {
+  return uv_cancel(reinterpret_cast<uv_req_t*>(&work_req_));
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_THREADPOOLWORK_INL_H_

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

@@ -0,0 +1,32 @@
+#ifndef SRC_TIMER_WRAP_INL_H_
+#define SRC_TIMER_WRAP_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "timer_wrap.h"
+
+#include <utility>
+
+#include "env.h"
+#include "uv.h"
+
+namespace node {
+
+template <typename... Args>
+inline TimerWrap::TimerWrap(Environment* env, Args&&... args)
+    : env_(env), fn_(std::forward<Args>(args)...) {
+  uv_timer_init(env->event_loop(), &timer_);
+  timer_.data = this;
+}
+
+template <typename... Args>
+inline TimerWrapHandle::TimerWrapHandle(Environment* env, Args&&... args) {
+  timer_ = new TimerWrap(env, std::forward<Args>(args)...);
+  env->AddCleanupHook(CleanupHook, this);
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMER_WRAP_INL_H_

package/src/headers/20/timer_wrap.h

@@ -0,0 +1,85 @@
+#ifndef SRC_TIMER_WRAP_H_
+#define SRC_TIMER_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "memory_tracker.h"
+#include "env.h"
+#include "uv.h"
+
+#include <functional>
+
+namespace node {
+
+// Utility class that makes working with libuv timers a bit easier.
+class TimerWrap final : public MemoryRetainer {
+ public:
+  using TimerCb = std::function<void()>;
+
+  template <typename... Args>
+  explicit inline TimerWrap(Environment* env, Args&&... args);
+
+  TimerWrap(const TimerWrap&) = delete;
+
+  inline Environment* env() const { return env_; }
+
+  // Stop calling the timer callback.
+  void Stop();
+  // Render the timer unusable and delete this object.
+  void Close();
+
+  // Starts / Restarts the Timer
+  void Update(uint64_t interval, uint64_t repeat = 0);
+
+  void Ref();
+  void Unref();
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(TimerWrap)
+  SET_SELF_SIZE(TimerWrap)
+
+ private:
+  static void TimerClosedCb(uv_handle_t* handle);
+  static void OnTimeout(uv_timer_t* timer);
+  ~TimerWrap() = default;
+
+  Environment* env_;
+  TimerCb fn_;
+  uv_timer_t timer_;
+
+  friend std::unique_ptr<TimerWrap>::deleter_type;
+};
+
+class TimerWrapHandle : public MemoryRetainer  {
+ public:
+  template <typename... Args>
+  explicit inline TimerWrapHandle(Environment* env, Args&&... args);
+
+  TimerWrapHandle(const TimerWrapHandle&) = delete;
+
+  ~TimerWrapHandle() { Close(); }
+
+  void Update(uint64_t interval, uint64_t repeat = 0);
+
+  void Ref();
+  void Unref();
+
+  void Stop();
+  void Close();
+
+  void MemoryInfo(node::MemoryTracker* tracker) const override;
+
+  SET_MEMORY_INFO_NAME(TimerWrapHandle)
+  SET_SELF_SIZE(TimerWrapHandle)
+
+ private:
+  static void CleanupHook(void* data);
+
+  TimerWrap* timer_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMER_WRAP_H_

package/src/headers/20/timers.h

@@ -0,0 +1,70 @@
+#ifndef SRC_TIMERS_H_
+#define SRC_TIMERS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "node_snapshotable.h"
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace timers {
+class BindingData : public SnapshotableObject {
+ public:
+  BindingData(Realm* env, v8::Local<v8::Object> obj);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  SET_BINDING_ID(timers_binding_data)
+  SERIALIZABLE_OBJECT_METHODS()
+
+  SET_NO_MEMORY_INFO()
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void SetupTimers(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void SlowGetLibuvNow(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static double FastGetLibuvNow(v8::Local<v8::Object> receiver);
+  static double GetLibuvNowImpl(BindingData* data);
+
+  static void SlowScheduleTimer(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastScheduleTimer(v8::Local<v8::Object> receiver,
+                                int64_t duration);
+  static void ScheduleTimerImpl(BindingData* data, int64_t duration);
+
+  static void SlowToggleTimerRef(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastToggleTimerRef(v8::Local<v8::Object> receiver, bool ref);
+  static void ToggleTimerRefImpl(BindingData* data, bool ref);
+
+  static void SlowToggleImmediateRef(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastToggleImmediateRef(v8::Local<v8::Object> receiver, bool ref);
+  static void ToggleImmediateRefImpl(BindingData* data, bool ref);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterTimerExternalReferences(
+      ExternalReferenceRegistry* registry);
+
+ private:
+  static v8::CFunction fast_get_libuv_now_;
+  static v8::CFunction fast_schedule_timers_;
+  static v8::CFunction fast_toggle_timer_ref_;
+  static v8::CFunction fast_toggle_immediate_ref_;
+};
+
+}  // namespace timers
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMERS_H_

package/src/headers/20/tracing/agent.h

@@ -0,0 +1,195 @@
+#ifndef SRC_TRACING_AGENT_H_
+#define SRC_TRACING_AGENT_H_
+
+#include "libplatform/v8-tracing.h"
+#include "uv.h"
+#include "util.h"
+#include "node_mutex.h"
+
+#include <list>
+#include <set>
+#include <string>
+#include <unordered_map>
+
+namespace v8 {
+class ConvertableToTraceFormat;
+class TracingController;
+}  // namespace v8
+
+namespace node {
+namespace tracing {
+
+using v8::platform::tracing::TraceConfig;
+using v8::platform::tracing::TraceObject;
+
+class Agent;
+
+class AsyncTraceWriter {
+ public:
+  virtual ~AsyncTraceWriter() = default;
+  virtual void AppendTraceEvent(TraceObject* trace_event) = 0;
+  virtual void Flush(bool blocking) = 0;
+  virtual void InitializeOnThread(uv_loop_t* loop) {}
+};
+
+class TracingController : public v8::platform::tracing::TracingController {
+ public:
+  TracingController() : v8::platform::tracing::TracingController() {}
+
+  int64_t CurrentTimestampMicroseconds() override {
+    return uv_hrtime() / 1000;
+  }
+  void AddMetadataEvent(
+      const unsigned char* category_group_enabled,
+      const char* name,
+      int num_args,
+      const char** arg_names,
+      const unsigned char* arg_types,
+      const uint64_t* arg_values,
+      std::unique_ptr<v8::ConvertableToTraceFormat>* convertable_values,
+      unsigned int flags);
+};
+
+class AgentWriterHandle {
+ public:
+  inline AgentWriterHandle() = default;
+  inline ~AgentWriterHandle() { reset(); }
+
+  inline AgentWriterHandle(AgentWriterHandle&& other);
+  inline AgentWriterHandle& operator=(AgentWriterHandle&& other);
+  inline bool empty() const { return agent_ == nullptr; }
+  inline void reset();
+
+  inline void Enable(const std::set<std::string>& categories);
+  inline void Disable(const std::set<std::string>& categories);
+
+  inline bool IsDefaultHandle();
+
+  inline Agent* agent() { return agent_; }
+
+  inline v8::TracingController* GetTracingController();
+
+  AgentWriterHandle(const AgentWriterHandle& other) = delete;
+  AgentWriterHandle& operator=(const AgentWriterHandle& other) = delete;
+
+ private:
+  inline AgentWriterHandle(Agent* agent, int id) : agent_(agent), id_(id) {}
+
+  Agent* agent_ = nullptr;
+  int id_ = 0;
+
+  friend class Agent;
+};
+
+class Agent {
+ public:
+  Agent();
+  ~Agent();
+
+  TracingController* GetTracingController() {
+    TracingController* controller = tracing_controller_.get();
+    CHECK_NOT_NULL(controller);
+    return controller;
+  }
+
+  enum UseDefaultCategoryMode {
+    kUseDefaultCategories,
+    kIgnoreDefaultCategories
+  };
+
+  // Destroying the handle disconnects the client
+  AgentWriterHandle AddClient(const std::set<std::string>& categories,
+                              std::unique_ptr<AsyncTraceWriter> writer,
+                              enum UseDefaultCategoryMode mode);
+  // A handle that is only used for managing the default categories
+  // (which can then implicitly be used through using `USE_DEFAULT_CATEGORIES`
+  // when adding a client later).
+  AgentWriterHandle DefaultHandle();
+
+  // Returns a comma-separated list of enabled categories.
+  std::string GetEnabledCategories() const;
+
+  // Writes to all writers registered through AddClient().
+  void AppendTraceEvent(TraceObject* trace_event);
+
+  void AddMetadataEvent(std::unique_ptr<TraceObject> event);
+  // Flushes all writers registered through AddClient().
+  void Flush(bool blocking);
+
+  TraceConfig* CreateTraceConfig() const;
+
+ private:
+  friend class AgentWriterHandle;
+
+  void InitializeWritersOnThread();
+
+  void Start();
+  void StopTracing();
+  void Disconnect(int client);
+
+  void Enable(int id, const std::set<std::string>& categories);
+  void Disable(int id, const std::set<std::string>& categories);
+
+  uv_thread_t thread_;
+  uv_loop_t tracing_loop_;
+
+  bool started_ = false;
+  class ScopedSuspendTracing;
+
+  // Each individual Writer has one id.
+  int next_writer_id_ = 1;
+  enum { kDefaultHandleId = -1 };
+  // These maps store the original arguments to AddClient(), by id.
+  std::unordered_map<int, std::multiset<std::string>> categories_;
+  std::unordered_map<int, std::unique_ptr<AsyncTraceWriter>> writers_;
+  std::unique_ptr<TracingController> tracing_controller_;
+
+  // Variables related to initializing per-event-loop properties of individual
+  // writers, such as libuv handles.
+  Mutex initialize_writer_mutex_;
+  ConditionVariable initialize_writer_condvar_;
+  uv_async_t initialize_writer_async_;
+  std::set<AsyncTraceWriter*> to_be_initialized_;
+
+  Mutex metadata_events_mutex_;
+  std::list<std::unique_ptr<TraceObject>> metadata_events_;
+};
+
+void AgentWriterHandle::reset() {
+  if (agent_ != nullptr)
+    agent_->Disconnect(id_);
+  agent_ = nullptr;
+}
+
+AgentWriterHandle& AgentWriterHandle::operator=(AgentWriterHandle&& other) {
+  reset();
+  agent_ = other.agent_;
+  id_ = other.id_;
+  other.agent_ = nullptr;
+  return *this;
+}
+
+AgentWriterHandle::AgentWriterHandle(AgentWriterHandle&& other) {
+  *this = std::move(other);
+}
+
+void AgentWriterHandle::Enable(const std::set<std::string>& categories) {
+  if (agent_ != nullptr) agent_->Enable(id_, categories);
+}
+
+void AgentWriterHandle::Disable(const std::set<std::string>& categories) {
+  if (agent_ != nullptr) agent_->Disable(id_, categories);
+}
+
+bool AgentWriterHandle::IsDefaultHandle() {
+  return agent_ != nullptr && id_ == Agent::kDefaultHandleId;
+}
+
+inline v8::TracingController* AgentWriterHandle::GetTracingController() {
+  return agent_ != nullptr ? agent_->GetTracingController() : nullptr;
+}
+
+}  // namespace tracing
+}  // namespace node
+
+#endif  // SRC_TRACING_AGENT_H_