public static void main(final String[] args) { try { ServerModule _serverModule = new ServerModule(); final Injector injector = Guice.createInjector(_serverModule); final LanguageServer languageServer = injector.<LanguageServer>getInstance(LanguageServer.class); final ServerSocketChannel serverSocket = ServerSocketChannel.open(); InetSocketAddress _inetSocketAddress = new InetSocketAddress("localhost", 5007); serverSocket.bind(_inetSocketAddress); final SocketChannel socketChannel = serverSocket.accept(); InputStream _newInputStream = Channels.newInputStream(socketChannel); OutputStream _newOutputStream = Channels.newOutputStream(socketChannel); PrintWriter _printWriter = new PrintWriter(System.out); final Launcher<LanguageClient> launcher = LSPLauncher.createServerLauncher(languageServer, _newInputStream, _newOutputStream, true, _printWriter); launcher.startListening().get(); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } }
/** * creates a proxy, delegating to a remote endpoint, forwarding to another remote endpoint, that delegates to an actual implementation. * @param intf * @param impl * @return * @throws IOException */ public <T> T wrap(Class<T> intf, T impl) { PipedInputStream in1 = new PipedInputStream(); PipedOutputStream out1 = new PipedOutputStream(); Launcher<T> launcher1 = Launcher.createLauncher(impl, intf, in1, out1); PipedInputStream in2 = new PipedInputStream(); PipedOutputStream out2 = new PipedOutputStream(); Launcher<T> launcher2 = Launcher.createLauncher(new Object(), intf, in2, out2); try { in1.connect(out2); in2.connect(out1); } catch (IOException e) { throw new IllegalStateException(e); } launcher1.startListening(); launcher2.startListening(); return launcher2.getRemoteProxy(); }
@Test public void testCanceled() throws Exception { A a = new A() { @Override public void say(Param p) { } }; Launcher<A> launcher = Launcher.createLauncher(a, A.class, new InputStream() { @Override public int read() throws IOException { try { Thread.sleep(100); } catch (InterruptedException e) { throw new RuntimeException(e); } return '\n'; } }, new ByteArrayOutputStream()); Future<?> startListening = launcher.startListening(); startListening.cancel(true); Assert.assertTrue(startListening.isDone()); Assert.assertTrue(startListening.isCancelled()); }
@Override public LanguageServer launch(String projectPath, LanguageClient client) throws LanguageServerException { try { Socket socket = new Socket(host, port); socket.setKeepAlive(true); InputStream inputStream = socket.getInputStream(); OutputStream outputStream = socket.getOutputStream(); Launcher<LanguageServer> launcher = Launcher.createLauncher(client, LanguageServer.class, inputStream, outputStream); launcher.startListening(); return launcher.getRemoteProxy(); } catch (IOException e) { throw new LanguageServerException( "Can't launch language server for project: " + projectPath, e); } }
/** * Listen for requests from the parent node process. Send replies asynchronously. When the * request stream is closed, wait for 5s for all outstanding responses to compute, then return. */ public static void run(Socket connection) throws IOException { JavaLanguageServer server = new JavaLanguageServer(); Launcher<LanguageClient> launcher = LSPLauncher.createServerLauncher( server, connection.getInputStream(), connection.getOutputStream()); server.installClient(launcher.getRemoteProxy()); launcher.startListening(); LOG.info(String.format("java.version is %s", System.getProperty("java.version"))); }
static <T> Launcher<T> createSocketLauncher(Object localService, Class<T> remoteInterface, SocketAddress socketAddress, ExecutorService executorService, Function<MessageConsumer, MessageConsumer> wrapper) throws IOException { AsynchronousServerSocketChannel serverSocket = AsynchronousServerSocketChannel.open().bind(socketAddress); AsynchronousSocketChannel socketChannel; try { socketChannel = serverSocket.accept().get(); return Launcher.createIoLauncher(localService, remoteInterface, Channels.newInputStream(socketChannel), Channels.newOutputStream(socketChannel), executorService, wrapper); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } return null; }
static <T> Launcher<T> createSocketLauncher(Object localService, Class<T> remoteInterface, SocketAddress socketAddress, ExecutorService executorService, Function<MessageConsumer, MessageConsumer> wrapper, InputStream inputStream, OutputStream outputStream) throws IOException { return Launcher.createIoLauncher(localService, remoteInterface, inputStream, outputStream, executorService, wrapper); }
private void startConnection() throws IOException { protocol = new JDTLanguageServer(projectsManager, preferenceManager); ConnectionStreamFactory connectionFactory = new ConnectionStreamFactory(); Launcher<JavaLanguageClient> launcher = Launcher.createLauncher(protocol, JavaLanguageClient.class, connectionFactory.getInputStream(), connectionFactory.getOutputStream(), Executors.newCachedThreadPool(), new ParentProcessWatcher(this.languageServer)); protocol.connectClient(launcher.getRemoteProxy()); launcher.startListening(); }
@Test public void testUnexpectedParams() throws Exception { // intercept log messages LogMessageAccumulator logMessages = new LogMessageAccumulator(); try { logMessages.registerTo(GenericEndpoint.class); // create client messages String notificationMessage = "{\"jsonrpc\":\"2.0\"," + "\"method\":\"myNotification\",\n" + "\"params\": { \"value\": \"foo\" }\n" + "}"; String clientMessages = getHeader(notificationMessage.getBytes().length) + notificationMessage; // create server side ByteArrayInputStream in = new ByteArrayInputStream(clientMessages.getBytes()); ByteArrayOutputStream out = new ByteArrayOutputStream(); UnexpectedParamsTestServer server = new UnexpectedParamsTestServer() { public void myNotification() { } }; Launcher<MyClient> serverSideLauncher = Launcher.createLauncher(server, MyClient.class, in, out); serverSideLauncher.startListening(); logMessages.await(Level.WARNING, "Unexpected params '{\"value\":\"foo\"}' for " + "'public abstract void org.eclipse.lsp4j.jsonrpc.test.IntegrationTest$UnexpectedParamsTestServer.myNotification()' is ignored"); } finally { logMessages.unregister(); } }
@Test public void testDone() throws Exception { A a = new A() { @Override public void say(Param p) { } }; Launcher<A> launcher = Launcher.createLauncher(a, A.class, new ByteArrayInputStream("".getBytes()), new ByteArrayOutputStream()); Future<?> startListening = launcher.startListening(); startListening.get(TIMEOUT, TimeUnit.MILLISECONDS); Assert.assertTrue(startListening.isDone()); Assert.assertFalse(startListening.isCancelled()); }
@Override protected LanguageServer connectToLanguageServer( Process languageServerProcess, LanguageClient client) throws LanguageServerException { Launcher<LanguageServer> launcher = Launcher.createLauncher( client, LanguageServer.class, languageServerProcess.getInputStream(), languageServerProcess.getOutputStream()); launcher.startListening(); return launcher.getRemoteProxy(); }
@Override protected LanguageServer connectToLanguageServer( final Process languageServerProcess, LanguageClient client) { Launcher<LanguageServer> launcher = Launcher.createLauncher( client, LanguageServer.class, languageServerProcess.getInputStream(), languageServerProcess.getOutputStream()); launcher.startListening(); return launcher.getRemoteProxy(); }
protected LanguageServer connectToLanguageServer( final Process languageServerProcess, LanguageClient client) { Launcher<LanguageServer> launcher = Launcher.createLauncher( client, LanguageServer.class, languageServerProcess.getInputStream(), languageServerProcess.getOutputStream()); launcher.startListening(); return launcher.getRemoteProxy(); }
protected LanguageServer connectToLanguageServer( final Process languageServerProcess, LanguageClient client) { Launcher<LanguageServer> launcher = Launcher.createLauncher( client, LanguageServer.class, languageServerProcess.getInputStream(), languageServerProcess.getOutputStream()); launcher.startListening(); setYamlLanguageServer(launcher.getRemoteProxy()); return launcher.getRemoteProxy(); }
public static void main(String[] args) { CamelLanguageServer server = new CamelLanguageServer(); Launcher<LanguageClient> launcher = Launcher.createLauncher(server, LanguageClient.class, System.in, System.out); server.connect(launcher.getRemoteProxy()); launcher.startListening(); }
public static Launcher<LanguageClient> createServerLauncher(LanguageServer server, InputStream in, OutputStream out) { return Launcher.createLauncher(server, LanguageClient.class, in, out); }
public static Launcher<LanguageClient> createServerLauncher(LanguageServer server, InputStream in, OutputStream out, boolean validate, PrintWriter trace) { return Launcher.createLauncher(server, LanguageClient.class, in, out, validate, trace); }
public static Launcher<LanguageClient> createServerLauncher(LanguageServer server, InputStream in, OutputStream out, ExecutorService executorService, Function<MessageConsumer, MessageConsumer> wrapper) { return Launcher.createLauncher(server, LanguageClient.class, in, out, executorService, wrapper); }
public static Launcher<LanguageServer> createClientLauncher(LanguageClient client, InputStream in, OutputStream out) { return Launcher.createLauncher(client, LanguageServer.class, in, out); }
public static Launcher<LanguageServer> createClientLauncher(LanguageClient client, InputStream in, OutputStream out, boolean validate, PrintWriter trace) { return Launcher.createLauncher(client, LanguageServer.class, in, out, validate, trace); }
public static Launcher<LanguageServer> createClientLauncher(LanguageClient client, InputStream in, OutputStream out, ExecutorService executorService, Function<MessageConsumer, MessageConsumer> wrapper) { return Launcher.createLauncher(client, LanguageServer.class, in, out, executorService, wrapper); }
public static Launcher<IDebugProtocolClient> createServerLauncher(IDebugProtocolServer server, InputStream in, OutputStream out) { return DebugLauncher.createLauncher(server, IDebugProtocolClient.class, in, out); }
public static Launcher<IDebugProtocolClient> createServerLauncher(IDebugProtocolServer server, InputStream in, OutputStream out, boolean validate, PrintWriter trace) { return DebugLauncher.createLauncher(server, IDebugProtocolClient.class, in, out, validate, trace); }
public static Launcher<IDebugProtocolClient> createServerLauncher(IDebugProtocolServer server, InputStream in, OutputStream out, ExecutorService executorService, Function<MessageConsumer, MessageConsumer> wrapper) { return DebugLauncher.createLauncher(server, IDebugProtocolClient.class, in, out, executorService, wrapper); }
public static Launcher<IDebugProtocolServer> createClientLauncher(IDebugProtocolClient client, InputStream in, OutputStream out) { return DebugLauncher.createLauncher(client, IDebugProtocolServer.class, in, out); }
public static Launcher<IDebugProtocolServer> createClientLauncher(IDebugProtocolClient client, InputStream in, OutputStream out, boolean validate, PrintWriter trace) { return DebugLauncher.createLauncher(client, IDebugProtocolServer.class, in, out, validate, trace); }
public static Launcher<IDebugProtocolServer> createClientLauncher(IDebugProtocolClient client, InputStream in, OutputStream out, ExecutorService executorService, Function<MessageConsumer, MessageConsumer> wrapper) { return DebugLauncher.createLauncher(client, IDebugProtocolServer.class, in, out, executorService, wrapper); }
@Test public void testCancellationResponse() throws Exception { // create client messages String requestMessage = "{\"jsonrpc\":\"2.0\"," + "\"id\":\"1\",\n" + "\"method\":\"askServer\",\n" + "\"params\": { value: \"bar\" }\n" + "}"; String cancellationMessage = "{\"jsonrpc\":\"2.0\"," + "\"method\":\"$/cancelRequest\",\n" + "\"params\": { id: 1 }\n" + "}"; String clientMessages = getHeader(requestMessage.getBytes().length) + requestMessage + getHeader(cancellationMessage.getBytes().length) + cancellationMessage; // create server side ByteArrayInputStream in = new ByteArrayInputStream(clientMessages.getBytes()); ByteArrayOutputStream out = new ByteArrayOutputStream(); MyServer server = new MyServer() { @Override public CompletableFuture<MyParam> askServer(MyParam param) { return CompletableFutures.computeAsync(cancelToken -> { try { long startTime = System.currentTimeMillis(); do { cancelToken.checkCanceled(); Thread.sleep(50); } while (System.currentTimeMillis() - startTime < TIMEOUT); } catch (InterruptedException e) { Assert.fail("Thread was interrupted unexpectedly."); } return param; }); } }; Launcher<MyClient> serverSideLauncher = Launcher.createLauncher(server, MyClient.class, in, out); serverSideLauncher.startListening().get(TIMEOUT, TimeUnit.MILLISECONDS); Assert.assertEquals("Content-Length: 132" + CRLF + CRLF + "{\"jsonrpc\":\"2.0\",\"id\":\"1\",\"error\":{\"code\":-32800,\"message\":\"The request (id: 1, method: \\u0027askServer\\u0027) has been cancelled\"}}", out.toString()); }
@Test public void testUnknownMessages() throws Exception { // intercept log messages LogMessageAccumulator logMessages = new LogMessageAccumulator(); try { logMessages.registerTo(GenericEndpoint.class); // create client messages String clientMessage1 = "{\"jsonrpc\":\"2.0\"," + "\"method\":\"foo1\",\n" + " \"params\":\"bar\"\n" + "}"; String clientMessage2 = "{\"jsonrpc\":\"2.0\"," + "\"id\":\"1\",\n" + "\"method\":\"foo2\",\n" + " \"params\":\"bar\"\n" + "}"; String clientMessages = getHeader(clientMessage1.getBytes().length) + clientMessage1 + getHeader(clientMessage2.getBytes().length) + clientMessage2; // create server side ByteArrayInputStream in = new ByteArrayInputStream(clientMessages.getBytes()); ByteArrayOutputStream out = new ByteArrayOutputStream(); MyServer server = new MyServer() { @Override public CompletableFuture<MyParam> askServer(MyParam param) { return CompletableFuture.completedFuture(param); } }; Launcher<MyClient> serverSideLauncher = Launcher.createLauncher(server, MyClient.class, in, out); serverSideLauncher.startListening(); logMessages.await(Level.WARNING, "Unsupported notification method: foo1"); logMessages.await(Level.WARNING, "Unsupported request method: foo2"); Assert.assertEquals("Content-Length: 95" + CRLF + CRLF + "{\"jsonrpc\":\"2.0\",\"id\":\"1\",\"error\":{\"code\":-32601,\"message\":\"Unsupported request method: foo2\"}}", out.toString()); } finally { logMessages.unregister(); } }
@Test public void testUnknownOptionalMessages() throws Exception { // intercept log messages LogMessageAccumulator logMessages = new LogMessageAccumulator(); try { logMessages.registerTo(GenericEndpoint.class); // create client messages String clientMessage1 = "{\"jsonrpc\":\"2.0\"," + "\"method\":\"$/foo1\",\n" + " \"params\":\"bar\"\n" + "}"; String clientMessage2 = "{\"jsonrpc\":\"2.0\"," + "\"id\":\"1\",\n" + "\"method\":\"$/foo2\",\n" + " \"params\":\"bar\"\n" + "}"; String clientMessages = getHeader(clientMessage1.getBytes().length) + clientMessage1 + getHeader(clientMessage2.getBytes().length) + clientMessage2; // create server side ByteArrayInputStream in = new ByteArrayInputStream(clientMessages.getBytes()); ByteArrayOutputStream out = new ByteArrayOutputStream(); MyServer server = new MyServer() { @Override public CompletableFuture<MyParam> askServer(MyParam param) { return CompletableFuture.completedFuture(param); } }; Launcher<MyClient> serverSideLauncher = Launcher.createLauncher(server, MyClient.class, in, out); serverSideLauncher.startListening(); logMessages.await(Level.INFO, "Unsupported notification method: $/foo1"); logMessages.await(Level.INFO, "Unsupported request method: $/foo2"); Assert.assertEquals("Content-Length: 40" + CRLF + CRLF + "{\"jsonrpc\":\"2.0\",\"id\":\"1\",\"result\":null}", out.toString()); } finally { logMessages.unregister(); } }