Rewrite archived absolute symlink targets

Author: mazdak

Sources/Services/ContainerAPIService/Client/Archiver.swift

@@ -95,6 +95,10 @@ public final class Archiver: Sendable {
                 }
             }
 
+            let archivedPathsByHostPath = entryInfo.reduce(into: [URL: [URL]]()) { result, info in
+                result[info.pathOnHost.standardizedFileURL, default: []].append(info.pathInArchive)
+            }
+
             let archiver = try ArchiveWriter(
                 configuration: writerConfiguration
             )
@@ -104,7 +108,7 @@ public final class Archiver: Sendable {
             encoder.outputFormatting = .sortedKeys
 
             for info in entryInfo {
-                guard let entry = try Self._createEntry(entryInfo: info) else {
+                guard let entry = try Self._createEntry(entryInfo: info, archivedPathsByHostPath: archivedPathsByHostPath) else {
                     throw Error.failedToCreateEntry
                 }
                 let hashInfo = ArchiveEntryHashInfo(
@@ -252,7 +256,11 @@ public final class Archiver: Sendable {
         try writer.finish()
     }
 
-    private static func _createEntry(entryInfo: ArchiveEntryInfo, pathPrefix: String = "") throws -> WriteEntry? {
+    private static func _createEntry(
+        entryInfo: ArchiveEntryInfo,
+        archivedPathsByHostPath: [URL: [URL]] = [:],
+        pathPrefix: String = ""
+    ) throws -> WriteEntry? {
         let entry = WriteEntry()
         let fileManager = FileManager.default
         let attributes = try fileManager.attributesOfItem(atPath: entryInfo.pathOnHost.path)
@@ -270,7 +278,11 @@ public final class Archiver: Sendable {
                 entry.fileType = .symbolicLink
                 entry.size = 0
                 let symlinkTarget = try fileManager.destinationOfSymbolicLink(atPath: entryInfo.pathOnHost.path)
-                entry.symlinkTarget = symlinkTarget
+                entry.symlinkTarget = Self._rewriteArchivedAbsoluteSymlinkTarget(
+                    symlinkTarget,
+                    entryInfo: entryInfo,
+                    archivedPathsByHostPath: archivedPathsByHostPath
+                )
             default:
                 return nil
             }
@@ -332,6 +344,48 @@ public final class Archiver: Sendable {
         return trimmedPath
     }
 
+    private static func _rewriteArchivedAbsoluteSymlinkTarget(
+        _ symlinkTarget: String,
+        entryInfo: ArchiveEntryInfo,
+        archivedPathsByHostPath: [URL: [URL]]
+    ) -> String {
+        guard symlinkTarget.hasPrefix("/") else {
+            return symlinkTarget
+        }
+
+        let targetPath = URL(fileURLWithPath: symlinkTarget).standardizedFileURL
+        guard let targetArchivePaths = archivedPathsByHostPath[targetPath], targetArchivePaths.count == 1, let targetArchivePath = targetArchivePaths.first else {
+            return symlinkTarget
+        }
+
+        let sourceDirectory = entryInfo.pathInArchive.deletingLastPathComponent().relativePath
+        return Self._relativeArchivePath(fromDirectory: sourceDirectory, to: targetArchivePath.relativePath)
+    }
+
+    private static func _relativeArchivePath(fromDirectory: String, to path: String) -> String {
+        let fromComponents = Self._archivePathComponents(fromDirectory)
+        let toComponents = Self._archivePathComponents(path)
+
+        var commonPrefixCount = 0
+        while commonPrefixCount < fromComponents.count,
+            commonPrefixCount < toComponents.count,
+            fromComponents[commonPrefixCount] == toComponents[commonPrefixCount]
+        {
+            commonPrefixCount += 1
+        }
+
+        let upwardTraversal = Array(repeating: "..", count: fromComponents.count - commonPrefixCount)
+        let remainder = Array(toComponents.dropFirst(commonPrefixCount))
+        let relativeComponents = upwardTraversal + remainder
+        return relativeComponents.isEmpty ? "." : relativeComponents.joined(separator: "/")
+    }
+
+    private static func _archivePathComponents(_ path: String) -> [String] {
+        NSString(string: path).pathComponents.filter { component in
+            component != "/" && component != "."
+        }
+    }
+
     private static func _isSymbolicLink(_ path: URL) throws -> Bool {
         let resourceValues = try path.resourceValues(forKeys: [.isSymbolicLinkKey])
         if let isSymbolicLink = resourceValues.isSymbolicLink {

Tests/ContainerAPIClientTests/ArchiverTests.swift

@@ -99,6 +99,46 @@ struct ArchiverTests {
         #expect(try fileManager.destinationOfSymbolicLink(atPath: extractedLinkURL.path) == externalTargetURL.path)
     }
 
+    @Test
+    func testCompressAndUncompressRewritesArchivedAbsoluteSymbolicLinkTarget() throws {
+        let fileManager = FileManager.default
+        let tempURL = try fileManager.url(
+            for: .itemReplacementDirectory,
+            in: .userDomainMask,
+            appropriateFor: .temporaryDirectory,
+            create: true
+        )
+        defer { try? fileManager.removeItem(at: tempURL) }
+
+        let sourceURL = tempURL.appendingPathComponent("source")
+        let archiveURL = tempURL.appendingPathComponent("archive.tar.gz")
+        let destinationURL = tempURL.appendingPathComponent("destination")
+        try fileManager.createDirectory(at: sourceURL, withIntermediateDirectories: true)
+
+        let targetURL = sourceURL.appendingPathComponent("target.txt")
+        try #require("hello".data(using: .utf8)).write(to: targetURL)
+        let linkURL = sourceURL.appendingPathComponent("link.txt")
+        try fileManager.createSymbolicLink(atPath: linkURL.path, withDestinationPath: targetURL.path)
+
+        _ = try Archiver.compress(source: sourceURL, destination: archiveURL) { url in
+            let sourcePath = sourceURL.standardizedFileURL.path
+            let path = url.standardizedFileURL.path
+            let relativePath = String(path.dropFirst(sourcePath.count + 1))
+            return Archiver.ArchiveEntryInfo(
+                pathOnHost: url,
+                pathInArchive: URL(fileURLWithPath: relativePath)
+            )
+        }
+
+        try Archiver.uncompress(source: archiveURL, destination: destinationURL)
+
+        let extractedLinkURL = destinationURL.appendingPathComponent("link.txt")
+        let values = try extractedLinkURL.resourceValues(forKeys: [.isSymbolicLinkKey])
+        #expect(values.isSymbolicLink == true)
+        #expect(try fileManager.destinationOfSymbolicLink(atPath: extractedLinkURL.path) == "target.txt")
+        #expect(try String(contentsOf: extractedLinkURL, encoding: .utf8) == "hello")
+    }
+
     @Test
     func testCompressDigestChangesWhenSymlinkTargetChanges() throws {
         let fileManager = FileManager.default