import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的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.sftp.SFTPClient; //导入依赖的package包/类
private void transferEvents(SSHClient sshClient, List<MotionEvent> motionEvents) throws IOException, ParseException {
    for (MotionEvent motionEvent : motionEvents) {
        ByteArraySourceFile byteArraySourceFile = new ByteArraySourceFile.Builder()
                .fileData(motionEvent.getImage())
                .name(motionEvent.getId() + ".jpg")
                .build();
        String day = concurrentDateFormatAccess.convertDateToString(motionEvent.getTimestamp());
        SFTPClient sftpClient = sshClient.newSFTPClient();
        String destinationPath = eyeballsConfiguration.getSftpDestinationDirectory() + "/" + day + "/";
        sftpClient.mkdirs(destinationPath);
        sftpClient.put(byteArraySourceFile, destinationPath);
    }
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
public long lastModified() throws MalformedURLException, SmbException {
    switch (mode) {
        case SFTP:
            SshClientUtils.execute(new SFtpClientTemplate(path) {
                @Override
                public Long execute(SFTPClient client) throws IOException {
                    return client.mtime(SshClientUtils.extractRemotePathFrom(path));
                }
            });
            break;
        case SMB:
            SmbFile smbFile = getSmbFile();
            if (smbFile != null)
                return smbFile.lastModified();
            break;
        case FILE:
            new File(path).lastModified();
            break;
        case ROOT:
            HybridFileParcelable baseFile = generateBaseFileFromParent();
            if (baseFile != null)
                return baseFile.getDate();
    }
    return new File("/").lastModified();
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的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.sftp.SFTPClient; //导入依赖的package包/类
@Test
public void copyFilesFromLocalDiskShouldRunSCPAndToCorrectDirectory() throws IOException {
  SCPFileTransfer mockSCPFileTransfer = mock(SCPFileTransfer.class);
  when(mMockSSHClient.newSCPFileTransfer()).thenReturn(mockSCPFileTransfer);
  SFTPClient mockSFTP = mock(SFTPClient.class);
  when(mMockSSHClient.newSFTPClient()).thenReturn(mockSFTP);

  Path from = FileSystems.getDefault().getPath(".");
  String to = "foo";

  mSSHEnv.copyFilesFromLocalDisk(from, to);

  verify(mMockSSHClient).newSCPFileTransfer();
  String expectedDestination = FilenameUtils.concat(REMOTE_HOME_PATH, to);
  verify(mockSCPFileTransfer).upload(any(LocalSourceFile.class), eq(expectedDestination));
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的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.sftp.SFTPClient; //导入依赖的package包/类
@Override
public void upload(final File source, final String destination) throws IOException {

    final char separator = platform.getSeparator();
    final String destination_path;
    if (destination.endsWith(String.valueOf(separator))) {
        destination_path = SimplePlatform.addTailingSeparator(separator, destination);
    }
    else {
        destination_path = destination;
    }
    final SFTPClient sftp = ssh.newSFTPClient();
    LOGGER.debug("Uploading {} to {} on host {} ", source, destination, getName());
    upload(sftp, source, destination_path);
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的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.sftp.SFTPClient; //导入依赖的package包/类
private List<String> listChildrenNamesByFilter(String remotePath, RemoteResourceFilter remoteFolderResourceFilter) throws IOException {
    try (SFTPClient sftpClient = sshClient.newSFTPClient()) {
        List<String> children = new ArrayList<>();
        List<RemoteResourceInfo> childrenInfos = sftpClient.ls(remotePath, remoteFolderResourceFilter);
        childrenInfos.stream().forEach((childInfo) -> {
            children.add(childInfo.getName());
        });
        return children;
    }
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
@Test
public void listFiles() throws IOException, NoSuchProviderException, NoSuchAlgorithmException {
  sftpHome.newFile("fred.txt");
  List<RemoteResourceInfo> files;

  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 {
      files = sftp.ls("/");
    } finally {
      sftp.close();
    }
  } finally {
    ssh.disconnect();
  }

  assertThat(files.size(), is(1));
  assertThat(files.get(0).getName(), is("fred.txt"));
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
@Override
protected Set<FileInfo> listFilesUsingNativeSystem(LogAccessConfig logAccessConfig, String subPath) throws LogAccessException {
	
	// Get ssh client
	SSHClient sshClient = sshClientThreadLocal.get();

	// Define target directory
	String targetPath = logAccessConfig.getDirectory();
	if (subPath != null) {
		targetPath += "/" + subPath;
	}

	// List files and directories (keep only the 'fileListMaxCount' last modified resources)
	SFTPClient sftpClient = null;
	Collection<RemoteResourceInfo> remoteResourceInfos;
	try {
		sftpClient = sshClient.newSFTPClient();
		LastUpdatedRemoteResourceFilter remoteResourcefilter = new LastUpdatedRemoteResourceFilter(configService.getFileListMaxCount());
		sftpClient.ls(targetPath, remoteResourcefilter);
		remoteResourceInfos = remoteResourcefilter.getRemoteResourceInfos();
	}
	catch (IOException e) {
		throw new LogAccessException("Error when listing files and directories on " + logAccessConfig, e);
	}
	finally {
		IOUtils.closeQuietly(sftpClient, sshClient);
	}
	
	// Extract meta-informations
	Set<FileInfo> fileInfos = new TreeSet<FileInfo>();
	for (RemoteResourceInfo remoteResourceInfo : remoteResourceInfos) {
		FileInfo fileInfo = new FileInfo();
		fileInfo.setFileName(remoteResourceInfo.getName());
		fileInfo.setRelativePath(remoteResourceInfo.getPath().substring(logAccessConfig.getDirectory().length() + 1).replace('\\', '/'));
		fileInfo.setDirectory(remoteResourceInfo.isDirectory());
		fileInfo.setLastModified(new Date(remoteResourceInfo.getAttributes().getMtime() * 1000L));
		fileInfo.setFileSize(remoteResourceInfo.isDirectory() ? 0L : remoteResourceInfo.getAttributes().getSize());
		fileInfo.setLogAccessType(LogAccessType.SSH);
		fileInfos.add(fileInfo);
	}
	
	// Return meta-informations about files and folders
	return fileInfos;
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
/**
 * Create directories in environment if they don't exist. If directoryPath consists of several
 * directories all required parent directories are created as well.
 *
 * @param directoryPath path to create
 */
public void mkdirs(String directoryPath) throws IOException {
  LOGGER.trace("mkdirs({})", directoryPath);
  String finalDirectoryPath = concatenatePathToHome(directoryPath);
  FilenameUtils.normalize(finalDirectoryPath, true);
  if (!finalDirectoryPath.startsWith("/")) {
    // SFTP mkdirs requires to a dot for relative path, otherwise it assumes given path is
    // absolute.
    finalDirectoryPath = "./" + finalDirectoryPath;
  }

  SSHClient ssh = connectWithSSH();
  try {
    try {
      try (SFTPClient sftp = ssh.newSFTPClient()) {
        sftp.mkdirs(finalDirectoryPath);
      }
    } catch (IOException e) {
      // SFTP has failed (on some systems it may be just disabled) revert to mkdir.
      List<String> command = new ArrayList<>();
      command.add("mkdir");
      command.add("-p");
      command.add(finalDirectoryPath);
      String sshHomeDir = ".";
      int exitStatus = runCommand(command, ssh, sshHomeDir);
      if (exitStatus != 0) {
        throw new IOException("Could not create suggested directories.");
      }
    }
  } finally {
    ssh.disconnect();
  }
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
@Test(expected = IOException.class)
public void copyFilesShouldThrowExceptionWhenSCPFails() throws IOException {
  SCPFileTransfer mockSCPFileTransfer = mock(SCPFileTransfer.class);
  when(mMockSSHClient.newSCPFileTransfer()).thenReturn(mockSCPFileTransfer);
  SFTPClient mockSFTP = mock(SFTPClient.class);
  when(mMockSSHClient.newSFTPClient()).thenReturn(mockSFTP);
  doThrow(new IOException()).when(mockSCPFileTransfer).upload(
      any(LocalSourceFile.class), anyString());

  Path from = FileSystems.getDefault().getPath(".");
  String to = "foo";

  mSSHEnv.copyFilesFromLocalDisk(from, to);
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
@Test(expected = IllegalArgumentException.class)
public void copyFilesShouldThrowExceptionWhenDestinationIsIncorrect() throws IOException {
  SCPFileTransfer mockSCPFileTransfer = mock(SCPFileTransfer.class);
  when(mMockSSHClient.newSCPFileTransfer()).thenReturn(mockSCPFileTransfer);
  SFTPClient mockSFTP = mock(SFTPClient.class);
  when(mMockSSHClient.newSFTPClient()).thenReturn(mockSFTP);

  Path from = FileSystems.getDefault().getPath(".");
  String to = "../../..";

  mSSHEnv.copyFilesFromLocalDisk(from, to);
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
@Test
public void mkdirsShouldUseSFTPFirstAndDestinationPathShouldContainDot() throws IOException {
  SFTPClient mockSFTP = mock(SFTPClient.class);
  when(mMockSSHClient.newSFTPClient()).thenReturn(mockSFTP);
  mSSHEnv.mkdirs("mock");

  String properDestinationPath = "./" + FilenameUtils.concat(REMOTE_HOME_PATH, "mock");
  verify(mockSFTP).mkdirs(eq(properDestinationPath));
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
@Test
public void mkdirsShouldUseDirectCommandOnSFTPFailure() throws IOException {
  SFTPClient mockSFTP = mock(SFTPClient.class);
  when(mMockSSHClient.newSFTPClient()).thenThrow(new IOException());
  doThrow(new IOException()).when(mockSFTP).mkdirs(anyString());
  Session mockSession = mock(Session.class);
  when(mMockSSHClient.startSession()).thenReturn(mockSession);
  Command mockCommand = mock(Command.class);
  when(mockSession.exec(anyString())).thenReturn(mockCommand);
  mSSHEnv.mkdirs("mock");
  verify(mockSession).exec(contains("mkdir -p"));
  verify(mockSession).exec(contains(FilenameUtils.concat(REMOTE_HOME_PATH, "mock")));
  verify(mockCommand).join();
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
@Test
public void mkdirsShouldUseDirectCommandOnSFTPFailure2() throws IOException {
  SFTPClient mockSFTP = mock(SFTPClient.class);
  when(mMockSSHClient.newSFTPClient()).thenReturn(mockSFTP);
  doThrow(new IOException()).when(mockSFTP).mkdirs(anyString());
  Session mockSession = mock(Session.class);
  when(mMockSSHClient.startSession()).thenReturn(mockSession);
  Command mockCommand = mock(Command.class);
  when(mockSession.exec(anyString())).thenReturn(mockCommand);
  mSSHEnv.mkdirs("mock");
  verify(mockSession).exec(contains("mkdir -p"));
  verify(mockCommand).join();
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
@Test(expected = IOException.class)
public void mkdirsShouldThrowExceptionOnDirectCommandFailure() throws IOException {
  SFTPClient mockSFTP = mock(SFTPClient.class);
  when(mMockSSHClient.newSFTPClient()).thenReturn(mockSFTP);
  doThrow(new IOException()).when(mockSFTP).mkdirs(anyString());
  Session mockSession = mock(Session.class);
  when(mMockSSHClient.startSession()).thenReturn(mockSession);
  Command mockCommand = mock(Command.class);
  when(mockSession.exec(anyString())).thenReturn(mockCommand);
  when(mockCommand.getExitStatus()).thenReturn(-1);
  mSSHEnv.mkdirs("mock");
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
/**
 * @deprecated use {@link #length(Context)} to handle content resolvers
 * @return
 */
public long length() {
    long s = 0L;
    switch (mode) {
        case SFTP:
            return SshClientUtils.execute(new SFtpClientTemplate(path) {
                @Override
                public Long execute(SFTPClient client) throws IOException {
                    return client.size(SshClientUtils.extractRemotePathFrom(path));
                }
            });
        case SMB:
            SmbFile smbFile = getSmbFile();
            if (smbFile != null)
                try {
                    s = smbFile.length();
                } catch (SmbException e) {
                }
            return s;
        case FILE:
            s = new File(path).length();
            return s;
        case ROOT:
            HybridFileParcelable baseFile = generateBaseFileFromParent();
            if (baseFile != null) return baseFile.getSize();
            break;
    }
    return s;
}
 

import net.schmizz.sshj.sftp.SFTPClient; //导入依赖的package包/类
/**
 * @deprecated use {@link #folderSize(Context)}
 * @return
 */
public long folderSize() {
    long size = 0L;

    switch (mode) {
        case SFTP:
            return SshClientUtils.execute(new SFtpClientTemplate(path, false) {
                @Override
                public Long execute(SFTPClient client) throws IOException {
                    Long retval = client.size(SshClientUtils.extractRemotePathFrom(path));
                    client.close();
                    return retval;
                }
            });
        case SMB:
            try {
                size = FileUtils.folderSize(new SmbFile(path));
            } catch (MalformedURLException e) {
                size = 0L;
                e.printStackTrace();
            }
            break;
        case FILE:
            size = FileUtils.folderSize(new File(path), null);
            break;
        case ROOT:
            HybridFileParcelable baseFile = generateBaseFileFromParent();
            if (baseFile != null) size = baseFile.getSize();
            break;
        default:
            return 0L;
    }
    return size;
}