import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
@Test
public void uploadFile() throws IOException, NoSuchProviderException, NoSuchAlgorithmException {
  final SSHClient ssh = new SSHClient();
  ssh.addHostKeyVerifier(SecurityUtils.getFingerprint(subject.getHostsPublicKey()));

  ssh.connect("localhost", subject.getPort());
  try {
    ssh.authPublickey("this_is_ignored", new KeyPairWrapper(
        KeyPairGenerator.getInstance("DSA", "SUN").generateKeyPair()));

    final SFTPClient sftp = ssh.newSFTPClient();
    File testFile = local.newFile("fred.txt");
    try {
      sftp.put(new FileSystemFile(testFile), "/fred.txt");
    } finally {
      sftp.close();
    }
  } finally {
    ssh.disconnect();
  }

  assertThat(sftpHome.getRoot().list(), is(new String[]{"fred.txt"}));
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
public void receiveFile(String lfile, String rfile) throws Exception {
	final SSHClient ssh = getConnectedClient();

	try {
		final Session session = ssh.startSession();
		try {
			ssh.newSCPFileTransfer().download(rfile, new FileSystemFile(lfile));
		} catch (SCPException e) {
			if (e.getMessage().contains("No such file or directory"))
				logger.warn("No file or directory `{}` found on {}.", rfile, ip);
			else
				throw e;
		} finally {
			session.close();
		}
	} finally {
		ssh.disconnect();
		ssh.close();
	}
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
@Test
public void downloadFile() throws IOException, NoSuchProviderException, NoSuchAlgorithmException {
  FileUtils.write(sftpHome.newFile("fred.txt"), "Electric boogaloo");

  final SSHClient ssh = new SSHClient();
  ssh.addHostKeyVerifier(SecurityUtils.getFingerprint(subject.getHostsPublicKey()));

  ssh.connect("localhost", subject.getPort());
  try {
    ssh.authPublickey("this_is_ignored", new KeyPairWrapper(
        KeyPairGenerator.getInstance("DSA", "SUN").generateKeyPair()));

    final SFTPClient sftp = ssh.newSFTPClient();

    try {
      sftp.get("fred.txt", new FileSystemFile(new File(local.getRoot(), "fred.txt")));
    } finally {
      sftp.close();
    }
  } finally {
    ssh.disconnect();
  }

  assertThat(FileUtils.readFileToString(new File(local.getRoot(), "fred.txt")),
      is("Electric boogaloo"));
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
@Override
public void copyFilesFromLocalDisk(Path srcPath, String destRelPath) throws IOException {
  LOGGER.trace("copyFilesFromLocalDisk({}, {})", srcPath.toString(), destRelPath);
  mkdirs(destRelPath);

  // Must be correct, because mkdirs has passed.
  String remotePath = concatenatePathToHome(destRelPath);

  SSHClient ssh = connectWithSSH();
  try {
    ssh.useCompression();

    ssh.newSCPFileTransfer().upload(new FileSystemFile(srcPath.toFile()), remotePath);
  } finally {
    ssh.disconnect();
  }
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
@Override
public void copyFilesToLocalDisk(String srcRelPath, Path destPath) throws IOException {
  LOGGER.trace("copyFilesToLocalDisk({}, {})", srcRelPath, destPath.toString());
  createDestinationDirectoriesLocally(destPath);

  SSHClient ssh = connectWithSSH();
  try {
    ssh.useCompression();

    String remotePath = concatenatePathToHome(srcRelPath);

    ssh.newSCPFileTransfer().download(remotePath, new FileSystemFile(destPath.toFile()));
  } finally {
    ssh.disconnect();
  }
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
/**
 * Uploads a local file (or directory) to the remote server via SCP.
 *
 * @param address the hostname or IP address of the remote server.
 * @param username the username of the remote server.
 * @param password the password of the remote server.
 * @param localPath a local file or directory which will be uploaded.
 * @param remotePath the destination path on the remote server.
 * @throws Exception
 */
public void upload(String address, String username, String password, String localPath, String remotePath) throws Exception {
	SSHClient client = newSSHClient();
	client.connect(address);
	logger.debug("Connected to hostname %s", address);
	try {
		client.authPassword(username, password.toCharArray());
		logger.debug("Successful authentication of user %s", username);

		client.newSCPFileTransfer().upload(new FileSystemFile(new File(localPath)), remotePath);
		logger.debug("Successful upload from %s to %s", localPath, remotePath);
	} finally {
		client.disconnect();
		logger.debug("Disconnected to hostname %s", address);
	}
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
/**
 * Downloads a remote file (or directory) to the local directory via SCP.
 * 
 * @param address the hostname or IP address of the remote server.
 * @param username the username of the remote server.
 * @param password the password of the remote server.
 * @param remotePath a remote file or directory which will be downloaded.
 * @param localPath the destination directory on the local file system.
 * @throws Exception
 */
public void download(String address, String username, String password, String remotePath, String localPath) throws Exception {
	SSHClient client = newSSHClient();
	client.connect(address);
	logger.debug("Connected to hostname %s", address);
	try {
		client.authPassword(username, password.toCharArray());
		logger.debug("Successful authentication of user %s", username);

		client.newSCPFileTransfer().download(remotePath, new FileSystemFile(new File(localPath)));
		logger.debug("Successful download from %s to %s", remotePath, localPath);
	} finally {
		client.disconnect();
		logger.debug("Disconnected to hostname %s", address);
	}
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
/**
 * Updates the configuration file of an agent.
 * @param parameters
 * @param ssh
 * @param tmpDir
 * @param keyToNewValue
 * @throws IOException
 */
void updateAgentConfigurationFile(
		TargetHandlerParameters parameters,
		SSHClient ssh,
		File tmpDir,
		Map<String,String> keyToNewValue )
throws IOException {

	this.logger.fine( "Updating agent parameters on remote host..." );

	// Update the agent's configuration file
	String agentConfigDir = Utils.getValue( parameters.getTargetProperties(), SCP_AGENT_CONFIG_DIR, DEFAULT_SCP_AGENT_CONFIG_DIR );
	File localAgentConfig = new File( tmpDir, Constants.KARAF_CFG_FILE_AGENT );
	File remoteAgentConfig = new File( agentConfigDir, Constants.KARAF_CFG_FILE_AGENT );

	// Download remote agent config file...
	ssh.newSCPFileTransfer().download(remoteAgentConfig.getCanonicalPath(), new FileSystemFile(tmpDir));

	// Replace "parameters" property to point on the user data file...
	String config = Utils.readFileContent(localAgentConfig);
	config = Utils.updateProperties( config, keyToNewValue );
	Utils.writeStringInto(config, localAgentConfig);

	// Then upload agent config file back
	ssh.newSCPFileTransfer().upload(new FileSystemFile(localAgentConfig), agentConfigDir);
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
public File getTempLocalInstance( String remoteFilePath )
{
  File tempFile = null;
  SSHClient client = new SSHClient();
  // required if host is not in knownLocalHosts
  client.addHostKeyVerifier(new PromiscuousVerifier());

  try {
    client.connect(hostName);
    client.authPassword(userName, userPass);

    tempFile = File.createTempFile("tmp", null, null);
    tempFile.deleteOnExit();

    SFTPClient sftp = client.newSFTPClient();
    sftp.get(remoteFilePath, new FileSystemFile(tempFile));
    sftp.close();
    client.disconnect();

  } catch( Exception e ) { 
    //TODO: this needs to be more robust than just catching all exceptions
    e.printStackTrace();
    logger.error( e.toString() );
    return null;
  } 
  
  return tempFile;
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
@Override
public void download(final String source, final File destination) throws IOException {

    final SFTPClient sftp = ssh.newSFTPClient();
    LOGGER.debug("downloading {} from host {} to {}", source, getName(), destination);
    sftp.get(source, new FileSystemFile(destination));
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
private void upload(final SFTPClient sftp, final File file, final String destination) throws IOException {

        final String path = FilenameUtils.getFullPath(destination);
        LOGGER.debug("path to make on remote {}", path);
        sftp.mkdirs(path);
        sftp.put(new FileSystemFile(file), destination);
    }
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
public void sendFile(String lfile, String rfile) throws Exception {
	final SSHClient ssh = getConnectedClient();

	try {
		final Session session = ssh.startSession();
		try {
			ssh.newSCPFileTransfer().upload(new FileSystemFile(lfile), rfile);
		} finally {
			session.close();
		}
	} finally {
		ssh.disconnect();
		ssh.close();
	}
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
@Test
public void testUpload_1() throws Exception {
	when(client.newSCPFileTransfer()).thenReturn(scpTransfer);
	
	ssh.upload("127.0.1.1", "username", "password", "file", "/tmp");
	
	verify(client, times(1)).connect("127.0.1.1");
	verify(client, times(1)).authPassword("username", "password".toCharArray());
	verify(client, times(1)).newSCPFileTransfer();
	verify(scpTransfer, times(1)).upload(new FileSystemFile(new File("file")), "/tmp");
	
	verify(client, times(1)).disconnect();
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
@Test
public void testDownload_1() throws Exception {
	when(client.newSCPFileTransfer()).thenReturn(scpTransfer);
	
	ssh.download("127.0.1.1", "username", "password", "/var/log", "download");
	
	verify(client, times(1)).connect("127.0.1.1");
	verify(client, times(1)).authPassword("username", "password".toCharArray());
	verify(client, times(1)).newSCPFileTransfer();
	verify(scpTransfer, times(1)).download("/var/log", new FileSystemFile(new File("download")));
	
	verify(client, times(1)).disconnect();
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
Map<String,String> prepareConfiguration( TargetHandlerParameters parameters, SSHClient ssh, File tmpDir )
throws IOException {

	// Generate local user-data file
	String userData = UserDataHelpers.writeUserDataAsString(
			parameters.getMessagingProperties(),
			parameters.getDomain(),
			parameters.getApplicationName(),
			parameters.getScopedInstancePath());

	File userdataFile = new File(tmpDir, USER_DATA_FILE);
	Utils.writeStringInto(userData, userdataFile);

	// Then upload it
	this.logger.fine( "Uploading user data as a file..." );
	String agentConfigDir = Utils.getValue( parameters.getTargetProperties(), SCP_AGENT_CONFIG_DIR, DEFAULT_SCP_AGENT_CONFIG_DIR );
	ssh.newSCPFileTransfer().upload( new FileSystemFile(userdataFile), agentConfigDir);

	// Update the agent's configuration file
	Map<String,String> keyToNewValue = new HashMap<> ();
	File remoteAgentConfig = new File(agentConfigDir, userdataFile.getName());

	// Reset all the fields
	keyToNewValue.put( AGENT_APPLICATION_NAME, "" );
	keyToNewValue.put( AGENT_SCOPED_INSTANCE_PATH, "" );
	keyToNewValue.put( AGENT_DOMAIN, "" );

	// The location of the parameters must be an URL
	keyToNewValue.put( AGENT_PARAMETERS, remoteAgentConfig.toURI().toURL().toString());

	return keyToNewValue;
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
@Override
public void download(String remotePath, Path local) throws IOException {
    try (SFTPClient sftpClient = sshClient.newSFTPClient()) {
        sftpClient.get(remotePath, new FileSystemFile(local.toFile()));
    }
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
@Override
public void upload(Path local, String remotePath) throws IOException {
    try (SFTPClient sFTPClient = sshClient.newSFTPClient()) {
        sFTPClient.put(new FileSystemFile(local.toFile()), remotePath);
    }
}
 

import net.schmizz.sshj.xfer.FileSystemFile; //导入依赖的package包/类
@Test
public void testUpdateAgentConfigurationFile() throws Exception {

	// Prepare the mocks
	File tmpDir = this.folder.newFolder();
	File agentConfigurationFile = new File( tmpDir, Constants.KARAF_CFG_FILE_AGENT );

	Properties props = new Properties();
	props.setProperty( "a0", "c0" );
	props.setProperty( "a1", "c213" );
	props.setProperty( "a2", "c2" );
	props.setProperty( "a3", "c3" );
	props.setProperty( "a4", "c4" );
	props.setProperty( "a5", "c5" );
	Utils.writePropertiesFile( props, agentConfigurationFile );

	TargetHandlerParameters parameters = new TargetHandlerParameters()
			.targetProperties( new HashMap<String,String>( 0 ));

	final Map<String,String> keyToNewValue = new HashMap<> ();
	keyToNewValue.put( "a1", "b1" );
	keyToNewValue.put( "a2", "b2" );
	keyToNewValue.put( "a3", "b3" );

	SSHClient ssh = Mockito.mock( SSHClient.class );
	SCPFileTransfer scp = Mockito.mock( SCPFileTransfer.class );
	Mockito.when( ssh.newSCPFileTransfer()).thenReturn( scp );

	// Invoke the method
	EmbeddedHandler embedded = new EmbeddedHandler();
	embedded.karafData = this.folder.newFolder().getAbsolutePath();
	ConfiguratorOnCreation configurator = new ConfiguratorOnCreation( parameters, "ip", "machineId", embedded );
	configurator.updateAgentConfigurationFile( parameters, ssh, tmpDir, keyToNewValue );

	// Verify
	ArgumentCaptor<String> remotePathCaptor = ArgumentCaptor.forClass( String.class );
	ArgumentCaptor<FileSystemFile> fileCaptor = ArgumentCaptor.forClass( FileSystemFile.class );
	Mockito.verify( scp ).download( remotePathCaptor.capture(), fileCaptor.capture());

	Assert.assertEquals( tmpDir, fileCaptor.getValue().getFile());
	Assert.assertEquals(
			new File( DEFAULT_SCP_AGENT_CONFIG_DIR, Constants.KARAF_CFG_FILE_AGENT ).getAbsolutePath(),
			remotePathCaptor.getValue());

	// 1st: we upload the user data
	// 2nd: we reupload the same file than the one we downloaded
	ArgumentCaptor<String> remotePathCaptor2 = ArgumentCaptor.forClass( String.class );
	ArgumentCaptor<FileSystemFile> fileCaptor2 = ArgumentCaptor.forClass( FileSystemFile.class );
	Mockito.verify( scp ).upload( fileCaptor2.capture(), remotePathCaptor2.capture());

	Assert.assertEquals( agentConfigurationFile.getAbsolutePath(), fileCaptor2.getValue().getFile().getAbsolutePath());
	Assert.assertEquals( DEFAULT_SCP_AGENT_CONFIG_DIR, remotePathCaptor2.getValue());

	// And no additional call
	Mockito.verifyNoMoreInteractions( scp );
	Mockito.verify( ssh, Mockito.times( 2 )).newSCPFileTransfer();
	Mockito.verifyNoMoreInteractions( ssh );

	// Verify the properties were correctly updated in the file
	Properties readProps = Utils.readPropertiesFile( agentConfigurationFile );
	Assert.assertEquals( "c0", readProps.get( "a0" ));
	Assert.assertEquals( "b1", readProps.get( "a1" ));
	Assert.assertEquals( "b2", readProps.get( "a2" ));
	Assert.assertEquals( "b3", readProps.get( "a3" ));
	Assert.assertEquals( "c4", readProps.get( "a4" ));
	Assert.assertEquals( "c5", readProps.get( "a5" ));
	Assert.assertEquals( props.size(), readProps.size());

	// Prevent a compilation warning about leaks
	configurator.close();
}