src/files.js

   1 'use strict';
   2
   3 var async = require('async'),
   4     fs = require('fs'),
   5     path = require('path'),
   6     rm = require('del'),
   7     debug = require('debug')('files'),
   8     mkdirp = require('mkdirp'),
   9     HttpError = require('connect-lastmile').HttpError,
  10     HttpSuccess = require('connect-lastmile').HttpSuccess;
  11
  12 var gBasePath;
  13
  14 exports = module.exports = function (basePath) {
  15     gBasePath = basePath;
  16
  17     return {
  18         get: get,
  19         put: put,
  20         del: del
  21     };
  22 };
  23
  24 // http://stackoverflow.com/questions/11293857/fastest-way-to-copy-file-in-node-js
  25 function copyFile(source, target, cb) {
  26     var cbCalled = false;
  27
  28     // ensure directory
  29     mkdirp(path.dirname(target), function (error) {
  30         if (error) return cb(error);
  31
  32         var rd = fs.createReadStream(source);
  33             rd.on("error", function(err) {
  34             done(err);
  35         });
  36
  37         var wr = fs.createWriteStream(target);
  38             wr.on("error", function(err) {
  39             done(err);
  40         });
  41
  42         wr.on("close", function(ex) {
  43             done();
  44         });
  45
  46         rd.pipe(wr);
  47
  48         function done(err) {
  49             if (!cbCalled) {
  50                 cb(err);
  51                 cbCalled = true;
  52             }
  53         }
  54     });
  55 }
  56
  57 function getAbsolutePath(filePath) {
  58     var absoluteFilePath = path.resolve(path.join(gBasePath, filePath));
  59
  60     if (absoluteFilePath.indexOf(gBasePath) !== 0) return null;
  61     return absoluteFilePath;
  62 }
  63
  64 function removeBasePath(filePath) {
  65     return filePath.slice(gBasePath.length);
  66 }
  67
  68 function get(req, res, next) {
  69     var filePath = req.params[0];
  70     var absoluteFilePath = getAbsolutePath(filePath);
  71     if (!absoluteFilePath) return next(new HttpError(403, 'Path not allowed'));
  72
  73     fs.stat(absoluteFilePath, function (error, result) {
  74         if (error) return next(new HttpError(404, error));
  75
  76         debug('get', absoluteFilePath);
  77
  78         if (!result.isDirectory() && !result.isFile()) return next(new HttpError(500, 'unsupported type'));
  79         if (result.isFile()) return res.sendFile(absoluteFilePath);
  80
  81         async.map(fs.readdirSync(absoluteFilePath), function (filePath, callback) {
  82             fs.stat(path.join(absoluteFilePath, filePath), function (error, result) {
  83                 if (error) return callback(error);
  84
  85                 callback(null, {
  86                     isDirectory: result.isDirectory(),
  87                     isFile: result.isFile(),
  88                     atime: result.atime,
  89                     mtime: result.mtime,
  90                     ctime: result.ctime,
  91                     birthtime: result.birthtime,
  92                     size: result.size,
  93                     filePath: filePath
  94                 });
  95             });
  96         }, function (error, results) {
  97             if (error) return next(new HttpError(500, error));
  98             res.status(222).send({ entries: results });
  99         });
 100     });
 101 }
 102
 103 function put(req, res, next) {
 104     var filePath = req.params[0];
 105
 106     if (!req.files.file) return next(new HttpError(400, 'missing file'));
 107
 108     var absoluteFilePath = getAbsolutePath(filePath);
 109     if (!absoluteFilePath) return next(new HttpError(403, 'Path not allowed'));
 110
 111     fs.stat(absoluteFilePath, function (error, result) {
 112         if (error && error.code !== 'ENOENT') return next(new HttpError(500, error));
 113
 114         debug('put', absoluteFilePath, req.files.file);
 115
 116         if (result && result.isDirectory()) return next(new HttpError(409, 'cannot put on directories'));
 117         if (!result || result.isFile()) {
 118             return copyFile(req.files.file.path, absoluteFilePath, function (error) {
 119                 if (error) return next(new HttpError(500, error));
 120                 next(new HttpSuccess(201, {}));
 121             });
 122         }
 123
 124         return next(new HttpError(500, 'unsupported type'));
 125     });
 126 }
 127
 128 function del(req, res, next) {
 129     var filePath = req.params[0];
 130     var recursive = !!req.query.recursive;
 131     var dryRun = !!req.query.dryRun;
 132
 133     var absoluteFilePath = getAbsolutePath(filePath);
 134     if (!absoluteFilePath) return next(new HttpError(404, 'Not found'));
 135
 136     // absoltueFilePath has to have the base path prepended
 137     if (absoluteFilePath.length <= gBasePath.length) return next(new HttpError(404, 'Not found'));
 138
 139     fs.stat(absoluteFilePath, function (error, result) {
 140         if (error) return next(new HttpError(404, error));
 141
 142         if (result.isDirectory() && !recursive) return next(new HttpError(403, 'Is directory'));
 143
 144         // add globs to get file listing
 145         if (result.isDirectory()) absoluteFilePath += '/**';
 146
 147         rm(absoluteFilePath, { dryRun: dryRun }).then(function (result) {
 148             result = result.map(removeBasePath);
 149             next(new HttpSuccess(200, { entries: result }));
 150         }, function (error) {
 151             console.error(error);
 152             next(new HttpError(500, 'Unable to remove'));
 153         });
 154     });
 155 }