Proxy Requests for Unknown Paths #56

README.md

@@ -295,6 +295,7 @@ Release History
 ---------------
 ### next
 * fix improper handling of carriage return in windows #79 (@git-jiby-me)
+* support to proxy unknown paths to another domain #56 (@git-jiby-me)
 
 ### 0.3.7
 * The regex for matching request, was not considering arrays in the request JSON

bin/canned

@@ -14,6 +14,8 @@ var canned = require('../index')
           .describe('cors', 'disable cors support')
           .default('headers', false)
           .describe('headers', 'add custom headers allowed in cors requests')
+          .default('proxy', '')
+          .describe('proxy', 'proxy unknown paths to this domain')
           .default('h', false)
           .alias('h', 'help')
           .describe('h', 'show the help')
@@ -29,6 +31,7 @@ var dir = ''
 ,   port = argv.p
 ,   cors = argv.cors
 ,   cors_headers = argv.headers
+,   proxy = argv.proxy
 ,   logger
 ,   cannedDir
 ,   wildcard = argv.wildcard
@@ -42,6 +45,12 @@ if (argv.q) {
   process.stdout.write('starting canned on port ' + port + ' for ' + cannedDir + '\n')
 }
 
-var can = canned(dir, { logger: logger, cors: cors, cors_headers: cors_headers, wildcard: wildcard})
+var can = canned(dir, { 
+  logger: logger, 
+  cors: cors, 
+  cors_headers: cors_headers, 
+  wildcard: wildcard, 
+  proxy: proxy
+})
 http.createServer(can).listen(port)
 

index.js

@@ -7,7 +7,7 @@ var canned = function (dir, options) {
   if (!options) options = {}
   dir = path.relative(process.cwd(), dir)
   var c = new Canned(dir, options)
-  return c.responseFilter.bind(c)
+  return c.responder.bind(c)
 }
 
 module.exports = canned

lib/canned.js

@@ -9,10 +9,12 @@ var url = require('url')
 var cannedUtils = require('./utils')
 var lookup = require('./lookup')
 var _ = require('lodash')
+var request = require('request')
 
 function Canned(dir, options) {
   this.logger = options.logger
   this.wildcard = options.wildcard || 'any'
+  this.proxy = options.proxy
   this.response_opts = {
     cors_enabled: options.cors,
     cors_headers: options.cors_headers
@@ -224,27 +226,26 @@ Canned.prototype._responseForFile = function (httpObj, files, cb) {
     fs.readFile(filePath, { encoding: 'utf8' }, function (err, data) {
       var response
       if (err) {
-        response = new Response(getContentType('html'), '', 404, httpObj.res, that.response_opts)
-        cb('Not found', response)
+        cb('Not found', httpObj.res)
       } else {
-        var _data = that.getVariableResponse(data, httpObj.content, httpObj.headers)
-        data = _data.data
-        var statusCode = _data.statusCode
-        var content = that.sanatizeContent(data, fileObject)
-
-        if (content !== false) {
-          response = new Response(_data.contentType || getContentType(fileObject.mimetype), content, statusCode, httpObj.res, that.response_opts, _data.customHeaders)
-          cb(null, response)
-        } else {
-          content = 'Internal Server error invalid input file'
-          response = new Response(getContentType('html'), content, 500, httpObj.res, that.response_opts)
-          cb(null, response)
-        }
+        that._extractRequestContent(httpObj.req, function (content) {
+          var _data = that.getVariableResponse(data, content, httpObj.headers)
+          data = _data.data
+          var statusCode = _data.statusCode
+          content = that.sanatizeContent(data, fileObject)
+          if (content !== false) {
+            response = new Response(_data.contentType || getContentType(fileObject.mimetype), content, statusCode, httpObj.res, that.response_opts, _data.customHeaders)
+            cb(null, response)
+          } else {
+            content = 'Internal Server error invalid input file'
+            response = new Response(getContentType('html'), content, 500, httpObj.res, that.response_opts)
+            cb(null, response)
+          }
+        });
       }
     })
   } else {
-    var response = new Response(getContentType('html'), '', 404, httpObj.res, that.response_opts)
-    cb('Not found', response)
+    cb('Not found', httpObj.res)
   }
 }
 
@@ -278,21 +279,21 @@ Canned.prototype.respondWithAny = function (httpObj, files, cb) {
   })
 }
 
