TypeScript ps.listProcesses函数代码示例

	async getDiagnostics(launchService: ILaunchService): Promise<string> {
		const output: string[] = [];
		const info = await launchService.getMainProcessInfo();
		return listProcesses(info.mainPID).then(async rootProcess => {

			// Environment Info
			output.push('');
			output.push(this.formatEnvironment(info));

			// Process List
			output.push('');
			output.push(this.formatProcessList(info, rootProcess));

			// Workspace Stats
			if (info.windows.some(window => window.folderURIs && window.folderURIs.length > 0 && !window.remoteAuthority)) {
				output.push('');
				output.push('Workspace Stats: ');
				output.push(await this.formatWorkspaceMetadata(info));
			}

			try {
				const data = await launchService.getRemoteDiagnostics({ includeProcesses: true, includeWorkspaceMetadata: true });
				data.forEach(diagnostics => {
					if (isRemoteDiagnosticError(diagnostics)) {
						output.push(`\n${diagnostics.errorMessage}`);
					} else {
						output.push('\n\n');
						output.push(`Remote:           ${diagnostics.hostName}`);
						output.push(this.formatMachineInfo(diagnostics.machineInfo));

						if (diagnostics.processes) {
							output.push(this.formatProcessList(info, diagnostics.processes));
						}

						if (diagnostics.workspaceMetadata) {
							for (const folder of Object.keys(diagnostics.workspaceMetadata)) {
								const metadata = diagnostics.workspaceMetadata[folder];

								let countMessage = `${metadata.fileCount} files`;
								if (metadata.maxFilesReached) {
									countMessage = `more than ${countMessage}`;
								}

								output.push(`Folder (${folder}): ${countMessage}`);
								output.push(this.formatWorkspaceStats(metadata));
							}
						}
					}
				});
			} catch (e) {
				output.push('\n\n');
				output.push(`Fetching status information from remotes failed: ${e.message}`);
			}

			output.push('');
			output.push('');

			return output.join('\n');
		});
	}

	printDiagnostics(info: IMainProcessInfo): Promise<any> {
		return listProcesses(info.mainPID).then(rootProcess => {

			// Environment Info
			console.log('');
			console.log(this.formatEnvironment(info));

			// Process List
			console.log('');
			console.log(this.formatProcessList(info, rootProcess));

			// Workspace Stats
			const workspaceStatPromises = [];
			if (info.windows.some(window => window.folderURIs && window.folderURIs.length > 0)) {
				console.log('');
				console.log('Workspace Stats: ');
				info.windows.forEach(window => {
					if (window.folderURIs.length === 0) {
						return;
					}

					console.log(`|  Window (${window.title})`);

					window.folderURIs.forEach(uriComponents => {
						const folderUri = URI.revive(uriComponents);
						if (folderUri.scheme === 'file') {
							const folder = folderUri.fsPath;
							workspaceStatPromises.push(collectWorkspaceStats(folder, ['node_modules', '.git']).then(async stats => {
								let countMessage = `${stats.fileCount} files`;
								if (stats.maxFilesReached) {
									countMessage = `more than ${countMessage}`;
								}
								console.log(`|    Folder (${basename(folder)}): ${countMessage}`);
								console.log(this.formatWorkspaceStats(stats));

								await collectLaunchConfigs(folder).then(launchConfigs => {
									if (launchConfigs.length > 0) {
										console.log(this.formatLaunchConfigs(launchConfigs));
									}
								});
							}).catch(error => {
								console.log(`|      Error: Unable to collect workspace stats for folder ${folder} (${error.toString()})`);
							}));
						} else {
							console.log(`|    Folder (${folderUri.toString()}): Workspace stats not available.`);
						}
					});
				});
			}

			return Promise.all(workspaceStatPromises).then(() => {
				console.log('');
				console.log('');
			});
		});
	}

	setInterval(() => listProcesses(remote.process.pid).then(processes => {
		processList = getProcessList(processes);
		updateProcessInfo(processList);

		const tableRows = document.getElementsByTagName('tr');
		for (let i = 0; i < tableRows.length; i++) {
			const tableRow = tableRows[i];
			tableRow.addEventListener('contextmenu', (e) => {
				showContextMenu(e);
			});
		}
	}), 1200);

	getPerformanceInfo(info: IMainProcessInfo): Promise<PerformanceInfo> {
		return listProcesses(info.mainPID).then(rootProcess => {
			const workspaceInfoMessages = [];

			// Workspace Stats
			const workspaceStatPromises = [];
			if (info.windows.some(window => window.folderURIs && window.folderURIs.length > 0)) {
				info.windows.forEach(window => {
					if (window.folderURIs.length === 0) {
						return;
					}

					workspaceInfoMessages.push(`|  Window (${window.title})`);

					window.folderURIs.forEach(uriComponents => {
						const folderUri = URI.revive(uriComponents);
						if (folderUri.scheme === 'file') {
							const folder = folderUri.fsPath;
							workspaceStatPromises.push(collectWorkspaceStats(folder, ['node_modules', '.git']).then(async stats => {

								let countMessage = `${stats.fileCount} files`;
								if (stats.maxFilesReached) {
									countMessage = `more than ${countMessage}`;
								}
								workspaceInfoMessages.push(`|    Folder (${basename(folder)}): ${countMessage}`);
								workspaceInfoMessages.push(this.formatWorkspaceStats(stats));

								const launchConfigs = await collectLaunchConfigs(folder);
								if (launchConfigs.length > 0) {
									workspaceInfoMessages.push(this.formatLaunchConfigs(launchConfigs));
								}
							}));
						} else {
							workspaceInfoMessages.push(`|    Folder (${folderUri.toString()}): RPerformance stats not available.`);
						}
					});
				});
			}

			return Promise.all(workspaceStatPromises).then(() => {
				return {
					processInfo: this.formatProcessList(info, rootProcess),
					workspaceInfo: workspaceInfoMessages.join('\n')
				};
			}).catch(error => {
				return {
					processInfo: this.formatProcessList(info, rootProcess),
					workspaceInfo: `Unable to calculate workspace stats: ${error}`
				};
			});
		});
	}

	setInterval(() => {
		ipcRenderer.send('windowsInfoRequest');

		listProcesses(data.pid).then(processes => {
			processList = getProcessList(processes);
			updateProcessInfo(processList);

			const tableRows = document.getElementsByTagName('tr');
			for (let i = 0; i < tableRows.length; i++) {
				const tableRow = tableRows[i];
				tableRow.addEventListener('contextmenu', (e) => {
					showContextMenu(e);
				});
			}
		});
	}, 1200);

