break; Request request = new Request("waitFor"); request.parameters().add(new StringValue(fileReference.value())); target.invokeSync(request, rpcTimeout); if (request.checkReturnTypes("s")) { return new File(request.returnValues().get(0).asString()); } else if (!request.isError()) { throw new RuntimeException("Invalid response: " + request.returnValues()); } else if (temporaryError(request.errorCode())) { log.log(LogLevel.INFO, "Retrying waitFor for " + fileReference + ": " + request.errorCode() + " -- " + request.errorMessage()); Thread.sleep(1000); } else { if (request.errorCode() == FileDistributionErrorCode.fileReferenceDoesNotExists) throw new FileReferenceDoesNotExistException(fileReference.value()); else if (request.errorCode() == FileDistributionErrorCode.fileReferenceRemoved) throw new FileReferenceRemovedException(fileReference.value()); else throw new RuntimeException("Wait for " + fileReference + " failed:" + request.errorMessage() + " (" + request.errorCode() + ")");
@Override public void handleRequestDone(Request req) { if ( ! req.checkReturnTypes("S")) { registerReq.setError(ErrorCode.METHOD_FAILED, "error during register callback: " + req.errorMessage()); registerReq.returnRequest(); target.close(); return; } String[] names = req.returnValues().get(0).asStringArray(); boolean found = false; for (String n : names) { if (n.equals(name)) { found = true; } } if (!found) { registerReq.setError(ErrorCode.METHOD_FAILED, "register failed: served names does not contain name"); registerReq.returnRequest(); target.close(); return; } handleRegisterCallbackDone(registerReq, name, spec, target); } }
private boolean validateResponse(Request request) { if (request.isError()) { return false; } else if (request.returnValues().size() == 0) { return false; } else if (!request.checkReturnTypes("is")) { // TODO: Do not hard-code return type log.log(LogLevel.WARNING, "Invalid return types for response: " + request.errorMessage()); return false; } return true; }
protected Request createRequest(String method,List<String> arguments) { Request request=new Request(method); if (arguments!=null) { for (String argument : arguments) request.parameters().add(getArgument(request,argument)); } return request; }
public void returnRequest() { if (!conn.completeRequest(done)) { throw new IllegalStateException("Request already returned"); } if (noReply) { return; } if (!request.isError() && !method.checkReturnValues(request)) { request.setError(ErrorCode.WRONG_RETURN, "Return values in " + request + " does not match " + method); } if (request.isError()) { conn.postPacket(new ErrorPacket(0, replyKey, request.errorCode(), request.errorMessage())); } else { conn.postPacket(new ReplyPacket(0, replyKey, request.returnValues())); } } }
if (req.methodName().equals(UNREGISTER_METHOD_NAME)) { logOnSuccess = true; } else { final Boolean lastSucceeded = lastRegisterSucceeded.get(name); if (lastSucceeded == null || lastSucceeded != !req.isError()) { logOnSuccess = true; lastRegisterSucceeded.put(name, !req.isError()); if (req.isError()) { if (req.errorCode() != ErrorCode.METHOD_FAILED) { log.log(Level.INFO, logMessagePrefix() + " failed, will disconnect: " + req.errorMessage() + " (code " + req.errorCode() + ")"); target.close(); target = null; } else { log.log(Level.WARNING, logMessagePrefix() + " failed: " + req.errorMessage()); if (unreg.size() > 0) { name = unreg.remove(unreg.size() - 1); req = new Request(UNREGISTER_METHOD_NAME); } else if (pending.size() > 0) { name = pending.remove(pending.size() - 1); req = new Request(REGISTER_METHOD_NAME); } else { pending.addAll(names); req.parameters().add(new StringValue(name)); req.parameters().add(new StringValue(mySpec)); log.log(Level.FINE, logMessagePrefix() + " now");
private void rpc_fetchIncremental(Request req) { int gencnt = req.parameters().get(0).asInt32(); int timeout = req.parameters().get(1).asInt32(); // for now, always make "full diff" from generation 0 req.returnValues().add(new Int32Value(0)); req.returnValues().add(new StringArray(new String[0])); if (gencnt == this.gencnt) { pendingFetch.add(new FetchMirror(req, timeout)); } else { dumpServices(req); } }
@SuppressWarnings({"UnusedDeclaration"}) public final void setFileReferencesToDownload(Request req) { log.log(LogLevel.DEBUG, () -> "Received method call '" + req.methodName() + "' with parameters : " + req.parameters()); Arrays.stream(req.parameters().get(0).asStringArray()) .map(FileReference::new) .forEach(fileReference -> downloader.downloadIfNeeded(new FileReferenceDownload(fileReference))); req.returnValues().add(new Int32Value(0)); }
private boolean startDownloadRpc(FileReferenceDownload fileReferenceDownload, int retryCount) { Connection connection = connectionPool.getCurrent(); Request request = new Request("filedistribution.serveFile"); String fileReference = fileReferenceDownload.fileReference().value(); request.parameters().add(new StringValue(fileReference)); request.parameters().add(new Int32Value(fileReferenceDownload.downloadFromOtherSourceIfNotFound() ? 0 : 1)); execute(request, connection); Level logLevel = (retryCount > 0 ? LogLevel.INFO : LogLevel.DEBUG); if (validateResponse(request)) { log.log(logLevel, () -> "Request callback, OK. Req: " + request + "\nSpec: " + connection); if (request.returnValues().get(0).asInt32() == 0) { log.log(logLevel, () -> "Found file reference '" + fileReference + "' available at " + connection.getAddress()); return true; } else { log.log(logLevel, "File reference '" + fileReference + "' not found for " + connection.getAddress()); connectionPool.setNewCurrentConnection(); return false; } } else { log.log(logLevel, "Request failed. Req: " + request + "\nSpec: " + connection.getAddress() + ", error code: " + request.errorCode() + ", set error for connection and use another for next request"); connectionPool.setError(connection, request.errorCode()); return false; } }
private void doRequestDone(Request req) { SendContext ctx = (SendContext)req.getContext(); String serviceName = ((RPCServiceAddress)ctx.recipient.getServiceAddress()).getServiceName(); Reply reply = null; Error error = null; if (!req.checkReturnTypes(getReturnSpec())) { switch (req.errorCode()) { case com.yahoo.jrt.ErrorCode.TIMEOUT: error = new Error(ErrorCode.TIMEOUT, "A timeout occured while waiting for '" + serviceName + "' (" + ctx.timeout + " seconds expired); " + req.errorMessage()); break; case com.yahoo.jrt.ErrorCode.CONNECTION: error = new Error(ErrorCode.CONNECTION_ERROR, "A connection error occured for '" + serviceName + "'; " + req.errorMessage()); break; default: error = new Error(ErrorCode.NETWORK_ERROR, "A network error occured for '" + serviceName + "'; " + req.errorMessage()); reply = createReply(req.returnValues(), serviceName, ctx.trace);
/** * Check whether the parameters of the given request satisfies the * parameters of this method. * * @return true if the parameters of the given request satisfies * the parameters of this method * @param req a request **/ boolean checkParameters(Request req) { return req.parameters().satisfies(paramTypes); }
private void downloadFile(Request req) { FileReference fileReference = new FileReference(req.parameters().get(0).asString()); log.log(LogLevel.DEBUG, () -> "getFile() called for file reference '" + fileReference.value() + "'"); Optional<File> pathToFile = downloader.getFile(fileReference); try { if (pathToFile.isPresent()) { req.returnValues().add(new StringValue(pathToFile.get().getAbsolutePath())); log.log(LogLevel.DEBUG, () -> "File reference '" + fileReference.value() + "' available at " + pathToFile.get()); } else { log.log(LogLevel.INFO, "File reference '" + fileReference.value() + "' not found, returning error"); req.setError(fileReferenceDoesNotExists, "File reference '" + fileReference.value() + "' not found"); } } catch (Throwable e) { log.log(LogLevel.WARNING, "File reference '" + fileReference.value() + "' got exception: " + e.getMessage()); req.setError(fileReferenceInternalError, "File reference '" + fileReference.value() + "' removed"); } req.returnRequest(); }
/** * Check whether the return values of the given request satisfies * the return values of this method. * * @return true if the return values of the given request satisfies * the return values of this method * @param req a request **/ boolean checkReturnValues(Request req) { return req.returnValues().satisfies(returnTypes); }
@Override public void handleRequestDone(Request requestWithResponse) { if (requestWithResponse.isError()) { handler.receive(GetDocsumsResponseOrError.fromError("Error response from " + node + ": " + requestWithResponse.errorMessage())); return; } Values returnValues = requestWithResponse.returnValues(); if (returnValues.size() < 3) { handler.receive(GetDocsumsResponseOrError.fromError("Invalid getDocsums response from " + node + ": Expected 3 return arguments, got " + returnValues.size())); return; } byte compression = returnValues.get(0).asInt8(); int uncompressedSize = returnValues.get(1).asInt32(); byte[] compressedSlimeBytes = returnValues.get(2).asData(); List<FastHit> hits = (List<FastHit>) requestWithResponse.getContext(); handler.receive(GetDocsumsResponseOrError.fromResponse(new GetDocsumsResponse(compression, uncompressedSize, compressedSlimeBytes, hits))); }
@Override public void handleRequestDone(Request req) { List<VersionHandler> handlers; boolean shouldLog = log.isLoggable(LogLevel.DEBUG); synchronized (this) { targetInvoked = false; if (req.checkReturnTypes("s")) { String str = req.returnValues().get(0).asString(); try { version = new Version(str); if (shouldLog) { log.log(LogLevel.DEBUG, "Target '" + name + "' has version " + version + "."); } } catch (IllegalArgumentException e) { log.log(LogLevel.WARNING, "Failed to parse '" + str + "' as version for target '" + name + "'.", e); } } else { log.log(LogLevel.INFO, "Method mbus.getVersion() failed for target '" + name + "'; " + req.errorMessage()); } handlers = versionHandlers; versionHandlers = new LinkedList<>(); } for (VersionHandler handler : handlers) { handler.handleVersion(version); } }
@SuppressWarnings({"UnusedDeclaration"}) public final void receiveFileMeta(Request req) { log.log(LogLevel.DEBUG, () -> "Received method call '" + req.methodName() + "' with parameters : " + req.parameters()); FileReference reference = new FileReference(req.parameters().get(0).asString()); String fileName = req.parameters().get(1).asString(); String type = req.parameters().get(2).asString(); long fileSize = req.parameters().get(3).asInt64(); int sessionId = nextSessionId.getAndIncrement(); int retval = 0; synchronized (sessions) { if (sessions.containsKey(sessionId)) { retval = 1; log.severe("Session id " + sessionId + " already exist, impossible. Request from(" + req.target() + ")"); } else { try { sessions.put(sessionId, new Session(downloadDirectory, tmpDirectory, sessionId, reference, FileReferenceData.Type.valueOf(type),fileName, fileSize)); } catch (Exception e) { retval = 1; } } } req.returnValues().add(new Int32Value(retval)); req.returnValues().add(new Int32Value(sessionId)); }
public void getMethodInfo(Request req) { Method method = parent.methodMap().get(req.parameters().get(0).asString()); if (method == null) { req.setError(ErrorCode.METHOD_FAILED, "No Such Method"); return; } req.returnValues().add(new StringValue(method.methodDesc())); req.returnValues().add(new StringValue(method.paramTypes())); req.returnValues().add(new StringValue(method.returnTypes())); int paramCnt = method.paramTypes().length(); int returnCnt = method.returnTypes().length(); String[] ret3_paramName = new String[paramCnt]; String[] ret4_paramDesc = new String[paramCnt]; String[] ret5_returnName = new String[returnCnt]; String[] ret6_returnDesc = new String[returnCnt]; for (int i = 0; i < paramCnt; i++) { ret3_paramName[i] = method.paramName(i); ret4_paramDesc[i] = method.paramDesc(i); } for (int i = 0; i < returnCnt; i++) { ret5_returnName[i] = method.returnName(i); ret6_returnDesc[i] = method.returnDesc(i); } req.returnValues().add(new StringArray(ret3_paramName)); req.returnValues().add(new StringArray(ret4_paramDesc)); req.returnValues().add(new StringArray(ret5_returnName)); req.returnValues().add(new StringArray(ret6_returnDesc)); } }
@Override public void getDocsums(List<FastHit> hits, NodeConnection node, CompressionType compression, int uncompressedLength, byte[] compressedSlime, RpcFillInvoker.GetDocsumsResponseReceiver responseReceiver, double timeoutSeconds) { Request request = new Request("proton.getDocsums"); request.parameters().add(new Int8Value(compression.getCode())); request.parameters().add(new Int32Value(uncompressedLength)); request.parameters().add(new DataValue(compressedSlime)); request.setContext(hits); RpcNodeConnection rpcNode = ((RpcNodeConnection) node); rpcNode.invokeAsync(request, timeoutSeconds, new RpcResponseWaiter(rpcNode, responseReceiver)); }
void receive(FileReference reference, String filename, byte[] content) { log.log(LogLevel.INFO, "Preparing receive call for " + reference.value() + " and file " + filename); XXHash64 hasher = XXHashFactory.fastestInstance().hash64(); Request fileBlob = new Request("filedistribution.receiveFile"); log.log(LogLevel.INFO, "Calling " + fileBlob.methodName() + " with target " + target); fileBlob.parameters().add(new StringValue(reference.value())); fileBlob.parameters().add(new StringValue(filename)); fileBlob.parameters().add(new DataValue(content)); fileBlob.parameters().add(new Int64Value(hasher.hash(ByteBuffer.wrap(content), 0))); fileBlob.parameters().add(new Int32Value(0)); fileBlob.parameters().add(new StringValue("OK")); log.log(LogLevel.INFO, "Doing invokeSync"); target.invokeSync(fileBlob, 5); log.log(LogLevel.INFO, "Done with invokeSync"); } }