import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的package包/类
@Test
public void testAcceptWithLimitNotReached() throws Exception {
	
	// given
	RemoteResourceInfo resource1 = createRemoteResourceInfo(2L);
	RemoteResourceInfo resource2 = createRemoteResourceInfo(1L);
	int resourceMaxCount = 2;
	
	// when
	LastUpdatedRemoteResourceFilter resourceFilter = new LastUpdatedRemoteResourceFilter(resourceMaxCount);
	resourceFilter.accept(resource1);
	resourceFilter.accept(resource2);
	Collection<RemoteResourceInfo> remoteResourceInfos = resourceFilter.getRemoteResourceInfos();
	
	// then
	Assert.assertEquals(2, remoteResourceInfos.size());
	Iterator<RemoteResourceInfo> resourceIterator = remoteResourceInfos.iterator();
	Assert.assertTrue(resource2 == resourceIterator.next());
	Assert.assertTrue(resource1 == resourceIterator.next());
}
 

import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的package包/类
@Test
public void testAcceptWithLimitReached() throws Exception {
	
	// given
	RemoteResourceInfo resource1 = createRemoteResourceInfo(1L);
	RemoteResourceInfo resource2 = createRemoteResourceInfo(2L);
	RemoteResourceInfo resource3 = createRemoteResourceInfo(3L);
	int resourceMaxCount = 2;
	
	// when
	LastUpdatedRemoteResourceFilter resourceFilter = new LastUpdatedRemoteResourceFilter(resourceMaxCount);
	resourceFilter.accept(resource1);
	resourceFilter.accept(resource2);
	resourceFilter.accept(resource3);
	Collection<RemoteResourceInfo> remoteResourceInfos = resourceFilter.getRemoteResourceInfos();
	
	// then
	Assert.assertEquals(2, remoteResourceInfos.size());
	Iterator<RemoteResourceInfo> resourceIterator = remoteResourceInfos.iterator();
	Assert.assertTrue(resource2 == resourceIterator.next());
	Assert.assertTrue(resource3 == resourceIterator.next());
}
 

import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的package包/类
@Test
public void testCompare() throws Exception {
	
	// given
	RemoteResourceInfo resource1 = createRemoteResourceInfo(2L);
	RemoteResourceInfo resource2 = createRemoteResourceInfo(1L);
	int resourceMaxCount = 2;
	
	// when
	LastUpdatedRemoteResourceFilter resourceFilter = new LastUpdatedRemoteResourceFilter(resourceMaxCount);
	int result = resourceFilter.compare(resource1, resource2);
	
	// then
	final int greaterThanReturn = 1;
	Assert.assertEquals(greaterThanReturn, result);
}
 

import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的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.RemoteResourceInfo; //导入依赖的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.RemoteResourceInfo; //导入依赖的package包/类
@Nonnull
private Record getRecord(@Nonnull RemoteResourceInfo info) {
	if (info.getAttributes().getType() == FileMode.Type.SYMLINK) {
		return Unchecked.get(() -> getRecord(info.getPath()));
	}

	long time = info.getAttributes().getMtime() * 1000;
	long size = info.getAttributes().getSize();
	return new Record(uri, RecordPath.from(info.getParent(), info.getName()), time, size, info.isDirectory());
}
 

import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的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.RemoteResourceInfo; //导入依赖的package包/类
/**
 * Stores the resource in remoteResourceInfos set (which is sorted by mtime).
 * Keeps only the 'resourceMaxCount' last modified resources in remoteResourceInfos.
 * Always return false, so that no resource is stored in client list (the real filtered result list is stored in this instance, in 'remoteResourceInfos')
 */
@Override
public boolean accept(RemoteResourceInfo resource) {
	remoteResourceInfos.add(resource);
	if (remoteResourceInfos.size() > resourceMaxCount) {
		remoteResourceInfos.remove(remoteResourceInfos.first());
	}
	return false;
}
 

import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的package包/类
/**
 * Comparator method which sorts by mtime ascending
 */
@Override
public int compare(RemoteResourceInfo o1, RemoteResourceInfo o2) {
	if (o1 == o2) {
		return 0;
	}
	else {
		long diff = o1.getAttributes().getMtime() - o2.getAttributes().getMtime();
		return (diff >= 0) ? 1 : -1;
	}
}
 

import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的package包/类
public ArrayList< String > getFilesInPath( String path ) 
{
  ArrayList< String > ret = new ArrayList< String >();

  SSHClient client = new SSHClient();
  client.addHostKeyVerifier(new PromiscuousVerifier());

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

    SFTPClient sftp                  = client.newSFTPClient();
    List< RemoteResourceInfo > files = sftp.ls( path );
    for( RemoteResourceInfo file: files )
    {
      ret.add( file.getPath() );
    }

    sftp.close();
    client.disconnect();

  } catch( Exception e ) {
    logger.error( e.toString() );
  } 

  return ret;
}
 

import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的package包/类
@Override
public List<String> listChildrenFolderNames(String remotePath) throws IOException {
    return listChildrenNamesByFilter(remotePath, RemoteResourceInfo::isDirectory);
}
 

import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的package包/类
@Override
public List<String> listChildrenFileNames(String remotePath) throws IOException {
    return listChildrenNamesByFilter(remotePath, RemoteResourceInfo::isRegularFile);
}
 

import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的package包/类
public LastUpdatedRemoteResourceFilter(int resourceMaxCount) {
	this.resourceMaxCount = resourceMaxCount;
	this.remoteResourceInfos = new TreeSet<RemoteResourceInfo>(this);
}
 

import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的package包/类
/**
 * Return the 'resourceMaxCount' last modified resources filtered 
 */
public Collection<RemoteResourceInfo> getRemoteResourceInfos() {
	return remoteResourceInfos;
}
 

import net.schmizz.sshj.sftp.RemoteResourceInfo; //导入依赖的package包/类
private RemoteResourceInfo createRemoteResourceInfo(long mtime) {
	PathComponents comps = new PathComponents("parent", "name" + mtime, "/");
	FileAttributes attrs = new FileAttributes(0, 0, 0, 0, null, 0L, mtime, new HashMap<String, String>());
	return new RemoteResourceInfo(comps, attrs);
}