Emcee

1
import Deployer
2
import FileSystem
3
import Foundation
4
import EmceeLogging
5
import PathLib
6
import QueueModels
7
import SocketModels
8
import SSHDeployer
9
import Tmp
10
import UniqueIdentifierGenerator
11
import Zip
12

13
public final class DefaultRemoteWorkersStarter: RemoteWorkerStarter {
14
    private let sshClientProvider: SSHClientProvider
15
    private let deploymentDestination: DeploymentDestination
16
    private let emceeVersion: Version
17
    private let fileSystem: FileSystem
18
    private let logger: ContextualLogger
19
    private let tempFolder: TemporaryFolder
20
    private let uniqueIdentifierGenerator: UniqueIdentifierGenerator
21
    private let zipCompressor: ZipCompressor
22

23
    public init(
24
        sshClientProvider: SSHClientProvider,
25
        deploymentDestination: DeploymentDestination,
26
        emceeVersion: Version,
27
        fileSystem: FileSystem,
28
        logger: ContextualLogger,
29
        tempFolder: TemporaryFolder,
30
        uniqueIdentifierGenerator: UniqueIdentifierGenerator,
31
        zipCompressor: ZipCompressor
32
    ) {
33
        self.sshClientProvider = sshClientProvider
34
        self.deploymentDestination = deploymentDestination
35
        self.emceeVersion = emceeVersion
36
        self.fileSystem = fileSystem
37
        self.logger = logger
38
        self.tempFolder = tempFolder
39
        self.uniqueIdentifierGenerator = uniqueIdentifierGenerator
40
        self.zipCompressor = zipCompressor
41
    }
42
    
43
    public func deployAndStartWorker(
44
        queueAddress: SocketAddress
45
    ) throws {
46
        let deployablesGenerator = DeployablesGenerator(
47
            emceeVersion: emceeVersion,
48
            remoteEmceeBinaryName: "EmceeWorker"
49
        )
50
        let deployableItems = try deployablesGenerator.deployables()
51
        let emceeBinaryDeployableItem = try deployablesGenerator.runnerTool()
52
        
53
        let launchdPlist = RemoteWorkerLaunchdPlist(
54
            deploymentDestination: deploymentDestination,
55
            emceeVersion: emceeVersion,
56
            executableDeployableItem: emceeBinaryDeployableItem,
57
            queueAddress: queueAddress
58
        )
59
        let launchdPlistTargetPath = "launchd_\(deploymentDestination.workerId.value).plist"
60
        
61
        let filePath = try tempFolder.createFile(
62
            filename: launchdPlistTargetPath,
63
            contents: try launchdPlist.plistData()
64
        )
65
        
66
        logger.debug("Deploying to \(deploymentDestination)")
67
        
68
        let launchdDeployableItem = DeployableItem(
69
            name: "launchd_plist",
70
            files: [
71
                DeployableFile(
72
                    source: filePath,
73
                    destination: RelativePath(launchdPlistTargetPath)
74
                )
75
            ]
76
        )
77
        let launchctlDeployableCommands = LaunchctlDeployableCommands(
78
            launchdPlistDeployableItem: launchdDeployableItem,
79
            plistFilename: launchdPlistTargetPath
80
        )
81
        
82
        let deployer = DistDeployer(
83
            sshClientProvider: sshClientProvider,
84
            deploymentId: emceeVersion.value,
85
            deploymentDestination: deploymentDestination,
86
            deployableItems: deployableItems + [launchdDeployableItem],
87
            deployableCommands: [
88
                launchctlDeployableCommands.forceUnloadFromBackgroundCommand(),
89
                [
90
                    "sleep", "2"        // launchctl is async, so we have to wait :(
91
                ],
92
                launchctlDeployableCommands.forceLoadInBackgroundCommand()
93
            ],
94
            fileSystem: fileSystem,
95
            logger: logger,
96
            tempFolder: tempFolder,
97
            uniqueIdentifierGenerator: uniqueIdentifierGenerator,
98
            zipCompressor: zipCompressor
99
        )
100
        
101
        try deployer.deploy()
102
    }
103
}
104