verify-transfer

#!/usr/bin/env node

if (process.argv.includes('-h') || process.argv.includes('--help')) {
  usage(0);
}

const [ server1, dir1 ] = splitLocation(process.argv[2]);
const [ server2, dir2 ] = splitLocation(process.argv[3]);

if (!dir1 || !dir2) {
  usage(1);
}

const childProcess = require('child_process');
const ProgressBar = require('progress');

main();

// Function definitions

function usage(exitCode = 0) {
  console.log(`Compare all files within two directories.
This will display the filenames of any files that do not have the same hash.

A location can be local or remote (e.g. username@example.com:~/my/remote/file ~/my/local/file)
SSH will be used for remote files

Usage: ${process.argv[1]} <location1> <location2>
`);

  process.exit(exitCode);
}

function splitLocation(location = '') {
  location = location.replace(/ /g, '\\ ');
  if (!~location.indexOf(':')) {
    return [ '', location ] ;
  }
  return location.split(/:(.+)/);
}

function spawn(server, dir, cmd) {
  let args, opts = {};
  if (server) {
    args = [ server, `cd ${dir} && ${cmd.replace(';', '\\;')}` ];
    cmd = 'ssh';
  } else {
    args = cmd.split(' ');
    cmd = args.shift();
    opts.cwd = dir;
  }

  return childProcess.spawn(cmd, args, opts);
}

function fetchNumFiles(server, dir) {
  return new Promise((resolve, reject) => {
    let child = spawn(server, dir, 'find . -type f');

    let numFiles = 0;
    child.on('error', error => reject(error));
    child.stderr.on('data', error => reject(`Cannot find directory ${server}:${dir}\n${error}`));
    child.stdout.on('data', data => {
      numFiles += `${data}`.split(/\n/).filter(line => line).length;
    });

    child.on('close', () => resolve(numFiles));
  });
}

function fetchHashes(server, dir, progress) {
  return new Promise((resolve, reject) => {
    let hashes = {};
    let child = spawn(server, dir, 'find . -type f -exec md5sum {} ;');

    child.on('error', error => reject(error));
    child.stdout.on('data', data => {
      let lines = `${data}`.split('\n');
      for (let line of lines) {
        let [ hash, filename ] = line.split(/ +(.+)/);
        if (filename) {
          progress.tick(1);
          hashes[filename.substr(2)] = hash;
        }
      }
    });

    child.on('close', () => resolve(hashes));
  });
}

function hashDiff([ left, right ]) {
  let diffs = { '<': [], '~': [], '>': [] };

  for (let filename of Object.keys(left).sort()) {
    if (left[filename] !== right[filename]) {
      diffs[right[filename] ? '~' : '<'].push(filename);
    }

    delete right[filename];
  }

  diffs['>'] = Object.keys(right).sort();

  return [ '<', '~', '>' ].reduce(
    (all, type) => all.concat(diffs[type].map(filename => `${type} ${filename}`)),
    []
  );
}

function forBoth(fn, ...extraArgs) {
  return Promise.all([
    fn(server1, dir1, ...extraArgs),
    fn(server2, dir2, ...extraArgs),
  ]);
}

function main() {
  console.log('Scanning for files...');
  forBoth(fetchNumFiles)
  .then(numFiles => {
    return new ProgressBar('Calculating hashes (:bar) :percent :etas', {
      complete: '.',
      incomplete: ' ',
      width: 20,
      total: numFiles.reduce((sum, num) => sum + num, 0)
    });
  })
  .then(progress => forBoth(fetchHashes, progress))
  .then(hashDiff)
  .then(differences => {
    console.log(); // Ensure progress bar has a newline
    if (differences.length) {
      console.log(`Found ${differences.length} differences:`);
      for (let difference of differences) {
        console.log(difference);
      }
      process.exit(1);
    } else {
      console.log('Found no differences!');
      process.exit(0);
    }
  })
  .catch(error => {
    console.log(error.stack || error);
    process.exit(1);
  });
}