streams: Pre-emptively buffer readables up to the highWaterMark

Also, this adds a test that guarantees that the ordering of several
push() calls in a row is always preserved in synchronous readable streams

stream: Return false from push() more properly

There are cases where a push() call would return true, even though
the thing being pushed was in fact way way larger than the high
water mark, simply because the 'needReadable' was already set, and
would not get unset until nextTick.

In some cases, this could lead to an infinite loop of pushing data
into the buffer, never getting to the 'readable' event which would
unset the needReadable flag.

Fix by splitting up the emitReadable function, so that it always
sets the flag on this tick, even if it defers until nextTick to
actually emit the event.

Also, if we're not ending or already in the process of reading, it
now calls read(0) if we're below the high water mark.  Thus, the
highWaterMark value is the intended amount to buffer up to, and it
is smarter about hitting the target.

stream: remove lowWaterMark feature

It seems like a good idea on the face of it, but lowWaterMarks are
actually not useful, and in practice should always be set to zero.

It would be worthwhile for writers if we actually did some kind of
writev() type of thing, but actually this just delays calling write()
and the overhead of doing a bunch of Buffer copies is not worth the
slight benefit of calling write() fewer times.

path: Throw TypeError on non-string args to path.resolve

test: modify async native test.js to test for #4820

test: add an "async-hello-world" native addon test

path: join throws TypeError on non-string args

lib/path.js:
  - throws a TypeError on the filter if the argument is not a string.

test/simple/test-path.js:
  - removed the test to check if non-string types are filtered.
  - added a test to check if path.join throws TypeError on arguments that
    are not strings.

tls: _handle.readStart/readStop for CryptoStream

lib/http.js is using stream._handle.readStart/readStop to control
data-flow coming out from underlying stream. If this methods are not
present - data might be buffered regardless of whether it'll be read.

see #4657

process: fix bug where spinner wasn't called

Apperently there is a case where calling the spinner was required after
passing a callback to nextTick(). This fixes that issue.

path: Do not coerce paths to strings on Windows

Fix #4795

stream_wrap: remove superfluous buffer len check

It's a buffer so it's never bigger than Buffer::kMaxLength bytes,
which in turn is always < INT_MAX.

deps: upgrade libuv to 26fa6f8

buffer: check logic simplification

Checks have been simplified and optimized for most-used cases.

Calling Buffer with another Buffer as the subject will now use the
SlowBuffer Copy method instead of the for loop.

No need to call for value coercion, just place the ternary inline.

benchmark: Fix alignment issues on --html compare output

node: code cleanup, make tick_infobox static

It's not used outside of src/node.cc so make it static.

crypto: fix uninitialized memory access in openssl

ASN1_STRING_to_UTF8() passes an ASN1_STRING to ASN1_STRING_set() but forgot to
initialize the `length` field.

Fixes the following valgrind error:

  $ valgrind -q --track-origins=yes --num-callers=19 \
      out/Debug/node test/simple/test-tls-client-abort.js
  ==2690== Conditional jump or move depends on uninitialised value(s)
  ==2690==    at 0x784B69: ASN1_STRING_set (asn1_lib.c:382)
  ==2690==    by 0x809564: ASN1_mbstring_ncopy (a_mbstr.c:204)
  ==2690==    by 0x8090F0: ASN1_mbstring_copy (a_mbstr.c:86)
  ==2690==    by 0x782F1F: ASN1_STRING_to_UTF8 (a_strex.c:570)
  ==2690==    by 0x78F090: asn1_string_canon (x_name.c:409)
  ==2690==    by 0x78EF17: x509_name_canon (x_name.c:354)
  ==2690==    by 0x78EA7D: x509_name_ex_d2i (x_name.c:210)
  ==2690==    by 0x788058: ASN1_item_ex_d2i (tasn_dec.c:239)
  ==2690==    by 0x7890D4: asn1_template_noexp_d2i (tasn_dec.c:746)
  ==2690==    by 0x788CB6: asn1_template_ex_d2i (tasn_dec.c:607)
  ==2690==    by 0x78877A: ASN1_item_ex_d2i (tasn_dec.c:448)
  ==2690==    by 0x7890D4: asn1_template_noexp_d2i (tasn_dec.c:746)
  ==2690==    by 0x788CB6: asn1_template_ex_d2i (tasn_dec.c:607)
  ==2690==    by 0x78877A: ASN1_item_ex_d2i (tasn_dec.c:448)
  ==2690==    by 0x787C93: ASN1_item_d2i (tasn_dec.c:136)
  ==2690==    by 0x78F5E4: d2i_X509 (x_x509.c:141)
  ==2690==    by 0x7C9B91: PEM_ASN1_read_bio (pem_oth.c:81)
  ==2690==    by 0x7CA506: PEM_read_bio_X509 (pem_x509.c:67)
  ==2690==    by 0x703C9A: node::crypto::SecureContext::AddRootCerts(v8::Arguments const&) (node_crypto.cc:497)
  ==2690==  Uninitialised value was created by a stack allocation
  ==2690==    at 0x782E89: ASN1_STRING_to_UTF8 (a_strex.c:560)

