Java 类org.eclipse.lsp4j.jsonrpc.Launcher 实例源码

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();
}

@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();
}

@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();
  setYamlLanguageServer(launcher.getRemoteProxy());
  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();
  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<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();
    }
}