Uncategorized – andreINC

Recursive folder walks using NIO.2 API

December 6, 2013October 4, 2016 Andrei Ciobanu Leave a comment

FileVisitor Interface

The FileVisitor interface allows us to recursively traverse file structures – folders, sub-folders and files.

Every method of this interface can return 4 possible results (instances of the FileVisitResult enum):

FileVisitResult.CONTINUE: This means that the traversal process will continue.
FileVisitResult.SKIP_SIBLINGS: This means that the traversal process will continue without visiting the siblings (files or folders) of that particular Path
FileVisitResult.SKIP_SUBTREE: This means that the traversal process will continue without visiting the rest of the tree entries.
FileVisitResult.TERMINATE: This means that the traversal process should stop.

This FileVisitor interface has 4 methods:

visitFile():
The method is invoked for a file. The method should return a FileVisitResult.CONTINUE result or a FileVisitResult.TERMINATE result. The method receive a reference to the file (a Path object) and to the BasicFileAttributes object associated with the Path.
preVisitDirectory():
This method is invoked for a directory before visiting its children. The method returns FileVisitResult.CONTINUE if we want it’s children to be visited or FileVisitResult.SKIP_SUBTREE if we want the process to stop. If we want to skip visiting the siblings of the directory we need to return FileVisitResult.SKIP_SIBLINGS .
postVisitDirectory():
This method is invoked after we visit all the children of a directory (including other folders and their descendants).
visitFileFailed():
This method is invoked if a file (or folder) cannot be accessed.

In practice it is also possible to use the SimpleFileVisitor class if we want to traverse only the directories.

Once we have created the “recursive-walking-mechanism” by implementing FileVisitor interface or by extending the SimpleFileVisitor class we can start the recursive process by calling the walkFileTree() method .

Example: Writing an application that search for files bigger than a pre-defined size

In this example we are going to implement a FileVisitor that walks a folder and logs to output all files that are bigger than certain amount.

The first step is to write the FileVisitor:

/**
 * This FileVisitor searches for files bigger than 'size' .
 * 
 * If a file matching our criteria is found, we log the results in the stdout .
 * 
 * @author AndreICiobanu
 * 
 */
class FileSizeVisitor implements FileVisitor<Path> {

	private Long size;

	public FileSizeVisitor(Long size) {
		this.size = size;
	}

	/**
	 * This is triggered before visiting a directory.
	 */
	@Override
	public FileVisitResult preVisitDirectory(Path path,
			BasicFileAttributes attrs) throws IOException {
		return FileVisitResult.CONTINUE;
	}

	/**
	 * This is triggered when we visit a file.
	 */
	@Override
	public FileVisitResult visitFile(Path path, BasicFileAttributes attrs)
			throws IOException {

		long fileSize = attrs.size() / 1024;

		if (fileSize >= this.size) {
			System.out.println("File bigger than " + this.size + "KB  found: "
					+ path);
		}

		return FileVisitResult.CONTINUE;
	}

	/**
	 * This is triggered if we cannot visit a Path We log the fact we cannot
	 * visit a specified path .
	 */
	@Override
	public FileVisitResult visitFileFailed(Path path, IOException exc)
			throws IOException {
		// We print the error
		System.err.println("ERROR: Cannot visit path: " + path);
		// We continue the folder walk
		return FileVisitResult.CONTINUE;
	}

	/**
	 * This is triggered after we finish visiting a specified folder.
	 */
	@Override
	public FileVisitResult postVisitDirectory(Path path, IOException exc)
			throws IOException {
		// We continue the folder walk
		return FileVisitResult.CONTINUE;
	}

}

