Permalink
Browse files

Initial commit.

  • Loading branch information...
0 parents commit e8300abc84cf16f11a7ce3a3b880fde4ad9901c4 @mikeal committed Oct 28, 2011
Showing with 900 additions and 0 deletions.
  1. +76 −0 README.md
  2. +182 −0 main.js
  3. +146 −0 mimetypes.js
  4. +14 −0 package.json
  5. +47 −0 rfc822.js
  6. +20 −0 test-server.js
  7. +197 −0 test.js
  8. +1 −0 test/index.html
  9. +20 −0 test/server.js
  10. +197 −0 test/test.js
@@ -0,0 +1,76 @@
+# filed -- Simplified file library.
+
+## Install
+
+<pre>
+ npm install filed
+</pre>
+
+## Super simple to use
+
+Filed does a lazy stat call so you can actually open a file and being writing to it and if the file isn't there it will just be created.
+
+```javascript
+var request = require('filed');
+var f = filed('/newfile')
+f.write('test')
+f.end()
+```
+
+## Streaming
+
+The returned file object is a stream so you can do standard stream stuff to it. Based on *what* you do the object it will be a read stream, a write stream.
+
+So if you send data to it, it'll be a write stream.
+
+```javascript
+fs.createReadStream(filed('/newfile'))
+```
+
+If you pipe it to a destination it'll be a read stream.
+
+```javascript
+filed('/myfile').pipe(fs.createWriteStream('/out'))
+```
+
+And of course you can pipe a filed object from itself to itself and it'll figure it out.
+
+```javascript
+filed('/myfile').pipe(filed('/newfile'))
+```
+
+Those familiar with [request](http://github.com/mikeal/request) will be familiar seeing object capability detection when doing HTTP. filed does this as well.
+
+```javascript
+http.createServer(function (req, resp) {
+ filed('/data.json').pipe(resp)
+})
+```
+
+Not only does the JSON file get streamed to the HTTP Response it will include an Etag, Last-Modified, Content-Length, and a Content-Type header based on the filed extension.
+
+```javascript
+http.createServer(function (req, resp) {
+ req.pipe(filed('/newfile')).pipe(resp)
+})
+```
+
+When accepting a PUT request data will be streamed to the file and a 201 status will be sent on the HTTP Response when the upload is finished.
+
+During a GET request a 404 Response will be sent if the file does not exist.
+
+```javascript
+http.createServer(function (req, resp) {
+ req.pipe(filed('/data.json')).pipe(resp)
+})
+```
+
+The Etag and Last-Modified headers filed creates are based solely on the stat() call so if you pipe a request to an existing file the cache control headers will be taken in to account a 304 response will be sent if the cache control headers match a new stat() call. This can be very helpful in avoiding unnecessary disc reads.
+
+```javascript
+http.createServer(function (req, resp) {
+ req.pipe(filed('/directory')).pipe(resp)
+})
+```
+
+Just to round out the full feature set and make it full file server if you give filed an existing directory it will actually check for an index.html file in that directory and serve it if it exists.
182 main.js
@@ -0,0 +1,182 @@
+var fs = require('fs')
+ , util = require('util')
+ , crypto = require('crypto')
+ , stream = require('stream')
+ , path = require('path')
+ , mimetypes = require('./mimetypes')
+ , rfc822 = require('./rfc822')
+ ;
+
+function File (options) {
+ stream.Stream.call(this)
+
+ this.writable = true
+ this.readable = true
+ this.buffers = []
+
+ var self = this
+
+ if (typeof options === 'string') options = {path:options}
+ if (!options.index) options.index = 'index.html'
+ self.writable = (typeof options.writable === "undefined") ? true : options.writable
+ self.readable = (typeof options.readable === "undefined") ? true : options.readable
+
+ self.path = options.path
+ self.index = options.index
+
+ self.on('pipe', function (src) {
+ this.src = src;
+ })
+
+ this.buffering = true
+
+ this.mimetype = mimetypes.lookup(this.path.slice(this.path.lastIndexOf('.')+1))
+
+ var stopBuffering = function () {
+ self.buffering = false
+ while (self.buffers.length) {
+ self.emit('data', self.buffers.shift())
+ }
+ if (self.ended) self.emit('end')
+ }
+
+ fs.stat(options.path, function (err, stats) {
+
+ var finish = function (err, stats) {
+ if (err && !self.dest && !self.src) return self.emit('error', err)
+ if (err && self.dest && !self.dest.writeHead) return self.emit('error', err)
+
+ // See if writes are disabled
+ if (self.src && self.src.method &&
+ !self.writable && self.dest.writeHead &&
+ (self.src.method === 'PUT' || self.src.method === 'POST')) {
+ self.dest.writeHead(405, {'content-type':'text/plain'})
+ self.dest.end(self.src.method+' Not Allowed')
+ return
+ }
+
+ if (!err) {
+ self.etag = crypto.createHash('md5').update(stats.ino + stats.mtime + stats.size).digest("hex")
+ self.lastmodified = rfc822.getRFC822Date(stats.mtime)
+ }
+
+ process.nextTick(function () {
+ stopBuffering()
+ })
+
+ // 404 and 500
+ if ( err && self.dest && self.dest.writeHead && // We have an error object and dest is an HTTP response
+ ( // Either we have a source and it's a GET/HEAD or we don't have a src
+ (self.src && (self.src.method == 'GET' || self.src.method === 'HEAD')) || (!self.src)
+ )
+ ) {
+ if (err.code === 'ENOENT') {
+ self.dest.statusCode = 404
+ self.end('Not Found')
+ } else {
+ self.dest.statusCode = 500
+ self.end(err.message)
+ }
+ return
+ }
+
+ // Source is an HTTP Server Request
+ if (self.src && (self.src.method === 'GET' || self.src.method === 'HEAD')) {
+
+ self.dest.setHeader('content-type', self.mimetype)
+ self.dest.setHeader('etag', self.etag)
+ self.dest.setHeader('last-modified', self.lastmodified)
+
+ if (self.dest && self.dest.writeHead) {
+ if (self.src && self.src.headers) {
+ if (self.src.headers['if-none-match'] === self.etag ||
+ // Lazy last-modifed matching but it's faster than parsing Datetime
+ self.src.headers['if-modifified-since'] === self.lastmodified) {
+ self.dest.statusCode = 304
+ self.dest.end()
+ return
+ }
+ }
+ // We're going to return the whole file
+ self.dest.statusCode = 200
+ self.dest.setHeader('content-length', stats.size)
+ } else if (self.dest && !self.dest.writeHead) {
+ // Destination is not an HTTP response, GET and HEAD method are not allowed
+ return
+ }
+ if (self.dest || self.src.method !== 'HEAD') {
+ fs.createReadStream(self.path).pipe(self.dest)
+ }
+ return
+ }
+ if (self.src && (self.src.method === 'PUT' || self.src.method === 'POST')) {
+ if (!err) {
+ // TODO handle overwrite case
+ return
+ }
+ stream.Stream.prototype.pipe.call(self, fs.createWriteStream(self.path))
+ if (self.dest && self.dest.writeHead) {
+ self.on('end', function () {
+ self.dest.statusCode = 201
+ self.dest.setHeader('content-length', 0)
+ self.dest.end()
+ })
+ }
+ return
+ }
+ // Desination is an HTTP response, we already handled 404 and 500
+ if (self.dest && self.dest.writeHead) {
+ self.dest.statusCode = 200
+ self.dest.setHeader('content-type', self.mimetype)
+ self.dest.setHeader('etag', self.etag)
+ self.dest.setHeader('last-modified', self.lastmodified)
+ fs.createReadStream(self.path).pipe(self.dest)
+ return
+ }
+
+ // Destination is not an HTTP request
+
+ if (self.src && !self.dest) {
+ stream.Stream.prototype.pipe.call(self, fs.createWriteStream(self.path))
+ } else if (self.dest && !self.src) {
+ fs.createReadStream(self.path).pipe(self.dest)
+ }
+ }
+
+ if (!err && stats.isDirectory()) {
+ self.path = path.join(self.path, self.index)
+ self.mimetype = mimetypes.lookup(self.path.slice(self.path.lastIndexOf('.')+1))
+ fs.stat(self.path, finish)
+ } else {
+ finish(err, stats)
+ }
+
+ })
+
+}
+util.inherits(File, stream.Stream)
+File.prototype.pipe = function (dest, options) {
+ this.dest = dest
+ this.destOptions = options
+ // stream.Stream.prototype.pipe.call(this, dest, options)
+}
+File.prototype.write = function (chunk, encoding) {
+ if (encoding) chunk = chunk.toString(encoding)
+ if (this.buffering) {
+ this.buffers.push(chunk)
+ } else {
+ this.emit('data', chunk)
+ }
+}
+File.prototype.end = function () {
+ if (this.buffering) {
+ this.ended = true
+ } else {
+ this.emit('end')
+ }
+}
+
+module.exports = function (options) {
+ return new File(options)
+}
+module.exports.File = File
Oops, something went wrong.

0 comments on commit e8300ab

Please sign in to comment.