Refactor registry configuration to new pattern

mattt · mattt · commit 61ee7ad3d015 · 2021-08-24T06:21:16.000-07:00
diff --git a/Sources/Commands/SwiftPackageRegistryTool.swift b/Sources/Commands/SwiftPackageRegistryTool.swift
@@ -92,21 +92,21 @@ public struct SwiftPackageRegistryTool: ParsableCommand {
 
             // TODO: Require login if password is specified
 
-            let path = try swiftTool.getRegistryConfigurationPath(fileSystem: localFileSystem, global: global)
-
-            var configuration = RegistryConfiguration()
-            if localFileSystem.exists(path) {
-                configuration = try RegistryConfiguration.readFromJSONFile(in: localFileSystem, at: path)
+            let set: (inout RegistryConfiguration) throws -> Void = { configuration in
+                if let scope = scope {
+                    configuration.scopedRegistries[scope] = .init(url: url)
+                } else {
+                    configuration.defaultRegistry = .init(url: url)
+                }
             }
 
-            if let scope = scope {
-                configuration.scopedRegistries[scope] = .init(url: url)
+            let configuration = try swiftTool.getRegistriesConfig()
+            if global {
+                try configuration.applyShared(handler: set)
             } else {
-                configuration.defaultRegistry = .init(url: url)
+                try configuration.applyLocal(handler: set)
             }
 
-            try configuration.writeToJSONFile(in: localFileSystem, at: path)
-
             // TODO: Add login and password to .netrc
         }
     }
@@ -125,56 +125,45 @@ public struct SwiftPackageRegistryTool: ParsableCommand {
         var scope: String?
 
         func run(_ swiftTool: SwiftTool) throws {
-            let path = try swiftTool.getRegistryConfigurationPath(fileSystem: localFileSystem, global: global)
-            var configuration = try RegistryConfiguration.readFromJSONFile(in: localFileSystem, at: path)
-
-            if let scope = scope {
-                guard let _ = configuration.scopedRegistries[scope] else {
-                    throw RegistryConfigurationError.missingScope(scope)
+            let unset: (inout RegistryConfiguration) throws -> Void = { configuration in
+                if let scope = scope {
+                    guard let _ = configuration.scopedRegistries[scope] else {
+                        throw RegistryConfigurationError.missingScope(scope)
+                    }
+                    configuration.scopedRegistries.removeValue(forKey: scope)
+                } else {
+                    guard let _ = configuration.defaultRegistry else {
+                        throw RegistryConfigurationError.missingScope()
+                    }
+                    configuration.defaultRegistry = nil
                 }
-                configuration.scopedRegistries.removeValue(forKey: scope)
-            } else {
-                guard let _ = configuration.defaultRegistry else {
-                    throw RegistryConfigurationError.missingScope()
-                }
-                configuration.defaultRegistry = nil
             }
 
-            try configuration.writeToJSONFile(in: localFileSystem, at: path)
+            let configuration = try swiftTool.getRegistriesConfig()
+            if global {
+                try configuration.applyShared(handler: unset)
+            } else {
+                try configuration.applyLocal(handler: unset)
+            }
         }
     }
 }
 
 // MARK: -
 
-private extension Decodable {
-    static func readFromJSONFile(in fileSystem: FileSystem, at path: AbsolutePath) throws -> Self {
-        let content = try fileSystem.readFileContents(path)
-        let decoder = JSONDecoder.makeWithDefaults()
-        return try decoder.decode(Self.self, from: Data(content.contents))
-    }
-}
-
-private extension Encodable {
-    func writeToJSONFile(in fileSystem: FileSystem, at path: AbsolutePath) throws {
-        let encoder = JSONEncoder.makeWithDefaults()
-        let data = try encoder.encode(self)
-        try fileSystem.writeFileContents(path, bytes: ByteString(data), atomically: true)
-    }
-}
 
 private extension SwiftTool {
-    func getRegistryConfigurationPath(fileSystem: FileSystem, global: Bool) throws -> AbsolutePath {
-        let filename = "registries.json"
-        if global {
-            return try fileSystem.getOrCreateSwiftPMConfigDirectory().appending(component: filename)
-        } else {
-            let directory = try configFilePath()
-            if !fileSystem.exists(directory) {
-                try fileSystem.createDirectory(directory, recursive: true)
-            }
+    func getRegistriesConfig(sharedConfigurationDirectory: AbsolutePath? = nil) throws -> Workspace.Configuration.Registries {
+        let sharedConfigurationDirectory = try sharedConfigurationDirectory ?? self.getSharedConfigurationDirectory()
+        let sharedRegistriesFile = sharedConfigurationDirectory.map { Workspace.DefaultLocations.registriesConfigurationFile(at: $0) }
+        return try .init(
+            localRegistriesFile: self.registriesConfigFile(),
+            sharedRegistriesFile: sharedRegistriesFile,
+            fileSystem: localFileSystem
+        )
+    }
 
-            return directory.appending(component: filename)
-        }
+    func registriesConfigFile() throws -> AbsolutePath {
+        try self.getPackageRoot().appending(components: ".swiftpm", "config", "registries.json")
     }
 }
diff --git a/Sources/Commands/SwiftTool.swift b/Sources/Commands/SwiftTool.swift
@@ -536,7 +536,7 @@ public class SwiftTool {
         return netrcFilePath
     }
 
-    private func getSharedCacheDirectory() throws -> AbsolutePath? {
+    func getSharedCacheDirectory() throws -> AbsolutePath? {
         if let explicitCachePath = options.cachePath {
             // Create the explicit cache path if necessary
             if !localFileSystem.exists(explicitCachePath) {
@@ -553,7 +553,7 @@ public class SwiftTool {
         }
     }
 
-    private func getSharedConfigurationDirectory() throws -> AbsolutePath? {
+    func getSharedConfigurationDirectory() throws -> AbsolutePath? {
         if let explicitConfigPath = options.configPath {
             // Create the explicit config path if necessary
             if !localFileSystem.exists(explicitConfigPath) {
diff --git a/Sources/PackageRegistry/RegistryConfiguration.swift b/Sources/PackageRegistry/RegistryConfiguration.swift
@@ -34,6 +34,20 @@ public struct RegistryConfiguration: Hashable {
         self.defaultRegistry = nil
         self.scopedRegistries = [:]
     }
+
+    public var isEmpty: Bool {
+        return self.defaultRegistry == nil && self.scopedRegistries.isEmpty
+    }
+
+    public mutating func merge(_ other: RegistryConfiguration) {
+        if let defaultRegistry = other.defaultRegistry {
+            self.defaultRegistry = defaultRegistry
+        }
+
+        for (scope, registry) in other.scopedRegistries {
+            self.scopedRegistries[scope] = registry
+        }
+    }
 }
 
 // MARK: - Codable
diff --git a/Sources/Workspace/WorkspaceConfiguration.swift b/Sources/Workspace/WorkspaceConfiguration.swift
@@ -11,6 +11,7 @@
 import Basics
 import Foundation
 import TSCBasic
+import PackageRegistry
 
 // MARK: - Location
 
@@ -62,6 +63,11 @@ extension Workspace {
             self.sharedConfigurationDirectory.map { DefaultLocations.mirrorsConfigurationFile(at: $0) }
         }
 
+        /// Path to the shared registries configuration.
+        public var sharedRegistriesConfigurationFile: AbsolutePath? {
+            self.sharedConfigurationDirectory.map { DefaultLocations.registriesConfigurationFile(at: $0) }
+        }
+
         /// Create a new workspace location.
         ///
         /// - Parameters:
@@ -129,6 +135,10 @@ extension Workspace {
             path.appending(component: "mirrors.json")
         }
 
+        public static func registriesConfigurationFile(at path: AbsolutePath) -> AbsolutePath {
+            path.appending(component: "registries.json")
+        }
+
         public static func manifestsDirectory(at path: AbsolutePath) -> AbsolutePath {
             path.appending(component: "manifests")
         }
@@ -360,6 +370,141 @@ extension Workspace.Configuration {
     }
 }
 
+// MARK: - Registries
+
+extension Workspace.Configuration {
+    public class Registries {
+        private let localRegistries: RegistriesStorage
+        private let sharedRegistries: RegistriesStorage?
+        private let fileSystem: FileSystem
+
+        private var _configuration = RegistryConfiguration()
+        private let lock = Lock()
+
+        /// The registry configuration
+        public var configuration: RegistryConfiguration {
+            self.lock.withLock {
+                return self._configuration
+            }
+        }
+
+        /// Initialize the workspace registries configuration
+        ///
+        /// - Parameters:
+        ///   - localRegistriesFile: Path to the workspace registries configuration file
+        ///   - sharedRegistriesFile: Path to the shared registries configuration file, defaults to the standard location.
+        ///   - fileSystem: The file system to use.
+        public init(
+            localRegistriesFile: AbsolutePath,
+            sharedRegistriesFile: AbsolutePath?,
+            fileSystem: FileSystem
+        ) throws {
+            self.localRegistries = .init(path: localRegistriesFile, fileSystem: fileSystem, deleteWhenEmpty: true)
+            self.sharedRegistries = sharedRegistriesFile.map { .init(path: $0, fileSystem: fileSystem, deleteWhenEmpty: false) }
+            self.fileSystem = fileSystem
+            try self.computeRegistries()
+        }
+
+        @discardableResult
+        public func applyLocal(handler: (inout RegistryConfiguration) throws -> Void) throws -> RegistryConfiguration {
+            try self.localRegistries.apply(handler: handler)
+            try self.computeRegistries()
+            return self.configuration
+        }
+
+        @discardableResult
+        public func applyShared(handler: (inout RegistryConfiguration) throws -> Void) throws -> RegistryConfiguration {
+            guard let sharedRegistries = self.sharedRegistries else {
+                throw InternalError("shared registries not configured")
+            }
+            try sharedRegistries.apply(handler: handler)
+            try self.computeRegistries()
+            return self.configuration
+        }
+
+        // mutating the state we hold since we are passing it by reference to the workspace
+        // access should be done using a lock
+        private func computeRegistries() throws {
+            try self.lock.withLock {
+                var configuration = RegistryConfiguration()
+
+                if let sharedConfiguration = try sharedRegistries?.get() {
+                    configuration.merge(sharedConfiguration)
+                }
+
+                let localConfiguration = try localRegistries.get()
+                configuration.merge(localConfiguration)
+
+                self._configuration = configuration
+            }
+        }
+    }
+}
+
+extension Workspace.Configuration {
+    private struct RegistriesStorage {
+        private let path: AbsolutePath
+        private let fileSystem: FileSystem
+        private let deleteWhenEmpty: Bool
+
+        public init(path: AbsolutePath, fileSystem: FileSystem, deleteWhenEmpty: Bool) {
+            self.path = path
+            self.fileSystem = fileSystem
+            self.deleteWhenEmpty = deleteWhenEmpty
+        }
+
+        public func get() throws -> RegistryConfiguration {
+            return try self.fileSystem.withLock(on: self.path.parentDirectory, type: .shared) {
+                return try Self.load(self.path, fileSystem: self.fileSystem)
+            }
+        }
+
+        @discardableResult
+        public func apply(handler: (inout RegistryConfiguration) throws -> Void) throws -> RegistryConfiguration {
+            if !self.fileSystem.exists(self.path.parentDirectory) {
+                try self.fileSystem.createDirectory(self.path.parentDirectory, recursive: true)
+            }
+            return try self.fileSystem.withLock(on: self.path.parentDirectory, type: .exclusive) {
+                let configuration = try Self.load(self.path, fileSystem: self.fileSystem)
+                var updatedConfiguration = configuration
+                try handler(&updatedConfiguration)
+                if updatedConfiguration != configuration {
+                    try Self.save(updatedConfiguration, to: self.path, fileSystem: self.fileSystem, deleteWhenEmpty: self.deleteWhenEmpty)
+                }
+                return updatedConfiguration
+            }
+        }
+
+        private static func load(_ path: AbsolutePath, fileSystem: FileSystem) throws -> RegistryConfiguration {
+            guard fileSystem.exists(path) else {
+                return RegistryConfiguration()
+            }
+
+            let data: Data = try fileSystem.readFileContents(path)
+            let decoder = JSONDecoder.makeWithDefaults()
+            return try decoder.decode(RegistryConfiguration.self, from: data)
+        }
+
+        private static func save(_ configuration: RegistryConfiguration, to path: AbsolutePath, fileSystem: FileSystem, deleteWhenEmpty: Bool) throws {
+            if configuration.isEmpty {
+                if deleteWhenEmpty && fileSystem.exists(path)  {
+                    // deleteWhenEmpty is a backward compatibility mode
+                    return try fileSystem.removeFileTree(path)
+                } else if !fileSystem.exists(path)  {
+                    // nothing to do
+                    return
+                }
+            }
+
+            let encoder = JSONEncoder.makeWithDefaults()
+            let data = try encoder.encode(configuration)
+            if !fileSystem.exists(path.parentDirectory) {
+                try fileSystem.createDirectory(path.parentDirectory, recursive: true)
+            }
+            try fileSystem.writeFileContents(path, data: data)
+        }
+    }
+}
 
 // MARK: - Deprecated 8/20201
 

Original file line number	Diff line number	Diff line change
`@@ -536,7 +536,7 @@ public class SwiftTool {`
`536`	`536`	`return netrcFilePath`
`537`	`537`	`}`
`538`	`538`
`539`		`- private func getSharedCacheDirectory() throws -> AbsolutePath? {`
	`539`	`+ func getSharedCacheDirectory() throws -> AbsolutePath? {`
`540`	`540`	`if let explicitCachePath = options.cachePath {`
`541`	`541`	`// Create the explicit cache path if necessary`
`542`	`542`	`if !localFileSystem.exists(explicitCachePath) {`
`@@ -553,7 +553,7 @@ public class SwiftTool {`
`553`	`553`	`}`
`554`	`554`	`}`
`555`	`555`
`556`		`- private func getSharedConfigurationDirectory() throws -> AbsolutePath? {`
	`556`	`+ func getSharedConfigurationDirectory() throws -> AbsolutePath? {`
`557`	`557`	`if let explicitConfigPath = options.configPath {`
`558`	`558`	`// Create the explicit config path if necessary`
`559`	`559`	`if !localFileSystem.exists(explicitConfigPath) {`