Emcee

1
import ArgLib
2
import EmceeDI
3
import EmceeLogging
4
import EmceeVersion
5
import Foundation
6
import LocalHostDeterminer
7
import MetricsExtensions
8
import PathLib
9
import QueueModels
10
import SignalHandling
11
import SimulatorPool
12
import Tmp
13
import TestDiscovery
14

15
public final class DumpCommand: Command {
16
    public let name = "dump"
17
    public let description = "Performs test discovery and dumps information about discovered tests into JSON file"
18
    public let arguments: Arguments = [
19
        ArgumentDescriptions.emceeVersion.asOptional,
20
        ArgumentDescriptions.output.asRequired,
21
        ArgumentDescriptions.tempFolder.asRequired,
22
        ArgumentDescriptions.testArgFile.asRequired,
23
        ArgumentDescriptions.remoteCacheConfig.asOptional,
24
        ArgumentDescriptions.hostname.asOptional,
25
    ]
26
    
27
    private let di: DI
28
    private let encoder = JSONEncoder.pretty()
29
    
30
    public init(di: DI) throws {
31
        self.di = di
32
    }
33

34
    public func run(payload: CommandPayload) throws {
35
        let hostname: String = try payload.optionalSingleTypedValue(argumentName: ArgumentDescriptions.hostname.name) ?? LocalHostDeterminer.currentHostAddress
36
        try HostnameSetup.update(hostname: hostname, di: di)
37
    
38
        let testArgFile = try ArgumentsReader.testArgFile(try payload.expectedSingleTypedValue(argumentName: ArgumentDescriptions.testArgFile.name))
39
        let remoteCacheConfig = try ArgumentsReader.remoteCacheConfig(
40
            try payload.optionalSingleTypedValue(argumentName: ArgumentDescriptions.remoteCacheConfig.name)
41
        )
42
        let tempFolder = try TemporaryFolder(
43
            containerPath: try payload.expectedSingleTypedValue(argumentName: ArgumentDescriptions.tempFolder.name)
44
        )
45
        let outputPath: AbsolutePath = try payload.expectedSingleTypedValue(argumentName: ArgumentDescriptions.output.name)
46
        let emceeVersion: Version = try payload.optionalSingleTypedValue(argumentName: ArgumentDescriptions.emceeVersion.name) ?? EmceeVersion.version
47
        
48
        try di.get(GlobalMetricRecorder.self).set(analyticsConfiguration: testArgFile.prioritizedJob.analyticsConfiguration)
49
        if let kibanaConfiguration = testArgFile.prioritizedJob.analyticsConfiguration.kibanaConfiguration {
50
            try di.get(LoggingSetup.self).set(kibanaConfiguration: kibanaConfiguration)
51
        }
52
        di.set(
53
            try di.get(ContextualLogger.self).with(
54
                analyticsConfiguration: testArgFile.prioritizedJob.analyticsConfiguration
55
            )
56
        )
57
        
58
        let logger = try di.get(ContextualLogger.self)
59
        
60
        let onDemandSimulatorPool = try OnDemandSimulatorPoolFactory.create(
61
            di: di,
62
            hostname: hostname,
63
            logger: logger,
64
            tempFolder: tempFolder,
65
            version: emceeVersion
66
        )
67
        defer { onDemandSimulatorPool.deleteSimulators() }
68
        
69
        di.set(onDemandSimulatorPool, for: OnDemandSimulatorPool.self)
70
        
71
        SignalHandling.addSignalHandler(signals: [.term, .int]) { [logger] signal in
72
            logger.trace("Got signal: \(signal)")
73
            onDemandSimulatorPool.deleteSimulators()
74
        }
75
        
76
        di.set(
77
            TestDiscoveryQuerierImpl(
78
                dateProvider: try di.get(),
79
                developerDirLocator: try di.get(),
80
                fileSystem: try di.get(),
81
                hostname: hostname,
82
                globalMetricRecorder: try di.get(),
83
                specificMetricRecorderProvider: try di.get(),
84
                onDemandSimulatorPool: try di.get(),
85
                pluginEventBusProvider: try di.get(),
86
                processControllerProvider: try di.get(),
87
                resourceLocationResolver: try di.get(),
88
                runnerWasteCollectorProvider: try di.get(),
89
                tempFolder: tempFolder,
90
                testRunnerProvider: try di.get(),
91
                uniqueIdentifierGenerator: try di.get(),
92
                version: emceeVersion,
93
                waiter: try di.get()
94
            ),
95
            for: TestDiscoveryQuerier.self
96
        )
97
        
98
        let discoverer = PipelinedTestDiscoverer(
99
            runtimeDumpRemoteCacheProvider: try di.get(),
100
            testDiscoveryQuerier: try di.get(),
101
            urlResource: try di.get()
102
        )
103
        
104
        let dumpedTests = try discoverer.performTestDiscovery(
105
            logger: logger,
106
            testArgFile: testArgFile,
107
            remoteCacheConfig: remoteCacheConfig
108
        )
109
        
110
        do {
111
            let encodedResult = try encoder.encode(dumpedTests)
112
            try encodedResult.write(to: outputPath.fileUrl, options: [.atomic])
113
            logger.info("Wrote test discovery result into \(outputPath)")
114
        } catch {
115
            logger.error("Failed to write output: \(error)")
116
        }
117
    }
118
}
119