@Override public CompletableFuture<?> request(String method, Object parameter) { Function<Object, CompletableFuture<Object>> handler = methodHandlers.get(method); if (handler != null) { return handler.apply(parameter); } if (delegate instanceof Endpoint) { return ((Endpoint) delegate).request(method, parameter); } String message = "Unsupported request method: " + method; if (isOptionalMethod(method)) { LOG.log(Level.INFO, message); return CompletableFuture.completedFuture(null); } LOG.log(Level.WARNING, message); CompletableFuture<?> exceptionalResult = new CompletableFuture<Object>(); ResponseError error = new ResponseError(ResponseErrorCode.MethodNotFound, message, null); exceptionalResult.completeExceptionally(new ResponseErrorException(error)); return exceptionalResult; }
@Override public void notify(String method, Object parameter) { Function<Object, CompletableFuture<Object>> handler = methodHandlers.get(method); if (handler != null) { handler.apply(parameter); return; } if (delegate instanceof Endpoint) { ((Endpoint) delegate).notify(method, parameter); return; } String message = "Unsupported notification method: " + method; if (isOptionalMethod(method)) { LOG.log(Level.INFO, message); } else { LOG.log(Level.WARNING, message); } }
@Override public void notify(final String method, final Object parameter) { Collection<Endpoint> _get = this.extensionProviders.get(method); for (final Endpoint endpoint : _get) { try { endpoint.notify(method, parameter); } catch (final Throwable _t) { if (_t instanceof UnsupportedOperationException) { final UnsupportedOperationException e = (UnsupportedOperationException)_t; if ((e != ILanguageServerExtension.NOT_HANDLED_EXCEPTION)) { throw e; } } else { throw Exceptions.sneakyThrow(_t); } } } }
@Override public CompletableFuture<?> request(final String method, final Object parameter) { boolean _containsKey = this.extensionProviders.containsKey(method); boolean _not = (!_containsKey); if (_not) { throw new UnsupportedOperationException((("The json request \'" + method) + "\' is unknown.")); } Collection<Endpoint> _get = this.extensionProviders.get(method); for (final Endpoint endpoint : _get) { try { return endpoint.request(method, parameter); } catch (final Throwable _t) { if (_t instanceof UnsupportedOperationException) { final UnsupportedOperationException e = (UnsupportedOperationException)_t; if ((e != ILanguageServerExtension.NOT_HANDLED_EXCEPTION)) { throw e; } } else { throw Exceptions.sneakyThrow(_t); } } } return null; }
@Test public void testNullResponse() throws InterruptedException, ExecutionException { Endpoint endpoint = ServiceEndpoints.toEndpoint(this); Map<String, JsonRpcMethod> methods = ServiceEndpoints.getSupportedMethods(LanguageServer.class); MessageJsonHandler handler = new MessageJsonHandler(methods); List<Message> msgs = new ArrayList<>(); MessageConsumer consumer = (message) -> { msgs.add(message); }; RemoteEndpoint re = new RemoteEndpoint(consumer, endpoint); RequestMessage request = new RequestMessage(); request.setId("1"); request.setMethod("shutdown"); re.consume(request); Assert.assertEquals("{\"jsonrpc\":\"2.0\",\"id\":\"1\",\"result\":null}", handler.serialize(msgs.get(0))); msgs.clear(); shutdownReturn = new Object(); re.consume(request); Assert.assertEquals("{\"jsonrpc\":\"2.0\",\"id\":\"1\",\"result\":{}}", handler.serialize(msgs.get(0))); }
@Override public void onServerInitialized( LanguageServerLauncher launcher, LanguageServer server, ServerCapabilities capabilities, String projectPath) { try { Map<String, String> preferences = requestFactory.fromUrl(apiUrl + "/preferences").useGetMethod().request().asProperties(); Endpoint endpoint = ServiceEndpoints.toEndpoint(server); YamlSchemaAssociations serviceObject = ServiceEndpoints.toServiceObject(endpoint, YamlSchemaAssociations.class); Map<String, String[]> associations = jsonToSchemaAssociations(preferences.get("yaml.preferences")); serviceObject.yamlSchemaAssociation(associations); } catch (ApiException | IOException e) { LOG.error(e.getLocalizedMessage(), e); } }
/** * Route for getting getting schemas from client side and injecting them into yaml language server * * @param yamlDto A yamlDTO containing the list of schemas you would like to add */ @POST @Path("schemas") @Consumes(MediaType.APPLICATION_JSON) public void putSchemas(YamlDTO yamlDto) throws ApiException { LanguageServer yamlLS = YamlLanguageServerLauncher.getYamlLanguageServer(); if (yamlDto != null && yamlLS != null) { Endpoint endpoint = ServiceEndpoints.toEndpoint(yamlLS); YamlSchemaAssociations serviceObject = ServiceEndpoints.toServiceObject(endpoint, YamlSchemaAssociations.class); Map<String, String[]> schemaAssociations = new HashMap<>(); Map<String, String> yamlDtoSchemas = yamlDto.getSchemas(); for (Map.Entry<String, String> schema : yamlDtoSchemas.entrySet()) { schemaAssociations.put( schema.getKey(), new Gson().fromJson(schema.getValue(), String[].class)); } serviceObject.yamlSchemaAssociation(schemaAssociations); } }
@Override public void onServerInitialized( LanguageServerLauncher launcher, LanguageServer server, ServerCapabilities capabilities, String projectPath) { Endpoint endpoint = ServiceEndpoints.toEndpoint(server); JsonExtension serviceObject = ServiceEndpoints.toServiceObject(endpoint, JsonExtension.class); Map<String, String[]> associations = new HashMap<>(); associations.put("/*.schema.json", new String[] {"http://json-schema.org/draft-04/schema#"}); associations.put("/bower.json", new String[] {"http://json.schemastore.org/bower"}); associations.put("/.bower.json", new String[] {"http://json.schemastore.org/bower"}); associations.put("/.bowerrc", new String[] {"http://json.schemastore.org/bowerrc"}); associations.put("/composer.json", new String[] {"https://getcomposer.org/schema.json"}); associations.put("/package.json", new String[] {"http://json.schemastore.org/package"}); associations.put("/jsconfig.json", new String[] {"http://json.schemastore.org/jsconfig"}); associations.put("/tsconfig.json", new String[] {"http://json.schemastore.org/tsconfig"}); serviceObject.jsonSchemaAssociation(associations); }
public EndpointProxy(Endpoint delegate, Class<?> interf) { if (delegate == null) throw new NullPointerException("delegate"); if (interf == null) throw new NullPointerException("interf"); this.delegate = delegate; try { object_equals = Object.class.getDeclaredMethod("equals", Object.class); object_hashCode = Object.class.getDeclaredMethod("hashCode"); object_toString = Object.class.getDeclaredMethod("toString"); } catch (NoSuchMethodException | SecurityException exception) { throw new RuntimeException(exception); } methodInfos = new LinkedHashMap<>(); AnnotationUtil.findRpcMethods(interf, new HashSet<Class<?>>(), (methodInfo) -> { if (methodInfos.put(methodInfo.method.getName(), methodInfo) != null) { throw new IllegalStateException("Method overload not allowed : " + methodInfo.method); } }); delegatedSegments = new LinkedHashMap<>(); AnnotationUtil.findDelegateSegments(interf, new HashSet<Class<?>>(), (method) -> { Object delegateProxy = ServiceEndpoints.toServiceObject(delegate, method.getReturnType()); DelegateInfo info = new DelegateInfo(); info.delegate = delegateProxy; info.method = method; if (delegatedSegments.put(method.getName(), info) != null) { throw new IllegalStateException("Method overload not allowed : " + method); } }); }
@Override public void initialize(final ILanguageServerAccess access) { this.access = access; this.access.addBuildListener(this); LanguageClient _languageClient = access.getLanguageClient(); this.client = ServiceEndpoints.<TestLangLSPExtension.CustomClient>toServiceObject(((Endpoint) _languageClient), TestLangLSPExtension.CustomClient.class); }
public DebugRemoteEndpoint(MessageConsumer out, Endpoint localEndpoint) { super(out, localEndpoint); }
public DebugRemoteEndpoint(MessageConsumer out, Endpoint localEndpoint, Function<Throwable, ResponseError> exceptionHandler) { super(out, localEndpoint, exceptionHandler); }
/** * Wraps a given {@link Endpoint} in the given service interface. * @param endpoint * @param interface_ * @return */ @SuppressWarnings("unchecked") public static <T> T toServiceObject(Endpoint endpoint, Class<T> interface_) { Object newProxyInstance = Proxy.newProxyInstance(interface_.getClassLoader(), new Class[]{interface_, Endpoint.class}, new EndpointProxy(endpoint, interface_)); return (T) newProxyInstance; }
/** * Wraps a given object with service annotations behind an {@link Endpoint} interface. * * @param serviceObject * @return */ public static Endpoint toEndpoint(Object serviceObject) { return new GenericEndpoint(serviceObject); }
/** * Wraps a given {@link Endpoint} in the given service interface. * @param endpoint * @param interface_ * @return the wrapped service object */ @SuppressWarnings("unchecked") public static <T> T toServiceObject(Endpoint endpoint, Class<T> interface_) { Object newProxyInstance = Proxy.newProxyInstance(interface_.getClassLoader(), new Class[]{interface_, Endpoint.class}, new EndpointProxy(endpoint, interface_)); return (T) newProxyInstance; }
/** * Wraps a given object with service annotations behind an {@link Endpoint} interface. * * @param serviceObject * @return the wrapped service endpoint */ public static Endpoint toEndpoint(Object serviceObject) { return new GenericEndpoint(serviceObject); }