You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@netbeans.apache.org by en...@apache.org on 2021/05/31 07:40:22 UTC

[netbeans] branch master updated: Debugger attach in VSCode extension. (#5346)

This is an automated email from the ASF dual-hosted git repository.

entl pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/netbeans.git


The following commit(s) were added to refs/heads/master by this push:
     new c47c7f2  Debugger attach in VSCode extension. (#5346)
c47c7f2 is described below

commit c47c7f22bb7adc97af6c428100487ab2f82688e3
Author: Martin Entlicher <ma...@oracle.com>
AuthorDate: Thu May 27 18:16:49 2021 +0200

    Debugger attach in VSCode extension. (#5346)
---
 .../lsp/server/debugging/NbProtocolServer.java     |  14 +-
 .../debugging/attach/AttachConfigurations.java     | 222 +++++++++++++++++++++
 .../debugging/attach/NbAttachRequestHandler.java   | 222 +++++++++++++++++++++
 .../server/debugging/launch/NbDebugSession.java    |   2 +-
 .../java/lsp/server/protocol/DebugConnector.java   | 151 ++++++++++++++
 .../modules/java/lsp/server/protocol/Server.java   |  27 ++-
 .../lsp/server/protocol/WorkspaceServiceImpl.java  |  15 +-
 .../java/lsp/server/protocol/ServerTest.java       |  42 ++++
 java/java.lsp.server/vscode/package.json           |  39 +++-
 java/java.lsp.server/vscode/src/extension.ts       |  61 +++---
 java/java.lsp.server/vscode/src/protocol.ts        |   7 +
 11 files changed, 758 insertions(+), 44 deletions(-)

diff --git a/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/NbProtocolServer.java b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/NbProtocolServer.java
index 56f20df..6ae1497 100644
--- a/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/NbProtocolServer.java
+++ b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/NbProtocolServer.java
@@ -19,19 +19,15 @@
 package org.netbeans.modules.java.lsp.server.debugging;
 
 import java.io.File;
-import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.net.URL;
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicReference;
 
 import org.apache.commons.lang3.StringUtils;
 import org.eclipse.lsp4j.debug.Capabilities;
@@ -41,7 +37,6 @@ import org.eclipse.lsp4j.debug.ContinueResponse;
 import org.eclipse.lsp4j.debug.DisconnectArguments;
 import org.eclipse.lsp4j.debug.EvaluateArguments;
 import org.eclipse.lsp4j.debug.EvaluateResponse;
-import org.eclipse.lsp4j.debug.ExceptionBreakMode;
 import org.eclipse.lsp4j.debug.ExceptionBreakpointsFilter;
 import org.eclipse.lsp4j.debug.ExceptionInfoArguments;
 import org.eclipse.lsp4j.debug.ExceptionInfoResponse;
@@ -79,10 +74,11 @@ import org.netbeans.api.debugger.jpda.ObjectVariable;
 import org.netbeans.api.debugger.jpda.Variable;
 import org.netbeans.modules.debugger.jpda.truffle.vars.TruffleVariable;
 import org.netbeans.modules.java.lsp.server.LspSession;
+import org.netbeans.modules.java.lsp.server.debugging.breakpoints.NbBreakpointsRequestHandler;
+import org.netbeans.modules.java.lsp.server.debugging.attach.NbAttachRequestHandler;
 import org.netbeans.modules.java.lsp.server.debugging.launch.NbDebugSession;
 import org.netbeans.modules.java.lsp.server.debugging.launch.NbDisconnectRequestHandler;
 import org.netbeans.modules.java.lsp.server.debugging.launch.NbLaunchRequestHandler;
-import org.netbeans.modules.java.lsp.server.debugging.breakpoints.NbBreakpointsRequestHandler;
 import org.netbeans.modules.java.lsp.server.debugging.variables.NbVariablesRequestHandler;
 import org.netbeans.modules.java.lsp.server.debugging.utils.ErrorUtilities;
 import org.netbeans.modules.nativeimage.api.debug.EvaluateException;
@@ -99,6 +95,7 @@ public final class NbProtocolServer implements IDebugProtocolServer, LspSession.
 
     private final DebugAdapterContext context;
     private final NbLaunchRequestHandler launchRequestHandler = new NbLaunchRequestHandler();
+    private final NbAttachRequestHandler attachRequestHandler = new NbAttachRequestHandler();
     private final NbDisconnectRequestHandler disconnectRequestHandler = new NbDisconnectRequestHandler();
     private final NbBreakpointsRequestHandler breakpointsRequestHandler = new NbBreakpointsRequestHandler();
     private final NbVariablesRequestHandler variablesRequestHandler = new NbVariablesRequestHandler();
@@ -172,6 +169,11 @@ public final class NbProtocolServer implements IDebugProtocolServer, LspSession.
     }
 
     @Override
+    public CompletableFuture<Void> attach(Map<String, Object> args) {
+        return attachRequestHandler.attach(args, context);
+    }
+
+    @Override
     public CompletableFuture<Void> disconnect(DisconnectArguments args) {
         return disconnectRequestHandler.disconnect(args, context);
     }
diff --git a/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/attach/AttachConfigurations.java b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/attach/AttachConfigurations.java
new file mode 100644
index 0000000..5a99511
--- /dev/null
+++ b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/attach/AttachConfigurations.java
@@ -0,0 +1,222 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.netbeans.modules.java.lsp.server.debugging.attach;
+
+import com.sun.jdi.Bootstrap;
+import com.sun.jdi.VirtualMachineManager;
+import com.sun.jdi.connect.AttachingConnector;
+import com.sun.jdi.connect.Connector;
+import com.sun.tools.attach.AttachNotSupportedException;
+import com.sun.tools.attach.VirtualMachine;
+import com.sun.tools.attach.VirtualMachineDescriptor;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.CompletableFuture;
+
+import org.eclipse.lsp4j.MessageParams;
+import org.eclipse.lsp4j.MessageType;
+import org.eclipse.lsp4j.jsonrpc.messages.ResponseErrorCode;
+
+import org.netbeans.modules.java.lsp.server.debugging.utils.ErrorUtilities;
+import org.netbeans.modules.java.lsp.server.protocol.DebugConnector;
+import org.netbeans.modules.java.lsp.server.protocol.NbCodeLanguageClient;
+import org.netbeans.modules.java.lsp.server.protocol.QuickPickItem;
+import org.netbeans.modules.java.lsp.server.protocol.Server;
+import org.netbeans.modules.java.lsp.server.protocol.ShowQuickPickParams;
+import org.openide.util.NbBundle.Messages;
+import org.openide.util.RequestProcessor;
+
+/**
+ * Debugger attach configurations provider.
+ *
+ * @author Martin Entlicher
+ */
+public final class AttachConfigurations {
+
+    static final String NAME_ATTACH_PROCESS = "Attach to Process";          // NOI18N
+    static final String NAME_ATTACH_SOCKET = "Attach to Port";              // NOI18N
+    static final String NAME_ATTACH_SHMEM = "Attach to Shared Memory";      // NOI18N
+    static final String NAME_ATTACH_BY = "Attach by ";                      // NOI18N
+
+    static final String CONNECTOR_PROCESS = "com.sun.jdi.ProcessAttach";    // NOI18N
+    static final String CONNECTOR_SOCKET = "com.sun.jdi.SocketAttach";      // NOI18N
+    static final String CONNECTOR_SHMEM = "com.sun.jdi.SharedMemoryAttach"; // NOI18N
+
+    static final String PROCESS_ARG_PID = "processId";          // NOI18N
+    static final String SOCKET_ARG_HOST = "hostName";           // NOI18N
+    static final String SOCKET_ARG_PORT = "port";               // NOI18N
+    static final String SHMEM_ARG_NAME = "sharedMemoryName";    // NOI18N
+
+    private static final RequestProcessor RP = new RequestProcessor(AttachConfigurations.class);
+
+    private AttachConfigurations() {}
+
+    public static CompletableFuture<Object> findConnectors() {
+        return CompletableFuture.supplyAsync(() -> {
+            return listAttachingConnectors();
+        }, RP);
+    }
+
+    @Messages({"LBL_ConnectorPort=port of the debuggee JVM", "LBL_ConnectorShmemName=shared memory name"})
+    private static List<DebugConnector> listAttachingConnectors() {
+        VirtualMachineManager vmm = Bootstrap.virtualMachineManager ();
+        List<AttachingConnector> attachingConnectors = vmm.attachingConnectors();
+        List<DebugConnector> connectors = new ArrayList<>(5);
+        String type = "java8+";             // NOI18N
+        for (AttachingConnector ac : attachingConnectors) {
+            String connectorName = ac.name();
+            Map<String, Connector.Argument> defaultArguments = ac.defaultArguments();
+            DebugConnector connector;
+            switch (connectorName) {
+                case CONNECTOR_PROCESS:
+                    connector = new DebugConnector(NAME_ATTACH_PROCESS, type,
+                            Collections.singletonList(PROCESS_ARG_PID),
+                            Collections.singletonList("${command:" + Server.JAVA_FIND_DEBUG_PROCESS_TO_ATTACH + "}"));    // NOI18N
+                    break;
+                case CONNECTOR_SOCKET: {
+                    String hostName = getArgumentOrDefault(defaultArguments.get("hostname"), "localhost");          // NOI18N
+                    String port = getArgumentOrDefault(defaultArguments.get("port"), "<"+Bundle.LBL_ConnectorPort()+">"); // NOI18N
+                    connector = new DebugConnector(NAME_ATTACH_SOCKET, type,
+                            Arrays.asList(SOCKET_ARG_HOST, SOCKET_ARG_PORT),
+                            Arrays.asList(hostName, port));
+                    break;
+                }
+                case CONNECTOR_SHMEM: {
+                    String name = getArgumentOrDefault(defaultArguments.get("name"), "<"+Bundle.LBL_ConnectorShmemName()+">");       // NOI18N
+                    connector = new DebugConnector(NAME_ATTACH_SHMEM, type,
+                            Collections.singletonList(SHMEM_ARG_NAME),
+                            Collections.singletonList(name));
+                    break;
+                }
+                default: {
+                    List<String> names = new ArrayList<>();
+                    List<String> values = new ArrayList<>();
+                    for (Connector.Argument arg : defaultArguments.values()) {
+                        if (arg.mustSpecify()) {
+                            names.add(arg.name());
+                            String value = arg.value();
+                            if (value.isEmpty()) {
+                                value = "<" + arg.description()+ ">";   // NOI18N
+                            }
+                            values.add(value);
+                        }
+                    }
+                    connector = new DebugConnector(NAME_ATTACH_BY + connectorName, type,
+                            names, values);
+                }
+            }
+            connectors.add(connector);
+        }
+        connectors.sort((c1, c2) -> c1.getName().compareToIgnoreCase(c2.getName()));
+        return connectors;
+    }
+
+    private static String getArgumentOrDefault(Connector.Argument arg, String def) {
+        if (arg != null) {
+            String value = arg.value();
+            if (!value.isEmpty()) {
+                return value;
+            }
+        }
+        return def;
+    }
+
+    public static CompletableFuture<Object> findProcessAttachTo(NbCodeLanguageClient client) {
+        return CompletableFuture.supplyAsync(() -> {
+            return listProcessesToAttachTo(client);
+        }, RP).thenCompose(params -> client.showQuickPick(params)).thenApply(itemsList -> {
+            if (itemsList == null || itemsList.isEmpty()) {
+                return null;
+            } else {
+                return itemsList.get(0).getUserData();
+            }
+        });
+    }
+
+    @Messages("MSG_NoDebuggableProcess=No debuggable JVM process found. Please be sure to use `-agentlib:jdwp=transport=dt_socket,server=y` option.")
+    private static void notifyNoProcessesError(NbCodeLanguageClient client) {
+        MessageParams params = new MessageParams();
+        params.setMessage(Bundle.MSG_NoDebuggableProcess());
+        params.setType(MessageType.Error);
+        client.showMessage(params);
+    }
+
+    @Messages("LBL_PickProcessAttach=Pick JVM process to attach to:")
+    private static ShowQuickPickParams listProcessesToAttachTo(NbCodeLanguageClient client) {
+        List<QuickPickItem> attachables = new ArrayList<>();
+        List<VirtualMachineDescriptor> descriptors = VirtualMachine.list();
+        for (VirtualMachineDescriptor descriptor : descriptors) {
+            try {
+                VirtualMachine vm = VirtualMachine.attach(descriptor);
+                Properties agentProperties = vm.getAgentProperties();
+                boolean hasJDWP = false;
+                for (Object key : agentProperties.keySet()) {
+                    if (key instanceof String && ((String) key).contains("jdwp")) { // NOI18N
+                        hasJDWP = true;
+                        break;
+                    }
+                }
+                if (hasJDWP) {
+                    attachables.add(createQuickPickItem(descriptor, vm));
+                }
+            } catch (AttachNotSupportedException | IOException ex) {
+                continue;
+            }
+        }
+        if (attachables.isEmpty()) {
+            notifyNoProcessesError(client);
+            throw ErrorUtilities.createResponseErrorException("No debuggable JVM process found.", ResponseErrorCode.RequestCancelled);  // NOI18N
+        }
+        return new ShowQuickPickParams(Bundle.LBL_PickProcessAttach(), attachables);
+    }
+
+    private static QuickPickItem createQuickPickItem(VirtualMachineDescriptor descriptor, VirtualMachine vm) {
+        String label = descriptor.id();
+        String detail = descriptor.displayName();
+        if ("Unknown".equals(detail)) {     // NOI18N
+            String command = null;
+            try {
+                command = vm.getSystemProperties().getProperty("sun.java.command");     // NOI18N
+            } catch (IOException ex) {}
+            if (command == null) {
+                try {
+                    command = vm.getAgentProperties().getProperty("sun.java.command");  // NOI18N
+                } catch (IOException ex) {}
+            }
+            if (command != null) {
+                detail = command;
+            }
+        }
+        int index = detail.indexOf(' ');
+        String description = index > 0 ? detail.substring(0, index) : detail;
+        if (index <= 0) {
+            // Do not duplicate the description.
+            detail = null;
+        }
+        Object userData = descriptor.id(); // Process Id
+        return new QuickPickItem(label, description, detail, false, userData);
+    }
+
+}
diff --git a/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/attach/NbAttachRequestHandler.java b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/attach/NbAttachRequestHandler.java
new file mode 100644
index 0000000..8b403f8
--- /dev/null
+++ b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/attach/NbAttachRequestHandler.java
@@ -0,0 +1,222 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.netbeans.modules.java.lsp.server.debugging.attach;
+
+import com.sun.jdi.Bootstrap;
+import com.sun.jdi.VirtualMachineManager;
+import com.sun.jdi.connect.AttachingConnector;
+import com.sun.jdi.connect.Connector.Argument;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.eclipse.lsp4j.MessageParams;
+import org.eclipse.lsp4j.MessageType;
+import org.eclipse.lsp4j.debug.TerminatedEventArguments;
+import org.eclipse.lsp4j.jsonrpc.messages.ResponseErrorCode;
+
+import org.netbeans.api.debugger.DebuggerEngine;
+import org.netbeans.api.debugger.DebuggerInfo;
+import org.netbeans.api.debugger.DebuggerManager;
+import org.netbeans.api.debugger.Session;
+import org.netbeans.api.debugger.jpda.AttachingDICookie;
+import org.netbeans.api.debugger.jpda.DebuggerStartException;
+import org.netbeans.api.debugger.jpda.JPDADebugger;
+import org.netbeans.modules.java.lsp.server.debugging.DebugAdapterContext;
+import org.netbeans.modules.java.lsp.server.debugging.launch.NbDebugSession;
+import org.netbeans.modules.java.lsp.server.debugging.utils.ErrorUtilities;
+import org.netbeans.modules.java.lsp.server.protocol.NbCodeLanguageClient;
+import org.openide.util.NbBundle.Messages;
+import org.openide.util.RequestProcessor;
+
+/**
+ *
+ * @author Martin Entlicher
+ */
+public final class NbAttachRequestHandler {
+
+    private static final String CONNECTOR_ARG_PID = "pid";          // NOI18N
+    private static final String CONNECTOR_ARG_HOST = "hostname";    // NOI18N
+    private static final String CONNECTOR_ARG_PORT = "port";        // NOI18N
+    private static final String CONNECTOR_ARG_NAME = "name";        // NOI18N
+    // The default attributes of DebugConfiguration
+    private static final Set<String> CONFIG_ATTRIBUTES = new HashSet<>(Arrays.asList("type", "name", "request", "classPaths", "console"));   // NOI18N
+
+    private static final RequestProcessor RP = new RequestProcessor(AttachConfigurations.class);
+
+    public CompletableFuture<Void> attach(Map<String, Object> attachArguments, DebugAdapterContext context) {
+        boolean isNative = "nativeimage".equals(attachArguments.get("type"));   // NOI18N
+        if (isNative) {
+            return attachToNative(attachArguments, context);
+        } else {
+            return attachToJVM(attachArguments, context);
+        }
+    }
+
+    private CompletableFuture<Void> attachToNative(Map<String, Object> attachArguments, DebugAdapterContext context) {
+        CompletableFuture<Void> resultFuture = new CompletableFuture<>();
+        // TODO
+        ErrorUtilities.completeExceptionally(resultFuture,
+                "Attach to native image is not implemented yet", ResponseErrorCode.serverErrorStart);
+        return resultFuture;
+    }
+
+    @Messages({"# {0} - connector name", "MSG_InvalidConnector=Invalid connector name: {0}"})
+    private CompletableFuture<Void> attachToJVM(Map<String, Object> attachArguments, DebugAdapterContext context) {
+        String name = (String) attachArguments.get("name");     // NOI18N
+        AttachingDICookie attachingCookie;
+        String connectorName;
+        Map<String, String> translatedArguments = new HashMap<>();
+        CompletableFuture<Void> resultFuture = new CompletableFuture<>();
+        switch (name) {
+            case AttachConfigurations.NAME_ATTACH_PROCESS:
+                Object pid = attachArguments.get(AttachConfigurations.PROCESS_ARG_PID);
+                connectorName = AttachConfigurations.CONNECTOR_PROCESS;
+                translatedArguments.put(AttachConfigurations.PROCESS_ARG_PID, CONNECTOR_ARG_PID);
+                break;
+            case AttachConfigurations.NAME_ATTACH_SOCKET:
+                connectorName = AttachConfigurations.CONNECTOR_SOCKET;
+                translatedArguments.put(AttachConfigurations.SOCKET_ARG_HOST, CONNECTOR_ARG_HOST);
+                translatedArguments.put(AttachConfigurations.SOCKET_ARG_PORT, CONNECTOR_ARG_PORT);
+                break;
+            case AttachConfigurations.NAME_ATTACH_SHMEM:
+                connectorName = AttachConfigurations.CONNECTOR_SHMEM;
+                translatedArguments.put(AttachConfigurations.SHMEM_ARG_NAME, CONNECTOR_ARG_NAME);
+                break;
+            default:
+                if (name.startsWith(AttachConfigurations.NAME_ATTACH_BY)) {
+                    connectorName = name.substring(AttachConfigurations.NAME_ATTACH_BY.length());
+                } else {
+                    ErrorUtilities.completeExceptionally(resultFuture,
+                            Bundle.MSG_InvalidConnector(name),
+                            ResponseErrorCode.serverErrorStart);
+                    connectorName = null;
+                }
+        }
+        if (connectorName != null) {
+            context.setDebugMode(true);
+            RP.post(() -> attachTo(connectorName, attachArguments, translatedArguments, context, resultFuture));
+        } else {
+            assert resultFuture.isCompletedExceptionally();
+        }
+        return resultFuture;
+    }
+
+    @Messages({"# {0} - connector name", "# {1} - argument name", "MSG_ConnectorArgumentNotFound=Argument {0} of {1} was not found.",
+               "# {0} - argument name", "# {1} - value", "MSG_ConnectorInvalidValue=Invalid value of {0}: {1}",
+               "# {0} - connector name", "MSG_ConnectorNotFound=Connector {0} was not found."})
+    private void attachTo(String connectorName, Map<String, Object> arguments, Map<String, String> translatedArguments, DebugAdapterContext context, CompletableFuture<Void> resultFuture) {
+        VirtualMachineManager vmm = Bootstrap.virtualMachineManager ();
+        List<AttachingConnector> attachingConnectors = vmm.attachingConnectors();
+        for (AttachingConnector connector : attachingConnectors) {
+            if (connector.name().equals(connectorName)) {
+                Map<String, Argument> args = connector.defaultArguments();
+                for (String argName : arguments.keySet()) {
+                    if (CONFIG_ATTRIBUTES.contains(argName) || argName.startsWith("__")) {
+                        continue;
+                    }
+                    String argNameTranslated = translatedArguments.getOrDefault(argName, argName);
+                    Argument arg = args.get(argNameTranslated);
+                    if (arg == null) {
+                        ErrorUtilities.completeExceptionally(resultFuture,
+                            Bundle.MSG_ConnectorArgumentNotFound(connectorName, argNameTranslated),
+                            ResponseErrorCode.serverErrorStart);
+                        return ;
+                    }
+                    String value = arguments.get(argName).toString();
+                    if (!arg.isValid(value)) {
+                        ErrorUtilities.completeExceptionally(resultFuture,
+                            Bundle.MSG_ConnectorInvalidValue(argName, value),
+                            ResponseErrorCode.serverErrorStart);
+                        return ;
+                    }
+                    arg.setValue(value);
+                }
+                AttachingDICookie attachingCookie = AttachingDICookie.create(connector, args);
+                resultFuture.complete(null);
+                startAttaching(attachingCookie, context);
+                return ;
+            }
+        }
+        ErrorUtilities.completeExceptionally(resultFuture,
+                Bundle.MSG_ConnectorNotFound(connectorName),
+                ResponseErrorCode.serverErrorStart);
+    }
+
+    @Messages("MSG_FailedToAttach=Failed to attach.")
+    private void startAttaching(AttachingDICookie attachingCookie, DebugAdapterContext context) {
+        DebuggerEngine[] es = DebuggerManager.getDebuggerManager ().startDebugging(
+            DebuggerInfo.create(AttachingDICookie.ID, new Object [] { attachingCookie })
+        );
+        if (es.length > 0) {
+            JPDADebugger debugger = es[0].lookupFirst(null, JPDADebugger.class);
+            if (debugger != null) {
+                Session session = es[0].lookupFirst(null, Session.class);
+                NbDebugSession debugSession = new NbDebugSession(session);
+                context.setDebugSession(debugSession);
+                AtomicBoolean finished = new AtomicBoolean(false);
+                debugger.addPropertyChangeListener(JPDADebugger.PROP_STATE, new PropertyChangeListener() {
+                    @Override
+                    public void propertyChange(PropertyChangeEvent evt) {
+                        int newState = (int) evt.getNewValue();
+                        if (newState == JPDADebugger.STATE_DISCONNECTED) {
+                            if (!finished.getAndSet(true)) {
+                                notifyTerminated(context);
+                            }
+                        }
+                    }
+                });
+                boolean success = false;
+                try {
+                    debugger.waitRunning();
+                    success = debugger.getState() != JPDADebugger.STATE_DISCONNECTED;
+                } catch (DebuggerStartException ex) {
+                    notifyErrorMessage(context, ex.getLocalizedMessage());
+                }
+                if (!success) {
+                    if (!finished.getAndSet(true)) {
+                        notifyTerminated(context);
+                    }
+                }
+                return ;
+            }
+        }
+        notifyErrorMessage(context, Bundle.MSG_FailedToAttach());
+        notifyTerminated(context);
+    }
+
+    private void notifyErrorMessage(DebugAdapterContext context, String message) {
+        MessageParams params = new MessageParams();
+        params.setMessage(message);
+        params.setType(MessageType.Error);
+        context.getLspSession().getLookup().lookup(NbCodeLanguageClient.class).showMessage(params);
+    }
+
+    private void notifyTerminated(DebugAdapterContext context) {
+        context.getClient().terminated(new TerminatedEventArguments());
+    }
+}
diff --git a/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/launch/NbDebugSession.java b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/launch/NbDebugSession.java
index e18052c..3c110a6 100644
--- a/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/launch/NbDebugSession.java
+++ b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/launch/NbDebugSession.java
@@ -31,7 +31,7 @@ public final class NbDebugSession {
     private final Session session;
     private volatile NIDebugger niDebugger;
 
-    NbDebugSession(Session session) {
+    public NbDebugSession(Session session) {
         this.session = session;
     }
 
diff --git a/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/DebugConnector.java b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/DebugConnector.java
new file mode 100644
index 0000000..e8b3a20
--- /dev/null
+++ b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/DebugConnector.java
@@ -0,0 +1,151 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.netbeans.modules.java.lsp.server.protocol;
+
+import java.util.List;
+import java.util.Objects;
+import org.eclipse.lsp4j.jsonrpc.validation.NonNull;
+import org.eclipse.xtext.xbase.lib.Pure;
+import org.eclipse.xtext.xbase.lib.util.ToStringBuilder;
+
+/**
+ * Debug connector arguments.
+ *
+ * @author Martin Entlicher
+ */
+public final class DebugConnector {
+
+    /**
+     * The display name identifier of the connector.
+     */
+    @NonNull
+    private String name;
+
+    /**
+     * The type of the connector.
+     */
+    @NonNull
+    private String type;
+
+    /**
+     * The debug connector arguments.
+     */
+    @NonNull
+    private List<String> arguments;
+
+    /**
+     * Default values of debug connector arguments.
+     */
+    @NonNull
+    private List<String> defaultValues;
+
+    public DebugConnector(String name, String type, List<String> arguments, List<String> defaultValues) {
+        this.name = name;
+        this.type = type;
+        this.arguments = arguments;
+        this.defaultValues = defaultValues;
+    }
+
+    @Pure
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Pure
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    @Pure
+    public List<String> getArguments() {
+        return arguments;
+    }
+
+    public void setArguments(List<String> arguments) {
+        this.arguments = arguments;
+    }
+
+    @Pure
+    public List<String> getDefaultValues() {
+        return defaultValues;
+    }
+
+    public void setDefaultValues(List<String> defaultValues) {
+        this.defaultValues = defaultValues;
+    }
+
+    @Pure
+    @Override
+    public int hashCode() {
+        int hash = 7;
+        hash = 37 * hash + Objects.hashCode(this.name);
+        hash = 37 * hash + Objects.hashCode(this.type);
+        hash = 37 * hash + Objects.hashCode(this.arguments);
+        hash = 37 * hash + Objects.hashCode(this.defaultValues);
+        return hash;
+    }
+
+    @Pure
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final DebugConnector other = (DebugConnector) obj;
+        if (!Objects.equals(this.name, other.name)) {
+            return false;
+        }
+        if (!Objects.equals(this.type, other.type)) {
+            return false;
+        }
+        if (!Objects.equals(this.arguments, other.arguments)) {
+            return false;
+        }
+        if (!Objects.equals(this.defaultValues, other.defaultValues)) {
+            return false;
+        }
+        return true;
+    }
+
+    @Pure
+    @Override
+    public String toString() {
+        ToStringBuilder b = new ToStringBuilder(this);
+        b.add("name", name);
+        b.add("type", type);
+        b.add("arguments", arguments.toString());
+        b.add("defaultValues", defaultValues.toString());
+        return b.toString();
+    }
+
+}
diff --git a/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/Server.java b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/Server.java
index cb184b2..3a19dea 100644
--- a/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/Server.java
+++ b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/Server.java
@@ -606,9 +606,18 @@ public final class Server {
                 capabilities.setImplementationProvider(true);
                 capabilities.setDocumentHighlightProvider(true);
                 capabilities.setReferencesProvider(true);
-                List<String> commands = new ArrayList<>(Arrays.asList(JAVA_NEW_FROM_TEMPLATE, JAVA_BUILD_WORKSPACE, JAVA_GET_PROJECT_SOURCE_ROOTS,
-                        JAVA_GET_PROJECT_CLASSPATH, JAVA_GET_PROJECT_PACKAGES,JAVA_LOAD_WORKSPACE_TESTS, GRAALVM_PAUSE_SCRIPT, JAVA_SUPER_IMPLEMENTATION,
-                        JAVA_FIND_CONFIGURATIONS));
+                List<String> commands = new ArrayList<>(Arrays.asList(
+                        GRAALVM_PAUSE_SCRIPT,
+                        JAVA_BUILD_WORKSPACE,
+                        JAVA_FIND_DEBUG_ATTACH_CONFIGURATIONS,
+                        JAVA_FIND_DEBUG_PROCESS_TO_ATTACH,
+                        JAVA_FIND_PROJECT_CONFIGURATIONS,
+                        JAVA_GET_PROJECT_CLASSPATH,
+                        JAVA_GET_PROJECT_PACKAGES,
+                        JAVA_GET_PROJECT_SOURCE_ROOTS,
+                        JAVA_LOAD_WORKSPACE_TESTS,
+                        JAVA_NEW_FROM_TEMPLATE,
+                        JAVA_SUPER_IMPLEMENTATION));
                 for (CodeGenerator codeGenerator : Lookup.getDefault().lookupAll(CodeGenerator.class)) {
                     commands.addAll(codeGenerator.getCommands());
                 }
@@ -731,8 +740,16 @@ public final class Server {
     /**
      * Enumerates project configurations.
      */
-    public static final String JAVA_FIND_CONFIGURATIONS = "java.project.configurations";
-            
+    public static final String JAVA_FIND_PROJECT_CONFIGURATIONS = "java.project.configurations";
+    /**
+     * Enumerates attach debugger configurations.
+     */
+    public static final String JAVA_FIND_DEBUG_ATTACH_CONFIGURATIONS = "java.attachDebugger.configurations";
+    /**
+     * Enumerates JVM processes eligible for debugger attach.
+     */
+    public static final String JAVA_FIND_DEBUG_PROCESS_TO_ATTACH = "java.attachDebugger.pickProcess";
+
     static final String INDEXING_COMPLETED = "Indexing completed.";
     static final String NO_JAVA_SUPPORT = "Cannot initialize Java support on JDK ";
 
diff --git a/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/WorkspaceServiceImpl.java b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/WorkspaceServiceImpl.java
index 8fe666d..7f970ad 100644
--- a/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/WorkspaceServiceImpl.java
+++ b/java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/WorkspaceServiceImpl.java
@@ -78,6 +78,7 @@ import org.netbeans.api.project.ui.OpenProjects;
 import org.netbeans.modules.gsf.testrunner.ui.api.TestMethodController;
 import org.netbeans.modules.java.lsp.server.LspServerState;
 import org.netbeans.modules.java.lsp.server.Utils;
+import org.netbeans.modules.java.lsp.server.debugging.attach.AttachConfigurations;
 import org.netbeans.modules.java.source.ui.JavaSymbolProvider;
 import org.netbeans.modules.java.source.ui.JavaTypeProvider;
 import org.netbeans.modules.java.source.usages.ClassIndexImpl;
@@ -219,7 +220,7 @@ public final class WorkspaceServiceImpl implements WorkspaceService, LanguageCli
                 Position pos = gson.fromJson(gson.toJson(params.getArguments().get(1)), Position.class);
                 return (CompletableFuture)((TextDocumentServiceImpl)server.getTextDocumentService()).superImplementations(uri, pos);
                 
-            case Server.JAVA_FIND_CONFIGURATIONS: {
+            case Server.JAVA_FIND_PROJECT_CONFIGURATIONS: {
                 String fileUri = ((JsonPrimitive) params.getArguments().get(0)).getAsString();
                 
                 FileObject file;
@@ -232,6 +233,12 @@ public final class WorkspaceServiceImpl implements WorkspaceService, LanguageCli
 
                 return findProjectConfigurations(file);
             }
+            case Server.JAVA_FIND_DEBUG_ATTACH_CONFIGURATIONS: {
+                return AttachConfigurations.findConnectors();
+            }
+            case Server.JAVA_FIND_DEBUG_PROCESS_TO_ATTACH: {
+                return AttachConfigurations.findProcessAttachTo(client);
+            }
             default:
                 for (CodeGenerator codeGenerator : Lookup.getDefault().lookupAll(CodeGenerator.class)) {
                     if (codeGenerator.getCommands().contains(command)) {
@@ -249,8 +256,10 @@ public final class WorkspaceServiceImpl implements WorkspaceService, LanguageCli
             }
             ProjectConfigurationProvider<ProjectConfiguration> provider = p.getLookup().lookup(ProjectConfigurationProvider.class);
             List<String> configDispNames = new ArrayList<>();
-            for (ProjectConfiguration c : provider.getConfigurations()) {
-                configDispNames.add(c.getDisplayName());
+            if (provider != null) {
+                for (ProjectConfiguration c : provider.getConfigurations()) {
+                    configDispNames.add(c.getDisplayName());
+                }
             }
             return configDispNames;
         });
diff --git a/java/java.lsp.server/test/unit/src/org/netbeans/modules/java/lsp/server/protocol/ServerTest.java b/java/java.lsp.server/test/unit/src/org/netbeans/modules/java/lsp/server/protocol/ServerTest.java
index 075782b..51a4bcd 100644
--- a/java/java.lsp.server/test/unit/src/org/netbeans/modules/java/lsp/server/protocol/ServerTest.java
+++ b/java/java.lsp.server/test/unit/src/org/netbeans/modules/java/lsp/server/protocol/ServerTest.java
@@ -1076,6 +1076,48 @@ public class ServerTest extends NbTestCase {
         assertEquals(13, loc.getRange().getEnd().getCharacter());
     }
 
+    public void testFindDebugAttachConfigurations() throws Exception {
+        Launcher<LanguageServer> serverLauncher = LSPLauncher.createClientLauncher(new LspClient() {
+        }, client.getInputStream(), client.getOutputStream());
+        serverLauncher.startListening();
+        LanguageServer server = serverLauncher.getRemoteProxy();
+        server.initialize(new InitializeParams()).get();
+        Object ret = server.getWorkspaceService().executeCommand(new ExecuteCommandParams(Server.JAVA_FIND_DEBUG_ATTACH_CONFIGURATIONS, Collections.emptyList())).get();
+        assertNotNull(ret);
+        DebugConnector[] connectors = gson.fromJson(gson.toJsonTree(ret).getAsJsonArray(), DebugConnector[].class);
+        assertTrue(connectors.length > 0);
+        boolean haveAttachToPort = false;
+        boolean haveAttachToProcess = false;
+        for (DebugConnector c : connectors) {
+            if ("Attach to Port".equals(c.getName())) {
+                haveAttachToPort = true;
+                checkAttachToPort(c);
+            }
+            if ("Attach to Process".equals(c.getName())) {
+                haveAttachToProcess = true;
+                checkAttachToProcess(c);
+            }
+        }
+        assertTrue(Arrays.toString(connectors), haveAttachToPort && haveAttachToProcess);
+    }
+
+    private void checkAttachToPort(DebugConnector c) {
+        assertEquals("java8+", c.getType());
+        List<String> arguments = c.getArguments();
+        assertEquals(2, arguments.size());
+        assertEquals("hostName", arguments.get(0));
+        assertEquals("port", arguments.get(1));
+        assertEquals(2, c.getDefaultValues().size());
+    }
+
+    private void checkAttachToProcess(DebugConnector c) {
+        assertEquals("java8+", c.getType());
+        List<String> arguments = c.getArguments();
+        assertEquals(1, arguments.size());
+        assertEquals("processId", arguments.get(0));
+        assertEquals(1, c.getDefaultValues().size());
+    }
+
     public void testOpenProjectOpenJDK() throws Exception {
         getWorkDir().mkdirs();
 
diff --git a/java/java.lsp.server/vscode/package.json b/java/java.lsp.server/vscode/package.json
index 8e871d6..dbf3a5f 100644
--- a/java/java.lsp.server/vscode/package.json
+++ b/java/java.lsp.server/vscode/package.json
@@ -28,7 +28,8 @@
 		"workspaceContains:**/*.java",
 		"workspaceContains:pom.xml",
 		"workspaceContains:build.gradle",
-		"onDebug"
+		"onDebug",
+		"onDebugDynamicConfigurations"
 	],
 	"main": "./out/extension.js",
 	"contributes": {
@@ -125,7 +126,7 @@
 								"description": "Arguments for the Java VM",
 								"default": null
 							},
-							"launchConfiguration" : {
+							"launchConfiguration": {
 								"type": [
 									"string",
 									"null"
@@ -133,6 +134,34 @@
 								"description": "Mode and default behaviour for launch"
 							}
 						}
+					},
+					"attach": {
+						"properties": {
+							"hostName": {
+								"type": "string",
+								"default": "localhost",
+								"description": "Host name or IP address to which to attach"
+							},
+							"port": {
+								"type": "string",
+								"default": "8000",
+								"description": "Port number to which to attach"
+							},
+							"sharedMemoryName": {
+								"type": "string",
+								"description": "Shared memory name of the debuggee"
+							},
+							"processId": {
+								"type": "string",
+								"default": "${command:java.attachDebugger.pickProcess}",
+								"description": "Process Id of the debuggee"
+							},
+							"timeout": {
+								"type": "string",
+								"default": "30000",
+								"description": "Timeout while waiting to attach"
+							}
+						}
 					}
 				},
 				"initialConfigurations": [
@@ -297,16 +326,16 @@
 		"nbjavac": "node ./out/nbcode.js -J-Dnetbeans.close=true --modules --install .*nbjavac.*"
 	},
 	"devDependencies": {
-		"@types/vscode": "^1.49.0",
 		"@types/glob": "^7.1.1",
 		"@types/mocha": "^7.0.2",
 		"@types/node": "^13.11.0",
 		"@types/ps-node": "^0.1.0",
+		"@types/vscode": "^1.49.0",
 		"glob": "^7.1.6",
 		"mocha": "^7.1.2",
+		"ps-node": "^0.1.6",
 		"typescript": "^3.8.3",
-		"vscode-test": "^1.3.0",
-		"ps-node": "^0.1.6"
+		"vscode-test": "^1.3.0"
 	},
 	"dependencies": {
 		"vscode-debugadapter": "1.42.1",
diff --git a/java/java.lsp.server/vscode/src/extension.ts b/java/java.lsp.server/vscode/src/extension.ts
index ada41c6..7027ff6 100644
--- a/java/java.lsp.server/vscode/src/extension.ts
+++ b/java/java.lsp.server/vscode/src/extension.ts
@@ -41,7 +41,7 @@ import { testExplorerExtensionId, TestHub } from 'vscode-test-adapter-api';
 import { TestAdapterRegistrar } from 'vscode-test-adapter-util';
 import * as launcher from './nbcode';
 import {NbTestAdapter} from './testAdapter';
-import { StatusMessageRequest, ShowStatusMessageParams, QuickPickRequest, InputBoxRequest, TestProgressNotification } from './protocol';
+import { StatusMessageRequest, ShowStatusMessageParams, QuickPickRequest, InputBoxRequest, TestProgressNotification, DebugConnector } from './protocol';
 
 const API_VERSION : string = "1.0";
 let client: Promise<LanguageClient>;
@@ -173,7 +173,7 @@ export function activate(context: ExtensionContext): VSNetBeansAPI {
 
     //register debugger:
     let configProvider = new NetBeansConfigurationProvider();
-    context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider('java8+', configProvider));
+    context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider('java8+', configProvider, vscode.DebugConfigurationProviderTriggerKind.Dynamic));
     let configNativeProvider = new NetBeansConfigurationNativeProvider();
     context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider('nativeimage', configNativeProvider));
 
@@ -672,30 +672,43 @@ class NetBeansConfigurationProvider implements vscode.DebugConfigurationProvider
         } else {
             u = vscode.window.activeTextEditor?.document?.uri
         }
+        let result : vscode.DebugConfiguration[] = [];
         const configNames : string[] | null | undefined = await vscode.commands.executeCommand('java.project.configurations', u?.toString());
-        if (!configNames) {
-            return [];
+        if (configNames) {
+            let first : boolean = true;
+            for (let cn of configNames) {
+                let cname : string;
+
+                if (first) {
+                    // ignore the default config, comes first.
+                    first = false;
+                    continue;
+                } else {
+                    cname = "Launch Java: " + cn;
+                }
+                const debugConfig : vscode.DebugConfiguration = {
+                    name: cname,
+                    type: "java8+",
+                    request: "launch",
+                    mainClass: '${file}',
+                    launchConfiguration: cn,
+                };
+                result.push(debugConfig);
+            }
         }
-        let result : vscode.DebugConfiguration[] = [];
-        let first : boolean = true;
-        for (let cn of configNames) {
-            let cname : string;
-
-            if (first) {
-                // ignore the default config, comes first.
-                first = false;
-                continue;
-            } else {
-                cname = "Launch Java: " + cn;
+        const attachConnectors : DebugConnector[] | null | undefined = await vscode.commands.executeCommand('java.attachDebugger.configurations');
+        if (attachConnectors) {
+            for (let ac of attachConnectors) {
+                const debugConfig : vscode.DebugConfiguration = {
+                    name: ac.name,
+                    type: ac.type,
+                    request: "attach",
+                };
+                for (let i = 0; i < ac.arguments.length; i++) {
+                    debugConfig[ac.arguments[i]] = ac.defaultValues[i];
+                }
+                result.push(debugConfig)
             }
-            const debugConfig : vscode.DebugConfiguration = {
-                name: cname,
-                type: "java8+",
-                request: "launch",
-                mainClass: '${file}',
-                launchConfiguration: cn,
-            };
-            result.push(debugConfig);
         }
         return result;
     }
@@ -707,7 +720,7 @@ class NetBeansConfigurationProvider implements vscode.DebugConfigurationProvider
         if (!config.request) {
             config.request = 'launch';
         }
-        if (!config.mainClass) {
+        if ('launch' == config.request && !config.mainClass) {
             config.mainClass = '${file}';
         }
         if (!config.classPaths) {
diff --git a/java/java.lsp.server/vscode/src/protocol.ts b/java/java.lsp.server/vscode/src/protocol.ts
index 8a4d08f..5b48c2e 100644
--- a/java/java.lsp.server/vscode/src/protocol.ts
+++ b/java/java.lsp.server/vscode/src/protocol.ts
@@ -96,3 +96,10 @@ export interface TestCase {
 export namespace TestProgressNotification {
     export const type = new NotificationType<TestProgressParams, void>('window/notifyTestProgress');
 };
+
+export interface DebugConnector {
+    name: string;
+    type: string;
+    arguments: string[];
+    defaultValues: string[];
+}

---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@netbeans.apache.org
For additional commands, e-mail: commits-help@netbeans.apache.org

For further information about the NetBeans mailing lists, visit:
https://cwiki.apache.org/confluence/display/NETBEANS/Mailing+lists