This is the second post in an ongoing series explaining the internals of Electron. Check out the first post about event loop integration if you haven't already.
Most people use Node for server-side applications, but because of Node's rich API set and thriving community, it is also a great fit for an embedded library. This post explains how Node is used as a library in Electron.
Sistema de criação
Tanto o Node quanto o Electron usam
GYP como sistemas de compilação. If you want to embed Node inside your app, you have to use it as your build system too.
GYP? Leia este guia antes de continuar mais nesta publicação.
. o arquivo yp no diretório de código fonte do Node descreve como o Node é criado, junto com várias variáveis do
GYP controlando quais partes do nó estão habilitadas e se devem abrir certas configurações.
To change the build flags, you need to set the variables in the
.gypi file of your project. The
configure script in Node can generate some common configurations for you, for example running
./configure --shared will generate a
config.gypi with variables instructing Node to be built as a shared library.
Electron does not use the
configure script since it has its own build scripts. As configurações para o Node são definidas no arquivo
common.gypi no diretório do código fonte raiz do Electron.
Link Node with Electron
In Electron, Node is being linked as a shared library by setting the
true, so Node's build type will be changed from
shared_library, and the source code containing the Node's
main entry point will not be compiled.
Since Electron uses the V8 library shipped with Chromium, the V8 library included in Node's source code is not used. This is done by setting both
Shared library or static library
When linking with Node, there are two options: you can either build Node as a static library and include it in the final executable, or you can build it as a shared library and ship it alongside the final executable.
In Electron, Node was built as a static library for a long time. This made the build simple, enabled the best compiler optimizations, and allowed Electron to be distributed without an extra
No entanto, isto mudou depois que o Chrome mudou para usar o BoringSSL. BoringSSL é um fork do OpenSSL que remove várias APIs não utilizadas e altera muitas interfaces existentes. Because Node still uses OpenSSL, the compiler would generate numerous linking errors due to conflicting symbols if they were linked together.
O Electron não pôde usar BoringSSL no Node, ou usar o OpenSSL no Chromium, então a única opção era mudar para construir o Node como uma biblioteca compartilhada, e esconde os símbolos BoringSSL e OpenSSL nos componentes de cada um.
This change brought Electron some positive side effects. Before this change, you could not rename the executable file of Electron on Windows if you used native modules because the name of the executable was hard coded in the import library. After Node was built as a shared library, this limitation was gone because all native modules were linked to
node.dll, whose name didn't need to be changed.
Supporting native modules
Módulos nativos no Node funcionam definindo uma função de entrada para carregar o Node e, em seguida, pesquisando os símbolos da V8 e da libuv do Node. This is a bit troublesome for embedders because by default the symbols of V8 and libuv are hidden when building Node as a library and native modules will fail to load because they cannot find the symbols.
So in order to make native modules work, the V8 and libuv symbols were exposed in Electron. Para V8 isso é feito forçando todos os símbolos no arquivo de configuração do Chromium a serem expostos. Para libuv, é alcançado definindo a definição
Starting Node in your app
After all the work of building and linking with Node, the final step is to run Node in your app.
Node doesn't provide many public APIs for embedding itself into other apps. Geralmente, você pode apenas chamar
node::Init para iniciar uma nova instância do Node. However, if you are building a complex app based on Node, you have to use APIs like
node::CreateEnvironment to precisely control every step.
In Electron, Node is started in two modes: the standalone mode that runs in the main process, which is similar to official Node binaries, and the embedded mode which inserts Node APIs into web pages. The details of this will be explained in a future post.