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
dbfbebd91787effa9f8df87f8fc17707a5cb28cd

Branches

Tags

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

Clone

HTTPS

Download ZIP

vscode-react-native/src/debugger

src/debugger/nodeDebugWrapper.ts

267lines · 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 fs from "fs";
7import stripJsonComments = require("strip-json-comments");
8
9import { Telemetry } from "../common/telemetry";
10import { TelemetryHelper } from "../common/telemetryHelper";
11import { RemoteExtension } from "../common/remoteExtension";
12import { RemoteTelemetryReporter, ReassignableTelemetryReporter } from "../common/telemetryReporters";
13import { ChromeDebugSession, IChromeDebugSessionOpts, ChromeDebugAdapter, logger } from "vscode-chrome-debug-core";
14import { ContinuedEvent, TerminatedEvent, Logger, Response } from "vscode-debugadapter";
15import { DebugProtocol } from "vscode-debugprotocol";
16
17import { MultipleLifetimesAppWorker } from "./appWorker";
18
19import { ReactNativeProjectHelper } from "../common/reactNativeProjectHelper";
20import * as nls from "vscode-nls";
21import { ErrorHelper } from "../common/error/errorHelper";
22import { InternalErrorCode } from "../common/error/internalErrorCode";
23const localize = nls.loadMessageBundle();
24
25export function makeSession(
26 debugSessionClass: typeof ChromeDebugSession,
27 debugSessionOpts: IChromeDebugSessionOpts,
28 telemetryReporter: ReassignableTelemetryReporter,
29 appName: string, version: string): typeof ChromeDebugSession {
30
31 return class extends debugSessionClass {
32
33 private projectRootPath: string;
34 private remoteExtension: RemoteExtension;
35 private appWorker: MultipleLifetimesAppWorker | null = null;
36
37 constructor(debuggerLinesAndColumnsStartAt1?: boolean, isServer?: boolean) {
38 super(debuggerLinesAndColumnsStartAt1, isServer, debugSessionOpts);
39 }
40
41 // Override ChromeDebugSession's sendEvent to control what we will send to client
42 public sendEvent(event: DebugProtocol.Event): void {
43 // Do not send "terminated" events signaling about session's restart to client as it would cause it
44 // to restart adapter's process, while we want to stay alive and don't want to interrupt connection
45 // to packager.
46
47 if (event.event === "terminated" && event.body && event.body.restart) {
48
49 // Worker has been reloaded and switched to "continue" state
50 // So we have to send "continued" event to client instead of "terminated"
51 // Otherwise client might mistakenly show "stopped" state
52 let continuedEvent: ContinuedEvent = {
53 event: "continued",
54 type: "event",
55 seq: event["seq"], // tslint:disable-line
56 body: { threadId: event.body.threadId },
57 };
58
59 super.sendEvent(continuedEvent);
60 return;
61 }
62
63 super.sendEvent(event);
64 }
65
66 protected dispatchRequest(request: DebugProtocol.Request): void {
67 if (request.command === "disconnect")
68 return this.disconnect(request);
69
70 if (request.command === "attach")
71 return this.attach(request);
72
73 if (request.command === "launch")
74 return this.launch(request);
75
76 return super.dispatchRequest(request);
77 }
78
79 private launch(request: DebugProtocol.Request): void {
80 this.requestSetup(request.arguments)
81 .then(() => {
82 logger.verbose(`Handle launch request: ${JSON.stringify(request.arguments, null , 2)}`);
83 return this.remoteExtension.launch(request);
84 })
85 .then(() => {
86 return this.remoteExtension.getPackagerPort(request.arguments.program);
87 })
88 .then((packagerPort: number) => {
89 this.attachRequest({
90 ...request,
91 arguments: {
92 ...request.arguments,
93 port: packagerPort,
94 },
95 });
96 })
97 .catch(error => {
98 this.bailOut(error.data || error.message);
99 });
100 }
101
102 private attach(request: DebugProtocol.Request): void {
103 this.requestSetup(request.arguments)
104 .then(() => {
105 logger.verbose(`Handle attach request: ${JSON.stringify(request.arguments, null , 2)}`);
106 return this.remoteExtension.getPackagerPort(request.arguments.program);
107 })
108 .then((packagerPort: number) => {
109 this.attachRequest({
110 ...request,
111 arguments: {
112 ...request.arguments,
113 port: request.arguments.port || packagerPort,
114 },
115 });
116 })
117 .catch(error => {
118 this.bailOut(error.data || error.message);
119 });
120 }
121
122 private disconnect(request: DebugProtocol.Request): void {
123 // The client is about to disconnect so first we need to stop app worker
124 if (this.appWorker) {
125 this.appWorker.stop();
126 }
127
128 // Then we tell the extension to stop monitoring the logcat, and then we disconnect the debugging session
129 if (request.arguments.platform === "android") {
130 this.remoteExtension.stopMonitoringLogcat()
131 .catch(reason => logger.warn(localize("CouldNotStopMonitoringLogcat", "Couldn't stop monitoring logcat: {0}", reason.message || reason)))
132 .finally(() => super.dispatchRequest(request));
133 } else {
134 super.dispatchRequest(request);
135 }
136 }
137
138 private requestSetup(args: any): Q.Promise<void> {
139 let logLevel: string = args.trace;
140 if (logLevel) {
141 logLevel = logLevel.replace(logLevel[0], logLevel[0].toUpperCase());
142 logger.setup(Logger.LogLevel[logLevel], false);
143 } else {
144 logger.setup(Logger.LogLevel.Log, false);
145 }
146
147 const projectRootPath = getProjectRoot(args);
148 return ReactNativeProjectHelper.isReactNativeProject(projectRootPath)
149 .then((result) => {
150 if (!result) {
151 throw ErrorHelper.getInternalError(InternalErrorCode.NotInReactNativeFolderError);
152 }
153 this.projectRootPath = projectRootPath;
154 this.remoteExtension = RemoteExtension.atProjectRootPath(this.projectRootPath);
155
156 // Start to send telemetry
157 telemetryReporter.reassignTo(new RemoteTelemetryReporter(
158 appName, version, Telemetry.APPINSIGHTS_INSTRUMENTATIONKEY, this.projectRootPath));
159 return void 0;
160 });
161 }
162
163 /**
164 * Runs logic needed to attach.
165 * Attach should:
166 * - Enable js debugging
167 */
168 // tslint:disable-next-line:member-ordering
169 protected attachRequest(request: DebugProtocol.Request): Q.Promise<void> {
170 const extProps = {
171 platform: {
172 value: request.arguments.platform,
173 isPii: false,
174 },
175 };
176
177 return TelemetryHelper.generate("attach", extProps, (generator) => {
178 return Q({})
179 .then(() => {
180 logger.log(localize("StartingDebuggerAppWorker", "Starting debugger app worker."));
181 // TODO: remove dependency on args.program - "program" property is technically
182 // no more required in launch configuration and could be removed
183 const workspaceRootPath = path.resolve(path.dirname(request.arguments.program), "..");
184 const sourcesStoragePath = path.join(workspaceRootPath, ".vscode", ".react");
185
186 // If launch is invoked first time, appWorker is undefined, so create it here
187 this.appWorker = new MultipleLifetimesAppWorker(
188 request.arguments,
189 sourcesStoragePath,
190 this.projectRootPath,
191 undefined);
192 this.appWorker.on("connected", (port: number) => {
193 logger.log(localize("DebuggerWorkerLoadedRuntimeOnPort", "Debugger worker loaded runtime on port {0}", port));
194 // Don't mutate original request to avoid side effects
195 let attachArguments = Object.assign({}, request.arguments, {
196 address: "localhost",
197 port,
198 restart: true,
199 request: "attach",
200 remoteRoot: undefined,
201 localRoot: undefined,
202 });
203 // Reinstantiate debug adapter, as the current implementation of ChromeDebugAdapter
204 // doesn't allow us to reattach to another debug target easily. As of now it's easier
205 // to throw previous instance out and create a new one.
206 (this as any)._debugAdapter = new (<any>debugSessionOpts.adapter)(debugSessionOpts, this);
207
208 // Explicity call _debugAdapter.attach() to prevent directly calling dispatchRequest()
209 // yield a response as "attach" even for "launch" request. Because dispatchRequest() will
210 // decide to do a sendResponse() aligning with the request parameter passed in.
211 Q((this as any)._debugAdapter.attach(attachArguments, request.seq))
212 .then((responseBody) => {
213 const response: DebugProtocol.Response = new Response(request);
214 response.body = responseBody;
215 this.sendResponse(response);
216 });
217 });
218
219 return this.appWorker.start();
220 })
221 .catch(error => this.bailOut(error.message));
222 });
223 }
224
225 /**
226 * Logs error to user and finishes the debugging process.
227 */
228 private bailOut(message: string): void {
229 logger.error(localize("CouldNotDebug", "Could not debug. {0}" , message));
230 this.sendEvent(new TerminatedEvent());
231 }
232 };
233}
234
235export function makeAdapter(debugAdapterClass: typeof ChromeDebugAdapter): typeof ChromeDebugAdapter {
236 return class extends debugAdapterClass {
237 public doAttach(port: number, targetUrl?: string, address?: string, timeout?: number): Promise<void> {
238 // We need to overwrite ChromeDebug's _attachMode to let Node2 adapter
239 // to set up breakpoints on initial pause event
240 (this as any)._attachMode = false;
241 return super.doAttach(port, targetUrl, address, timeout);
242 }
243
244 public async terminate(args: DebugProtocol.TerminatedEvent) {
245 return this.disconnect({
246 terminateDebuggee: true,
247 });
248 }
249 };
250}
251
252/**
253 * Parses settings.json file for workspace root property
254 */
255function getProjectRoot(args: any): string {
256 try {
257 let vsCodeRoot = path.resolve(args.program, "../..");
258 let settingsPath = path.resolve(vsCodeRoot, ".vscode/settings.json");
259 let settingsContent = fs.readFileSync(settingsPath, "utf8");
260 settingsContent = stripJsonComments(settingsContent);
261 let parsedSettings = JSON.parse(settingsContent);
262 let projectRootPath = parsedSettings["react-native-tools.projectRoot"] || parsedSettings["react-native-tools"].projectRoot;
263 return path.resolve(vsCodeRoot, projectRootPath);
264 } catch (e) {
265 return path.resolve(args.program, "../..");
266 }
267}
268