forked from utmapp/UTM
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathUTMScriptingVirtualMachineImpl.swift
More file actions
299 lines (272 loc) · 11.4 KB
/
UTMScriptingVirtualMachineImpl.swift
File metadata and controls
299 lines (272 loc) · 11.4 KB
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
//
// Copyright © 2022 osy. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
import Foundation
import QEMUKitInternal
@MainActor
@objc(UTMScriptingVirtualMachineImpl)
class UTMScriptingVirtualMachineImpl: NSObject, UTMScriptable {
@nonobjc var box: VMData
@nonobjc var data: UTMData
@nonobjc var vm: (any UTMVirtualMachine)! {
box.wrapped
}
@objc var id: String {
vm.id.uuidString
}
@objc var name: String {
box.detailsTitleLabel
}
@objc var notes: String {
box.detailsNotes ?? ""
}
@objc var machine: String {
box.detailsSystemTargetLabel
}
@objc var architecture: String {
box.detailsSystemArchitectureLabel
}
@objc var memory: String {
box.detailsSystemMemoryLabel
}
@objc var backend: UTMScriptingBackend {
if vm is UTMQemuVirtualMachine {
return .qemu
} else if vm is UTMAppleVirtualMachine {
return .apple
} else {
return .unavailable
}
}
@objc var status: UTMScriptingStatus {
switch vm.state {
case .stopped: return .stopped
case .starting: return .starting
case .started: return .started
case .pausing: return .pausing
case .paused: return .paused
case .resuming: return .resuming
case .stopping: return .stopping
case .saving: return .pausing // FIXME: new entries
case .restoring: return .resuming // FIXME: new entries
}
}
@objc var serialPorts: [UTMScriptingSerialPortImpl] {
if let config = vm.config as? UTMQemuConfiguration {
return config.serials.indices.map({ UTMScriptingSerialPortImpl(qemuSerial: config.serials[$0], parent: self, index: $0) })
} else if let config = vm.config as? UTMAppleConfiguration {
return config.serials.indices.map({ UTMScriptingSerialPortImpl(appleSerial: config.serials[$0], parent: self, index: $0) })
} else {
return []
}
}
var guestAgent: QEMUGuestAgent! {
get async {
await (vm as? UTMQemuVirtualMachine)?.guestAgent
}
}
override var objectSpecifier: NSScriptObjectSpecifier? {
let appDescription = NSApplication.classDescription() as! NSScriptClassDescription
return NSUniqueIDSpecifier(containerClassDescription: appDescription,
containerSpecifier: nil,
key: "scriptingVirtualMachines",
uniqueID: id)
}
init(for vm: VMData, data: UTMData) {
self.box = vm
self.data = data
}
@objc func start(_ command: NSScriptCommand) {
let shouldSaveState = command.evaluatedArguments?["saveFlag"] as? Bool ?? true
withScriptCommand(command) { [self] in
if !shouldSaveState {
guard type(of: vm).capabilities.supportsDisposibleMode else {
throw ScriptingError.operationNotSupported
}
}
data.run(vm: box, startImmediately: false)
if vm.state == .stopped {
try await vm.start(options: shouldSaveState ? [] : .bootDisposibleMode)
} else if vm.state == .paused {
try await vm.resume()
} else {
throw ScriptingError.operationNotAvailable
}
}
}
@objc func suspend(_ command: NSScriptCommand) {
let shouldSaveState = command.evaluatedArguments?["saveFlag"] as? Bool ?? false
withScriptCommand(command) { [self] in
guard vm.state == .started else {
throw ScriptingError.notRunning
}
try await vm.pause()
if shouldSaveState {
try await vm.saveSnapshot(name: nil)
}
}
}
@objc func stop(_ command: NSScriptCommand) {
let stopMethod: UTMScriptingStopMethod
if let stopMethodValue = command.evaluatedArguments?["stopBy"] as? AEKeyword {
stopMethod = UTMScriptingStopMethod(rawValue: stopMethodValue) ?? .force
} else {
stopMethod = .force
}
withScriptCommand(command) { [self] in
guard vm.state == .started || stopMethod == .kill else {
throw ScriptingError.notRunning
}
switch stopMethod {
case .force:
try await vm.stop(usingMethod: .force)
case .kill:
try await vm.stop(usingMethod: .kill)
case .request:
try await vm.stop(usingMethod: .request)
}
}
}
@objc func delete(_ command: NSDeleteCommand) {
withScriptCommand(command) { [self] in
guard vm.state == .stopped else {
throw ScriptingError.notStopped
}
try await data.delete(vm: box, alsoRegistry: true)
}
}
@objc func clone(_ command: NSCloneCommand) {
let properties = command.evaluatedArguments?["WithProperties"] as? [AnyHashable : Any]
withScriptCommand(command) { [self] in
guard vm.state == .stopped else {
throw ScriptingError.notStopped
}
let newVM = try await data.clone(vm: box)
if let properties = properties, let newConfiguration = properties["configuration"] as? [AnyHashable : Any] {
let wrapper = UTMScriptingConfigImpl(newVM.config!)
try wrapper.updateConfiguration(from: newConfiguration)
try await data.save(vm: newVM)
}
}
}
}
// MARK: - Guest agent suite
@objc extension UTMScriptingVirtualMachineImpl {
@nonobjc private func withGuestAgent<Result>(_ block: (QEMUGuestAgent) async throws -> Result) async throws -> Result {
guard vm.state == .started else {
throw ScriptingError.notRunning
}
guard let vm = vm as? UTMQemuVirtualMachine else {
throw ScriptingError.operationNotSupported
}
guard let guestAgent = await vm.guestAgent else {
throw ScriptingError.guestAgentNotRunning
}
return try await block(guestAgent)
}
@objc func valueInOpenFilesWithUniqueID(_ id: Int) -> UTMScriptingGuestFileImpl {
UTMScriptingGuestFileImpl(from: id, parent: self)
}
@objc func openFile(_ command: NSScriptCommand) {
let path = command.evaluatedArguments?["path"] as? String
let mode = command.evaluatedArguments?["mode"] as? AEKeyword
let isUpdate = command.evaluatedArguments?["isUpdate"] as? Bool ?? false
withScriptCommand(command) { [self] in
guard let path = path else {
throw ScriptingError.invalidParameter
}
let modeValue: String
if let mode = mode {
switch UTMScriptingOpenMode(rawValue: mode) {
case .reading: modeValue = "r"
case .writing: modeValue = "w"
case .appending: modeValue = "a"
default: modeValue = "r"
}
} else {
modeValue = "r"
}
return try await withGuestAgent { guestAgent in
let handle = try await guestAgent.guestFileOpen(path, mode: modeValue + (isUpdate ? "+" : ""))
return UTMScriptingGuestFileImpl(from: handle, parent: self)
}
}
}
@objc func valueInProcessesWithUniqueID(_ id: Int) -> UTMScriptingGuestProcessImpl {
UTMScriptingGuestProcessImpl(from: id, parent: self)
}
@objc func execute(_ command: NSScriptCommand) {
let path = command.evaluatedArguments?["path"] as? String
let argv = command.evaluatedArguments?["argv"] as? [String]
let envp = command.evaluatedArguments?["envp"] as? [String]
let input = command.evaluatedArguments?["input"] as? String
let isBase64Encoded = command.evaluatedArguments?["isBase64Encoded"] as? Bool ?? false
let isCaptureOutput = command.evaluatedArguments?["isCaptureOutput"] as? Bool ?? false
let inputData = dataFromText(input, isBase64Encoded: isBase64Encoded)
withScriptCommand(command) { [self] in
guard let path = path else {
throw ScriptingError.invalidParameter
}
return try await withGuestAgent { guestAgent in
let pid = try await guestAgent.guestExec(path, argv: argv, envp: envp, input: inputData, captureOutput: isCaptureOutput)
return UTMScriptingGuestProcessImpl(from: pid, parent: self)
}
}
}
@objc func queryIp(_ command: NSScriptCommand) {
withScriptCommand(command) { [self] in
try await withGuestAgent { guestAgent in
let interfaces = try await guestAgent.guestNetworkGetInterfaces()
var ipv4: [String] = []
var ipv6: [String] = []
for interface in interfaces {
for ip in interface.ipAddresses {
if ip.isIpV6Address {
if ip.ipAddress != "::1" && ip.ipAddress != "0:0:0:0:0:0:0:1" {
ipv6.append(ip.ipAddress)
}
} else {
if ip.ipAddress != "127.0.0.1" {
ipv4.append(ip.ipAddress)
}
}
}
}
return ipv4 + ipv6
}
}
}
}
// MARK: - Errors
extension UTMScriptingVirtualMachineImpl {
enum ScriptingError: Error, LocalizedError {
case operationNotAvailable
case operationNotSupported
case notRunning
case notStopped
case guestAgentNotRunning
case invalidParameter
var errorDescription: String? {
switch self {
case .operationNotAvailable: return NSLocalizedString("Operation not available.", comment: "UTMScriptingVirtualMachineImpl")
case .operationNotSupported: return NSLocalizedString("Operation not supported by the backend.", comment: "UTMScriptingVirtualMachineImpl")
case .notRunning: return NSLocalizedString("The virtual machine is not running.", comment: "UTMScriptingVirtualMachineImpl")
case .notStopped: return NSLocalizedString("The virtual machine must be stopped before this operation can be performed.", comment: "UTMScriptingVirtualMachineImpl")
case .guestAgentNotRunning: return NSLocalizedString("The QEMU guest agent is not running or not installed on the guest.", comment: "UTMScriptingVirtualMachineImpl")
case .invalidParameter: return NSLocalizedString("One or more required parameters are missing or invalid.", comment: "UTMScriptingVirtualMachineImpl")
}
}
}
}