/**

* This FileVisitor searches for files bigger than 'size' .

* If a file matching our criteria is found, we log the results in the stdout .

* @author AndreICiobanu

class FileSizeVisitor implements FileVisitor<Path> {

private Long size;

public FileSizeVisitor(Long size) {

this.size = size;

}

/**

* This is triggered before visiting a directory.

@Override

public FileVisitResult preVisitDirectory(Path path,

BasicFileAttributes attrs) throws IOException {

return FileVisitResult.CONTINUE;

}

/**

* This is triggered when we visit a file.

@Override

public FileVisitResult visitFile(Path path, BasicFileAttributes attrs)

throws IOException {

long fileSize = attrs.size() / 1024;

if (fileSize >= this.size) {

System.out.println("File bigger than " + this.size + "KB found: "

+ path);

}

return FileVisitResult.CONTINUE;

}

/**

* This is triggered if we cannot visit a Path We log the fact we cannot

* visit a specified path .

@Override

public FileVisitResult visitFileFailed(Path path, IOException exc)

throws IOException {

// We print the error

System.err.println("ERROR: Cannot visit path: " + path);

// We continue the folder walk

return FileVisitResult.CONTINUE;

}

/**

* This is triggered after we finish visiting a specified folder.

@Override

public FileVisitResult postVisitDirectory(Path path, IOException exc)

throws IOException {

// We continue the folder walk

return FileVisitResult.CONTINUE;

}

The main method:

Path homeFolder = Paths.get("C:\\");
FileVisitor fileVisitor = new FileSizeVisitor(new Long(5000));
try {
	Files.walkFileTree(homeFolder, fileVisitor);
} catch (IOException e) {
	e.printStackTrace();
}

Path homeFolder = Paths.get("C:\\");

FileVisitor fileVisitor = new FileSizeVisitor(new Long(5000));

try {

Files.walkFileTree(homeFolder, fileVisitor);

} catch (IOException e) {

e.printStackTrace();

}

And some sample output from my machine:

...
File bigger than 5000  found: C:\Windows\System32\IME\imekr8\applets\mshwkorrIME.dll
File bigger than 5000  found: C:\Windows\System32\IME\IMETC10\applets\MSHWCHTRIME.dll
File bigger than 5000  found: C:\Windows\System32\korwbrkr.lex
ERROR: Cannot visit path: C:\Windows\System32\LogFiles\WMI\RtBackup
...

...

File bigger than 5000 found: C:\Windows\System32\IME\imekr8\applets\mshwkorrIME.dll

File bigger than 5000 found: C:\Windows\System32\IME\IMETC10\applets\MSHWCHTRIME.dll

File bigger than 5000 found: C:\Windows\System32\korwbrkr.lex

ERROR: Cannot visit path: C:\Windows\System32\LogFiles\WMI\RtBackup

...

Writing a file search application based on a criteria

We can extend the example from above and create a more general approach.

The idea is to write an abstract implementation of the FileVisitor interface, that contains an abstract method “criteria(Path, BasicFileAttributes)“.

Later we can use anonymous classes to define a new behavior of our visitors specifying only the criteria and avoiding to write the boiler-plate-code necessary to implement a FileVisitor.

We will name our FileVisitor implementation FileSearchByCriteriaVisitor:

abstract class FileSearchByCriteriaVisitor implements FileVisitor<Path>

1	abstract class FileSearchByCriteriaVisitor implements FileVisitor<Path>

This class will have two instance variables called results and failedVisits:

private List<Path> results = new LinkedList<Path>();
private List<Path> failedVisits = new LinkedList<Path>();
public List<Path> getResults() {
	return this.results;
}
public List<Path> getFailedVisits() {
	return this.failedVisits;
}

private List<Path> results = new LinkedList<Path>();

private List<Path> failedVisits = new LinkedList<Path>();

public List<Path> getResults() {

return this.results;

}

public List<Path> getFailedVisits() {

return this.failedVisits;

}

The “criteria(Path, BasicFileAttributes)” mentioned before will be used like this:

// This method will be later implemented
protected abstract Boolean criteria(Path path, BasicFileAttributes attrs);
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
		throws IOException {
	// Everytime we visit a file we check if that particular file matches a
	// criteria .
	if (criteria(file, attrs)) {
		// If the file matches the criteria we add it as a result
		results.add(file);
	}
	return FileVisitResult.CONTINUE;
}

// This method will be later implemented

protected abstract Boolean criteria(Path path, BasicFileAttributes attrs);

@Override

public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)

throws IOException {

// Everytime we visit a file we check if that particular file matches a

// criteria .

if (criteria(file, attrs)) {

// If the file matches the criteria we add it as a result

results.add(file);

}

return FileVisitResult.CONTINUE;

}

Now everytime we implement a new FileSearchByCriteriaVisitor we must supply an implementation for the abstract method defined before.

Example how to use the FileSearchByCriteriaVisitor:

// Search all the files bigger than size
final long size = 5000; // KB
// Defining a new visitor criteria
FileSearchByCriteriaVisitor sizeVisitor = new FileSearchByCriteriaVisitor() {
	@Override
	protected Boolean criteria(Path path, BasicFileAttributes attrs) {
		if (attrs.size() / 1024 >= size) {
			return true;
		}
		return false;
	}
};
// Walk don't run
Files.walkFileTree(Paths.get("C:\\"), sizeVisitor);
// Evaluate results
evaluate(sizeVisitor.getResults());

// Search all the files bigger than size

final long size = 5000; // KB

// Defining a new visitor criteria

FileSearchByCriteriaVisitor sizeVisitor = new FileSearchByCriteriaVisitor() {

@Override

protected Boolean criteria(Path path, BasicFileAttributes attrs) {

if (attrs.size() / 1024 >= size) {

return true;

}

return false;

}

};

// Walk don't run

Files.walkFileTree(Paths.get("C:\\"), sizeVisitor);

// Evaluate results

evaluate(sizeVisitor.getResults());

The results and the paths with errors are available in “sizeVisitor.getResults()” and “sizeVisitor.getFailedVisits()”.

File Attributes int the NIO.2 API

December 5, 2013October 10, 2016 Andrei Ciobanu 1 Comment

Introduction

With NIO.2 we can easily determine the attributes of a file by using the java.nio.file.attribute package.

Various file systems have different properties associated with files but NIO.2 groups the attributes into views, each view is specific to a particular file system implementation.

NIO.2 comes with a set of views:

BasicFileAttributeView: This view contains a set of common attributes supported by all filesystem implementations. The inner name of the attribute view is ‘basic’.
DosFileAttributeView: This view contains a set of attributes specific to filesystems that implement DOS attributes. The inner name of the attribute view is ‘dos’.
PosixFileAttributeView: This view contains a set of attributes specific to file systems that support the POSIX standards. The inner name of the attribute view is ‘posix’.
AclFileAttributeView: This view is supported by all filesystems implementations that have the concept of ACL. The inner name of the attribute is ‘acl’.
FileOwnerAttributeView: This view is supported by all filesystems implementations that have the concept of “ownership” over a file. The inner name of the attribute is ‘owner’.
UserDefinedFileAttributeView

How do we determine what are the views supported by our filesystem ?

import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.util.Set;

public class MainClass {

	public static void main(String argv[]) {
		// Retrieves the default file system
		FileSystem fileSystem = FileSystems.getDefault();
		Set<String> fileSystemViews = fileSystem.supportedFileAttributeViews();

		// We iterate over the available file attribute views
		// of a file system
		for (String fileSystemView : fileSystemViews) {
			System.out.println(fileSystemView);
		}
	}
}

import java.nio.file.FileSystem;

import java.nio.file.FileSystems;

import java.util.Set;

public class MainClass {

public static void main(String argv[]) {

// Retrieves the default file system

FileSystem fileSystem = FileSystems.getDefault();

Set<String> fileSystemViews = fileSystem.supportedFileAttributeViews();

// We iterate over the available file attribute views

// of a file system

for (String fileSystemView : fileSystemViews) {

System.out.println(fileSystemView);

}

Output (I am using a Windows 7 machine):

acl
basic
owner
user
dos

acl

basic

owner

user

dos

Everytime we want to access the view attributes of a file/folder, it is advisable to check if the file system supports the particular view. NIO.2 allows us to test this using the FileSystem.supportedFileAttributeViews() method .

Eg.:

package mainpack;

import java.nio.file.FileStore;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.attribute.AclFileAttributeView;
import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.DosFileAttributeView;
import java.nio.file.attribute.FileOwnerAttributeView;
import java.nio.file.attribute.PosixFileAttributeView;

public class MainClass {

	public static void main(String argv[]) {
		// Retrieves the default file system
		FileSystem fileSystem = FileSystems.getDefault();
		Iterable<FileStore> fileStores = fileSystem.getFileStores();

		for (FileStore fileStore : fileStores) {
			// Test if it supports BasicFileAttributeView
			System.out.println(String.format(
				"Filestore %s supports (%s) : %s",
				fileStore,
				BasicFileAttributeView.class.getSimpleName(),
				fileStore.supportsFileAttributeView(BasicFileAttributeView.class)));
			
			// Test if supports DosFileAttributeView
			System.out.println(String.format(
				"Filestore %s supports (%s) : %s",
				fileStore,
				DosFileAttributeView.class.getSimpleName(),
				fileStore.supportsFileAttributeView(DosFileAttributeView.class)));
			
			// Test if supports PosixFileAttributeView
			System.out.println(String.format(
				"Filestore %s supports (%s) : %s",
				fileStore,
				PosixFileAttributeView.class.getSimpleName(),
				fileStore.supportsFileAttributeView(PosixFileAttributeView.class)));
			
			// Test if supports AclFileAttributeView
			System.out.println(String.format(
				"Filestore %s supports (%s) : %s",
				fileStore,
				AclFileAttributeView.class.getSimpleName(),
				fileStore.supportsFileAttributeView(AclFileAttributeView.class)));
			
			// Test if supports FileOwnerAttributeView
			System.out.println(String.format(
				"Filestore %s supports (%s) : %s",
				fileStore,
				FileOwnerAttributeView.class.getSimpleName(),
				fileStore.supportsFileAttributeView(FileOwnerAttributeView.class)));
			
			System.out.println();
		}
	}
}

package mainpack;

import java.nio.file.FileStore;

import java.nio.file.FileSystem;

import java.nio.file.FileSystems;

import java.nio.file.attribute.AclFileAttributeView;

import java.nio.file.attribute.BasicFileAttributeView;

import java.nio.file.attribute.DosFileAttributeView;

import java.nio.file.attribute.FileOwnerAttributeView;

import java.nio.file.attribute.PosixFileAttributeView;

public class MainClass {

public static void main(String argv[]) {

// Retrieves the default file system

FileSystem fileSystem = FileSystems.getDefault();

Iterable<FileStore> fileStores = fileSystem.getFileStores();

for (FileStore fileStore : fileStores) {

// Test if it supports BasicFileAttributeView