@Override public void send(WireCommand cmd) throws ConnectionFailedException { recentMessage.set(true); Futures.getAndHandleExceptions(getChannel().writeAndFlush(cmd), ConnectionFailedException::new); }
void recordResult(final CompletableFuture<Void> scaleTestResult, final String testName) { Futures.getAndHandleExceptions(scaleTestResult.handle((r, e) -> { if (e != null) { log.error("test {} failed with exception {}", testName, e); } else { log.debug("test {} succeed", testName); } return null; }), RuntimeException::new); }
@Override public void send(Append append) throws ConnectionFailedException { recentMessage.set(true); batchSizeTracker.recordAppend(append.getEventNumber(), append.getData().readableBytes()); Futures.getAndHandleExceptions(getChannel().writeAndFlush(append), ConnectionFailedException::new); }
@Override public void commit() throws TxnFailedException { throwIfClosed(); for (SegmentTransaction<Type> tx : inner.values()) { tx.close(); } getAndHandleExceptions(controller.commitTransaction(stream, txId), TxnFailedException::new); pinger.stopPing(txId); closed.set(true); }
@Override public void commit() throws TxnFailedException { throwIfClosed(); for (SegmentTransaction<Type> tx : inner.values()) { tx.close(); } getAndHandleExceptions(controller.commitTransaction(stream, txId), TxnFailedException::new); pinger.stopPing(txId); closed.set(true); }
@Override public boolean createScope(String scopeName) { return Futures.getAndHandleExceptions(controller.createScope(scope), RuntimeException::new); }
@Override public boolean deleteScope(String scopeName) { return Futures.getAndHandleExceptions(controller.deleteScope(scope), RuntimeException::new); }
@Override public boolean sealStream(String scopeName, String streamName) { return Futures.getAndHandleExceptions(controller.sealStream(scopeName, streamName), RuntimeException::new); }
@Override public boolean truncateStream(String scopeName, String streamName, StreamCut streamCut) { Preconditions.checkNotNull(streamCut); return Futures.getAndHandleExceptions(controller.truncateStream(scopeName, streamName, streamCut), RuntimeException::new); }
static URI startPravegaControllerInstances(final URI zkUri, final int instanceCount) throws ExecutionException { Service controllerService = Utils.createPravegaControllerService(zkUri); if (!controllerService.isRunning()) { controllerService.start(true); } Futures.getAndHandleExceptions(controllerService.scaleService(instanceCount), ExecutionException::new); List<URI> conUris = controllerService.getServiceDetails(); log.info("Pravega Controller service details: {}", conUris); // Fetch all the RPC endpoints and construct the client URIs. final List<String> uris = conUris.stream().filter(ISGRPC).map(URI::getAuthority).collect(Collectors.toList()); URI controllerURI = URI.create("tcp://" + String.join(",", uris)); log.info("Controller Service direct URI: {}", controllerURI); return controllerURI; }
private Stream createStreamHelper(String streamName, StreamConfiguration config) { Futures.getAndHandleExceptions(controller.createStream(scope, streamName, config), RuntimeException::new); return new StreamImpl(scope, streamName); }
@After public void tearDown() throws ExecutionException { // Scale back the segment store instance count. Futures.getAndHandleExceptions(this.segmentServiceInstance.scaleService(1), ExecutionException::new); }
@Override public void deleteReaderGroup(String groupName) { Futures.getAndHandleExceptions(controller.deleteStream(scope, NameUtils.getStreamForReaderGroup(groupName)), RuntimeException::new); } }
private <T> void sendRequestOverNewConnection(WireCommand request, ReplyProcessor replyProcessor, CompletableFuture<T> resultFuture) { ClientConnection connection = getAndHandleExceptions(connectionFactory .establishConnection(new PravegaNodeUri(endpoint, port), replyProcessor), RuntimeException::new); resultFuture.whenComplete((result, e) -> { connection.close(); }); connection.sendAsync(request, cfe -> { if (cfe != null) { resultFuture.completeExceptionally(cfe); } }); }
private Stream createStreamHelper(String streamName, StreamConfiguration config) { getAndHandleExceptions(controller.createStream(scope, streamName, StreamConfiguration.builder() .scalingPolicy(config.getScalingPolicy()) .build()), RuntimeException::new); return new StreamImpl(scope, streamName); }
private ByteStreamReader createByteStreamReaders(Segment segment) { String delegationToken = Futures.getAndHandleExceptions(controller.getOrRefreshDelegationTokenFor(segment.getScope(), segment.getStream() .getStreamName()), RuntimeException::new); return new ByteStreamReaderImpl(inputStreamFactory.createInputStreamForSegment(segment, delegationToken), metaStreamFactory.createSegmentMetadataClient(segment, delegationToken)); }
private EventSegmentReader getEventSegmentReader(Segment segment, long endOffset, int bufferSize) { String delegationToken = Futures.getAndHandleExceptions(controller.getOrRefreshDelegationTokenFor(segment.getScope(), segment.getStream() .getStreamName()), RuntimeException::new); AsyncSegmentInputStreamImpl async = new AsyncSegmentInputStreamImpl(controller, cf, segment, delegationToken); async.getConnection(); return getEventSegmentReader(async, 0, endOffset, bufferSize); }
static void startPravegaSegmentStoreInstances(final URI zkUri, final URI controllerURI, final int instanceCount) throws ExecutionException { Service segService = Utils.createPravegaSegmentStoreService(zkUri, controllerURI); if (!segService.isRunning()) { segService.start(true); } Futures.getAndHandleExceptions(segService.scaleService(instanceCount), ExecutionException::new); List<URI> segUris = segService.getServiceDetails(); log.info("Pravega Segmentstore service details: {}", segUris); } }
@Override public boolean updateStream(String scopeName, String streamName, StreamConfiguration config) { if (config == null) { config = StreamConfiguration.builder() .scalingPolicy(ScalingPolicy.fixed(1)) .build(); } return Futures.getAndHandleExceptions(controller.updateStream(scopeName, streamName, config), RuntimeException::new); }
@Override public boolean createStream(String scopeName, String streamName, StreamConfiguration config) { NameUtils.validateUserStreamName(streamName); if (config == null) { config = StreamConfiguration.builder() .scalingPolicy(ScalingPolicy.fixed(1)) .build(); } return Futures.getAndHandleExceptions(controller.createStream(scopeName, streamName, config), RuntimeException::new); }