Better terminal re-use method

haneefdm · haneefdm · commit 41ce39f4eb01 · 2021-07-26T11:10:23.000-07:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,4 +1,11 @@
 ChangeLog
+
+# V0.3.14.pre1
+New Features:
+   * Support for RTT (SEGGER RealTimeTrace) with OpenOCD. JLink is not supported yet
+     See [Issue#456](https://github.com/Marus/cortex-debug/issues/456) for more info
+   * `demangle` is by default true. You can turn it off in `launch.json`
+   
 # V0.3.13
 
 New Features:
diff --git a/package.json b/package.json
@@ -1904,5 +1904,5 @@
         "compile": "webpack --mode development",
         "test-compile": "tsc -p ./"
     },
-    "version": "0.3.13-pre1"
+    "version": "0.3.14-pre1"
 }
diff --git a/src/frontend/extension.ts b/src/frontend/extension.ts
@@ -19,7 +19,7 @@ import { FileSWOSource } from './swo/sources/file';
 import { SerialSWOSource } from './swo/sources/serial';
 import { DisassemblyContentProvider } from './disassembly_content_provider';
 import { SymbolInformation, SymbolScope } from '../symbols';
-import { RTTTerminal } from './rtt_terminal';
+import { RTTTerminal, TerminalServer } from './rtt_terminal';
 
 const commandExistsSync = require('command-exists').sync;
 interface SVDInfo {
@@ -36,6 +36,7 @@ export class CortexDebugExtension {
     private rttSources: SocketRTTSource[] = [];
     private rttTerminals: RTTTerminal[] = [];
     private rttPortMap: { [channel: number]: string} = {};
+    private rttTermServer = new TerminalServer();
 
 
     private peripheralProvider: PeripheralTreeProvider;
@@ -546,10 +547,10 @@ export class CortexDebugExtension {
         });
     }
 
