sicksync/dist/local/index.js

Don’t accept the available as the preferable. Go extra mile with extra speed.

'use strict';

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

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _os = require('os');

var _os2 = _interopRequireDefault(_os);

var _untildify = require('untildify');

var _untildify2 = _interopRequireDefault(_untildify);

var _parseGitignore = require('parse-gitignore');

var _parseGitignore2 = _interopRequireDefault(_parseGitignore);

var _fsHelper = require('./fs-helper');

var _wsClient = require('./ws-client');

var _constants = require('../../conf/constants');

var _constants2 = _interopRequireDefault(_constants);

var _text = require('../../conf/text');

var _text2 = _interopRequireDefault(_text);

var _events = require('../../conf/events');

var _events2 = _interopRequireDefault(_events);

var _bigSync = require('../big-sync');

var _util = require('../util');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const hostname = _os2.default.hostname(); /**
                                           *  Client
                                           *
                                           *  Entry point into the client portion of sicksync
                                           */

const wsEvents = _events2.default.WS.LOCAL;
const fsEvents = _events2.default.FS.LOCAL;

function triggerBigSync(project, params, cb) {
  (0, _bigSync.bigSync)({
    project: project.project,
    excludes: project.excludes,
    sourceLocation: (0, _util.ensureTrailingSlash)(project.sourceLocation),
    destinationLocation: (0, _util.ensureTrailingSlash)(project.destinationLocation),
    hostname: project.hostname,
    username: project.username
  }, params, cb);
}

function start(config, projects) {
  const foundProjects = (0, _util.getProjectsFromConfig)(config, projects);

  if (_lodash2.default.isEmpty(foundProjects)) {
    return logProjectsNotFound(foundProjects);
  }

  _lodash2.default.each(foundProjects, project => {
    startProject(config, project);
  });
}

function startProject(config, projectConf) {
  const FSHelper = (0, _util.uniqInstance)(_constants2.default.FS_TOKEN, _fsHelper.FSHelper);
  const WebSocketClient = (0, _util.uniqInstance)(_constants2.default.WS_TOKEN, _wsClient.WSClient);

  const localLog = (0, _util.generateLog)(projectConf.project, hostname);
  const remoteLog = (0, _util.generateLog)(projectConf.project, projectConf.hostname);
  const sourceLocation = (0, _util.ensureTrailingSlash)(projectConf.sourceLocation);
  const destinationLocation = (0, _util.ensureTrailingSlash)(projectConf.destinationLocation);
  const secret = (0, _util.getId)();

  const fsHelper = new FSHelper({
    sourceLocation: sourceLocation,
    followSymlinks: projectConf.followSymlinks,
    excludes: _lodash2.default.concat(projectConf.excludes, _lodash2.default.chain(projectConf.excludesFile).map(_untildify2.default).map(_parseGitignore2.default).flatten().value())
  });

  const wsClient = new WebSocketClient({
    username: projectConf.username,
    hostname: projectConf.hostname,
    websocketPort: projectConf.websocketPort,
    secret: secret,
    prefersEncrypted: projectConf.prefersEncrypted
  });

  // WS events
  wsClient.on(wsEvents.READY, () => {
    triggerBigSync(projectConf, { debug: config.debug }, () => {
      fsHelper.watch();

      localLog(_text2.default.SYNC_ON_CONNECT, projectConf.hostname, projectConf.prefersEncrypted ? 'using' : 'not using', 'encryption');
    });
  });

  wsClient.on(wsEvents.RECONNECTING, _lodash2.default.partial(_lodash2.default.ary(localLog, 1), _text2.default.SYNC_ON_RECONNECT));

  wsClient.on(wsEvents.DISCONNECTED, () => {
    localLog(_text2.default.SYNC_ON_DISCONNECT);
    process.exit();
  });

  wsClient.on(wsEvents.REMOTE_NOT_FOUND, err => {
    localLog(_text2.default.SYNC_ON_REMOTE_NOT_FOUND, projectConf.hostname, err);
    process.exit();
  });

  wsClient.on(wsEvents.REMOTE_MESSAGE, message => {
    // Since WS can be shared amongst projects, filter out
    // any that are not in this project
    if (_lodash2.default.includes(message, destinationLocation)) {
      remoteLog(message);
    }
  });

  // FS events
  fsHelper.on(fsEvents.CHANGE, fileChange => {
    fileChange.destinationpath = destinationLocation + fileChange.sourcepath;
    fileChange.subject = 'file';

    localLog('>', fileChange.changeType, fileChange.sourcepath);

    wsClient.send(fileChange);
  });

  fsHelper.on(fsEvents.LARGE, () => {
    localLog(_text2.default.SYNC_ON_LARGE_CHANGE);
    fsHelper.pauseWatch();

    triggerBigSync(projectConf, { debug: config.debug }, () => {
      localLog(_text2.default.SYNC_ON_LARGE_CHANGE_DONE);
      fsHelper.watch();
    });
  });
}

function once(config, projects, opts) {
  const foundProjects = (0, _util.getProjectsFromConfig)(config, projects);

  if (_lodash2.default.isEmpty(foundProjects)) {
    return logProjectsNotFound(foundProjects);
  }

  _lodash2.default.each(foundProjects, project => {
    const localLog = (0, _util.generateLog)(project.project, hostname);

    localLog(_text2.default.SYNC_ON_ONCE);

    triggerBigSync(project, {
      dry: opts.dryRun,
      debug: config.debug
    }, _lodash2.default.partial(localLog, _text2.default.SYNC_ON_ONCE_DONE));
  });
}

function logProjectsNotFound(projects) {
  const projectsWanted = projects.length ? projects : process.cwd();

  console.info(_text2.default.PROJECT_NOT_FOUND, projectsWanted);
}