1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift open source project
//
// Copyright (c) 2014-2023 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import class Basics.ObservabilityScope
import func Dispatch.dispatchPrecondition
import class Dispatch.DispatchQueue
import enum PackageFingerprint.FingerprintCheckingMode
import enum PackageGraph.ContainerUpdateStrategy
import protocol PackageGraph.PackageContainer
import protocol PackageGraph.PackageContainerProvider
import struct PackageModel.PackageReference
// MARK: - Package container provider
extension Workspace: PackageContainerProvider {
public func getContainer(
for package: PackageReference,
updateStrategy: ContainerUpdateStrategy,
observabilityScope: ObservabilityScope,
on queue: DispatchQueue,
completion: @escaping (Result<any PackageContainer, any Swift.Error>) -> Void
) {
do {
switch package.kind {
// If the container is local, just create and return a local package container.
case .root, .fileSystem:
let container = try FileSystemPackageContainer(
package: package,
identityResolver: self.identityResolver,
dependencyMapper: self.dependencyMapper,
manifestLoader: self.manifestLoader,
currentToolsVersion: self.currentToolsVersion,
fileSystem: self.fileSystem,
observabilityScope: observabilityScope
)
queue.async {
completion(.success(container))
}
// Resolve the container using the repository manager.
case .localSourceControl, .remoteSourceControl:
let repositorySpecifier = try package.makeRepositorySpecifier()
self.repositoryManager.lookup(
package: package.identity,
repository: repositorySpecifier,
updateStrategy: updateStrategy.repositoryUpdateStrategy,
observabilityScope: observabilityScope,
delegateQueue: queue,
callbackQueue: queue
) { result in
dispatchPrecondition(condition: .onQueue(queue))
// Create the container wrapper.
let result = result.tryMap { handle -> PackageContainer in
// Open the repository.
//
// FIXME: Do we care about holding this open for the lifetime of the container.
let repository = try handle.open()
return try SourceControlPackageContainer(
package: package,
identityResolver: self.identityResolver,
dependencyMapper: self.dependencyMapper,
repositorySpecifier: repositorySpecifier,
repository: repository,
manifestLoader: self.manifestLoader,
currentToolsVersion: self.currentToolsVersion,
fingerprintStorage: self.fingerprints,
fingerprintCheckingMode: FingerprintCheckingMode
.map(self.configuration.fingerprintCheckingMode),
observabilityScope: observabilityScope
)
}
completion(result)
}
// Resolve the container using the registry
case .registry:
let container = RegistryPackageContainer(
package: package,
identityResolver: self.identityResolver,
dependencyMapper: self.dependencyMapper,
registryClient: self.registryClient,
manifestLoader: self.manifestLoader,
currentToolsVersion: self.currentToolsVersion,
observabilityScope: observabilityScope
)
queue.async {
completion(.success(container))
}
}
} catch {
queue.async {
completion(.failure(error))
}
}
}
}
|
