caike · October 17, 2022 00:27 · Jul 17, 2014 · Jul 17, 2014 · Jul 17, 2014 · Jul 9, 2014
diff --git a/streams-2-back-pressure.js b/streams-2-back-pressure.js
@@ -7,6 +7,6 @@ readStream.on('readable', function() {
   }	
 })
 
-readStream.on('drain', function() {
+writeStream.on('drain', function() {
   canWrite = true;
 });
diff --git a/streams-2-back-pressure.js b/streams-2-back-pressure.js
@@ -1,10 +1,10 @@
 var canWrite = true;
 
 readStream.on('readable', function() {
-	while(canWrite && (null !== (chunk = readStream.read()))){
-		var bufferGood = writeStream.write(chunk)
-		if (!bufferGood) canWrite = false;
-	}	
+  while(canWrite && (null !== (chunk = readStream.read()))){
+    var bufferGood = writeStream.write(chunk)
+    if (!bufferGood) canWrite = false;
+  }	
 })
 
 readStream.on('drain', function() {

diff --git a/about.md b/about.md
@@ -6,13 +6,9 @@
 * Instead of `data` events spewing, call `read()` to pull data from source.
 * When there isn't any data to consume, then `read()` will return **undefined**.
 * Adding a `data` event listener will switch the Readable stream into "old mode", where data is emitted as soon as it is available rather than waiting for you to call `read()` to consume it. This requires you to handle backpressure problems manually.
-* The `pipe` method helps write less code and handles backpressure.
+* The `pipe` method helps write less code and handles back-pressure.
 * If you add an `end` listener and don't ever `read()` or `pipe()`, it'll never emit `end`.
 
-## Question
-
-Is there still room for back-pressure issues in streams2 ?
-
 ## Resources
 
 [Isaac Z. Presentation](https://dl.dropboxusercontent.com/u/3685/presentations/streams2/streams2-ko.pdf)  

diff --git a/streams-2-back-pressure.js b/streams-2-back-pressure.js
@@ -0,0 +1,12 @@
+var canWrite = true;
+
+readStream.on('readable', function() {
+	while(canWrite && (null !== (chunk = readStream.read()))){
+		var bufferGood = writeStream.write(chunk)
+		if (!bufferGood) canWrite = false;
+	}	
+})
+
+readStream.on('drain', function() {
+  canWrite = true;
+});
diff --git a/about.md b/about.md
@@ -9,20 +9,7 @@
 * The `pipe` method helps write less code and handles backpressure.
 * If you add an `end` listener and don't ever `read()` or `pipe()`, it'll never emit `end`.
 
-From <http://nodejs.org/api/stream.html#stream_class_stream_readable>:
-
-The Readable stream interface is the abstraction for a source of data that you are reading from. In other words, data comes out of a Readable stream.
-
-A Readable stream will not start emitting data until you indicate that you are ready to receive it.
-
-Readable streams have two "modes":
-
-* flowing mode
-* non-flowing mode.
-
-When in flowing mode (old mode), data is read from the underlying system and provided to your program as fast as possible. In non-flowing mode (a.k.a. streams2), you must explicitly call `stream.read()` to get chunks of data out.
-
-## Questions
+## Question
 
 Is there still room for back-pressure issues in streams2 ?
 

diff --git a/streams-2-file-upload.js → upload-streams-2.js b/streams-2-file-upload.js → upload-streams-2.js
diff --git a/streams-2-file-upload.js b/streams-2-file-upload.js
@@ -0,0 +1,27 @@
+var http = require('http');
+var fs = require('fs');
+
+http.createServer(function(req, res) {
+
+  var newFile = fs.createWriteStream('destination.jpg');
+  var fileBytes = req.headers['content-length'];
+  var uploadedBytes = 0;
+
+  req.on('readable', function() {
+    var chunk = null;
+    while(null !== (chunk = req.read())){
+      uploadedBytes += chunk.length;
+      var progress = (uploadedBytes / fileBytes) * 100;
+      res.write("Progress: " + parseInt(progress, 10) + "%\n");
+    }
+  });
+
+  req.on('end', function() {
+    res.end('uploaded!');
+  });
+
+  req.pipe(newFile);
+
+}).listen(8080);
+
+// run with `curl --upload-file <your-file.jpg> http://localhost:8080`
diff --git a/about.md b/about.md
@@ -28,7 +28,7 @@ Is there still room for back-pressure issues in streams2 ?
 
 ## Resources
 
-[Izaac S. Presentation](https://dl.dropboxusercontent.com/u/3685/presentations/streams2/streams2-ko.pdf)  
+[Isaac Z. Presentation](https://dl.dropboxusercontent.com/u/3685/presentations/streams2/streams2-ko.pdf)  
 [Tim Caswell](http://howtonode.org/streams-explained)  
 [Stream Compatibility](http://nodejs.org/api/stream.html#stream_compatibility_with_older_node_versions)  
 [Getting Started With Streams2](http://maxantoni.de/blog/2013/06/getting-started-with-streams-2.html)  
diff --git a/about.md b/about.md
@@ -28,7 +28,7 @@ Is there still room for back-pressure issues in streams2 ?
 
 ## Resources
 
-[Izaac S. Presentation](https://dl.dropboxusercontent.com/u/3685/presentations/streams2/streams2-ko.pdf)
-[Tim Caswell](http://howtonode.org/streams-explained)
-[Stream Compatibility](http://nodejs.org/api/stream.html#stream_compatibility_with_older_node_versions)
-[Getting Started With Streams2](http://maxantoni.de/blog/2013/06/getting-started-with-streams-2.html)
+[Izaac S. Presentation](https://dl.dropboxusercontent.com/u/3685/presentations/streams2/streams2-ko.pdf)  
+[Tim Caswell](http://howtonode.org/streams-explained)  
+[Stream Compatibility](http://nodejs.org/api/stream.html#stream_compatibility_with_older_node_versions)  
+[Getting Started With Streams2](http://maxantoni.de/blog/2013/06/getting-started-with-streams-2.html)  
diff --git a/about.md b/about.md
@@ -4,11 +4,10 @@
 * Introduced in node v0.10.
 * "suck" streams instead of "spew" streams.
 * Instead of `data` events spewing, call `read()` to pull data from source.
-* When there isn't any data to consume, then `read()` will return null.
-* In order to tweak back pressure settings, there is a `highWaterMark` and `lowWaterMark` property. These are limits that lets us configure how different streams exert backpressure.
-* All Writables emit `finish` when ended and flushed.
-* New streams can switch into old-mode, where they spew data. Adding a `data` event listener will switch the Readable stream into "old mode", where data is emitted as soon as it is available rather than waiting for you to call `read()` to consume it.
-* If you add an `end` listener, but don't add a `data` listener, and don't ever `read()` or `pipe()`, it'll never emit `end`.
+* When there isn't any data to consume, then `read()` will return **undefined**.
+* Adding a `data` event listener will switch the Readable stream into "old mode", where data is emitted as soon as it is available rather than waiting for you to call `read()` to consume it. This requires you to handle backpressure problems manually.
+* The `pipe` method helps write less code and handles backpressure.
+* If you add an `end` listener and don't ever `read()` or `pipe()`, it'll never emit `end`.
 
 From <http://nodejs.org/api/stream.html#stream_class_stream_readable>:
 
@@ -23,5 +22,13 @@ Readable streams have two "modes":
 
 When in flowing mode (old mode), data is read from the underlying system and provided to your program as fast as possible. In non-flowing mode (a.k.a. streams2), you must explicitly call `stream.read()` to get chunks of data out.
 
+## Questions
+
+Is there still room for back-pressure issues in streams2 ?
+
 ## Resources
+
 [Izaac S. Presentation](https://dl.dropboxusercontent.com/u/3685/presentations/streams2/streams2-ko.pdf)
+[Tim Caswell](http://howtonode.org/streams-explained)
+[Stream Compatibility](http://nodejs.org/api/stream.html#stream_compatibility_with_older_node_versions)
+[Getting Started With Streams2](http://maxantoni.de/blog/2013/06/getting-started-with-streams-2.html)
diff --git a/about. → about.md b/about. → about.md
diff --git a/about. b/about.
@@ -0,0 +1,27 @@
+# NodeJS Streams
+
+* Current implementation is known as **streams2**.
+* Introduced in node v0.10.
+* "suck" streams instead of "spew" streams.
+* Instead of `data` events spewing, call `read()` to pull data from source.
+* When there isn't any data to consume, then `read()` will return null.
+* In order to tweak back pressure settings, there is a `highWaterMark` and `lowWaterMark` property. These are limits that lets us configure how different streams exert backpressure.
+* All Writables emit `finish` when ended and flushed.
+* New streams can switch into old-mode, where they spew data. Adding a `data` event listener will switch the Readable stream into "old mode", where data is emitted as soon as it is available rather than waiting for you to call `read()` to consume it.
+* If you add an `end` listener, but don't add a `data` listener, and don't ever `read()` or `pipe()`, it'll never emit `end`.
+
+From <http://nodejs.org/api/stream.html#stream_class_stream_readable>:
+
+The Readable stream interface is the abstraction for a source of data that you are reading from. In other words, data comes out of a Readable stream.
+
+A Readable stream will not start emitting data until you indicate that you are ready to receive it.
+
+Readable streams have two "modes":
+
+* flowing mode
+* non-flowing mode.
+
+When in flowing mode (old mode), data is read from the underlying system and provided to your program as fast as possible. In non-flowing mode (a.k.a. streams2), you must explicitly call `stream.read()` to get chunks of data out.
+
+## Resources
+[Izaac S. Presentation](https://dl.dropboxusercontent.com/u/3685/presentations/streams2/streams2-ko.pdf)
diff --git a/streams-1.js b/streams-1.js
@@ -0,0 +1,21 @@
+// streams1
+// works in node v0.6.21
+// works in node v0.10.29 (latest stable)
+// Tested with `curl -d 'akshdakjhdakjhsdkajhdjkahdsjka' http://localhost:8080`
+var http = require('http');
+
+http.createServer(function(req, res) {
+
+  console.log('Got Request');
+
+  res.writeHead(200);
+
+  req.on('data', function(chunk){
+    console.log('got %d bytes of data', chunk.length);
+  });
+
+  req.on('end', function() {
+    res.end('over');
+  });
+
+}).listen(8080);
diff --git a/streams-2.js b/streams-2.js
@@ -0,0 +1,23 @@
+// streams2
+// works in v0.10.29
+// does not work in v.0.6.21
+// Example taken from http://nodejs.org/api/stream.html#stream_class_stream_readable
+// Tested with `curl -d 'akshdakjhdakjhsdkajhdjkahdsjka' http://localhost:8080`
+var http = require('http');
+
+http.createServer(function(req, res) {
+
+  console.log('Got Request');
+
+  req.on('readable', function() {
+    var chunk = null;
+    while (null !== (chunk = req.read())) {
+      console.log('got %d bytes of data', chunk.length);
+    }
+  });
+
+  req.on('end', function() {
+    res.end('Done');
+  });
+
+}).listen(8080);
No results found