@cloudant/couchbackup 2.9.15-SNAPSHOT.176 → 2.9.15

package/.scannerwork/scanner-report/source-65.txt

@@ -1,4 +1,4 @@
-// Copyright © 2017, 2023 IBM Corp. All rights reserved.
+// Copyright © 2017, 2022 IBM Corp. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,283 +11,101 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-
-/* global describe it before after beforeEach */
 'use strict';
 
-const assert = require('assert');
 const fs = require('fs');
-const u = require('./citestutils.js');
-const mockServerPort = +process.env.COUCHBACKUP_MOCK_SERVER_PORT || 7777;
-const { once } = require('node:events');
-const url = `http://localhost:${mockServerPort}`;
-const nock = require('nock');
-const httpProxy = require('http-proxy');
-const Readable = require('stream').Readable;
-
-// Create an infinite stream to read.
-// It just keeps sending a backup line, useful for testing cases of
-// termination while a stream has content remaining (the animaldb backup
-// is too small for that).
-class InfiniteBackupStream extends Readable {
-  constructor(opt) {
-    super(opt);
-    this.contents = Buffer.from('[{"_id":"giraffe","_rev":"3-7665c3e66315ff40616cceef62886bd8","min_weight":830,"min_length":5,"max_weight":1600,"max_length":6,"wiki_page":"http://en.wikipedia.org/wiki/Giraffe","class":"mammal","diet":"herbivore","_revisions":{"start":3,"ids":["7665c3e66315ff40616cceef62886bd8","aaaf10d5a68cdf22d95a5482a0e95549","967a00dff5e02add41819138abb3284d"]}}]\n', 'utf8');
-  }
-
-  _read() {
-    let proceed;
-    do {
-      proceed = this.push(this.contents);
-    } while (proceed);
-  }
-}
-
-function assertNock() {
-  try {
-    assert.ok(nock.isDone());
-  } catch (err) {
-    console.error('pending mocks: %j', nock.pendingMocks());
-    throw err;
-  }
-}
-
-function testPromiseWithAssertNock(testPromise) {
-  return testPromise.finally(() => {
-    assertNock();
-  });
-}
-
-async function backupHttpError(opts, errorName, errorCode) {
-  const p = u.p(opts, { expectedBackupError: { name: errorName, code: errorCode } });
-
-  // Create a file and attempt a backup to it
-  const output = fs.createWriteStream('/dev/null');
-  return once(output, 'open')
-    .then(() => {
-      return testPromiseWithAssertNock(u.testBackup(p, 'fakenockdb', output));
-    });
-}
-
-async function restoreHttpError(opts, errorName, errorCode) {
-  const q = u.p(opts, { expectedRestoreError: { name: errorName, code: errorCode } });
-  return testPromiseWithAssertNock(u.testRestoreFromFile(q, './test/fixtures/animaldb_expected.json', 'fakenockdb'));
-}
-
-[{ useApi: true }, { useApi: false }].forEach(function(params) {
-  describe(u.scenario('#unit Fatal errors', params), function() {
-    // These tests do real requests with mocks and if they run slowly
-    // the 2 second default mocha timeout can be insufficient, use 10 s
-    this.timeout(10000);
-
-    let processEnvCopy;
-    let proxy;
-
-    before('Set process data for test', function() {
-      const proxyPort = mockServerPort + 1000;
-      // Copy env and argv so we can reset them after the tests
-      processEnvCopy = JSON.parse(JSON.stringify(process.env));
-
-      // Set up a proxy to point to our nock server because the nock override
-      // isn't visible to the spawned CLI process
-      if (!params.useApi) {
-        proxy = httpProxy.createProxyServer({ target: url }).listen(proxyPort, 'localhost');
-        proxy.on('error', (err, req, res) => {
-          console.log(`Proxy received error ${err}`);
-          res.writeHead(400, {
-            'Content-Type': 'application/json'
-          });
-          res.end(JSON.stringify(err));
-        });
-      }
-
-      // setup environment variables
-      process.env.COUCH_URL = (params.useApi) ? url : `http://localhost:${proxyPort}`;
-
-      nock.emitter.on('no match', (req, opts) => {
-        console.error(`Unmatched nock request ${opts.method} ${opts.protocol}${opts.host}${opts.path}`);
-      });
-    });
-
-    after('Reset process data', function(done) {
-      process.env = processEnvCopy;
-      nock.emitter.removeAllListeners();
-      if (!params.useApi) {
-        proxy.close(done);
-      } else {
-        done();
+const liner = require('./liner.js');
+const change = require('./change.js');
+const error = require('./error.js');
+const debug = require('debug')('couchbackup:spoolchanges');
+
+/**
+ * Write log file for all changes from a database, ready for downloading
+ * in batches.
+ *
+ * @param {string} dbUrl - URL of database
+ * @param {string} log - path to log file to use
+ * @param {number} bufferSize - the number of changes per batch/log line
+ * @param {function(err)} callback - a callback to run on completion
+ */
+module.exports = function(db, log, bufferSize, ee, callback) {
+  // list of document ids to process
+  const buffer = [];
+  let batch = 0;
+  let lastSeq = null;
+  const logStream = fs.createWriteStream(log);
+  let pending = 0;
+  // The number of changes to fetch per request
+  const limit = 100000;
+
+  // send documents ids to the queue in batches of bufferSize + the last batch
+  const processBuffer = function(lastOne) {
+    if (buffer.length >= bufferSize || (lastOne && buffer.length > 0)) {
+      debug('writing', buffer.length, 'changes to the backup file');
+      const b = { docs: buffer.splice(0, bufferSize), batch: batch };
+      logStream.write(':t batch' + batch + ' ' + JSON.stringify(b.docs) + '\n');
+      ee.emit('changes', batch);
+      batch++;
+    }
+  };
+
+  // called once per received change
+  const onChange = function(c) {
+    if (c) {
+      if (c.error) {
+        ee.emit('error', new error.BackupError('InvalidChange', `Received invalid change: ${c}`));
+      } else if (c.changes) {
+        const obj = { id: c.id };
+        buffer.push(obj);
+        processBuffer(false);
+      } else if (c.last_seq) {
+        lastSeq = c.last_seq;
+        pending = c.pending;
       }
-    });
-
-    beforeEach('Reset nocks', function() {
-      nock.cleanAll();
-    });
-
-    describe('for backup', function() {
-      it('should terminate when DB does not exist', function() {
-        // Simulate existence check
-        nock(url).head('/fakenockdb').reply(404, { error: 'not_found', reason: 'missing' });
-        return backupHttpError(params, 'DatabaseNotFound', 10);
-      });
-
-      it('should terminate on BulkGetError', function() {
-        // Simulate existence check
-        const n = nock(url).head('/fakenockdb').reply(200);
-        // Simulate _bulk_get not available
-        n.post('/fakenockdb/_bulk_get').reply(404, { error: 'not_found', reason: 'missing' });
-        return backupHttpError(params, 'BulkGetError', 50);
-      });
-
-      it('should terminate on Unauthorized existence check', function() {
-        // Simulate a 401
-        nock(url).head('/fakenockdb').reply(401, { error: 'unauthorized', reason: '_reader access is required for this request' });
-        return backupHttpError(params, 'Unauthorized', 11);
-      });
-
-      it('should terminate on Forbidden no _reader', function() {
-        // Simulate a 403
-        nock(url).head('/fakenockdb').reply(403, { error: 'forbidden', reason: '_reader access is required for this request' });
-        return backupHttpError(params, 'Forbidden', 12);
-      });
-
-      it('should terminate on _bulk_get HTTPFatalError', function() {
-        // Provide a mock complete changes log to allow a resume to skip ahead
-        const p = u.p(params, { opts: { resume: true, log: './test/fixtures/test.log' } });
-        // Allow the existence and _bulk_get checks to pass
-        const n = nock(url).head('/fakenockdb').reply(200);
-        n.post('/fakenockdb/_bulk_get').reply(200, '{"results": []}');
-        // Simulate a fatal HTTP error when trying to fetch docs
-        // Note: 2 outstanding batches, so 2 responses, 1 mock is optional because we can't guarantee timing
-        n.post('/fakenockdb/_bulk_get').query(true).reply(400, { error: 'bad_request', reason: 'testing bad response' });
-        n.post('/fakenockdb/_bulk_get').query(true).optionally().reply(400, { error: 'bad_request', reason: 'testing bad response' });
-        return backupHttpError(p, 'HTTPFatalError', 40);
-      });
-
-      it('should terminate on NoLogFileName', function() {
-        // Don't supply a log file name with resume
-        const p = u.p(params, { opts: { resume: true } });
-        return backupHttpError(p, 'NoLogFileName', 20);
-      });
-
-      it('should terminate on LogDoesNotExist', function() {
-        // Use a non-existent log file
-        const p = u.p(params, { opts: { resume: true, log: './test/fixtures/doesnotexist.log' } });
-        return backupHttpError(p, 'LogDoesNotExist', 21);
-      });
-
-      it('should terminate on IncompleteChangesInLogFile', function() {
-        // Use an incomplete changes log file
-        const p = u.p(params, { opts: { resume: true, log: './test/fixtures/incomplete_changes.log' } });
-        // Allow the existence and _bulk_get checks to pass
-        const n = nock(url).head('/fakenockdb').reply(200);
-        n.post('/fakenockdb/_bulk_get').reply(200, '{"results": []}');
-        // Should fail when it reads the incomplete changes
-        return backupHttpError(p, 'IncompleteChangesInLogFile', 22);
-      });
-
-      it('should terminate on _changes HTTPFatalError', function() {
-        // Allow the existence and _bulk_get checks to pass
-        const n = nock(url).head('/fakenockdb').reply(200);
-        n.post('/fakenockdb/_bulk_get').reply(200, '{"results": []}');
-        // Simulate a fatal HTTP error when trying to fetch docs (note 2 outstanding batches)
-        n.post('/fakenockdb/_changes').query(true).reply(400, { error: 'bad_request', reason: 'testing bad response' });
-        return backupHttpError(params, 'HTTPFatalError', 40);
-      });
-
-      it('should terminate on SpoolChangesError', function() {
-        // Allow the existence and _bulk_get checks to pass
-        const n = nock(url).head('/fakenockdb').reply(200);
-        n.post('/fakenockdb/_bulk_get').reply(200, '{"results": []}');
-        // Simulate a changes without a last_seq
-        n.post('/fakenockdb/_changes').query(true).reply(200,
-          {
-            results: [{
-              seq: '2-g1AAAAEbeJzLYWBgYMlgTmFQSElKzi9KdUhJstTLTS3KLElMT9VLzskvTUnMK9HLSy3JAapkSmRIsv___39WBnMiUy5QgN3MzDIxOdEMWb85dv0gSxThigyN8diS5AAkk-pBFiUyoOkzxKMvjwVIMjQAKaDW_Zh6TQnqPQDRC7I3CwDPDV1k',
-              id: 'badger',
-              changes: [{ rev: '4-51aa94e4b0ef37271082033bba52b850' }]
-            }]
+    }
+  };
+
+  function getChanges(since = 0) {
+    debug('making changes request since ' + since);
+    return db.service.postChangesAsStream({ db: db.db, since: since, limit: limit, seqInterval: limit })
+      .then(response => {
+        response.result.pipe(liner())
+          .on('error', function(err) {
+            logStream.end();
+            callback(err);
+          })
+          .pipe(change(onChange))
+          .on('error', function(err) {
+            logStream.end();
+            callback(err);
+          })
+          .on('finish', function() {
+            processBuffer(true);
+            if (!lastSeq) {
+              logStream.end();
+              debug('changes request terminated before last_seq was sent');
+              callback(new error.BackupError('SpoolChangesError', 'Changes request terminated before last_seq was sent'));
+            } else {
+              debug(`changes request completed with last_seq: ${lastSeq} and ${pending} changes pending.`);
+              if (pending > 0) {
+                // Return the next promise
+                return getChanges(lastSeq);
+              } else {
+                debug('finished streaming database changes');
+                logStream.end(':changes_complete ' + lastSeq + '\n', 'utf8', callback);
+              }
+            }
           });
-        return backupHttpError(params, 'SpoolChangesError', 30);
-      });
-    });
-
-    describe('for restore', function() {
-      it('should terminate on Unauthorized db existence check', function() {
-        // Simulate a 401
-        nock(url).get('/fakenockdb').reply(401, { error: 'unauthorized', reason: '_reader access is required for this request' });
-        return restoreHttpError(params, 'Unauthorized', 11);
-      });
-
-      it('should terminate on Forbidden no _writer', function() {
-        // Simulate the DB exists (i.e. you can read it)
-        const n = nock(url).get('/fakenockdb').reply(200, { doc_count: 0, doc_del_count: 0 });
-        // Simulate a 403 trying to write
-        n.post('/fakenockdb/_bulk_docs').reply(403, { error: 'forbidden', reason: '_writer access is required for this request' });
-        return restoreHttpError(params, 'Forbidden', 12);
-      });
-
-      it('should terminate on RestoreDatabaseNotFound', function() {
-        // Simulate the DB does not exist
-        nock(url).get('/fakenockdb').reply(404, { error: 'not_found', reason: 'Database does not exist.' });
-        return restoreHttpError(params, 'DatabaseNotFound', 10);
-      });
-
-      it('should terminate on notEmptyDBErr when database is not empty', function() {
-        // Simulate the DB that does exist and not empty
-        nock(url).get('/fakenockdb').reply(200, { doc_count: 10, doc_del_count: 0 });
-        return restoreHttpError(params, 'DatabaseNotEmpty', 13);
-      });
-
-      it('should terminate on notEmptyDBErr when database is not new', function() {
-        // Simulate the DB that does exist and not new
-        nock(url).get('/fakenockdb').reply(200, { doc_count: 0, doc_del_count: 10 });
-        return restoreHttpError(params, 'DatabaseNotEmpty', 13);
-      });
-
-      it('should terminate on _bulk_docs HTTPFatalError', function() {
-        // Simulate the DB exists
-        const n = nock(url).get('/fakenockdb').reply(200, { doc_count: 0, doc_del_count: 0 });
-        // Use a parallelism of one and mock one response
-        const p = u.p(params, { opts: { parallelism: 1 } });
-        // Simulate a 400 trying to write
-        n.post('/fakenockdb/_bulk_docs').reply(400, { error: 'bad_request', reason: 'testing bad response' });
-        return restoreHttpError(p, 'HTTPFatalError', 40);
-      });
-
-      it('should terminate on _bulk_docs HTTPFatalError from system database', function() {
-        // Simulate that target database exists and is _not_ empty.
-        // This should pass validator as we exclude system databases from the check.
-        const n = nock(url).get('/_replicator').reply(200, { doc_count: 1, doc_del_count: 0 });
-        // Simulate a 400 trying to write
-        n.post('/_replicator/_bulk_docs').reply(400, { error: 'bad_request', reason: 'testing bad response' });
-        // Use a parallelism of one and mock one response
-        const q = u.p(params, { opts: { parallelism: 1 }, expectedRestoreError: { name: 'HTTPFatalError', code: 40 } });
-        return testPromiseWithAssertNock(u.testRestore(q, new InfiniteBackupStream(), '_replicator'));
-      });
-
-      it('should terminate on _bulk_docs HTTPFatalError large stream', function() {
-        // Simulate the DB exists
-        const n = nock(url).get('/fakenockdb').reply(200, { doc_count: 0, doc_del_count: 0 });
-        // Simulate a 400 trying to write
-        // Provide a body function to handle the stream, but allow any body
-        n.post('/fakenockdb/_bulk_docs', function(body) { return true; }).reply(400, { error: 'bad_request', reason: 'testing bad response' });
-        // Use only parallelism 1 so we don't have to mock up loads of responses
-        const q = u.p(params, { opts: { parallelism: 1 }, expectedRestoreError: { name: 'HTTPFatalError', code: 40 } });
-        return testPromiseWithAssertNock(u.testRestore(q, new InfiniteBackupStream(), 'fakenockdb'));
+      })
+      .catch(err => {
+        logStream.end();
+        if (err.status && err.status >= 400) {
+          callback(error.convertResponseError(err));
+        } else if (err.name !== 'SpoolChangesError') {
+          callback(new error.BackupError('SpoolChangesError', `Failed changes request - ${err.message}`));
+        }
       });
+  }
 
-      it('should terminate on multiple _bulk_docs HTTPFatalError', function() {
-        // Simulate the DB exists
-        const n = nock(url).get('/fakenockdb').reply(200, { doc_count: 0, doc_del_count: 0 });
-        // Simulate a 400 trying to write docs, 5 times because of default parallelism
-        // Provide a body function to handle the stream, but allow any body
-        // Four of the mocks are optional because of parallelism 5 we can't guarantee that the exit will happen
-        // after all 5 requests, but we must get at least one of them
-        n.post('/fakenockdb/_bulk_docs', function(body) { return true; }).reply(400, { error: 'bad_request', reason: 'testing bad response' });
-        n.post('/fakenockdb/_bulk_docs', function(body) { return true; }).times(4).optionally().reply(400, { error: 'bad_request', reason: 'testing bad response' });
-        const q = u.p(params, { opts: { bufferSize: 1 }, expectedRestoreError: { name: 'HTTPFatalError', code: 40 } });
-        return restoreHttpError(q, 'HTTPFatalError', 40);
-      });
-    });
-  });
-});
+  getChanges();
+};

package/.scannerwork/scanner-report/{source-15.txt → source-66.txt}

@@ -17,8 +17,9 @@ const fs = require('fs');
 const stream = require('stream');
 const liner = require('./liner.js');
 
-const onLine = function(onCommand, batches) {
+const onLine = function(onCommand, getDocs) {
   const change = new stream.Transform({ objectMode: true });
+
   change._transform = function(line, encoding, done) {
     if (line && line[0] === ':') {
       const obj = {
@@ -41,35 +42,51 @@ const onLine = function(onCommand, batches) {
         obj.batch = parseInt(matches[1]);
       }
 
-      // if this is one we want
-      if (obj.command === 't' && batches.indexOf(obj.batch) > -1) {
+      // extract doc ids
+      if (getDocs && obj.command === 't') {
         const json = line.replace(/^.* batch[0-9]+ /, '').trim();
         obj.docs = JSON.parse(json);
-        onCommand(obj);
       }
+      onCommand(obj);
     }
     done();
   };
   return change;
 };
 
-module.exports = function(log, batches, callback) {
+/**
+ * Generate a list of remaining batches from a download file.
+ *
+ * @param {string} log - log file name
+ * @param {function} callback - callback with err, {changesComplete: N, batches: N}.
+ *  changesComplete signifies whether the log file appeared to
+ *  have completed reading the changes feed (contains :changes_complete).
+ *  batches are remaining batch IDs for download.
+ */
+module.exports = function(log, callback) {
   // our sense of state
-  const retval = { };
+  const state = {
+
+  };
+  let changesComplete = false;
 
   // called with each line from the log file
   const onCommand = function(obj) {
-    retval[obj.batch] = obj;
+    if (obj.command === 't') {
+      state[obj.batch] = true;
+    } else if (obj.command === 'd') {
+      delete state[obj.batch];
+    } else if (obj.command === 'changes_complete') {
+      changesComplete = true;
+    }
   };
 
   // stream through the previous log file
   fs.createReadStream(log)
     .pipe(liner())
-    .pipe(onLine(onCommand, batches))
-    .on('error', function(err) {
-      callback(err);
-    })
+    .pipe(onLine(onCommand, false))
     .on('finish', function() {
-      callback(null, retval);
+      const obj = { changesComplete: changesComplete, batches: state };
+      callback(null, obj);
     });
 };