GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/vscode-react-native

Public

mirrored fromhttps://github.com/microsoft/vscode-react-nativeAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
70cfd5650973cc6872aaae01ea2db7a924e6b67b

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

vscode-react-native/src/debugger

src/debugger/forkedAppWorker.ts

176lines · modecode

RawDownload
Latest commit unavailable.
1// Copyright (c) Microsoft Corporation. All rights reserved.
2// Licensed under the MIT license. See LICENSE file in the project root for details.
3
4import * as Q from "q";
5import * as path from "path";
6import * as url from "url";
7import * as child_process from "child_process";
8import * as fs from "fs";
9import {ScriptImporter, DownloadedScript} from "./scriptImporter";
10
11import { logger } from "vscode-chrome-debug-core";
12import { ErrorHelper } from "../common/error/errorHelper";
13import { IDebuggeeWorker, RNAppMessage } from "./appWorker";
14import { RemoteExtension } from "../common/remoteExtension";
15import { InternalErrorCode } from "../common/error/internalErrorCode";
16import { getLoggingDirectory } from "../extension/log/LogHelper";
17
18function printDebuggingError(error: Error, reason: any) {
19 const nestedError = ErrorHelper.getNestedError(error, InternalErrorCode.DebuggingWontWorkReloadJSAndReconnect, reason);
20
21 logger.error(nestedError.message);
22}
23
24/** This class will run the RN App logic inside a forked Node process. The framework to run the logic is provided by the file
25 * debuggerWorker.js (designed to run on a WebWorker). We add a couple of tweaks (mostly to polyfill WebWorker API) to that
26 * file and load it inside of a process.
27 * On this side we listen to IPC messages and either respond to them or redirect them to packager via MultipleLifetimeAppWorker's
28 * instance. We also intercept packager's signal to load the bundle's code and mutate the message with path to file we've downloaded
29 * to let importScripts function take this file.
30 */
31export class ForkedAppWorker implements IDebuggeeWorker {
32
33 protected scriptImporter: ScriptImporter;
34 protected debuggeeProcess: child_process.ChildProcess | null = null;
35 /** A deferred that we use to make sure that worker has been loaded completely defore start sending IPC messages */
36 protected workerLoaded = Q.defer<void>();
37 private bundleLoaded: Q.Deferred<void>;
38 private remoteExtension: RemoteExtension;
39 private logWriteStream: fs.WriteStream;
40 private logDirectory: string | null;
41
42 constructor(
43 private packagerAddress: string,
44 private packagerPort: number,
45 private sourcesStoragePath: string,
46 private projectRootPath: string,
47 private postReplyToApp: (message: any) => void,
48 private packagerRemoteRoot?: string,
49 private packagerLocalRoot?: string
50 ) {
51 this.scriptImporter = new ScriptImporter(this.packagerAddress, this.packagerPort, this.sourcesStoragePath, this.packagerRemoteRoot, this.packagerLocalRoot);
52
53 this.remoteExtension = RemoteExtension.atProjectRootPath(this.projectRootPath);
54
55 this.remoteExtension.api.Debugger.onShowDevMenu(() => {
56 this.postMessage({
57 method: "vscode_showDevMenu",
58 });
59 });
60
61 this.remoteExtension.api.Debugger.onReloadApp(() => {
62 this.postMessage({
63 method: "vscode_reloadApp",
64 });
65 });
66 }
67
68 public stop() {
69 if (this.debuggeeProcess) {
70 logger.verbose(`About to kill debuggee with pid ${this.debuggeeProcess.pid}`);
71 this.debuggeeProcess.kill();
72 this.debuggeeProcess = null;
73 }
74 }
75
76 public start(): Q.Promise<number> {
77 let scriptToRunPath = path.resolve(this.sourcesStoragePath, ScriptImporter.DEBUGGER_WORKER_FILENAME);
78 const port = Math.round(Math.random() * 40000 + 3000);
79
80 // Note that we set --inspect-brk flag to pause the process on the first line - this is
81 // required for debug adapter to set the breakpoints BEFORE the debuggee has started.
82 // The adapter will continue execution once it's done with breakpoints.
83 // --no-deprecation flag disables deprecation warnings like "[DEP0005] DeprecationWarning: Buffer() is deprecated..." and so on that leads to errors in native app
84 // https://nodejs.org/dist/latest-v7.x/docs/api/cli.html
85 const nodeArgs = [`--inspect-brk=${port}`, "--no-deprecation", scriptToRunPath];
86 // Start child Node process in debugging mode
87 // Using fork instead of spawn causes breakage of piping between app worker and VS Code debug console, e.g. console.log() in application
88 // wouldn't work. Please see https://github.com/Microsoft/vscode-react-native/issues/758
89 this.debuggeeProcess = child_process.spawn("node", nodeArgs, {
90 stdio: ["pipe", "pipe", "pipe", "ipc"],
91 })
92 .on("message", (message: any) => {
93 // 'workerLoaded' is a special message that indicates that worker is done with loading.
94 // We need to wait for it before doing any IPC because process.send doesn't seems to care
95 // about whether the message has been received or not and the first messages are often get
96 // discarded by spawned process
97 if (message && message.workerLoaded) {
98 this.workerLoaded.resolve(void 0);
99 return;
100 }
101
102 this.postReplyToApp(message);
103 })
104 .on("error", (error: Error) => {
105 printDebuggingError(ErrorHelper.getInternalError(InternalErrorCode.ReactNativeWorkerProcessThrownAnError), error);
106 });
107
108 // If special env variables are defined, then write process outputs to file
109 this.logDirectory = getLoggingDirectory();
110
111 if (this.logDirectory) {
112 this.logWriteStream = fs.createWriteStream(path.join(this.logDirectory, "nodeProcessLog.txt"));
113 this.logWriteStream.on("error", err => {
114 logger.error(`Error creating log file at path: ${this.logDirectory}. Error: ${err.toString()}\n`);
115 });
116 this.debuggeeProcess.stdout.pipe(this.logWriteStream);
117 this.debuggeeProcess.stderr.pipe(this.logWriteStream);
118 this.debuggeeProcess.on("close", () => {
119 this.logWriteStream.end();
120 });
121 }
122
123 // Resolve with port debugger server is listening on
124 // This will be sent to subscribers of MLAppWorker in "connected" event
125 logger.verbose(`Spawned debuggee process with pid ${this.debuggeeProcess.pid} listening to ${port}`);
126
127 return Q.resolve(port);
128 }
129
130 public postMessage(rnMessage: RNAppMessage): Q.Promise<RNAppMessage> {
131 // Before sending messages, make sure that the worker is loaded
132 const promise = this.workerLoaded.promise
133 .then(() => {
134 if (rnMessage.method !== "executeApplicationScript") {
135 // Before sending messages, make sure that the app script executed
136 if (this.bundleLoaded) {
137 return this.bundleLoaded.promise.then(() => {
138 return rnMessage;
139 });
140 } else {
141 return rnMessage;
142 }
143 } else {
144 this.bundleLoaded = Q.defer<void>();
145 // When packager asks worker to load bundle we download that bundle and
146 // then set url field to point to that downloaded bundle, so the worker
147 // will take our modified bundle
148 if (rnMessage.url) {
149 const packagerUrl = url.parse(rnMessage.url);
150 packagerUrl.host = `${this.packagerAddress}:${this.packagerPort}`;
151 rnMessage = {
152 ...rnMessage,
153 url: url.format(packagerUrl),
154 };
155 logger.verbose(`Packager requested runtime to load script from ${rnMessage.url}`);
156 return this.scriptImporter.downloadAppScript(<string>rnMessage.url, this.projectRootPath)
157 .then((downloadedScript: DownloadedScript) => {
158 this.bundleLoaded.resolve(void 0);
159 return Object.assign({}, rnMessage, { url: downloadedScript.filepath });
160 });
161 } else {
162 throw ErrorHelper.getInternalError(InternalErrorCode.RNMessageWithMethodExecuteApplicationScriptDoesntHaveURLProperty);
163 }
164 }
165 });
166 promise.done(
167 (message: RNAppMessage) => {
168 if (this.debuggeeProcess) {
169 this.debuggeeProcess.send({ data: message });
170 }
171 },
172 (reason) => printDebuggingError(ErrorHelper.getInternalError(InternalErrorCode.CouldntImportScriptAt, rnMessage.url), reason));
173
174 return promise;
175 }
176}
177