001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018package org.apache.commons.io.file; 019 020import java.io.IOException; 021import java.nio.file.FileVisitResult; 022import java.nio.file.Files; 023import java.nio.file.LinkOption; 024import java.nio.file.NoSuchFileException; 025import java.nio.file.Path; 026import java.nio.file.attribute.BasicFileAttributes; 027import java.util.Arrays; 028import java.util.Objects; 029 030import org.apache.commons.io.file.Counters.PathCounters; 031 032/** 033 * Deletes files and directories as a visit proceeds. 034 * 035 * @since 2.7 036 */ 037public class DeletingPathVisitor extends CountingPathVisitor { 038 039 /** 040 * Constructs a new instance configured with a BigInteger {@link PathCounters}. 041 * 042 * @return a new instance configured with a BigInteger {@link PathCounters}. 043 */ 044 public static DeletingPathVisitor withBigIntegerCounters() { 045 return new DeletingPathVisitor(Counters.bigIntegerPathCounters()); 046 } 047 048 /** 049 * Constructs a new instance configured with a long {@link PathCounters}. 050 * 051 * @return a new instance configured with a long {@link PathCounters}. 052 */ 053 public static DeletingPathVisitor withLongCounters() { 054 return new DeletingPathVisitor(Counters.longPathCounters()); 055 } 056 057 private final String[] skip; 058 private final boolean overrideReadOnly; 059 private final LinkOption[] linkOptions; 060 061 /** 062 * Constructs a instance that deletes files except for the files and directories explicitly given. 063 * 064 * @param pathCounter How to count visits. 065 * @param deleteOption How deletion is handled. 066 * @param skip The files to skip deleting. 067 * @since 2.8.0 068 */ 069 public DeletingPathVisitor(final PathCounters pathCounter, final DeleteOption[] deleteOption, final String... skip) { 070 this(pathCounter, PathUtils.noFollowLinkOptionArray(), deleteOption, skip); 071 } 072 073 /** 074 * Constructs a instance that deletes files except for the files and directories explicitly given. 075 * 076 * @param pathCounter How to count visits. 077 * @param linkOptions How symbolic links are handled. 078 * @param deleteOption How deletion is handled. 079 * @param skip The files to skip deleting. 080 * @since 2.9.0 081 */ 082 public DeletingPathVisitor(final PathCounters pathCounter, final LinkOption[] linkOptions, final DeleteOption[] deleteOption, final String... skip) { 083 super(pathCounter); 084 final String[] temp = skip != null ? skip.clone() : EMPTY_STRING_ARRAY; 085 Arrays.sort(temp); 086 this.skip = temp; 087 this.overrideReadOnly = StandardDeleteOption.overrideReadOnly(deleteOption); 088 // TODO Files.deleteIfExists() never follows links, so use LinkOption.NOFOLLOW_LINKS in other calls to Files. 089 this.linkOptions = linkOptions == null ? PathUtils.noFollowLinkOptionArray() : linkOptions.clone(); 090 } 091 092 /** 093 * Constructs a instance that deletes files except for the files and directories explicitly given. 094 * 095 * @param pathCounter How to count visits. 096 * 097 * @param skip The files to skip deleting. 098 */ 099 public DeletingPathVisitor(final PathCounters pathCounter, final String... skip) { 100 this(pathCounter, PathUtils.EMPTY_DELETE_OPTION_ARRAY, skip); 101 } 102 103 /** 104 * Returns true to process the given path, false if not. 105 * 106 * @param path the path to test. 107 * @return true to process the given path, false if not. 108 */ 109 private boolean accept(final Path path) { 110 return Arrays.binarySearch(skip, PathUtils.getFileNameString(path)) < 0; 111 } 112 113 @Override 114 public boolean equals(final Object obj) { 115 if (this == obj) { 116 return true; 117 } 118 if (!super.equals(obj)) { 119 return false; 120 } 121 if (getClass() != obj.getClass()) { 122 return false; 123 } 124 final DeletingPathVisitor other = (DeletingPathVisitor) obj; 125 return overrideReadOnly == other.overrideReadOnly && Arrays.equals(skip, other.skip); 126 } 127 128 @Override 129 public int hashCode() { 130 final int prime = 31; 131 int result = super.hashCode(); 132 result = prime * result + Arrays.hashCode(skip); 133 result = prime * result + Objects.hash(overrideReadOnly); 134 return result; 135 } 136 137 @Override 138 public FileVisitResult postVisitDirectory(final Path dir, final IOException exc) throws IOException { 139 if (PathUtils.isEmptyDirectory(dir)) { 140 Files.deleteIfExists(dir); 141 } 142 return super.postVisitDirectory(dir, exc); 143 } 144 145 @Override 146 public FileVisitResult preVisitDirectory(final Path dir, final BasicFileAttributes attrs) throws IOException { 147 super.preVisitDirectory(dir, attrs); 148 return accept(dir) ? FileVisitResult.CONTINUE : FileVisitResult.SKIP_SUBTREE; 149 } 150 151 @Override 152 public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException { 153 if (accept(file)) { 154 // delete files and valid links, respecting linkOptions 155 if (Files.exists(file, linkOptions)) { 156 if (overrideReadOnly) { 157 PathUtils.setReadOnly(file, false, linkOptions); 158 } 159 Files.deleteIfExists(file); 160 } 161 // invalid links will survive previous delete, different approach needed: 162 if (Files.isSymbolicLink(file)) { 163 try { 164 // deleteIfExists does not work for this case 165 Files.delete(file); 166 } catch (final NoSuchFileException ignored) { 167 // ignore 168 } 169 } 170 } 171 updateFileCounters(file, attrs); 172 return FileVisitResult.CONTINUE; 173 } 174}