/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.tools.ant.taskdefs.optional.ssh;
import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import org.apache.tools.ant.util.FileUtils;
import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpATTRS;
import com.jcraft.jsch.SftpException;
/**
* A helper object representing an scp download.
*/
public class ScpFromMessage extends AbstractSshMessage {
private static final int HUNDRED_KILOBYTES = 102400;
private static final byte LINE_FEED = 0x0a;
private static final int BUFFER_SIZE = 100*1024;
private String remoteFile;
private File localFile;
private boolean isRecursive = false;
private boolean preserveLastModified = false;
/**
* Constructor for ScpFromMessage
* @param session the ssh session to use
*/
public ScpFromMessage(final Session session) {
super(session);
}
/**
* Constructor for ScpFromMessage
* @param verbose if true do verbose logging
* @param session the ssh session to use
* @since Ant 1.7
*/
public ScpFromMessage(final boolean verbose, final Session session) {
super(verbose, session);
}
/**
* Constructor for ScpFromMessage.
* @param verbose if true log extra information
* @param session the Scp session to use
* @param aRemoteFile the remote file name
* @param aLocalFile the local file
* @param recursive if true use recursion (-r option to scp)
* @since Ant 1.6.2
*/
public ScpFromMessage(final boolean verbose,
final Session session,
final String aRemoteFile,
final File aLocalFile,
final boolean recursive) {
this(false, session, aRemoteFile, aLocalFile, recursive, false);
}
/**
* Constructor for ScpFromMessage.
* @param session the Scp session to use
* @param aRemoteFile the remote file name
* @param aLocalFile the local file
* @param recursive if true use recursion (-r option to scp)
*/
public ScpFromMessage(final Session session,
final String aRemoteFile,
final File aLocalFile,
final boolean recursive) {
this(false, session, aRemoteFile, aLocalFile, recursive);
}
/**
* Constructor for ScpFromMessage.
* @param verbose if true log extra information
* @param session the Scp session to use
* @param aRemoteFile the remote file name
* @param aLocalFile the local file
* @param recursive if true use recursion (-r option to scp)
* @param preserveLastModified whether to preserve file
* modification times
* @since Ant 1.8.0
*/
public ScpFromMessage(final boolean verbose,
final Session session,
final String aRemoteFile,
final File aLocalFile,
final boolean recursive,
final boolean preserveLastModified) {
this(verbose, session, aRemoteFile, aLocalFile, recursive, preserveLastModified, false);
}
/**
* Constructor for ScpFromMessage.
* @param verbose if true log extra information
* @param session the Scp session to use
* @param aRemoteFile the remote file name
* @param aLocalFile the local file
* @param recursive if true use recursion (-r option to scp)
* @param preserveLastModified whether to preserve file
* @param compressed if true use compression (-C option to scp)
* modification times
* @since Ant 1.9.8
*/
public ScpFromMessage(boolean verbose,
Session session,
String aRemoteFile,
File aLocalFile,
boolean recursive,
boolean preserveLastModified,
boolean compressed) {
super(verbose, compressed, session);
this.remoteFile = aRemoteFile;
this.localFile = aLocalFile;
this.isRecursive = recursive;
this.preserveLastModified = preserveLastModified;
}
/**
* Carry out the transfer.
* @throws IOException on i/o errors
* @throws JSchException on errors detected by scp
*/
@Override
public void execute() throws IOException, JSchException {
String command = "scp -f ";
if (isRecursive) {
command += "-r ";
}
if (getCompressed()) {
command += "-C ";
}
command += remoteFile;
final Channel channel = openExecChannel(command);
try {
// get I/O streams for remote scp
final OutputStream out = channel.getOutputStream();
final InputStream in = channel.getInputStream();
channel.connect();
sendAck(out);
startRemoteCpProtocol(in, out, localFile);
} finally {
if (channel != null) {
channel.disconnect();
}
}
log("done\n");
}
protected boolean getPreserveLastModified() {
return preserveLastModified;
}
private void startRemoteCpProtocol(final InputStream in,
final OutputStream out,
final File localFile)
throws IOException, JSchException {
File startFile = localFile;
while (true) {
// C0644 filesize filename - header for a regular file
// T time 0 time 0\n - present if perserve time.
// D directory - this is the header for a directory.
final ByteArrayOutputStream stream = new ByteArrayOutputStream();
while (true) {
final int read = in.read();
if (read < 0) {
return;
}
if ((byte) read == LINE_FEED) {
break;
}
stream.write(read);
}
final String serverResponse = stream.toString("UTF-8");
if (serverResponse.charAt(0) == 'C') {
parseAndFetchFile(serverResponse, startFile, out, in);
} else if (serverResponse.charAt(0) == 'D') {
startFile = parseAndCreateDirectory(serverResponse,
startFile);
sendAck(out);
} else if (serverResponse.charAt(0) == 'E') {
startFile = startFile.getParentFile();
sendAck(out);
} else if (serverResponse.charAt(0) == '\01'
|| serverResponse.charAt(0) == '\02') {
// this indicates an error.
throw new IOException(serverResponse.substring(1));
}
}
}
private File parseAndCreateDirectory(final String serverResponse,
final File localFile) {
int start = serverResponse.indexOf(' ');
// appears that the next token is not used and it's zero.
start = serverResponse.indexOf(' ', start + 1);
final String directoryName = serverResponse.substring(start + 1);
if (localFile.isDirectory()) {
final File dir = new File(localFile, directoryName);
dir.mkdir();
log("Creating: " + dir);
return dir;
}
return null;
}
private void parseAndFetchFile(final String serverResponse,
final File localFile,
final OutputStream out,
final InputStream in)
throws IOException, JSchException {
int start = 0;
int end = serverResponse.indexOf(' ', start + 1);
start = end + 1;
end = serverResponse.indexOf(' ', start + 1);
final long filesize = Long.parseLong(serverResponse.substring(start, end));
final String filename = serverResponse.substring(end + 1);
log("Receiving: " + filename + " : " + filesize);
final File transferFile = localFile.isDirectory()
? new File(localFile, filename)
: localFile;
fetchFile(transferFile, filesize, out, in);
waitForAck(in);
sendAck(out);
}
private void fetchFile(final File localFile,
long filesize,
final OutputStream out,
final InputStream in)
throws IOException, JSchException {
final byte[] buf = new byte[BUFFER_SIZE];
sendAck(out);
// read a content of lfile
final OutputStream fos = Files.newOutputStream(localFile.toPath());
int length;
long totalLength = 0;
final long startTime = System.currentTimeMillis();
// only track progress for files larger than 100kb in verbose mode
final boolean trackProgress = getVerbose() && filesize > HUNDRED_KILOBYTES;
// since filesize keeps on decreasing we have to store the
// initial filesize
final long initFilesize = filesize;
int percentTransmitted = 0;
try {
while (true) {
length = in.read(buf, 0,
BUFFER_SIZE < filesize ? BUFFER_SIZE
: (int) filesize);
if (length < 0) {
throw new EOFException("Unexpected end of stream.");
}
fos.write(buf, 0, length);
filesize -= length;
totalLength += length;
if (filesize == 0) {
break;
}
if (trackProgress) {
percentTransmitted = trackProgress(initFilesize,
totalLength,
percentTransmitted);
}
}
} finally {
final long endTime = System.currentTimeMillis();
logStats(startTime, endTime, totalLength);
fos.flush();
fos.close();
}
if (getPreserveLastModified()) {
setLastModified(localFile);
}
}
private void setLastModified(final File localFile) throws JSchException {
SftpATTRS fileAttributes = null;
final ChannelSftp channel = openSftpChannel();
channel.connect();
try {
fileAttributes = channel.lstat(remoteDir(remoteFile)
+ localFile.getName());
} catch (final SftpException e) {
throw new JSchException("failed to stat remote file", e);
}
FileUtils.getFileUtils().setFileLastModified(localFile,
((long) fileAttributes
.getMTime())
* 1000);
}
/**
* returns the directory part of the remote file, if any.
*/
private static String remoteDir(final String remoteFile) {
int index = remoteFile.lastIndexOf('/');
if (index < 0) {
index = remoteFile.lastIndexOf('\\');
}
return index < 0 ? "" : remoteFile.substring(0, index + 1);
}
}