VirtualFile.readLink

core/src/main/java/hudson/Util.java

@@ -1403,7 +1403,7 @@ public class Util {
      *      The relative path is meant to be resolved from the location of the symlink.
      */
     @CheckForNull
-    public static String resolveSymlink(@Nonnull File link) throws InterruptedException, IOException {
+    public static String resolveSymlink(@Nonnull File link) throws IOException {
         try {
             Path path =  link.toPath();
             return Files.readSymbolicLink(path).toString();
@@ -1415,7 +1415,7 @@ public class Util {
         } catch (IOException x) {
             throw x;
         } catch (Exception x) {
-            throw (IOException) new IOException(x.toString()).initCause(x);
+            throw new IOException(x);
         }
     }
 

core/src/main/java/jenkins/util/VirtualFile.java

@@ -139,8 +139,20 @@ public abstract class VirtualFile implements Comparable<VirtualFile>, Serializab
      */
     public abstract boolean isFile() throws IOException;
 
+    /**
+     * If this file is a symlink, returns the link target.
+     * <p>The default implementation always returns null.
+     * Some implementations may not support symlinks under any conditions.
+     * @return a target (typically a relative path in some format), or null if this is not a link
+     * @throws IOException if reading the link, or even determining whether this file is a link, failed
+     */
+    public @CheckForNull String readLink() throws IOException {
+        return null;
+    }
+
     /**
      * Checks whether this file exists.
+     * The behavior is undefined for symlinks; if in doubt, check {@link #readLink} first.
      * @return true if it is a plain file or directory, false if nonexistent
      * @throws IOException in case checking status failed
      */
@@ -378,6 +390,12 @@ public abstract class VirtualFile implements Comparable<VirtualFile>, Serializab
                 }
                 return f.exists();
             }
+            @Override public String readLink() throws IOException {
+                if (isIllegalSymlink()) {
+                    return null; // best to just ignore link -> ../whatever
+                }
+                return Util.resolveSymlink(f);
+            }
             @Override public VirtualFile[] list() throws IOException {
                 if (isIllegalSymlink()) {
                     return new VirtualFile[0];
@@ -497,6 +515,13 @@ public abstract class VirtualFile implements Comparable<VirtualFile>, Serializab
                     throw new IOException(x);
                 }
             }
+            @Override public String readLink() throws IOException {
+                try {
+                    return f.readLink();
+                } catch (InterruptedException x) {
+                    throw new IOException(x);
+                }
+            }
             @Override public VirtualFile[] list() throws IOException {
                 try {
                     List<FilePath> kids = f.list();

core/src/test/java/jenkins/util/VirtualFileTest.java

@@ -175,4 +175,21 @@ public class VirtualFileTest {
         }
     }
 
+    @Issue("JENKINS-26810")
+    @Test public void readLink() throws Exception {
+        assumeFalse("Symlinks do not work well on Windows", Functions.isWindows());
+        File root = tmp.getRoot();
+        FilePath rootF = new FilePath(root);
+        rootF.child("plain").write("", null);
+        rootF.child("link").symlinkTo("physical", TaskListener.NULL);
+        for (VirtualFile vf : new VirtualFile[] {VirtualFile.forFile(root), VirtualFile.forFilePath(rootF)}) {
+            assertNull(vf.readLink());
+            assertNull(vf.child("plain").readLink());
+            VirtualFile link = vf.child("link");
+            assertEquals("physical", link.readLink());
+            assertFalse(link.isFile());
+            assertFalse(link.isDirectory());
+        }
+    }
+
 }