1. module scp2
   1. function scp2.Client (options)
   2. function scp2.scp (src, dest, client, callback)
   3. object scp2.Client.prototype
   4. object scp2._options
   5. object scp2.client
   6. object scp2.remote
2. module scp2.Client
   1. function scp2.Client (options)
   2. function scp2.Client.super_ ()
3. module scp2.Client.prototype
   1. function scp2.Client.prototype.close ()
   2. function scp2.Client.prototype.defaults (options)
   3. function scp2.Client.prototype.download (src, dest, callback)
   4. function scp2.Client.prototype.mkdir (dir, attrs, callback)
   5. function scp2.Client.prototype.parse (remote)
   6. function scp2.Client.prototype.sftp (callback)
   7. function scp2.Client.prototype.upload (src, dest, callback)
   8. function scp2.Client.prototype.write (options, callback)
4. module scp2.client
   1. function scp2.client.Client (options)
   2. object scp2.client._options
   3. object scp2.client.remote
5. module scp2.scp
   1. function scp2.scp (src, dest, client, callback)
   2. function scp2.scp.Client (options)
   3. object scp2.scp._options
   4. object scp2.scp.remote

module scp2

function scp2.Client (options)

• description and source-code

  function Client(options) {
    this._options = options || {};
  
    this.remote = {};
  }

• example usage

  n/a

function scp2.scp (src, dest, client, callback)

• description and source-code

  scp = function (src, dest, client, callback) {
    if (typeof client === 'function') {
      callback = client;
      client = new Client();
    }
    client.on('error', callback);
    var parsed = client.parse(src);
    if (parsed.host && parsed.path) {
      cp2local(client, parsed, dest, callback);
    } else {
      cp2remote(client, src, dest, callback);
    }
  }