openssl: make perlasm target pentium or newer for masm outputs

When perlasm generates MASM code it sets the assembler target to 468.
In this mode MASM refuses to assemble a couple of instructions. Bumping
the target to 686 solves this problem.

openssl: disable HT sidechannel attack mitigation

It used to be off before. It's extremely unlikely that such an attack
would be a viable attack against node. And it makes AES much slower.

openssl: update to 1.0.1e

Merge branch 'benchmark-refactor-2'

bench: Add bench-crypto

bench: Simplify duration arguments to benchmarks

For throughput benchmarks, run with just 5s durations rather than 1s and 3s.

For startup benchmark, run with just a single 1s duration, since it's very
consistent anyway.

bench: Consistency in benchmark filenames

bench: Only run http,net,fs,tls by default

bench: Remove _bench_timer (no loner used)

bench: Use wrk for http benchmarking

Remove ab, since it's no longer used.

tools: Add wrk for benchmarking http servers

bench: Show % change rather than % difference

bench: Add --html to compare script

bench: Fail gracefully if function_call binding fails

make: Add benchmark make targets

bench: Remove old run script

bench: Replace tls-fragmentation with tls/throughput

bench: Move tls-connect into benchmark/tls

Also, make it work properly with current node.

bench: Make io.c output easier to read

bench: Remove io.js

Better covered by the other benchmark/fs scripts.

bench: Add fs write stream throughput

bench: Add read-stream throughput

bench: Move fs-readfile.js to fs/readfile.js

bench: Move v8_bench into misc

bench: Move string_creation into misc

bench: Remove settimeout (Covered by misc/timeout.js)

bench: Move timers to misc/timers

bench: move next-tick to misc/next-tick-breadth

bench: Move nexttick-2 to misc/next-tick-depth

x

bench: Move process_loop to misc/spawn-echo

bench: Add function_call to bench-misc

bench: Arrays

bench: Add buffers/dataview_set

bench: Remove unused 'fast_buffer2' benchmarks

bench: Merge fast_buffer_creation and buffer_creation

bench: Buffer read/write benchmarks

bench: Buffer creation

bench: buffer-base64-encode

bench: misc/startup.js

bench: misc/url

bench: http benchmarks

Also: make http_simple less chatty

bench: Remove client_latency

No one actually knows what this is supposed to be doing,
anyway.  It's not a good benchmark.

bench: Remove throughput (covered by benchmark/net)

bench: net benchmarks using common script

bench: Move net-pipe into benchmark/net

bench: A compare script for analyzing benchmarks

bench: add runner

bench: Add ab() method to common for http testing

bench: Add common script

Now working on v0.9.11

Merge branch 'v0.9.10-release'

2013.02.19, Version 0.9.10 (Unstable)

* V8: Upgrade to 3.15.11.15

* npm: Upgrade to 1.2.12

* fs: Change default WriteStream config, increase perf (isaacs)

* process: streamlining tick callback logic (Trevor Norris)

* stream_wrap, udp_wrap: add read-only fd property (Ben Noordhuis)

* buffer: accept negative indices in Buffer#slice() (Ben Noordhuis)

* tls: Cycle data when underlying socket drains (isaacs)

* stream: read(0) should not always trigger _read(n,cb) (isaacs)

* stream: Empty strings/buffers do not signal EOF any longer (isaacs)

* crypto: improve cipher/decipher error messages (Ben Noordhuis)

* net: Respect the 'readable' flag on sockets (isaacs)

* net: don't suppress ECONNRESET (Ben Noordhuis)

* typed arrays: copy Buffer in typed array constructor (Ben Noordhuis)

* typed arrays: make DataView throw on non-ArrayBuffer (Ben Noordhuis)

* windows: MSI installer enhancements (Scott Blomquist, Jim Schubert)

npm: Upgrade to 1.2.12

tls: Write pending data on socket drain

Fixes #4800

test: Fix regression in tls test

Undefined reference, introduced by a77c29a.

test: Fix tls tests which fail sporadically

The count of ECONNRESETs is dependent on timing, and thus unreliable,
especially on Linux machines.

doc: Use 'close' rather than 'exit' in spawn examples

Close #4515

http: Add fixme comment about ECONNRESET handling

Merge remote-tracking branch 'ry/v0.8' into master

Conflicts:
AUTHORS
ChangeLog
lib/http.js
src/node_version.h
test/simple/test-http-header-response-splitting.js

stream: Pipe data in chunks matching read data

This creates better flow for large values of lowWaterMark.

fs: Change default WriteStream config, increase perf

This increases fs.WriteStream throughput dramatically by removing the
"higher default water marks" for fs.WriteStream.

