@Test public void testCancellation() { TestEndpoint endp = new TestEndpoint(); TestMessageConsumer consumer = new TestMessageConsumer(); RemoteEndpoint endpoint = new RemoteEndpoint(consumer, endp); endpoint.consume(new RequestMessage() {{ setId("1"); setMethod("foo"); setParams("myparam"); }}); Entry<RequestMessage, CompletableFuture<Object>> entry = endp.requests.entrySet().iterator().next(); entry.getValue().cancel(true); ResponseMessage message = (ResponseMessage) consumer.messages.get(0); assertNotNull(message); ResponseError error = message.getError(); assertNotNull(error); assertEquals(error.getCode(), ResponseErrorCode.RequestCancelled.getValue()); assertEquals(error.getMessage(), "The request (id: 1, method: 'foo') has been cancelled"); }
@Override public void consume(Message message) { List<String> result = new ArrayList<>(); try { validate(message, result, new LinkedList<>()); } catch (Throwable e) { LOG.log(Level.SEVERE, "Error during message validation: " + e.getMessage(), e); result.add("The message validation failed, please look at the server's logs."); } if (!result.isEmpty()) { ResponseError error = new ResponseError(ResponseErrorCode.InvalidParams, result.stream().collect(Collectors.joining(", ")), message); throw new InvalidMessageException(error.getMessage(), error, null); } else if (delegate != null) { delegate.consume(message); } }
@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; }
@Test public void testCancellation() { TestEndpoint endp = new TestEndpoint(); TestMessageConsumer consumer = new TestMessageConsumer(); RemoteEndpoint endpoint = new DebugRemoteEndpoint(consumer, endp); endpoint.consume(new RequestMessage() {{ setId("1"); setMethod("foo"); setParams("myparam"); }}); Entry<RequestMessage, CompletableFuture<Object>> entry = endp.requests.entrySet().iterator().next(); entry.getValue().cancel(true); ResponseMessage message = (ResponseMessage) consumer.messages.get(0); assertNotNull(message); ResponseError error = message.getError(); assertNotNull(error); assertEquals(error.getCode(), ResponseErrorCode.RequestCancelled.getValue()); assertEquals(error.getMessage(), "The request (id: 1, method: 'foo') has been cancelled"); }
public RemoteEndpoint(MessageConsumer out, Endpoint localEndpoint, Function<Throwable, ResponseError> exceptionHandler) { if (out == null) throw new NullPointerException("out"); if (localEndpoint == null) throw new NullPointerException("localEndpoint"); if (exceptionHandler == null) throw new NullPointerException("exceptionHandler"); this.out = out; this.localEndpoint = localEndpoint; this.exceptionHandler = exceptionHandler; }
public void checkSeverity() { RefactoringIssueAcceptor.Severity _maximumSeverity = this.getMaximumSeverity(); boolean _lessThan = (_maximumSeverity.compareTo(RefactoringIssueAcceptor.Severity.WARNING) < 0); if (_lessThan) { ResponseError _responseError = this.toResponseError(); throw new ResponseErrorException(_responseError); } }
protected IWorkspaceConfig getWorkspaceConfig() { if ((this._workspaceConfig == null)) { final ResponseError error = new ResponseError(ResponseErrorCode.serverNotInitialized, "Workspace has not been initialized yet.", null); throw new ResponseErrorException(error); } return this._workspaceConfig; }
@Test public void testResponseError() { ResponseMessage _responseMessage = new ResponseMessage(); final Procedure1<ResponseMessage> _function = (ResponseMessage it) -> { it.setJsonrpc("2.0"); it.setId("12"); ResponseError _responseError = new ResponseError(); final Procedure1<ResponseError> _function_1 = (ResponseError it_1) -> { it_1.setCode(ResponseErrorCode.InvalidRequest); it_1.setMessage("Could not parse request."); }; ResponseError _doubleArrow = ObjectExtensions.<ResponseError>operator_doubleArrow(_responseError, _function_1); it.setError(_doubleArrow); }; final ResponseMessage message = ObjectExtensions.<ResponseMessage>operator_doubleArrow(_responseMessage, _function); StringConcatenation _builder = new StringConcatenation(); _builder.append("{"); _builder.newLine(); _builder.append(" "); _builder.append("\"jsonrpc\": \"2.0\","); _builder.newLine(); _builder.append(" "); _builder.append("\"id\": \"12\","); _builder.newLine(); _builder.append(" "); _builder.append("\"error\": {"); _builder.newLine(); _builder.append(" "); _builder.append("\"code\": -32600,"); _builder.newLine(); _builder.append(" "); _builder.append("\"message\": \"Could not parse request.\""); _builder.newLine(); _builder.append(" "); _builder.append("}"); _builder.newLine(); _builder.append("}"); _builder.newLine(); this.assertSerialize(message, _builder); }
private static ResponseError fallbackResponseError(String header, Throwable throwable) { LOG.log(Level.SEVERE, header + ": " + throwable.getMessage(), throwable); ResponseError error = new ResponseError(); error.setMessage(header + "."); error.setCode(ResponseErrorCode.InternalError); ByteArrayOutputStream stackTrace = new ByteArrayOutputStream(); PrintWriter stackTraceWriter = new PrintWriter(stackTrace); throwable.printStackTrace(stackTraceWriter); stackTraceWriter.flush(); error.setData(stackTrace.toString()); return error; }
/** * @param exceptionHandler An exception handler that should never return null. */ public RemoteEndpoint(MessageConsumer out, Endpoint localEndpoint, Function<Throwable, ResponseError> exceptionHandler) { if (out == null) throw new NullPointerException("out"); if (localEndpoint == null) throw new NullPointerException("localEndpoint"); if (exceptionHandler == null) throw new NullPointerException("exceptionHandler"); this.out = out; this.localEndpoint = localEndpoint; this.exceptionHandler = exceptionHandler; }
@Override public Message read(JsonReader in) throws IOException { if (in.peek() == JsonToken.NULL) { in.nextNull(); return null; } in.beginObject(); String jsonrpc = null, id = null, method = null; Object rawParams = null; Object result = null; ResponseError error = null; while (in.hasNext()) { String name = in.nextName(); switch (name) { case "jsonrpc": { jsonrpc = in.nextString(); break; } case "id": { id = in.nextString(); break; } case "method": { method = in.nextString(); break; } case "params": { rawParams = parseParams(in, method); break; } case "result": { Type type = null; MethodProvider methodProvider = handler.getMethodProvider(); if (methodProvider != null && id != null) { String resolvedMethod = methodProvider.resolveMethod(id); if (resolvedMethod != null) { JsonRpcMethod jsonRpcMethod = handler.getJsonRpcMethod(resolvedMethod); if (jsonRpcMethod != null) type = jsonRpcMethod.getReturnType(); } } if (type == null) result = new JsonParser().parse(in); else result = gson.fromJson(in, type); break; } case "error": { error = gson.fromJson(in, ResponseError.class); break; } default: in.skipValue(); } } in.endObject(); Object params = parseParams(rawParams, method); return createMessage(jsonrpc, id, method, params, result, error); }
public ResponseErrorException(ResponseError responseError) { this.responseError = responseError; }
public ResponseError getResponseError() { return responseError; }
public DebugRemoteEndpoint(MessageConsumer out, Endpoint localEndpoint, Function<Throwable, ResponseError> exceptionHandler) { super(out, localEndpoint, exceptionHandler); }
@Override public Message read(JsonReader in) throws IOException { if (in.peek() == JsonToken.NULL) { in.nextNull(); return null; } in.beginObject(); String jsonrpc = null, id = null, method = null; Object rawParams = null; Object rawResult = null; ResponseError error = null; while (in.hasNext()) { String name = in.nextName(); switch (name) { case "jsonrpc": { jsonrpc = in.nextString(); break; } case "id": { id = in.nextString(); break; } case "method": { method = in.nextString(); break; } case "params": { rawParams = parseParams(in, method); break; } case "result": { rawResult = parseResult(in, id); break; } case "error": { error = gson.fromJson(in, ResponseError.class); break; } default: in.skipValue(); } } in.endObject(); Object params = parseParams(rawParams, method); Object result = parseResult(rawResult, method); return createMessage(jsonrpc, id, method, params, result, error); }
protected ResponseMessage createErrorResponseMessage(RequestMessage requestMessage, ResponseError errorObject) { ResponseMessage responseMessage = createResponseMessage(requestMessage); responseMessage.setError(errorObject); return responseMessage; }