package org.eclipse.jdt.internal.launching;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.jdi.Bootstrap;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.jdt.launching.IVMConnector;
import org.eclipse.osgi.util.NLS;
import com.sun.jdi.connect.Connector;
import com.sun.jdi.connect.IllegalConnectorArgumentsException;
import com.sun.jdi.connect.ListeningConnector;
public class SocketListenConnector implements IVMConnector {
protected static ListeningConnector getListeningConnector() throws CoreException {
ListeningConnector connector= null;
Iterator<ListeningConnector> iter= Bootstrap.virtualMachineManager().listeningConnectors().iterator();
while (iter.hasNext()) {
ListeningConnector lc= iter.next();
if (lc.name().equals("com.sun.jdi.SocketListen")) {
connector= lc;
break;
}
}
if (connector == null) {
abort(LaunchingMessages.SocketListenConnector_0, null, IJavaLaunchConfigurationConstants.ERR_SHARED_MEMORY_CONNECTOR_UNAVAILABLE);
}
return connector;
}
@Override
public String getIdentifier() {
return IJavaLaunchConfigurationConstants.ID_SOCKET_LISTEN_VM_CONNECTOR;
}
@Override
public String getName() {
return LaunchingMessages.SocketListenConnector_1;
}
@Override
public void connect(Map<String, String> arguments, IProgressMonitor monitor, ILaunch launch) throws CoreException {
if (monitor == null) {
monitor = new NullProgressMonitor();
}
monitor.subTask(LaunchingMessages.SocketListenConnector_2);
ListeningConnector connector= getListeningConnector();
String portNumberString = arguments.get("port");
if (portNumberString == null) {
abort(LaunchingMessages.SocketAttachConnector_Port_unspecified_for_remote_connection__2, null, IJavaLaunchConfigurationConstants.ERR_UNSPECIFIED_PORT);
}
Map<String, Connector.Argument> acceptArguments = connector.defaultArguments();
Connector.Argument param= acceptArguments.get("port");
param.setValue(portNumberString);
int connectionLimit = 1;
if (arguments.containsKey("connectionLimit")) {
connectionLimit = Integer.valueOf(arguments.get("connectionLimit"));
}
try {
monitor.subTask(NLS.bind(LaunchingMessages.SocketListenConnector_3, new String[]{portNumberString}));
connector.startListening(acceptArguments);
SocketListenConnectorProcess process = new SocketListenConnectorProcess(launch, portNumberString, connectionLimit);
process.waitForConnection(connector, acceptArguments);
} catch (IOException e) {
abort(LaunchingMessages.SocketListenConnector_4, e, IJavaLaunchConfigurationConstants.ERR_REMOTE_VM_CONNECTION_FAILED);
} catch (IllegalConnectorArgumentsException e) {
abort(LaunchingMessages.SocketListenConnector_4, e, IJavaLaunchConfigurationConstants.ERR_REMOTE_VM_CONNECTION_FAILED);
}
}
@Override
public Map<String, Connector.Argument> getDefaultArguments() throws CoreException {
Map<String, Connector.Argument> def = getListeningConnector().defaultArguments();
Connector.IntegerArgument arg = (Connector.IntegerArgument)def.get("port");
arg.setValue(8000);
return def;
}
@Override
public List<String> getArgumentOrder() {
List<String> list = new ArrayList<>(1);
list.add("port");
list.add("connectionLimit");
return list;
}
protected static void abort(String message, Throwable exception, int code) throws CoreException {
throw new CoreException(new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(), code, message, exception));
}
}