oprot.writeMessageBegin(new TMessage("setAcceptNewStream", TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); byte[] buffer = Arrays.copyOfRange(memoryBuffer.getArray(), 0, memoryBuffer.length()); return Future.value(buffer); } catch (Exception e1) { return Future.exception(e1); return Future.exception(e); return Future.exception(e); future = iface.setAcceptNewStream(args.enabled); } catch (Exception e) { future = Future.exception(e); return future.flatMap(new Function<Void, Future<byte[]>>() { public Future<byte[]> apply(Void value) { setAcceptNewStream_result result = new setAcceptNewStream_result(); TProtocol oprot = protocolFactory.getProtocol(memoryBuffer); }).rescue(new Function<Throwable, Future<byte[]>>() { public Future<byte[]> apply(Throwable t) { return Future.exception(t); return Future.exception(e);
void readLoop() { if (!running) { return; } logReaders[streamIdx].readBulk(10).addEventListener(this); }
@Override public Future<Boolean> truncate(final DLSN dlsn) { if (DLSN.InvalidDLSN == dlsn) { return Future.value(false); } BKLogWriteHandler writeHandler; try { writeHandler = getWriteHandler(); } catch (IOException e) { return Future.exception(e); } return writeHandler.setLogSegmentsOlderThanDLSNTruncated(dlsn).map(TruncationResultConverter); }
public Future<ServerInfo> apply(byte[] __buffer__) { TMemoryInputTransport __memoryTransport__ = new TMemoryInputTransport(__buffer__); TProtocol __prot__ = ServiceToClient.this.protocolFactory.getProtocol(__memoryTransport__); try { return Future.value((new Client(__prot__)).recv_handshakeWithClientInfo()); } catch (Exception e) { return Future.exception(e); } } });
public Future<ServerInfo> handshake() { try { // TODO: size TMemoryBuffer __memoryTransport__ = new TMemoryBuffer(512); TProtocol __prot__ = this.protocolFactory.getProtocol(__memoryTransport__); __prot__.writeMessageBegin(new TMessage("handshake", TMessageType.CALL, 0)); handshake_args __args__ = new handshake_args(); __args__.write(__prot__); __prot__.writeMessageEnd(); byte[] __buffer__ = Arrays.copyOfRange(__memoryTransport__.getArray(), 0, __memoryTransport__.length()); ThriftClientRequest __request__ = new ThriftClientRequest(__buffer__, false); Future<byte[]> __done__ = this.service.apply(__request__); return __done__.flatMap(new Function<byte[], Future<ServerInfo>>() { public Future<ServerInfo> apply(byte[] __buffer__) { TMemoryInputTransport __memoryTransport__ = new TMemoryInputTransport(__buffer__); TProtocol __prot__ = ServiceToClient.this.protocolFactory.getProtocol(__memoryTransport__); try { return Future.value((new Client(__prot__)).recv_handshake()); } catch (Exception e) { return Future.exception(e); } } }); } catch (TException e) { return Future.exception(e); } } public Future<ServerInfo> handshakeWithClientInfo(ClientInfo clientInfo) {
public Future<byte[]> apply(byte[] request) { TTransport inputTransport = new TMemoryInputTransport(request); TProtocol iprot = protocolFactory.getProtocol(inputTransport); TMessage msg; try { msg = iprot.readMessageBegin(); } catch (Exception e) { return Future.exception(e); } Function2<TProtocol, Integer, Future<byte[]>> fn = functionMap.get(msg.name); if (fn == null) { try { TProtocolUtil.skip(iprot, TType.STRUCT); iprot.readMessageEnd(); TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'"); TMemoryBuffer memoryBuffer = new TMemoryBuffer(512); TProtocol oprot = protocolFactory.getProtocol(memoryBuffer); oprot.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return Future.value(Arrays.copyOfRange(memoryBuffer.getArray(), 0, memoryBuffer.length())); } catch (Exception e) { return Future.exception(e); } } return fn.apply(iprot, msg.seqid); } }
Future<List<LogSegmentMetadata>> setLogSegmentsOlderThanDLSNTruncated(final DLSN dlsn) { if (DLSN.InvalidDLSN == dlsn) { List<LogSegmentMetadata> emptyList = new ArrayList<LogSegmentMetadata>(0); return Future.value(emptyList); } scheduleGetAllLedgersTaskIfNeeded(); return asyncGetFullLedgerList(false, false).flatMap( new AbstractFunction1<List<LogSegmentMetadata>, Future<List<LogSegmentMetadata>>>() { @Override public Future<List<LogSegmentMetadata>> apply(List<LogSegmentMetadata> logSegments) { return setLogSegmentsOlderThanDLSNTruncated(logSegments, dlsn); } }); }
@Override public void run() { reinitStream(idx).map(new Function<Void, Void>() { @Override public Void apply(Void value) { LOG.info("Initialized stream reader {}.", idx); latch.countDown(); return null; } }); } });
private Future<List<Try<DLSN>>> asTryList(Future<List<Future<DLSN>>> futureList) { return futureList.flatMap(new AbstractFunction1<List<Future<DLSN>>, Future<List<Try<DLSN>>>>() { @Override public Future<List<Try<DLSN>>> apply(List<Future<DLSN>> results) { return Future$.MODULE$.collectToTry(results); } }); }
fetchFutures.add(fetchLogLocation(uri, logName)); Future.collect(fetchFutures).addEventListener(new FutureEventListener<List<Optional<URI>>>() { @Override public void onSuccess(List<Optional<URI>> fetchResults) {
Future<Long> markEndOfStream() { final Stopwatch stopwatch = Stopwatch.createStarted(); Future<BKLogSegmentWriter> logSegmentWriterFuture; synchronized (this) { logSegmentWriterFuture = this.rollingFuture; } if (null == logSegmentWriterFuture) { logSegmentWriterFuture = getLogSegmentWriterForEndOfStream(); } return logSegmentWriterFuture.flatMap(new AbstractFunction1<BKLogSegmentWriter, Future<Long>>() { @Override public Future<Long> apply(BKLogSegmentWriter w) { return w.markEndOfStream(); } }).addEventListener(new OpStatsListener<Long>(markEndOfStreamOpStatsLogger, stopwatch)); }
private Future<List<Void>> closeStreams(Set<Stream> streamsToClose, Optional<RateLimiter> rateLimiter) { if (streamsToClose.isEmpty()) { logger.info("No streams to close."); List<Void> emptyList = new ArrayList<Void>(); return Future.value(emptyList); } List<Future<Void>> futures = new ArrayList<Future<Void>>(streamsToClose.size()); for (Stream stream : streamsToClose) { if (rateLimiter.isPresent()) { rateLimiter.get().acquire(); } futures.add(stream.requestClose("Close Streams")); } return Future.collect(futures); }
@Override public Future<Optional<URI>> getLogLocation(final String logName) { if (duplicatedLogFound.get()) { return duplicatedLogException(duplicatedLogName.get()); } URI location = log2Locations.get(logName); if (null != location) { return postStateCheck(Future.value(Optional.of(location))); } if (!forceCheckLogExistence) { Optional<URI> result = Optional.absent(); return Future.value(result); } return postStateCheck(fetchLogLocation(logName).onSuccess( new AbstractFunction1<Optional<URI>, BoxedUnit>() { @Override public BoxedUnit apply(Optional<URI> uriOptional) { if (uriOptional.isPresent()) { log2Locations.putIfAbsent(logName, uriOptional.get()); } return BoxedUnit.UNIT; } })); }
private void getLastCommitPositions(final Promise<Map<String, DLSN>> result, List<String> subscribers) { List<Future<Pair<String, DLSN>>> futures = new ArrayList<Future<Pair<String, DLSN>>>(subscribers.size()); for (String s : subscribers) { final String subscriber = s; Future<Pair<String, DLSN>> future = // Get the last commit position from zookeeper getSubscriber(subscriber).getLastCommitPositionFromZK().map( new AbstractFunction1<DLSN, Pair<String, DLSN>>() { @Override public Pair<String, DLSN> apply(DLSN dlsn) { return Pair.of(subscriber, dlsn); } }); futures.add(future); } Future.collect(futures).foreach( new AbstractFunction1<List<Pair<String, DLSN>>, BoxedUnit>() { @Override public BoxedUnit apply(List<Pair<String, DLSN>> subscriptions) { Map<String, DLSN> subscriptionMap = new HashMap<String, DLSN>(); for (Pair<String, DLSN> pair : subscriptions) { subscriptionMap.put(pair.getLeft(), pair.getRight()); } result.setValue(subscriptionMap); return BoxedUnit.UNIT; } }); }
@Override public Future<Void> setAcceptNewStream(boolean enabled) { Map<SocketAddress, ProxyClient> snapshot = clientManager.getAllClients(); List<Future<Void>> futures = new ArrayList<Future<Void>>(snapshot.size()); for (Map.Entry<SocketAddress, ProxyClient> entry : snapshot.entrySet()) { futures.add(entry.getValue().getService().setAcceptNewStream(enabled)); } return Future.collect(futures).map(new Function<List<Void>, Void>() { @Override public Void apply(List<Void> list) { return null; } }); }
@Override public Future<PinLaterDequeueResponse> dequeueJobs( RequestContext context, final PinLaterDequeueRequest request) { if (!queueConfig.allowDequeue(request.getQueueName(), request.getLimit())) { Stats.incr(request.getQueueName() + "_dequeue_requests_rate_limited"); return Future.exception(new PinLaterException(ErrorCode.DEQUEUE_RATE_LIMITED, "Dequeue rate limit exceeded for queue: " + request.getQueueName())); } return Stats.timeFutureMillis( "PinLaterService.dequeueJobs", backend.dequeueJobs(context.getSource(), request).onSuccess( new Function<PinLaterDequeueResponse, BoxedUnit>() { @Override public BoxedUnit apply(PinLaterDequeueResponse response) { Stats.incr(request.getQueueName() + "_dequeue", response.getJobsSize()); return null; } }).rescue(new LogAndWrapException<PinLaterDequeueResponse>( context, "dequeueJobs", request.toString()))); }
@Override public Future<PinLaterEnqueueResponse> enqueueJobs( RequestContext context, final PinLaterEnqueueRequest request) { return Stats.timeFutureMillis( "PinLaterService.enqueueJobs", backend.enqueueJobs(request).onSuccess( new Function<PinLaterEnqueueResponse, BoxedUnit>() { @Override public BoxedUnit apply(PinLaterEnqueueResponse response) { Stats.incr(request.getQueueName() + "_enqueue", request.getJobsSize()); return null; } }).rescue(new LogAndWrapException<PinLaterEnqueueResponse>( context, "enqueueJobs", request.toString()))); }
return Futures.collect(futures).map(new Function<List<StreamLoad>, TreeSet<ServerLoad>>() { @Override public TreeSet<ServerLoad> apply(List<StreamLoad> streamLoads) { }).onSuccess(new Function<TreeSet<ServerLoad>, BoxedUnit>() { @Override public BoxedUnit apply(TreeSet<ServerLoad> serverLoads) { return BoxedUnit.UNIT; }).onFailure(new Function<Throwable, BoxedUnit>() { @Override public BoxedUnit apply(Throwable t) {