1 /***********************************************************************
2  * Copyright (c) 2013-2024 Commonwealth Computer Research, Inc.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Apache License, Version 2.0
5  * which accompanies this distribution and is available at
6  * http://www.opensource.org/licenses/apache2.0.php.
7  ***********************************************************************/
8 
9 package org.locationtech.geomesa.utils.io
10 
11 import com.typesafe.scalalogging.LazyLogging
12 import org.apache.commons.io.FilenameUtils
13 import org.locationtech.geomesa.utils.io.fs.FileSystemDelegate.FileHandle
14 import org.locationtech.geomesa.utils.io.fs.{FileSystemDelegate, LocalDelegate}
15 
16 import java.io._
17 import java.net.URL
18 import java.nio.file._
19 import java.nio.file.attribute.BasicFileAttributes
20 import java.util.regex.Pattern
21 import scala.util.Try
22 
23 object PathUtils extends FileSystemDelegate with LazyLogging {
24 
25   private val uriRegex = Pattern.compile("""\w+://.*""")
26 
27   private val localDelegate = new LocalDelegate()
28 
29   // delegate allows us to avoid a runtime dependency on hadoop
30   private val hadoopDelegate: FileSystemDelegate =
31     try {
32       Class.forName("org.locationtech.geomesa.utils.hadoop.HadoopDelegate")
33         .getDeclaredConstructor().newInstance().asInstanceOf[FileSystemDelegate]
34     } catch {
35       case _: Throwable => null
36     }
37 
38   override def interpretPath(path: String): Seq[FileHandle] = chooseDelegate(path).interpretPath(path)
39 
40   override def getHandle(path: String): FileHandle = chooseDelegate(path).getHandle(path)
41 
42   override def getUrl(path: String): URL = chooseDelegate(path).getUrl(path)
43 
44   /**
45     * Checks to see if the path uses a URL pattern and then if it is *not* file://
46     *
47     * @param path Input resource path
48     * @return     Whether or not the resource is remote.
49     */
50   def isRemote(path: String): Boolean =
51     uriRegex.matcher(path).matches() && !path.toLowerCase.startsWith("file://")
52 
53   /**
54     * Returns the file extension, minus any compression that may be present
55     *
56     * @param path file path
57     * @return
58     */
59   def getUncompressedExtension(path: String): String =
60     FilenameUtils.getExtension(CompressionUtils.getUncompressedFilename(path))
61 
62   /**
63     * Gets the base file name and the extension. Useful for adding unique ids to a common file name,
64     * while preserving the extension
65     *
66     * @param path path
67     * @param includeDot if true, the '.' will be preserved in the extension, otherwise it will be dropped
68     * @return (base name including path prefix, extension)
69     */
70   def getBaseNameAndExtension(path: String, includeDot: Boolean = true): (String, String) = {
71     def dotIndex(base: Int): Int = if (includeDot) { base } else { base + 1}
72     val split = FilenameUtils.indexOfExtension(path)
73     if (split == -1) { (path, "") } else {
74       val withoutExtension = path.substring(0, split)
75       // look for file names like 'foo.tar.gz'
76       val secondSplit = FilenameUtils.indexOfExtension(withoutExtension)
77       if (secondSplit != -1 && CompressionUtils.isCompressedFilename(path)) {
78         (path.substring(0, secondSplit), path.substring(dotIndex(secondSplit)))
79       } else {
80         (withoutExtension, path.substring(dotIndex(split)))
81       }
82     }
83   }
84 
85   /**
86     * Wrap the input stream in a decompressor, if the file is compressed
87     *
88     * @param is input stream
89     * @param filename filename (used to determine compression)
90     * @return
91     */
92   def handleCompression(is: InputStream, filename: String): InputStream = {
93     val buffered = new BufferedInputStream(is)
94     CompressionUtils.Utils.find(_.isCompressedFilename(filename)) match {
95       case None => buffered
96       case Some(utils) => utils.compress(buffered)
97     }
98   }
99 
100   /**
101     * Delete a path, including all children
102     *
103     * @param path path
104     */
105   def deleteRecursively(path: Path): Unit = Files.walkFileTree(path, new DeleteFileVisitor)
106 
107   private def chooseDelegate(path: String): FileSystemDelegate =
108     if (hadoopDelegate != null && uriRegex.matcher(path).matches()) { hadoopDelegate } else { localDelegate }
109 
110   /**
111     * File visitor to delete nested paths
112     */
113   class DeleteFileVisitor extends FileVisitor[Path] {
114 
115     override def visitFileFailed(file: Path, exc: IOException): FileVisitResult = FileVisitResult.CONTINUE
116 
117     override def visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult = {
118       if (!attrs.isDirectory) {
119         Files.delete(file)
120       }
121       FileVisitResult.CONTINUE
122     }
123 
124     override def preVisitDirectory(dir: Path, attrs: BasicFileAttributes): FileVisitResult = FileVisitResult.CONTINUE
125 
126     override def postVisitDirectory(dir: Path, exc: IOException): FileVisitResult = {
127       Files.delete(dir)
128       FileVisitResult.CONTINUE
129     }
130   }
131 }