deep-package-manager/lib.compiled/Registry/Storage/Storage.js

DEEP Package Manager

/**
 * Created by AlexanderC on 2/3/16.
 */

'use strict';

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

var _TmpFSDriver = require('./Driver/TmpFSDriver');

var _ModuleDB = require('../DB/ModuleDB');

var _SmartStrategy = require('./Strategy/SmartStrategy');

var _ComplexDriver = require('./Driver/ComplexDriver');

var _GitHubDriver = require('./Driver/GitHubDriver');

var _ModuleConfig = require('../ModuleConfig');

var _ModuleInstance = require('../Module/ModuleInstance');

var _ModuleDBLockedException = require('./Exception/ModuleDBLockedException');

class Storage {
  /**
   * @param {TmpFSDriver} driver
   * @param {StdStrategy} strategy
   */
  constructor(driver = null, strategy = null) {
    this._driver = driver || Storage.DEFAULT_DRIVER;
    this._strategy = strategy || Storage.DEFAULT_STRATEGY;
  }

  /**
   * @param {String} moduleContext
   * @param {Function} cb
   */
  moduleExists(moduleContext, cb) {
    this._driver.hasObj(this._strategy.getModuleLocation(moduleContext), cb);
  }

  /**
   * @param {String} moduleContext
   * @param {Function} cb
   */
  readModule(moduleContext, cb) {
    this._driver.readObj(this._strategy.getModuleLocation(moduleContext), (error, rawContent) => {
      if (error) {
        cb(error, null);
        return;
      }

      try {
        cb(null, _ModuleInstance.ModuleInstance.create(moduleContext, rawContent, this));
      } catch (error) {
        cb(error, null);
      }
    });
  }

  /**
   * @param {ModuleInstance} moduleObj
   * @param {Function} cb
   */
  uploadModule(moduleObj, cb) {
    this._driver.putObj(this._strategy.getModuleLocation(moduleObj.context), moduleObj, cb);
  }

  /**
   * @param {String} moduleContext
   * @param {Function} cb
   */
  deleteModule(moduleContext, cb) {
    this._driver.deleteObj(this._strategy.getModuleLocation(moduleContext), cb);
  }

  /**
   * @param {String} moduleContext
   * @param {Function} cb
   */
  moduleConfigExists(moduleContext, cb) {
    this._driver.hasObj(this._strategy.getModuleConfigLocation(moduleContext), cb);
  }

  /**
   * @param {String} moduleContext
   * @param {Function} cb
   */
  readModuleConfig(moduleContext, cb) {
    this._driver.readObj(this._strategy.getModuleConfigLocation(moduleContext), (error, rawContent) => {
      if (error) {
        cb(error, null);
        return;
      }

      try {
        cb(null, new _ModuleConfig.ModuleConfig(moduleContext, rawContent, this));
      } catch (error) {
        cb(error, null);
      }
    });
  }

  /**
   * @param {ModuleConfig} moduleConfig
   * @param {Function} cb
   */
  dumpModuleConfig(moduleConfig, cb) {
    this._driver.putObj(this._strategy.getModuleConfigLocation(moduleConfig.context), moduleConfig, cb);
  }

  /**
   * @param {String} moduleContext
   * @param {Function} cb
   */
  deleteModuleConfig(moduleContext, cb) {
    this._driver.deleteObj(this._strategy.getModuleConfigLocation(moduleContext), cb);
  }

  /**
   * @param {String} moduleContext
   * @param {Function} cb
   */
  moduleDbExists(moduleContext, cb) {
    this._driver.hasObj(this._strategy.getDbLocation(moduleContext), cb);
  }

  /**
   * @param {String} moduleContext
   * @param {Function} cb
   */
  readModuleDb(moduleContext, cb) {
    this._driver.readObj(this._strategy.getDbLocation(moduleContext), (error, rawContent) => {
      if (error) {
        cb(error, null);
        return;
      }

      try {
        cb(null, _ModuleDB.ModuleDB.createFromRawConfig(moduleContext, this, rawContent));
      } catch (error) {
        cb(error, null);
      }
    });
  }

  /**
   * @param {Context} moduleContext
   * @param {Function} cb
   */
  updateModuleDb(moduleContext, cb) {
    let dbObjPath = this._strategy.getDbLocation(moduleContext);

    this._driver.isObjLocked(dbObjPath, (error, state) => {
      if (error) {
        cb(error);
      } else if (state) {
        cb(new _ModuleDBLockedException.ModuleDBLockedException(moduleContext));
      } else {
        this._driver.lockObj(dbObjPath, error => {
          if (error) {
            cb(error);
            return;
          }

          this.moduleDbExists(moduleContext, (error, state) => {
            if (error) {
              this._driver.releaseObjLock(dbObjPath, () => {
                cb(error);
              });

              return;
            }

            if (state) {
              this.readModuleDb(moduleContext, (error, moduleDb) => {
                if (error) {
                  this._driver.releaseObjLock(dbObjPath, () => {
                    cb(error);
                  });

                  return;
                }

                moduleDb.addVersion(moduleContext.version);

                this.dumpModuleDb(moduleDb, error => {
                  this._driver.releaseObjLock(dbObjPath, () => {
                    cb(error);
                  });
                });
              });
            } else {
              let moduleDb = _ModuleDB.ModuleDB.createFromRawConfig(moduleContext, this, '{}');

              moduleDb.addVersion(moduleContext.version);

              this.dumpModuleDb(moduleDb, error => {
                this._driver.releaseObjLock(dbObjPath, () => {
                  cb(error);
                });
              });
            }
          });
        });
      }
    });
  }

  /**
   * @param {ModuleDB} moduleDb
   * @param {Function} cb
   */
  dumpModuleDb(moduleDb, cb) {
    this._driver.putObj(this._strategy.getDbLocation(moduleDb.context), moduleDb, cb);
  }

  /**
   * @param {String} moduleContext
   * @param {Function} cb
   */
  deleteModuleDb(moduleContext, cb) {
    this._driver.deleteObj(this._strategy.getDbLocation(moduleContext), cb);
  }

  /**
   * @returns {TmpFSDriver}
   */
  get driver() {
    return this._driver;
  }

  /**
   * @returns {StdStrategy}
   */
  get strategy() {
    return this._strategy;
  }

  /**
   * @returns {ComplexDriver}
   */
  static get DEFAULT_DRIVER() {
    return new _ComplexDriver.ComplexDriver(new _TmpFSDriver.TmpFSDriver(), new _GitHubDriver.GitHubDriver());
  }

  /**
   * @returns {SmartStrategy}
   */
  static get DEFAULT_STRATEGY() {
    return new _SmartStrategy.SmartStrategy();
  }
}
exports.Storage = Storage;