-Canned.prototype.responder = function(body, req, res) {
+Canned.prototype.responder = function(req, res) {
   var responseHandler
   var httpObj = {}
   var that = this
   var parsedurl = url.parse(req.url)
   httpObj.headers   = req.headers
   httpObj.accept    = (req.headers && req.headers.accept) ? req.headers.accept.trim().split(',') : []
-  httpObj.content   = body
   httpObj.pathname  = parsedurl.pathname.split('/')
   httpObj.dname     = httpObj.pathname.pop()
   httpObj.fname     = '_' + httpObj.dname
   httpObj.path      = this.dir + httpObj.pathname.join('/')
   httpObj.query     = parsedurl.query
   httpObj.method    = req.method.toLowerCase()
   httpObj.res       = res
+  httpObj.req       = req
   httpObj.ctype     = ''
 
   this._log('request: ' + httpObj.method + ' ' + req.url)
@@ -320,8 +321,11 @@ Canned.prototype.responder = function(body, req, res) {
         httpObj.path = that.dir + paths.splice(0, 1)[0];
         httpObj.fname = '_' + httpObj.dname;
         return that.findResponse(httpObj, responseHandler);
-      } else {
+      } else if (that.proxy){
+        return that._proxyRequest(httpObj)
+      }else {
         that._log(' not found\n');
+        resp = new Response(getContentType('html'), '', 404, httpObj.res, that.response_opts)
       }
     } else {
       that._logHTTPObject(httpObj)
@@ -334,6 +338,19 @@ Canned.prototype.responder = function(body, req, res) {
 
 }
 
+Canned.prototype._proxyRequest = function (httpObj) {
+  var that = this;
+  var parsedurl = url.parse(httpObj.req.url)
+  var proxyUrl = that.proxy + (parsedurl.path || '') + (parsedurl.query || '')+ (parsedurl.hash || '');
+  that._log(' proxying request to ' + proxyUrl + '\n');
+  return httpObj.req.pipe(request(proxyUrl))
+    .on('error', function(err) {
+      that._log(' proxy gave error ' + err.code + '\n');
+      var resp = new Response(getContentType('html'), '', 404, httpObj.res, that.response_opts)
+      resp.send();
+    }).pipe(httpObj.res);
+}
+
 Canned.prototype.findResponse = function(httpObj, cb) {
   var that = this;
   fs.readdir(httpObj.path, function (err, files) {
@@ -357,11 +374,10 @@ Canned.prototype.findResponse = function(httpObj, cb) {
   })
 }
 
-Canned.prototype.responseFilter = function (req, res) {
+Canned.prototype._extractRequestContent = function (req, callback) {
   var that = this
   var body = ''
-
-  // assemble response body if GET/POST/PUT
+  // assemble request body if GET/POST/PUT
   switch(req.method) {
   case 'PUT':
   case 'POST':
@@ -377,18 +393,18 @@ Canned.prototype.responseFilter = function (req, res) {
           that._log('Invalid json content')
         }
       }
-      that.responder(responderBody, req, res)
+      callback(responderBody);
     })
     break
   case 'GET':
     var query = url.parse(req.url).query
     if (query && query.length > 0) {
       body = querystring.parse(query)
     }
-    that.responder(body, req, res)
+    callback(body)
     break
   default:
-    that.responder(body, req, res)
+    callback(body)
     break
   }
 }

package.json

@@ -14,7 +14,8 @@
   },
   "dependencies": {
     "lodash": "^3.10.1",
-    "optimist": "^0.6.0"
+    "optimist": "^0.6.0",
+    "request": "^2.67.0"
   },
   "devDependencies": {
     "jasmine-node": "^1.14.2",

spec/canned.spec.js

@@ -702,4 +702,56 @@ describe('canned', function () {
     })
   })
 
+  describe("proxy requests for unknown paths", function () {
+    it('should return 404 if path unknown and proxy not configured', function (done) {
+      req.url = '/unkown_path'
+      res.end = function (content) {
+        expect(res.statusCode).toEqual(404);
+        done()
+      }
+      can(req, res)
+    })
+
+    it('should return mock if path known and proxy  configured', function (done) {
+      var can = canned('./spec/test_responses', {
+        proxy: 'http://localhost:9615'
+      })
+
+      req.url = '/a'
+      res.end = function (content) {
+        expect(res.statusCode).toEqual(200);
+        done()
+      }
+      can(req, res)
+    })
+
+    it('should proxy request if path unknown and proxy is configured', function (done) {
+      var proxy = require('http').createServer(function (req, res) {
+        res.writeHead(200, {'Content-Type': 'text/plain'});
+        res.end('OK');
+        req.on('data', function (data) {
+          expect(data.toString()).toEqual('test');
+        })
+      }).listen(9615);
+
+      var can = canned('./spec/test_responses', {
+        proxy: 'http://localhost:9615'
+      })
+
+      var req = new require('stream').Readable();
+      req._read = function noop() {};
+      req.push('test');
+      req.method = 'POST'
+      req.url = '/unkown_path'
+
+      var res = new require('stream').Writable();
+      res._write = function noop(data) {
+        expect(data.toString()).toEqual('OK');
+        proxy.close()
+        done()
+      };
+      can(req, res)
+    })
+  })
+
 })