lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
12956 Commits
131 Branches
446 Tags
325 MiB
Tree: 8221917e85
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8221917e85'
${ noResults }
node/src/env.h

614 lines
29 KiB
Raw Normal View History

src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now "remember" the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
#ifndef SRC_ENV_H_
#define SRC_ENV_H_
#include "ares.h"
src: move debug agent from deps/ to src/ There is not much point in keeping it a separate project because it doesn't build standalone, plus it makes applying changes to core more difficult because of the implicit dependency on header files in src/.
10 years ago
#include "debug-agent.h"
src: switch from QUEUE to intrusive list This commit also breaks up req_wrap.h into req-wrap.h and req-wrap-inl.h to work around a circular dependency issue in env.h. PR-URL: https://github.com/iojs/io.js/pull/667 Reviewed-By: Fedor Indutny <fedor.indutny@gmail.com> Reviewed-By: Trevor Norris <trev.norris@gmail.com>
10 years ago
#include "handle_wrap.h"
#include "req-wrap.h"
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now "remember" the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
#include "tree.h"
#include "util.h"
#include "uv.h"
#include "v8.h"
#include <stdint.h>
// Caveat emptor: we're going slightly crazy with macros here but the end
// hopefully justifies the means. We have a lot of per-context properties
// and adding and maintaining their getters and setters by hand would be
// a nightmare so let's make the preprocessor generate them for us.
//
// Make sure that any macros defined here are undefined again at the bottom
src: change kIsolateSlot to 3 The slot 0 and 1 had already been taken by &#34;gin&#34; and &#34;blink&#34; in Chrome, and the size of isolate&#39;s slots is 4 by default, so using 3 should hopefully make node work independently when embedded into other application. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
// of context-inl.h. The exceptions are NODE_CONTEXT_EMBEDDER_DATA_INDEX
// and NODE_ISOLATE_SLOT, they may have been defined externally.
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
namespace node {
// Pick an index that's hopefully out of the way when we're embedded inside
// another application. Performance-wise or memory-wise it doesn't matter:
// Context::SetAlignedPointerInEmbedderData() is backed by a FixedArray,
// worst case we pay a one-time penalty for resizing the array.
#ifndef NODE_CONTEXT_EMBEDDER_DATA_INDEX
#define NODE_CONTEXT_EMBEDDER_DATA_INDEX 32
#endif
src: change kIsolateSlot to 3 The slot 0 and 1 had already been taken by &#34;gin&#34; and &#34;blink&#34; in Chrome, and the size of isolate&#39;s slots is 4 by default, so using 3 should hopefully make node work independently when embedded into other application. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
// The slot 0 and 1 had already been taken by "gin" and "blink" in Chrome,
// and the size of isolate's slots is 4 by default, so using 3 should
// hopefully make node work independently when embedded into other
// application.
#ifndef NODE_ISOLATE_SLOT
#define NODE_ISOLATE_SLOT 3
#endif
node: fix erroneously named function call The initial implementation of setPropByIndex() set the value of an Array by index during development. Though the final form of the function simply pushes passed values to an array as passed by arguments. Thus the functions have been renamed to pushValueToArray() and push_values_to_array_function() respectively. Also add define for maximum number of arguments should be used before hitting the limit of performance increase. Fixes: 494227b &#34;node: improve GetActiveRequests performance&#34; PR-URL: https://github.com/nodejs/node/pull/3780 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
9 years ago
// The number of items passed to push_values_to_array_function has diminishing
// returns around 8. This should be used at all call sites using said function.
#ifndef NODE_PUSH_VAL_TO_ARRAY_MAX
#define NODE_PUSH_VAL_TO_ARRAY_MAX 8
#endif
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
// Strings are per-isolate primitives but Environment proxies them
src: internalize per-isolate string properties Speeds up property lookups a little and it creates the string in the old space straight away. It&#39;s a little easier on the garbage collector because it doesn&#39;t have to track eternalized strings in the new space. PR-URL: https://github.com/nodejs/node/pull/3060 Reviewed-By: James M Snell &lt;jasnell@gmail.com&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
9 years ago
// for the sake of convenience. Strings should be ASCII-only.
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
#define PER_ISOLATE_STRING_PROPERTIES(V) \
V(address_string, "address") \
tls, crypto: add ALPN Support ALPN is added to tls according to RFC7301, which supersedes NPN. When the server receives both NPN and ALPN extensions from the client, ALPN takes precedence over NPN and the server does not send NPN extension to the client. alpnProtocol in TLSSocket always returns false when no selected protocol exists by ALPN. In https server, http/1.1 token is always set when no options.ALPNProtocols exists. PR-URL: https://github.com/nodejs/node/pull/2564 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
V(alpn_buffer_string, "alpnBuffer") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(args_string, "args") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(argv_string, "argv") \
module: always decorate thrown errors This provides more information when encountering a syntax or similar error when executing a file with require(). Fixes: https://github.com/nodejs/node/issues/4286 PR-URL: https://github.com/nodejs/node/pull/4287 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Colin Ihrig &lt;cjihrig@gmail.com&gt;
9 years ago
V(arrow_message_string, "node:arrowMessage") \
src: add tracing.v8.on(&#39;gc&#39;) statistics hooks Add a new &#39;tracing&#39; module with a v8 property that lets the user register listeners for gc events. The listeners are invoked after every garbage collection cycle with &#39;before&#39; and &#39;after&#39; statistics. Useful for monitoring tools that want to keep track of memory usage.
11 years ago
V(async, "async") \
async-wrap: add event hooks Call a user-defined callback at specific points in the lifetime of an asynchronous event. Which are on instantiation, just before/after the callback has been run. **If any of these callbacks throws an exception, there is no forgiveness or recovery. A message will be displayed and a core file dumped.** Currently these only tie into AsyncWrap, meaning no call to a hook callback will be made for timers or process.nextTick() events. Though those will be added in a future commit. Here are a few notes on how to make the hooks work: - The &#34;this&#34; of all event hook callbacks is the request object. - The zero field (kCallInitHook) of the flags object passed to setupHooks() must be set != 0 before the init callback will be called. - kCallInitHook only affects the calling of the init callback. If the request object has been run through the create callback it will always run the before/after callbacks. Regardless of kCallInitHook. - In the init callback the property &#34;_asyncQueue&#34; must be attached to the request object. e.g. function initHook() { this._asyncQueue = {}; } - DO NOT inspect the properties of the object in the init callback. Since the object is in the middle of being instantiated there are some cases when a getter is not complete, and doing so will cause Node to crash. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
V(async_queue_string, "_asyncQueue") \
src: add tracing.v8.on(&#39;gc&#39;) statistics hooks Add a new &#39;tracing&#39; module with a v8 property that lets the user register listeners for gc events. The listeners are invoked after every garbage collection cycle with &#39;before&#39; and &#39;after&#39; statistics. Useful for monitoring tools that want to keep track of memory usage.
11 years ago
V(atime_string, "atime") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(birthtime_string, "birthtime") \
V(blksize_string, "blksize") \
V(blocks_string, "blocks") \
V(buffer_string, "buffer") \
V(bytes_string, "bytes") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(bytes_parsed_string, "bytesParsed") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(callback_string, "callback") \
V(change_string, "change") \
tls: use `SSL_set_cert_cb` for async SNI/OCSP Do not enable ClientHello parser for async SNI/OCSP. Use new OpenSSL-1.0.2&#39;s API `SSL_set_cert_cb` to pause the handshake process and load the cert/OCSP response asynchronously. Hopefuly this will make whole async SNI/OCSP process much faster and will eventually let us remove the ClientHello parser itself (which is currently used only for async session, see #1462 for the discussion of removing it). NOTE: Ported our code to `SSL_CTX_add1_chain_cert` to use `SSL_CTX_get0_chain_certs` in `CertCbDone`. Test provided for this feature. Fix: https://github.com/iojs/io.js/issues/1423 PR-URL: https://github.com/iojs/io.js/pull/1464 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
V(oncertcb_string, "oncertcb") \
timers: make Timer.close idempotent fixes #1287 PR-URL: https://github.com/iojs/io.js/pull/1288 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
V(onclose_string, "_onclose") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(code_string, "code") \
buffer: add compare and equals methods compare() works like String.localeCompare such that: Buffer.compare(a, b) === a.compare(b); equals() does a native check to see if two buffers are equal. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
V(compare_string, "compare") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(ctime_string, "ctime") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(cwd_string, "cwd") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(debug_port_string, "debugPort") \
V(debug_string, "debug") \
module: always decorate thrown errors This provides more information when encountering a syntax or similar error when executing a file with require(). Fixes: https://github.com/nodejs/node/issues/4286 PR-URL: https://github.com/nodejs/node/pull/4287 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Colin Ihrig &lt;cjihrig@gmail.com&gt;
9 years ago
V(decorated_string, "node:decorated") \
fs: improve error messages * Include a description for the error message * For rename, link, and symlink, include both the source and destination path in the error message. * Expose the destination path as the `dest` property on the error object. * Fix a bug where `ThrowUVException()` would incorrectly delegate to `Environment::TrowErrnoException()`. API impact: * Adds an extra overload for node::UVException() which takes 6 arguments. PR: https://github.com/iojs/io.js/pull/675 Fixes: https://github.com/iojs/io.js/issues/207 Closes: https://github.com/iojs/io.js/pull/293 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
V(dest_string, "dest") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(detached_string, "detached") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(dev_string, "dev") \
V(disposed_string, "_disposed") \
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
V(domain_string, "domain") \
src: fix --abort-on-uncaught-exception Revert 0af4c9ea7434e4f505dbe071357e4bc3b4ab2a8a, parts of 921f2de6cf999b5a4663615e37967b4269d755fe and port https://github.com/nodejs/node-v0.x-archive/pull/25835 from v0.12 to master so that node aborts at the right time when an error is thrown and --abort-on-uncaught-exception is used. Fixes #3035. PR: #3036 PR-URL: https://github.com/nodejs/node/pull/3036 Reviewed-By: Ben Noordhuis &lt;ben@strongloop.com&gt;
9 years ago
V(emitting_top_level_domain_error_string, "_emittingTopLevelDomainError") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(exchange_string, "exchange") \
V(idle_string, "idle") \
V(irq_string, "irq") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(enter_string, "enter") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(env_pairs_string, "envPairs") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(env_string, "env") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(errno_string, "errno") \
tls_wrap: propagate errors to write callbacks fix #6903
11 years ago
V(error_string, "error") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(events_string, "_events") \
V(exec_argv_string, "execArgv") \
V(exec_path_string, "execPath") \
V(exiting_string, "_exiting") \
V(exit_code_string, "exitCode") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(exit_string, "exit") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(expire_string, "expire") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(exponent_string, "exponent") \
V(exports_string, "exports") \
V(ext_key_usage_string, "ext_key_usage") \
stream_base: various improvements Expose and use in TLSWrap an `v8::External` wrap of the `StreamBase*` pointer instead of guessing the ancestor C++ class in `node_wrap.h`. Make use of `StreamBase::Callback` structure for storing/passing both callback and context in a single object. Introduce `GetObject()` for future user-land usage, when a child class is not going to be inherited from AsyncWrap. PR-URL: https://github.com/nodejs/node/pull/2351 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
V(external_stream_string, "_externalStream") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(family_string, "family") \
V(fatal_exception_string, "_fatalException") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(fd_string, "fd") \
V(file_string, "file") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(fingerprint_string, "fingerprint") \
src: add tracing.v8.on(&#39;gc&#39;) statistics hooks Add a new &#39;tracing&#39; module with a v8 property that lets the user register listeners for gc events. The listeners are invoked after every garbage collection cycle with &#39;before&#39; and &#39;after&#39; statistics. Useful for monitoring tools that want to keep track of memory usage.
11 years ago
V(flags_string, "flags") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(fsevent_string, "FSEvent") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(gid_string, "gid") \
V(handle_string, "handle") \
V(heap_total_string, "heapTotal") \
V(heap_used_string, "heapUsed") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(hostmaster_string, "hostmaster") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(ignore_string, "ignore") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(immediate_callback_string, "_immediateCallback") \
tls: support OCSP on client and server
11 years ago
V(infoaccess_string, "infoAccess") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(inherit_string, "inherit") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(ino_string, "ino") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(input_string, "input") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(internal_string, "internal") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(ipv4_string, "IPv4") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(ipv6_lc_string, "ipv6") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(ipv6_string, "IPv6") \
streams: introduce StreamWrap and JSStream Introduce a way to wrap plain-js `stream.Duplex` streams into C++ StreamBase&#39;s child class. With such method at hand it is now possible to pass `stream.Duplex` instance as a `socket` parameter to `tls.connect()`. PR-URL: https://github.com/iojs/io.js/pull/926 Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
V(isalive_string, "isAlive") \
V(isclosing_string, "isClosing") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(issuer_string, "issuer") \
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
V(issuercert_string, "issuerCertificate") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(kill_signal_string, "killSignal") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(mac_string, "mac") \
src: add tracing.v8.on(&#39;gc&#39;) statistics hooks Add a new &#39;tracing&#39; module with a v8 property that lets the user register listeners for gc events. The listeners are invoked after every garbage collection cycle with &#39;before&#39; and &#39;after&#39; statistics. Useful for monitoring tools that want to keep track of memory usage.
11 years ago
V(mark_sweep_compact_string, "mark-sweep-compact") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(max_buffer_string, "maxBuffer") \
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
V(message_string, "message") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(minttl_string, "minttl") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(mode_string, "mode") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(model_string, "model") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(modulus_string, "modulus") \
V(mtime_string, "mtime") \
V(name_string, "name") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(need_imm_cb_string, "_needImmediateCallback") \
V(netmask_string, "netmask") \
V(nice_string, "nice") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(nlink_string, "nlink") \
tls,crypto: move NPN protcol data to hidden value This fix is to be consistent implementation with ALPN. Tow NPN protocol data in the persistent memebers move to hidden variables in the wrap object. PR-URL: https://github.com/nodejs/node/pull/2564 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
9 years ago
V(npn_buffer_string, "npnBuffer") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(nsname_string, "nsname") \
tls: support OCSP on client and server
11 years ago
V(ocsp_request_string, "OCSPRequest") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(offset_string, "offset") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(onchange_string, "onchange") \
V(onclienthello_string, "onclienthello") \
V(oncomplete_string, "oncomplete") \
V(onconnection_string, "onconnection") \
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
V(ondone_string, "ondone") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(onerror_string, "onerror") \
V(onexit_string, "onexit") \
V(onhandshakedone_string, "onhandshakedone") \
V(onhandshakestart_string, "onhandshakestart") \
V(onmessage_string, "onmessage") \
V(onnewsession_string, "onnewsession") \
tls: introduce asynchronous `newSession` fix #7105
11 years ago
V(onnewsessiondone_string, "onnewsessiondone") \
tls: support OCSP on client and server
11 years ago
V(onocspresponse_string, "onocspresponse") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(onread_string, "onread") \
streams: introduce StreamWrap and JSStream Introduce a way to wrap plain-js `stream.Duplex` streams into C++ StreamBase&#39;s child class. With such method at hand it is now possible to pass `stream.Duplex` instance as a `socket` parameter to `tls.connect()`. PR-URL: https://github.com/iojs/io.js/pull/926 Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
V(onreadstart_string, "onreadstart") \
V(onreadstop_string, "onreadstop") \
async-wrap: integrate with WeakObject Making WeakObject inherit from AsyncWrap allows us to peak into almost all the MakeCallback calls in Node internals.
11 years ago
V(onselect_string, "onselect") \
streams: introduce StreamWrap and JSStream Introduce a way to wrap plain-js `stream.Duplex` streams into C++ StreamBase&#39;s child class. With such method at hand it is now possible to pass `stream.Duplex` instance as a `socket` parameter to `tls.connect()`. PR-URL: https://github.com/iojs/io.js/pull/926 Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
V(onshutdown_string, "onshutdown") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(onsignal_string, "onsignal") \
V(onstop_string, "onstop") \
streams: introduce StreamWrap and JSStream Introduce a way to wrap plain-js `stream.Duplex` streams into C++ StreamBase&#39;s child class. With such method at hand it is now possible to pass `stream.Duplex` instance as a `socket` parameter to `tls.connect()`. PR-URL: https://github.com/iojs/io.js/pull/926 Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
V(onwrite_string, "onwrite") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(output_string, "output") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(order_string, "order") \
V(owner_string, "owner") \
V(parse_error_string, "Parse Error") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(path_string, "path") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(pbkdf2_error_string, "PBKDF2 Error") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(pid_string, "pid") \
V(pipe_string, "pipe") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(port_string, "port") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(preference_string, "preference") \
V(priority_string, "priority") \
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
V(processed_string, "processed") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(prototype_string, "prototype") \
tls: `getPeerCertificate(detailed)` Add `raw` property to certificate, add mode to output full certificate chain.
11 years ago
V(raw_string, "raw") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(rdev_string, "rdev") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(readable_string, "readable") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(received_shutdown_string, "receivedShutdown") \
V(refresh_string, "refresh") \
V(regexp_string, "regexp") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(rename_string, "rename") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(replacement_string, "replacement") \
V(retry_string, "retry") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(rss_string, "rss") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(serial_string, "serial") \
src: add tracing.v8.on(&#39;gc&#39;) statistics hooks Add a new &#39;tracing&#39; module with a v8 property that lets the user register listeners for gc events. The listeners are invoked after every garbage collection cycle with &#39;before&#39; and &#39;after&#39; statistics. Useful for monitoring tools that want to keep track of memory usage.
11 years ago
V(scavenge_string, "scavenge") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(scopeid_string, "scopeid") \
tls,crypto: move NPN protcol data to hidden value This fix is to be consistent implementation with ALPN. Tow NPN protocol data in the persistent memebers move to hidden variables in the wrap object. PR-URL: https://github.com/nodejs/node/pull/2564 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
9 years ago
V(selected_npn_buffer_string, "selectedNpnBuffer") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(sent_shutdown_string, "sentShutdown") \
tls: add serialNumber to getPeerCertificate() Add a &#39;serialNumber&#39; property to the object that is returned by tls.CryptoStream#getPeerCertificate(). Contains the certificate&#39;s serial number encoded as a hex string. The format is identical to `openssl x509 -serial -in path/to/certificate`. Fixes #6583.
11 years ago
V(serial_number_string, "serialNumber") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(service_string, "service") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(servername_string, "servername") \
V(session_id_string, "sessionId") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(signal_string, "signal") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(size_string, "size") \
tls: fix crash in SNICallback `tls_wrap.cc` was crashing in an `Unwrap` call, when non `SecureContext` object was passed to it. Check that the passed object is a `SecureContext` instance before unwrapping it. fix #7008
11 years ago
V(sni_context_err_string, "Invalid SNI context") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(sni_context_string, "sni_context") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(speed_string, "speed") \
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
V(stack_string, "stack") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(status_string, "status") \
V(stdio_string, "stdio") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(subject_string, "subject") \
V(subjectaltname_string, "subjectaltname") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(sys_string, "sys") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(syscall_string, "syscall") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(tick_callback_string, "_tickCallback") \
V(tick_domain_cb_string, "_tickDomainCallback") \
tls: introduce internal `onticketkeycallback` `enableTicketKeyCallback` and `onticketkeycallback` could be potentially used to renew the TLS Session Tickets before they expire. However this commit will introduce it only for private use yet, because we are not sure about the API, and already need this feature for testing. See: https://github.com/nodejs/io.js/issues/2304 PR-URL: https://github.com/nodejs/io.js/pull/2312 Reviewed-By: Shigeki Ohtsu &lt;ohtsu@iij.ad.jp&gt;
10 years ago
V(ticketkeycallback_string, "onticketkeycallback") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(timeout_string, "timeout") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(times_string, "times") \
src: add tracing.v8.on(&#39;gc&#39;) statistics hooks Add a new &#39;tracing&#39; module with a v8 property that lets the user register listeners for gc events. The listeners are invoked after every garbage collection cycle with &#39;before&#39; and &#39;after&#39; statistics. Useful for monitoring tools that want to keep track of memory usage.
11 years ago
V(timestamp_string, "timestamp") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(title_string, "title") \
V(tls_npn_string, "tls_npn") \
tls, crypto: add ALPN Support ALPN is added to tls according to RFC7301, which supersedes NPN. When the server receives both NPN and ALPN extensions from the client, ALPN takes precedence over NPN and the server does not send NPN extension to the client. alpnProtocol in TLSSocket always returns false when no selected protocol exists by ALPN. In https server, http/1.1 token is always set when no options.ALPNProtocols exists. PR-URL: https://github.com/nodejs/node/pull/2564 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
V(tls_alpn_string, "tls_alpn") \
tls: support OCSP on client and server
11 years ago
V(tls_ocsp_string, "tls_ocsp") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(tls_sni_string, "tls_sni") \
V(tls_string, "tls") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(tls_ticket_string, "tlsTicket") \
src: add tracing.v8.on(&#39;gc&#39;) statistics hooks Add a new &#39;tracing&#39; module with a v8 property that lets the user register listeners for gc events. The listeners are invoked after every garbage collection cycle with &#39;before&#39; and &#39;after&#39; statistics. Useful for monitoring tools that want to keep track of memory usage.
11 years ago
V(type_string, "type") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(uid_string, "uid") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(unknown_string, "<unknown>") \
V(user_string, "user") \
V(uv_string, "uv") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(valid_from_string, "valid_from") \
V(valid_to_string, "valid_to") \
crypto: allow custom generator for DiffieHellman
11 years ago
V(verify_error_string, "verifyError") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(version_string, "version") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(weight_string, "weight") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(windows_verbatim_arguments_string, "windowsVerbatimArguments") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(wrap_string, "wrap") \
bindings: add spawn_sync bindings This implements a nested event loop that makes it possible to control a child process, while blocking the main loop until the process exits.
11 years ago
V(writable_string, "writable") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(write_queue_size_string, "writeQueueSize") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(x_forwarded_string, "x-forwarded-for") \
V(zero_return_string, "ZERO_RETURN") \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
#define ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V) \
src: make accessors immune to context confusion It&#39;s possible for an accessor or named interceptor to get called with a different execution context than the one it lives in, see the test case for an example using the debug API. This commit fortifies against that by passing the environment as a data property instead of looking it up through the current context. Fixes: https://github.com/iojs/io.js/issues/1190 (again) PR-URL: https://github.com/iojs/io.js/pull/1238 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
V(as_external, v8::External) \
node: fix erroneously named function call The initial implementation of setPropByIndex() set the value of an Array by index during development. Though the final form of the function simply pushes passed values to an array as passed by arguments. Thus the functions have been renamed to pushValueToArray() and push_values_to_array_function() respectively. Also add define for maximum number of arguments should be used before hitting the limit of performance increase. Fixes: 494227b &#34;node: improve GetActiveRequests performance&#34; PR-URL: https://github.com/nodejs/node/pull/3780 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
9 years ago
V(async_hooks_destroy_function, v8::Function) \
async-wrap: add event hooks Call a user-defined callback at specific points in the lifetime of an asynchronous event. Which are on instantiation, just before/after the callback has been run. **If any of these callbacks throws an exception, there is no forgiveness or recovery. A message will be displayed and a core file dumped.** Currently these only tie into AsyncWrap, meaning no call to a hook callback will be made for timers or process.nextTick() events. Though those will be added in a future commit. Here are a few notes on how to make the hooks work: - The &#34;this&#34; of all event hook callbacks is the request object. - The zero field (kCallInitHook) of the flags object passed to setupHooks() must be set != 0 before the init callback will be called. - kCallInitHook only affects the calling of the init callback. If the request object has been run through the create callback it will always run the before/after callbacks. Regardless of kCallInitHook. - In the init callback the property &#34;_asyncQueue&#34; must be attached to the request object. e.g. function initHook() { this._asyncQueue = {}; } - DO NOT inspect the properties of the object in the init callback. Since the object is in the middle of being instantiated there are some cases when a getter is not complete, and doing so will cause Node to crash. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
V(async_hooks_init_function, v8::Function) \
V(async_hooks_post_function, v8::Function) \
node: fix erroneously named function call The initial implementation of setPropByIndex() set the value of an Array by index during development. Though the final form of the function simply pushes passed values to an array as passed by arguments. Thus the functions have been renamed to pushValueToArray() and push_values_to_array_function() respectively. Also add define for maximum number of arguments should be used before hitting the limit of performance increase. Fixes: 494227b &#34;node: improve GetActiveRequests performance&#34; PR-URL: https://github.com/nodejs/node/pull/3780 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
9 years ago
V(async_hooks_pre_function, v8::Function) \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(binding_cache_object, v8::Object) \
V(buffer_constructor_function, v8::Function) \
buffer: implement Uint8Array backed Buffer With V8 4.4 removing the external array data API currently used by Buffer, the new implementation uses the Uint8Array to back Buffer. Buffers now have a maximum size of Smi::kMaxLength, as defined by V8. Which is ~2 GB on 64 bit and ~1 GB on 32 bit. The flag --use-old-buffer allows using the old Buffer implementation. This flag will be removed once V8 4.4 has landed. The two JS Buffer implementations have been split into two files for simplicity. Use getter to return expected .parent/.offset values for backwards compatibility. PR-URL: https://github.com/nodejs/io.js/pull/1825 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
V(buffer_prototype_object, v8::Object) \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(context, v8::Context) \
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
V(domain_array, v8::Array) \
domains: fix handling of uncaught exceptions Fix node exiting due to an exception being thrown rather than emitting an `&#39;uncaughtException&#39;` event on the process object when: 1. no error handler is set on the domain within which an error is thrown 2. an `&#39;uncaughtException&#39;` event listener is set on the process Also fix an issue where the process would not abort in the proper function call if an error is thrown within a domain with no error handler and `--abort-on-uncaught-exception` is used. Finally, change the behavior of --abort-on-uncaught-exception so that, if the domain within which the error is thrown has no error handler, but a domain further up the domains stack has one, the process will not abort. Fixes #3607 and #3653. PR: #3654 PR-URL: https://github.com/nodejs/node/pull/3654 Reviewed-By: Chris Dickinson &lt;chris@neversaw.us&gt;
9 years ago
V(domains_stack_array, v8::Array) \
fs: improve performance of all stat functions By building the fs.Stats object in JS, which is returned by all fs stat functions, calls to v8::Object::Set() are removed. This also includes creating all associated Date objects in JS, rather than using v8::Date::New(). Both these changes have significant performance gains. Note that the returned value from fs.stat changes slightly for non-POSIX systems. Whereas before the stats object would be missing blocks and blksize keys, it now has these keys with undefined as the value. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
V(fs_stats_constructor_function, v8::Function) \
async_wrap: ensure all objects have internal field If the constructor can&#39;t assign a class id then the heap snapshot will not be able to report the object. So ensure that all AsyncWrap instances use a FunctionTemplate instance with an internal field count &gt;= 1. PR-URL: https://github.com/nodejs/node/pull/3139 Reviewed-By: Fedor Indutny &lt;fedor.indutny@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-by: Stephen Belanger &lt;admin@stephenbelanger.com&gt;
9 years ago
V(generic_internal_field_template, v8::ObjectTemplate) \
streams: introduce StreamWrap and JSStream Introduce a way to wrap plain-js `stream.Duplex` streams into C++ StreamBase&#39;s child class. With such method at hand it is now possible to pass `stream.Duplex` instance as a `socket` parameter to `tls.connect()`. PR-URL: https://github.com/iojs/io.js/pull/926 Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
V(jsstream_constructor_template, v8::FunctionTemplate) \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(module_load_list_array, v8::Array) \
V(pipe_constructor_template, v8::FunctionTemplate) \
V(process_object, v8::Object) \
node: implement unhandled rejection tracking Implement unhandled rejection tracking for promises as specified in https://gist.github.com/benjamingr/0237932cee84712951a2 Fixes #256 PR-URL: https://github.com/iojs/io.js/pull/758 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Domenic Denicola &lt;domenic@domenicdenicola.com&gt;
10 years ago
V(promise_reject_function, v8::Function) \
node: fix erroneously named function call The initial implementation of setPropByIndex() set the value of an Array by index during development. Though the final form of the function simply pushes passed values to an array as passed by arguments. Thus the functions have been renamed to pushValueToArray() and push_values_to_array_function() respectively. Also add define for maximum number of arguments should be used before hitting the limit of performance increase. Fixes: 494227b &#34;node: improve GetActiveRequests performance&#34; PR-URL: https://github.com/nodejs/node/pull/3780 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
9 years ago
V(push_values_to_array_function, v8::Function) \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(script_context_constructor_template, v8::FunctionTemplate) \
V(script_data_constructor_function, v8::Function) \
V(secure_context_constructor_template, v8::FunctionTemplate) \
V(tcp_constructor_template, v8::FunctionTemplate) \
V(tick_callback_function, v8::Function) \
V(tls_wrap_constructor_function, v8::Function) \
stream_base: introduce StreamBase StreamBase is an improved way to write C++ streams. The class itself is for separting `StreamWrap` (with the methods like `.writeAsciiString`, `.writeBuffer`, `.writev`, etc) from the `HandleWrap` class, making possible to write abstract C++ streams that are not bound to any uv socket. The following methods are important part of the abstraction (which mimics libuv&#39;s stream API): * Events: * `OnAlloc(size_t size, uv_buf_t*)` * `OnRead(ssize_t nread, const uv_buf_t*, uv_handle_type pending)` * `OnAfterWrite(WriteWrap*)` * Wrappers: * `DoShutdown(ShutdownWrap*)` * `DoTryWrite(uv_buf_t** bufs, size_t* count)` * `DoWrite(WriteWrap*, uv_buf_t*, size_t count, uv_stream_t* handle)` * `Error()` * `ClearError()` The implementation should provide all of these methods, thus providing the access to the underlying resource (be it uv handle, TLS socket, or anything else). A C++ stream may consume the input of another stream by replacing the event callbacks and proxying the writes. This kind of API is actually used now for the TLSWrap implementation, making it possible to wrap TLS stream into another TLS stream. Thus legacy API calls are no longer required in `_tls_wrap.js`. PR-URL: https://github.com/iojs/io.js/pull/840 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
V(tls_wrap_constructor_template, v8::FunctionTemplate) \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
V(tty_constructor_template, v8::FunctionTemplate) \
V(udp_constructor_function, v8::Function) \
stream_base: introduce StreamBase StreamBase is an improved way to write C++ streams. The class itself is for separting `StreamWrap` (with the methods like `.writeAsciiString`, `.writeBuffer`, `.writev`, etc) from the `HandleWrap` class, making possible to write abstract C++ streams that are not bound to any uv socket. The following methods are important part of the abstraction (which mimics libuv&#39;s stream API): * Events: * `OnAlloc(size_t size, uv_buf_t*)` * `OnRead(ssize_t nread, const uv_buf_t*, uv_handle_type pending)` * `OnAfterWrite(WriteWrap*)` * Wrappers: * `DoShutdown(ShutdownWrap*)` * `DoTryWrite(uv_buf_t** bufs, size_t* count)` * `DoWrite(WriteWrap*, uv_buf_t*, size_t count, uv_stream_t* handle)` * `Error()` * `ClearError()` The implementation should provide all of these methods, thus providing the access to the underlying resource (be it uv handle, TLS socket, or anything else). A C++ stream may consume the input of another stream by replacing the event callbacks and proxying the writes. This kind of API is actually used now for the TLSWrap implementation, making it possible to wrap TLS stream into another TLS stream. Thus legacy API calls are no longer required in `_tls_wrap.js`. PR-URL: https://github.com/iojs/io.js/pull/840 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Chris Dickinson &lt;christopher.s.dickinson@gmail.com&gt;
10 years ago
V(write_wrap_constructor_function, v8::Function) \
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
class Environment;
// TODO(bnoordhuis) Rename struct, the ares_ prefix implies it's part
// of the c-ares API while the _t suffix implies it's a typedef.
struct ares_task_t {
Environment* env;
ares_socket_t sock;
uv_poll_t poll_watcher;
RB_ENTRY(ares_task_t) node;
};
RB_HEAD(ares_task_list, ares_task_t);
class Environment {
public:
async-wrap: add event hooks Call a user-defined callback at specific points in the lifetime of an asynchronous event. Which are on instantiation, just before/after the callback has been run. **If any of these callbacks throws an exception, there is no forgiveness or recovery. A message will be displayed and a core file dumped.** Currently these only tie into AsyncWrap, meaning no call to a hook callback will be made for timers or process.nextTick() events. Though those will be added in a future commit. Here are a few notes on how to make the hooks work: - The &#34;this&#34; of all event hook callbacks is the request object. - The zero field (kCallInitHook) of the flags object passed to setupHooks() must be set != 0 before the init callback will be called. - kCallInitHook only affects the calling of the init callback. If the request object has been run through the create callback it will always run the before/after callbacks. Regardless of kCallInitHook. - In the init callback the property &#34;_asyncQueue&#34; must be attached to the request object. e.g. function initHook() { this._asyncQueue = {}; } - DO NOT inspect the properties of the object in the init callback. Since the object is in the middle of being instantiated there are some cases when a getter is not complete, and doing so will cause Node to crash. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
class AsyncHooks {
public:
inline uint32_t* fields();
inline int fields_count() const;
async-wrap: don&#39;t call init callback unnecessarily Some calls to ReqWrap would get through the initial check and allow the init callback to run, even though the callback had not been used on the parent. Fix by explicitly checking if the parent has a queue. Also change the name of the check, and internal field of AsyncHooks. Other names were confusing. PR-URL: https://github.com/iojs/io.js/pull/1614 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
inline bool callbacks_enabled();
inline void set_enable_callbacks(uint32_t flag);
async-wrap: add event hooks Call a user-defined callback at specific points in the lifetime of an asynchronous event. Which are on instantiation, just before/after the callback has been run. **If any of these callbacks throws an exception, there is no forgiveness or recovery. A message will be displayed and a core file dumped.** Currently these only tie into AsyncWrap, meaning no call to a hook callback will be made for timers or process.nextTick() events. Though those will be added in a future commit. Here are a few notes on how to make the hooks work: - The &#34;this&#34; of all event hook callbacks is the request object. - The zero field (kCallInitHook) of the flags object passed to setupHooks() must be set != 0 before the init callback will be called. - kCallInitHook only affects the calling of the init callback. If the request object has been run through the create callback it will always run the before/after callbacks. Regardless of kCallInitHook. - In the init callback the property &#34;_asyncQueue&#34; must be attached to the request object. e.g. function initHook() { this._asyncQueue = {}; } - DO NOT inspect the properties of the object in the init callback. Since the object is in the middle of being instantiated there are some cases when a getter is not complete, and doing so will cause Node to crash. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
private:
friend class Environment; // So we can call the constructor.
inline AsyncHooks();
enum Fields {
// Set this to not zero if the init hook should be called.
async-wrap: don&#39;t call init callback unnecessarily Some calls to ReqWrap would get through the initial check and allow the init callback to run, even though the callback had not been used on the parent. Fix by explicitly checking if the parent has a queue. Also change the name of the check, and internal field of AsyncHooks. Other names were confusing. PR-URL: https://github.com/iojs/io.js/pull/1614 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
kEnableCallbacks,
async-wrap: add event hooks Call a user-defined callback at specific points in the lifetime of an asynchronous event. Which are on instantiation, just before/after the callback has been run. **If any of these callbacks throws an exception, there is no forgiveness or recovery. A message will be displayed and a core file dumped.** Currently these only tie into AsyncWrap, meaning no call to a hook callback will be made for timers or process.nextTick() events. Though those will be added in a future commit. Here are a few notes on how to make the hooks work: - The &#34;this&#34; of all event hook callbacks is the request object. - The zero field (kCallInitHook) of the flags object passed to setupHooks() must be set != 0 before the init callback will be called. - kCallInitHook only affects the calling of the init callback. If the request object has been run through the create callback it will always run the before/after callbacks. Regardless of kCallInitHook. - In the init callback the property &#34;_asyncQueue&#34; must be attached to the request object. e.g. function initHook() { this._asyncQueue = {}; } - DO NOT inspect the properties of the object in the init callback. Since the object is in the middle of being instantiated there are some cases when a getter is not complete, and doing so will cause Node to crash. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
kFieldsCount
};
uint32_t fields_[kFieldsCount];
DISALLOW_COPY_AND_ASSIGN(AsyncHooks);
};
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
class DomainFlag {
public:
inline uint32_t* fields();
inline int fields_count() const;
inline uint32_t count() const;
private:
friend class Environment; // So we can call the constructor.
inline DomainFlag();
enum Fields {
kCount,
kFieldsCount
};
uint32_t fields_[kFieldsCount];
DISALLOW_COPY_AND_ASSIGN(DomainFlag);
};
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
class TickInfo {
public:
inline uint32_t* fields();
inline int fields_count() const;
node: don&#39;t share state with in_tick/last_threw There was no need to share state between C++ and JS for these two values. So they have been moved to their respective locations. This will help performance only a tiny bit, but it does help code complexity much more.
11 years ago
inline bool in_tick() const;
inline bool last_threw() const;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
inline uint32_t index() const;
inline uint32_t length() const;
node: don&#39;t share state with in_tick/last_threw There was no need to share state between C++ and JS for these two values. So they have been moved to their respective locations. This will help performance only a tiny bit, but it does help code complexity much more.
11 years ago
inline void set_in_tick(bool value);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
inline void set_index(uint32_t value);
node: don&#39;t share state with in_tick/last_threw There was no need to share state between C++ and JS for these two values. So they have been moved to their respective locations. This will help performance only a tiny bit, but it does help code complexity much more.
11 years ago
inline void set_last_threw(bool value);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
private:
friend class Environment; // So we can call the constructor.
inline TickInfo();
enum Fields {
kIndex,
kLength,
kFieldsCount
};
uint32_t fields_[kFieldsCount];
node: don&#39;t share state with in_tick/last_threw There was no need to share state between C++ and JS for these two values. So they have been moved to their respective locations. This will help performance only a tiny bit, but it does help code complexity much more.
11 years ago
bool in_tick_;
bool last_threw_;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
DISALLOW_COPY_AND_ASSIGN(TickInfo);
};
buffer: construct Uint8Array in JS Overall construction time of Typed Arrays is faster in JS, but the problem with using it normally is zero-fill of memory. Get around this by using a flag in the ArrayBuffer::Allocator to trigger when memory should or shouldn&#39;t be zero-filled. Remove Buffer::Create() as it is no longer called. The creation of the Uint8Array() was done at each callsite because at the time of this patch there was a performance penalty for centralizing the call in a single function. PR-URL: https://github.com/nodejs/node/pull/2866 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
9 years ago
class ArrayBufferAllocatorInfo {
public:
inline uint32_t* fields();
inline int fields_count() const;
inline bool no_zero_fill() const;
inline void reset_fill_flag();
private:
friend class Environment; // So we can call the constructor.
inline ArrayBufferAllocatorInfo();
enum Fields {
kNoZeroFill,
kFieldsCount
};
uint32_t fields_[kFieldsCount];
DISALLOW_COPY_AND_ASSIGN(ArrayBufferAllocatorInfo);
};
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
typedef void (*HandleCleanupCb)(Environment* env,
uv_handle_t* handle,
void* arg);
class HandleCleanup {
private:
friend class Environment;
HandleCleanup(uv_handle_t* handle, HandleCleanupCb cb, void* arg)
: handle_(handle),
cb_(cb),
arg_(arg) {
}
uv_handle_t* handle_;
HandleCleanupCb cb_;
void* arg_;
src: switch from QUEUE to intrusive list This commit also breaks up req_wrap.h into req-wrap.h and req-wrap-inl.h to work around a circular dependency issue in env.h. PR-URL: https://github.com/iojs/io.js/pull/667 Reviewed-By: Fedor Indutny &lt;fedor.indutny@gmail.com&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
ListNode<HandleCleanup> handle_cleanup_queue_;
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
};
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
static inline Environment* GetCurrent(v8::Isolate* isolate);
static inline Environment* GetCurrent(v8::Local<v8::Context> context);
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
static inline Environment* GetCurrent(
const v8::FunctionCallbackInfo<v8::Value>& info);
src: make accessors immune to context confusion It&#39;s possible for an accessor or named interceptor to get called with a different execution context than the one it lives in, see the test case for an example using the debug API. This commit fortifies against that by passing the environment as a data property instead of looking it up through the current context. Fixes: https://github.com/iojs/io.js/issues/1190 (again) PR-URL: https://github.com/iojs/io.js/pull/1238 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
template <typename T>
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
static inline Environment* GetCurrent(
src: make accessors immune to context confusion It&#39;s possible for an accessor or named interceptor to get called with a different execution context than the one it lives in, see the test case for an example using the debug API. This commit fortifies against that by passing the environment as a data property instead of looking it up through the current context. Fixes: https://github.com/iojs/io.js/issues/1190 (again) PR-URL: https://github.com/iojs/io.js/pull/1238 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
const v8::PropertyCallbackInfo<T>& info);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
// See CreateEnvironment() in src/node.cc.
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
static inline Environment* New(v8::Local<v8::Context> context,
uv_loop_t* loop);
inline void CleanupHandles();
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
inline void Dispose();
vm: assign Environment to created context ContextifyContext::CreateV8Context is now create context with Environment pointer Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
void AssignToContext(v8::Local<v8::Context> context);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
inline v8::Isolate* isolate() const;
inline uv_loop_t* event_loop() const;
async-wrap: don&#39;t call init callback unnecessarily Some calls to ReqWrap would get through the initial check and allow the init callback to run, even though the callback had not been used on the parent. Fix by explicitly checking if the parent has a queue. Also change the name of the check, and internal field of AsyncHooks. Other names were confusing. PR-URL: https://github.com/iojs/io.js/pull/1614 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
inline bool async_wrap_callbacks_enabled() const;
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
inline bool in_domain() const;
env: add watched_providers for AsyncListener Now the second field in asyncFlags will tell if the provider is currently being watched, or listened for. Signed-off-by: Timothy J Fontaine &lt;tjfontaine@gmail.com&gt;
11 years ago
inline uint32_t watched_providers() const;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
static inline Environment* from_immediate_check_handle(uv_check_t* handle);
inline uv_check_t* immediate_check_handle();
inline uv_idle_t* immediate_idle_handle();
src: notify V8 profiler when we&#39;re idle Inform V8&#39;s CPU profiler when we&#39;re idle. The profiler is sampling-based but not all samples are created equal; mark the wall clock time spent in epoll_wait() and friends so profiling tools can filter it out. The samples still end up in v8.log but with state=IDLE rather than state=EXTERNAL.
11 years ago
static inline Environment* from_idle_prepare_handle(uv_prepare_t* handle);
inline uv_prepare_t* idle_prepare_handle();
static inline Environment* from_idle_check_handle(uv_check_t* handle);
inline uv_check_t* idle_check_handle();
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
// Register clean-up cb to be called on env->Dispose()
inline void RegisterHandleCleanup(uv_handle_t* handle,
HandleCleanupCb cb,
void *arg);
inline void FinishHandleCleanup(uv_handle_t* handle);
async-wrap: add event hooks Call a user-defined callback at specific points in the lifetime of an asynchronous event. Which are on instantiation, just before/after the callback has been run. **If any of these callbacks throws an exception, there is no forgiveness or recovery. A message will be displayed and a core file dumped.** Currently these only tie into AsyncWrap, meaning no call to a hook callback will be made for timers or process.nextTick() events. Though those will be added in a future commit. Here are a few notes on how to make the hooks work: - The &#34;this&#34; of all event hook callbacks is the request object. - The zero field (kCallInitHook) of the flags object passed to setupHooks() must be set != 0 before the init callback will be called. - kCallInitHook only affects the calling of the init callback. If the request object has been run through the create callback it will always run the before/after callbacks. Regardless of kCallInitHook. - In the init callback the property &#34;_asyncQueue&#34; must be attached to the request object. e.g. function initHook() { this._asyncQueue = {}; } - DO NOT inspect the properties of the object in the init callback. Since the object is in the middle of being instantiated there are some cases when a getter is not complete, and doing so will cause Node to crash. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
inline AsyncHooks* async_hooks();
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
inline DomainFlag* domain_flag();
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
inline TickInfo* tick_info();
buffer: construct Uint8Array in JS Overall construction time of Typed Arrays is faster in JS, but the problem with using it normally is zero-fill of memory. Get around this by using a flag in the ArrayBuffer::Allocator to trigger when memory should or shouldn&#39;t be zero-filled. Remove Buffer::Create() as it is no longer called. The creation of the Uint8Array() was done at each callsite because at the time of this patch there was a performance penalty for centralizing the call in a single function. PR-URL: https://github.com/nodejs/node/pull/2866 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
9 years ago
inline ArrayBufferAllocatorInfo* array_buffer_allocator_info();
timers: improve Timer.now() performance Record the start time so we can make the return value of Timer.now() relative to it, increasing the chances that it fits in a tagged integer instead of a heap-allocated double, at least for the first one or two billion milliseconds. PR-URL: https://github.com/nodejs/io.js/pull/2256 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
inline uint64_t timer_base() const;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
static inline Environment* from_cares_timer_handle(uv_timer_t* handle);
inline uv_timer_t* cares_timer_handle();
inline ares_channel cares_channel();
inline ares_channel* cares_channel_ptr();
inline ares_task_list* cares_task_list();
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
inline bool using_domains() const;
inline void set_using_domains(bool value);
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
inline bool printed_error() const;
inline void set_printed_error(bool value);
core: implement runtime flag to trace sync io Use the --trace-sync-io flag to print a stack trace whenever a sync method is used after the first tick, excluding during the process exit event. (e.g. fs.readFileSync()) It does not track if the warning has occurred at a specific location in the past and so will print the warning every time. Reason for not printing during the first tick of the appication is so all necessary resources can be required. Also by excluding synchronous calls during exit is necessary in case any data needs to be logged out by the application before it shuts down. Fixes: https://github.com/nodejs/io.js/issues/1674 PR-URL: https://github.com/nodejs/io.js/pull/1707 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Jeremiah Senkpiel &lt;fishrock123@rocketmail.com&gt; Reviewed-By: Petka Antonov &lt;petka_antonov@hotmail.com&gt;
10 years ago
void PrintSyncTrace() const;
inline void set_trace_sync_io(bool value);
async_wrap: new instances get uid New instances of AsyncWrap are automatically assigned a unique id. The value will be used in future commits to communicate additional information via the async hooks. While the largest value we can reliably communicate to JS is 2^53, even if a new AsyncWrap is created every 100ns the uid won&#39;t reach its end for 28.5 years. PR-URL: https://github.com/nodejs/node/pull/3461 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
9 years ago
inline int64_t get_async_wrap_uid();
env: introduce `KickNextTick` There might be a need to &#34;kick off&#34; the next tick queue and execute events on it. Normally it is done through the `MakeCallback` interface, but in case when it is not - we need a way to &#34;kick them off&#34; manually. PR-URL: https://github.com/nodejs/node/pull/2355 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
9 years ago
bool KickNextTick();
deps: update v8 to 4.4.63.9 Upgrade the bundled V8 and update code in src/ and lib/ to the new API. Notable backwards incompatible changes are the removal of the smalloc module and dropped support for CESU-8 decoding. CESU-8 support can be brought back if necessary by doing UTF-8 decoding ourselves. This commit includes https://codereview.chromium.org/1192973004 to fix a build error on python 2.6 systems. The original commit log follows: Use optparse in js2c.py for python compatibility Without this change, V8 won&#39;t build on RHEL/CentOS 6 because the distro python is too old to know about the argparse module. PR-URL: https://github.com/nodejs/io.js/pull/2022 Reviewed-By: Rod Vagg &lt;rod@vagg.org&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
inline uint32_t* heap_statistics_buffer() const;
inline void set_heap_statistics_buffer(uint32_t* pointer);
v8,src: expose statistics about heap spaces Provide means to inspect information about the separate heap spaces via a callable API. This is helpful to analyze memory issues. Fixes: https://github.com/nodejs/node/issues/2079 PR-URL: https://github.com/nodejs/node/pull/4463 Reviewed-By: Colin Ihrig &lt;cjihrig@gmail.com&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: James M Snell &lt;jasnell@gmail.com&gt;
9 years ago
inline uint32_t* heap_space_statistics_buffer() const;
inline void set_heap_space_statistics_buffer(uint32_t* pointer);
http_parser: consume StreamBase instance Consume StreamBase instance and operate on incoming data directly without allocating Buffer instances. Improves performance. PR-URL: https://github.com/nodejs/node/pull/2355 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
inline char* http_parser_buffer() const;
inline void set_http_parser_buffer(char* buffer);
src: remove `node_isolate` from source fix #6899
11 years ago
inline void ThrowError(const char* errmsg);
inline void ThrowTypeError(const char* errmsg);
inline void ThrowRangeError(const char* errmsg);
inline void ThrowErrnoException(int errorno,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
const char* syscall = nullptr,
const char* message = nullptr,
const char* path = nullptr);
src: remove `node_isolate` from source fix #6899
11 years ago
inline void ThrowUVException(int errorno,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
const char* syscall = nullptr,
const char* message = nullptr,
fs: improve error messages * Include a description for the error message * For rename, link, and symlink, include both the source and destination path in the error message. * Expose the destination path as the `dest` property on the error object. * Fix a bug where `ThrowUVException()` would incorrectly delegate to `Environment::TrowErrnoException()`. API impact: * Adds an extra overload for node::UVException() which takes 6 arguments. PR: https://github.com/iojs/io.js/pull/675 Fixes: https://github.com/iojs/io.js/issues/207 Closes: https://github.com/iojs/io.js/pull/293 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
const char* path = nullptr,
const char* dest = nullptr);
src: remove `node_isolate` from source fix #6899
11 years ago
// Convenience methods for contextify
inline static void ThrowError(v8::Isolate* isolate, const char* errmsg);
inline static void ThrowTypeError(v8::Isolate* isolate, const char* errmsg);
inline static void ThrowRangeError(v8::Isolate* isolate, const char* errmsg);
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
inline v8::Local<v8::FunctionTemplate>
NewFunctionTemplate(v8::FunctionCallback callback,
v8::Local<v8::Signature> signature =
v8::Local<v8::Signature>());
// Convenience methods for NewFunctionTemplate().
inline void SetMethod(v8::Local<v8::Object> that,
const char* name,
v8::FunctionCallback callback);
inline void SetProtoMethod(v8::Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback);
inline void SetTemplateMethod(v8::Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback);
async_wrap: ensure all objects have internal field If the constructor can&#39;t assign a class id then the heap snapshot will not be able to report the object. So ensure that all AsyncWrap instances use a FunctionTemplate instance with an internal field count &gt;= 1. PR-URL: https://github.com/nodejs/node/pull/3139 Reviewed-By: Fedor Indutny &lt;fedor.indutny@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-by: Stephen Belanger &lt;admin@stephenbelanger.com&gt;
9 years ago
inline v8::Local<v8::Object> NewInternalFieldObject();
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
// Strings are shared across shared contexts. The getters simply proxy to
// the per-isolate primitive.
#define V(PropertyName, StringValue) \
inline v8::Local<v8::String> PropertyName() const;
PER_ISOLATE_STRING_PROPERTIES(V)
#undef V
#define V(PropertyName, TypeName) \
inline v8::Local<TypeName> PropertyName() const; \
inline void set_ ## PropertyName(v8::Local<TypeName> value);
ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)
#undef V
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
inline debugger::Agent* debugger_agent() {
return &debugger_agent_;
}
src: switch from QUEUE to intrusive list This commit also breaks up req_wrap.h into req-wrap.h and req-wrap-inl.h to work around a circular dependency issue in env.h. PR-URL: https://github.com/iojs/io.js/pull/667 Reviewed-By: Fedor Indutny &lt;fedor.indutny@gmail.com&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
typedef ListHead<HandleWrap, &HandleWrap::handle_wrap_queue_> HandleWrapQueue;
typedef ListHead<ReqWrap<uv_req_t>, &ReqWrap<uv_req_t>::req_wrap_queue_>
ReqWrapQueue;
inline HandleWrapQueue* handle_wrap_queue() { return &handle_wrap_queue_; }
inline ReqWrapQueue* req_wrap_queue() { return &req_wrap_queue_; }
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
vm: fix crash on fatal error in debug context Ensure that the debug context has an Environment assigned in case a fatal error is raised. The fatal exception handler in node.cc is not equipped to deal with contexts that don&#39;t have one and can&#39;t easily be taught that due to a deficiency in the V8 API: there is no way for the embedder to tell if the data index is in use. Fixes: https://github.com/iojs/io.js/issues/1190 PR-URL: https://github.com/iojs/io.js/pull/1229 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
static const int kContextEmbedderDataIndex = NODE_CONTEXT_EMBEDDER_DATA_INDEX;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
private:
src: change kIsolateSlot to 3 The slot 0 and 1 had already been taken by &#34;gin&#34; and &#34;blink&#34; in Chrome, and the size of isolate&#39;s slots is 4 by default, so using 3 should hopefully make node work independently when embedded into other application. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
static const int kIsolateSlot = NODE_ISOLATE_SLOT;
src: update to v8 3.24 APIs
11 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
class IsolateData;
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
inline Environment(v8::Local<v8::Context> context, uv_loop_t* loop);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
inline ~Environment();
inline IsolateData* isolate_data() const;
v8::Isolate* const isolate_;
IsolateData* const isolate_data_;
uv_check_t immediate_check_handle_;
uv_idle_t immediate_idle_handle_;
src: notify V8 profiler when we&#39;re idle Inform V8&#39;s CPU profiler when we&#39;re idle. The profiler is sampling-based but not all samples are created equal; mark the wall clock time spent in epoll_wait() and friends so profiling tools can filter it out. The samples still end up in v8.log but with state=IDLE rather than state=EXTERNAL.
11 years ago
uv_prepare_t idle_prepare_handle_;
uv_check_t idle_check_handle_;
async-wrap: add event hooks Call a user-defined callback at specific points in the lifetime of an asynchronous event. Which are on instantiation, just before/after the callback has been run. **If any of these callbacks throws an exception, there is no forgiveness or recovery. A message will be displayed and a core file dumped.** Currently these only tie into AsyncWrap, meaning no call to a hook callback will be made for timers or process.nextTick() events. Though those will be added in a future commit. Here are a few notes on how to make the hooks work: - The &#34;this&#34; of all event hook callbacks is the request object. - The zero field (kCallInitHook) of the flags object passed to setupHooks() must be set != 0 before the init callback will be called. - kCallInitHook only affects the calling of the init callback. If the request object has been run through the create callback it will always run the before/after callbacks. Regardless of kCallInitHook. - In the init callback the property &#34;_asyncQueue&#34; must be attached to the request object. e.g. function initHook() { this._asyncQueue = {}; } - DO NOT inspect the properties of the object in the init callback. Since the object is in the middle of being instantiated there are some cases when a getter is not complete, and doing so will cause Node to crash. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
AsyncHooks async_hooks_;
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
DomainFlag domain_flag_;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
TickInfo tick_info_;
buffer: construct Uint8Array in JS Overall construction time of Typed Arrays is faster in JS, but the problem with using it normally is zero-fill of memory. Get around this by using a flag in the ArrayBuffer::Allocator to trigger when memory should or shouldn&#39;t be zero-filled. Remove Buffer::Create() as it is no longer called. The creation of the Uint8Array() was done at each callsite because at the time of this patch there was a performance penalty for centralizing the call in a single function. PR-URL: https://github.com/nodejs/node/pull/2866 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
9 years ago
ArrayBufferAllocatorInfo array_buffer_allocator_info_;
timers: improve Timer.now() performance Record the start time so we can make the return value of Timer.now() relative to it, increasing the chances that it fits in a tagged integer instead of a heap-allocated double, at least for the first one or two billion milliseconds. PR-URL: https://github.com/nodejs/io.js/pull/2256 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
const uint64_t timer_base_;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
uv_timer_t cares_timer_handle_;
ares_channel cares_channel_;
ares_task_list cares_task_list_;
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
bool using_domains_;
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
bool printed_error_;
core: implement runtime flag to trace sync io Use the --trace-sync-io flag to print a stack trace whenever a sync method is used after the first tick, excluding during the process exit event. (e.g. fs.readFileSync()) It does not track if the warning has occurred at a specific location in the past and so will print the warning every time. Reason for not printing during the first tick of the appication is so all necessary resources can be required. Also by excluding synchronous calls during exit is necessary in case any data needs to be logged out by the application before it shuts down. Fixes: https://github.com/nodejs/io.js/issues/1674 PR-URL: https://github.com/nodejs/io.js/pull/1707 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-By: Jeremiah Senkpiel &lt;fishrock123@rocketmail.com&gt; Reviewed-By: Petka Antonov &lt;petka_antonov@hotmail.com&gt;
10 years ago
bool trace_sync_io_;
async_wrap: new instances get uid New instances of AsyncWrap are automatically assigned a unique id. The value will be used in future commits to communicate additional information via the async hooks. While the largest value we can reliably communicate to JS is 2^53, even if a new AsyncWrap is created every 100ns the uid won&#39;t reach its end for 28.5 years. PR-URL: https://github.com/nodejs/node/pull/3461 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
9 years ago
int64_t async_wrap_uid_;
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
debugger::Agent debugger_agent_;
src: switch from QUEUE to intrusive list This commit also breaks up req_wrap.h into req-wrap.h and req-wrap-inl.h to work around a circular dependency issue in env.h. PR-URL: https://github.com/iojs/io.js/pull/667 Reviewed-By: Fedor Indutny &lt;fedor.indutny@gmail.com&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
HandleWrapQueue handle_wrap_queue_;
ReqWrapQueue req_wrap_queue_;
ListHead<HandleCleanup,
&HandleCleanup::handle_cleanup_queue_> handle_cleanup_queue_;
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
int handle_cleanup_waiting_;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
deps: update v8 to 4.4.63.9 Upgrade the bundled V8 and update code in src/ and lib/ to the new API. Notable backwards incompatible changes are the removal of the smalloc module and dropped support for CESU-8 decoding. CESU-8 support can be brought back if necessary by doing UTF-8 decoding ourselves. This commit includes https://codereview.chromium.org/1192973004 to fix a build error on python 2.6 systems. The original commit log follows: Use optparse in js2c.py for python compatibility Without this change, V8 won&#39;t build on RHEL/CentOS 6 because the distro python is too old to know about the argparse module. PR-URL: https://github.com/nodejs/io.js/pull/2022 Reviewed-By: Rod Vagg &lt;rod@vagg.org&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
uint32_t* heap_statistics_buffer_ = nullptr;
v8,src: expose statistics about heap spaces Provide means to inspect information about the separate heap spaces via a callable API. This is helpful to analyze memory issues. Fixes: https://github.com/nodejs/node/issues/2079 PR-URL: https://github.com/nodejs/node/pull/4463 Reviewed-By: Colin Ihrig &lt;cjihrig@gmail.com&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: James M Snell &lt;jasnell@gmail.com&gt;
9 years ago
uint32_t* heap_space_statistics_buffer_ = nullptr;
deps: update v8 to 4.4.63.9 Upgrade the bundled V8 and update code in src/ and lib/ to the new API. Notable backwards incompatible changes are the removal of the smalloc module and dropped support for CESU-8 decoding. CESU-8 support can be brought back if necessary by doing UTF-8 decoding ourselves. This commit includes https://codereview.chromium.org/1192973004 to fix a build error on python 2.6 systems. The original commit log follows: Use optparse in js2c.py for python compatibility Without this change, V8 won&#39;t build on RHEL/CentOS 6 because the distro python is too old to know about the argparse module. PR-URL: https://github.com/nodejs/io.js/pull/2022 Reviewed-By: Rod Vagg &lt;rod@vagg.org&gt; Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
http_parser: consume StreamBase instance Consume StreamBase instance and operate on incoming data directly without allocating Buffer instances. Improves performance. PR-URL: https://github.com/nodejs/node/pull/2355 Reviewed-By: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
char* http_parser_buffer_;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
#define V(PropertyName, TypeName) \
v8::Persistent<TypeName> PropertyName ## _;
ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)
#undef V
// Per-thread, reference-counted singleton.
class IsolateData {
public:
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
static inline IsolateData* GetOrCreate(v8::Isolate* isolate,
uv_loop_t* loop);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
inline void Put();
inline uv_loop_t* event_loop() const;
#define V(PropertyName, StringValue) \
inline v8::Local<v8::String> PropertyName() const;
PER_ISOLATE_STRING_PROPERTIES(V)
#undef V
private:
src: add tracing.v8.on(&#39;gc&#39;) statistics hooks Add a new &#39;tracing&#39; module with a v8 property that lets the user register listeners for gc events. The listeners are invoked after every garbage collection cycle with &#39;before&#39; and &#39;after&#39; statistics. Useful for monitoring tools that want to keep track of memory usage.
11 years ago
inline static IsolateData* Get(v8::Isolate* isolate);
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
inline explicit IsolateData(v8::Isolate* isolate, uv_loop_t* loop);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
inline v8::Isolate* isolate() const;
uv_loop_t* const event_loop_;
v8::Isolate* const isolate_;
#define V(PropertyName, StringValue) \
src: update after v8 api changes
11 years ago
v8::Eternal<v8::String> PropertyName ## _;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
PER_ISOLATE_STRING_PROPERTIES(V)
#undef V
unsigned int ref_count_;
DISALLOW_COPY_AND_ASSIGN(IsolateData);
};
DISALLOW_COPY_AND_ASSIGN(Environment);
};
} // namespace node
#endif // SRC_ENV_H_