Fix: stop start build server when getRandomPipepath return empty

extension/jdtls.ext/com.microsoft.gradle.bs.importer/src/com/microsoft/gradle/bs/importer/GradleBuildServerProjectImporter.java

@@ -8,6 +8,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.concurrent.CompletionException;
 
 import org.eclipse.core.internal.resources.Project;
 import org.eclipse.core.internal.resources.ProjectDescription;
@@ -31,6 +32,8 @@
 import org.eclipse.jdt.ls.core.internal.managers.BasicFileDetector;
 import org.eclipse.jdt.ls.core.internal.managers.DigestStore;
 import org.eclipse.jdt.ls.core.internal.preferences.Preferences;
+import org.eclipse.lsp4j.jsonrpc.ResponseErrorException;
+
 import com.microsoft.java.builder.JavaProblemChecker;
 import com.microsoft.gradle.bs.importer.model.BuildServerPreferences;
 import com.microsoft.gradle.bs.importer.model.Telemetry;
@@ -54,6 +57,7 @@ public class GradleBuildServerProjectImporter extends AbstractProjectImporter {
     public static final String SETTINGS_GRADLE_DESCRIPTOR = "settings.gradle";
     public static final String SETTINGS_GRADLE_KTS_DESCRIPTOR = "settings.gradle.kts";
     public static final String ANDROID_MANIFEST = "AndroidManifest.xml";
+    private boolean isResolved = true;
 
     @Override
     public boolean applies(IProgressMonitor monitor) throws OperationCanceledException, CoreException {
@@ -172,9 +176,20 @@ public void importToWorkspace(IProgressMonitor monitor) throws OperationCanceled
         );
         BuildServerPreferences data = getBuildServerPreferences();
         params.setData(data);
-        InitializeBuildResult initializeResult = buildServer.buildInitialize(params).join();
-        buildServer.onBuildInitialized();
-        // TODO: save the capabilities of this server
+        try {
+            InitializeBuildResult initializeResult = buildServer.buildInitialize(params).join();
+            buildServer.onBuildInitialized();
+            // TODO: save the capabilities of this server
+        } catch (CompletionException e) {
+            Throwable cause = e.getCause();
+            if (e.getCause() instanceof ResponseErrorException responseError) {
+                if ("Unhandled method build/initialize".equals(responseError.getMessage())) {
+                    JavaLanguageServerPlugin.logException("Failed to start Gradle Build Server, use BuildShip instead", null);
+                    this.isResolved = false;
+                    return;
+                }
+            }
+        }
 
         if (monitor.isCanceled()) {
             return;
@@ -208,7 +223,7 @@ public boolean isResolved(File folder) throws OperationCanceledException, CoreEx
         // the gradle project has already imported by other importers, we can modify this logic
         // so that Maven importer can be involved for other projects.
         for (IProject project : ProjectUtils.getAllProjects()) {
-            if (Utils.isGradleBuildServerProject(project) &&
+            if (this.isResolved && Utils.isGradleBuildServerProject(project) &&
                     project.getLocation().toPath().startsWith(folder.toPath())) {
                 return true;
             }

extension/src/Extension.ts

@@ -247,7 +247,7 @@
     private async activate(): Promise<void> {
         const testExtension = vscode.extensions.getExtension("vscjava.vscode-java-test");
         if (testExtension) {
             testExtension.activate().then((api: any) => {
                 if (api) {
                     const testRunner: GradleTestRunner = this.buildServerController.getGradleTestRunner(api);
                     api.registerTestProfile("Delegate Test to Gradle", vscode.TestRunProfileKind.Run, testRunner);
@@ -260,7 +260,6 @@
             });
         }
         const activated = !!(await this.rootProjectsStore.getProjectRoots()).length;
-        this.bspProxy.prepareToStart();
         if (!this.server.isReady()) {
             await this.server.start();
         }

extension/src/bs/BspProxy.ts

@@ -16,6 +16,7 @@ import { sendInfo } from "vscode-extension-telemetry-wrapper";
 export class BspProxy {
     private buildServerConnector: BuildServerConnector;
     private jdtlsImporterConnector: JdtlsImporterConnector;
+    private buildServerStart: boolean;
 
     constructor(context: vscode.ExtensionContext, private readonly logger: Logger) {
         this.buildServerConnector = new BuildServerConnector();
@@ -24,8 +25,8 @@ export class BspProxy {
     /**
      * This function needs to be called before we start Java Gradle Server.
      */
-    public prepareToStart(): void {
-        this.buildServerConnector.setupBuildServerPipeStream();
+    public prepareToStart(): boolean {
+        return this.buildServerConnector.setupBuildServerPipeStream();
     }
 
     /**
@@ -37,11 +38,12 @@ export class BspProxy {
     public async start(): Promise<void> {
         await this.jdtlsImporterConnector.waitForImporterPipePath();
         await this.jdtlsImporterConnector.setupImporterPipeStream();
-
-        this.setupMessageForwarding(
-            this.jdtlsImporterConnector.getImporterConnection(),
-            this.buildServerConnector.getServerConnection()
-        );
+        if (this.buildServerStart) {
+            this.setupMessageForwarding(
+                this.jdtlsImporterConnector.getImporterConnection(),
+                this.buildServerConnector.getServerConnection()
+            );
+        }
         this.jdtlsImporterConnector.startListening();
     }
 
@@ -53,20 +55,26 @@ export class BspProxy {
         importerConnection: rpc.MessageConnection | null,
         buildServerConnection: rpc.MessageConnection | null
     ): void {
-        importerConnection?.onRequest((method, params) => {
+        if (!importerConnection) {
+            return;
+        }
+        if (!buildServerConnection) {
+            return;
+        }
+        importerConnection.onRequest((method, params) => {
             if (params !== null) {
-                return buildServerConnection?.sendRequest(method, params);
+                return buildServerConnection.sendRequest(method, params);
             }
-            return buildServerConnection?.sendRequest(method);
+            return buildServerConnection.sendRequest(method);
         });
 
-        buildServerConnection?.onNotification((method, params) => {
+        buildServerConnection.onNotification((method, params) => {
             if (params !== null) {
-                return importerConnection?.sendNotification(method, params);
+                return importerConnection.sendNotification(method, params);
             }
-            importerConnection?.sendNotification(method);
+            importerConnection.sendNotification(method);
         });
-        importerConnection?.onError(([error]) => {
+        importerConnection.onError(([error]) => {
             this.logger.error(`Error on importerConnection: ${error.message}`);
             sendInfo("", {
                 kind: "bspProxy-importerConnectionError",
@@ -76,7 +84,7 @@ export class BspProxy {
             // TODO: Implement more specific error handling logic here
         });
 
-        buildServerConnection?.onError(([error]) => {
+        buildServerConnection.onError(([error]) => {
             this.logger.error(`Error on buildServerConnection: ${error.message}`);
             sendInfo("", {
                 kind: "bspProxy-buildServerConnectionError",
@@ -86,6 +94,9 @@ export class BspProxy {
             // TODO: Implement more specific error handling logic here
         });
     }
+    public setBuildServerStarted(started: boolean): void {
+        this.buildServerStart = started;
+    }
 
     public closeConnection(): void {
         this.buildServerConnector.close();

extension/src/bs/BuildServerConnector.ts

@@ -15,8 +15,11 @@ export class BuildServerConnector {
      * Generates a random pipe name, creates a pipe server and
      * waiting for the connection from the Java build server.
      */
-    public setupBuildServerPipeStream(): void {
+    public setupBuildServerPipeStream(): boolean {
         this.serverPipePath = getRandomPipeName();
+        if (this.serverPipePath === "") {
+            return false;
+        }
         this.serverPipeServer = net.createServer((socket: net.Socket) => {
             this.serverConnection = rpc.createMessageConnection(
                 new rpc.StreamMessageReader(socket),
@@ -25,6 +28,7 @@ export class BuildServerConnector {
             this.serverConnection.listen();
         });
         this.serverPipeServer.listen(this.serverPipePath);
+        return true;
     }
 
     public getServerConnection(): rpc.MessageConnection | null {

extension/src/server/GradleServer.ts

@@ -49,6 +49,13 @@
         return this.languageServerPipePath;
     }
     public async start(): Promise<void> {
+        const isPrepared = this.bspProxy.prepareToStart();
+        if (!isPrepared) {
+            this.logger.error("Failed to generate build server pipe path, build server will not start");
+        }
+        const startBuildServer = isPrepared && redHatJavaInstalled();
+        this.bspProxy.setBuildServerStarted(startBuildServer);
+
         this.taskServerPort = await getPort();
         const cwd = this.context.asAbsolutePath("lib");
         const cmd = path.join(cwd, getGradleServerCommand());
@@ -61,13 +68,12 @@
             await vscode.window.showErrorMessage(NO_JAVA_EXECUTABLE);
             return;
         }
-        const startBuildServer = redHatJavaInstalled() ? "true" : "false";
         const args = [
             quoteArg(`--port=${this.taskServerPort}`),
             quoteArg(`--startBuildServer=${startBuildServer}`),
             quoteArg(`--languageServerPipePath=${this.languageServerPipePath}`),
         ];
-        if (startBuildServer === "true") {
+        if (startBuildServer) {
             const buildServerPipeName = this.bspProxy.getBuildServerPipeName();
             args.push(quoteArg(`--pipeName=${buildServerPipeName}`));
             args.push(quoteArg(`--bundleDir=${bundleDirectory}`));
@@ -142,7 +148,7 @@
 
     private async killProcess(): Promise<void> {
         if (this.process) {
             return new Promise((resolve, _reject) => {
                 if (this.process?.pid) {
                     kill(this.process.pid, () => resolve);
                 }