Merge Task Server & Build Server

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

@@ -27,6 +27,7 @@ public class NamedPipeStream {
 
     private StreamProvider provider;
 
+    private final int MAX_ATTEMPTS = 5;
     interface StreamProvider {
         InputStream getInputStream() throws IOException;
 
@@ -55,35 +56,47 @@ public OutputStream getOutputStream() throws IOException {
         private void initializeNamedPipe() {
             String pathName = generateRandomPipeName();
             sendImporterPipeName(pathName);
-
             File pipeFile = new File(pathName);
 
-            // Need to retry until the pipeName was sent and pipe is created by Extension side
+            int attempts = 0;
             boolean connected = false;
-            while (!connected) {
-                try{
-                    if (isWindows()) {
-                        AsynchronousFileChannel channel = AsynchronousFileChannel.open(pipeFile.toPath(),
-                        StandardOpenOption.READ, StandardOpenOption.WRITE);
-                        input = new NamedPipeInputStream(channel);
-                        output = new NamedPipeOutputStream(channel);
-                    } else {
-                        UnixDomainSocketAddress socketAddress = UnixDomainSocketAddress.of(pipeFile.toPath());
-                        SocketChannel channel = SocketChannel.open(StandardProtocolFamily.UNIX);
-                        channel.connect(socketAddress);
-                        input = new NamedPipeInputStream(channel);
-                        output = new NamedPipeOutputStream(channel);
-                    }
+            // Need to retry until the pipeName was sent and pipe is created by Extension side
+            while (!connected && attempts < MAX_ATTEMPTS) {
+                try {
+                    attemptConnection(pipeFile);
                     connected = true;
                 } catch (IOException e) {
-                    try {
-                        Thread.sleep(1000);
-                    } catch (InterruptedException ie) {
-                        Thread.currentThread().interrupt();
-                        throw new RuntimeException("Thread interrupted while trying to connect to named pipe", ie);
-                    }
+                    handleConnectionFailure(e, attempts);
+                    attempts++;
                 }
             }
+            if (!connected) {
+                throw new RuntimeException("Failed to connect after " + MAX_ATTEMPTS + " attempts.");
+            }
+        }
+
+        private void attemptConnection(File pipeFile) throws IOException {
+            if (isWindows()) {
+                AsynchronousFileChannel channel = AsynchronousFileChannel.open(pipeFile.toPath(),
+                        StandardOpenOption.READ, StandardOpenOption.WRITE);
+                input = new NamedPipeInputStream(channel);
+                output = new NamedPipeOutputStream(channel);
+            } else {
+                UnixDomainSocketAddress socketAddress = UnixDomainSocketAddress.of(pipeFile.toPath());
+                SocketChannel channel = SocketChannel.open(StandardProtocolFamily.UNIX);
+                channel.connect(socketAddress);
+                input = new NamedPipeInputStream(channel);
+                output = new NamedPipeOutputStream(channel);
+            }
+        }
+
+        private void handleConnectionFailure(IOException e, int attempts) {
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException ie) {
+                Thread.currentThread().interrupt();
+                throw new RuntimeException("Thread interrupted while handling connection failure", ie);
+            }
         }
     }
 
@@ -202,6 +215,7 @@ public InputStream getInputStream() throws IOException {
     }
 
     public OutputStream getOutputStream() throws IOException {
+
         return getSelectedStream().getOutputStream();
     }
 
@@ -214,7 +228,7 @@ private void sendImporterPipeName(String pipeName){
             .sendNotification("gradle.getImporterPipeName", pipeName);
     }
 
-    public static String generateRandomHex(int numBytes) {
+    private static String generateRandomHex(int numBytes) {
         SecureRandom random = new SecureRandom();
         byte[] bytes = new byte[numBytes];
         random.nextBytes(bytes);
@@ -225,7 +239,7 @@ public static String generateRandomHex(int numBytes) {
         return hexString.toString();
     }
 
-    public String generateRandomPipeName() {
+    private String generateRandomPipeName() {
         if (System.getProperty("os.name").startsWith("Windows")) {
             return Paths.get("\\\\.\\pipe\\", generateRandomHex(16) + "-sock").toString();
         }

extension/package.json

@@ -131,14 +131,6 @@
           "dark": "resources/dark/run.svg"
         }
       },
-      {
-        "command": "gradle.getBundleDirectory",
-        "title": "Get Build Server Port"
-      },
-      {
-        "command": "gradle.getBundlePath",
-        "title": "Get Build Server Port"
-      },
       {
         "command": "gradle.runBuild",
         "category": "Gradle",

extension/src/Extension.ts

@@ -31,14 +31,13 @@ import {
     GRADLE_COMPLETION,
     GRADLE_PROPERTIES_FILE_CHANGE,
     VSCODE_TRIGGER_COMPLETION,
-    GET_EXTENSION_PATH,
 } from "./constant";
 import { instrumentOperation, sendInfo } from "vscode-extension-telemetry-wrapper";
 import { GradleBuildContentProvider } from "./client/GradleBuildContentProvider";
 import { BuildServerController } from "./bs/BuildServerController";
-import { MessageForwardHandler } from "./bs/MessageForwardHandler";
+import { MessageProxy } from "./bs/MessageProxy";
 export class Extension {
-    private readonly messageForwardHandler: MessageForwardHandler;
+    private readonly messageProxy: MessageProxy;
     private readonly client: GradleClient;
     private readonly server: GradleServer;
     private readonly pinnedTasksStore: PinnedTasksStore;
@@ -83,14 +82,8 @@ export class Extension {
         }
 
         const statusBarItem = vscode.window.createStatusBarItem();
-        this.context.subscriptions.push(
-            vscode.commands.registerCommand(GET_EXTENSION_PATH, () => {
-                return this.context.extensionPath;
-            })
-        );
-
-        this.messageForwardHandler = new MessageForwardHandler(this.context);
-        this.server = new GradleServer({ host: "localhost" }, context, serverLogger, this.messageForwardHandler);
+        this.messageProxy = new MessageProxy(this.context);
+        this.server = new GradleServer({ host: "localhost" }, context, serverLogger, this.messageProxy);
         this.client = new GradleClient(this.server, statusBarItem, clientLogger);
         this.pinnedTasksStore = new PinnedTasksStore(context);
         this.recentTasksStore = new RecentTasksStore();
@@ -238,7 +231,7 @@ export class Extension {
         if (!this.server.isReady()) {
             await this.server.start();
         }
-        await this.messageForwardHandler.startForwarding();
+        await this.messageProxy.start();
         await vscode.commands.executeCommand("setContext", "gradle:activated", activated);
         await vscode.commands.executeCommand("setContext", "gradle:defaultView", true);
     }

extension/src/bs/BuildServerConnector.ts

@@ -0,0 +1,33 @@
+import * as net from "net";
+import * as rpc from "vscode-jsonrpc/node";
+import { generateRandomPipeName } from "../util/generateRandomPipeName";
+
+export class BuildServerConnector {
+    private serverConnection: rpc.MessageConnection | null = null;
+    private serverPipeServer: net.Server;
+    private serverPipePath: string;
+
+    constructor() {
+        this.setupServer();
+    }
+
+    private setupServer(): void {
+        this.serverPipePath = generateRandomPipeName();
+        this.serverPipeServer = net.createServer((socket: net.Socket) => {
+            this.serverConnection = rpc.createMessageConnection(
+                new rpc.StreamMessageReader(socket),
+                new rpc.StreamMessageWriter(socket)
+            );
+            this.serverConnection.listen();
+        });
+        this.serverPipeServer.listen(this.serverPipePath);
+    }
+
+    public getServerConnection(): rpc.MessageConnection | null {
+        return this.serverConnection;
+    }
+
+    public getServerPipePath(): string {
+        return this.serverPipePath;
+    }
+}

extension/src/bs/JdtlsImporterConnector.ts

@@ -0,0 +1,52 @@
+import * as net from "net";
+import * as rpc from "vscode-jsonrpc/node";
+import * as vscode from "vscode";
+import * as path from "path";
+
+export const GET_IMPORTER_PIPE_NAME = "gradle.getImporterPipeName";
+
+export class JdtlsImporterConnector {
+    private importerConnection: rpc.MessageConnection | null = null;
+    private importerPipeServer: net.Server;
+    private importerPipePath: string;
+    private readonly context: vscode.ExtensionContext;
+
+    constructor(context: vscode.ExtensionContext) {
+        this.context = context;
+    }
+
+    //receive the pipe name from Java jdt.ls importer
+    public async waitForImporterPipePath(): Promise<void> {
+        return new Promise((resolve) => {
+            this.context.subscriptions.push(
+                vscode.commands.registerCommand(GET_IMPORTER_PIPE_NAME, (pipeName: string) => {
+                    this.importerPipePath = path.resolve(pipeName);
+                    resolve();
+                })
+            );
+        });
+    }
+
+    public setupImporterServer(buildServerConnection: rpc.MessageConnection | null): void {
+        this.importerPipeServer = net.createServer((socket: net.Socket) => {
+            this.importerConnection = rpc.createMessageConnection(
+                new rpc.StreamMessageReader(socket),
+                new rpc.StreamMessageWriter(socket)
+            );
+            this.setupMessageForwarding(buildServerConnection);
+            this.importerConnection.listen();
+        });
+        this.importerPipeServer.listen(this.importerPipePath);
+    }
+
+    private setupMessageForwarding(buildServerConnection: rpc.MessageConnection | null): void {
+        const importerConnection = this.importerConnection;
+
+        importerConnection?.onRequest((method, params) => {
+            return buildServerConnection?.sendRequest(method, params);
+        });
+        buildServerConnection?.onNotification((method, params) => {
+            importerConnection?.sendNotification(method, params);
+        });
+    }
+}

extension/src/bs/MessageProxy.ts

@@ -0,0 +1,21 @@
+import { JdtlsImporterConnector } from "./JdtlsImporterConnector";
+import { BuildServerConnector } from "./BuildServerConnector";
+import * as vscode from "vscode";
+
+export class MessageProxy {
+    private buildServerConnector: BuildServerConnector;
+    private jdtlsImporterConnector: JdtlsImporterConnector;
+
+    constructor(context: vscode.ExtensionContext) {
+        this.buildServerConnector = new BuildServerConnector();
+        this.jdtlsImporterConnector = new JdtlsImporterConnector(context);
+    }
+
+    public async start(): Promise<void> {
+        await this.jdtlsImporterConnector.waitForImporterPipePath();
+        this.jdtlsImporterConnector.setupImporterServer(this.buildServerConnector.getServerConnection());
+    }
+    public getBuildServerPipeName(): string {
+        return this.buildServerConnector.getServerPipePath();
+    }
+}

extension/src/constant.ts

@@ -5,7 +5,6 @@
 export namespace Context {
     export const ACTIVATION_CONTEXT_KEY = "gradle:extensionActivated";
 }
-export const GET_EXTENSION_PATH = "gradle.getExtensionPath";
 
 export const GRADLE_BUILD_FILE_CHANGE = "gradle.buildFileChanged";