export function printDiagnostics(info: IMainProcessInfo): Promise<any> {
	return listProcesses(info.mainPID).then(rootProcess => {

		// Environment Info
		console.log('');
		console.log(formatEnvironment(info));

		// Process List
		console.log('');
		console.log(formatProcessList(info, rootProcess));

		// Workspace Stats
		if (info.windows.some(window => window.folders && window.folders.length > 0)) {
			console.log('');
			console.log('Workspace Stats: ');
			info.windows.forEach(window => {
				if (window.folders.length === 0) {
					return;
				}

				console.log(`|  Window (${window.title})`);

				window.folders.forEach(folder => {
					try {
						const stats = collectWorkspaceStats(folder, ['node_modules', '.git']);
						let countMessage = `${stats.fileCount} files`;
						if (stats.maxFilesReached) {
							countMessage = `more than ${countMessage}`;
						}
						console.log(`|    Folder (${basename(folder)}): ${countMessage}`);
						console.log(formatWorkspaceStats(stats));

						const launchConfigs = collectLaunchConfigs(folder);
						if (launchConfigs.length > 0) {
							console.log(formatLaunchConfigs(launchConfigs));
						}
					} catch (error) {
						console.log(`|      Error: Unable to collect workpsace stats for folder ${folder} (${error.toString()})`);
					}
				});
			});
		}
		console.log('');
		console.log('');
	});
}

