@encharm/cws 4.4.1 → 4.5.2

package/src/headers/14/node_worker.h

@@ -1,141 +0,0 @@
-#ifndef SRC_NODE_WORKER_H_
-#define SRC_NODE_WORKER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <unordered_map>
-#include "node_messaging.h"
-#include "uv.h"
-
-namespace node {
-namespace worker {
-
-class WorkerThreadData;
-
-enum ResourceLimits {
-  kMaxYoungGenerationSizeMb,
-  kMaxOldGenerationSizeMb,
-  kCodeRangeSizeMb,
-  kStackSizeMb,
-  kTotalResourceLimitCount
-};
-
-// A worker thread, as represented in its parent thread.
-class Worker : public AsyncWrap {
- public:
-  Worker(Environment* env,
-         v8::Local<v8::Object> wrap,
-         const std::string& url,
-         std::shared_ptr<PerIsolateOptions> per_isolate_opts,
-         std::vector<std::string>&& exec_argv,
-         std::shared_ptr<KVStore> env_vars);
-  ~Worker() override;
-
-  // Run the worker. This is only called from the worker thread.
-  void Run();
-
-  // Forcibly exit the thread with a specified exit code. This may be called
-  // from any thread. `error_code` and `error_message` can be used to create
-  // a custom `'error'` event before emitting `'exit'`.
-  void Exit(int code,
-            const char* error_code = nullptr,
-            const char* error_message = nullptr);
-
-  // Wait for the worker thread to stop (in a blocking manner).
-  void JoinThread();
-
-  template <typename Fn>
-  inline bool RequestInterrupt(Fn&& cb);
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(Worker)
-  SET_SELF_SIZE(Worker)
-
-  bool is_stopped() const;
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CloneParentEnvVars(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetEnvVars(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void StartThread(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void StopThread(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 GetResourceLimits(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  v8::Local<v8::Float64Array> GetResourceLimits(v8::Isolate* isolate) const;
-  static void TakeHeapSnapshot(const v8::FunctionCallbackInfo<v8::Value>& args);
-
- private:
-  void CreateEnvMessagePort(Environment* env);
-  static size_t NearHeapLimit(void* data, size_t current_heap_limit,
-                              size_t initial_heap_limit);
-
-  std::shared_ptr<PerIsolateOptions> per_isolate_opts_;
-  std::vector<std::string> exec_argv_;
-  std::vector<std::string> argv_;
-
-  MultiIsolatePlatform* platform_;
-  v8::Isolate* isolate_ = nullptr;
-  uv_thread_t tid_;
-
-  std::unique_ptr<InspectorParentHandle> inspector_parent_handle_;
-
-  // This mutex protects access to all variables listed below it.
-  mutable Mutex mutex_;
-
-  bool thread_joined_ = true;
-  const char* custom_error_ = nullptr;
-  std::string custom_error_str_;
-  int exit_code_ = 0;
-  ThreadId thread_id_;
-  uintptr_t stack_base_ = 0;
-
-  // Custom resource constraints:
-  double resource_limits_[kTotalResourceLimitCount];
-  void UpdateResourceConstraints(v8::ResourceConstraints* constraints);
-
-  // Full size of the thread's stack.
-  size_t stack_size_ = 4 * 1024 * 1024;
-  // Stack buffer size that is not available to the JS engine.
-  static constexpr size_t kStackBufferSize = 192 * 1024;
-
-  std::unique_ptr<MessagePortData> child_port_data_;
-  std::shared_ptr<KVStore> env_vars_;
-
-  // This is always kept alive because the JS object associated with the Worker
-  // instance refers to it via its [kPort] property.
-  MessagePort* parent_port_ = nullptr;
-
-  // A raw flag that is used by creator and worker threads to
-  // sync up on pre-mature termination of worker  - while in the
-  // warmup phase.  Once the worker is fully warmed up, use the
-  // async handle of the worker's Environment for the same purpose.
-  bool stopped_ = true;
-
-  bool has_ref_ = true;
-
-  // The real Environment of the worker object. It has a lesser
-  // lifespan than the worker object itself - comes to life
-  // when the worker thread creates a new Environment, and gets
-  // destroyed alongwith the worker thread.
-  Environment* env_ = nullptr;
-
-  friend class WorkerThreadData;
-};
-
-template <typename Fn>
-bool Worker::RequestInterrupt(Fn&& cb) {
-  Mutex::ScopedLock lock(mutex_);
-  if (env_ == nullptr) return false;
-  env_->RequestInterrupt(std::move(cb));
-  return true;
-}
-
-}  // namespace worker
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-
-#endif  // SRC_NODE_WORKER_H_

package/src/headers/14/pipe_wrap.h

@@ -1,78 +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_PIPE_WRAP_H_
-#define SRC_PIPE_WRAP_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-#include "connection_wrap.h"
-
-namespace node {
-
-class Environment;
-
-class PipeWrap : public ConnectionWrap<PipeWrap, uv_pipe_t> {
- public:
-  enum SocketType {
-    SOCKET,
-    SERVER,
-    IPC
-  };
-
-  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);
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(PipeWrap)
-  SET_SELF_SIZE(PipeWrap)
-
- private:
-  PipeWrap(Environment* env,
-           v8::Local<v8::Object> object,
-           ProviderType provider,
-           bool ipc);
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Bind(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 Open(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-#ifdef _WIN32
-  static void SetPendingInstances(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-#endif
-  static void Fchmod(const v8::FunctionCallbackInfo<v8::Value>& args);
-};
-
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_PIPE_WRAP_H_

package/src/headers/14/req_wrap-inl.h

@@ -1,170 +0,0 @@
-#ifndef SRC_REQ_WRAP_INL_H_
-#define SRC_REQ_WRAP_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "req_wrap.h"
-#include "async_wrap-inl.h"
-#include "uv.h"
-
-namespace node {
-
-ReqWrapBase::ReqWrapBase(Environment* env) {
-  CHECK(env->has_run_bootstrapping_code());
-  env->req_wrap_queue()->PushBack(this);
-}
-
-template <typename T>
-ReqWrap<T>::ReqWrap(Environment* env,
-                    v8::Local<v8::Object> object,
-                    AsyncWrap::ProviderType provider)
-    : AsyncWrap(env, object, provider),
-      ReqWrapBase(env) {
-  Reset();
-}
-
-template <typename T>
-ReqWrap<T>::~ReqWrap() {
-  CHECK_EQ(false, persistent().IsEmpty());
-}
-
-template <typename T>
-void ReqWrap<T>::Dispatched() {
-  req_.data = this;
-}
-
-template <typename T>
-void ReqWrap<T>::Reset() {
-  original_callback_ = nullptr;
-  req_.data = nullptr;
-}
-
-template <typename T>
-ReqWrap<T>* ReqWrap<T>::from_req(T* req) {
-  return ContainerOf(&ReqWrap<T>::req_, req);
-}
-
-template <typename T>
-void ReqWrap<T>::Cancel() {
-  if (req_.data == this)  // Only cancel if already dispatched.
-    uv_cancel(reinterpret_cast<uv_req_t*>(&req_));
-}
-
-template <typename T>
-AsyncWrap* ReqWrap<T>::GetAsyncWrap() {
-  return this;
-}
-
-// Below is dark template magic designed to invoke libuv functions that
-// initialize uv_req_t instances in a unified fashion, to allow easier
-// tracking of active/inactive requests.
-
-// Invoke a generic libuv function that initializes uv_req_t instances.
-// This is, unfortunately, necessary since they come in three different
-// variants that can not all be invoked in the same way:
-// - int uv_foo(uv_loop_t* loop, uv_req_t* request, ...);
-// - int uv_foo(uv_req_t* request, ...);
-// - void uv_foo(uv_req_t* request, ...);
-template <typename ReqT, typename T>
-struct CallLibuvFunction;
-
-// Detect `int uv_foo(uv_loop_t* loop, uv_req_t* request, ...);`.
-template <typename ReqT, typename... Args>
-struct CallLibuvFunction<ReqT, int(*)(uv_loop_t*, ReqT*, Args...)> {
-  using T = int(*)(uv_loop_t*, ReqT*, Args...);
-  template <typename... PassedArgs>
-  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
-    return fn(loop, req, args...);
-  }
-};
-
-// Detect `int uv_foo(uv_req_t* request, ...);`.
-template <typename ReqT, typename... Args>
-struct CallLibuvFunction<ReqT, int(*)(ReqT*, Args...)> {
-  using T = int(*)(ReqT*, Args...);
-  template <typename... PassedArgs>
-  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
-    return fn(req, args...);
-  }
-};
-
-// Detect `void uv_foo(uv_req_t* request, ...);`.
-template <typename ReqT, typename... Args>
-struct CallLibuvFunction<ReqT, void(*)(ReqT*, Args...)> {
-  using T = void(*)(ReqT*, Args...);
-  template <typename... PassedArgs>
-  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
-    fn(req, args...);
-    return 0;
-  }
-};
-
-// This is slightly darker magic: This template is 'applied' to each parameter
-// passed to the libuv function. If the parameter type (aka `T`) is a
-// function type, it is assumed that this it is the request callback, and a
-// wrapper that calls the original callback is created.
-// If not, the parameter is passed through verbatim.
-template <typename ReqT, typename T>
-struct MakeLibuvRequestCallback {
-  static T For(ReqWrap<ReqT>* req_wrap, T v) {
-    static_assert(!is_callable<T>::value,
-                  "MakeLibuvRequestCallback missed a callback");
-    return v;
-  }
-};
-
-// Match the `void callback(uv_req_t*, ...);` signature that all libuv
-// callbacks use.
-template <typename ReqT, typename... Args>
-struct MakeLibuvRequestCallback<ReqT, void(*)(ReqT*, Args...)> {
-  using F = void(*)(ReqT* req, Args... args);
-
-  static void Wrapper(ReqT* req, Args... args) {
-    ReqWrap<ReqT>* req_wrap = ReqWrap<ReqT>::from_req(req);
-    req_wrap->env()->DecreaseWaitingRequestCounter();
-    F original_callback = reinterpret_cast<F>(req_wrap->original_callback_);
-    original_callback(req, args...);
-  }
-
-  static F For(ReqWrap<ReqT>* req_wrap, F v) {
-    CHECK_NULL(req_wrap->original_callback_);
-    req_wrap->original_callback_ =
-        reinterpret_cast<typename ReqWrap<ReqT>::callback_t>(v);
-    return Wrapper;
-  }
-};
-
-template <typename T>
-template <typename LibuvFunction, typename... Args>
-int ReqWrap<T>::Dispatch(LibuvFunction fn, Args... args) {
-  Dispatched();
-
-  // This expands as:
-  //
-  // int err = fn(env()->event_loop(), req(), arg1, arg2, Wrapper, arg3, ...)
-  //              ^                                       ^        ^
-  //              |                                       |        |
-  //              \-- Omitted if `fn` has no              |        |
-  //                  first `uv_loop_t*` argument         |        |
-  //                                                      |        |
-  //        A function callback whose first argument      |        |
-  //        matches the libuv request type is replaced ---/        |
-  //        by the `Wrapper` method defined above                  |
-  //                                                               |
-  //               Other (non-function) arguments are passed  -----/
-  //               through verbatim
-  int err = CallLibuvFunction<T, LibuvFunction>::Call(
-      fn,
-      env()->event_loop(),
-      req(),
-      MakeLibuvRequestCallback<T, Args>::For(this, args)...);
-  if (err >= 0)
-    env()->IncreaseWaitingRequestCounter();
-  return err;
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_REQ_WRAP_INL_H_

package/src/headers/14/req_wrap.h

@@ -1,77 +0,0 @@
-#ifndef SRC_REQ_WRAP_H_
-#define SRC_REQ_WRAP_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-#include "util.h"
-#include "v8.h"
-
-namespace node {
-
-class Environment;
-
-class ReqWrapBase {
- public:
-  explicit inline ReqWrapBase(Environment* env);
-
-  virtual ~ReqWrapBase() = default;
-
-  virtual void Cancel() = 0;
-  virtual AsyncWrap* GetAsyncWrap() = 0;
-
- private:
-  friend int GenDebugSymbols();
-  friend class Environment;
-
-  ListNode<ReqWrapBase> req_wrap_queue_;
-};
-
-template <typename T>
-class ReqWrap : public AsyncWrap, public ReqWrapBase {
- public:
-  inline ReqWrap(Environment* env,
-                 v8::Local<v8::Object> object,
-                 AsyncWrap::ProviderType provider);
-  inline ~ReqWrap() override;
-  // Call this after the req has been dispatched, if that did not already
-  // happen by using Dispatch().
-  inline void Dispatched();
-  // Call this after a request has finished, if re-using this object is planned.
-  inline void Reset();
-  T* req() { return &req_; }
-  inline void Cancel() final;
-  inline AsyncWrap* GetAsyncWrap() override;
-
-  static ReqWrap* from_req(T* req);
-
-  template <typename LibuvFunction, typename... Args>
-  inline int Dispatch(LibuvFunction fn, Args... args);
-
- private:
-  friend int GenDebugSymbols();
-
-  // Adding `friend struct MakeLibuvRequestCallback` is not enough anymore
-  // for some reason. Consider this private.
- public:
-  typedef void (*callback_t)();
-  callback_t original_callback_ = nullptr;
-
- protected:
-  // req_wrap_queue_ needs to be at a fixed offset from the start of the class
-  // because it is used by ContainerOf to calculate the address of the embedding
-  // ReqWrap. ContainerOf compiles down to simple, fixed pointer arithmetic. It
-  // is also used by src/node_postmortem_metadata.cc to calculate offsets and
-  // generate debug symbols for ReqWrap, which assumes that the position of
-  // members in memory are predictable. sizeof(req_) depends on the type of T,
-  // so req_wrap_queue_ would no longer be at a fixed offset if it came after
-  // req_. For more information please refer to
-  // `doc/guides/node-postmortem-support.md`
-  T req_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_REQ_WRAP_H_