Postpone Bazel Info call

Before this change, `bazel info` was called before the actual BSP
server. This means, there was no clear way to submit failure (for
example if `bazel` executable was not available in PATH). Currently,
it is run on `build/intitialize` request, so the error will be logged
via BSP failure response.

server/src/main/java/org/jetbrains/bsp/bazel/server/BazelBspServer.kt

@@ -3,14 +3,10 @@ package org.jetbrains.bsp.bazel.server
 import ch.epfl.scala.bsp4j.BuildClient
 import io.grpc.ServerBuilder
 import org.eclipse.lsp4j.jsonrpc.Launcher
-import org.jetbrains.bsp.bazel.bazelrunner.BazelInfo
 import org.jetbrains.bsp.bazel.bazelrunner.BazelRunner
 import org.jetbrains.bsp.bazel.logger.BspClientLogger
 import org.jetbrains.bsp.bazel.server.bep.BepServer
-import org.jetbrains.bsp.bazel.server.bsp.BazelBspServerLifetime
-import org.jetbrains.bsp.bazel.server.bsp.BspIntegrationData
-import org.jetbrains.bsp.bazel.server.bsp.BspRequestsRunner
-import org.jetbrains.bsp.bazel.server.bsp.BspServerApi
+import org.jetbrains.bsp.bazel.server.bsp.*
 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
