@W-14955790 BazelEventsExtensionAPI

src/apiHandler.ts

@@ -0,0 +1,74 @@
+import { Uri } from 'vscode';
+import { Emitter } from 'vscode-languageclient';
+import { BazelEventsExtensionAPI, TimeEvent } from './extension.api';
+``;
+class ApiHandler {
+	private api!: BazelEventsExtensionAPI;
+	private onSyncStartedEmitter: Emitter<string> = new Emitter<string>();
+	private onSyncEndedEmitter: Emitter<TimeEvent> = new Emitter<TimeEvent>();
+	private onBazelProjectFileCreatedEmitter: Emitter<string> =
+		new Emitter<string>();
+	private onBazelProjectFileUpdatedEmitter: Emitter<Uri> = new Emitter<Uri>();
+	private onSyncDirectoriesStartedEmitter: Emitter<string[]> = new Emitter<
+		string[]
+	>();
+	private onSyncDirectoriesEndedEmitter: Emitter<string[]> = new Emitter<
+		string[]
+	>();
+
+	public initApi() {
+		const onSyncStarted = this.onSyncStartedEmitter.event;
+		const onSyncEnded = this.onSyncEndedEmitter.event;
+		const onBazelProjectFileCreated =
+			this.onBazelProjectFileCreatedEmitter.event;
+		const onBazelProjectFileUpdated =
+			this.onBazelProjectFileUpdatedEmitter.event;
+		const onSyncDirectoriesStarted = this.onSyncDirectoriesStartedEmitter.event;
+		const onSyncDirectoriesEnded = this.onSyncDirectoriesEndedEmitter.event;
+
+		this.api = {
+			onSyncStarted,
+			onSyncEnded,
+			onBazelProjectFileCreated,
+			onBazelProjectFileUpdated,
+			onSyncDirectoriesStarted,
+			onSyncDirectoriesEnded,
+		};
+	}
+
+	public fireSyncStarted(event: string) {
+		this.onSyncStartedEmitter.fire(event);
+	}
+
+	public fireSyncEnded(workspace: string, timeSpecSec: number) {
+		this.onSyncEndedEmitter.fire({
+			workspaceRoot: workspace,
+			timeTookSec: timeSpecSec,
+		});
+	}
+
+	public fireBazelProjectFileCreated(event: string) {
+		this.onBazelProjectFileCreatedEmitter.fire(event);
+	}
+
+	public fireBazelProjectFileUpdated(event: Uri) {
+		this.onBazelProjectFileUpdatedEmitter.fire(event);
+	}
+
+	public fireSyncDirectoriesStarted(event: string[]) {
+		this.onSyncDirectoriesStartedEmitter.fire(event);
+	}
+
+	public fireSyncDirectoriesEnded(event: string[]) {
+		this.onSyncDirectoriesEndedEmitter.fire(event);
+	}
+
+	public getApi(): BazelEventsExtensionAPI {
+		if (!this.api) {
+			throw new Error(`ApiHandler is not initialized`);
+		}
+		return this.api;
+	}
+}
+
+export const apiHandler = new ApiHandler();

src/bazelLangaugeServerTerminal.ts

@@ -1,14 +1,19 @@
 import { Writable } from 'stream';
 import { Terminal, window, workspace } from 'vscode';
+import { apiHandler } from './apiHandler';
 import { BazelTerminal } from './bazelTerminal';
+import { LOGGER, getWorkspaceRoot } from './util';
 
 const BAZEL_TERMINAL_NAME = 'Bazel Build Status';
