[fix] Create BEP server on demand for each Bazel call (#370)

Previously it was created only on build

bazelrunner/src/main/java/org/jetbrains/bsp/bazel/bazelrunner/BazelRunner.kt

@@ -25,17 +25,16 @@ class BazelRunner private constructor(
         }
     }
 
-    private var besBackendPort: Int? = null
-
     fun commandBuilder(): BazelRunnerCommandBuilder = BazelRunnerCommandBuilder(this)
 
     fun runBazelCommandBes(
         command: String,
         flags: List<String>,
         arguments: List<String>,
-        originId: String?
+        originId: String?,
+        besBackendPort: Int,
     ): BazelProcess {
-        fun besFlags() = listOf("--bes_backend=grpc://localhost:${besBackendPort!!}")
+        fun besFlags() = listOf("--bes_backend=grpc://localhost:${besBackendPort}")
 
         return runBazelCommand(command, flags = besFlags() + flags, arguments, originId)
     }
@@ -69,8 +68,4 @@ class BazelRunner private constructor(
 
     private fun bazel(workspaceContext: WorkspaceContext): String = workspaceContext.bazelPath.value.toString()
     private fun buildFlags(workspaceContext: WorkspaceContext): List<String> = workspaceContext.buildFlags.values
-
-    fun setBesBackendPort(port: Int) {
-        besBackendPort = port
-    }
 }

bazelrunner/src/main/java/org/jetbrains/bsp/bazel/bazelrunner/BazelRunnerBuilder.kt

@@ -86,7 +86,7 @@ open class BazelRunnerBuilder internal constructor(
         return bazelRunner.runBazelCommand(bazelCommand, flags, arguments)
     }
 
-    fun executeBazelBesCommand(originId: String? = null): BazelProcess {
-        return bazelRunner.runBazelCommandBes(bazelCommand, flags, arguments, originId)
+    fun executeBazelBesCommand(originId: String? = null, bazelBesPort: Int): BazelProcess {
+        return bazelRunner.runBazelCommandBes(bazelCommand, flags, arguments, originId, bazelBesPort)
     }
 }

server/src/main/java/org/jetbrains/bsp/bazel/server/bep/BUILD

