Merge pull request #2182 from codefori/fix/eventFunctionsCrash

Fix event functions chain crash

package.json

@@ -3,7 +3,7 @@
  "icon": "icon.png",
  "displayName": "Code for IBM i",
  "description": "Maintain your RPGLE, CL, COBOL, C/CPP on IBM i right from Visual Studio Code.",
- "version": "2.12.0",
+ "version": "2.12.1-dev.0",
  "keywords": [
  "ibmi",
  "rpgle",

src/api/Instance.ts

@@ -5,18 +5,21 @@ import IBMi from "./IBMi";
 import { ConnectionStorage, GlobalStorage } from "./Storage";
 
 type IBMiEventSubscription = {
- event: IBMiEvent,
- func: Function
+ func: Function,
+ transient?: boolean
 };
 
+type SubscriptionMap = Map<string, IBMiEventSubscription>
+
 export default class Instance {
  private connection: IBMi | undefined;
  private storage: ConnectionStorage;
  private emitter: vscode.EventEmitter<IBMiEvent> = new vscode.EventEmitter();
- private subscribers: IBMiEventSubscription[] = [];
+ private subscribers: Map<IBMiEvent, SubscriptionMap> = new Map;
+
+ private deprecationCount = 0; //TODO: remove in v3.0.0
 
  constructor(context: vscode.ExtensionContext) {
- this.subscribers = [];
  this.storage = new ConnectionStorage(context);
  this.emitter.event(e => this.processEvent(e));
  }
@@ -56,17 +59,58 @@ export default class Instance {
  return this.storage.ready ? this.storage : undefined;
  }
 
+ /**
+ * Subscribe to an {@link IBMiEvent}. When the event is triggerred, the `func` function gets executed.
+ * 
+ * Each `context`/`name` couple must be unique.
+ * @param context the extension subscribing to the event
+ * @param event the {@link IBMiEvent} to subscribe to 
+ * @param name a human-readable name summarizing the function 
+ * @param func the function to execute when the {@link IBMiEvent} is triggerred
+ * @param transient if `true`, the function will only be executed once during the lifetime of a connection
+ */
+ subscribe(context: vscode.ExtensionContext, event: IBMiEvent, name: string, func: Function, transient?: boolean) {
+ this.getSubscribers(event).set(`${context.extension.id} - ${name}`, { func, transient });
+ }
+
+ private getSubscribers(event: IBMiEvent) {
+ let eventSubscribers: SubscriptionMap = this.subscribers.get(event) || new Map;
+ if (!this.subscribers.has(event)) {
+ this.subscribers.set(event, eventSubscribers);
+ }
+ return eventSubscribers;
+ }
+
+ /**
+ * @deprecated Will be removed in `v3.0.0`; use {@link subscribe} instead
+ */
  onEvent(event: IBMiEvent, func: Function): void {
- this.subscribers.push({ event, func });
+ this.getSubscribers(event).set(`deprecated - ${func.name || "unknown"}_${this.deprecationCount++}`, { func });
+ console.warn("[Code for IBM i] Deprecation warning: you are using Instance::onEvent which is deprecated and will be removed in v3.0.0. Please use Instance::subscribe instead.");
  }
 
  fire(event: IBMiEvent) {
  this.emitter?.fire(event);
  }
 
  async processEvent(event: IBMiEvent) {
- for (const subscriber of this.subscribers.filter(s => s.event === event)) {
- await subscriber.func();
+ const eventSubscribers = this.getSubscribers(event)
+ console.time(event);
+ for (const [identity, callable] of eventSubscribers.entries()) {
+ try {
+ console.time(identity);
+ await callable.func();
+ console.timeEnd(identity);
+ }
+ catch (error) {
+ console.error(`${event} event function ${identity} failed`, error);
+ }
+ finally {
+ if (callable.transient) {
+ eventSubscribers.delete(identity);
+ }
+ }
  }
+ console.timeEnd(event);
  }
 }

src/api/Terminal.ts

@@ -34,6 +34,8 @@ export namespace Terminal {
  connectionString?: string
  }
 
+ let terminalCount = 0;
+
  function setHalted(state: boolean) {
  commands.executeCommand(`setContext`, `code-for-ibmi:term5250Halted`, state);
  }
@@ -43,17 +45,17 @@ export namespace Terminal {
  const ATTENTION = 1;
  const TAB = 9;
 
- export function registerTerminalCommands() {
+ export function registerTerminalCommands(context: vscode.ExtensionContext) {
  return [
  vscode.commands.registerCommand(`code-for-ibmi.launchTerminalPicker`, () => {
- return selectAndOpen(instance);
+ return selectAndOpen(context, instance);
  }),
 
  vscode.commands.registerCommand(`code-for-ibmi.openTerminalHere`, async (ifsNode) => {
  const content = instance.getContent();
  if (content) {
  const ifsPath = (await content.isDirectory(ifsNode.path)) ? ifsNode.path : path.dirname(ifsNode.path);
- const terminal = await selectAndOpen(instance, TerminalType.PASE);
+ const terminal = await selectAndOpen(context, instance, TerminalType.PASE);
  terminal?.sendText(`cd ${ifsPath}`);
  }
  }),
@@ -68,7 +70,7 @@ export namespace Terminal {
  ];
  }
 
- export async function selectAndOpen(instance: Instance, openType?: TerminalType) {
+ async function selectAndOpen(context: vscode.ExtensionContext, instance: Instance, openType?: TerminalType) {
  const connection = instance.getConnection();
  const configuration = instance.getConfig();
  if (connection && configuration) {
@@ -104,14 +106,14 @@ export namespace Terminal {
  vscode.workspace.getConfiguration().update(`terminal.integrated.sendKeybindingsToShell`, true, true);
  }
 
- return createTerminal(connection, terminalSettings);
+ return createTerminal(context, connection, terminalSettings);
  }
  }
  }
 
  const HALTED = ` II`;
 
- async function createTerminal(connection: IBMi, terminalSettings: TerminalSettings) {
+ async function createTerminal(context: vscode.ExtensionContext, connection: IBMi, terminalSettings: TerminalSettings) {
  const writeEmitter = new vscode.EventEmitter<string>();
  const paseWelcomeMessage = 'echo "Terminal started. Thanks for using Code for IBM i"';
 
@@ -201,7 +203,12 @@ export namespace Terminal {
  channel.stdin.write(`${paseWelcomeMessage}\n`);
  }
 
- instance.onEvent('disconnected', () => emulatorTerminal.dispose());
+ instance.subscribe(
+ context,
+ 'disconnected',
+ `Dispose Terminal ${terminalCount++}`,
+ () => emulatorTerminal.dispose(),
+ true);
 
  return emulatorTerminal;
  }

src/api/debug/index.ts

@@ -371,36 +371,44 @@ export async function initialize(context: ExtensionContext) {
  );
 
  // Run during startup:
- instance.onEvent("connected", async () => {
- activateDebugExtension();
- const connection = instance.getConnection();
- const content = instance.getContent();
- if (connection && content && server.debugPTFInstalled()) {
- vscode.commands.executeCommand(`setContext`, ptfContext, true);
+ instance.subscribe(
+ context,
+ 'connected',
+ `Load debugger status`,
+ async () => {
+ activateDebugExtension();
+ const connection = instance.getConnection();
+ const content = instance.getContent();
+ if (connection && content && server.debugPTFInstalled()) {
+ vscode.commands.executeCommand(`setContext`, ptfContext, true);
 
- //Enable debug related commands
- vscode.commands.executeCommand(`setContext`, debugContext, true);
+  //Enable debug related commands
+  vscode.commands.executeCommand(`setContext`, debugContext, true);
 
- //Enable service entry points related commands
- vscode.commands.executeCommand(`setContext`, debugSEPContext, await server.isSEPSupported());
+  //Enable service entry points related commands
+  vscode.commands.executeCommand(`setContext`, debugSEPContext, await server.isSEPSupported());
 
- const isDebugManaged = isManaged();
- vscode.commands.executeCommand(`setContext`, `code-for-ibmi:debugManaged`, isDebugManaged);
- if (!isDebugManaged) {
- if (validateIPv4address(connection.currentHost)) {
- vscode.window.showWarningMessage(`You are using an IPv4 address to connect to this system. This may cause issues with debugging. Please use a hostname in the Login Settings instead.`);
- }
+  const isDebugManaged = isManaged();
+  vscode.commands.executeCommand(`setContext`, `code-for-ibmi:debugManaged`, isDebugManaged);
+  if (!isDebugManaged) {
+  if (validateIPv4address(connection.currentHost)) {
+  vscode.window.showWarningMessage(`You are using an IPv4 address to connect to this system. This may cause issues with debugging. Please use a hostname in the Login Settings instead.`);
+  }
 
- certificates.sanityCheck(connection, content);
+ certificates.sanityCheck(connection, content);
+ }
  }
- }
- });
+ });
 
- instance.onEvent("disconnected", () => {
- resetDebugServiceDetails();
- vscode.commands.executeCommand(`setContext`, debugContext, false);
- vscode.commands.executeCommand(`setContext`, debugSEPContext, false);
- });
+ instance.subscribe(
+ context,
+ 'disconnected',
+ `Clear debugger status`,
+ () => {
+ resetDebugServiceDetails();
+ vscode.commands.executeCommand(`setContext`, debugContext, false);
+ vscode.commands.executeCommand(`setContext`, debugSEPContext, false);
+ });
 }
 
 function validateIPv4address(ipaddress: string) {

src/api/local/deployment.ts

@@ -45,55 +45,63 @@ export namespace Deployment {
  buildWatcher().then(bw => context.subscriptions.push(bw));
  }
 
- instance.onEvent("connected", () => {
- const workspaces = vscode.workspace.workspaceFolders;
- const connection = instance.getConnection();
- const config = instance.getConfig();
- const storage = instance.getStorage();
-
- if (workspaces && connection && storage && config) {
- if (workspaces.length > 0) {
- buildWatcher().then(bw => context.subscriptions.push(bw));
- button.show();
- }
+ instance.subscribe(
+ context,
+ 'connected',
+ `Initialize deployment`,
+ () => {
+ const workspaces = vscode.workspace.workspaceFolders;
+ const connection = instance.getConnection();
+ const config = instance.getConfig();
+ const storage = instance.getStorage();
+
+ if (workspaces && connection && storage && config) {
+ if (workspaces.length > 0) {
+ buildWatcher().then(bw => context.subscriptions.push(bw));
+ button.show();
+ }
 
- const existingPaths = storage.getDeployment();
+  const existingPaths = storage.getDeployment();
 
- if (workspaces.length === 1) {
- const workspace = workspaces[0];
-
- if (existingPaths && !existingPaths[workspace.uri.fsPath]) {
- const possibleDeployDir = DeployTools.buildPossibleDeploymentDirectory(workspace);
- vscode.window.showInformationMessage(
- `Deploy directory for Workspace not setup. Would you like to default to '${possibleDeployDir}'?`,
- `Yes`,
- `Ignore`
- ).then(async result => {
- if (result === `Yes`) {
- DeployTools.setDeployLocation({ path: possibleDeployDir }, workspace);
- }
- });
- }
+ if (workspaces.length === 1) {
+ const workspace = workspaces[0];
 
- getLocalActions(workspace).then(result => {
- if (result.length === 0) {
+  if (existingPaths && !existingPaths[workspace.uri.fsPath]) {
+  const possibleDeployDir = DeployTools.buildPossibleDeploymentDirectory(workspace);
  vscode.window.showInformationMessage(
- `There are no local Actions defined for this project.`,
- `Run Setup`
- ).then(result => {
- if (result === `Run Setup`)
- vscode.commands.executeCommand(`code-for-ibmi.launchActionsSetup`);
+ `Deploy directory for Workspace not setup. Would you like to default to '${possibleDeployDir}'?`,
+ `Yes`,
+ `Ignore`
+ ).then(async result => {
+ if (result === `Yes`) {
+ DeployTools.setDeployLocation({ path: possibleDeployDir }, workspace);
+ }
  });
  }
- })
+
+ getLocalActions(workspace).then(result => {
+ if (result.length === 0) {
+ vscode.window.showInformationMessage(
+ `There are no local Actions defined for this project.`,
+ `Run Setup`
+ ).then(result => {
+ if (result === `Run Setup`)
+ vscode.commands.executeCommand(`code-for-ibmi.launchActionsSetup`);
+ });
+ }
+ })
+ }
  }
- }
- });
+ });
 
- instance.onEvent("disconnected", () => {
- fixCCSID = undefined;
- button.hide();
- })
+ instance.subscribe(
+ context,
+ 'disconnected',
+ `Clear deployment`,
+ () => {
+ fixCCSID = undefined;
+ button.hide();
+ })
  }
 
  export function getConnection(): IBMi {

src/extension.ts

@@ -57,7 +57,7 @@ export async function activate(context: ExtensionContext): Promise<CodeForIBMi>
  context.subscriptions.push(
  window.registerTreeDataProvider(
  `helpView`,
- new HelpView()
+ new HelpView(context)
  ),
  window.registerTreeDataProvider(
  `libraryListView`,
@@ -114,14 +114,16 @@ export async function activate(context: ExtensionContext): Promise<CodeForIBMi>
  initialise(context);
  }
 
- instance.onEvent(`connected`, () => {
- Promise.all([
- commands.executeCommand("code-for-ibmi.refreshObjectBrowser"),
- commands.executeCommand("code-for-ibmi.refreshLibraryListView"),
- commands.executeCommand("code-for-ibmi.refreshIFSBrowser"),
- commands.executeCommand("code-for-ibmi.refreshProfileView")
- ]);
- });
+ instance.subscribe(
+ context,
+ 'connected',
+ `Refresh views`,
+ () => {
+ commands.executeCommand("code-for-ibmi.refreshObjectBrowser");
+ commands.executeCommand("code-for-ibmi.refreshLibraryListView");
+ commands.executeCommand("code-for-ibmi.refreshIFSBrowser");
+ commands.executeCommand("code-for-ibmi.refreshProfileView");
+ });
 
  return { instance, customUI: () => new CustomUI(), deployTools: DeployTools, evfeventParser: parseErrors, tools: Tools };
 }