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 public static String onlyName(String name) { 258 return onlyName(name, false); 259 } 260 261 public static String onlyName(String name, boolean singleMode) { 262 name = FileUtil.stripPath(name); 263 name = FileUtil.stripExt(name, singleMode); 264 265 return name; 266 } 267 268 /** 269 * Compacts a path by stacking it and reducing <tt>..</tt>, and uses OS specific file separators (eg 270 * {@link java.io.File#separator}). 271 */ 272 public static String compactPath(String path) { 273 return compactPath(path, "" + File.separatorChar); 274 } 275 276 /** 277 * Compacts a path by stacking it and reducing <tt>..</tt>, and uses the given separator. 278 * 279 */ 280 public static String compactPath(String path, char separator) { 281 return compactPath(path, "" + separator); 282 } 283 284 /** 285 * Compacts a file path by stacking it and reducing <tt>..</tt>, and uses the given separator. 286 */ 287 public static String compactPath(String path, String separator) { 288 if (path == null) { 289 return null; 290 } 291 292 if (path.startsWith("http:") || path.startsWith("https:")) { 293 return path; 294 } 295 296 // only normalize if contains a path separator 297 if (path.indexOf('/') == -1 && path.indexOf('\\') == -1) { 298 return path; 299 } 300 301 // need to normalize path before compacting 302 path = normalizePath(path); 303 304 // preserve scheme 305 String scheme = null; 306 if (hasScheme(path)) { 307 int pos = path.indexOf(':'); 308 scheme = path.substring(0, pos); 309 path = path.substring(pos + 1); 310 } 311 312 // preserve ending slash if given in input path 313 boolean endsWithSlash = path.endsWith("/") || path.endsWith("\\"); 314 315 // preserve starting slash if given in input path 316 int cntSlashsAtStart = 0; 317 if (path.startsWith("/") || path.startsWith("\\")) { 318 cntSlashsAtStart++; 319 // for Windows, preserve up to 2 starting slashes, which is necessary for UNC paths. 320 if (isWindows() && path.length() > 1 && (path.charAt(1) == '/' || path.charAt(1) == '\\')) { 321 cntSlashsAtStart++; 322 } 323 } 324 325 Deque<String> stack = new ArrayDeque<>(); 326 327 // separator can either be windows or unix style 328 String separatorRegex = "\\\\|/"; 329 String[] parts = path.split(separatorRegex); 330 for (String part : parts) { 331 if (part.equals("..") && !stack.isEmpty() && !"..".equals(stack.peek())) { 332 // only pop if there is a previous path, which is not a ".." path either 333 stack.pop(); 334 } else if (part.equals(".") || part.isEmpty()) { 335 // do nothing because we don't want a path like foo/./bar or foo//bar 336 } else { 337 stack.push(part); 338 } 339 } 340 341 // build path based on stack 342 StringBuilder sb = new StringBuilder(); 343 if (scheme != null) { 344 sb.append(scheme); 345 sb.append(":"); 346 } 347 348 for (int i = 0; i < cntSlashsAtStart; i++) { 349 sb.append(separator); 350 } 351 352 // now we build back using FIFO so need to use descending 353 for (Iterator<String> it = stack.descendingIterator(); it.hasNext();) { 354 sb.append(it.next()); 355 if (it.hasNext()) { 356 sb.append(separator); 357 } 358 } 359 360 if (endsWithSlash && !stack.isEmpty()) { 361 sb.append(separator); 362 } 363 364 return sb.toString(); 365 } 366 367 public static void removeDir(File d) { 368 String[] list = d.list(); 369 if (list == null) { 370 list = new String[0]; 371 } 372 for (String s : list) { 373 File f = new File(d, s); 374 if (f.isDirectory()) { 375 removeDir(f); 376 } else { 377 delete(f); 378 } 379 } 380 delete(d); 381 } 382 383 private static void delete(File f) { 384 if (!f.delete()) { 385 if (isWindows()) { 386 System.gc(); 387 } 388 try { 389 Thread.sleep(RETRY_SLEEP_MILLIS); 390 } catch (InterruptedException ex) { 391 // Ignore Exception 392 } 393 if (!f.delete()) { 394 f.deleteOnExit(); 395 } 396 } 397 } 398 399 /** 400 * Renames a file. 401 * 402 * @param from the from file 403 * @param to the to file 404 * @param copyAndDeleteOnRenameFail whether to fallback and do copy and delete, if renameTo fails 405 * @return <tt>true</tt> if the file was renamed, otherwise <tt>false</tt> 406 * @throws java.io.IOException is thrown if error renaming file 407 */ 408 public static boolean renameFile(File from, File to, boolean copyAndDeleteOnRenameFail) throws IOException { 409 // do not try to rename non existing files 410 if (!from.exists()) { 411 return false; 412 } 413 414 // some OS such as Windows can have problem doing rename IO operations so we may need to 415 // retry a couple of times to let it work 416 boolean renamed = false; 417 int count = 0; 418 while (!renamed && count < 3) { 419 if (LOG.isDebugEnabled() && count > 0) { 420 LOG.debug("Retrying attempt {} to rename file from: {} to: {}", count, from, to); 421 } 422 423 renamed = from.renameTo(to); 424 if (!renamed && count > 0) { 425 try { 426 Thread.sleep(1000); 427 } catch (InterruptedException e) { 428 // ignore 429 } 430 } 431 count++; 432 } 433 434 // we could not rename using renameTo, so lets fallback and do a copy/delete approach. 435 // for example if you move files between different file systems (linux -> windows etc.) 436 if (!renamed && copyAndDeleteOnRenameFail) { 437 // now do a copy and delete as all rename attempts failed 438 LOG.debug("Cannot rename file from: {} to: {}, will now use a copy/delete approach instead", from, to); 439 renamed = renameFileUsingCopy(from, to); 440 } 441 442 if (LOG.isDebugEnabled() && count > 0) { 443 LOG.debug("Tried {} to rename file: {} to: {} with result: {}", count, from, to, renamed); 444 } 445 return renamed; 446 } 447 448 /** 449 * Rename file using copy and delete strategy. This is primarily used in environments where the regular rename 450 * operation is unreliable. 451 * 452 * @param from the file to be renamed 453 * @param to the new target file 454 * @return <tt>true</tt> if the file was renamed successfully, otherwise <tt>false</tt> 455 * @throws IOException If an I/O error occurs during copy or delete operations. 456 */ 457 public static boolean renameFileUsingCopy(File from, File to) throws IOException { 458 // do not try to rename non existing files 459 if (!from.exists()) { 460 return false; 461 } 462 463 LOG.debug("Rename file '{}' to '{}' using copy/delete strategy.", from, to); 464 465 copyFile(from, to); 466 if (!deleteFile(from)) { 467 throw new IOException( 468 "Renaming file from '" + from + "' to '" + to + "' failed: Cannot delete file '" + from 469 + "' after copy succeeded"); 470 } 471 472 return true; 473 } 474 475 /** 476 * Copies the file 477 * 478 * @param from the source file 479 * @param to the destination file 480 * @throws IOException If an I/O error occurs during copy operation 481 */ 482 public static void copyFile(File from, File to) throws IOException { 483 Files.copy(from.toPath(), to.toPath(), StandardCopyOption.REPLACE_EXISTING); 484 } 485 486 /** 487 * Deletes the file. 488 * <p/> 489 * This implementation will attempt to delete the file up till three times with one second delay, which can mitigate 490 * problems on deleting files on some platforms such as Windows. 491 * 492 * @param file the file to delete 493 */ 494 public static boolean deleteFile(File file) { 495 // do not try to delete non existing files 496 if (!file.exists()) { 497 return false; 498 } 499 500 // some OS such as Windows can have problem doing delete IO operations so we may need to 501 // retry a couple of times to let it work 502 boolean deleted = false; 503 int count = 0; 504 while (!deleted && count < 3) { 505 LOG.debug("Retrying attempt {} to delete file: {}", count, file); 506 507 deleted = file.delete(); 508 if (!deleted && count > 0) { 509 try { 510 Thread.sleep(1000); 511 } catch (InterruptedException e) { 512 // ignore 513 } 514 } 515 count++; 516 } 517 518 if (LOG.isDebugEnabled() && count > 0) { 519 LOG.debug("Tried {} to delete file: {} with result: {}", count, file, deleted); 520 } 521 return deleted; 522 } 523 524 /** 525 * Is the given file an absolute file. 526 * <p/> 527 * Will also work around issue on Windows to consider files on Windows starting with a \ as absolute files. This 528 * makes the logic consistent across all OS platforms. 529 * 530 * @param file the file 531 * @return <tt>true</ff> if its an absolute path, <tt>false</tt> otherwise. 532 */ 533 public static boolean isAbsolute(File file) { 534 if (isWindows()) { 535 // special for windows 536 String path = file.getPath(); 537 if (path.startsWith(File.separator)) { 538 return true; 539 } 540 } 541 return file.isAbsolute(); 542 } 543 544 /** 545 * Creates a new file. 546 * 547 * @param file the file 548 * @return <tt>true</tt> if created a new file, <tt>false</tt> otherwise 549 * @throws IOException is thrown if error creating the new file 550 */ 551 public static boolean createNewFile(File file) throws IOException { 552 // need to check first 553 if (file.exists()) { 554 return false; 555 } 556 try { 557 return file.createNewFile(); 558 } catch (IOException e) { 559 // and check again if the file was created as createNewFile may create the file 560 // but throw a permission error afterwards when using some NAS 561 if (file.exists()) { 562 return true; 563 } else { 564 throw e; 565 } 566 } 567 } 568 569 /** 570 * Determines whether the URI has a scheme (e.g. file:, classpath: or http:) 571 * 572 * @param uri the URI 573 * @return <tt>true</tt> if the URI starts with a scheme 574 */ 575 private static boolean hasScheme(String uri) { 576 if (uri == null) { 577 return false; 578 } 579 580 return uri.startsWith("file:") || uri.startsWith("classpath:") || uri.startsWith("http:"); 581 } 582 583}