mirror of
https://github.com/nodejs/node.git
synced 2025-05-01 08:42:45 +00:00
b697160256
So far, process initialization has been a bit all over the place in Node.js. `InitializeNodeWithArgs()` is our main public API for this, but inclusion of items in it vs. `InitializeOncePerProcess()` and `PlatformInit()` has been random at best. Likewise, some pieces of initialization have been guarded by `NODE_SHARED_MODE`, but also fairly randomly and without any meaningful connection to shared library usage. This leaves embedders in a position to cherry-pick some of the initialization code into their own code to make their application behave like typical Node.js applications to the degree to which they desire it. Electron takes an alternative route and makes direct use of `InitializeOncePerProcess()` already while it is a private API, with a `TODO` to add it to the public API in Node.js. This commit addresses that `TODO`, and `TODO`s around the `NODE_SHARED_MODE` usage. Specifically: - `InitializeOncePerProcess()` and `TearDownOncePerProcess()` are added to the public API. - The `flags` option of these functions are merged with the `flags` option for `InitializeNodeWithArgs()`, since they essentially share the same semantics. - The return value of the function is made an abstract class, rather than a struct, for easier API/ABI stability. - Initialization code from `main()` is brought into these functions (since that makes sense in general). - Add a `TODO` for turning `InitializeNodeWithArgs()` into a small wrapper around `InitializeOncePerProcess()` and eventually removing it (at least one major release cycle each, presumably). - Remove `NODE_SHARED_MODE` guards and replace them with runtime options. PR-URL: https://github.com/nodejs/node/pull/44121 Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com> Reviewed-By: Michael Dawson <midawson@redhat.com>
94 lines
2.7 KiB
C++
94 lines
2.7 KiB
C++
#include "node.h"
|
||
#include "uv.h"
|
||
#include <assert.h>
|
||
|
||
// Note: This file is being referred to from doc/api/embedding.md, and excerpts
|
||
// from it are included in the documentation. Try to keep these in sync.
|
||
|
||
using node::CommonEnvironmentSetup;
|
||
using node::Environment;
|
||
using node::MultiIsolatePlatform;
|
||
using v8::Context;
|
||
using v8::HandleScope;
|
||
using v8::Isolate;
|
||
using v8::Locker;
|
||
using v8::MaybeLocal;
|
||
using v8::V8;
|
||
using v8::Value;
|
||
|
||
static int RunNodeInstance(MultiIsolatePlatform* platform,
|
||
const std::vector<std::string>& args,
|
||
const std::vector<std::string>& exec_args);
|
||
|
||
int main(int argc, char** argv) {
|
||
argv = uv_setup_args(argc, argv);
|
||
std::vector<std::string> args(argv, argv + argc);
|
||
std::unique_ptr<node::InitializationResult> result =
|
||
node::InitializeOncePerProcess(
|
||
args,
|
||
{node::ProcessInitializationFlags::kNoInitializeV8,
|
||
node::ProcessInitializationFlags::kNoInitializeNodeV8Platform});
|
||
|
||
for (const std::string& error : result->errors())
|
||
fprintf(stderr, "%s: %s\n", args[0].c_str(), error.c_str());
|
||
if (result->early_return() != 0) {
|
||
return result->exit_code();
|
||
}
|
||
|
||
std::unique_ptr<MultiIsolatePlatform> platform =
|
||
MultiIsolatePlatform::Create(4);
|
||
V8::InitializePlatform(platform.get());
|
||
V8::Initialize();
|
||
|
||
int ret =
|
||
RunNodeInstance(platform.get(), result->args(), result->exec_args());
|
||
|
||
V8::Dispose();
|
||
V8::DisposePlatform();
|
||
|
||
node::TearDownOncePerProcess();
|
||
return ret;
|
||
}
|
||
|
||
int RunNodeInstance(MultiIsolatePlatform* platform,
|
||
const std::vector<std::string>& args,
|
||
const std::vector<std::string>& exec_args) {
|
||
int exit_code = 0;
|
||
|
||
std::vector<std::string> errors;
|
||
std::unique_ptr<CommonEnvironmentSetup> setup =
|
||
CommonEnvironmentSetup::Create(platform, &errors, args, exec_args);
|
||
if (!setup) {
|
||
for (const std::string& err : errors)
|
||
fprintf(stderr, "%s: %s\n", args[0].c_str(), err.c_str());
|
||
return 1;
|
||
}
|
||
|
||
Isolate* isolate = setup->isolate();
|
||
Environment* env = setup->env();
|
||
|
||
{
|
||
Locker locker(isolate);
|
||
Isolate::Scope isolate_scope(isolate);
|
||
HandleScope handle_scope(isolate);
|
||
Context::Scope context_scope(setup->context());
|
||
|
||
MaybeLocal<Value> loadenv_ret = node::LoadEnvironment(
|
||
env,
|
||
"const publicRequire ="
|
||
" require('module').createRequire(process.cwd() + '/');"
|
||
"globalThis.require = publicRequire;"
|
||
"globalThis.embedVars = { nön_ascıı: '🏳️🌈' };"
|
||
"require('vm').runInThisContext(process.argv[1]);");
|
||
|
||
if (loadenv_ret.IsEmpty()) // There has been a JS exception.
|
||
return 1;
|
||
|
||
exit_code = node::SpinEventLoop(env).FromMaybe(1);
|
||
|
||
node::Stop(env);
|
||
}
|
||
|
||
return exit_code;
|
||
}
|