export function getPerformanceInfo(info: IMainProcessInfo): Promise<PerformanceInfo> {
	return listProcesses(info.mainPID).then(rootProcess => {
		const workspaceInfoMessages = [];

		// Workspace Stats
		const workspaceStatPromises = [];
		if (info.windows.some(window => window.folders && window.folders.length > 0)) {
			info.windows.forEach(window => {
				if (window.folders.length === 0) {
					return;
				}

				workspaceInfoMessages.push(`|  Window (${window.title})`);

				window.folders.forEach(folder => {
					workspaceStatPromises.push(collectWorkspaceStats(folder, ['node_modules', '.git']).then(async stats => {

						let countMessage = `${stats.fileCount} files`;
						if (stats.maxFilesReached) {
							countMessage = `more than ${countMessage}`;
						}
						workspaceInfoMessages.push(`|    Folder (${basename(folder)}): ${countMessage}`);
						workspaceInfoMessages.push(formatWorkspaceStats(stats));

						const launchConfigs = await collectLaunchConfigs(folder);
						if (launchConfigs.length > 0) {
							workspaceInfoMessages.push(formatLaunchConfigs(launchConfigs));
						}
					}));
				});
			});
		}

		return Promise.all(workspaceStatPromises).then(() => {
			return {
				processInfo: formatProcessList(info, rootProcess),
				workspaceInfo: workspaceInfoMessages.join('\n')
			};
		}).catch(error => {
			return {
				processInfo: formatProcessList(info, rootProcess),
				workspaceInfo: `Unable to calculate workspace stats: ${error}`
			};
		});
	});
}

	async getPerformanceInfo(launchService: ILaunchService): Promise<PerformanceInfo> {
		const info = await launchService.getMainProcessInfo();
		return Promise.all<ProcessItem, string>([listProcesses(info.mainPID), this.formatWorkspaceMetadata(info)]).then(async result => {
			let [rootProcess, workspaceInfo] = result;
			let processInfo = this.formatProcessList(info, rootProcess);

			try {
				const remoteData = await launchService.getRemoteDiagnostics({ includeProcesses: true, includeWorkspaceMetadata: true });
				remoteData.forEach(diagnostics => {
					if (isRemoteDiagnosticError(diagnostics)) {
						processInfo += `\n${diagnostics.errorMessage}`;
						workspaceInfo += `\n${diagnostics.errorMessage}`;
					} else {
						processInfo += `\n\nRemote: ${diagnostics.hostName}`;
						if (diagnostics.processes) {
							processInfo += `\n${this.formatProcessList(info, diagnostics.processes)}`;
						}

						if (diagnostics.workspaceMetadata) {
							workspaceInfo += `\n|  Remote: ${diagnostics.hostName}`;
							for (const folder of Object.keys(diagnostics.workspaceMetadata)) {
								const metadata = diagnostics.workspaceMetadata[folder];

								let countMessage = `${metadata.fileCount} files`;
								if (metadata.maxFilesReached) {
									countMessage = `more than ${countMessage}`;
								}

								workspaceInfo += `|    Folder (${folder}): ${countMessage}`;
								workspaceInfo += this.formatWorkspaceStats(metadata);
							}
						}
					}
				});
			} catch (e) {
				processInfo += `\nFetching remote data failed: ${e}`;
				workspaceInfo += `\nFetching remote data failed: ${e}`;
			}

			return {
				processInfo,
				workspaceInfo
			};
		});
	}

export function buildDiagnostics(info: IMainProcessInfo): Promise<DiagnosticInfo> {
	return listProcesses(info.mainPID).then(rootProcess => {
		const workspaceInfoMessages = [];

		// Workspace Stats
		if (info.windows.some(window => window.folders && window.folders.length > 0)) {
			info.windows.forEach(window => {
				if (window.folders.length === 0) {
					return;
				}

				workspaceInfoMessages.push(`|  Window (${window.title})`);

				window.folders.forEach(folder => {
					try {
						const stats = collectWorkspaceStats(folder, ['node_modules', '.git']);
						let countMessage = `${stats.fileCount} files`;
						if (stats.maxFilesReached) {
							countMessage = `more than ${countMessage}`;
						}
						workspaceInfoMessages.push(`|    Folder (${basename(folder)}): ${countMessage}`);
						workspaceInfoMessages.push(formatWorkspaceStats(stats));

						const launchConfigs = collectLaunchConfigs(folder);
						if (launchConfigs.length > 0) {
							workspaceInfoMessages.push(formatLaunchConfigs(launchConfigs));
						}
					} catch (error) {
						workspaceInfoMessages.push(`|      Error: Unable to collect workpsace stats for folder ${folder} (${error.toString()})`);
					}
				});
			});
		}

		return {
			versionInfo: getVersionInfo(),
			systemInfo: getSystemInfo(info),
			processInfo: getProcessList(info, rootProcess),
			workspaceInfo: workspaceInfoMessages.join('\n')
		};
	});
}