@@ -22,39 +18,41 @@ import org.jetbrains.bsp.bazel.workspacecontext.WorkspaceContextProvider
 import java.nio.file.Path
 
 class BazelBspServer(
-    bspInfo: BspInfo, workspaceContextProvider: WorkspaceContextProvider, workspaceRoot: Path
+    bspInfo: BspInfo, workspaceContextProvider: WorkspaceContextProvider, val workspaceRoot: Path
 ) {
     private val bazelRunner: BazelRunner
-    private val bazelInfo: BazelInfo
-    private val bspServerApi: BspServerApi
     private val compilationManager: BazelBspCompilationManager
-    private val bspClientLogger: BspClientLogger
+    private val bspServerApi: BspServerApi
+    private val bspClientLogger: BspClientLogger= BspClientLogger()
 
     init {
+        bazelRunner = BazelRunner.of(workspaceContextProvider, this.bspClientLogger, workspaceRoot)
+        compilationManager = BazelBspCompilationManager(bazelRunner)
+        bspServerApi = BspServerApi{bspServerData(bspInfo, workspaceContextProvider)}
+    }
+
+    private fun bspServerData(bspInfo: BspInfo, workspaceContextProvider: WorkspaceContextProvider): BazelServices {
         val serverContainer =
-            ServerContainer.create(bspInfo, workspaceContextProvider, workspaceRoot, null)
-        bspClientLogger = serverContainer.bspClientLogger
-        bazelInfo = serverContainer.bazelInfo
-        compilationManager = serverContainer.compilationManager
-        bazelRunner = serverContainer.bazelRunner
+                ServerContainer.create(bspInfo, workspaceContextProvider, null, BspClientLogger(), bazelRunner, compilationManager)
+
         val bspProjectMapper = BspProjectMapper(
-            serverContainer.languagePluginsService, workspaceContextProvider
+                serverContainer.languagePluginsService, workspaceContextProvider
         )
         val projectSyncService =
-            ProjectSyncService(bspProjectMapper, serverContainer.projectProvider)
+                ProjectSyncService(bspProjectMapper, serverContainer.projectProvider)
         val executeService = ExecuteService(
-            compilationManager,
-            serverContainer.projectProvider,
-            bazelRunner,
-            workspaceContextProvider
+                compilationManager,
+                serverContainer.projectProvider,
+                bazelRunner,
+                workspaceContextProvider
         )
         val serverLifetime = BazelBspServerLifetime()
         val bspRequestsRunner = BspRequestsRunner(serverLifetime)
-        bspServerApi = BspServerApi(
-            serverLifetime,
-            bspRequestsRunner,
-            projectSyncService,
-            executeService)
+        return BazelServices(
+                serverLifetime,
+                bspRequestsRunner,
+                projectSyncService,
+                executeService)
     }
 
     fun startServer(bspIntegrationData: BspIntegrationData) {
@@ -65,7 +63,7 @@ class BazelBspServer(
         bspIntegrationData.launcher = launcher
         val client = launcher.remoteProxy
         bspClientLogger.initialize(client)
-        val bepServer = BepServer(client, DiagnosticsService(bazelInfo))
+        val bepServer = BepServer(client, DiagnosticsService(workspaceRoot))
         compilationManager.setBepServer(bepServer)
         bspIntegrationData.server = ServerBuilder.forPort(0).addService(bepServer).build()
     }

server/src/main/java/org/jetbrains/bsp/bazel/server/ServerInitializer.kt

@@ -50,7 +50,7 @@ object ServerInitializer {
             bspIntegrationData.launcher.startListening()
             server.awaitTermination()
         } catch (e: Exception) {
-            e.printStackTrace()
+            e.printStackTrace(System.err)
             hasErrors = true
         } finally {
             executor.shutdown()

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

@@ -20,8 +20,11 @@
 import java.util.Set;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
+import org.jetbrains.bsp.bazel.bazelrunner.BazelRunner;
+import org.jetbrains.bsp.bazel.logger.BspClientLogger;
 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;
@@ -55,9 +58,17 @@ public BloopExporter(
   }
 
   public void export() throws BazelExportFailedException {
+    var bspClientLogger = new BspClientLogger();
+    var bazelRunner = BazelRunner.of(workspaceContextProvider, bspClientLogger, workspaceRoot);
+    var compilationManager = new BazelBspCompilationManager(bazelRunner);
     var serverContainer =
         ServerContainer.create(
-            bspInfo, workspaceContextProvider, this.workspaceRoot, new NoopProjectStorage());
+            bspInfo,
+            workspaceContextProvider,
+            new NoopProjectStorage(),
+            bspClientLogger,
+            bazelRunner,
+            compilationManager);
     var projectProvider = serverContainer.getProjectProvider();
     var client = new BloopBuildClient(System.out);
     initializeClient(serverContainer, client);
@@ -83,7 +94,9 @@ public void export() throws BazelExportFailedException {
 
   private void initializeClient(ServerContainer serverContainer, BloopBuildClient client) {
     serverContainer.getBspClientLogger().initialize(client);
-    var bepServer = new BepServer(client, new DiagnosticsService(serverContainer.getBazelInfo()));
+    var bepServer =
+        new BepServer(
+            client, new DiagnosticsService(serverContainer.getBazelInfo().getWorkspaceRoot()));
     serverContainer.getCompilationManager().setBepServer(bepServer);
 
     var grpcServer = ServerBuilder.forPort(0).addService(bepServer).build();

server/src/main/java/org/jetbrains/bsp/bazel/server/bsp/BazelServices.java

@@ -0,0 +1,38 @@
+package org.jetbrains.bsp.bazel.server.bsp;
+
+import org.jetbrains.bsp.bazel.server.sync.ExecuteService;
+import org.jetbrains.bsp.bazel.server.sync.ProjectSyncService;
+
+public class BazelServices {
+  private final BazelBspServerLifetime serverLifetime;
+  private final BspRequestsRunner bspRequestsRunner;
+  private final ProjectSyncService projectSyncService;
+  private final ExecuteService executeService;
+
+  public BazelServices(
+      BazelBspServerLifetime serverLifetime,
+      BspRequestsRunner bspRequestsRunner,
+      ProjectSyncService projectSyncService,
+      ExecuteService executeService) {
+    this.serverLifetime = serverLifetime;
+    this.bspRequestsRunner = bspRequestsRunner;
+    this.projectSyncService = projectSyncService;
+    this.executeService = executeService;
+  }
+
+  public BazelBspServerLifetime getServerLifetime() {
+    return serverLifetime;
+  }
+
+  public BspRequestsRunner getBspRequestsRunner() {
+    return bspRequestsRunner;
+  }
+
+  public ProjectSyncService getProjectSyncService() {
+    return projectSyncService;
+  }
+
+  public ExecuteService getExecuteService() {
+    return executeService;
+  }
+}

server/src/main/java/org/jetbrains/bsp/bazel/server/bsp/BspServerApi.java

@@ -41,31 +41,36 @@
 import ch.epfl.scala.bsp4j.TestResult;
 import ch.epfl.scala.bsp4j.WorkspaceBuildTargetsResult;
 import java.util.concurrent.CompletableFuture;
+import java.util.function.Supplier;
 import org.jetbrains.bsp.bazel.server.sync.ExecuteService;
 import org.jetbrains.bsp.bazel.server.sync.ProjectSyncService;
 
 public class BspServerApi
     implements BuildServer, JvmBuildServer, ScalaBuildServer, JavaBuildServer, CppBuildServer {
 
-  private final BazelBspServerLifetime serverLifetime;
-  private final BspRequestsRunner runner;
-  private final ProjectSyncService projectSyncService;
-  private final ExecuteService executeService;
+  private final Supplier<BazelServices> bazelServicesBuilder;
+  private BazelBspServerLifetime serverLifetime = null;
+  private BspRequestsRunner runner = null;
+  private ProjectSyncService projectSyncService = null;
+  private ExecuteService executeService = null;
 
-  public BspServerApi(
-      BazelBspServerLifetime serverLifetime,
-      BspRequestsRunner runner,
-      ProjectSyncService projectSyncService,
-      ExecuteService executeService) {
-    this.serverLifetime = serverLifetime;
-    this.runner = runner;
-    this.projectSyncService = projectSyncService;
-    this.executeService = executeService;
+  public BspServerApi(Supplier<BazelServices> bazelServicesBuilder) {
+    this.bazelServicesBuilder = bazelServicesBuilder;
+  }
+
+  void init() {
+    var serverContainer = this.bazelServicesBuilder.get();
+
+    this.serverLifetime = serverContainer.getServerLifetime();
+    this.runner = serverContainer.getBspRequestsRunner();
+    this.projectSyncService = serverContainer.getProjectSyncService();
+    this.executeService = serverContainer.getExecuteService();
   }
 
   @Override
   public CompletableFuture<InitializeBuildResult> buildInitialize(
       InitializeBuildParams initializeBuildParams) {
+    init();
     return runner.handleRequest(
         "buildInitialize", projectSyncService::initialize, runner::serverIsNotFinished);
   }

server/src/main/java/org/jetbrains/bsp/bazel/server/common/ServerContainer.kt

@@ -18,7 +18,6 @@ import org.jetbrains.bsp.bazel.server.sync.languages.java.JdkVersionResolver
 import org.jetbrains.bsp.bazel.server.sync.languages.scala.ScalaLanguagePlugin
 import org.jetbrains.bsp.bazel.server.sync.languages.thrift.ThriftLanguagePlugin
 import org.jetbrains.bsp.bazel.workspacecontext.WorkspaceContextProvider
-import java.nio.file.Path
 
 class ServerContainer internal constructor(
     val projectProvider: ProjectProvider,
@@ -31,24 +30,21 @@ class ServerContainer internal constructor(
     companion object {
         @JvmStatic
         fun create(
-            bspInfo: BspInfo,
-            workspaceContextProvider: WorkspaceContextProvider,
-            workspaceRoot: Path,
-            projectStorage: ProjectStorage?
+                bspInfo: BspInfo,
+                workspaceContextProvider: WorkspaceContextProvider,
+                projectStorage: ProjectStorage?,
+                bspClientLogger: BspClientLogger,
+                bazelRunner: BazelRunner,
+                compilationManager: BazelBspCompilationManager
         ): ServerContainer {
-            val bspClientLogger = BspClientLogger()
             val bazelInfoStorage = BazelInfoStorage(bspInfo)
             val bazelDataResolver =
                 BazelInfoResolver(
-                    BazelRunner.of(workspaceContextProvider, bspClientLogger, workspaceRoot),
+                    bazelRunner,
                     bazelInfoStorage
                 )
             val bazelInfo = bazelDataResolver.resolveBazelInfo()
 
-            val bazelRunner = BazelRunner.of(
-                workspaceContextProvider, bspClientLogger, bazelInfo.workspaceRoot
-            )
-            val compilationManager = BazelBspCompilationManager(bazelRunner)
             val aspectsResolver = InternalAspectsResolver(bspInfo)
             val bazelBspAspectsManager = BazelBspAspectsManager(compilationManager, aspectsResolver)
             val bazelPathsResolver = BazelPathsResolver(bazelInfo)

server/src/main/java/org/jetbrains/bsp/bazel/server/diagnostics/DiagnosticBspMapper.kt

@@ -9,8 +9,9 @@ import ch.epfl.scala.bsp4j.PublishDiagnosticsParams
 import ch.epfl.scala.bsp4j.TextDocumentIdentifier
 import java.nio.file.Paths
 import org.jetbrains.bsp.bazel.bazelrunner.BazelInfo
+import java.nio.file.Path
 
-class DiagnosticBspMapper(private val bazelInfo: BazelInfo) {
+class DiagnosticBspMapper(private val workspaceRoot: Path) {
 
     fun createDiagnostics(diagnostics: List<Diagnostic>, originId: String?): List<PublishDiagnosticsParams> {
         return diagnostics
@@ -39,7 +40,7 @@ class DiagnosticBspMapper(private val bazelInfo: BazelInfo) {
     private fun toAbsoluteUri(rawFileLocation: String): String {
         var path = Paths.get(rawFileLocation)
         if (!path.isAbsolute) {
-            path = bazelInfo.workspaceRoot.resolve(path)
+            path = workspaceRoot.resolve(path)
         }
         return path.toUri().toString()
     }

server/src/main/java/org/jetbrains/bsp/bazel/server/diagnostics/DiagnosticsService.kt

@@ -2,11 +2,12 @@ package org.jetbrains.bsp.bazel.server.diagnostics
 
 import ch.epfl.scala.bsp4j.PublishDiagnosticsParams
 import org.jetbrains.bsp.bazel.bazelrunner.BazelInfo
+import java.nio.file.Path
 
-class DiagnosticsService(bazelInfo: BazelInfo) {
+class DiagnosticsService(workspaceRoot: Path) {
 
     private val parser = DiagnosticsParser()
-    private val mapper = DiagnosticBspMapper(bazelInfo)
+    private val mapper = DiagnosticBspMapper(workspaceRoot)
 
     fun extractDiagnostics(
         bazelOutput: String,

server/src/test/java/org/jetbrains/bsp/bazel/server/diagnostics/DiagnosticsServiceTest.kt

@@ -525,7 +525,6 @@ class DiagnosticsServiceTest {
     }
 
     private fun extractDiagnostics(output: String, buildTarget: String): List<PublishDiagnosticsParams>? {
-        val bazelInfo = BasicBazelInfo("", workspacePath)
-        return DiagnosticsService(bazelInfo).extractDiagnostics(output, buildTarget, null)
+        return DiagnosticsService(workspacePath).extractDiagnostics(output, buildTarget, null)
     }
 }