-
Notifications
You must be signed in to change notification settings - Fork 947
/
index.tsx
345 lines (337 loc) · 13.3 KB
/
index.tsx
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
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @format
*/
import {exec} from 'child_process';
import {promisify} from 'util';
import {getEnvInfo} from './environmentInfo';
export {getEnvInfo} from './environmentInfo';
import * as watchman from 'fb-watchman';
import * as fs from 'fs';
import * as path from 'path';
import type {FlipperDoctor} from 'flipper-common';
import * as fs_extra from 'fs-extra';
export function getHealthchecks(): FlipperDoctor.Healthchecks {
return {
common: {
label: 'Common',
isRequired: true,
isSkipped: false,
healthchecks: [
{
key: 'common.openssl',
label: 'OpenSSL Installed',
run: async (_: FlipperDoctor.EnvironmentInfo) => {
const result = await tryExecuteCommand('openssl version');
const hasProblem = result.hasProblem;
const message = hasProblem
? `OpenSSL (https://wiki.openssl.org/index.php/Binaries) is not installed or not added to PATH. ${result.message}.`
: `OpenSSL (https://wiki.openssl.org/index.php/Binaries) is installed and added to PATH. ${result.message}.`;
return {
hasProblem,
message,
};
},
},
{
key: 'common.watchman',
label: 'Watchman Installed',
run: async (_: FlipperDoctor.EnvironmentInfo) => {
const isAvailable = await isWatchmanAvailable();
return {
hasProblem: !isAvailable,
message: isAvailable
? 'Watchman file watching service (https://facebook.github.io/watchman/) is installed and added to PATH. Live reloading after changes during Flipper plugin development is enabled.'
: 'Watchman file watching service (https://facebook.github.io/watchman/) is not installed or not added to PATH. Live reloading after changes during Flipper plugin development is disabled.',
};
},
},
],
},
android: {
label: 'Android',
isRequired: false,
isSkipped: false,
healthchecks: [
{
key: 'android.sdk',
label: 'SDK Installed',
isRequired: true,
run: async (_: FlipperDoctor.EnvironmentInfo) => {
const androidHome = process.env.ANDROID_HOME;
const androidSdkRoot = process.env.ANDROID_SDK_ROOT;
let androidHomeResult: FlipperDoctor.HealthcheckRunResult;
if (!androidHome) {
androidHomeResult = {
hasProblem: true,
message: `ANDROID_HOME is not defined. You can use Flipper Settings (File > Preferences) to point to its location.`,
};
} else if (!fs.existsSync(androidHome)) {
androidHomeResult = {
hasProblem: true,
message: `ANDROID_HOME point to a folder which does not exist: ${androidHome}. You can use Flipper Settings (File > Preferences) to point to a different location.`,
};
} else {
const platformToolsDir = path.join(androidHome, 'platform-tools');
if (!fs.existsSync(platformToolsDir)) {
androidHomeResult = {
hasProblem: true,
message: `Android SDK Platform Tools not found at the expected location "${platformToolsDir}". Probably they are not installed.`,
};
} else {
androidHomeResult = await tryExecuteCommand(
`"${path.join(platformToolsDir, 'adb')}" version`,
);
}
}
if (androidHomeResult.hasProblem == false) {
return androidHomeResult;
}
let androidSdkRootResult: FlipperDoctor.HealthcheckRunResult;
if (!androidSdkRoot) {
androidSdkRootResult = {
hasProblem: true,
message: `ANDROID_SDK_ROOT is not defined. You can use Flipper Settings (File > Preferences) to point to its location.`,
};
} else if (!fs.existsSync(androidSdkRoot)) {
androidSdkRootResult = {
hasProblem: true,
message: `ANDROID_SDK_ROOT point to a folder which does not exist: ${androidSdkRoot}. You can use Flipper Settings (File > Preferences) to point to a different location.`,
};
} else {
const platformToolsDir = path.join(
androidSdkRoot,
'platform-tools',
);
if (!fs.existsSync(platformToolsDir)) {
androidSdkRootResult = {
hasProblem: true,
message: `Android SDK Platform Tools not found at the expected location "${platformToolsDir}". Probably they are not installed.`,
};
} else {
androidSdkRootResult = await tryExecuteCommand(
`"${path.join(platformToolsDir, 'adb')}" version`,
);
}
}
return androidSdkRootResult;
},
},
],
},
ios: {
label: 'iOS',
...(process.platform === 'darwin'
? {
isRequired: false,
isSkipped: false,
healthchecks: [
{
key: 'ios.sdk',
label: 'SDK Installed',
isRequired: true,
run: async (e: FlipperDoctor.EnvironmentInfo) => {
const hasProblem =
!e.SDKs['iOS SDK'] ||
!e.SDKs['iOS SDK'].Platforms ||
!e.SDKs['iOS SDK'].Platforms.length;
const message = hasProblem
? 'iOS SDK is not installed. You can install it using Xcode (https://developer.apple.com/xcode/).'
: `iOS SDK is installed for the following platforms: ${JSON.stringify(
e.SDKs['iOS SDK'].Platforms,
)}.`;
return {
hasProblem,
message,
};
},
},
{
key: 'ios.xcode',
label: 'XCode Installed',
isRequired: true,
run: async (e: FlipperDoctor.EnvironmentInfo) => {
const hasProblem = e.IDEs == null || e.IDEs.Xcode == null;
const message = hasProblem
? 'Xcode (https://developer.apple.com/xcode/) is not installed.'
: `Xcode version ${e.IDEs.Xcode.version} is installed at "${e.IDEs.Xcode.path}".`;
return {
hasProblem,
message,
};
},
},
{
key: 'ios.xcode-select',
label: 'xcode-select set',
isRequired: true,
run: async (_: FlipperDoctor.EnvironmentInfo) => {
const result = await tryExecuteCommand('xcode-select -p');
if (result.hasProblem) {
return {
hasProblem: true,
message: `Xcode version is not selected. You can select it using command "sudo xcode-select -switch <path/to/>Xcode.app". ${result.message}.`,
};
}
const selectedXcode = result.stdout!.toString().trim();
if (selectedXcode == '/Library/Developer/CommandLineTools') {
return {
hasProblem: true,
message: `xcode-select has no Xcode selected, You can select it using command "sudo xcode-select -switch <path/to/>Xcode.app".`,
};
}
if ((await fs_extra.pathExists(selectedXcode)) == false) {
return {
hasProblem: true,
message: `xcode-select has path of ${selectedXcode}, however this path does not exist on disk. Run "sudo xcode-select --switch" with a valid Xcode.app path.`,
};
}
return {
hasProblem: false,
message: `xcode-select has path of ${selectedXcode}.`,
};
},
},
{
key: 'ios.xctrace',
label: 'xctrace exists',
isRequired: true,
run: async (_: FlipperDoctor.EnvironmentInfo) => {
const result = await tryExecuteCommand(
'xcrun xctrace version',
);
const hasProblem = result.hasProblem;
const message = hasProblem
? `xctrace is not available. Please ensure you have Xcode installed and are running a recent version (https://developer.apple.com/xcode/). ${result.message}.`
: `xctrace is available. ${result.message}.`;
return {
hasProblem,
message,
};
},
},
{
key: 'ios.idb',
label: 'IDB installed',
isRequired: false,
run: async (
_: FlipperDoctor.EnvironmentInfo,
settings?: {enablePhysicalIOS: boolean; idbPath: string},
) => {
if (!settings) {
return {
hasProblem: false,
message:
'Not enough context to check IDB installation. Needs to be run through Flipper UI.',
};
}
if (!settings.enablePhysicalIOS) {
return {
hasProblem: false,
message:
'Using physical iOS devices is disabled in settings. So IDB is not required.',
};
}
const result = await tryExecuteCommand(
`${settings?.idbPath} --help`,
);
const hasProblem = result.hasProblem;
const message = hasProblem
? `IDB is required to use Flipper with iOS devices. It can be installed from https://github.com/facebook/idb and configured in Flipper settings. You can also disable physical iOS device support in settings. Current setting: ${settings.idbPath} isn't a valid IDB installation.`
: 'Flipper is configured to use your IDB installation.';
return {
hasProblem,
message,
};
},
},
],
}
: {
isSkipped: true,
skipReason: `Healthcheck is skipped, because iOS development is not supported on the current platform "${process.platform}".`,
}),
},
};
}
export async function runHealthchecks(): Promise<
Array<FlipperDoctor.CategoryResult | FlipperDoctor.SkippedHealthcheckCategory>
> {
const environmentInfo = await getEnvInfo();
const healthchecks: FlipperDoctor.Healthchecks = getHealthchecks();
const results: Array<
FlipperDoctor.CategoryResult | FlipperDoctor.SkippedHealthcheckCategory
> = await Promise.all(
Object.entries(healthchecks).map(async ([key, category]) => {
if (category.isSkipped) {
return category;
}
const categoryResult: FlipperDoctor.CategoryResult = [
key,
{
label: category.label,
results: await Promise.all(
category.healthchecks.map(
async ({key, label, run, isRequired}) => ({
key,
label,
isRequired: isRequired ?? true,
result: await run!(environmentInfo).catch((e) => {
console.warn(`Health check ${key}/${label} failed with:`, e);
// TODO Improve result type to be: OK | Problem(message, fix...)
return {
hasProblem: true,
};
}),
}),
),
),
},
];
return categoryResult;
}),
);
return results;
}
async function tryExecuteCommand(
command: string,
): Promise<FlipperDoctor.SubprocessHealtcheckRunResult> {
try {
const output = await promisify(exec)(command);
return {
hasProblem: false,
message: `Command "${command}" successfully executed with output: ${output.stdout}`,
stdout: output.stdout,
};
} catch (err) {
return {
hasProblem: true,
message: `Command "${command}" failed to execute with output: ${err.message}`,
};
}
}
async function isWatchmanAvailable(): Promise<boolean> {
const client = new watchman.Client();
return new Promise((resolve) => {
const complete = (result: boolean) => {
resolve(result);
client.removeAllListeners('error');
client.end();
};
client.once('error', () => complete(false));
client.capabilityCheck(
{optional: [], required: ['relative_root']},
(error) => {
if (error) {
complete(false);
return;
}
complete(true);
},
);
});
}