add hw2
This commit is contained in:
nik
770
node_modules/basic-ftp/dist/Client.js
generated
vendored
Normal file
770
node_modules/basic-ftp/dist/Client.js
generated
vendored
Normal file
@@ -0,0 +1,770 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Client = void 0;
|
||||
const fs_1 = require("fs");
|
||||
const path_1 = require("path");
|
||||
const tls_1 = require("tls");
|
||||
const util_1 = require("util");
|
||||
const FtpContext_1 = require("./FtpContext");
|
||||
const parseList_1 = require("./parseList");
|
||||
const ProgressTracker_1 = require("./ProgressTracker");
|
||||
const StringWriter_1 = require("./StringWriter");
|
||||
const parseListMLSD_1 = require("./parseListMLSD");
|
||||
const netUtils_1 = require("./netUtils");
|
||||
const transfer_1 = require("./transfer");
|
||||
const parseControlResponse_1 = require("./parseControlResponse");
|
||||
// Use promisify to keep the library compatible with Node 8.
|
||||
const fsReadDir = (0, util_1.promisify)(fs_1.readdir);
|
||||
const fsMkDir = (0, util_1.promisify)(fs_1.mkdir);
|
||||
const fsStat = (0, util_1.promisify)(fs_1.stat);
|
||||
const fsOpen = (0, util_1.promisify)(fs_1.open);
|
||||
const fsClose = (0, util_1.promisify)(fs_1.close);
|
||||
const fsUnlink = (0, util_1.promisify)(fs_1.unlink);
|
||||
const LIST_COMMANDS_DEFAULT = () => ["LIST -a", "LIST"];
|
||||
const LIST_COMMANDS_MLSD = () => ["MLSD", "LIST -a", "LIST"];
|
||||
/**
|
||||
* High-level API to interact with an FTP server.
|
||||
*/
|
||||
class Client {
|
||||
/**
|
||||
* Instantiate an FTP client.
|
||||
*
|
||||
* @param timeout Timeout in milliseconds, use 0 for no timeout. Optional, default is 30 seconds.
|
||||
*/
|
||||
constructor(timeout = 30000) {
|
||||
this.availableListCommands = LIST_COMMANDS_DEFAULT();
|
||||
this.ftp = new FtpContext_1.FTPContext(timeout);
|
||||
this.prepareTransfer = this._enterFirstCompatibleMode([transfer_1.enterPassiveModeIPv6, transfer_1.enterPassiveModeIPv4]);
|
||||
this.parseList = parseList_1.parseList;
|
||||
this._progressTracker = new ProgressTracker_1.ProgressTracker();
|
||||
}
|
||||
/**
|
||||
* Close the client and all open socket connections.
|
||||
*
|
||||
* Close the client and all open socket connections. The client can’t be used anymore after calling this method,
|
||||
* you have to either reconnect with `access` or `connect` or instantiate a new instance to continue any work.
|
||||
* A client is also closed automatically if any timeout or connection error occurs.
|
||||
*/
|
||||
close() {
|
||||
this.ftp.close();
|
||||
this._progressTracker.stop();
|
||||
}
|
||||
/**
|
||||
* Returns true if the client is closed and can't be used anymore.
|
||||
*/
|
||||
get closed() {
|
||||
return this.ftp.closed;
|
||||
}
|
||||
/**
|
||||
* Connect (or reconnect) to an FTP server.
|
||||
*
|
||||
* This is an instance method and thus can be called multiple times during the lifecycle of a `Client`
|
||||
* instance. Whenever you do, the client is reset with a new control connection. This also implies that
|
||||
* you can reopen a `Client` instance that has been closed due to an error when reconnecting with this
|
||||
* method. In fact, reconnecting is the only way to continue using a closed `Client`.
|
||||
*
|
||||
* @param host Host the client should connect to. Optional, default is "localhost".
|
||||
* @param port Port the client should connect to. Optional, default is 21.
|
||||
*/
|
||||
connect(host = "localhost", port = 21) {
|
||||
this.ftp.reset();
|
||||
this.ftp.socket.connect({
|
||||
host,
|
||||
port,
|
||||
family: this.ftp.ipFamily
|
||||
}, () => this.ftp.log(`Connected to ${(0, netUtils_1.describeAddress)(this.ftp.socket)} (${(0, netUtils_1.describeTLS)(this.ftp.socket)})`));
|
||||
return this._handleConnectResponse();
|
||||
}
|
||||
/**
|
||||
* As `connect` but using implicit TLS. Implicit TLS is not an FTP standard and has been replaced by
|
||||
* explicit TLS. There are still FTP servers that support only implicit TLS, though.
|
||||
*/
|
||||
connectImplicitTLS(host = "localhost", port = 21, tlsOptions = {}) {
|
||||
this.ftp.reset();
|
||||
this.ftp.socket = (0, tls_1.connect)(port, host, tlsOptions, () => this.ftp.log(`Connected to ${(0, netUtils_1.describeAddress)(this.ftp.socket)} (${(0, netUtils_1.describeTLS)(this.ftp.socket)})`));
|
||||
this.ftp.tlsOptions = tlsOptions;
|
||||
return this._handleConnectResponse();
|
||||
}
|
||||
/**
|
||||
* Handles the first reponse by an FTP server after the socket connection has been established.
|
||||
*/
|
||||
_handleConnectResponse() {
|
||||
return this.ftp.handle(undefined, (res, task) => {
|
||||
if (res instanceof Error) {
|
||||
// The connection has been destroyed by the FTPContext at this point.
|
||||
task.reject(res);
|
||||
}
|
||||
else if ((0, parseControlResponse_1.positiveCompletion)(res.code)) {
|
||||
task.resolve(res);
|
||||
}
|
||||
// Reject all other codes, including 120 "Service ready in nnn minutes".
|
||||
else {
|
||||
// Don't stay connected but don't replace the socket yet by using reset()
|
||||
// so the user can inspect properties of this instance.
|
||||
task.reject(new FtpContext_1.FTPError(res));
|
||||
}
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Send an FTP command and handle the first response.
|
||||
*/
|
||||
send(command, ignoreErrorCodesDEPRECATED = false) {
|
||||
if (ignoreErrorCodesDEPRECATED) { // Deprecated starting from 3.9.0
|
||||
this.ftp.log("Deprecated call using send(command, flag) with boolean flag to ignore errors. Use sendIgnoringError(command).");
|
||||
return this.sendIgnoringError(command);
|
||||
}
|
||||
return this.ftp.request(command);
|
||||
}
|
||||
/**
|
||||
* Send an FTP command and ignore an FTP error response. Any other kind of error or timeout will still reject the Promise.
|
||||
*
|
||||
* @param command
|
||||
*/
|
||||
sendIgnoringError(command) {
|
||||
return this.ftp.handle(command, (res, task) => {
|
||||
if (res instanceof FtpContext_1.FTPError) {
|
||||
task.resolve({ code: res.code, message: res.message });
|
||||
}
|
||||
else if (res instanceof Error) {
|
||||
task.reject(res);
|
||||
}
|
||||
else {
|
||||
task.resolve(res);
|
||||
}
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Upgrade the current socket connection to TLS.
|
||||
*
|
||||
* @param options TLS options as in `tls.connect(options)`, optional.
|
||||
* @param command Set the authentication command. Optional, default is "AUTH TLS".
|
||||
*/
|
||||
async useTLS(options = {}, command = "AUTH TLS") {
|
||||
const ret = await this.send(command);
|
||||
this.ftp.socket = await (0, netUtils_1.upgradeSocket)(this.ftp.socket, options);
|
||||
this.ftp.tlsOptions = options; // Keep the TLS options for later data connections that should use the same options.
|
||||
this.ftp.log(`Control socket is using: ${(0, netUtils_1.describeTLS)(this.ftp.socket)}`);
|
||||
return ret;
|
||||
}
|
||||
/**
|
||||
* Login a user with a password.
|
||||
*
|
||||
* @param user Username to use for login. Optional, default is "anonymous".
|
||||
* @param password Password to use for login. Optional, default is "guest".
|
||||
*/
|
||||
login(user = "anonymous", password = "guest") {
|
||||
this.ftp.log(`Login security: ${(0, netUtils_1.describeTLS)(this.ftp.socket)}`);
|
||||
return this.ftp.handle("USER " + user, (res, task) => {
|
||||
if (res instanceof Error) {
|
||||
task.reject(res);
|
||||
}
|
||||
else if ((0, parseControlResponse_1.positiveCompletion)(res.code)) { // User logged in proceed OR Command superfluous
|
||||
task.resolve(res);
|
||||
}
|
||||
else if (res.code === 331) { // User name okay, need password
|
||||
this.ftp.send("PASS " + password);
|
||||
}
|
||||
else { // Also report error on 332 (Need account)
|
||||
task.reject(new FtpContext_1.FTPError(res));
|
||||
}
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Set the usual default settings.
|
||||
*
|
||||
* Settings used:
|
||||
* * Binary mode (TYPE I)
|
||||
* * File structure (STRU F)
|
||||
* * Additional settings for FTPS (PBSZ 0, PROT P)
|
||||
*/
|
||||
async useDefaultSettings() {
|
||||
const features = await this.features();
|
||||
// Use MLSD directory listing if possible. See https://tools.ietf.org/html/rfc3659#section-7.8:
|
||||
// "The presence of the MLST feature indicates that both MLST and MLSD are supported."
|
||||
const supportsMLSD = features.has("MLST");
|
||||
this.availableListCommands = supportsMLSD ? LIST_COMMANDS_MLSD() : LIST_COMMANDS_DEFAULT();
|
||||
await this.send("TYPE I"); // Binary mode
|
||||
await this.sendIgnoringError("STRU F"); // Use file structure
|
||||
await this.sendIgnoringError("OPTS UTF8 ON"); // Some servers expect UTF-8 to be enabled explicitly and setting before login might not have worked.
|
||||
if (supportsMLSD) {
|
||||
await this.sendIgnoringError("OPTS MLST type;size;modify;unique;unix.mode;unix.owner;unix.group;unix.ownername;unix.groupname;"); // Make sure MLSD listings include all we can parse
|
||||
}
|
||||
if (this.ftp.hasTLS) {
|
||||
await this.sendIgnoringError("PBSZ 0"); // Set to 0 for TLS
|
||||
await this.sendIgnoringError("PROT P"); // Protect channel (also for data connections)
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Convenience method that calls `connect`, `useTLS`, `login` and `useDefaultSettings`.
|
||||
*
|
||||
* This is an instance method and thus can be called multiple times during the lifecycle of a `Client`
|
||||
* instance. Whenever you do, the client is reset with a new control connection. This also implies that
|
||||
* you can reopen a `Client` instance that has been closed due to an error when reconnecting with this
|
||||
* method. In fact, reconnecting is the only way to continue using a closed `Client`.
|
||||
*/
|
||||
async access(options = {}) {
|
||||
var _a, _b;
|
||||
const useExplicitTLS = options.secure === true;
|
||||
const useImplicitTLS = options.secure === "implicit";
|
||||
let welcome;
|
||||
if (useImplicitTLS) {
|
||||
welcome = await this.connectImplicitTLS(options.host, options.port, options.secureOptions);
|
||||
}
|
||||
else {
|
||||
welcome = await this.connect(options.host, options.port);
|
||||
}
|
||||
if (useExplicitTLS) {
|
||||
// Fixes https://github.com/patrickjuchli/basic-ftp/issues/166 by making sure
|
||||
// host is set for any future data connection as well.
|
||||
const secureOptions = (_a = options.secureOptions) !== null && _a !== void 0 ? _a : {};
|
||||
secureOptions.host = (_b = secureOptions.host) !== null && _b !== void 0 ? _b : options.host;
|
||||
await this.useTLS(secureOptions);
|
||||
}
|
||||
// Set UTF-8 on before login in case there are non-ascii characters in user or password.
|
||||
// Note that this might not work before login depending on server.
|
||||
await this.sendIgnoringError("OPTS UTF8 ON");
|
||||
await this.login(options.user, options.password);
|
||||
await this.useDefaultSettings();
|
||||
return welcome;
|
||||
}
|
||||
/**
|
||||
* Get the current working directory.
|
||||
*/
|
||||
async pwd() {
|
||||
const res = await this.send("PWD");
|
||||
// The directory is part of the return message, for example:
|
||||
// 257 "/this/that" is current directory.
|
||||
const parsed = res.message.match(/"(.+)"/);
|
||||
if (parsed === null || parsed[1] === undefined) {
|
||||
throw new Error(`Can't parse response to command 'PWD': ${res.message}`);
|
||||
}
|
||||
return parsed[1];
|
||||
}
|
||||
/**
|
||||
* Get a description of supported features.
|
||||
*
|
||||
* This sends the FEAT command and parses the result into a Map where keys correspond to available commands
|
||||
* and values hold further information. Be aware that your FTP servers might not support this
|
||||
* command in which case this method will not throw an exception but just return an empty Map.
|
||||
*/
|
||||
async features() {
|
||||
const res = await this.sendIgnoringError("FEAT");
|
||||
const features = new Map();
|
||||
// Not supporting any special features will be reported with a single line.
|
||||
if (res.code < 400 && (0, parseControlResponse_1.isMultiline)(res.message)) {
|
||||
// The first and last line wrap the multiline response, ignore them.
|
||||
res.message.split("\n").slice(1, -1).forEach(line => {
|
||||
// A typical lines looks like: " REST STREAM" or " MDTM".
|
||||
// Servers might not use an indentation though.
|
||||
const entry = line.trim().split(" ");
|
||||
features.set(entry[0], entry[1] || "");
|
||||
});
|
||||
}
|
||||
return features;
|
||||
}
|
||||
/**
|
||||
* Set the working directory.
|
||||
*/
|
||||
async cd(path) {
|
||||
const validPath = await this.protectWhitespace(path);
|
||||
return this.send("CWD " + validPath);
|
||||
}
|
||||
/**
|
||||
* Switch to the parent directory of the working directory.
|
||||
*/
|
||||
async cdup() {
|
||||
return this.send("CDUP");
|
||||
}
|
||||
/**
|
||||
* Get the last modified time of a file. This is not supported by every FTP server, in which case
|
||||
* calling this method will throw an exception.
|
||||
*/
|
||||
async lastMod(path) {
|
||||
const validPath = await this.protectWhitespace(path);
|
||||
const res = await this.send(`MDTM ${validPath}`);
|
||||
const date = res.message.slice(4);
|
||||
return (0, parseListMLSD_1.parseMLSxDate)(date);
|
||||
}
|
||||
/**
|
||||
* Get the size of a file.
|
||||
*/
|
||||
async size(path) {
|
||||
const validPath = await this.protectWhitespace(path);
|
||||
const command = `SIZE ${validPath}`;
|
||||
const res = await this.send(command);
|
||||
// The size is part of the response message, for example: "213 555555". It's
|
||||
// possible that there is a commmentary appended like "213 5555, some commentary".
|
||||
const size = parseInt(res.message.slice(4), 10);
|
||||
if (Number.isNaN(size)) {
|
||||
throw new Error(`Can't parse response to command '${command}' as a numerical value: ${res.message}`);
|
||||
}
|
||||
return size;
|
||||
}
|
||||
/**
|
||||
* Rename a file.
|
||||
*
|
||||
* Depending on the FTP server this might also be used to move a file from one
|
||||
* directory to another by providing full paths.
|
||||
*/
|
||||
async rename(srcPath, destPath) {
|
||||
const validSrc = await this.protectWhitespace(srcPath);
|
||||
const validDest = await this.protectWhitespace(destPath);
|
||||
await this.send("RNFR " + validSrc);
|
||||
return this.send("RNTO " + validDest);
|
||||
}
|
||||
/**
|
||||
* Remove a file from the current working directory.
|
||||
*
|
||||
* You can ignore FTP error return codes which won't throw an exception if e.g.
|
||||
* the file doesn't exist.
|
||||
*/
|
||||
async remove(path, ignoreErrorCodes = false) {
|
||||
const validPath = await this.protectWhitespace(path);
|
||||
if (ignoreErrorCodes) {
|
||||
return this.sendIgnoringError(`DELE ${validPath}`);
|
||||
}
|
||||
return this.send(`DELE ${validPath}`);
|
||||
}
|
||||
/**
|
||||
* Report transfer progress for any upload or download to a given handler.
|
||||
*
|
||||
* This will also reset the overall transfer counter that can be used for multiple transfers. You can
|
||||
* also call the function without a handler to stop reporting to an earlier one.
|
||||
*
|
||||
* @param handler Handler function to call on transfer progress.
|
||||
*/
|
||||
trackProgress(handler) {
|
||||
this._progressTracker.bytesOverall = 0;
|
||||
this._progressTracker.reportTo(handler);
|
||||
}
|
||||
/**
|
||||
* Upload data from a readable stream or a local file to a remote file.
|
||||
*
|
||||
* @param source Readable stream or path to a local file.
|
||||
* @param toRemotePath Path to a remote file to write to.
|
||||
*/
|
||||
async uploadFrom(source, toRemotePath, options = {}) {
|
||||
return this._uploadWithCommand(source, toRemotePath, "STOR", options);
|
||||
}
|
||||
/**
|
||||
* Upload data from a readable stream or a local file by appending it to an existing file. If the file doesn't
|
||||
* exist the FTP server should create it.
|
||||
*
|
||||
* @param source Readable stream or path to a local file.
|
||||
* @param toRemotePath Path to a remote file to write to.
|
||||
*/
|
||||
async appendFrom(source, toRemotePath, options = {}) {
|
||||
return this._uploadWithCommand(source, toRemotePath, "APPE", options);
|
||||
}
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
async _uploadWithCommand(source, remotePath, command, options) {
|
||||
if (typeof source === "string") {
|
||||
return this._uploadLocalFile(source, remotePath, command, options);
|
||||
}
|
||||
return this._uploadFromStream(source, remotePath, command);
|
||||
}
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
async _uploadLocalFile(localPath, remotePath, command, options) {
|
||||
const fd = await fsOpen(localPath, "r");
|
||||
const source = (0, fs_1.createReadStream)("", {
|
||||
fd,
|
||||
start: options.localStart,
|
||||
end: options.localEndInclusive,
|
||||
autoClose: false
|
||||
});
|
||||
try {
|
||||
return await this._uploadFromStream(source, remotePath, command);
|
||||
}
|
||||
finally {
|
||||
await ignoreError(() => fsClose(fd));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
async _uploadFromStream(source, remotePath, command) {
|
||||
const onError = (err) => this.ftp.closeWithError(err);
|
||||
source.once("error", onError);
|
||||
try {
|
||||
const validPath = await this.protectWhitespace(remotePath);
|
||||
await this.prepareTransfer(this.ftp);
|
||||
// Keep the keyword `await` or the `finally` clause below runs too early
|
||||
// and removes the event listener for the source stream too early.
|
||||
return await (0, transfer_1.uploadFrom)(source, {
|
||||
ftp: this.ftp,
|
||||
tracker: this._progressTracker,
|
||||
command,
|
||||
remotePath: validPath,
|
||||
type: "upload"
|
||||
});
|
||||
}
|
||||
finally {
|
||||
source.removeListener("error", onError);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Download a remote file and pipe its data to a writable stream or to a local file.
|
||||
*
|
||||
* You can optionally define at which position of the remote file you'd like to start
|
||||
* downloading. If the destination you provide is a file, the offset will be applied
|
||||
* to it as well. For example: To resume a failed download, you'd request the size of
|
||||
* the local, partially downloaded file and use that as the offset. Assuming the size
|
||||
* is 23, you'd download the rest using `downloadTo("local.txt", "remote.txt", 23)`.
|
||||
*
|
||||
* @param destination Stream or path for a local file to write to.
|
||||
* @param fromRemotePath Path of the remote file to read from.
|
||||
* @param startAt Position within the remote file to start downloading at. If the destination is a file, this offset is also applied to it.
|
||||
*/
|
||||
async downloadTo(destination, fromRemotePath, startAt = 0) {
|
||||
if (typeof destination === "string") {
|
||||
return this._downloadToFile(destination, fromRemotePath, startAt);
|
||||
}
|
||||
return this._downloadToStream(destination, fromRemotePath, startAt);
|
||||
}
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
async _downloadToFile(localPath, remotePath, startAt) {
|
||||
const appendingToLocalFile = startAt > 0;
|
||||
const fileSystemFlags = appendingToLocalFile ? "r+" : "w";
|
||||
const fd = await fsOpen(localPath, fileSystemFlags);
|
||||
const destination = (0, fs_1.createWriteStream)("", {
|
||||
fd,
|
||||
start: startAt,
|
||||
autoClose: false
|
||||
});
|
||||
try {
|
||||
return await this._downloadToStream(destination, remotePath, startAt);
|
||||
}
|
||||
catch (err) {
|
||||
const localFileStats = await ignoreError(() => fsStat(localPath));
|
||||
const hasDownloadedData = localFileStats && localFileStats.size > 0;
|
||||
const shouldRemoveLocalFile = !appendingToLocalFile && !hasDownloadedData;
|
||||
if (shouldRemoveLocalFile) {
|
||||
await ignoreError(() => fsUnlink(localPath));
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
finally {
|
||||
await ignoreError(() => fsClose(fd));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
async _downloadToStream(destination, remotePath, startAt) {
|
||||
const onError = (err) => this.ftp.closeWithError(err);
|
||||
destination.once("error", onError);
|
||||
try {
|
||||
const validPath = await this.protectWhitespace(remotePath);
|
||||
await this.prepareTransfer(this.ftp);
|
||||
// Keep the keyword `await` or the `finally` clause below runs too early
|
||||
// and removes the event listener for the source stream too early.
|
||||
return await (0, transfer_1.downloadTo)(destination, {
|
||||
ftp: this.ftp,
|
||||
tracker: this._progressTracker,
|
||||
command: startAt > 0 ? `REST ${startAt}` : `RETR ${validPath}`,
|
||||
remotePath: validPath,
|
||||
type: "download"
|
||||
});
|
||||
}
|
||||
finally {
|
||||
destination.removeListener("error", onError);
|
||||
destination.end();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* List files and directories in the current working directory, or from `path` if specified.
|
||||
*
|
||||
* @param [path] Path to remote file or directory.
|
||||
*/
|
||||
async list(path = "") {
|
||||
const validPath = await this.protectWhitespace(path);
|
||||
let lastError;
|
||||
for (const candidate of this.availableListCommands) {
|
||||
const command = validPath === "" ? candidate : `${candidate} ${validPath}`;
|
||||
await this.prepareTransfer(this.ftp);
|
||||
try {
|
||||
const parsedList = await this._requestListWithCommand(command);
|
||||
// Use successful candidate for all subsequent requests.
|
||||
this.availableListCommands = [candidate];
|
||||
return parsedList;
|
||||
}
|
||||
catch (err) {
|
||||
const shouldTryNext = err instanceof FtpContext_1.FTPError;
|
||||
if (!shouldTryNext) {
|
||||
throw err;
|
||||
}
|
||||
lastError = err;
|
||||
}
|
||||
}
|
||||
throw lastError;
|
||||
}
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
async _requestListWithCommand(command) {
|
||||
const buffer = new StringWriter_1.StringWriter();
|
||||
await (0, transfer_1.downloadTo)(buffer, {
|
||||
ftp: this.ftp,
|
||||
tracker: this._progressTracker,
|
||||
command,
|
||||
remotePath: "",
|
||||
type: "list"
|
||||
});
|
||||
const text = buffer.getText(this.ftp.encoding);
|
||||
this.ftp.log(text);
|
||||
return this.parseList(text);
|
||||
}
|
||||
/**
|
||||
* Remove a directory and all of its content.
|
||||
*
|
||||
* @param remoteDirPath The path of the remote directory to delete.
|
||||
* @example client.removeDir("foo") // Remove directory 'foo' using a relative path.
|
||||
* @example client.removeDir("foo/bar") // Remove directory 'bar' using a relative path.
|
||||
* @example client.removeDir("/foo/bar") // Remove directory 'bar' using an absolute path.
|
||||
* @example client.removeDir("/") // Remove everything.
|
||||
*/
|
||||
async removeDir(remoteDirPath) {
|
||||
return this._exitAtCurrentDirectory(async () => {
|
||||
await this.cd(remoteDirPath);
|
||||
// Get the absolute path of the target because remoteDirPath might be a relative path, even `../` is possible.
|
||||
const absoluteDirPath = await this.pwd();
|
||||
await this.clearWorkingDir();
|
||||
const dirIsRoot = absoluteDirPath === "/";
|
||||
if (!dirIsRoot) {
|
||||
await this.cdup();
|
||||
await this.removeEmptyDir(absoluteDirPath);
|
||||
}
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Remove all files and directories in the working directory without removing
|
||||
* the working directory itself.
|
||||
*/
|
||||
async clearWorkingDir() {
|
||||
for (const file of await this.list()) {
|
||||
if (file.isDirectory) {
|
||||
await this.cd(file.name);
|
||||
await this.clearWorkingDir();
|
||||
await this.cdup();
|
||||
await this.removeEmptyDir(file.name);
|
||||
}
|
||||
else {
|
||||
await this.remove(file.name);
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Upload the contents of a local directory to the remote working directory.
|
||||
*
|
||||
* This will overwrite existing files with the same names and reuse existing directories.
|
||||
* Unrelated files and directories will remain untouched. You can optionally provide a `remoteDirPath`
|
||||
* to put the contents inside a directory which will be created if necessary including all
|
||||
* intermediate directories. If you did provide a remoteDirPath the working directory will stay
|
||||
* the same as before calling this method.
|
||||
*
|
||||
* @param localDirPath Local path, e.g. "foo/bar" or "../test"
|
||||
* @param [remoteDirPath] Remote path of a directory to upload to. Working directory if undefined.
|
||||
*/
|
||||
async uploadFromDir(localDirPath, remoteDirPath) {
|
||||
return this._exitAtCurrentDirectory(async () => {
|
||||
if (remoteDirPath) {
|
||||
await this.ensureDir(remoteDirPath);
|
||||
}
|
||||
return await this._uploadToWorkingDir(localDirPath);
|
||||
});
|
||||
}
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
async _uploadToWorkingDir(localDirPath) {
|
||||
const files = await fsReadDir(localDirPath);
|
||||
for (const file of files) {
|
||||
const fullPath = (0, path_1.join)(localDirPath, file);
|
||||
const stats = await fsStat(fullPath);
|
||||
if (stats.isFile()) {
|
||||
await this.uploadFrom(fullPath, file);
|
||||
}
|
||||
else if (stats.isDirectory()) {
|
||||
await this._openDir(file);
|
||||
await this._uploadToWorkingDir(fullPath);
|
||||
await this.cdup();
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Download all files and directories of the working directory to a local directory.
|
||||
*
|
||||
* @param localDirPath The local directory to download to.
|
||||
* @param remoteDirPath Remote directory to download. Current working directory if not specified.
|
||||
*/
|
||||
async downloadToDir(localDirPath, remoteDirPath) {
|
||||
return this._exitAtCurrentDirectory(async () => {
|
||||
if (remoteDirPath) {
|
||||
await this.cd(remoteDirPath);
|
||||
}
|
||||
return await this._downloadFromWorkingDir(localDirPath);
|
||||
});
|
||||
}
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
async _downloadFromWorkingDir(localDirPath) {
|
||||
await ensureLocalDirectory(localDirPath);
|
||||
for (const file of await this.list()) {
|
||||
const localPath = (0, path_1.join)(localDirPath, file.name);
|
||||
if (file.isDirectory) {
|
||||
await this.cd(file.name);
|
||||
await this._downloadFromWorkingDir(localPath);
|
||||
await this.cdup();
|
||||
}
|
||||
else if (file.isFile) {
|
||||
await this.downloadTo(localPath, file.name);
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Make sure a given remote path exists, creating all directories as necessary.
|
||||
* This function also changes the current working directory to the given path.
|
||||
*/
|
||||
async ensureDir(remoteDirPath) {
|
||||
// If the remoteDirPath was absolute go to root directory.
|
||||
if (remoteDirPath.startsWith("/")) {
|
||||
await this.cd("/");
|
||||
}
|
||||
const names = remoteDirPath.split("/").filter(name => name !== "");
|
||||
for (const name of names) {
|
||||
await this._openDir(name);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Try to create a directory and enter it. This will not raise an exception if the directory
|
||||
* couldn't be created if for example it already exists.
|
||||
* @protected
|
||||
*/
|
||||
async _openDir(dirName) {
|
||||
await this.sendIgnoringError("MKD " + dirName);
|
||||
await this.cd(dirName);
|
||||
}
|
||||
/**
|
||||
* Remove an empty directory, will fail if not empty.
|
||||
*/
|
||||
async removeEmptyDir(path) {
|
||||
const validPath = await this.protectWhitespace(path);
|
||||
return this.send(`RMD ${validPath}`);
|
||||
}
|
||||
/**
|
||||
* FTP servers can't handle filenames that have leading whitespace. This method transforms
|
||||
* a given path to fix that issue for most cases.
|
||||
*/
|
||||
async protectWhitespace(path) {
|
||||
if (!path.startsWith(" ")) {
|
||||
return path;
|
||||
}
|
||||
// Handle leading whitespace by prepending the absolute path:
|
||||
// " test.txt" while being in the root directory becomes "/ test.txt".
|
||||
const pwd = await this.pwd();
|
||||
const absolutePathPrefix = pwd.endsWith("/") ? pwd : pwd + "/";
|
||||
return absolutePathPrefix + path;
|
||||
}
|
||||
async _exitAtCurrentDirectory(func) {
|
||||
const userDir = await this.pwd();
|
||||
try {
|
||||
return await func();
|
||||
}
|
||||
finally {
|
||||
if (!this.closed) {
|
||||
await ignoreError(() => this.cd(userDir));
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Try all available transfer strategies and pick the first one that works. Update `client` to
|
||||
* use the working strategy for all successive transfer requests.
|
||||
*
|
||||
* @returns a function that will try the provided strategies.
|
||||
*/
|
||||
_enterFirstCompatibleMode(strategies) {
|
||||
return async (ftp) => {
|
||||
ftp.log("Trying to find optimal transfer strategy...");
|
||||
let lastError = undefined;
|
||||
for (const strategy of strategies) {
|
||||
try {
|
||||
const res = await strategy(ftp);
|
||||
ftp.log("Optimal transfer strategy found.");
|
||||
this.prepareTransfer = strategy; // eslint-disable-line require-atomic-updates
|
||||
return res;
|
||||
}
|
||||
catch (err) {
|
||||
// Try the next candidate no matter the exact error. It's possible that a server
|
||||
// answered incorrectly to a strategy, for example a PASV answer to an EPSV.
|
||||
lastError = err;
|
||||
}
|
||||
}
|
||||
throw new Error(`None of the available transfer strategies work. Last error response was '${lastError}'.`);
|
||||
};
|
||||
}
|
||||
/**
|
||||
* DEPRECATED, use `uploadFrom`.
|
||||
* @deprecated
|
||||
*/
|
||||
async upload(source, toRemotePath, options = {}) {
|
||||
this.ftp.log("Warning: upload() has been deprecated, use uploadFrom().");
|
||||
return this.uploadFrom(source, toRemotePath, options);
|
||||
}
|
||||
/**
|
||||
* DEPRECATED, use `appendFrom`.
|
||||
* @deprecated
|
||||
*/
|
||||
async append(source, toRemotePath, options = {}) {
|
||||
this.ftp.log("Warning: append() has been deprecated, use appendFrom().");
|
||||
return this.appendFrom(source, toRemotePath, options);
|
||||
}
|
||||
/**
|
||||
* DEPRECATED, use `downloadTo`.
|
||||
* @deprecated
|
||||
*/
|
||||
async download(destination, fromRemotePath, startAt = 0) {
|
||||
this.ftp.log("Warning: download() has been deprecated, use downloadTo().");
|
||||
return this.downloadTo(destination, fromRemotePath, startAt);
|
||||
}
|
||||
/**
|
||||
* DEPRECATED, use `uploadFromDir`.
|
||||
* @deprecated
|
||||
*/
|
||||
async uploadDir(localDirPath, remoteDirPath) {
|
||||
this.ftp.log("Warning: uploadDir() has been deprecated, use uploadFromDir().");
|
||||
return this.uploadFromDir(localDirPath, remoteDirPath);
|
||||
}
|
||||
/**
|
||||
* DEPRECATED, use `downloadToDir`.
|
||||
* @deprecated
|
||||
*/
|
||||
async downloadDir(localDirPath) {
|
||||
this.ftp.log("Warning: downloadDir() has been deprecated, use downloadToDir().");
|
||||
return this.downloadToDir(localDirPath);
|
||||
}
|
||||
}
|
||||
exports.Client = Client;
|
||||
async function ensureLocalDirectory(path) {
|
||||
try {
|
||||
await fsStat(path);
|
||||
}
|
||||
catch (err) {
|
||||
await fsMkDir(path, { recursive: true });
|
||||
}
|
||||
}
|
||||
async function ignoreError(func) {
|
||||
try {
|
||||
return await func();
|
||||
}
|
||||
catch (err) {
|
||||
// Ignore
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user