@encharm/cws 4.4.1 → 4.5.1

package/src/headers/16/tcp_wrap.h

@@ -1,103 +0,0 @@
-// 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)
-  std::string 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);
-
-#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/16/threadpoolwork-inl.h

@@ -1,57 +0,0 @@
-// 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 "util-inl.h"
-#include "node_internals.h"
-
-namespace node {
-
-void ThreadPoolWork::ScheduleWork() {
-  env_->IncreaseWaitingRequestCounter();
-  int status = uv_queue_work(
-      env_->event_loop(),
-      &work_req_,
-      [](uv_work_t* req) {
-        ThreadPoolWork* self = ContainerOf(&ThreadPoolWork::work_req_, req);
-        self->DoThreadPoolWork();
-      },
-      [](uv_work_t* req, int status) {
-        ThreadPoolWork* self = ContainerOf(&ThreadPoolWork::work_req_, req);
-        self->env_->DecreaseWaitingRequestCounter();
-        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/16/timer_wrap.h

@@ -1,84 +0,0 @@
-#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()>;
-
-  TimerWrap(Environment* env, const TimerCb& fn);
-  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:
-  TimerWrapHandle(
-      Environment* env,
-      const TimerWrap::TimerCb& fn);
-
-  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/16/tracing/agent.h

@@ -1,195 +0,0 @@
-#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_;
-
-  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_

package/src/headers/16/tracing/node_trace_buffer.h

@@ -1,83 +0,0 @@
-#ifndef SRC_TRACING_NODE_TRACE_BUFFER_H_
-#define SRC_TRACING_NODE_TRACE_BUFFER_H_
-
-#include "tracing/agent.h"
-#include "node_mutex.h"
-#include "libplatform/v8-tracing.h"
-
-#include <atomic>
-
-namespace node {
-namespace tracing {
-
-using v8::platform::tracing::TraceBuffer;
-using v8::platform::tracing::TraceBufferChunk;
-using v8::platform::tracing::TraceObject;
-
-// forward declaration
-class NodeTraceBuffer;
-
-class InternalTraceBuffer {
- public:
-  InternalTraceBuffer(size_t max_chunks, uint32_t id, Agent* agent);
-
-  TraceObject* AddTraceEvent(uint64_t* handle);
-  TraceObject* GetEventByHandle(uint64_t handle);
-  void Flush(bool blocking);
-  bool IsFull() const {
-    return total_chunks_ == max_chunks_ && chunks_[total_chunks_ - 1]->IsFull();
-  }
-  bool IsFlushing() const {
-    return flushing_;
-  }
-
- private:
-  uint64_t MakeHandle(size_t chunk_index, uint32_t chunk_seq,
-                      size_t event_index) const;
-  void ExtractHandle(uint64_t handle, uint32_t* buffer_id, size_t* chunk_index,
-                     uint32_t* chunk_seq, size_t* event_index) const;
-  size_t Capacity() const { return max_chunks_ * TraceBufferChunk::kChunkSize; }
-
-  Mutex mutex_;
-  bool flushing_;
-  size_t max_chunks_;
-  Agent* agent_;
-  std::vector<std::unique_ptr<TraceBufferChunk>> chunks_;
-  size_t total_chunks_ = 0;
-  uint32_t current_chunk_seq_ = 1;
-  uint32_t id_;
-};
-
-class NodeTraceBuffer : public TraceBuffer {
- public:
-  NodeTraceBuffer(size_t max_chunks, Agent* agent, uv_loop_t* tracing_loop);
-  ~NodeTraceBuffer() override;
-
-  TraceObject* AddTraceEvent(uint64_t* handle) override;
-  TraceObject* GetEventByHandle(uint64_t handle) override;
-  bool Flush() override;
-
-  static const size_t kBufferChunks = 1024;
-
- private:
-  bool TryLoadAvailableBuffer();
-  static void NonBlockingFlushSignalCb(uv_async_t* signal);
-  static void ExitSignalCb(uv_async_t* signal);
-
-  uv_loop_t* tracing_loop_;
-  uv_async_t flush_signal_;
-  uv_async_t exit_signal_;
-  bool exited_ = false;
-  // Used exclusively for exit logic.
-  Mutex exit_mutex_;
-  // Used to wait until async handles have been closed.
-  ConditionVariable exit_cond_;
-  std::atomic<InternalTraceBuffer*> current_buf_;
-  InternalTraceBuffer buffer1_;
-  InternalTraceBuffer buffer2_;
-};
-
-}  // namespace tracing
-}  // namespace node
-
-#endif  // SRC_TRACING_NODE_TRACE_BUFFER_H_

package/src/headers/16/tracing/node_trace_writer.h

@@ -1,75 +0,0 @@
-#ifndef SRC_TRACING_NODE_TRACE_WRITER_H_
-#define SRC_TRACING_NODE_TRACE_WRITER_H_
-
-#include <sstream>
-#include <queue>
-
-#include "libplatform/v8-tracing.h"
-#include "tracing/agent.h"
-#include "uv.h"
-
-namespace node {
-namespace tracing {
-
-using v8::platform::tracing::TraceObject;
-using v8::platform::tracing::TraceWriter;
-
-class NodeTraceWriter : public AsyncTraceWriter {
- public:
-  explicit NodeTraceWriter(const std::string& log_file_pattern);
-  ~NodeTraceWriter() override;
-
-  void InitializeOnThread(uv_loop_t* loop) override;
-  void AppendTraceEvent(TraceObject* trace_event) override;
-  void Flush(bool blocking) override;
-
-  static const int kTracesPerFile = 1 << 19;
-
- private:
-  struct WriteRequest {
-    std::string str;
-    int highest_request_id;
-  };
-
-  void AfterWrite();
-  void StartWrite(uv_buf_t buf);
-  void OpenNewFileForStreaming();
-  void WriteToFile(std::string&& str, int highest_request_id);
-  void WriteSuffix();
-  void FlushPrivate();
-  static void ExitSignalCb(uv_async_t* signal);
-
-  uv_loop_t* tracing_loop_ = nullptr;
-  // Triggers callback to initiate writing the contents of stream_ to disk.
-  uv_async_t flush_signal_;
-  // Triggers callback to close async objects, ending the tracing thread.
-  uv_async_t exit_signal_;
-  // Prevents concurrent R/W on state related to serialized trace data
-  // before it's written to disk, namely stream_ and total_traces_
-  // as well as json_trace_writer_.
-  Mutex stream_mutex_;
-  // Prevents concurrent R/W on state related to write requests.
-  // If both mutexes are locked, request_mutex_ has to be locked first.
-  Mutex request_mutex_;
-  // Allows blocking calls to Flush() to wait on a condition for
-  // trace events to be written to disk.
-  ConditionVariable request_cond_;
-  // Used to wait until async handles have been closed.
-  ConditionVariable exit_cond_;
-  int fd_ = -1;
-  uv_fs_t write_req_;
-  std::queue<WriteRequest> write_req_queue_;
-  int num_write_requests_ = 0;
-  int highest_request_id_completed_ = 0;
-  int total_traces_ = 0;
-  int file_num_ = 0;
-  std::string log_file_pattern_;
-  std::ostringstream stream_;
-  std::unique_ptr<TraceWriter> json_trace_writer_;
-  bool exited_ = false;
-};
-
-}  // namespace tracing
-}  // namespace node
-
-#endif  // SRC_TRACING_NODE_TRACE_WRITER_H_