TypeScript ftp.on函数代码示例

  public testConnection(host: string, port: number, username: string, password: string): void {
    var client = new ftp();
    client.on('ready', () => {
      client.list((err, list) => {
        if (err) console.error(err);

        console.dir(list);
        client.end();

        alert("Connection Successful");
      });
    });

    client.on('error', (err) => {
      console.error(err);
    });

    client.connect({
      host: host,
      port: port,
      user: username,
      password: password,
      secure: true,
      secureOptions: { rejectUnauthorized: false }
    });
  }

    return new Promise((resolve) => {
        const ftp = new FtpClient();

        ftp.on("error", (err) => {
            ftp.end();
            console.log(err);
            resolve(localStat);
        });

        ftp.on("ready", () => {
            ftp.list(jdfPath, (err, list) => {
                if (err) {
                    ftp.end();
                    console.log(err);
                    resolve(localStat);
                } else {
                    const index = indexOfJdf(list);
                    if (index >= 0) {
                        const remoteStat = list[indexOfJdf(list)];
                        if (localStat
                            && (localStat.size === parseInt(remoteStat.size)
                                && localStat.mtime.getTime() == remoteStat.date.getTime())) {
                            ftp.end();
                            resolve(localStat);
                        } else {
                            ftp.get(remoteJdfPath, (err, stream) => {
                                if (err) {
                                    ftp.end();
                                    console.log(err);
                                    resolve(localStat);
                                } else {
                                    stream.once("close", () => {
                                        ftp.end();
                                    });
                                    stream.pipe(fs.createWriteStream(localJdfPath).once("close", () => {
                                        fs.utimesSync(localJdfPath, new Date, remoteStat.date);
                                        resolve(getFileStat(localJdfPath));
                                    }));
                                }
                            });
                        }
                    } else {
                        ftp.end();
                        resolve(localStat);
                    }
                }
            });
        });

        ftp.connect({
            // secure: true,
            // secureOptions: {
            //     rejectUnauthorized: false
            // },
            // user: "",
            // password: "",
            host: cisjr
        });
    });

 /**
  * @hidden and @ignore
  */
 public _createReadableStream(option: FtpReadOption): Readable {
     const connector = new Connector();
     if (option.path === undefined) {
       const reader = new Readable();
       process.nextTick(() => {
         reader.emit("error", new Error(SourceError[421]), option);
         reader.destroy();
       });
       return reader;
     } else {
       const client = new Client();
       client.on("ready", () => {
         client.get(option.path as string, (e, stream) => {
           if (e) {
             connector.emit("error", e, option);
             connector.destroy();
           } else {
             stream.pipe(connector);
             stream.on("close", () => {
                   client.end();
                   // self.emit('end', self);
             });
           }
         });
       });
       // connect to localhost:21 as anonymous
       // client.on("error", (error) => {
       //   err = error;
       // });
       client.connect(option);
     }
     return connector as Readable;
 }

  writeFile (options: any, file: any) {

    options.user = options.username ? options.username : options.user;
    const ftp = new nodeFTP(),
          deferred = this.deferred(),
          limit = 20;
    options.attempts = 0;

    ftp.on('ready', () => {
      const writeStream = new Writable(file.path);
      const readStream = new Readable();
      readStream.push(file.content);
      readStream.push(null);

      ftp.put(readStream, file.path, (err) => {
        if (err) {
          deferred.reject(err);
        }
        ftp.end();
        deferred.resolve({});
      });
    }).on('error', (err) => {
      if (options.attempts > limit) {
        deferred.reject(err);
      }
      options.attempts++;
      ftp.connect(options);
    });

    ftp.connect(options);
    return deferred.promise;
  }

  readFile(options: any, file: any) {

    options.user = options.username ? options.username : options.user;
    const deferred = this.deferred();
    const ftp = new nodeFTP();

    ftp.on('ready', () => {
      ftp.get(file.path, (err, stream) => {
        if (err) {
          deferred.reject(err);
        }

        let content = "";
        stream.on('data', (chunk) => {
          content += chunk;
        }).on('end', () => {
          ftp.end();
          deferred.resolve(content);
        }).on('error', (err) => {
          ftp.end();
          deferred.reject(err);
        });
      })
    });
    ftp.connect(options);
    return deferred.promise;

  }

  moveFile (options: any, fromPath: string, toPath: string) {

    options.user = options.username ? options.username : options.user;
    const ftp = new nodeFTP(),
          deferred = this.deferred(),
          limit = 20;
    options.attempts = 0;

    ftp.on('ready', () => {

      ftp.rename(fromPath, toPath, (err, data) => {
        if (err) {
          deferred.reject(err);
        }
        ftp.end();
        deferred.resolve({});
      });
    }).on('error', (err) => {
      if (options.attempts > limit) {
        deferred.reject(err);
      }
      options.attempts++;
      ftp.connect(options);
    });

    ftp.connect(options);
    return deferred.promise;
  }

  public upload(rootPath: string, files: CommitFile[], ftpConfig: FtpConfig, logger: EventEmitter<string>) {
    rootPath = rootPath.replace(/\\/gi, "/") + "/";
    var ftpRootFolder = ftpConfig.IsStaging ? StagingFolder : ProductionFolder;
    var client = new ftp();

    logger.emit('Repo Selected: ' + rootPath);
    logger.emit('Files Queued: ' + files.length);

    client.on('ready', () => {
      logger.emit('Connected to FTP Server');

      files.forEach((commitFile) => {
        if(commitFile.Status === 'A' || commitFile.Status === 'M') {
          logger.emit('Uploading: ' + rootPath + commitFile.FileName);
          logger.emit('To: ' + ftpRootFolder + commitFile.FileName);

          client.put(rootPath + commitFile.FileName, ftpRootFolder + commitFile.FileName, (err) => {
            if(err) {
              logger.emit('ERROR: ' + err);
            } else {
              logger.emit('Upload successful: ' + commitFile.FileName);
            }
          });
        }
      });

      client.end();
    });

    client.on('error', (err) => {
      logger.emit('ERROR: ' + err);
    });

    client.connect({
      host: ftpConfig.Host,
      port: ftpConfig.Port,
      user: ftpConfig.Username,
      password: ftpConfig.Password,
      secure: true,
      secureOptions: { rejectUnauthorized: false }
    });
  }

  readDir(options: any, path: string) {

    options.user = options.username ? options.username : options.user;
    const deferred = this.deferred();
    const me = this,
          ftp = new nodeFTP();
    ftp.on('ready', () => {
      ftp.list(path, (err, list) => {
        if (err) {
          // throw err;
          deferred.reject(err);
        }
        deferred.resolve(list);      
      });
    });


    ftp.on('error', (err) => {
      deferred.reject(err);
    });

    ftp.connect(options);
    return deferred.promise;
  }

        }
    });
}

