Impore the source sending feature (#30)

- Move the file handling into the extension file
- Create custom event and custom request
- Fix the after state of source sending

IoT.js-Debug-DCO-1.0-Signed-off-by: Imre Kiss [email protected]

Author: knightburton

package.json

@@ -56,8 +56,7 @@
   },
   "activationEvents": [
     "onDebug",
-    "onCommand:iotjs-debug.initialConfigurations",
-    "onCommand:iotjs-debug.getProgramName"
+    "onCommand:iotjs-debug.initialConfigurations"
   ],
   "main": "./out/extension.js",
   "files": [
@@ -115,11 +114,6 @@
                 "type": "boolean",
                 "description": "Allowes to log debug messages to the console.",
                 "default": false
-              },
-              "program": {
-                "type": "string",
-                "description": "Absolute path to file. Leave it blank if you started server in normal mode.",
-                "default": "${command:AskForProgramName}"
               }
             }
           }
@@ -136,14 +130,10 @@
               "port": 5001,
               "localRoot": "${workspaceRoot}",
               "stopOnEntry": false,
-              "debugLog": false,
-              "program": "^\"\\${command:AskForProgramName}\""
+              "debugLog": false
             }
           }
-        ],
-        "variables": {
-          "AskForProgramName": "iotjs-debug.getProgramName"
-        }
+        ]
       }
     ]
   }

src/IotjsDebugger.ts

@@ -17,21 +17,28 @@
 'use strict';
 
 import {
-  LoggingDebugSession, DebugSession, Logger, logger, InitializedEvent, OutputEvent, Thread, Source,
-  StoppedEvent, ContinuedEvent, StackFrame, TerminatedEvent, Breakpoint as AdapterBreakpoint
+  DebugSession, InitializedEvent, OutputEvent, Thread, Source,
+  StoppedEvent, ContinuedEvent, StackFrame, TerminatedEvent, Breakpoint as AdapterBreakpoint, Event, ErrorDestination
 } from 'vscode-debugadapter';
 import { DebugProtocol } from 'vscode-debugprotocol';
 import * as Fs from 'fs';
 import * as Path from 'path';
-import { IAttachRequestArguments } from './IotjsDebuggerInterfaces';
+import { IAttachRequestArguments, SourceSendingOptions } from './IotjsDebuggerInterfaces';
 import { JerryDebuggerClient, JerryDebuggerOptions } from './JerryDebuggerClient';
 import {
   JerryDebugProtocolDelegate, JerryDebugProtocolHandler, JerryMessageScriptParsed, JerryEvalResult,
   JerryMessageExceptionHit
 } from './JerryProtocolHandler';
-import { EVAL_RESULT_SUBTYPE } from './JerryProtocolConstants';
+import { EVAL_RESULT_SUBTYPE, CLIENT as CLIENT_PACKAGE } from './JerryProtocolConstants';
 
