gina 0.6.7 → 0.6.8

package/framework/{v0.6.7 → v0.6.8}/lib/storage/src/local-cas.js

@@ -658,7 +658,7 @@ module.exports = function createLocalCasDriver(name, conf, metaStore) {
      */
     var capabilities = {
         offload   : false,
-        ranges    : false,
+        ranges    : true,
         dedup     : true,
         resumable : false,
         inline    : ( inlineThreshold > 0 )
@@ -727,14 +727,41 @@ module.exports = function createLocalCasDriver(name, conf, metaStore) {
             var ws      = null;
             var head    = [];
 
+            /**
+             * Abandon the put: tear both streams down, remove the temp, report.
+             *
+             * #B358 — the unlink WAITS for the write stream to close, and the
+             * callback waits with it, for the reason spelled out in `local.js`:
+             * `createWriteStream()` opens asynchronously, so an error arriving
+             * right after `spill()` reaches here while the `open(2)` is still
+             * in the threadpool, and an `existsSync`-gated unlink reads false,
+             * skips, and orphans the temp the worker thread creates a tick
+             * later. cas is vulnerable in its own right, not merely by shape:
+             * fault-injecting that one false `existsSync` answer orphaned a
+             * real temp here exactly as it did in `local.js`. It had simply
+             * never been SEEN, because this driver's interrupted-put tests
+             * destroy the source on a `setImmediate`, which hands the open the
+             * extra tick that hides the window. A null `ws` means `spill()`
+             * never ran; `force` makes that a no-op.
+             *
+             * @inner
+             * @param {*} err - The failure to report; wrapped if not an Error.
+             * @returns {void}
+             */
             var onError = function(err) {
                 if (settled) return;
                 settled = true;
                 head = null;
                 try { stream.destroy(); } catch (_e) {}
-                if (ws) { try { ws.destroy(); } catch (_e) {} }
-                try { if ( fs.existsSync(tmp) ) fs.unlinkSync(tmp); } catch (_e) {}
-                fn(( err instanceof Error ) ? err : new Error(String(err)));
+
+                var finish = function() {
+                    try { fs.rmSync(tmp, { force: true }); } catch (_e) {}
+                    fn(( err instanceof Error ) ? err : new Error(String(err)));
+                };
+
+                if ( !ws || ws.closed || ws.destroyed ) { return finish(); }
+                ws.once('close', finish);
+                try { ws.destroy(); } catch (_e) { finish(); }
             };
 
             /**
@@ -925,7 +952,7 @@ module.exports = function createLocalCasDriver(name, conf, metaStore) {
             metaStore.get(key, function(metaErr, m) {
                 if (metaErr) { return fn(metaErr); }
                 if ( !m || ( typeof m.refs === 'number' && m.refs < 1 ) ) {
-                    return fn(new Error('[storage:' + name + '] no object for key `' + key + '`'));
+                    return fn(util.codedError('STORAGE_NO_OBJECT', '[storage:' + name + '] no object for key `' + key + '`'));
                 }
                 if ( m.data != null ) {
                     // NB: the buffer must be wrapped in an array —
@@ -933,7 +960,7 @@ module.exports = function createLocalCasDriver(name, conf, metaStore) {
                     return fn(null, Readable.from([m.data]));
                 }
                 if ( !fs.existsSync(r.path) ) {
-                    return fn(new Error('[storage:' + name + '] no object for key `' + key + '`'));
+                    return fn(util.codedError('STORAGE_NO_OBJECT', '[storage:' + name + '] no object for key `' + key + '`'));
                 }
                 var rs = fs.createReadStream(r.path);
                 var handed = false;
@@ -950,6 +977,73 @@ module.exports = function createLocalCasDriver(name, conf, metaStore) {
             });
         },
 
+        /**
+         * Byte-range read — the driver half of HTTP Range serving.
+         *
+         * Contract is identical to the `sharded` twin (`end` INCLUSIVE, an
+         * over-long `end` clamped, only an unsatisfiable `start` refused), with
+         * one cas-specific addition: a zero-ref row reads as ABSENT here exactly
+         * as it does through `get()`/`stat()`/`resolve()`, so a released blob
+         * awaiting the sweep can never be range-read back into existence.
+         *
+         * Blobs are immutable, which makes them the ideal Range subject — the
+         * bytes behind a key can never change, so a client's partial download
+         * stays valid indefinitely and the digest doubles as a strong ETag.
+         *
+         * @param {string}   key   - The opaque storage key.
+         * @param {number}   start - First byte offset, inclusive; integer >= 0.
+         * @param {number}   end   - Last byte offset, INCLUSIVE; integer >= start.
+         * @param {function} fn    - `fn(err, stream)`.
+         * @returns {void}
+         *
+         * @example
+         * driver.getRange(key, 0, 1023, function (err, stream) {
+         *     if (err) { return self.throwError(416); }
+         *     stream.pipe(res);
+         * });
+         */
+        getRange: function(key, start, end, fn) {
+            if ( typeof fn !== 'function' ) {
+                throw new Error('[storage:' + name + '] getRange() requires a callback');
+            }
+            if ( !Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start ) {
+                return fn(util.codedError('STORAGE_INVALID_RANGE', '[storage:' + name + '] getRange(): invalid range [' + start + ', ' + end + '] — both bounds must be integers with 0 <= start <= end'));
+            }
+            var r = resolvePath(key);
+            if ( r.error ) { return fn(r.error); }
+            metaStore.get(key, function(metaErr, m) {
+                if (metaErr) { return fn(metaErr); }
+                if ( !m || ( typeof m.refs === 'number' && m.refs < 1 ) ) {
+                    return fn(util.codedError('STORAGE_NO_OBJECT', '[storage:' + name + '] no object for key `' + key + '`'));
+                }
+                if ( m.data != null ) {
+                    if ( start >= m.data.length ) {
+                        return fn(util.codedError('STORAGE_RANGE_UNSATISFIABLE', '[storage:' + name + '] getRange(): start ' + start + ' is beyond the object size (' + m.data.length + ') for key `' + key + '`'));
+                    }
+                    return fn(null, Readable.from([ m.data.subarray(start, Math.min(end, m.data.length - 1) + 1) ]));
+                }
+                if ( !fs.existsSync(r.path) ) {
+                    return fn(util.codedError('STORAGE_NO_OBJECT', '[storage:' + name + '] no object for key `' + key + '`'));
+                }
+                var size = fs.statSync(r.path).size;
+                if ( start >= size ) {
+                    return fn(util.codedError('STORAGE_RANGE_UNSATISFIABLE', '[storage:' + name + '] getRange(): start ' + start + ' is beyond the object size (' + size + ') for key `' + key + '`'));
+                }
+                var rs = fs.createReadStream(r.path, { start: start, end: Math.min(end, size - 1) });
+                var handed = false;
+                rs.on('error', function(err) {
+                    if (handed) return;
+                    handed = true;
+                    fn(err);
+                });
+                rs.on('open', function() {
+                    if (handed) return;
+                    handed = true;
+                    fn(null, rs);
+                });
+            });
+        },
+
         /**
          * Metadata for `key` — `null` for a missing OR fully-released key.
          *
@@ -1019,7 +1113,11 @@ module.exports = function createLocalCasDriver(name, conf, metaStore) {
          * @param {function} fn  - `fn(err, {kind: 'path', path: string} | {kind: 'inline'})`.
          * @returns {void}
          */
-        resolve: function(key, fn) {
+        resolve: function(key, opts, fn) {
+            // optional middle `opts` — offload response overrides, consumed
+            // by offload-capable adapters (`s3`); accepted and IGNORED here
+            // so one facade call site serves every driver.
+            if ( typeof opts === 'function' ) { fn = opts; }
             if ( typeof fn !== 'function' ) {
                 throw new Error('[storage:' + name + '] resolve() requires a callback');
             }
@@ -1028,13 +1126,13 @@ module.exports = function createLocalCasDriver(name, conf, metaStore) {
             metaStore.get(key, function(metaErr, m) {
                 if (metaErr) { return fn(metaErr); }
                 if ( !m || ( typeof m.refs === 'number' && m.refs < 1 ) ) {
-                    return fn(new Error('[storage:' + name + '] no object for key `' + key + '`'));
+                    return fn(util.codedError('STORAGE_NO_OBJECT', '[storage:' + name + '] no object for key `' + key + '`'));
                 }
                 if ( m.data != null ) {
                     return fn(null, { kind: 'inline' });
                 }
                 if ( !fs.existsSync(r.path) ) {
-                    return fn(new Error('[storage:' + name + '] no object for key `' + key + '`'));
+                    return fn(util.codedError('STORAGE_NO_OBJECT', '[storage:' + name + '] no object for key `' + key + '`'));
                 }
                 fn(null, { kind: 'path', path: r.path });
             });