@encharm/cws 4.1.0 → 4.2.0

package/src/headers/18/node_snapshot_builder.h

@@ -0,0 +1,43 @@
+
+#ifndef SRC_NODE_SNAPSHOT_BUILDER_H_
+#define SRC_NODE_SNAPSHOT_BUILDER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cstdint>
+#include "node_mutex.h"
+#include "v8.h"
+
+namespace node {
+
+class ExternalReferenceRegistry;
+struct SnapshotData;
+
+class NODE_EXTERN_PRIVATE SnapshotBuilder {
+ public:
+  static std::string Generate(const std::vector<std::string> args,
+                              const std::vector<std::string> exec_args);
+
+  // Generate the snapshot into out.
+  static void Generate(SnapshotData* out,
+                       const std::vector<std::string> args,
+                       const std::vector<std::string> exec_args);
+
+  // If nullptr is returned, the binary is not built with embedded
+  // snapshot.
+  static const SnapshotData* GetEmbeddedSnapshotData();
+  static void InitializeIsolateParams(const SnapshotData* data,
+                                      v8::Isolate::CreateParams* params);
+
+ private:
+  // Used to synchronize access to the snapshot data
+  static Mutex snapshot_data_mutex_;
+  static const std::vector<intptr_t>& CollectExternalReferences();
+
+  static std::unique_ptr<ExternalReferenceRegistry> registry_;
+};
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_SNAPSHOT_BUILDER_H_

package/src/headers/18/node_snapshotable.h

@@ -0,0 +1,130 @@
+
+#ifndef SRC_NODE_SNAPSHOTABLE_H_
+#define SRC_NODE_SNAPSHOTABLE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "util.h"
+
+namespace node {
+
+class Environment;
+struct EnvSerializeInfo;
+struct SnapshotData;
+class ExternalReferenceRegistry;
+
+#define SERIALIZABLE_OBJECT_TYPES(V)                                           \
+  V(fs_binding_data, fs::BindingData)                                          \
+  V(v8_binding_data, v8_utils::BindingData)                                    \
+  V(blob_binding_data, BlobBindingData)                                        \
+  V(process_binding_data, process::BindingData)
+
+enum class EmbedderObjectType : uint8_t {
+  k_default = 0,
+#define V(PropertyName, NativeType) k_##PropertyName,
+  SERIALIZABLE_OBJECT_TYPES(V)
+#undef V
+};
+
+// When serializing an embedder object, we'll serialize the native states
+// into a chunk that can be mapped into a subclass of InternalFieldInfo,
+// and pass it into the V8 callback as the payload of StartupData.
+// TODO(joyeecheung): the classification of types seem to be wrong.
+// We'd need a type for each field of each class of native object.
+// Maybe it's fine - we'll just use the type to invoke BaseObject constructors
+// and specify that the BaseObject has only one field for us to serialize.
+// And for non-BaseObject embedder objects, we'll use field-wise types.
+// The memory chunk looks like this:
+//
+// [   type   ] - EmbedderObjectType (a uint8_t)
+// [  length  ] - a size_t
+// [    ...   ] - custom bytes of size |length - header size|
+struct InternalFieldInfo {
+  EmbedderObjectType type;
+  size_t length;
+
+  InternalFieldInfo() = delete;
+
+  static InternalFieldInfo* New(EmbedderObjectType type) {
+    return New(type, sizeof(InternalFieldInfo));
+  }
+
+  static InternalFieldInfo* New(EmbedderObjectType type, size_t length) {
+    InternalFieldInfo* result =
+        reinterpret_cast<InternalFieldInfo*>(::operator new[](length));
+    result->type = type;
+    result->length = length;
+    return result;
+  }
+
+  InternalFieldInfo* Copy() const {
+    InternalFieldInfo* result =
+        reinterpret_cast<InternalFieldInfo*>(::operator new[](length));
+    memcpy(result, this, length);
+    return result;
+  }
+
+  void Delete() { ::operator delete[](this); }
+};
+
+// An interface for snapshotable native objects to inherit from.
+// Use the SERIALIZABLE_OBJECT_METHODS() macro in the class to define
+// the following methods to implement:
+//
+// - PrepareForSerialization(): This would be run prior to context
+//   serialization. Use this method to e.g. release references that
+//   can be re-initialized, or perform property store operations
+//   that needs a V8 context.
+// - Serialize(): This would be called during context serialization,
+//   once for each embedder field of the object.
+//   Allocate and construct an InternalFieldInfo object that contains
+//   data that can be used to deserialize native states.
+// - Deserialize(): This would be called after the context is
+//   deserialized and the object graph is complete, once for each
+//   embedder field of the object. Use this to restore native states
+//   in the object.
+class SnapshotableObject : public BaseObject {
+ public:
+  SnapshotableObject(Environment* env,
+                     v8::Local<v8::Object> wrap,
+                     EmbedderObjectType type = EmbedderObjectType::k_default);
+  const char* GetTypeNameChars() const;
+
+  virtual void PrepareForSerialization(v8::Local<v8::Context> context,
+                                       v8::SnapshotCreator* creator) = 0;
+  virtual InternalFieldInfo* Serialize(int index) = 0;
+  bool is_snapshotable() const override { return true; }
+  // We'll make sure that the type is set in the constructor
+  EmbedderObjectType type() { return type_; }
+
+ private:
+  EmbedderObjectType type_;
+};
+
+#define SERIALIZABLE_OBJECT_METHODS()                                          \
+  void PrepareForSerialization(v8::Local<v8::Context> context,                 \
+                               v8::SnapshotCreator* creator) override;         \
+  InternalFieldInfo* Serialize(int index) override;                            \
+  static void Deserialize(v8::Local<v8::Context> context,                      \
+                          v8::Local<v8::Object> holder,                        \
+                          int index,                                           \
+                          InternalFieldInfo* info);
+
+v8::StartupData SerializeNodeContextInternalFields(v8::Local<v8::Object> holder,
+                                                   int index,
+                                                   void* env);
+void DeserializeNodeInternalFields(v8::Local<v8::Object> holder,
+                                   int index,
+                                   v8::StartupData payload,
+                                   void* env);
+void SerializeBindingData(Environment* env,
+                          v8::SnapshotCreator* creator,
+                          EnvSerializeInfo* info);
+
+bool IsSnapshotableType(FastStringKey key);
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_SNAPSHOTABLE_H_

package/src/headers/{12 → 18}/node_sockaddr-inl.h

@@ -4,9 +4,11 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "node.h"
+#include "env-inl.h"
 #include "node_internals.h"
 #include "node_sockaddr.h"
 #include "util-inl.h"
+#include "memory_tracker-inl.h"
 
 #include <string>
 
@@ -87,11 +89,11 @@ SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
 }
 
 const sockaddr& SocketAddress::operator*() const {
-  return *this->data();
+  return *data();
 }
 
 const sockaddr* SocketAddress::operator->() const {
-  return this->data();
+  return data();
 }
 
 size_t SocketAddress::length() const {
@@ -150,7 +152,12 @@ void SocketAddress::Update(uint8_t* data, size_t len) {
   memcpy(&address_, data, len);
 }
 
-v8::Local<v8::Object> SocketAddress::ToJS(
+void SocketAddress::Update(const sockaddr* data, size_t len) {
+  CHECK_LE(len, sizeof(address_));
+  memcpy(&address_, data, len);
+}
+
+v8::MaybeLocal<v8::Object> SocketAddress::ToJS(
     Environment* env,
     v8::Local<v8::Object> info) const {
   return AddressToJS(env, data(), info);
@@ -164,7 +171,96 @@ bool SocketAddress::operator==(const SocketAddress& other) const {
 bool SocketAddress::operator!=(const SocketAddress& other) const {
   return !(*this == other);
 }
+
+bool SocketAddress::operator<(const SocketAddress& other) const {
+  return compare(other) == CompareResult::LESS_THAN;
+}
+
+bool SocketAddress::operator>(const SocketAddress& other) const {
+  return compare(other) == CompareResult::GREATER_THAN;
+}
+
+bool SocketAddress::operator<=(const SocketAddress& other) const {
+  CompareResult c = compare(other);
+  return c == CompareResult::NOT_COMPARABLE ? false :
+              c <= CompareResult::SAME;
+}
+
+bool SocketAddress::operator>=(const SocketAddress& other) const {
+  return compare(other) >= CompareResult::SAME;
+}
+
+template <typename T>
+SocketAddressLRU<T>::SocketAddressLRU(
+    size_t max_size)
+    : max_size_(max_size) {}
+
+template <typename T>
+typename T::Type* SocketAddressLRU<T>::Peek(
+    const SocketAddress& address) const {
+  auto it = map_.find(address);
+  return it == std::end(map_) ? nullptr : &it->second->second;
+}
+
+template <typename T>
+void SocketAddressLRU<T>::CheckExpired() {
+  auto it = list_.rbegin();
+  while (it != list_.rend()) {
+    if (T::CheckExpired(it->first, it->second)) {
+      map_.erase(it->first);
+      list_.pop_back();
+      it = list_.rbegin();
+      continue;
+    } else {
+      break;
+    }
+  }
+}
+
+template <typename T>
+void SocketAddressLRU<T>::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackFieldWithSize("list", size() * sizeof(Pair));
+}
+
+// If an item already exists for the given address, bump up it's
+// position in the LRU list and return it. If the item does not
+// exist, create it. If an item is created, check the size of the
+// cache and adjust if necessary. Whether the item exists or not,
+// purge expired items.
+template <typename T>
+typename T::Type* SocketAddressLRU<T>::Upsert(
+    const SocketAddress& address) {
+
+  auto on_exit = OnScopeLeave([&]() { CheckExpired(); });
+
+  auto it = map_.find(address);
+  if (it != std::end(map_)) {
+    list_.splice(list_.begin(), list_, it->second);
+    T::Touch(it->first, &it->second->second);
+    return &it->second->second;
+  }
+
+  list_.push_front(Pair(address, { }));
+  map_[address] = list_.begin();
+  T::Touch(list_.begin()->first, &list_.begin()->second);
+
+  // Drop the last item in the list if we are
+  // over the size limit...
+  if (map_.size() > max_size_) {
+    auto last = list_.end();
+    map_.erase((--last)->first);
+    list_.pop_back();
+  }
+
+  return &map_[address]->second;
+}
+
+v8::MaybeLocal<v8::Value> SocketAddressBlockList::Rule::ToV8String(
+    Environment* env) {
+  std::string str = ToString();
+  return ToV8Value(env->context(), str);
+}
 }  // namespace node
 
-#endif  // NODE_WANT_INTERNALS
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 #endif  // SRC_NODE_SOCKADDR_INL_H_