@encharm/cws 4.4.1 → 4.5.1

package/src/headers/16/handle_wrap.h

@@ -1,121 +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_HANDLE_WRAP_H_
-#define SRC_HANDLE_WRAP_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-#include "util.h"
-#include "uv.h"
-#include "v8.h"
-
-namespace node {
-
-class Environment;
-class ExternalReferenceRegistry;
-
-// Rules:
-//
-// - Do not throw from handle methods. Set errno.
-//
-// - MakeCallback may only be made directly off the event loop.
-//   That is there can be no JavaScript stack frames underneath it.
-//   (Is there any way to assert that?)
-//
-// - No use of v8::WeakReferenceCallback. The close callback signifies that
-//   we're done with a handle - external resources can be freed.
-//
-// - Reusable?
-//
-// - The uv_close_cb is used to free the c++ object. The close callback
-//   is not made into javascript land.
-//
-// - uv_ref, uv_unref counts are managed at this layer to avoid needless
-//   js/c++ boundary crossing. At the javascript layer that should all be
-//   taken care of.
-
-class HandleWrap : public AsyncWrap {
- public:
-  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Ref(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Unref(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void HasRef(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static inline bool IsAlive(const HandleWrap* wrap) {
-    return wrap != nullptr &&
-        wrap->IsDoneInitializing() &&
-        wrap->state_ != kClosed;
-  }
-
-  static inline bool HasRef(const HandleWrap* wrap) {
-    return IsAlive(wrap) && uv_has_ref(wrap->GetHandle());
-  }
-
-  inline uv_handle_t* GetHandle() const { return handle_; }
-
-  virtual void Close(
-      v8::Local<v8::Value> close_callback = v8::Local<v8::Value>());
-
-  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
-      Environment* env);
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-
- protected:
-  HandleWrap(Environment* env,
-             v8::Local<v8::Object> object,
-             uv_handle_t* handle,
-             AsyncWrap::ProviderType provider);
-  virtual void OnClose() {}
-  void OnGCCollect() final;
-  bool IsNotIndicativeOfMemoryLeakAtExit() const override;
-
-  void MarkAsInitialized();
-  void MarkAsUninitialized();
-
-  inline bool IsHandleClosing() const {
-    return state_ == kClosing || state_ == kClosed;
-  }
-
-  static void OnClose(uv_handle_t* handle);
-
- private:
-  friend class Environment;
-  friend void GetActiveHandles(const v8::FunctionCallbackInfo<v8::Value>&);
-
-  // handle_wrap_queue_ needs to be at a fixed offset from the start of the
-  // class because it is used by src/node_postmortem_metadata.cc to calculate
-  // offsets and generate debug symbols for HandleWrap, which assumes that the
-  // position of members in memory are predictable. For more information please
-  // refer to `doc/guides/node-postmortem-support.md`
-  friend int GenDebugSymbols();
-  ListNode<HandleWrap> handle_wrap_queue_;
-  enum { kInitialized, kClosing, kClosed } state_;
-  uv_handle_t* const handle_;
-};
-
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_HANDLE_WRAP_H_

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

@@ -1,88 +0,0 @@
-#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;
-  prev_ = 0;
-}
-
-int64_t Histogram::Min() {
-  Mutex::ScopedLock lock(mutex_);
-  return hdr_min(histogram_.get());
-}
-
-int64_t Histogram::Max() {
-  Mutex::ScopedLock lock(mutex_);
-  return hdr_max(histogram_.get());
-}
-
-double Histogram::Mean() {
-  Mutex::ScopedLock lock(mutex_);
-  return hdr_mean(histogram_.get());
-}
-
-double Histogram::Stddev() {
-  Mutex::ScopedLock lock(mutex_);
-  return hdr_stddev(histogram_.get());
-}
-
-double Histogram::Percentile(double percentile) {
-  Mutex::ScopedLock lock(mutex_);
-  CHECK_GT(percentile, 0);
-  CHECK_LE(percentile, 100);
-  return static_cast<double>(
-      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;
-    double value = static_cast<double>(iter.value);
-    fn(key, value);
-  }
-}
-
-bool Histogram::Record(int64_t value) {
-  Mutex::ScopedLock lock(mutex_);
-  return hdr_record_value(histogram_.get(), value);
-}
-
-uint64_t Histogram::RecordDelta() {
-  Mutex::ScopedLock lock(mutex_);
-  uint64_t time = uv_hrtime();
-  uint64_t delta = 0;
-  if (prev_ > 0) {
-    delta = time - prev_;
-    if (delta > 0) {
-      if (!hdr_record_value(histogram_.get(), delta) && exceeds_ < 0xFFFFFFFF)
-        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/16/histogram.h

@@ -1,216 +0,0 @@
-#ifndef SRC_HISTOGRAM_H_
-#define SRC_HISTOGRAM_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "hdr_histogram.h"
-#include "base_object.h"
-#include "memory_tracker.h"
-#include "node_messaging.h"
-#include "util.h"
-#include "v8.h"
-#include "uv.h"
-
-#include <functional>
-#include <limits>
-#include <map>
-#include <string>
-
-namespace node {
-
-class ExternalReferenceRegistry;
-
-constexpr int kDefaultHistogramFigures = 3;
-
-class Histogram : public MemoryRetainer {
- public:
-  Histogram(
-      int64_t lowest = 1,
-      int64_t highest = std::numeric_limits<int64_t>::max(),
-      int figures = kDefaultHistogramFigures);
-  virtual ~Histogram() = default;
-
-  inline bool Record(int64_t value);
-  inline void Reset();
-  inline int64_t Min();
-  inline int64_t Max();
-  inline double Mean();
-  inline double Stddev();
-  inline double Percentile(double percentile);
-  inline int64_t Exceeds() const { return exceeds_; }
-
-  inline uint64_t RecordDelta();
-
-  // 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_;
-  int64_t exceeds_ = 0;
-  uint64_t prev_ = 0;
-
-  Mutex mutex_;
-};
-
-class HistogramImpl {
- public:
-  HistogramImpl(int64_t lowest, int64_t highest, int figures);
-  explicit HistogramImpl(std::shared_ptr<Histogram> histogram);
-
-  Histogram* operator->() { return histogram_.get(); }
-
- protected:
-  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(
-    Environment* env);
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-
-  static BaseObjectPtr<HistogramBase> Create(
-      Environment* env,
-      int64_t lowest = 1,
-      int64_t highest = std::numeric_limits<int64_t>::max(),
-      int figures = kDefaultHistogramFigures);
-
-  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 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 GetPercentiles(
-      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);
-
-  HistogramBase(
-      Environment* env,
-      v8::Local<v8::Object> wrap,
-      int64_t lowest = 1,
-      int64_t highest = std::numeric_limits<int64_t>::max(),
-      int figures = kDefaultHistogramFigures);
-
-  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,
-      int64_t lowest = 1,
-      int64_t highest = std::numeric_limits<int64_t>::max(),
-      int figures = kDefaultHistogramFigures);
-
-  virtual void OnInterval() = 0;
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-
-  IntervalHistogram(
-      Environment* env,
-      v8::Local<v8::Object> wrap,
-      AsyncWrap::ProviderType type,
-      int32_t interval,
-      int64_t lowest = 1,
-      int64_t highest = std::numeric_limits<int64_t>::max(),
-      int figures = kDefaultHistogramFigures);
-
-  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 GetPercentiles(
-      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;
-
- private:
-  static void TimerCB(uv_timer_t* handle);
-  void OnStart(StartFlags flags = StartFlags::RESET);
-  void OnStop();
-
-  bool enabled_ = false;
-  int32_t interval_ = 0;
-  uv_timer_t timer_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_HISTOGRAM_H_

package/src/headers/16/inspector_io.h

@@ -1,78 +0,0 @@
-#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

package/src/headers/16/inspector_socket.h

@@ -1,60 +0,0 @@
-#ifndef SRC_INSPECTOR_SOCKET_H_
-#define SRC_INSPECTOR_SOCKET_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "util.h"
-#include "uv.h"
-
-#include <string>
-#include <vector>
-
-namespace node {
-namespace inspector {
-
-class ProtocolHandler;
-
-// HTTP Wrapper around a uv_tcp_t
-class InspectorSocket {
- public:
-  class Delegate {
-   public:
-    virtual void OnHttpGet(const std::string& host,
-                           const std::string& path) = 0;
-    virtual void OnSocketUpgrade(const std::string& host,
-                                 const std::string& path,
-                                 const std::string& accept_key) = 0;
-    virtual void OnWsFrame(const std::vector<char>& frame) = 0;
-    virtual ~Delegate() = default;
-  };
-
-  using DelegatePointer = std::unique_ptr<Delegate>;
-  using Pointer = std::unique_ptr<InspectorSocket>;
-
-  static Pointer Accept(uv_stream_t* server, DelegatePointer delegate);
-
-  ~InspectorSocket();
-
-  void AcceptUpgrade(const std::string& accept_key);
-  void CancelHandshake();
-  void Write(const char* data, size_t len);
-  void SwitchProtocol(ProtocolHandler* handler);
-  std::string GetHost();
-
-  InspectorSocket(const InspectorSocket&) = delete;
-  InspectorSocket& operator=(const InspectorSocket&) = delete;
-
- private:
-  static void Shutdown(ProtocolHandler*);
-  InspectorSocket() = default;
-
-  DeleteFnPtr<ProtocolHandler, Shutdown> protocol_handler_;
-};
-
-
-}  // namespace inspector
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_INSPECTOR_SOCKET_H_

package/src/headers/16/inspector_socket_server.h

@@ -1,110 +0,0 @@
-#ifndef SRC_INSPECTOR_SOCKET_SERVER_H_
-#define SRC_INSPECTOR_SOCKET_SERVER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "inspector_agent.h"
-#include "inspector_socket.h"
-#include "uv.h"
-
-#include <map>
-#include <string>
-#include <vector>
-
-#if !HAVE_INSPECTOR
-#error("This header can only be used when inspector is enabled")
-#endif
-
-namespace node {
-namespace inspector {
-
-std::string FormatWsAddress(const std::string& host, int port,
-                            const std::string& target_id,
-                            bool include_protocol);
-
-class InspectorSocketServer;
-class SocketSession;
-class ServerSocket;
-
-class SocketServerDelegate {
- public:
-  virtual void AssignServer(InspectorSocketServer* server) = 0;
-  virtual void StartSession(int session_id, const std::string& target_id) = 0;
-  virtual void EndSession(int session_id) = 0;
-  virtual void MessageReceived(int session_id, const std::string& message) = 0;
-  virtual std::vector<std::string> GetTargetIds() = 0;
-  virtual std::string GetTargetTitle(const std::string& id) = 0;
-  virtual std::string GetTargetUrl(const std::string& id) = 0;
-  virtual ~SocketServerDelegate() = default;
-};
-
-// HTTP Server, writes messages requested as TransportActions, and responds
-// to HTTP requests and WS upgrades.
-
-class InspectorSocketServer {
- public:
-  InspectorSocketServer(std::unique_ptr<SocketServerDelegate> delegate,
-                        uv_loop_t* loop,
-                        const std::string& host,
-                        int port,
-                        const InspectPublishUid& inspect_publish_uid,
-                        FILE* out = stderr);
-  ~InspectorSocketServer();
-
-  // Start listening on host/port
-  bool Start();
-
-  // Called by the TransportAction sent with InspectorIo::Write():
-  //   kKill and kStop
-  void Stop();
-  //   kSendMessage
-  void Send(int session_id, const std::string& message);
-  //   kKill
-  void TerminateConnections();
-  int Port() const;
-
-  // Session connection lifecycle
-  void Accept(int server_port, uv_stream_t* server_socket);
-  bool HandleGetRequest(int session_id, const std::string& host,
-                        const std::string& path);
-  void SessionStarted(int session_id, const std::string& target_id,
-                      const std::string& ws_id);
-  void SessionTerminated(int session_id);
-  void MessageReceived(int session_id, const std::string& message) {
-    delegate_->MessageReceived(session_id, message);
-  }
-  SocketSession* Session(int session_id);
-  bool done() const {
-    return server_sockets_.empty() && connected_sessions_.empty();
-  }
-
-  static void CloseServerSocket(ServerSocket*);
-  using ServerSocketPtr = DeleteFnPtr<ServerSocket, CloseServerSocket>;
-
- private:
-  void SendListResponse(InspectorSocket* socket, const std::string& host,
-                        SocketSession* session);
-  std::string GetFrontendURL(bool is_compat,
-                             const std::string &formatted_address);
-  bool TargetExists(const std::string& id);
-
-  enum class ServerState {kNew, kRunning, kStopped};
-  uv_loop_t* loop_;
-  std::unique_ptr<SocketServerDelegate> delegate_;
-  const std::string host_;
-  int port_;
-  InspectPublishUid inspect_publish_uid_;
-  std::vector<ServerSocketPtr> server_sockets_;
-  std::map<int, std::pair<std::string, std::unique_ptr<SocketSession>>>
-      connected_sessions_;
-  int next_session_id_;
-  FILE* out_;
-  ServerState state_;
-};
-
-}  // namespace inspector
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_INSPECTOR_SOCKET_SERVER_H_