@@ -15,6 +15,7 @@ java_library(
         "@googleapis//:google_devtools_build_v1_publish_build_event_java_proto",
         "@googleapis//:google_devtools_build_v1_publish_build_event_proto",
         "@io_bazel//src/main/java/com/google/devtools/build/lib/buildeventstream/proto:build_event_stream_java_proto",
+        "@io_bazel//third_party/grpc:grpc-jar_checked_in",
         "@maven//:ch_epfl_scala_bsp4j",
         "@maven//:com_google_guava_guava",
         "@maven//:com_google_protobuf_protobuf_java",

server/src/main/java/org/jetbrains/bsp/bazel/server/bep/BepServer.java

@@ -12,10 +12,13 @@
 import com.google.devtools.build.v1.PublishBuildToolEventStreamResponse;
 import com.google.devtools.build.v1.PublishLifecycleEventRequest;
 import com.google.protobuf.Empty;
+import io.grpc.netty.NettyServerBuilder;
 import io.grpc.stub.StreamObserver;
 import java.io.IOException;
+import java.net.InetSocketAddress;
 import java.net.URI;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.AbstractMap;
 import java.util.ArrayDeque;
@@ -44,6 +47,14 @@ public BepServer(BuildClient bspClient, DiagnosticsService diagnosticsService) {
     this.diagnosticsService = diagnosticsService;
   }
 
+  public static BepServer newBepServer(BuildClient client, Path workspaceRoot) {
+    return new BepServer(client, new DiagnosticsService(workspaceRoot));
+  }
+
+  public static NettyServerBuilder nettyServerBuilder() {
+    return NettyServerBuilder.forAddress(new InetSocketAddress("localhost", 0));
+  }
+
   @Override
   public void publishLifecycleEvent(
       PublishLifecycleEventRequest request, StreamObserver<Empty> responseObserver) {

server/src/main/java/org/jetbrains/bsp/bazel/server/bloop/BloopExporter.java

@@ -11,10 +11,7 @@
 import ch.epfl.scala.bsp4j.TaskProgressParams;
 import ch.epfl.scala.bsp4j.TaskStartParams;
 import com.google.common.collect.Sets;
-import io.grpc.netty.NettyServerBuilder;
-import java.io.IOException;
 import java.io.PrintStream;
-import java.net.InetSocketAddress;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.HashSet;
@@ -25,11 +22,9 @@
 import org.jetbrains.bsp.bazel.bazelrunner.BazelRunner;
 import org.jetbrains.bsp.bazel.logger.BspClientLogger;
 import org.jetbrains.bsp.bazel.logger.BspClientTestNotifier;
-import org.jetbrains.bsp.bazel.server.bep.BepServer;
 import org.jetbrains.bsp.bazel.server.bsp.info.BspInfo;
 import org.jetbrains.bsp.bazel.server.bsp.managers.BazelBspCompilationManager;
 import org.jetbrains.bsp.bazel.server.common.ServerContainer;
-import org.jetbrains.bsp.bazel.server.diagnostics.DiagnosticsService;
 import org.jetbrains.bsp.bazel.server.sync.ProjectStorage;
 import org.jetbrains.bsp.bazel.server.sync.model.Project;
 import org.jetbrains.bsp.bazel.workspacecontext.WorkspaceContextProvider;
@@ -99,20 +94,10 @@ public void export(CancelChecker cancelChecker) throws BazelExportFailedExceptio
 
   private void initializeClient(ServerContainer serverContainer, BloopBuildClient client) {
     serverContainer.getBspClientLogger().initialize(client);
-    var bepServer =
-        new BepServer(
-            client, new DiagnosticsService(serverContainer.getBazelInfo().getWorkspaceRoot()));
-
-    var grpcServer =
-        NettyServerBuilder.forAddress(new InetSocketAddress("localhost", 0))
-            .addService(bepServer)
-            .build();
-    try {
-      grpcServer.start();
-    } catch (IOException ex) {
-      throw new RuntimeException(ex);
-    }
-    serverContainer.getBazelRunner().setBesBackendPort(grpcServer.getPort());
+    serverContainer.getCompilationManager().setClient(client);
+    serverContainer
+        .getCompilationManager()
+        .setWorkspaceRoot(serverContainer.getBazelInfo().getWorkspaceRoot());
   }
 
   private void cleanUpBloopDirectory(Set<Path> expected, Path bloopRoot) {

server/src/main/java/org/jetbrains/bsp/bazel/server/bsp/managers/BazelBspCompilationManager.java

@@ -1,16 +1,13 @@
 package org.jetbrains.bsp.bazel.server.bsp.managers;
 
 import ch.epfl.scala.bsp4j.BuildClient;
-import io.grpc.netty.NettyServerBuilder;
 import io.vavr.collection.List;
 import io.vavr.collection.Seq;
 import java.io.IOException;
-import java.net.InetSocketAddress;
 import java.nio.file.Path;
 import org.eclipse.lsp4j.jsonrpc.CancelChecker;
 import org.jetbrains.bsp.bazel.bazelrunner.BazelRunner;
 import org.jetbrains.bsp.bazel.server.bep.BepServer;
-import org.jetbrains.bsp.bazel.server.diagnostics.DiagnosticsService;
 import org.jetbrains.bsp.bazel.workspacecontext.TargetsSpec;
 
 public class BazelBspCompilationManager {
@@ -33,37 +30,41 @@ public BepBuildResult buildTargetsWithBep(
       TargetsSpec targetSpecs,
       Seq<String> extraFlags,
       String originId) {
-    var bepServer = new BepServer(client, new DiagnosticsService(workspaceRoot));
-    var server =
-        NettyServerBuilder.forAddress(new InetSocketAddress("localhost", 0))
-            .addService(bepServer)
-            .build();
+    var bepServer = BepServer.newBepServer(client, workspaceRoot);
+    var nettyServer = BepServer.nettyServerBuilder().addService(bepServer).build();
     try {
-      server.start();
+      nettyServer.start();
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
-    bazelRunner.setBesBackendPort(server.getPort());
     try {
       var result =
           bazelRunner
               .commandBuilder()
               .build()
               .withFlags(extraFlags.asJava())
               .withTargets(targetSpecs)
-              .executeBazelBesCommand(originId)
+              .executeBazelBesCommand(originId, nettyServer.getPort())
               .waitAndGetResult(cancelChecker, true);
       return new BepBuildResult(result, bepServer.getBepOutput());
     } finally {
-      server.shutdown();
+      nettyServer.shutdown();
     }
   }
 
   public void setClient(BuildClient client) {
     this.client = client;
   }
 
+  public BuildClient getClient() {
+    return client;
+  }
+
   public void setWorkspaceRoot(Path workspaceRoot) {
     this.workspaceRoot = workspaceRoot;
   }
+
+  public Path getWorkspaceRoot() {
+    return workspaceRoot;
+  }
 }

server/src/main/java/org/jetbrains/bsp/bazel/server/sync/ExecuteService.kt

@@ -9,6 +9,7 @@ import ch.epfl.scala.bsp4j.RunParams
 import ch.epfl.scala.bsp4j.RunResult
 import ch.epfl.scala.bsp4j.TestParams
 import ch.epfl.scala.bsp4j.TestResult
+import io.grpc.Server
 import org.eclipse.lsp4j.jsonrpc.CancelChecker
 import org.eclipse.lsp4j.jsonrpc.ResponseErrorException
 import org.eclipse.lsp4j.jsonrpc.messages.ResponseError
@@ -17,6 +18,7 @@ import org.jetbrains.bsp.bazel.bazelrunner.BazelProcessResult
 import org.jetbrains.bsp.bazel.bazelrunner.BazelRunner
 import org.jetbrains.bsp.bazel.bazelrunner.params.BazelFlag
 import org.jetbrains.bsp.bazel.logger.BspClientTestNotifier
+import org.jetbrains.bsp.bazel.server.bep.BepServer
 import org.jetbrains.bsp.bazel.server.bsp.managers.BazelBspCompilationManager
 import org.jetbrains.bsp.bazel.server.sync.BspMappings.toBspId
 import org.jetbrains.bsp.bazel.server.sync.model.Module
@@ -31,6 +33,17 @@ class ExecuteService(
     private val workspaceContextProvider: WorkspaceContextProvider,
     private val bspClientTestNotifier: BspClientTestNotifier
 ) {
+    private fun <T> withBepServer(body : (Server) -> T) :T {
+        val server = BepServer.newBepServer(compilationManager.client, compilationManager.workspaceRoot)
+        val nettyServer = BepServer.nettyServerBuilder().addService(server).build()
+        nettyServer.start()
+        try {
+            return body(nettyServer)
+        } finally {
+            nettyServer.shutdown()
+        }
+    }
+
     fun compile(cancelChecker: CancelChecker, params: CompileParams): CompileResult {
         val targets = selectTargets(cancelChecker, params.targets)
         val result = build(cancelChecker, targets, params.originId)
@@ -44,12 +57,15 @@ class ExecuteService(
             return TestResult(result.statusCode)
         }
         val targetsSpec = TargetsSpec(targets, emptyList())
-        result = bazelRunner.commandBuilder().test()
-            .withTargets(targetsSpec)
-            .withArguments(params.arguments)
-            .withFlag(BazelFlag.testOutputAll())
-            .executeBazelBesCommand(params.originId)
-            .waitAndGetResult(cancelChecker, true)
+
+        result = withBepServer {server ->
+            bazelRunner.commandBuilder().test()
+                .withTargets(targetsSpec)
+                .withArguments(params.arguments)
+                .withFlag(BazelFlag.testOutputAll())
+                .executeBazelBesCommand(params.originId, server.port)
+                .waitAndGetResult(cancelChecker, true)
+        }
         JUnit5TestParser(bspClientTestNotifier).processTestOutput(result)
         return TestResult(result.statusCode).apply {
             originId = originId
@@ -74,14 +90,18 @@ class ExecuteService(
             return RunResult(result.statusCode)
         }
         val bazelProcessResult =
-            bazelRunner.commandBuilder().run().withArgument(BspMappings.toBspUri(bspId))
-                .withArguments(params.arguments).executeBazelBesCommand(params.originId).waitAndGetResult(cancelChecker)
+            withBepServer { server ->
+                bazelRunner.commandBuilder().run().withArgument(BspMappings.toBspUri(bspId))
+                    .withArguments(params.arguments).executeBazelBesCommand(params.originId, server.port)
+                    .waitAndGetResult(cancelChecker)
+            }
         return RunResult(bazelProcessResult.statusCode).apply { originId = originId }
     }
 
     fun clean(cancelChecker: CancelChecker, params: CleanCacheParams?): CleanCacheResult {
-        val bazelResult =
-            bazelRunner.commandBuilder().clean().executeBazelBesCommand().waitAndGetResult(cancelChecker)
+        val bazelResult = withBepServer { server ->
+            bazelRunner.commandBuilder().clean().executeBazelBesCommand(bazelBesPort = server.port).waitAndGetResult(cancelChecker)
+        }
         return CleanCacheResult(bazelResult.stdout, true)
     }