+const workspaceRoot = getWorkspaceRoot();
+const SYNC_INFO = RegExp(/100.0%\s+Synchronizing\s+core\s+(\S+)\n/);
 
 export namespace BazelLanguageServerTerminal {
 	export function stream(): Writable {
 		const s = new Writable();
 		s._write = (chunk: Buffer, encoding, next) => {
 			getBazelTerminal().sendText(chunk.toString());
+			catchBazelLog(chunk.toString());
 			next();
 		};
 		s.on('unpipe', () => s.end());
@@ -40,6 +45,7 @@ export namespace BazelLanguageServerTerminal {
 	} // gray
 }
 
+// Catch some bazel log messages to trigger API events
 export function getBazelTerminal(): Terminal {
 	const term = window.terminals.find(
 		(term) => term.name === BAZEL_TERMINAL_NAME
@@ -75,3 +81,17 @@ function getLogLevel(): LogLevel {
 			return LogLevel.INFO;
 	}
 }
+
+function catchBazelLog(chunk: string) {
+	const syncInfo = SYNC_INFO.exec(chunk);
+	if (syncInfo) {
+		let timeTook = 0;
+		if (syncInfo[1]) {
+			if (/[0-9]+s/.test(syncInfo[1])) {
+				timeTook = parseInt(syncInfo[1].replace('s', ''));
+			}
+		}
+		LOGGER.info(`Synchronization Summary detected. TimeTook ${timeTook}`);
+		apiHandler.fireSyncEnded(workspaceRoot, timeTook);
+	}
+}

src/extension.api.ts

@@ -0,0 +1,35 @@
+import * as vscode from 'vscode';
+
+export interface TimeEvent {
+	workspaceRoot: string;
+	timeTookSec: number;
+}
+
+export interface BazelEventsExtensionAPI {
+	/* An event which is fired on start of a Bazel Sync session.
+	 * The string points to path of the Workspace root.
+	 */
+	readonly onSyncStarted: vscode.Event<string>;
+	/* An event which is fired on end of a Bazel Sync session.
+	 * The string points to path of the Workspace root.
+	 */
+	readonly onSyncEnded: vscode.Event<TimeEvent>;
+	/* An event which is fired on creation of a .bazelproject file.
+	 *The string points to path of the .bazelproject file.
+	 */
+	readonly onBazelProjectFileCreated: vscode.Event<string>;
+	/* An event which is fired on updates to the .bazelproject file.
+	 * The Uri points to Uri of the .bazelproject file.
+	 */
+	readonly onBazelProjectFileUpdated: vscode.Event<vscode.Uri>;
+	/* An event which is fired on start of a Bazel Sync Directories session.
+	 * The list of strings stores the list of directories in .bazelproject
+	 * that are being synced.
+	 */
+	readonly onSyncDirectoriesStarted: vscode.Event<string[]>;
+	/* An event which is fired on end of a Bazel Sync Directories session.
+	 * The list of strings stores the list of directories in .bazelproject
+	 * that are being synced.
+	 */
+	readonly onSyncDirectoriesEnded: vscode.Event<string[]>;
+}

src/extension.ts

@@ -13,18 +13,21 @@ import {
 	window,
 	workspace,
 } from 'vscode';
+import { apiHandler } from './apiHandler';
 import {
 	BazelLanguageServerTerminal,
 	getBazelTerminal,
 } from './bazelLangaugeServerTerminal';
 import { BazelTaskManager } from './bazelTaskManager';
 import { getBazelProjectFile } from './bazelprojectparser';
 import { Commands, executeJavaLanguageServerCommand } from './commands';
+import { BazelEventsExtensionAPI } from './extension.api';
 import { registerLSClient } from './loggingTCPServer';
 import { BazelRunTargetProvider } from './provider/bazelRunTargetProvider';
 import { BazelTaskProvider } from './provider/bazelTaskProvider';
 import { ExcludeConfig, FileWatcherExcludeConfig } from './types';
 import {
+	LOGGER,
 	getWorkspaceRoot,
 	initBazelProjectFile,
 	isBazelWorkspaceRoot,
@@ -42,7 +45,7 @@ export async function activate(context: ExtensionContext) {
 	// fetch all projects loaded into LS and display those too
 	// show both .vscode and .eclipse folders
 	//
-
+	LOGGER.info('Extension bazel-vscode-java is being activated');
 	window.registerTreeDataProvider(
 		'bazelTaskOutline',
 		BazelRunTargetProvider.instance
@@ -53,7 +56,11 @@ export async function activate(context: ExtensionContext) {
 
 	workspace.onDidSaveTextDocument((doc) => {
 		if (doc.fileName.includes('bazelproject')) {
+			LOGGER.info(
+				`File with name including bazelproject has been changed. ${doc.fileName}`
+			);
 			toggleBazelProjectSyncStatus(doc);
+			apiHandler.fireBazelProjectFileUpdated(doc.uri);
 		}
 	});
 
@@ -71,6 +78,7 @@ export async function activate(context: ExtensionContext) {
 	);
 	// create .eclipse/.bazelproject file is DNE
 	if (isBazelWorkspaceRoot()) {
+		LOGGER.info('Bazel Workspace Root detected.');
 		initBazelProjectFile();
 		const showBazelprojectConfig =
 			workspace.getConfiguration('bazel.projectview');
@@ -84,6 +92,8 @@ export async function activate(context: ExtensionContext) {
 				openBazelProjectFile()
 			)
 		);
+	} else {
+		LOGGER.info('Bazel Workspace Root not detected.');
 	}
 
 	context.subscriptions.push(
@@ -126,22 +136,33 @@ export async function activate(context: ExtensionContext) {
 
 	// always update the project view after the initial project load
 	registerLSClient();
+
+	LOGGER.info('Activation is complete.');
+
+	return new Promise<BazelEventsExtensionAPI>((resolve, reject) => {
+		apiHandler.initApi();
+		resolve(apiHandler.getApi());
+	});
 }
 
 export function deactivate() {}
 
 function syncProjectView(): void {
 	if (!isRedhatJavaReady()) {
+		LOGGER.warn('RedHat Java is not ready for Bazel Project Sync.');
 		window.showErrorMessage(
 			'Unable to sync project view. Java language server is not ready'
 		);
 		return;
 	}
+	LOGGER.info('RedHat Java is ready. Starting Bazel Project Sync.');
 
+	apiHandler.fireSyncStarted(workspaceRoot);
 	const launchMode = workspace
 		.getConfiguration('java.server')
 		.get('launchMode');
 	// if the launchMode is not Standard it should be changed and the window reloaded to apply that change
+	LOGGER.info(`Java server launch mode is ${launchMode} .`);
 	if (!launchMode || launchMode !== 'Standard') {
 		workspace
 			.getConfiguration('java.server')
@@ -194,13 +215,21 @@ function isRedhatJavaReady(): boolean {
 }
 
 function toggleBazelProjectSyncStatus(doc: TextDocument) {
-	if (workspace.getConfiguration('bazel.projectview').get('notification')) {
+	const showNotification = workspace
+		.getConfiguration('bazel.projectview')
+		.get('notification');
+	LOGGER.info(
+		`toggleBazelProjectSyncStatus: Is notification to be shown ${showNotification}`
+	);
+	if (showNotification) {
+		LOGGER.info(`toggleBazelProjectSyncStatus: Notification is required.`);
 		window
 			.showWarningMessage(
 				`The Bazel Project View changed. Do you want to synchronize? [details](https://github.com/salesforce/bazel-eclipse/blob/main/docs/common/projectviews.md#project-views)`,
 				...['Java Projects', 'Only Directories', 'Do Nothing']
 			)
 			.then((val) => {
+				LOGGER.info(`toggleBazelProjectSyncStatus: Sync requested for ${val}`);
 				if (val === 'Java Projects') {
 					syncProjectView();
 				} else if (val === 'Only Directories') {
@@ -209,21 +238,32 @@ function toggleBazelProjectSyncStatus(doc: TextDocument) {
 					workspace
 						.getConfiguration('bazel.projectview')
 						.update('notification', false);
+				} else {
+					LOGGER.error(
+						`toggleBazelProjectSyncStatus: Unexpected value returned from showWarningMessage ${val}`
+					);
 				}
 			});
+	} else {
+		LOGGER.info(`toggleBazelProjectSyncStatus: Notification is not required.`);
 	}
 }
 
 async function syncProjectViewDirectories() {
 	if (workspaceRoot) {
+		LOGGER.info(
+			'Workspace root is defined for Directories sync. Syncing bazel project view.'
+		);
 		BazelLanguageServerTerminal.debug('Syncing bazel project view');
 		const displayFolders = new Set<string>(['.eclipse', '.vscode']); // TODO bubble this out to a setting
 		try {
 			const bazelProjectFile = await getBazelProjectFile();
 			let viewAll = false;
 			if (bazelProjectFile.directories.includes('.')) {
 				viewAll = true;
+				apiHandler.fireSyncDirectoriesStarted([]);
 			} else {
+				apiHandler.fireSyncDirectoriesStarted(bazelProjectFile.directories);
 				bazelProjectFile.directories.forEach((d) => {
 					const dirRoot = d.split('/').filter((x) => x)[0];
 					displayFolders.add(dirRoot);
@@ -322,9 +362,12 @@ async function syncProjectViewDirectories() {
 						);
 				}
 			});
+			apiHandler.fireSyncDirectoriesEnded(bazelProjectFile.directories);
 		} catch (err) {
 			throw new Error(`Could not read bazelproject file: ${err}`);
 		}
+	} else {
+		LOGGER.warn('Workspace root is not defined for Directories sync.');
 	}
 }
 

src/loggingTCPServer.ts

@@ -3,6 +3,7 @@ import { setTimeout } from 'timers/promises';
 import { commands, workspace } from 'vscode';
 import { BazelLanguageServerTerminal } from './bazelLangaugeServerTerminal';
 import { Commands } from './commands';
+import { LOGGER } from './util';
 
 const SERVER_START_RETRIES = 10;
 const PORT_REGISTRATION_RETRIES = 10;
@@ -13,6 +14,7 @@ let server: Server | undefined;
 function startTCPServer(attempts = 0): Promise<number> {
 	let port = 0;
 	if (workspace.getConfiguration('java').has('jdt.ls.vmargs')) {
+		LOGGER.info('Adjusting vmargs for TCP Server.');
 		const vmargs = workspace
 			.getConfiguration('java')
 			.get<string>('jdt.ls.vmargs');
@@ -28,6 +30,7 @@ function startTCPServer(attempts = 0): Promise<number> {
 
 	return new Promise((resolve) => {
 		if (!server) {
+			LOGGER.info('Starting TCP Server.');
 			server = createServer((sock: Socket) => {
 				attempts = 0;
 
@@ -50,10 +53,12 @@ function startTCPServer(attempts = 0): Promise<number> {
 					BazelLanguageServerTerminal.debug(
 						`Bazel log server listening on port ${port}`
 					);
+					LOGGER.info(`Bazel log server listening on port ${port}`);
 					resolve(port);
 				}
 			} else {
-				BazelLanguageServerTerminal.error(`Failed to start bazel TCP server`);
+				LOGGER.info('Failed to start bazel TCP server');
+				BazelLanguageServerTerminal.error('Failed to start bazel TCP server');
 				setTimeout<number>(1000 * attempts).then(() =>
 					startTCPServer(attempts + 1)
 				);

src/util.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
-import { workspace } from 'vscode';
+import { window, workspace } from 'vscode';
+import { apiHandler } from './apiHandler';
 
 // TODO: pull this template out into a file
 const BAZELPROJECT_TEMPLATE = `
@@ -17,6 +18,10 @@ directories:
 derive_targets_from_directories: true
 `;
 
+export const LOGGER = window.createOutputChannel('bazel-vscode-java', {
+	log: true,
+});
+
 export function getWorkspaceRoot(): string {
 	if (workspace.workspaceFile) {
 		return dirname(workspace.workspaceFile.path);
@@ -41,6 +46,9 @@ export function initBazelProjectFile() {
 			join(workspaceRoot, '.eclipse', '.bazelproject'),
 			BAZELPROJECT_TEMPLATE
 		);
+		apiHandler.fireBazelProjectFileCreated(
+			join(workspaceRoot, '.eclipse', '.bazelproject')
+		);
 	}
 }