Java Launcher.startListening方法代码示例

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
/**
 * 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();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
@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());
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
@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);
  }
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
/**
 * 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")));
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
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();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
@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();
	}
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
@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());
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
@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();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
@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();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
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();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
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();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
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();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
@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();
	}
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入方法依赖的package包/类
@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();
	}
}