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.
9854 Commits
131 Branches
446 Tags
325 MiB
Tree: 77d1f4a91f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '77d1f4a91f'
${ noResults }
node/src/env.h

534 lines
27 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.
11 years ago
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SRC_ENV_H_
#define SRC_ENV_H_
#include "ares.h"
#include "tree.h"
#include "util.h"
#include "uv.h"
#include "v8.h"
src: add tracing.v8.on('gc') statistics hooks Add a new 'tracing' module with a v8 property that lets the user register listeners for gc events. The listeners are invoked after every garbage collection cycle with 'before' and 'after' statistics. Useful for monitoring tools that want to keep track of memory usage.
11 years ago
#include "queue.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.
11 years ago
#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
// of context-inl.h. The sole exception is NODE_CONTEXT_EMBEDDER_DATA_INDEX,
// it may have been defined externally.
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
// Strings are per-isolate primitives but Environment proxies them
// for the sake of convenience.
#define PER_ISOLATE_STRING_PROPERTIES(V) \
V(address_string, "address") \
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") \
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 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(async, "async") \
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.
11 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") \
V(byte_length_string, "byteLength") \
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.
11 years ago
V(callback_string, "callback") \
V(change_string, "change") \
V(close_string, "close") \
V(code_string, "code") \
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") \
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.
11 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: 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.
11 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.
11 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.
11 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.
11 years ago
V(exponent_string, "exponent") \
V(exports_string, "exports") \
V(ext_key_usage_string, "ext_key_usage") \
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.
11 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.
11 years ago
V(gid_string, "gid") \
V(handle_string, "handle") \
V(headers_string, "headers") \
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(heap_size_limit_string, "heap_size_limit") \
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.
11 years ago
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.
11 years ago
V(immediate_callback_string, "_immediateCallback") \
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.
11 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.
11 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.
11 years ago
V(ipv6_string, "IPv6") \
V(issuer_string, "issuer") \
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: 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.
11 years ago
V(method_string, "method") \
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.
11 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.
11 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.
11 years ago
V(nlink_string, "nlink") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(nsname_string, "nsname") \
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.
11 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.
11 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") \
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.
11 years ago
V(onread_string, "onread") \
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") \
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.
11 years ago
V(onsignal_string, "onsignal") \
V(onstop_string, "onstop") \
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.
11 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.
11 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") \
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.
11 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.
11 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.
11 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") \
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.
11 years ago
V(servername_string, "servername") \
V(session_id_string, "sessionId") \
V(should_keep_alive_string, "shouldKeepAlive") \
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.
11 years ago
V(size_string, "size") \
V(smalloc_p_string, "_smalloc_p") \
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.
11 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") \
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.
11 years ago
V(status_code_string, "statusCode") \
http: parse the status message in a http response.
11 years ago
V(status_message_string, "statusMessage") \
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.
11 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.
11 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") \
V(tick_info_string, "_tickInfo") \
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") \
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.
11 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(total_heap_size_executable_string, "total_heap_size_executable") \
V(total_heap_size_string, "total_heap_size") \
V(total_physical_size_string, "total_physical_size") \
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.
11 years ago
V(uid_string, "uid") \
src: remove `node_isolate` from source fix #6899
11 years ago
V(unknown_string, "<unknown>") \
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.
11 years ago
V(upgrade_string, "upgrade") \
V(url_string, "url") \
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(used_heap_size_string, "used_heap_size") \
src: remove `node_isolate` from source fix #6899
11 years ago
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.
11 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.
11 years ago
V(version_major_string, "versionMajor") \
V(version_minor_string, "versionMinor") \
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.
11 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.
11 years ago
#define ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V) \
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
V(async_listener_run_function, v8::Function) \
async_wrap/timers: remove Add/RemoveAsyncListener The ability to add/remove an AsyncListener to an object after its creation was an artifact of trying to get AL working with the domain module. Now that is no longer necessary and other features are going to be implemented that would be affected by this functionality. So the code will be removed for now to simplify the implementation process. In the future this code will likely be reintroduced, but after some other more important matters have been addressed. None of this functionality was documented, as is was meant specifically for domain specific implementation work arounds. Signed-off-by: Timothy J Fontaine &lt;tjfontaine@gmail.com&gt;
11 years ago
V(async_listener_load_function, v8::Function) \
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
V(async_listener_unload_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.
11 years ago
V(binding_cache_object, v8::Object) \
V(buffer_constructor_function, v8::Function) \
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) \
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) \
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(gc_info_callback_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.
11 years ago
V(module_load_list_array, v8::Array) \
V(pipe_constructor_template, v8::FunctionTemplate) \
V(process_object, v8::Object) \
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) \
V(tty_constructor_template, v8::FunctionTemplate) \
V(udp_constructor_function, v8::Function) \
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:
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
class AsyncListener {
public:
inline uint32_t* fields();
inline int fields_count() const;
node: AsyncListener use separate storage mechanism Before when an AsyncListener object was created and the &#34;create&#34; callback returned a value, it was necessary to construct a new Object with the same callbacks but add a place for the new storage value. Now, instead, a separate storage array is kept on the context which is used for any return value of the &#34;create&#34; callback. This significantly reduces the number of Objects that need to be created. Also added a flags property to the context to quickly check if a specific callback was available either on the context or on the AsyncListener instance itself. Few other minor changes for readability that were difficult to separate into their own commit. This has not been optimized yet.
11 years ago
inline bool has_listener() 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;
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
private:
friend class Environment; // So we can call the constructor.
inline AsyncListener();
enum Fields {
node: AsyncListener use separate storage mechanism Before when an AsyncListener object was created and the &#34;create&#34; callback returned a value, it was necessary to construct a new Object with the same callbacks but add a place for the new storage value. Now, instead, a separate storage array is kept on the context which is used for any return value of the &#34;create&#34; callback. This significantly reduces the number of Objects that need to be created. Also added a flags property to the context to quickly check if a specific callback was available either on the context or on the AsyncListener instance itself. Few other minor changes for readability that were difficult to separate into their own commit. This has not been optimized yet.
11 years ago
kHasListener,
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
kWatchedProviders,
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
kFieldsCount
};
uint32_t fields_[kFieldsCount];
DISALLOW_COPY_AND_ASSIGN(AsyncListener);
};
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.
11 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.
11 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.
11 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.
11 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.
11 years ago
DISALLOW_COPY_AND_ASSIGN(TickInfo);
};
static inline Environment* GetCurrent(v8::Isolate* isolate);
static inline Environment* GetCurrent(v8::Local<v8::Context> context);
static inline Environment* GetCurrentChecked(v8::Isolate* isolate);
static inline Environment* GetCurrentChecked(v8::Local<v8::Context> context);
// See CreateEnvironment() in src/node.cc.
static inline Environment* New(v8::Local<v8::Context> context);
inline void Dispose();
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
// Defined in src/node_profiler.cc.
void StartGarbageCollectionTracking(v8::Local<v8::Function> callback);
void StopGarbageCollectionTracking();
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.
11 years ago
inline v8::Isolate* isolate() const;
inline uv_loop_t* event_loop() const;
node: AsyncListener use separate storage mechanism Before when an AsyncListener object was created and the &#34;create&#34; callback returned a value, it was necessary to construct a new Object with the same callbacks but add a place for the new storage value. Now, instead, a separate storage array is kept on the context which is used for any return value of the &#34;create&#34; callback. This significantly reduces the number of Objects that need to be created. Also added a flags property to the context to quickly check if a specific callback was available either on the context or on the AsyncListener instance itself. Few other minor changes for readability that were difficult to separate into their own commit. This has not been optimized yet.
11 years ago
inline bool has_async_listener() 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.
11 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();
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
inline AsyncListener* async_listener();
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.
11 years ago
inline TickInfo* tick_info();
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();
inline bool using_smalloc_alloc_cb() const;
inline void set_using_smalloc_alloc_cb(bool value);
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);
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,
const char* syscall = NULL,
const char* message = NULL,
const char* path = NULL);
inline void ThrowUVException(int errorno,
const char* syscall = NULL,
const char* message = NULL,
const char* path = NULL);
// 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: 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.
11 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
private:
src: update to v8 3.24 APIs
11 years ago
static const int kIsolateSlot = 0;
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
class GCInfo;
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.
11 years ago
class IsolateData;
inline explicit Environment(v8::Local<v8::Context> context);
inline ~Environment();
inline IsolateData* isolate_data() const;
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
void AfterGarbageCollectionCallback(const GCInfo* before,
const GCInfo* after);
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.
11 years ago
enum ContextEmbedderDataIndex {
kContextEmbedderDataIndex = NODE_CONTEXT_EMBEDDER_DATA_INDEX
};
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_;
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
AsyncListener async_listener_count_;
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.
11 years ago
TickInfo tick_info_;
uv_timer_t cares_timer_handle_;
ares_channel cares_channel_;
ares_task_list cares_task_list_;
bool using_smalloc_alloc_cb_;
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_;
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
QUEUE gc_tracker_queue_;
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_;
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.
11 years ago
#define V(PropertyName, TypeName) \
v8::Persistent<TypeName> PropertyName ## _;
ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)
#undef V
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
class GCInfo {
public:
inline GCInfo();
inline GCInfo(v8::Isolate* isolate,
v8::GCType type,
v8::GCCallbackFlags flags,
uint64_t timestamp);
inline v8::GCType type() const;
inline v8::GCCallbackFlags flags() const;
// TODO(bnoordhuis) Const-ify once https://codereview.chromium.org/63693005
// lands and makes it way into a stable release.
inline v8::HeapStatistics* stats() const;
inline uint64_t timestamp() const;
private:
v8::GCType type_;
v8::GCCallbackFlags flags_;
v8::HeapStatistics stats_;
uint64_t timestamp_;
};
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.
11 years ago
// Per-thread, reference-counted singleton.
class IsolateData {
public:
static inline IsolateData* GetOrCreate(v8::Isolate* isolate);
inline void Put();
inline uv_loop_t* event_loop() const;
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
// Defined in src/node_profiler.cc.
void StartGarbageCollectionTracking(Environment* env);
void StopGarbageCollectionTracking(Environment* 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.
11 years ago
#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);
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.
11 years ago
inline explicit IsolateData(v8::Isolate* isolate);
inline v8::Isolate* isolate() const;
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
// Defined in src/node_profiler.cc.
static void BeforeGarbageCollection(v8::Isolate* isolate,
v8::GCType type,
v8::GCCallbackFlags flags);
static void AfterGarbageCollection(v8::Isolate* isolate,
v8::GCType type,
v8::GCCallbackFlags flags);
void BeforeGarbageCollection(v8::GCType type, v8::GCCallbackFlags flags);
void AfterGarbageCollection(v8::GCType type, v8::GCCallbackFlags flags);
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.
11 years ago
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.
11 years ago
PER_ISOLATE_STRING_PROPERTIES(V)
#undef V
unsigned int ref_count_;
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
QUEUE gc_tracker_queue_;
GCInfo gc_info_before_;
GCInfo gc_info_after_;
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.
11 years ago
DISALLOW_COPY_AND_ASSIGN(IsolateData);
};
DISALLOW_COPY_AND_ASSIGN(Environment);
};
} // namespace node
#endif // SRC_ENV_H_