feat: create Runtime public class

Signed-off-by: Hosung Kim [email protected]

Author: hs0225

deps/node/src/lwnode/lwnode-public.cc

@@ -20,10 +20,59 @@
 #include "lwnode.h"
 #include "lwnode/aul-event-receiver.h"
 #include "node.h"
+#include "node_main_lw_runner-inl.h"
 #include "trace.h"
 
+using namespace node;
+
 namespace lwnode {
 
+class Runtime::Internal {
+  friend Runtime;
+
+ public:
+  ~Internal() {
+    if (is_initialized && instance_) {
+      DisposeNode(instance_);
+    }
+  }
+
+  std::pair<bool, int> Init(int argc, char** argv) {
+    is_initialized = true;
+    return InitializeNode(argc, argv, &instance_);
+  }
+
+  int Run() {
+    if (instance_ == nullptr) {
+      return -1;
+    }
+
+    return runner_.Run(*instance_);
+    ;
+  }
+
+ private:
+  NodeMainInstance* instance_{nullptr};
+  LWNode::LWNodeMainRunner runner_;
+  bool is_initialized{false};
+};
+
+Runtime::Runtime() {
+  internal_ = new Internal();
+}
+
+Runtime::~Runtime() {
+  delete internal_;
+}
+
+std::pair<bool, int> Runtime::Init(int argc, char** argv) {
+  return internal_->Init(argc, argv);
+}
+
+int Runtime::Run() {
+  return internal_->Run();
+}
+
 bool ParseAULEvent(int argc, char** argv) {
   bool result = AULEventReceiver::getInstance()->start(argc, argv);
   if (result) {
@@ -73,8 +122,4 @@ void SetDlogID(const std::string& tag) {
 #endif
 }
 
-int Start(int argc, char** argv) {
-  return node::Start(argc, argv);
-}
-
 }  // namespace lwnode

deps/node/src/node.cc

@@ -1069,13 +1069,55 @@ void TearDownOncePerProcess() {
   per_process::v8_platform.Dispose();
 }
 
+#if defined(LWNODE)
+std::pair<bool, int> InitializeNode(int argc, char** argv, NodeMainInstance** main_instance) {
+  InitializationResult result = InitializeOncePerProcess(argc, argv);
+  if (result.early_return) {
+    return std::make_pair(true, result.exit_code);
+  }
+
+  Isolate::CreateParams params;
+  const std::vector<size_t>* indexes = nullptr;
+  std::vector<intptr_t> external_references;
+
+  bool force_no_snapshot =
+      per_process::cli_options->per_isolate->no_node_snapshot;
+  if (!force_no_snapshot) {
+    v8::StartupData* blob = NodeMainInstance::GetEmbeddedSnapshotBlob();
+    if (blob != nullptr) {
+      // TODO(joyeecheung): collect external references and set it in
+      // params.external_references.
+      external_references.push_back(reinterpret_cast<intptr_t>(nullptr));
+      params.external_references = external_references.data();
+      params.snapshot_blob = blob;
+      indexes = NodeMainInstance::GetIsolateDataIndexes();
+    }
+  }
+  uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME);
+
+  *main_instance = new NodeMainInstance(&params,
+                                        uv_default_loop(),
+                                        per_process::v8_platform.Platform(),
+                                        result.args,
+                                        result.exec_args,
+                                        indexes);
+  return std::make_pair(false, result.exit_code);
+}
+
+void DisposeNode(NodeMainInstance* main_instance) {
+  delete main_instance;
+
+  TearDownOncePerProcess();
+}
+#endif
+
 int Start(int argc, char** argv) {
   InitializationResult result = InitializeOncePerProcess(argc, argv);
   if (result.early_return) {
     return result.exit_code;
   }
 
-  #if defined(LWNODE)
+#if defined(LWNODE)
   LWNode::LWNodeMainRunner nodeMainRunner; // @lwnode
   {
     Isolate::CreateParams params;

deps/node/src/node.h

@@ -1069,6 +1069,12 @@ void RegisterSignalHandler(int signal,
                            bool reset_handler = false);
 #endif  // _WIN32
 
+#ifdef LWNODE // @lwnode
+class NodeMainInstance;
+std::pair<bool, int> InitializeNode(int argc, char** argv, NodeMainInstance** main_instance);
+void DisposeNode(NodeMainInstance* main_instance);
+#endif
+
 }  // namespace node
 
 #endif  // SRC_NODE_H_

deps/node/src/node_main_lw.cc

@@ -71,15 +71,24 @@ int main(int argc, char* argv[]) {
   setvbuf(stdout, nullptr, _IONBF, 0);
   setvbuf(stderr, nullptr, _IONBF, 0);
 
+  lwnode::Runtime runtime;
+  std::pair<bool, int> init_result; // early_return, exit_code
+
   if (lwnode::ParseAULEvent(argc, argv)) {
     if (!lwnode::InitScriptRootPath()) {
       exit(-errno);
     }
 
     char* args[] = {"", "index.js", nullptr};
-    return lwnode::Start(2, args);
+    init_result = runtime.Init(2, args);
+  } else {
+    // started by command line
+    init_result = runtime.Init(argc, argv);
+  }
+
+  if (init_result.first) {
+    return init_result.second;
   }
 
-  // started by command line
-  return lwnode::Start(argc, argv);
+  return runtime.Run();
 }

include/lwnode/lwnode-public.h

@@ -32,9 +32,26 @@ LWNODE_EXPORT bool ParseAULEvent(int argc, char** argv);
 // function.
 LWNODE_EXPORT bool InitScriptRootPath(const std::string path = "");
 
-// Sets the dlog tag id for debugging. This is only used on Tizen when not in AUL mode.
+// Sets the dlog tag id for debugging. This is only used on Tizen when not in
+// AUL mode.
 LWNODE_EXPORT void SetDlogID(const std::string& appId);
 
-LWNODE_EXPORT int Start(int argc, char** argv);
+class LWNODE_EXPORT Runtime {
+ public:
+  Runtime();
+  ~Runtime();
+
+  // Initializes the runtime and returns true if it early termination and sets
+  // the exit code to the second return value. Otherwise, it returns false
+  // and you need call Run() to run the runtime.
+  std::pair<bool, int> Init(int argc, char** argv);
+
+  // Runs the runtime and returns the exit code. The runtime must be initialized.
+  int Run();
+
+ private:
+  class Internal;
+  Internal* internal_ = nullptr;
+};
 
 }  // namespace lwnode