• example usage

  ...
  ```js
  var client = require('scp2')
  ```
  
  Copy a file to the server:
  
  ```js
  client.scp('file.txt', 'admin:password@example.com:/home/admin/',
  function(err) {
  })
  ```
  
  You can also add the port to the url (default is 22):
  
  ```js
  client.scp('file.txt', 'admin:password@example.com:port:/home/admin/', function(err) {
  ...

module scp2.Client

function scp2.Client (options)

• description and source-code

  function Client(options) {
    this._options = options || {};
  
    this.remote = {};
  }

• example usage

  n/a

function scp2.Client.super_ ()

• description and source-code

  function EventEmitter() {
    EventEmitter.init.call(this);
  }

• example usage

  n/a

module scp2.Client.prototype

function scp2.Client.prototype.close ()

• description and source-code

  close = function () {
    if (this.__sftp) {
      this.__sftp.end();
      this.__sftp = null;
    }
    if (this.__ssh) {
      this.__ssh.end();
      this.__ssh = null;
    }
  }

• example usage

  ...
      self.emit('transfer', buf, lastCursor, length);
      sftp.write(handle, buf, 0, buf.length, lastIndex, function(err) {
        lastIndex += buf.length;
        lastCursor += 1;
        callback(err);
      });
    }, function(err) {
      sftp.close(handle, callback);
    });
  } else if (typeof content === 'number') {
    // content is a file descriptor
    length = parseInt((attrs.size - 1) / chunkSize, 10) + 1;
    var range = new Array(length);
    async.eachSeries(range, function(pos, callback) {
      chunkSize = Math.min(chunkSize, attrs.size - lastIndex);
  ...

function scp2.Client.prototype.defaults (options)

• description and source-code

  defaults = function (options) {
    if (options) {
      this._options = options || {};
    } else {
      return this._options;
    }
  }

• example usage

  ...
  
  
  - **defaults** `function({})`
  
  set the default values for the remote server.
  
  ```js
  client.defaults({
      port: 22,
      host: 'example.com',
      username: 'admin',
      privateKey: '....',
      // password: 'password', (accepts password also)
  });
  ```
  ...

function scp2.Client.prototype.download (src, dest, callback)

• description and source-code

  download = function (src, dest, callback) {
    var self = this;
  
    self.sftp(function(err,sftp){
      if (err) {
        return callback(err);
      }
  
      var sftp_readStream = sftp.createReadStream(src);
      sftp_readStream.on('error', function(err){
        callback(err);
      });
      sftp_readStream.pipe(fs.createWriteStream(dest))
      .on('close',function(){
        self.emit('read', src);
        callback(null);
      })
      .on('error', function(err){
        callback(err);
      });
    });
  }

• example usage

  ...
  function cp2local(client, src, dest, callback) {
    var remote = client.parse(src);
    // only works on single file now
    // TODO: glob match
    if (/\/$/.test(dest)) {
      dest = dest + path.basename(remote.path);
    }
    client.download(remote.path, dest, function () {
        client.close();
        callback.apply(this, arguments);
    });
  }
  
  exports = module.exports = global_client;
  ...

function scp2.Client.prototype.mkdir (dir, attrs, callback)

• description and source-code

  mkdir = function (dir, attrs, callback) {
    if (_.isFunction(attrs)) {
      callback = attrs;
      attrs = undefined;
    }
  
    if (attrs) {
      attrs.mode = getFolderAttr(process.platform, attrs);
    }
  
    var self = this;
    var dirs = [];
    var exists = false;
  
    this.sftp(function(err, sftp) {
      if (err) {
        return callback(err);
      }
  
      // for record log
      var mkdir = function(dir, callback) {
        self.emit('mkdir', dir);
        sftp.mkdir(dir, attrs, callback);
      };
  
      async.until(function() {
        return exists;
      }, function(done) {
        // detect if the directory exists
        sftp.stat(dir, function(err, attr) {
          if (err) {
            dirs.push(dir);
            dir = path.dirname(dir);
          } else {
            exists = true;
          }
          done();
        });
      }, function(err) {
        if (err) {
          callback(err);
        } else {
          // just like mkdir -p
          async.eachSeries(dirs.reverse(), mkdir, callback);
        }
      });
  
    });
  }

• example usage

  ...
  if (err) {
    return callback(err);
  }
  
  // for record log
  var mkdir = function(dir, callback) {
    self.emit('mkdir', dir);
    sftp.mkdir(dir, attrs, callback);
  };
  
  async.until(function() {
    return exists;
  }, function(done) {
    // detect if the directory exists
    sftp.stat(dir, function(err, attr) {
  ...

function scp2.Client.prototype.parse (remote)

• description and source-code

  parse = function (remote) {
    if (_.isString(remote)) {
      // username:password@host:/path/to
      var regex = /^([a-zA-Z0-9\-\.]+)(\:.*)?@([^:]+):([^:]+:)?(.*)?$/;
      var m = remote.match(regex);
      if (!m) return {};
      var ret = {
        username: m[1],
        host: m[3],
      };
      if (m[2]) {
        ret.password = m[2].slice(1);
      }
      if (m.length===6 && m[4]) {
        ret.port = m[4].slice(0,-1);
      }
      if (m.length===6 && m[5]) {
        ret.path = m[5];
      } else if (m.length===5 && m[4]) {
        ret.path = m[4];
      }
      this.remote = ret;
      return ret;
    }
    this.remote = remote;
    return remote;
  }

• example usage

  ...
  var path = require('path');
  var glob = require('glob');
  var async = require('async');
  var Client = require('./client').Client;
  var global_client = new Client();
  
  function cp2remote(client, src, dest, callback) {
    client.parse(dest);
  
    var _upload = function(files, callback) {
  var rootdir = files[0];
  
  async.eachSeries(files, function(fpath, done) {
    fs.stat(fpath, function(err, stats) {
      if (err) {
  ...

function scp2.Client.prototype.sftp (callback)

• description and source-code

  sftp = function (callback) {
    if (this.__sftp) {
      callback(null, this.__sftp);
      return;
    }
  
    var remote = _.defaults(this.remote, this._options);
    if (this.__ssh) {
      this.__ssh.connect(remote);
      return;
    }
  
    var self = this;
    var ssh = new Connection();
    ssh.on('connect', function() {
      self.emit('connect');
    });
    ssh.on('ready', function() {
      self.emit('ready');
  
      ssh.sftp(function(err, sftp) {
        if (err) throw err;
        // save for reuse
        self.__sftp = sftp;
        callback(err, sftp);
      });
    });
    ssh.on('error', function(err) {
      self.emit('error', err);
      callback(err);
    });
    ssh.on('end', function() {
      self.emit('end');
    });
    ssh.on('close', function() {
      self.emit('close');
    });
    ssh.on('keyboard-interactive', function(name, instructions, instructionsLang, prompts, finish) {
      self.emit('keyboard-interactive', name, instructions, instructionsLang, prompts, finish);
    });
    ssh.on('change password', function(message, language, done) {
      self.emit('change password', message, language, done);
    });
    ssh.on('tcp connection', function(details, accept, reject) {
      self.emit('tcp connection', details, accept, reject);
    });
    ssh.connect(remote);
    this.__ssh = ssh;
  }

• example usage

  ...
  var ssh = new Connection();
  ssh.on('connect', function() {
    self.emit('connect');
  });
  ssh.on('ready', function() {
    self.emit('ready');
  
    ssh.sftp(function(err, sftp) {
      if (err) throw err;
      // save for reuse
      self.__sftp = sftp;
      callback(err, sftp);
    });
  });
  ssh.on('error', function(err) {
  ...

function scp2.Client.prototype.upload (src, dest, callback)

• description and source-code

  upload = function (src, dest, callback) {
    dest = unixy(dest);
  
    var self = this;
  
    async.waterfall([
      function(callback) {
        fs.stat(src, callback);
      },
      function(stat, callback) {
        if (stat.isDirectory()) return callback(new Error('Can not upload a directory'));
  
        // Get the attributes of the source directory
        fs.stat(path.dirname(src), function(err, dirStat) {
          if(err) return callback(err);
          self.mkdir(path.dirname(dest), dirStat, function(err){ callback(err, stat) });
        });
      },
      function(stat, callback) {
        fs.open(src, 'r', function(err, fd) { callback(err, stat, fd); });
      },
      function(stat, fd, callback) {
        self.write({
          source: src,
          destination: dest,
          content: fd,
          attrs: stat
        }, callback);
      }
    ], function(err) {
      callback(err);
    });
  }

• example usage

  ...
  - source: the source path, e.g. local/file.txt
  
  - **upload** `function(src, dest, callback) -> callback(err)`
  
  upload a local file to the server.
  
  ```js
  client.upload('file.txt', '/home/admin/file.txt', callback)
  ```
  
  - **download** `function(src, dest, callback) -> callback(err)`
  
  download a server file to local.
  ...

function scp2.Client.prototype.write (options, callback)

• description and source-code

  write = function (options, callback) {
    var destination = options.destination;
    destination = unixy(destination);
  
    var attrs = options.attrs;
    var content = options.content;
    var chunkSize = options.chunkSize || 32768;
  
    var self = this;
  
    this.sftp(function(err, sftp) {
      if (err) {
        return callback(err);
      }
  
      var _write = function(handle) {
        self.emit('write', options);
        var length;
        var lastIndex = 0;
        var lastCursor = 0;
  
        if (Buffer.isBuffer(content)) {
          var contents = [];
          length = parseInt((content.length - 1) / chunkSize, 10) + 1;
  
          for (var i = 0 ; i < length; i++) {
            contents.push(content.slice(i * chunkSize, (i + 1) * chunkSize));
          }
          async.eachSeries(contents, function(buf, callback) {
            self.emit('transfer', buf, lastCursor, length);
            sftp.write(handle, buf, 0, buf.length, lastIndex, function(err) {
              lastIndex += buf.length;
              lastCursor += 1;
              callback(err);
            });
          }, function(err) {
            sftp.close(handle, callback);
          });
        } else if (typeof content === 'number') {
          // content is a file descriptor
          length = parseInt((attrs.size - 1) / chunkSize, 10) + 1;
          var range = new Array(length);
          async.eachSeries(range, function(pos, callback) {
            chunkSize = Math.min(chunkSize, attrs.size - lastIndex);
            if (!chunkSize) {
              callback(err);
              return;
            }
            var buf = new Buffer(chunkSize);
            fs.read(content, buf, 0, chunkSize, lastIndex, function(err, byteRead, buf) {
              self.emit('transfer', buf, lastCursor, length);
              sftp.write(handle, buf, 0, buf.length, lastIndex, function(err) {
                lastIndex += buf.length;
                lastCursor += 1;
                callback(err);
              });
            });
          }, function(err) {
            sftp.close(handle, function(err) {
              fs.close(content, callback);
            });
          });
        } else {
          throw new Error('Content should be buffer or file descriptor');
        }
      };
  
      sftp.open(destination, 'w', attrs, function(err, handle) {
        if (err) {
          // destination is directory
          destination = path.join(
            destination, path.basename(options.source)
          );
          destination = unixy(destination);
  
          // for emit write event
          options.destination = destination;
          sftp.open(destination, 'w', attrs, function(err, handle) {
            _write(handle);
          });
        } else {
          _write(handle);
        }
      });
    });
  }

• example usage

  ...
  Make a directory on the remote server. It behaves like `mdkir -p`.
  
  - **write** `function(options, callback) -> callback(err)`
  
  Write content on the remote server.
  
  ```js
  client.write({
      destination: '/home/admin/data/file.txt',
      content: 'hello world'
  }, callback)
  ```
  
  The options can contain:
  ...

module scp2.client

function scp2.client.Client (options)

• description and source-code

  function Client(options) {
    this._options = options || {};
  
    this.remote = {};
  }

• example usage

  n/a

module scp2.scp

function scp2.scp (src, dest, client, callback)

• description and source-code

  scp = function (src, dest, client, callback) {
    if (typeof client === 'function') {
      callback = client;
      client = new Client();
    }
    client.on('error', callback);
    var parsed = client.parse(src);
    if (parsed.host && parsed.path) {
      cp2local(client, parsed, dest, callback);
    } else {
      cp2remote(client, src, dest, callback);
    }
  }

• example usage

  ...
  ```js
  var client = require('scp2')
  ```
  
  Copy a file to the server:
  
  ```js
  client.scp('file.txt', 'admin:password@example.com:/home/admin/',
  function(err) {
  })
  ```
  
  You can also add the port to the url (default is 22):
  
  ```js
  client.scp('file.txt', 'admin:password@example.com:port:/home/admin/', function(err) {
  ...

function scp2.scp.Client (options)

• description and source-code

  function Client(options) {
    this._options = options || {};
  
    this.remote = {};
  }

• example usage

  n/a