TypeScript vscode.OutputChannel類代碼示例

export function batchExecuteFile(
    server: Server,
    editor: TextEditor,
    edit: TextEditorEdit,
    args: any[]) {
    batchOutputChannel = batchOutputChannel ||
        window.createOutputChannel('Lean: Batch File Output');

    const fileName = editor.document.fileName;

    const executablePath = server.executablePath;

    const lean = child.spawn(executablePath, [fileName],
        { cwd: workspace.rootPath, env: {} /* TODO(gabriel): take from server */ });

    batchOutputChannel.clear();

    carrier.carry(lean.stdout, (line) => {
        batchOutputChannel.appendLine(line);
    });

    carrier.carry(lean.stderr, (line) => {
        batchOutputChannel.appendLine(line);
    });

    lean.on('close', (code) => {
      /* not sure if we need to do anything here */
    });

    batchOutputChannel.show(true);
}

		window.showQuickPick(items).then((value) => {
			if(value) {
				outputChannel.appendLine('');
				outputChannel.appendLine(`Killing process ${value.label} (pid: ${value.pid})`);
				outputChannel.appendLine('');
				kill(value.pid, 'SIGTERM');
			}
		});

export function logError(error: string, notify: boolean = true) {
    var channel = getChannel(OUTPUT_CHANNEL_NAME);
    channel.appendLine('Error encountered during psake operation.')
    channel.appendLine(`E: ${error}`);

    if (notify) {
        window.showErrorMessage(error);
    }
}

export function addToOutput(message: string): void {
    const title = `${new Date().toLocaleString()}:`;

    // Create a sort of title, to differentiate between messages
    outputChannel.appendLine(title);
    outputChannel.appendLine('-'.repeat(title.length));

    // Append actual output
    outputChannel.appendLine(`${message}\n`);
}

    execPythonFile(pythonSettings.pythonPath, testArgs, rootDirectory, true, (data: string) => {
        if (data.startsWith('READY' + os.EOL)) {
            // debug socket server has started.
            launchDef.resolve();
            data = data.substring(('READY' + os.EOL).length);
        }

        if (!outputChannelShown) {
            outputChannelShown = true;
            outChannel.show();
        }
        outChannel.append(data);
    }, token).catch(reason => {

	p.on('exit', (_code: number, signal: string) => {
		runningProcesses.delete(p.pid);

		if (signal === 'SIGTERM') {
			outputChannel.appendLine('Successfully killed process');
			outputChannel.appendLine('-----------------------');
			outputChannel.appendLine('');
		} else {
			outputChannel.appendLine('-----------------------');
			outputChannel.appendLine('');
		}
		validateAllDocuments();
	});

 execPythonFile(pythonSettings.pythonPath, [testLauncherFile].concat(nosetestlauncherargs).concat(noseTestArgs.concat(testPaths)), rootDirectory, true, (data: string) => {
     if (data === 'READY' + os.EOL) {
         // debug socket server has started
         launchDef.resolve();
     }
     else {
         if (!outputChannelShown) {
             outputChannelShown = true;
             outChannel.show();
         }
         outChannel.append(data);
     }
 }, token).catch(reason => {

 tmp.file((err, tmpPath, fd, cleanupCallback) => {
     if (err) {
         return reject(err);
     }
     
     output.appendLine(`[INFO] Downloading to ${tmpPath}...`);
     
     const outStream = fs.createWriteStream(null, { fd: fd });
     
     outStream.once('error', err => reject(err));
     inStream.once('error', err => reject(err));
     
     outStream.once('finish', () => {
         // At this point, the asset has finished downloading.
         
         output.appendLine(`[INFO] Download complete!`);
         output.appendLine(`[INFO] Decompressing...`);
         
         return decompress(tmpPath, DefaultInstallLocation)
             .then(files => {
                 output.appendLine(`[INFO] Done! ${files.length} files unpacked.`)
                 return resolve(true);
             })
             .catch(err => {
                 output.appendLine(`[ERROR] ${err}`);
                 return reject(err);
             });
     });
     
     inStream.pipe(outStream);
 });

 process.on('exit', (code, signal) => {
     outputChannel.appendLine(`\nexit: code=${code}, signal=${signal}`);
     processExited = true;
     if (processClosed) {
         processProcessEnding(code);
     }
 });