c.on('ready', function () {
    tl.debug('connected to ftp host:' + serverEndpointUrl.host);

    if (clean) {
        tl.debug('cleaning remote: ' + remotePath);
        remoteExists(remotePath, function(exists){
            if(exists){
                c.rmdir(remotePath, true, function (err) {
                    if (err) {
                        c.destroy();
                        failTask('Unable to clean remote folder: ' + remotePath + ' error: ' + err);
                    }
                    uploadFiles();
                });
            } else {
                uploadFiles();
            }
        });
    } else {
        tl.debug('skipping clean: ' + remotePath);
        uploadFiles();
    }
});

var secure = serverEndpointUrl.protocol.toLowerCase() == 'ftps:' ? true : false;
tl.debug('secure ftp=' + secure);

function doWork() {
    tl.setResourcePath(path.join( __dirname, 'task.json'));

    let ftpOptions: FtpOptions = getFtpOptions();
    if (!ftpOptions.serverEndpointUrl.protocol) {
        tl.setResult(tl.TaskResult.Failed, tl.loc('FTPNoProtocolSpecified'));
    }
    if (!ftpOptions.serverEndpointUrl.hostname) {
        tl.setResult(tl.TaskResult.Failed, tl.loc('FTPNoHostSpecified'));
    }

    let ftpClient: any = new Client();
    let ftpHelper: ftputils.FtpHelper = new ftputils.FtpHelper(ftpOptions, ftpClient);

    let files: string[] = ftputils.findFiles(ftpOptions);
    tl.debug('number of files to upload: ' + files.length);
    tl.debug('files to upload: ' + JSON.stringify(files));

    let uploadSuccessful: boolean = false;

    ftpClient.on('greeting', (message: string) => {
        tl.debug('ftp client greeting');
        console.log(tl.loc('FTPConnected', message));
    });

    ftpClient.on('ready', async () => {
        tl.debug('ftp client ready');
        try {
            if (ftpOptions.clean) {
                console.log(tl.loc('CleanRemoteDir', ftpOptions.remotePath));
                await ftpHelper.cleanRemote(ftpOptions.remotePath);
            } else if (ftpOptions.cleanContents) {
                console.log(tl.loc('CleanRemoteDirContents', ftpOptions.remotePath));
                await ftpHelper.cleanRemoteContents(ftpOptions.remotePath);
            }

            console.log(tl.loc('UploadRemoteDir', ftpOptions.remotePath));
            await ftpHelper.uploadFiles(files);
            uploadSuccessful = true;
            console.log(tl.loc('UploadSucceedMsg', ftpHelper.progressTracking.getSuccessStatusMessage()));

            tl.setResult(tl.TaskResult.Succeeded, tl.loc('UploadSucceedRes'));
        } catch (err) {
            failTask(err);
        } finally {
            console.log(tl.loc('DisconnectHost', ftpOptions.serverEndpointUrl.host));
            ftpClient.end();
            ftpClient.destroy();
        }
    });

    ftpClient.on('close', (hadErr: boolean) => {
        console.log(tl.loc('Disconnected'));
        tl.debug('ftp client close, hadErr:' + hadErr);
    });

    ftpClient.on('end', () => {
        tl.debug('ftp client end');
    })

    ftpClient.on('error', (err) => {
        tl.debug('ftp client error, err: ' + err);
        if (!uploadSuccessful) {
            // once all files are successfully uploaded, a subsequent error should not fail the task
            failTask(err);
        }
    })

    let verboseSnippet: string[] = [];
    let debugLogger:any = function(message) {
        verboseSnippet.push(message);
        if (verboseSnippet.length >= 5) {
            verboseSnippet.shift();
        }
        tl.debug(message);
    };
    function failTask(message: string): void {
        let fullMessage: string = `FTP upload failed: "${message}". FTP log: "${verboseSnippet}".`;
        if (ftpHelper.progressTracking) {
            fullMessage += ftpHelper.progressTracking.getFailureStatusMessage();
        }
        console.log(fullMessage);
        tl.setResult(tl.TaskResult.Failed, message);
    }

    let secure: boolean = ftpOptions.serverEndpointUrl.protocol.toLowerCase() == 'ftps:' ? true : false;
    tl.debug('secure ftp=' + secure);

    let secureOptions: any = { 'rejectUnauthorized': !ftpOptions.trustSSL };

    let hostName: string = ftpOptions.serverEndpointUrl.hostname;
    let port: string = ftpOptions.serverEndpointUrl.port;
    if (!port) { // port not explicitly specifed, use default
        port = '21';
        tl.debug('port not specifided, using default: ' + port);
    }

    console.log(tl.loc('ConnectPort', hostName, port));
    ftpClient.connect({ 'host': hostName, 'port': port, 'user': ftpOptions.username, 'password': ftpOptions.password, 'secure': secure, 'secureOptions': secureOptions, 'debug': debugLogger });
}