-class IotjsDebugSession extends LoggingDebugSession {
+enum SOURCE_SENDING_STATES {
+  NOP = 0,
+  WAITING = 1,
+  IN_PROGRESS = 2,
+  LAST_SENT = 3
+}
+
+class IotjsDebugSession extends DebugSession {
 
   // We don't support multiple threads, so we can use a hardcoded ID for the default thread
   private static THREAD_ID = 1;
@@ -40,15 +47,14 @@ class IotjsDebugSession extends LoggingDebugSession {
   private _debugLog: boolean = false;
   private _debuggerClient: JerryDebuggerClient;
   private _protocolhandler: JerryDebugProtocolHandler;
+  private _sourceSendingOptions: SourceSendingOptions;
 
   public constructor() {
-    super('iotjs-debug.txt');
+    super();
 
     // The debugger uses zero-based lines and columns.
     this.setDebuggerLinesStartAt1(false);
     this.setDebuggerColumnsStartAt1(false);
-
-    logger.setup(Logger.LogLevel.Verbose, /*logToFile=*/false);
   }
 
   protected threadsRequest(response: DebugProtocol.ThreadsResponse): void {
@@ -79,6 +85,11 @@ class IotjsDebugSession extends LoggingDebugSession {
     response.body.supportsStepBack = false;
     response.body.supportsRestartRequest = true;
 
+    this._sourceSendingOptions = <SourceSendingOptions>{
+      contextReset: false,
+      state: SOURCE_SENDING_STATES.NOP
+    };
+
     this.sendResponse(response);
   }
 
@@ -140,23 +151,14 @@ class IotjsDebugSession extends LoggingDebugSession {
 
     const onWaitForSource = async () => {
       this.log('onWaitForSource');
-
-      if (args.program !== '' && args.program !== '\0') {
-        if (Fs.existsSync(`${args.localRoot}/${args.program}`)) {
-          const content = Fs.readFileSync(`${args.localRoot}/${args.program}`, {
-            encoding: 'utf8',
-            flag: 'r'
-          });
-          await this._protocolhandler.sendClientSource(args.program, content)
-            .then(() => this.log('Source has been sended to the engine.'))
-            .catch(error => {
-              this.sendErrorResponse(response, 0, error);
-            });
-        } else {
-          this.sendErrorResponse(response, 0, 'You must provide a valid path to source');
+      if (this._sourceSendingOptions.state === SOURCE_SENDING_STATES.NOP) {
+        this._sourceSendingOptions.state = SOURCE_SENDING_STATES.WAITING;
+        this.sendEvent(new Event('waitForSource'));
+      } else if (this._sourceSendingOptions.state === SOURCE_SENDING_STATES.LAST_SENT) {
+        if (!this._sourceSendingOptions.contextReset) {
+          this._sourceSendingOptions.state = SOURCE_SENDING_STATES.NOP;
+          this._protocolhandler.sendClientSourceControl(CLIENT_PACKAGE.JERRY_DEBUGGER_NO_MORE_SOURCES);
         }
-      } else {
-        this.sendErrorResponse(response, 0, 'You must provide a source');
       }
     };
 
@@ -180,10 +182,15 @@ class IotjsDebugSession extends LoggingDebugSession {
     this._protocolhandler.debuggerClient = this._debuggerClient;
 
     this._debuggerClient.connect()
-      .then(() => this.log(`Connected to: ${args.address}:${args.port}`))
-      .catch(error => this.log(error));
+      .then(() => {
+        this.log(`Connected to: ${args.address}:${args.port}`);
+        this.sendResponse(response);
+      })
+      .catch(error => {
+        this.log(error);
+        this.sendErrorResponse(response, 0, error.message);
+      });
 
-    this.sendResponse(response);
     this.sendEvent(new InitializedEvent());
   }
 
@@ -349,6 +356,30 @@ class IotjsDebugSession extends LoggingDebugSession {
       .catch(error => this.sendErrorResponse(response, 0, error));
   }
 
+  protected customRequest(command: string, response: DebugProtocol.Response, args: any): void {
+    this.log('customRequest');
+
+    switch (command) {
+      case 'sendSource': {
+        this._sourceSendingOptions.state = SOURCE_SENDING_STATES.IN_PROGRESS;
+        this._protocolhandler.sendClientSource(args.program.name, args.program.source)
+          .then(() => {
+            this.log('Source has been sent to the engine.');
+            this._sourceSendingOptions.state = SOURCE_SENDING_STATES.LAST_SENT;
+            this.sendResponse(response);
+          })
+          .catch(error => {
+            this.log(error);
+            this._sourceSendingOptions.state = SOURCE_SENDING_STATES.NOP;
+            this.sendErrorResponse(response, 0, error, null, ErrorDestination.User);
+          });
+        return;
+      }
+      default:
+        super.customRequest(command, response, args);
+    }
+  }
+
   private handleSource(data: JerryMessageScriptParsed): void {
     const path = `${this._args.localRoot}/${this.pathToBasename(data.name)}`;
     const src = this._protocolhandler.getSource(data.id);

src/IotjsDebuggerInterfaces.d.ts

@@ -32,3 +32,10 @@ export interface IAttachRequestArguments extends DebugProtocol.AttachRequestArgu
   // Ask for filename if in wait-for-source mode.
   provideSource: boolean;
 }
+
+export interface SourceSendingOptions {
+  // Engine context reset is available or not.
+  contextReset: boolean;
+  // Actual state of source sending.
+  state: number;
+}

src/JerryProtocolHandler.ts

@@ -758,6 +758,16 @@ export class JerryDebugProtocolHandler {
     return result;
   }
 
+  public sendClientSourceControl(code: number): Promise<any> {
+    const validCodes: number[] = [SP.CLIENT.JERRY_DEBUGGER_NO_MORE_SOURCES, SP.CLIENT.JERRY_DEBUGGER_CONTEXT_RESET];
+
+    if (validCodes.indexOf(code) === -1) {
+      return Promise.reject('Invalid source sending control code.');
+    }
+
+    return this.sendSimpleRequest(encodeMessage(this.byteConfig, 'B', [code]));
+  }
+
   onWaitForSource() {
     this.waitForSourceEnabled = true;
     if (this.delegate.onWaitForSource) {

src/extension.ts

@@ -28,8 +28,7 @@ const initialConfigurations = [{
   port: 5001,
   localRoot: '${workspaceRoot}',
   stopOnEntry: false,
-  debugLog: false,
-  program: '${command:AskForProgramName}'
+  debugLog: false
 }];
 
 const provideInitialConfigurations = (): string => {
@@ -45,33 +44,66 @@ const provideInitialConfigurations = (): string => {
   ].join('\n');
 };
 
-const getListOfFiles = (): Array<string> => {
-  let wsFiles = Array<string>();
+const walkSync = (dir: string, filelist: string[] = []): string[] => {
+  fs.readdirSync(dir).forEach(file => {
+    filelist = fs.statSync(path.join(dir, file)).isDirectory()
+      ? walkSync(path.join(dir, file), filelist)
+      : filelist.concat(path.join(dir, file));
+  });
+
+  return filelist.filter(f => path.extname(f).toLowerCase().match(/\.(js)$/i) && f !== '');
+};
+
+const getListOfFiles = (): string[] => {
+  let wsFiles: string[] = [];
 
   vscode.workspace.workspaceFolders.map(folder => folder.uri.fsPath).forEach(entry => {
-    fs.readdirSync(entry).forEach(file => {
-      if ((fs.statSync(`${entry}/${file}`)).isFile()) {
-        if (path.extname(file).toLowerCase().match(/\.(js)$/i)) {
-          wsFiles.push(file);
-        }
-      }
-    });
+    console.log(walkSync(entry));
+    wsFiles = [...wsFiles, ...walkSync(entry)];
   });
 
-  return ['\0', ...wsFiles];
+  return wsFiles;
 };
 
 const getProgramName = (): Thenable<string> => {
   return vscode.window.showQuickPick(getListOfFiles(), {
-    placeHolder: 'Select a file you want to debug or press Enter if you are in normal mode',
+    placeHolder: 'Select a file you want to debug',
     ignoreFocusOut: true
   });
 };
 
+const getProgramSource = (path: string): string => {
+  return fs.readFileSync(path, {
+    encoding: 'utf8',
+    flag: 'r'
+  });
+};
+
+const processCustomEvent = async (e: vscode.DebugSessionCustomEvent): Promise<any> => {
+  switch (e.event) {
+    case 'waitForSource': {
+      if (vscode.debug.activeDebugSession) {
+        const path = await getProgramName().then(path => path);
+        const source = getProgramSource(path);
+
+        vscode.debug.activeDebugSession.customRequest('sendSource', {
+          program: {
+            name: path.split('/').pop(),
+            source
+          }
+        });
+      }
+      return true;
+    }
+    default:
+      return undefined;
+  }
+};
+
 export const activate = (context: vscode.ExtensionContext) => {
   context.subscriptions.push(
     vscode.commands.registerCommand('iotjs-debug.provideInitialConfigurations', provideInitialConfigurations),
-    vscode.commands.registerCommand('iotjs-debug.getProgramName', getProgramName)
+    vscode.debug.onDidReceiveDebugSessionCustomEvent(e => processCustomEvent(e))
   );
 };