001: /*
002: * BEGIN_HEADER - DO NOT EDIT
003: *
004: * The contents of this file are subject to the terms
005: * of the Common Development and Distribution License
006: * (the "License"). You may not use this file except
007: * in compliance with the License.
008: *
009: * You can obtain a copy of the license at
010: * https://open-esb.dev.java.net/public/CDDLv1.0.html.
011: * See the License for the specific language governing
012: * permissions and limitations under the License.
013: *
014: * When distributing Covered Code, include this CDDL
015: * HEADER in each file and include the License file at
016: * https://open-esb.dev.java.net/public/CDDLv1.0.html.
017: * If applicable add the following below this CDDL HEADER,
018: * with the fields enclosed by brackets "[]" replaced with
019: * your own identifying information: Portions Copyright
020: * [year] [name of copyright owner]
021: */
022:
023: /*
024: * @(#)DirectoryUtil.java
025: * Copyright 2004-2007 Sun Microsystems, Inc. All Rights Reserved.
026: *
027: * END_HEADER - DO NOT EDIT
028: */
029: package com.sun.jbi.management.internal.support;
030:
031: import java.io.File;
032: import java.util.List;
033: import java.util.Arrays;
034: import java.util.ArrayList;
035: import java.util.Iterator;
036: import java.util.regex.Pattern;
037: import java.util.regex.Matcher;
038:
039: /**
040: * Provides utility methods for common file system tasks.
041: *
042: * @author Sun Microsystems, Inc.
043: */
044: public class DirectoryUtil {
045: /**
046: * file that gets created when a directory is not successfully removed
047: */
048: static final String DELETE_ME_FILE = ".DELETE_ME";
049:
050: /**
051: * Deletes directory including the sub directories.
052: *
053: * @param dirName Name of the directory to delete
054: * @throws Exception If failed to delete directory
055: */
056: public static void deleteDir(String dirName) throws Exception {
057: boolean success = true;
058:
059: File dir = new File(dirName);
060:
061: if (dir.isDirectory()) {
062: for (String child : dir.list()) {
063: String absChildName = dirName + File.separator + child;
064: File chldFile = new File(absChildName);
065: if (chldFile.isDirectory()) {
066: deleteDir(absChildName);
067: } else {
068: success = chldFile.delete();
069: }
070:
071: if (!success) {
072: throw new Exception("COULD_NOT_DELETE_FILE");
073: }
074: }
075: }
076:
077: // The directory is now empty so delete it
078: if (!dir.delete()) {
079: throw new Exception("COULD_NOT_DELETE_FILE");
080: }
081: }
082:
083: /** Complements deleteDir, but provides a more comprehensive contract
084: * for removal of a directory. If the deletion fails at any stage
085: * (parent or child), the top-level directory is marked for deletion
086: * at a subsequent time with a .DELETE_ME file.
087: */
088: public static boolean removeDir(String dirName) {
089: boolean success = false;
090:
091: try {
092: deleteDir(dirName);
093: success = true;
094: } catch (Exception ex) {
095: markDir(dirName);
096: }
097:
098: return success;
099: }
100:
101: /** Mark a directory for deletion by adding a .DELETE_ME file */
102: public static void markDir(String dirName) {
103: File dir;
104: File deleteMe;
105:
106: try {
107: dir = new File(dirName);
108:
109: if (dir.isDirectory()) {
110: deleteMe = new File(dir, DELETE_ME_FILE);
111: deleteMe.createNewFile();
112: }
113: } catch (java.io.IOException ioEx) {
114: ioEx.printStackTrace();
115: }
116: }
117:
118: /** Finds all marked child directories of parent and deletes them.
119: */
120: public static void removeMarkedDirs(String root) {
121: ArrayList markedDirs = new ArrayList();
122:
123: findMarkedDirs(new File(root), markedDirs);
124:
125: for (int i = 0; i < markedDirs.size(); i++) {
126: File dir = (File) markedDirs.get(i);
127: try {
128: deleteDir(dir.getAbsolutePath());
129: } catch (Exception ex) {
130: ex.printStackTrace();
131: }
132: }
133: }
134:
135: /**
136: * Util method to get the list of folders.
137: * @param aDir folder name for which contents have to be listed.
138: * @return array of folder names.
139: */
140: public static String[] getFolderNameListing(File aDir) {
141: ArrayList<String> folderList = new ArrayList<String>();
142:
143: if (aDir == null || !aDir.isDirectory()) {
144: return null;
145: }
146:
147: for (File file : aDir.listFiles()) {
148: if (file.isDirectory()) {
149: folderList.add(file.getName());
150: }
151: }
152:
153: return folderList.toArray(new String[] {});
154: }
155:
156: /** Determies if a given directory has been marked for deletion.
157: */
158: public static boolean isMarked(File dir) {
159: File[] files;
160: boolean isMarked = false;
161:
162: if (dir == null || !dir.isDirectory()) {
163: return false;
164: }
165:
166: files = dir.listFiles();
167: for (int i = 0; i < files.length; i++) {
168: if (files[i].isFile()
169: && files[i].getName().equals(DELETE_ME_FILE)) {
170: isMarked = true;
171: break;
172: }
173: }
174:
175: return isMarked;
176: }
177:
178: /** Returns a list of files within the specified directory that start with
179: * the specified prefix.
180: */
181: public static File[] listFiles(File root, Pattern prefix) {
182: return root.listFiles(new FilePrefixFilter(prefix));
183: }
184:
185: /** Adds all marked directories found underneath root to the list.
186: */
187: private static void findMarkedDirs(File root, List markedDirs) {
188: File[] children;
189:
190: // If the root directory is marked for deletion, no need to traverse
191: // it's children (they will be deleted too)
192: if (isMarked(root)) {
193: markedDirs.add(root);
194: return;
195: }
196:
197: // Recurse through children
198: children = root.listFiles();
199: for (int i = 0; i < children.length; i++) {
200: if (children[i].isDirectory()) {
201: findMarkedDirs(children[i], markedDirs);
202: }
203: }
204: }
205: }
206:
207: /** Matches all files that start with the specified prefix.
208: */
209: class FilePrefixFilter implements java.io.FileFilter {
210: private Pattern mPrefix;
211:
212: FilePrefixFilter(Pattern prefix) {
213: mPrefix = prefix;
214: }
215:
216: public boolean accept(File file) {
217: Matcher matcher = mPrefix.matcher(file.getName());
218: return matcher.matches();
219: }
220: }
|