vulpes
Version:
Job management framework
165 lines (126 loc) • 8.14 kB
JavaScript
;
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; }; }();
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var ChannelQueue = require("@buttercup/channel-queue");
var _require = require("../streams.js"),
waitForStream = _require.waitForStream;
var Helper = require("./Helper.js");
var TASK_TYPE_TAIL = ChannelQueue.Task.TASK_TYPE_TAIL;
/**
* Storage migration helper
* @augments Helper
*/
var StorageMigrationHelper = function (_Helper) {
_inherits(StorageMigrationHelper, _Helper);
/**
* Constructor for the storage migration helper
* @param {Storage} originStorage The storage to migrate from
* @memberof StorageMigrationHelper
*/
function StorageMigrationHelper(originStorage) {
_classCallCheck(this, StorageMigrationHelper);
var _this = _possibleConstructorReturn(this, (StorageMigrationHelper.__proto__ || Object.getPrototypeOf(StorageMigrationHelper)).call(this));
_this._originStorage = originStorage;
return _this;
}
_createClass(StorageMigrationHelper, [{
key: "initialise",
value: function () {
var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
var _this2 = this;
var queue, readStream, allKeys, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, itemID;
return regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
queue = new ChannelQueue();
_context2.next = 3;
return this._originStorage.streamItems();
case 3:
readStream = _context2.sent;
allKeys = [];
readStream.on("data", function (item) {
allKeys.push(item.id);
queue.channel("item").enqueue(_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
return regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
return _context.abrupt("return", _this2.service.storage.setItem(item.id, item));
case 1:
case "end":
return _context.stop();
}
}
}, _callee, _this2);
})));
});
// Wait for the read stream to finish
_context2.next = 8;
return waitForStream(readStream);
case 8:
_context2.next = 10;
return queue.channel("item").enqueue(function () {}, TASK_TYPE_TAIL);
case 10:
// Purge previous storage
_iteratorNormalCompletion = true;
_didIteratorError = false;
_iteratorError = undefined;
_context2.prev = 13;
_iterator = allKeys[Symbol.iterator]();
case 15:
if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
_context2.next = 22;
break;
}
itemID = _step.value;
_context2.next = 19;
return this._originStorage.removeItem(itemID);
case 19:
_iteratorNormalCompletion = true;
_context2.next = 15;
break;
case 22:
_context2.next = 28;
break;
case 24:
_context2.prev = 24;
_context2.t0 = _context2["catch"](13);
_didIteratorError = true;
_iteratorError = _context2.t0;
case 28:
_context2.prev = 28;
_context2.prev = 29;
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
case 31:
_context2.prev = 31;
if (!_didIteratorError) {
_context2.next = 34;
break;
}
throw _iteratorError;
case 34:
return _context2.finish(31);
case 35:
return _context2.finish(28);
case 36:
case "end":
return _context2.stop();
}
}
}, _callee2, this, [[13, 24, 28, 36], [29,, 31, 35]]);
}));
function initialise() {
return _ref.apply(this, arguments);
}
return initialise;
}()
}]);
return StorageMigrationHelper;
}(Helper);
module.exports = StorageMigrationHelper;