node/src/node_diagnostics_channel.h at 88481a3974317957f6e2804d5f2b09377872ba1b · nodejs/node · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#ifndef SRC_NODE_DIAGNOSTICS_CHANNEL_H_
#define SRC_NODE_DIAGNOSTICS_CHANNEL_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include <cinttypes>
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
#include "aliased_buffer.h"
#include "base_object.h"
#include "node_snapshotable.h"

namespace node {
class ExternalReferenceRegistry;

namespace diagnostics_channel {

class Channel;

class BindingData : public SnapshotableObject {
 public:
  static constexpr size_t kMaxChannels = 1024;

  struct InternalFieldInfo : public node::InternalFieldInfoBase {
    AliasedBufferIndex subscribers;
  };

  BindingData(Realm* realm,
              v8::Local<v8::Object> wrap,
              InternalFieldInfo* info = nullptr);

  SERIALIZABLE_OBJECT_METHODS()
  SET_BINDING_ID(diagnostics_channel_binding_data)

  void MemoryInfo(MemoryTracker* tracker) const override;
  SET_SELF_SIZE(BindingData)
  SET_MEMORY_INFO_NAME(BindingData)

  AliasedUint32Array subscribers_;

  uint32_t next_channel_index_ = 0;
  std::unordered_map<std::string, uint32_t> channel_indices_;

  uint32_t GetOrCreateChannelIndex(const std::string& name);

  v8::Global<v8::Function> link_callback_;
  v8::Global<v8::FunctionTemplate> channel_wrap_template_;
  std::vector<BaseObjectPtr<Channel>> channels_;

  static void GetOrCreateChannelIndex(
      const v8::FunctionCallbackInfo<v8::Value>& args);
  static void LinkNativeChannel(
      const v8::FunctionCallbackInfo<v8::Value>& args);

  using ChannelStatusCallback = std::function<void(bool is_active)>;
  void SetChannelStatusCallback(uint32_t index, ChannelStatusCallback cb);

  static void NotifyChannelActive(
      const v8::FunctionCallbackInfo<v8::Value>& args);
  static void NotifyChannelInactive(
      const v8::FunctionCallbackInfo<v8::Value>& args);

  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 RegisterExternalReferences(ExternalReferenceRegistry* registry);

 private:
  InternalFieldInfo* internal_field_info_ = nullptr;
  std::unordered_map<uint32_t, ChannelStatusCallback> channel_status_callbacks_;
};

class Channel : public BaseObject {
 public:
  // Public for MakeDetachedBaseObject.
  Channel(Environment* env,
          v8::Local<v8::Object> wrap,
          BindingData* binding_data,
          uint32_t index,
          std::string name);

  // Returns a non-owning pointer. Lifetime is managed by BindingData.
  static Channel* Get(Environment* env, const char* name);

  inline bool HasSubscribers() const {
    return binding_data_ != nullptr && binding_data_->subscribers_[index_] > 0;
  }

  void Publish(Environment* env, v8::Local<v8::Value> message);

  void Link(v8::Isolate* isolate, v8::Local<v8::Object> js_channel);

  inline bool IsLinked() const { return !js_channel_.IsEmpty(); }

  void Unlink();

  void MemoryInfo(MemoryTracker* tracker) const override;
  SET_MEMORY_INFO_NAME(Channel)
  SET_SELF_SIZE(Channel)

 private:
  friend class BindingData;

  void CachePublishFn(v8::Isolate* isolate, v8::Local<v8::Object> js_channel);

  BindingData* binding_data_;
  uint32_t index_;
  std::string name_;
  v8::Global<v8::Object> js_channel_;
  v8::Global<v8::Function> publish_fn_;
};

}  // namespace diagnostics_channel
}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_NODE_DIAGNOSTICS_CHANNEL_H_