var fs = require('fs') , Path = require('path') , crypto = require('crypto') , assert = require('assert') , fs_storage = require('./local-fs') , UError = require('./error').UserError , utils = require('./utils') , mystreams = require('./streams') , Logger = require('./logger') , info_file = 'package.json' // // Implements Storage interface // (same for storage.js, local-storage.js, up-storage.js) // function Storage(config) { if (!(this instanceof Storage)) return new Storage(config) this.config = config this.logger = Logger.logger.child({sub: 'fs'}) return this } // returns the minimal package file function get_boilerplate(name) { return { // standard things name: name, versions: {}, 'dist-tags': {}, // our own object '_distfiles': {}, '_attachments': {}, '_uplinks': {}, } } Storage.prototype._internal_error = function(err, file, message) { this.logger.error( {err: err, file: file} , message + ' @{file}: @{!err.message}' ) return new UError({ status: 500, message: 'internal server error' }) } Storage.prototype.add_package = function(name, metadata, callback) { this.storage(name).create_json(info_file, get_boilerplate(name), function(err) { if (err && err.code === 'EEXISTS') { return callback(new UError({ status: 409, message: 'this package is already present' })) } callback() }) } Storage.prototype.remove_package = function(name, callback) { var self = this self.logger.info({name: name}, 'unpublishing @{name} (all)') self.storage(name).read_json(info_file, function(err, data) { if (err) { if (err.code === 'ENOENT') { return callback(new UError({ status: 404, message: 'no such package available', })) } else { return callback(err) } } self._normalize_package(data) self.storage(name).unlink(info_file, function(err) { if (err) return callback(err) var files = Object.keys(data._attachments) function unlinkNext(cb) { if (files.length === 0) return cb() var file = files.shift() self.storage(name).unlink(file, function() { unlinkNext(cb) }) } unlinkNext(function() { // try to unlink the directory, but ignore errors because it can fail self.storage(name).rmdir('.', function(err) { callback(err) }) }) }) }) } Storage.prototype._read_create_package = function(name, callback) { var self = this self.storage(name).read_json(info_file, function(err, data) { // TODO: race condition if (err) { if (err.code === 'ENOENT') { // if package doesn't exist, we create it here data = get_boilerplate(name) } else { return callback(self._internal_error(err, info_file, 'error reading')) } } self._normalize_package(data) callback(null, data) }) } // synchronize remote package info with the local one // TODO: readfile called twice Storage.prototype.update_versions = function(name, newdata, callback) { var self = this self._read_create_package(name, function(err, data) { if (err) return callback(err) var change = false for (var ver in newdata.versions) { if (data.versions[ver] == null) { var verdata = newdata.versions[ver] // why does anyone need to keep that in database? delete verdata.readme change = true data.versions[ver] = verdata if (verdata.dist && verdata.dist.tarball) { var url = utils.parse_tarball_url( /*verdata.dist.__sinopia_orig_tarball ||*/ verdata.dist.tarball ) // we do NOT overwrite any existing records if (url != null && data._distfiles[url.filename] == null) { data._distfiles[url.filename] = { url: /*verdata.dist.__sinopia_orig_tarball ||*/ verdata.dist.tarball, sha: verdata.dist.shasum, } } } } } for (var tag in newdata['dist-tags']) { if (!Array.isArray(data['dist-tags'][tag]) || data['dist-tags'][tag].length != newdata['dist-tags'][tag].length) { // backward compat var need_change = true } else { for (var i=0; i startkey) { list.push({ time: stats.mtime, name: file }) } if (++i !== filesL) { return false } return callback(null, list) }) }) }) } // // This function allows to update the package thread-safely // // Arguments: // - name - package name // - updateFn - function(package, cb) - update function // - callback - callback that gets invoked after it's all updated // // Algorithm: // 1. lock package.json for writing // 2. read package.json // 3. updateFn(pkg, cb), and wait for cb // 4. write package.json.tmp // 5. move package.json.tmp package.json // 6. callback(err?) // Storage.prototype.update_package = function(name, updateFn, _callback) { var self = this self.storage(name).lock_and_read_json(info_file, function(err, fd, json) { function callback() { var _args = arguments if (fd) { fs.close(fd, function(err) { if (err) return _callback(err) _callback.apply(null, _args) }) } else { _callback.apply(null, _args) } } if (err) { if (err.code === 'EAGAIN') { return callback(new UError({ status: 503, message: 'resource temporarily unavailable' })) } else if (err.code === 'ENOENT') { return callback(new UError({ status: 404, message: 'no such package available', })) } else { return callback(err) } } self._normalize_package(json) updateFn(json, function(err) { if (err) return callback(err) self._write_package(name, json, callback) }) }) } Storage.prototype._normalize_package = function(pkg) { ;['versions', 'dist-tags', '_distfiles', '_attachments', '_uplinks'].forEach(function(key) { if (!utils.is_object(pkg[key])) pkg[key] = {} }) if (typeof(pkg._rev) !== 'string') pkg._rev = '0-0000000000000000' } Storage.prototype._write_package = function(name, json, callback) { // calculate revision a la couchdb if (typeof(json._rev) !== 'string') json._rev = '0-0000000000000000' var rev = json._rev.split('-') json._rev = ((+rev[0] || 0) + 1) + '-' + crypto.pseudoRandomBytes(8).toString('hex') this.storage(name).write_json(info_file, json, callback) } Storage.prototype.storage = function(package) { return new Path_Wrapper( Path.join( Path.resolve( Path.dirname(this.config.self_path), this.config.get_package_setting(package, 'storage') || this.config.storage ), package ) ) } var Path_Wrapper = (function() { // a wrapper adding paths to fs_storage methods function Wrapper(path) { this.path = path } for (var i in fs_storage) { if (fs_storage.hasOwnProperty(i)) { Wrapper.prototype[i] = wrapper(i) } } function wrapper(method) { return function(/*...*/) { var args = Array.prototype.slice.apply(arguments) args[0] = Path.join(this.path, args[0] || '') return fs_storage[method].apply(null, args) } } return Wrapper })() module.exports = Storage