chunk-splitter/lib/Chunker.js

File chunk splitter

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _crypto = require('crypto');

var _crypto2 = _interopRequireDefault(_crypto);

var _bluebird = require('bluebird');

var _bluebird2 = _interopRequireDefault(_bluebird);

var _lodash = require('lodash');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

_bluebird2.default.promisifyAll(_fs2.default);

var Chunker = function () {
  function Chunker(filepath) {
    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { chunkSize: 64 * 1e4 },
        chunkSize = _ref.chunkSize;

    _classCallCheck(this, Chunker);

    // 640ko
    this.filepath = filepath;
    this.chunkSize = chunkSize;
    // this.initChunks();
  }

  _createClass(Chunker, [{
    key: 'init',
    value: function init() {
      var _this = this;

      var skipHashmap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;

      return _fs2.default.openAsync(this.filepath, 'r').then(function (fd) {
        _this.fd = fd;
        return _fs2.default.fstatAsync(_this.fd);
      }).then(function (stat) {
        _this.size = stat.size;
        _this.realChunkCount = _this.size / _this.chunkSize;
        _this.chunkCount = Math.ceil(_this.size / _this.chunkSize);

        // Init hashmap
        if (!skipHashmap) return _this.initHashMap();
        return _bluebird2.default.resolve();
      });
    }
  }, {
    key: 'initHashMap',
    value: function initHashMap() {
      var _this2 = this;

      return _bluebird2.default.map((0, _lodash.times)(this.chunkCount), function (index) {
        return _this2.getChunk(index).then(function (buf) {
          var hash = _crypto2.default.createHash('sha1');
          var data = hash.update(buf);
          return data.digest('hex');
        });
      }, { concurrency: 20 }).tap(function (hashes) {
        _this2.hashes = hashes;
        // console.log(JSON.stringify(this.hashes, null, 2));
      });
    }
  }, {
    key: 'getChunkSize',
    value: function getChunkSize() {
      return this.chunkSize;
    }
  }, {
    key: 'getChunkCount',
    value: function getChunkCount() {
      return this.chunkCount;
    }
  }, {
    key: 'getChunk',
    value: function getChunk(index) {
      var buf = Buffer.alloc(index < this.realChunkCount - 1 ? this.chunkSize : this.size % this.chunkSize);
      return _fs2.default.readAsync(this.fd, buf, 0, buf.length, index * this.chunkSize).then(function () {
        return buf;
      });
    }
  }, {
    key: 'getHashMap',
    value: function getHashMap() {
      return this.hashes;
    }
  }, {
    key: 'close',
    value: function close() {
      return _fs2.default.closeAsync(this.fd);
    }
  }]);

  return Chunker;
}();

exports.default = Chunker;
//# sourceMappingURL=Chunker.js.map