Emcee

1
import AppleTools
2
import ArgLib
3
import EmceeDI
4
import DateProvider
5
import DeveloperDirLocator
6
import EmceeLogging
7
import EmceeVersion
8
import EmceeExtensions
9
import FileCache
10
import FileSystem
11
import Foundation
12
import HostnameProvider
13
import LocalHostDeterminer
14
import Metrics
15
import MetricsExtensions
16
import PathLib
17
import PluginManager
18
import ProcessController
19
import QueueModels
20
import RequestSender
21
import ResourceLocationResolver
22
import Runner
23
import SSHDeployer
24
import SynchronousWaiter
25
import TestDiscovery
26
import URLResource
27
import UniqueIdentifierGenerator
28
import WhatIsMyAddress
29
import Zip
30

31
public final class InProcessMain {
32
    public init() {}
33
    
34
    public func run() throws {
35
        let di: DI = DIImpl()
36
       
37
        di.set(
38
            FilePropertiesProviderImpl(),
39
            for: FilePropertiesProvider.self
40
        )
41
        di.set(
42
            LocalFileSystemProvider().create(),
43
            for: FileSystem.self
44
        )
45
        di.set(
46
            SystemDateProvider(),
47
            for: DateProvider.self
48
        )
49
        di.set(
50
            SpecificMetricRecorderProviderImpl(
51
                mutableMetricRecorderProvider: MutableMetricRecorderProviderImpl(
52
                    queue: DispatchQueue(
53
                        label: "MutableMetricRecorderProvider.queue",
54
                        attributes: .concurrent,
55
                        target: .global()
56
                    )
57
                )
58
            ),
59
            for: SpecificMetricRecorderProvider.self
60
        )
61
        
62
        // global metric recorder to be configured after obtaining analytics configuration 
63
        di.set(
64
            GlobalMetricRecorderImpl(),
65
            for: GlobalMetricRecorder.self
66
        )
67
        
68
        let globalMetricRecorder: GlobalMetricRecorder = try di.get()
69
        let specificMetricRecorderProvider: SpecificMetricRecorderProvider = try di.get()
70
        
71
        let logsTimeToLive = TimeUnit.days(5)
72
        
73
        let logCleaningQueue = OperationQueue()
74
        let loggingSetup = LoggingSetup(
75
            dateProvider: try di.get(),
76
            fileSystem: try di.get()
77
        )
78
        di.set(loggingSetup)
79
        
80
        let logger = try setupLogging(di: di, logsTimeToLive: logsTimeToLive, queue: logCleaningQueue)
81
            .withMetadata(key: .emceeVersion, value: EmceeVersion.version.value)
82
            .withMetadata(key: .processId, value: "\(ProcessInfo.processInfo.processIdentifier)")
83
            .withMetadata(key: .processName, value: ProcessInfo.processInfo.processName)
84
            .withMetadata(key: .hostname, value: LocalHostDeterminer.currentHostAddress)
85
        di.set(logger)
86
        
87
        defer {
88
            let timeout: TimeInterval = 10
89
            loggingSetup.tearDown(timeout: timeout)
90
            specificMetricRecorderProvider.tearDown(timeout: timeout)
91
            globalMetricRecorder.tearDown(timeout: timeout)
92
            logCleaningQueue.waitUntilAllOperationsAreFinished()
93
        }
94
        
95
        logger.trace("Arguments: \(ProcessInfo.processInfo.arguments)")
96

97
        di.set(
98
            try DetailedActivityLoggableProcessControllerProvider(di: di),
99
            for: ProcessControllerProvider.self
100
        )
101
        
102
        di.set(
103
            SubprocessSSHClientProvider(
104
                processControllerProvider: try di.get()
105
            ),
106
            for: SSHClientProvider.self
107
        )
108
        
109
        di.set(
110
            DefaultDeveloperDirLocator(
111
                processControllerProvider: try di.get()
112
            ),
113
            for: DeveloperDirLocator.self
114
        )
115
        
116
        di.set(
117
            DefaultRequestSenderProvider(
118
                logger: logger
119
            ),
120
            for: RequestSenderProvider.self
121
        )
122
        
123
        di.set(
124
            DefaultRuntimeDumpRemoteCacheProvider(
125
                senderProvider: try di.get()
126
            ),
127
            for: RuntimeDumpRemoteCacheProvider.self
128
        )
129
        
130
        di.set(
131
            try FileCache.fileCacheInDefaultLocation(
132
                dateProvider: try di.get(),
133
                fileSystem: try di.get()
134
            ),
135
            for: FileCache.self
136
        )
137
        
138
        di.set(
139
            URLResourceImpl(
140
                fileCache: try di.get(),
141
                logger: logger,
142
                urlSession: URLSession.shared
143
            ),
144
            for: URLResource.self
145
        )
146
        
147
        di.set(
148
            DefaultCommonlyUsedPathsProvider(
149
                fileManager: FileManager()
150
            ),
151
            for: CommonlyUsedPathsProvider.self
152
        )
153
        
154
        di.set(
155
            ResourceLocationResolverImpl(
156
                fileSystem: try di.get(),
157
                logger: logger,
158
                urlResource: try di.get(),
159
                processControllerProvider: try di.get(),
160
                commonlyUsedPathsProvider: try di.get()
161
            ),
162
            for: ResourceLocationResolver.self
163
        )
164
        
165
        di.set(
166
            RunnerWasteCollectorProviderImpl(),
167
            for: RunnerWasteCollectorProvider.self
168
        )
169
        
170
        di.set(
171
            MutableHostnameProviderImpl(
172
                hostname: LocalHostDeterminer.currentHostAddress
173
            ),
174
            for: MutableHostnameProvider.self
175
        )
176
        di.set(
177
            try di.get(MutableHostnameProvider.self),
178
            for: HostnameProvider.self
179
        )
180
        
181
        di.set(
182
            PluginEventBusProviderImpl(
183
                logger: logger,
184
                hostnameProvider: try di.get(),
185
                processControllerProvider: try di.get(),
186
                resourceLocationResolver: try di.get()
187
            ),
188
            for: PluginEventBusProvider.self
189
        )
190
        
191
        di.set(
192
            UuidBasedUniqueIdentifierGenerator(),
193
            for: UniqueIdentifierGenerator.self
194
        )
195
        
196
        di.set(
197
            XcResultToolImpl(
198
                dateProvider: try di.get(),
199
                logger: logger,
200
                processControllerProvider: try di.get()
201
            ),
202
            for: XcResultTool.self
203
        )
204
        
205
        di.set(
206
            DefaultTestRunnerProvider(
207
                dateProvider: try di.get(),
208
                fileSystem: try di.get(),
209
                hostnameProvider: try di.get(),
210
                processControllerProvider: try di.get(),
211
                resourceLocationResolver: try di.get(),
212
                version: EmceeVersion.version,
213
                xcResultTool: try di.get()
214
            ),
215
            for: TestRunnerProvider.self
216
        )
217
        
218
        di.set(
219
            SynchronousWaiter(),
220
            for: Waiter.self
221
        )
222
        di.set(
223
            ZipCompressorImpl(
224
                processControllerProvider: try di.get()
225
            ),
226
            for: ZipCompressor.self
227
        )
228
        di.set(
229
            AppleRunnerProvider(
230
                dateProvider: try di.get(),
231
                developerDirLocator: try di.get(),
232
                fileSystem: try di.get(),
233
                hostnameProvider: try di.get(),
234
                logger: try di.get(),
235
                pluginEventBusProvider: try di.get(),
236
                runnerWasteCollectorProvider: try di.get(),
237
                testRunnerProvider: try di.get(),
238
                uniqueIdentifierGenerator: try di.get(),
239
                waiter: try di.get()
240
            ),
241
            for: AppleRunnerProvider.self
242
        )
243
        di.set(
244
            MyAddressFetcherProviderImpl(
245
                requestSenderProvider: try di.get()
246
            ),
247
            for: MyAddressFetcherProvider.self
248
        )
249
        di.set(
250
            SynchronousMyAddressFetcherProviderImpl(
251
                myAddressFetcherProvider: try di.get(),
252
                waiter: try di.get()
253
            ),
254
            for: SynchronousMyAddressFetcherProvider.self
255
        )
256
        
257
        let commandInvoker = CommandInvoker(
258
            commands: [
259
                try DistWorkCommand(di: di),
260
                try DumpCommand(di: di),
261
                try RunTestsOnRemoteQueueCommand(di: di),
262
                try StartQueueServerCommand(di: di),
263
                try KickstartCommand(di: di),
264
                try EnableWorkerCommand(di: di),
265
                try DisableWorkerCommand(di: di),
266
                try ToggleWorkersSharingCommand(di: di),
267
                try InitTestArgFileCommand(di: di),
268
                try InitQueueServerConfigCommand(di: di),
269
                try RunTestsCommand(di: di),
270
                VersionCommand(),
271
            ],
272
            helpCommandType: .generateAutomatically
273
        )
274
        let invokableCommand = try commandInvoker.invokableCommand()
275
        
276
        di.set(
277
            try di.get(ContextualLogger.self)
278
                .withMetadata(key: .emceeCommand, value: invokableCommand.command.name)
279
        )
280
        
281
        try invokableCommand.invoke()
282
    }
283
    
284
    private func setupLogging(di: DI, logsTimeToLive: TimeUnit, queue: OperationQueue) throws -> ContextualLogger {
285
        let loggingSetup: LoggingSetup = try di.get()
286
        let logger = try loggingSetup.setupLogging(
287
            stderrVerbosity: .info,
288
            detailedLogVerbosity: .debug
289
        )
290
        
291
        try loggingSetup.cleanUpLogs(
292
            logger: logger,
293
            olderThan: try di.get(DateProvider.self).currentDate().addingTimeInterval(-logsTimeToLive.timeInterval),
294
            queue: queue,
295
            completion: { error in
296
                if let error = error {
297
                    logger.error("Failed to clean up old logs: \(error)")
298
                }
299
            }
300
        )
301
        
302
        return logger
303
    }
304
}
305