first commit

build/node_modules/fqueue/examples/du1.js

@@ -0,0 +1,69 @@
+
+var fs = require('fs'),
+    path = require('path'),
+    FunctionQueue = require('..');
+
+function Diskusage(p, cb, options) {
+  var self = this;
+  
+  var fqueue = new FunctionQueue(options);
+  var dirs = 0;
+  var files = 0;
+  var bytes = 0;
+  
+  function readdir(p) {
+    var args = arguments;
+    
+    fs.readdir(p, function(err, files) {
+      if(err) {
+        fqueue.error(err, readdir, args);
+      } else {
+        files.forEach(function(file) {
+          fqueue.enqueue(stat, [path.join(p, file)]);
+        });
+      }
+      fqueue.done();
+    });
+  }
+  
+  function stat(p) {
+    var args = arguments;
+    
+    fs.stat(p, function(err, s) {
+      if(err) {
+        fqueue.error(err, stat, args);
+      } else {
+        if(s.isDirectory()) {
+          dirs += 1;
+          fqueue.enqueue(readdir, [p]);
+        } else {
+          files += 1;
+          bytes += s.size;
+        }
+      }
+      fqueue.done();
+    });
+  }
+  
+  fqueue.on('error', function(err) {
+    console.log('error:', err);
+  });
+  
+  fqueue.on('retry', function(func, args) {
+    console.log('retry:', args[0]);
+  });
+  
+  fqueue.on('done', function() {
+    cb(bytes, dirs, files, fqueue.errors);
+  });
+  
+  fqueue.start(stat, [p], this);
+}
+
+// Runtime
+
+Diskusage('.', function(bytes, dirs, files, errors) {
+  console.log('');
+  console.log('diskusage: %d bytes in %d dirs and %d files.', bytes, dirs, files);
+  console.log('           %d unreadable paths.', errors);
+});

build/node_modules/fqueue/examples/du2.js

@@ -0,0 +1,70 @@
+
+var fs = require('fs'),
+    path = require('path'),
+    util = require('util'),
+    FunctionQueue = require('..');
+
+function Diskusage(options) {
+  FunctionQueue.call(this, options);
+  this.dirs = 0;
+  this.files = 0;
+  this.bytes = 0;
+}
+util.inherits(Diskusage, FunctionQueue);
+
+Diskusage.prototype.run = function(dir) {
+  this.start(this._stat, [dir]);
+  return this;
+};
+
+Diskusage.prototype._readdir = function(p) {
+  var self = this, args = arguments;
+  
+  fs.readdir(p, function(err, files) {
+    if(err) {
+      self.error(err, self._readdir, args);
+    } else {
+      files.forEach(function(file) {
+        self.enqueue(self._stat, [path.join(p, file)]);
+      });
+    }
+    self.done();
+  });
+};
+
+Diskusage.prototype._stat = function(p) {
+  var self = this, args = arguments;
+  
+  fs.stat(p, function(err, s) {
+    if(err) {
+      self.error(err, self._stat, args);
+    } else {
+      if(s.isDirectory()) {
+        self.dirs += 1;
+        self.enqueue(self._readdir, [p]);
+      } else {
+        self.files += 1;
+        self.bytes += s.size;
+      }
+    }
+    self.done();
+  });
+};
+
+// Runtime
+
+new Diskusage()
+  .on('error', function(err) {
+    console.log('error:', err);
+  })
+  .on('retry', function(func, args) {
+    console.log('retry:', args[0]);
+  })
+  .on('done', function() {
+    console.log('');
+    console.log('diskusage: %d bytes in %d dirs and %d files.', this.bytes, this.dirs, this.files);
+    console.log('           %d unreadable paths.', this.errors);
+  })
+.run('.');
+
+

build/node_modules/fqueue/examples/hash.js

@@ -0,0 +1,98 @@
+
+var started = Date.now();
+
+var path = require('path'),
+    fs = require('fs'),
+    createHash = require('crypto').createHash,
+    HASH_ALGO = 'md5',
+    fqueue = require('..')({
+      maxPending: 1
+    });
+    dirs = 0,
+    files = 0,
+    bytes = 0,
+    hashstack = {};
+
+fqueue.on('error', function(err) {
+  console.log('error:', err);
+});
+
+fqueue.on('retry', function(func, args) {
+  console.log('retry:', args[0]);
+});
+
+fqueue.on('done', function() {
+  console.log('');
+  var duration = Date.now()-started;
+  console.log('%d ms', duration);
+  console.log('%d dirs, %d files, %d bytes, %d errors', dirs, files, bytes, this.errors);
+  
+  var hash = createHash(HASH_ALGO),
+      keys = Object.keys(hashstack);
+  keys.sort();
+  keys.forEach(function(p) {
+    hash.update(hashstack[p]);
+  });
+  console.log('');
+  console.log(hash.digest('hex'));
+});
+
+fqueue.start(stat, ['.']);
+
+function readfile(p, s) {
+  var args = arguments,
+      rs, hash = createHash(HASH_ALGO);
+  rs = fs.createReadStream(p)
+    .on('error', function(err) {
+      fqueue.error(err, readfile, args);
+      fqueue.done();
+    })
+    .on('data', function(data) {
+      hash.update(data);
+    })
+    rs.on('end', function(data) {
+      hash = hash.digest('binary');
+      hashstack[p] = hash;
+      // console.log(new Buffer(hash, 'binary').toString('hex'), ('                '+s.size).slice(-16), p);
+      console.log(new Buffer(hash, 'binary').toString('hex'), p);
+    })
+    rs.on('close', function(data) {
+      fqueue.done();
+    })
+  ;
+}
+
+function readdir(p, s) {
+  var args = arguments;
+  
+  fs.readdir(p, function(err, files) {
+    if(err) {
+      fqueue.error(err, readdir, args);
+    } else {
+      files.forEach(function(file) {
+        fqueue.enqueue(stat, [path.join(p, file)]);
+      });
+    }
+    fqueue.done();
+  });
+}
+
+function stat(p) {
+  var args = arguments;
+  
+  fs.stat(p, function(err, s) {
+    if(err) {
+      fqueue.error(err, stat, args);
+    } else {
+      if(s.isDirectory()) {
+        dirs += 1;
+        fqueue.enqueue(readdir, [p, s]);
+      } else {
+        files += 1;
+        bytes += s.size;
+        fqueue.enqueue(readfile, [p, s]);
+      }
+    }
+    fqueue.done();
+  });
+}