Also includes a benchmark.  Current performance is significantly higher
than v0.8 for strings at all tested levels except size=1.  Buffer
performance is still lackluster.

Further improvement in the stream.Writable base class is required, but
this is a start.

test: Bump up debugger timeouts

200ms is still short enough for occasional spurious failures.

process: allow ticker to cross communicate better

Using external memory values allows for quick communication between js
and cc land, so we can check if the js land callback needs to be run.
(this is where I meant that manually tracking nextTickQueue.length would
be helpful)

Also did some minor cleanup of removing the old Tick and
StartTickSpinner functions, and a few unneeded comments.

Conflicts:

src/node.cc

process: streamlining tick callback logic

* Callbacks from spinner now calls its own function, separate from the
  tickCallback logic
* MakeCallback will call a domain specific function if a domain is
  detected
* _tickCallback assumes no domains, until nextTick receives a callback
  with a domain. After that _tickCallback is overridden with the domain
  specific implementation.
* _needTickCallback runs in startup() instead of nextTick (isaacs)
* Fix bug in _fatalException where exit would be called twice (isaacs)
* Process.domain has a default value of null
* Manually track nextTickQueue.length (will be useful later)
* Update tests to reflect internal api changes

Revert "Move MakeCallback to JS"

This reverts commit 0109a9f90acdfdb287436676f2384f7b072fbb6a.

Also included:  Port all the changes to process._makeCallback into the
C++ version.  Immediate nextTick, etc.

This yields a slight boost in several benchmarks.  V8 is optimizing and
deoptimizing process._makeCallback repeatedly.

doc: add setImmediate execute timing description

timer: move setImmediate from timer to uv_check

uv_check is the robust place to invoke setImmediate callbacks after
process.nextTick and before timers(setTimeout/setInterval)

blog: Release v0.8.20

Now working on v0.8.21

Merge branch 'v0.8.20-release' into v0.8

2013.02.15, Version 0.8.20 (Stable)

* npm: Upgrade to v1.2.11

* http: Do not let Agent hand out destroyed sockets (isaacs)

* http: Raise hangup error on destroyed socket write (isaacs)

* http: protect against response splitting attacks (Bert Belder)

npm: Upgrade to v1.2.11

http: Do not let Agent hand out destroyed sockets

Fix #4373

http: Raise hangup error on destroyed socket write

Prior to v0.10, Node ignored ECONNRESET errors in many situations.
There *are* valid cases in which ECONNRESET should be ignored as a
normal part of the TCP dance, but in many others, it's a very relevant
signal that must be heeded with care.

Exacerbating this problem, if the OutgoingMessage does not have a
req.connection._handle, it assumes that it is in the process of
connecting, and thus buffers writes up in an array.

The problem happens when you reuse a socket between two requests, and it
is destroyed abruptly in between them.  The writes will be buffered,
because the socket has no handle, but it's not ever going to GET a
handle, because it's not connecting, it's destroyed.

The proper fix is to treat ECONNRESET correctly.  However, this is a
behavior/semantics change, and cannot land in a stable branch.

Fix #4775

doc: clarify child_process.exec() stdio option

It only works for stdin, not stdout/stderr, for obvious reasons.

doc: add tools/ dir to CONTRIBUTING.md verboten list

doc: add prompt to fix repl_test.js example

Running repl.start without the prompt set produces this error:

repl.js:95
    throw new Error('An options Object, or a prompt String are required');
          ^
Error: An options Object, or a prompt String are required
    at new REPLServer (repl.js:95:11)
    at Object.exports.start (repl.js:321:14)
    at Object.<anonymous> (/Users/dan/Dropbox/Documents/dev/nextgen/repl_test.js:5:6)
    at Module._compile (module.js:449:26)
    at Object.Module._extensions..js (module.js:467:10)
    at Module.load (module.js:356:32)
    at Function.Module._load (module.js:312:12)
    at Module.runMain (module.js:492:10)
    at process.startup.processNextTick.process._tickCallback (node.js:244:9)

stream_wrap, udp_wrap: add read-only fd property

Expose the file descriptor as a read-only property on the internal
handle objects. Intended for debugging purposes, not part of the API
proper. The property is always null on Windows.

Fixes #4754.

udp_wrap: use proper imports in source file

udp_wrap: don't use namespace imports in header

It's not really harmful but it's inconsistent with the other header
files.

buffer: accept negative indices in Buffer#slice()

A negative start or end parameter now indexes from the end of the
buffer. More in line with String#slice() and ArrayBuffer#slice().

net: Respect the 'readable' flag on sockets

Previously, we were only destroying sockets on end if their readable
side had already been ended.  This causes a problem for non-readable
streams, since we don't expect to ever see an 'end' event from those.

Treat the lack of a 'readable' flag the same as if it was an ended
readable stream.

Fix #4751

blog: Forgot slug on peer-dependencies article

blog: Peer Dependencies article

Thanks, @domenic