Java FileSystemFile类代码示例

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;
}