JAVA: Deleing Symbolic File In Linux&Unix

JAVA: Deleing Symbolic File In Linux&Unix

http://joust.kano.net/weblog/archives/000071.html

Code to safely delete a directory containing symbolic links

Today I had to write code to delete a directory, which, in Java, requires individually deleting all of the files in it as well as its subdirectories and their subdirectories and so on.

It's easy to recursively delete things, but if your code is going to run on a system with symbolic links (Linux, Unix, OSX (?)) you need to be careful. The code I came up with is below:
(This code is released in the public domain. Feel free to use it in your own project.)

public static boolean deleteDir(File dir) {
// to see if this directory is actually a symbolic link to a directory,
// we want to get its canonical path - that is, we follow the link to
// the file it's actually linked to
File candir;
try {
candir = dir.getCanonicalFile();
} catch (IOException e) {
return false;
}
// a symbolic link has a different canonical path than its actual path,
// unless it's a link to itself
if (!candir.equals(dir.getAbsoluteFile())) {
// this file is a symbolic link, and there's no reason for us to
// follow it, because then we might be deleting something outside of
// the directory we were told to delete
return false;
}
// now we go through all of the files and subdirectories in the
// directory and delete them one by one
File[] files = candir.listFiles();
if (files != null) {
for (int i = 0; i < files.length; i++) {
File file = files[i];
// in case this directory is actually a symbolic link, or it's
// empty, we want to try to delete the link before we try
// anything
boolean deleted = file.delete();
if (!deleted) {
// deleting the file failed, so maybe it's a non-empty
// directory
if (file.isDirectory()) deleteDir(file);
// otherwise, there's nothing else we can do
}
}
}
// now that we tried to clear the directory out, we can try to delete it
// again
return dir.delete();
}

Posted by keith at February 5, 2004 12:08 AM | TrackBack

===================================

http://www.eddie-meyer.com/docs/notes/delete-symbolic-link-from-java.html

Deleting a symbolic link

Given a symbolic link of

	fileA -> fileB

what happens if you try to call file.delete() (the Java 'delete' command) on fileA?

To test what happens, I wrote a test program using Java1.4 on Sun Solaris 8.

Here is the program...

/* Program to test what happens if you try to delete a symbolic
* link from java (running on Solaris)
*
* Command line arguments:
* 		filename - the symbolic link to delete. (target can be a file or a directory.)
*/
import java.io.*;
public class delete
{
public static void main(String args[])
{
if ( args.length <= 0 )
{
System.out.println("You didn't specify the symbolic link to delete.");
System.out.println("Exiting...");
System.exit(1);
}
String link_name = args[0];
System.out.println("Input Details...");
System.out.println("Symbolic Link: "+link_name);
System.out.println("");
delete d = new delete(link_name);
}
/**
* Constructor
*/
public delete(String link_name)
{
if ( ! exists( link_name ) )
{
System.out.println( link_name + " does not exist.");
System.out.println("Exiting...");
System.exit(1);
}
if ( ! isSymbolicLink( link_name ) )
{
System.out.println( link_name + " is not a symbolic link.");
System.out.println("Exiting...");
System.exit(1);
}
if ( delete(link_name) )
{
System.out.println("Java's File.delete() returned OK.");
}
else
{
System.out.println("Java's File.delete() did NOT work OK.");
}
}
private boolean exists(String link_name)
{
File f = new File( link_name );
return f.exists();
}
private boolean isSymbolicLink(String link_name)
{
try
{
File f = new File( link_name );
if ( ! f.getAbsolutePath().equals( f.getCanonicalPath() ) )
{
return true;
}
else
{
return false;
}
}
catch(IOException e)
{
System.out.println("Exception occurred while trying to determine if " + link_name + "is a symbolic link.");
System.out.println("Can't continue, exiting...");
System.exit(1);
return false;
}
}
private boolean delete(String link_name)
{
File f = new File(link_name);
return f.delete();
}
} // end of class.

The result of my tests were that the symbolic link gets removed (whether the symbolic link points to a file or a directory) but the target object was left untouched.

Note: In the above code, I attempted to identify a symbolic link by comparing the file's absolute path to it's canonical path (see the 'isSymbolicLink(...)' method above). This was the method I had seen suggested several times on the web. Since implementing this method, however, I have determined that it is NOT reliable enough and I am not all that happy with it... (see the following thread in the Java secion of the forums area).