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 */ 017package org.apache.camel.util; 018 019import java.io.File; 020import java.io.IOException; 021import java.nio.file.Files; 022import java.nio.file.StandardCopyOption; 023import java.util.ArrayDeque; 024import java.util.Deque; 025import java.util.Iterator; 026import java.util.Locale; 027import java.util.Objects; 028 029import org.slf4j.Logger; 030import org.slf4j.LoggerFactory; 031 032/** 033 * File utilities. 034 */ 035public final class FileUtil { 036 037 public static final int BUFFER_SIZE = 128 * 1024; 038 039 private static final Logger LOG = LoggerFactory.getLogger(FileUtil.class); 040 private static final int RETRY_SLEEP_MILLIS = 10; 041 /** 042 * The System property key for the user directory. 043 */ 044 private static final String USER_DIR_KEY = "user.dir"; 045 private static final File USER_DIR = new File(System.getProperty(USER_DIR_KEY)); 046 private static boolean windowsOs = initWindowsOs(); 047 048 private FileUtil() { 049 // Utils method 050 } 051 052 private static boolean initWindowsOs() { 053 // initialize once as System.getProperty is not fast 054 String osName = System.getProperty("os.name").toLowerCase(Locale.ENGLISH); 055 return osName.contains("windows"); 056 } 057 058 public static File getUserDir() { 059 return USER_DIR; 060 } 061 062 /** 063 * Normalizes the path to cater for Windows and other platforms 064 */ 065 public static String normalizePath(String path) { 066 if (path == null) { 067 return null; 068 } 069 070 if (isWindows()) { 071 // special handling for Windows where we need to convert / to \\ 072 return path.replace('/', '\\'); 073 } else { 074 // for other systems make sure we use / as separators 075 return path.replace('\\', '/'); 076 } 077 } 078 079 /** 080 * Returns true, if the OS is windows 081 */ 082 public static boolean isWindows() { 083 return windowsOs; 084 } 085 086 public static File createTempFile(String prefix, String suffix, File parentDir) throws IOException { 087 Objects.requireNonNull(parentDir); 088 089 if (suffix == null) { 090 suffix = ".tmp"; 091 } 092 if (prefix == null) { 093 prefix = "camel"; 094 } else if (prefix.length() < 3) { 095 prefix = prefix + "camel"; 096 } 097 098 // create parent folder 099 parentDir.mkdirs(); 100 101 return Files.createTempFile(parentDir.toPath(), prefix, suffix).toFile(); 102 } 103 104 /** 105 * Strip any leading separators 106 */ 107 public static String stripLeadingSeparator(String name) { 108 if (name == null) { 109 return null; 110 } 111 while (name.startsWith("/") || name.startsWith(File.separator)) { 112 name = name.substring(1); 113 } 114 return name; 115 } 116 117 /** 118 * Does the name start with a leading separator 119 */ 120 public static boolean hasLeadingSeparator(String name) { 121 if (name == null) { 122 return false; 123 } 124 if (name.startsWith("/") || name.startsWith(File.separator)) { 125 return true; 126 } 127 return false; 128 } 129 130 /** 131 * Strip first leading separator 132 */ 133 public static String stripFirstLeadingSeparator(String name) { 134 if (name == null) { 135 return null; 136 } 137 if (name.startsWith("/") || name.startsWith(File.separator)) { 138 name = name.substring(1); 139 } 140 return name; 141 } 142 143 /** 144 * Strip any trailing separators 145 */ 146 public static String stripTrailingSeparator(String name) { 147 if (ObjectHelper.isEmpty(name)) { 148 return name; 149 } 150 151 String s = name; 152 153 // there must be some leading text, as we should only remove trailing separators 154 while (s.endsWith("/") || s.endsWith(File.separator)) { 155 s = s.substring(0, s.length() - 1); 156 } 157 158 // if the string is empty, that means there was only trailing slashes, and no leading text 159 // and so we should then return the original name as is 160 if (ObjectHelper.isEmpty(s)) { 161 return name; 162 } else { 163 // return without trailing slashes 164 return s; 165 } 166 } 167 168 /** 169 * Strips any leading paths 170 */ 171 public static String stripPath(String name) { 172 if (name == null) { 173 return null; 174 } 175 int posUnix = name.lastIndexOf('/'); 176 int posWin = name.lastIndexOf('\\'); 177 int pos = Math.max(posUnix, posWin); 178 179 if (pos != -1) { 180 return name.substring(pos + 1); 181 } 182 return name; 183 } 184 185 public static String stripExt(String name) { 186 return stripExt(name, false); 187 } 188 189 public static String stripExt(String name, boolean singleMode) { 190 if (name == null) { 191 return null; 192 } 193 194 // the name may have a leading path 195 int posUnix = name.lastIndexOf('/'); 196 int posWin = name.lastIndexOf('\\'); 197 int pos = Math.max(posUnix, posWin); 198 199 if (pos > 0) { 200 String onlyName = name.substring(pos + 1); 201 int pos2 = singleMode ? onlyName.lastIndexOf('.') : onlyName.indexOf('.'); 202 if (pos2 > 0) { 203 return name.substring(0, pos + pos2 + 1); 204 } 205 } else { 206 // if single ext mode, then only return last extension 207 int pos2 = singleMode ? name.lastIndexOf('.') : name.indexOf('.'); 208 if (pos2 > 0) { 209 return name.substring(0, pos2); 210 } 211 } 212 213 return name; 214 } 215 216 public static String onlyExt(String name) { 217 return onlyExt(name, false); 218 } 219 220 public static String onlyExt(String name, boolean singleMode) { 221 if (name == null) { 222 return null; 223 } 224 name = stripPath(name); 225 226 // extension is the first dot, as a file may have double extension such as .tar.gz 227 // if single ext mode, then only return last extension 228 int pos = singleMode ? name.lastIndexOf('.') : name.indexOf('.'); 229 if (pos != -1) { 230 return name.substring(pos + 1); 231 } 232 return null; 233 } 234 235 /** 236 * Returns only the leading path (returns <tt>null</tt> if no path) 237 */ 238 public static String onlyPath(String name) { 239 if (name == null) { 240 return null; 241 } 242 243 int posUnix = name.lastIndexOf('/'); 244 int posWin = name.lastIndexOf('\\'); 245 int pos = Math.max(posUnix, posWin); 246 247 if (pos > 0) { 248 return name.substring(0, pos); 249 } else if (pos == 0) { 250 // name is in the root path, so extract the path as the first char 251 return name.substring(0, 1); 252 } 253 // no path in name 254 return null; 255 } 256 257 /** 258 * Compacts a path by stacking it and reducing <tt>..</tt>, and uses OS specific file separators (eg 259 * {@link java.io.File#separator}). 260 */ 261 public static String compactPath(String path) { 262 return compactPath(path, "" + File.separatorChar); 263 } 264 265 /** 266 * Compacts a path by stacking it and reducing <tt>..</tt>, and uses the given separator. 267 * 268 */ 269 public static String compactPath(String path, char separator) { 270 return compactPath(path, "" + separator); 271 } 272 273 /** 274 * Compacts a file path by stacking it and reducing <tt>..</tt>, and uses the given separator. 275 */ 276 public static String compactPath(String path, String separator) { 277 if (path == null) { 278 return null; 279 } 280 281 if (path.startsWith("http:")) { 282 return path; 283 } 284 285 // only normalize if contains a path separator 286 if (path.indexOf('/') == -1 && path.indexOf('\\') == -1) { 287 return path; 288 } 289 290 // need to normalize path before compacting 291 path = normalizePath(path); 292 293 // preserve ending slash if given in input path 294 boolean endsWithSlash = path.endsWith("/") || path.endsWith("\\"); 295 296 // preserve starting slash if given in input path 297 int cntSlashsAtStart = 0; 298 if (path.startsWith("/") || path.startsWith("\\")) { 299 cntSlashsAtStart++; 300 // for Windows, preserve up to 2 starting slashes, which is necessary for UNC paths. 301 if (isWindows() && path.length() > 1 && (path.charAt(1) == '/' || path.charAt(1) == '\\')) { 302 cntSlashsAtStart++; 303 } 304 } 305 306 Deque<String> stack = new ArrayDeque<>(); 307 308 // separator can either be windows or unix style 309 String separatorRegex = "\\\\|/"; 310 String[] parts = path.split(separatorRegex); 311 for (String part : parts) { 312 if (part.equals("..") && !stack.isEmpty() && !"..".equals(stack.peek())) { 313 // only pop if there is a previous path, which is not a ".." path either 314 stack.pop(); 315 } else if (part.equals(".") || part.isEmpty()) { 316 // do nothing because we don't want a path like foo/./bar or foo//bar 317 } else { 318 stack.push(part); 319 } 320 } 321 322 // build path based on stack 323 StringBuilder sb = new StringBuilder(); 324 325 for (int i = 0; i < cntSlashsAtStart; i++) { 326 sb.append(separator); 327 } 328 329 // now we build back using FIFO so need to use descending 330 for (Iterator<String> it = stack.descendingIterator(); it.hasNext();) { 331 sb.append(it.next()); 332 if (it.hasNext()) { 333 sb.append(separator); 334 } 335 } 336 337 if (endsWithSlash && !stack.isEmpty()) { 338 sb.append(separator); 339 } 340 341 return sb.toString(); 342 } 343 344 public static void removeDir(File d) { 345 String[] list = d.list(); 346 if (list == null) { 347 list = new String[0]; 348 } 349 for (String s : list) { 350 File f = new File(d, s); 351 if (f.isDirectory()) { 352 removeDir(f); 353 } else { 354 delete(f); 355 } 356 } 357 delete(d); 358 } 359 360 private static void delete(File f) { 361 if (!f.delete()) { 362 if (isWindows()) { 363 System.gc(); 364 } 365 try { 366 Thread.sleep(RETRY_SLEEP_MILLIS); 367 } catch (InterruptedException ex) { 368 // Ignore Exception 369 } 370 if (!f.delete()) { 371 f.deleteOnExit(); 372 } 373 } 374 } 375 376 /** 377 * Renames a file. 378 * 379 * @param from the from file 380 * @param to the to file 381 * @param copyAndDeleteOnRenameFail whether to fallback and do copy and delete, if renameTo fails 382 * @return <tt>true</tt> if the file was renamed, otherwise <tt>false</tt> 383 * @throws java.io.IOException is thrown if error renaming file 384 */ 385 public static boolean renameFile(File from, File to, boolean copyAndDeleteOnRenameFail) throws IOException { 386 // do not try to rename non existing files 387 if (!from.exists()) { 388 return false; 389 } 390 391 // some OS such as Windows can have problem doing rename IO operations so we may need to 392 // retry a couple of times to let it work 393 boolean renamed = false; 394 int count = 0; 395 while (!renamed && count < 3) { 396 if (LOG.isDebugEnabled() && count > 0) { 397 LOG.debug("Retrying attempt {} to rename file from: {} to: {}", count, from, to); 398 } 399 400 renamed = from.renameTo(to); 401 if (!renamed && count > 0) { 402 try { 403 Thread.sleep(1000); 404 } catch (InterruptedException e) { 405 // ignore 406 } 407 } 408 count++; 409 } 410 411 // we could not rename using renameTo, so lets fallback and do a copy/delete approach. 412 // for example if you move files between different file systems (linux -> windows etc.) 413 if (!renamed && copyAndDeleteOnRenameFail) { 414 // now do a copy and delete as all rename attempts failed 415 LOG.debug("Cannot rename file from: {} to: {}, will now use a copy/delete approach instead", from, to); 416 renamed = renameFileUsingCopy(from, to); 417 } 418 419 if (LOG.isDebugEnabled() && count > 0) { 420 LOG.debug("Tried {} to rename file: {} to: {} with result: {}", count, from, to, renamed); 421 } 422 return renamed; 423 } 424 425 /** 426 * Rename file using copy and delete strategy. This is primarily used in environments where the regular rename 427 * operation is unreliable. 428 * 429 * @param from the file to be renamed 430 * @param to the new target file 431 * @return <tt>true</tt> if the file was renamed successfully, otherwise <tt>false</tt> 432 * @throws IOException If an I/O error occurs during copy or delete operations. 433 */ 434 public static boolean renameFileUsingCopy(File from, File to) throws IOException { 435 // do not try to rename non existing files 436 if (!from.exists()) { 437 return false; 438 } 439 440 LOG.debug("Rename file '{}' to '{}' using copy/delete strategy.", from, to); 441 442 copyFile(from, to); 443 if (!deleteFile(from)) { 444 throw new IOException( 445 "Renaming file from '" + from + "' to '" + to + "' failed: Cannot delete file '" + from 446 + "' after copy succeeded"); 447 } 448 449 return true; 450 } 451 452 /** 453 * Copies the file 454 * 455 * @param from the source file 456 * @param to the destination file 457 * @throws IOException If an I/O error occurs during copy operation 458 */ 459 public static void copyFile(File from, File to) throws IOException { 460 Files.copy(from.toPath(), to.toPath(), StandardCopyOption.REPLACE_EXISTING); 461 } 462 463 /** 464 * Deletes the file. 465 * <p/> 466 * This implementation will attempt to delete the file up till three times with one second delay, which can mitigate 467 * problems on deleting files on some platforms such as Windows. 468 * 469 * @param file the file to delete 470 */ 471 public static boolean deleteFile(File file) { 472 // do not try to delete non existing files 473 if (!file.exists()) { 474 return false; 475 } 476 477 // some OS such as Windows can have problem doing delete IO operations so we may need to 478 // retry a couple of times to let it work 479 boolean deleted = false; 480 int count = 0; 481 while (!deleted && count < 3) { 482 LOG.debug("Retrying attempt {} to delete file: {}", count, file); 483 484 deleted = file.delete(); 485 if (!deleted && count > 0) { 486 try { 487 Thread.sleep(1000); 488 } catch (InterruptedException e) { 489 // ignore 490 } 491 } 492 count++; 493 } 494 495 if (LOG.isDebugEnabled() && count > 0) { 496 LOG.debug("Tried {} to delete file: {} with result: {}", count, file, deleted); 497 } 498 return deleted; 499 } 500 501 /** 502 * Is the given file an absolute file. 503 * <p/> 504 * Will also work around issue on Windows to consider files on Windows starting with a \ as absolute files. This 505 * makes the logic consistent across all OS platforms. 506 * 507 * @param file the file 508 * @return <tt>true</ff> if its an absolute path, <tt>false</tt> otherwise. 509 */ 510 public static boolean isAbsolute(File file) { 511 if (isWindows()) { 512 // special for windows 513 String path = file.getPath(); 514 if (path.startsWith(File.separator)) { 515 return true; 516 } 517 } 518 return file.isAbsolute(); 519 } 520 521 /** 522 * Creates a new file. 523 * 524 * @param file the file 525 * @return <tt>true</tt> if created a new file, <tt>false</tt> otherwise 526 * @throws IOException is thrown if error creating the new file 527 */ 528 public static boolean createNewFile(File file) throws IOException { 529 // need to check first 530 if (file.exists()) { 531 return false; 532 } 533 try { 534 return file.createNewFile(); 535 } catch (IOException e) { 536 // and check again if the file was created as createNewFile may create the file 537 // but throw a permission error afterwards when using some NAS 538 if (file.exists()) { 539 return true; 540 } else { 541 throw e; 542 } 543 } 544 } 545 546}