-    private rttCreateTerninal(decoder: RTTConsoleDecoderOpts) {
+    private async rttCreateTerninal(decoder: RTTConsoleDecoderOpts) {
         for (const terminal of this.rttTerminals) {
-            if (terminal.canReuse(decoder)) {
-                terminal.inUse = true;
+            const success = await terminal.tryReuse(decoder);
+            if (success) {
                 if (vscode.debug.activeDebugConsole) {
                     vscode.debug.activeDebugConsole.appendLine(
                         `Reusing RTT terminal for channel ${decoder.port} on tcp port ${decoder.tcpPort}`
@@ -565,7 +566,7 @@ export class CortexDebugExtension {
         if (!this.nodeExecExists) {
             vscode.window.showErrorMessage('RTT terminal needs "node" to be installed. Visit\nhttps://nodejs.org\nto doanload and install')
         } else {
-            const newTerminal = new RTTTerminal(this.context, decoder);
+            const newTerminal = new RTTTerminal(this.context, decoder, this.rttTermServer);
             if (newTerminal.startTerminal()) {
                 this.rttTerminals.push(newTerminal);
                 if (vscode.debug.activeDebugConsole) {
diff --git a/src/frontend/rtt_terminal.ts b/src/frontend/rtt_terminal.ts
@@ -1,10 +1,44 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
 import * as fs from 'fs';
-import { RTTConsoleDecoderOpts, TerminalInputMode } from '../common';
+import * as net from 'net';
+import { getAnyFreePort, RTTConsoleDecoderOpts, TerminalInputMode } from '../common';
 import { SWORTTSource } from './swo/sources/common';
 import EventEmitter = require('events');
+import { getNonce } from './swo/common';
+
+export interface IRTTTerminalOptions
+{
+    port      : string;
+    prompt    : string;
+    noprompt  : boolean;
+    clear     : boolean;
+    logfile   : string;
+    inputmode : TerminalInputMode;
+    binary    : boolean;
+    scale     : number;
+    encoding  : string;
+    nonce     : string;
+}
+
+export class RTTTerminalOptions implements IRTTTerminalOptions {
+    constructor(options: RTTConsoleDecoderOpts,
+        public nonce,
+        public port      = options.tcpPort,
+        public prompt    = options.prompt || `RTT-${options.port}> `,
+        public noprompt  = !!options.noprompt,
+        public clear     = !!options.clear,
+        public logfile   = options.logfile || '',
+        public inputmode = options.inputmode,
+        public binary    = options.type === 'binary',
+        public scale     = options.scale || 1,
+        public encoding  = options.encoding || (options.type === 'binary' ? 'unsigned' : 'utf8'),
+    ) {}
+}
+
 export class RTTTerminal extends EventEmitter implements SWORTTSource   {
+    protected termOptions: RTTTerminalOptions;
+    protected nonce = getNonce();
     connected: boolean;
     protected _rttTerminal: vscode.Terminal = null;
     public get rttTerminal(): vscode.Terminal {
@@ -26,8 +60,10 @@ export class RTTTerminal extends EventEmitter implements SWORTTSource   {
 
     constructor(
         protected context: vscode.ExtensionContext,
-        public options: RTTConsoleDecoderOpts) {
+        public options: RTTConsoleDecoderOpts,
+        protected rttTermServer: TerminalServer) {
         super();
+        this.termOptions = new RTTTerminalOptions(options, this.nonce);
     }
     dispose() {
         // process.kill(this.rttTerminal.processId)
@@ -40,47 +76,26 @@ export class RTTTerminal extends EventEmitter implements SWORTTSource   {
     }
 
     public startTerminal(): boolean {
+        if (this.connected) {
+            return true;
+        }
         const script = path.join(this.context.extensionPath, 'dist', 'tcp_cat.bundle.js');
-        this._name = RTTTerminal.createTermName(this.options);
+        this._name = RTTTerminal.createTermName(this.options, null);
         const args = {
             name: this.name,
             shellPath: 'node',
             shellArgs: [script,
-                "--port", this.options.tcpPort,   // Can be [host:]port
-                "--encoding", this.options.encoding || 'utf8'
+                "--useserver", this.rttTermServer.portNumber().toString(),
+                "--nonce", this.termOptions.nonce
             ]
         };
 
-        if (this.options.noprompt) {
-            args.shellArgs.push('--noprompt');
-        } else {
-            args.shellArgs.push('--prompt', this.options.prompt || `RTT-${this.options.port}> `);
-        }
-
-        if (this.options.clear) {
-            args.shellArgs.push('--clear');
-        }
-        if (this.options.inputmode === TerminalInputMode.RAW) {
-            args.shellArgs.push('--raw');
-        } else if (this.options.inputmode === TerminalInputMode.RAWECHO) {
-            args.shellArgs.push('--rawecho');
-        }
-
-        if (this.options.type === 'binary') {
-            args.shellArgs.push('--binary');
-            if (this.options.scale) {
-                args.shellArgs.push('--scale', `${this.options.scale}`);
-            }
-        }
-
         if (this.options.logfile) {
             try {
                 fs.writeFileSync(this.options.logfile, "");
-                args.shellArgs.push('--logfile', this.options.logfile);
             }
             catch (e) {
-                vscode.window.showErrorMessage(
-                    `RTT logging failed ${this.options.logfile}: ${e.toString()}`);
+                vscode.window.showErrorMessage(`RTT logging failed ${this.options.logfile}: ${e.toString()}`);
             }
         }
 
@@ -89,6 +104,8 @@ export class RTTTerminal extends EventEmitter implements SWORTTSource   {
             setTimeout(() => {
                 this._rttTerminal.show();
             }, 100);
+            this.rttTermServer.addClient(this.nonce);
+            this.sendOptions(this.termOptions);
             this.connected = true;
             this.inUse = true;
             return true;
@@ -99,24 +116,144 @@ export class RTTTerminal extends EventEmitter implements SWORTTSource   {
         }     
     }
 
-    static createTermName(options: RTTConsoleDecoderOpts): string {
+    static createTermName(options: RTTConsoleDecoderOpts, existing: string | null): string {
         const channel = options.port || 0;
         const orig = options.label || `RTT Ch:${channel}`;
         let ret = orig;
         let count = 1;
         while (vscode.window.terminals.findIndex((t) => t.name === ret) >= 0) {
+            if (existing === ret) {
+                return existing;
+            }
             ret = `${orig}-${count}`;
             count = count + 1;
         }
         return ret;
     }
 
-    public canReuse(options: RTTConsoleDecoderOpts) {
-        for (const prop of ['type', 'tcpPort', 'port', 'label', 'prompt', 'noprompt', 'logfile', 'clear', 'scale']) {
-            if (options[prop] !== this.options[prop]) {
+    // If all goes well, this will reset the terminal options. The original port (meaning channel) name
+    // has to match and the label for the VSCode terminal has to match. If successful, tt will reset the
+    // Terminal options and mark it as used (inUse = true) as well.
+    public async tryReuse(options: RTTConsoleDecoderOpts): Promise<boolean> {
+        if (this.options.port === options.port) {
+            // See if we are going to get the same label as before because that cannot be changed
+            const newName = RTTTerminal.createTermName(options, this._rttTerminal.name);
+            if (newName !== this._rttTerminal.name) {
                 return false;
             }
+            const termOptions = new RTTTerminalOptions(options, this.termOptions.nonce);
+            const ret = await this.sendOptions(termOptions);
+            return ret;
+        }
+        return false;
+    }
+
+    private sendOptions(options: RTTTerminalOptions): boolean {
+        const str = JSON.stringify(options) + '\n';
+        if (this.rttTermServer.sendToClient(this.nonce, str)) {
+            this.termOptions = options;
+            this.inUse = true;
+            return true;
         }
-        return true;
+        return false;
+    }
+}
+
+export class TerminalServer {
+    protected server: net.Server = null;
+    protected port: number;
+    protected socketByNonce: Map<string, net.Socket> = new Map();
+    protected nonceBySocket: Map<net.Socket, string> = new Map();
+
+    constructor() {
+        this.createServer();
+    }
+
+    public portNumber(): number { return this.port; }
+    public isConnected(): boolean { return !!this.server; }
+    private createServer() {
+        getAnyFreePort(55000).then((x) => {
+            this.port = x;
+            const newServer = net.createServer(this.onNewClient.bind(this));
+            newServer.listen(this.port, 'localhost', () => {
+                this.server = newServer;
+            });
+            newServer.on(('error'), (e) => {
+                console.log(e);
+            });
+            newServer.on('close', () => { this.server = null; });
+        }).catch((e) => {
+        });
+    }
+
+    protected onNewClient(socket: net.Socket) {
+        console.log('New client connected');
+        socket.setKeepAlive(true);
+        socket.on('close', () => {
+            console.log('client closed');
+            const nonce = this.nonceBySocket.get(socket);
+            if (nonce) {
+                this.nonceBySocket.delete(socket);
+                this.socketByNonce.delete(nonce);
+            }
+        });
+        socket.on('data', (data) => {
+            const str = data.toString().trim();
+            if (this.socketByNonce.has(str)) {
+                // Client is alive and responded with proper nonce
+                this.socketByNonce.set(str, socket);
+                this.nonceBySocket.set(socket, str);
+            } else {
+                console.error(`Unknown message '${str}' from client`);
+            }
+        });
+        socket.on('error', (e) => {
+            console.error(`client error ${e}`)
+        });
+    }
+
+    public dispose() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+    }
+
+    public sendToClient(nonce: string, data: string | Buffer): Promise<boolean> {
+        return new Promise<boolean>((resolve) => {
+            if (!this.socketByNonce.has(nonce)) {
+                resolve(false);
+                return;
+            }
+            let socket: net.Socket = this.socketByNonce[nonce];
+            function send() {
+                try {
+                    socket.write(data);   
+                    socket.uncork();   
+                    resolve(true);
+                }
+                catch (e) {
+                    resolve(false);
+                }
+            }
+            if (socket) {
+                send();
+            } else {
+                // This can happen the very first time we are sending something. Technically, return
+                // should be a promise
+                const interval = setInterval(() => {
+                    socket = this.socketByNonce.get(nonce);
+                    if (socket) {
+                        clearInterval(interval);
+                        send();
+                    }
+                }, 1);
+            }
+        });
+    }
+
+    public addClient(nonce:string) {
+        console.log(`adding client ${nonce}`);
+        this.socketByNonce.set(nonce, null);
     }
 }
diff --git a/src/frontend/swo/common.ts b/src/frontend/swo/common.ts
@@ -124,7 +124,7 @@ export interface Packet {
 
 export function parseHostPort(hostPort: string) {
     let port: number;
-    let host = 'localhost';
+    let host = '127.0.0.1';
     const match = hostPort.match(/(.*)\:([0-9]+)/);
     if (match) {
         host = match[1] ? match[1] : host;
@@ -134,3 +134,12 @@ export function parseHostPort(hostPort: string) {
     }
     return { port: port, host: host };
 }
+
+export function getNonce() {
+    let text = '';
+    const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    for (let i = 0; i < 32; i++) {
+        text += possible.charAt(Math.floor(Math.random() * possible.length));
+    }
+    return text;
+}
diff --git a/src/frontend/swo/core.ts b/src/frontend/swo/core.ts
@@ -10,7 +10,8 @@ import { SWORTTSource } from './sources/common';
 import { SWODecoderConfig, GraphConfiguration, SWOAdvancedDecoderConfig,
     SWOBinaryDecoderConfig, SWOConsoleDecoderConfig, SWOGraphDecoderConfig,
     SWOBasicDecoderConfig, GrapherMessage, GrapherStatusMessage,
-    GrapherProgramCounterMessage } from './common';
+    GrapherProgramCounterMessage, 
+    getNonce} from './common';
 import { SWORTTAdvancedProcessor } from './decoders/advanced';
 import { EventEmitter } from 'events';
 import { PacketType, Packet } from './common';
@@ -204,23 +205,14 @@ class SWOWebview {
 
     private getHTML() {
         const scriptUri = vscode.Uri.file(path.join(this.extensionPath, 'dist', 'grapher.bundle.js')).with({ scheme: 'vscode-resource' });
-        const nonce = this.getNonce();
+        const nonce = getNonce();
 
         let html = fs.readFileSync(path.join(this.extensionPath, 'resources', 'grapher.html'), { encoding: 'utf8', flag: 'r' });
         html = html.replace(/\$\{nonce\}/g, nonce).replace(/\$\{scriptUri\}/g, scriptUri.toString());
 
         return html;
     }
 
-    private getNonce() {
-        let text = '';
-        const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-        for (let i = 0; i < 32; i++) {
-            text += possible.charAt(Math.floor(Math.random() * possible.length));
-        }
-        return text;
-    }
-
     private processors: Array<SWORTTGraphProcessor | SWORTTAdvancedProcessor> = [];
     public registerProcessors(processor: SWORTTGraphProcessor | SWORTTAdvancedProcessor): void {
         processor.on('message', this.sendMessage.bind(this));
diff --git a/src/tcp_cat.ts b/src/tcp_cat.ts

Original file line number	Diff line number	Diff line change
`@@ -1904,5 +1904,5 @@`
`1904`	`1904`	`"compile": "webpack --mode development",`
`1905`	`1905`	`"test-compile": "tsc -p ./"`
`1906`	`1906`	`},`
`1907`		`- "version": "0.3.13-pre1"`
	`1907`	`+ "version": "0.3.14-pre1"`
`1908`	`1908`	`}`