io.pravega.controller.stream.api.grpc.v1.Controller$StreamInfo.getStream java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 ScheduledThreadPoolExecutor s =new ScheduledThreadPoolExecutor(corePoolSize)
ThreadFactory threadFactory;new ScheduledThreadPoolExecutor(corePoolSize, threadFactory)
String str;new ScheduledThreadPoolExecutor(1, new ThreadFactoryBuilder().setNameFormat(str).build())
Smart code suggestions by Codota
}

public static final Controller.StreamCutRangeResponse createStreamCutRangeResponse(final String scope, final String stream,
                                          final List<SegmentId> segments, String delegationToken) {
  Exceptions.checkNotNullOrEmpty(scope, "scope");
  Exceptions.checkNotNullOrEmpty(stream, "stream");
  Exceptions.checkArgument(segments.stream().allMatch(x -> x.getStreamInfo().getScope().equals(scope) &&
          x.getStreamInfo().getStream().equals(stream)),
      "streamInfo", "stream info does not match segment id", scope, stream, segments);
  return Controller.StreamCutRangeResponse.newBuilder()
      .addAllSegments(segments)
      .setDelegationToken(delegationToken)
      .build();
}

public CompletableFuture<NodeUri> getURI(final SegmentId segment) {
  Preconditions.checkNotNull(segment, "segment");
  return CompletableFuture.completedFuture(
      segmentHelper.getSegmentUri(segment.getStreamInfo().getScope(), segment.getStreamInfo().getStream(),
          segment.getSegmentId(), hostStore)
  );
}

@Override
public void getSegmentsBetween(Controller.StreamCutRange request, StreamObserver<Controller.StreamCutRangeResponse> responseObserver) {
  log.info("getSegmentsBetweenStreamCuts called for stream {} for cuts from {} to {}", request.getStreamInfo(), request.getFromMap(), request.getToMap());
  String scope = request.getStreamInfo().getScope();
  String stream = request.getStreamInfo().getStream();
  authenticateExecuteAndProcessResults(() -> this.authHelper.checkAuthorization(scope + "/" + stream, AuthHandler.Permissions.READ),
      delegationToken -> controllerService.getSegmentsBetweenStreamCuts(request)
          .thenApply(segments -> ModelHelper.createStreamCutRangeResponse(scope, stream,
              segments.stream().map(x -> ModelHelper.createSegmentId(scope, stream, x.segmentId()))
                  .collect(Collectors.toList()), delegationToken)),
      responseObserver);
}

@Override
public void truncateStream(Controller.StreamCut request, StreamObserver<UpdateStreamStatus> responseObserver) {
  RequestTag requestTag = requestTracker.initializeAndTrackRequestTag(requestIdGenerator.get(), "truncateStream",
      request.getStreamInfo().getScope(), request.getStreamInfo().getStream());
  log.info(requestTag.getRequestId(), "truncateStream called for stream {}/{}.",
      request.getStreamInfo().getScope(), request.getStreamInfo().getStream());
  authenticateExecuteAndProcessResults(() -> this.authHelper.checkAuthorization(request.getStreamInfo().getScope() + "/" +
          request.getStreamInfo().getStream(), AuthHandler.Permissions.READ_UPDATE),
      delegationToken -> controllerService.truncateStream(request.getStreamInfo().getScope(),
          request.getStreamInfo().getStream(), ModelHelper.encode(request)), responseObserver, requestTag);
}

@Override
public void abortTransaction(TxnRequest request, StreamObserver<TxnStatus> responseObserver) {
  log.info("abortTransaction called for stream {}/{}, txnId={}.", request.getStreamInfo().getScope(),
      request.getStreamInfo().getStream(), request.getTxnId());
  authenticateExecuteAndProcessResults( () -> this.authHelper.checkAuthorization(request.getStreamInfo().getScope() + "/" +
          request.getStreamInfo().getStream(), AuthHandler.Permissions.READ_UPDATE),
      delegationToken -> controllerService.abortTransaction(request.getStreamInfo().getScope(),
          request.getStreamInfo().getStream(),
          request.getTxnId()),
      responseObserver);
}

@Override
public void commitTransaction(TxnRequest request, StreamObserver<TxnStatus> responseObserver) {
  log.info("commitTransaction called for stream {}/{}, txnId={}.", request.getStreamInfo().getScope(),
      request.getStreamInfo().getStream(), request.getTxnId());
  authenticateExecuteAndProcessResults(() -> this.authHelper.checkAuthorization(request.getStreamInfo().getScope() + "/" +
          request.getStreamInfo().getStream(), AuthHandler.Permissions.READ_UPDATE),
      delegationToken -> controllerService.commitTransaction(request.getStreamInfo().getScope(),
          request.getStreamInfo().getStream(),
          request.getTxnId()),
      responseObserver);
}

@Override
public void getCurrentSegments(StreamInfo request, StreamObserver<SegmentRanges> responseObserver) {
  log.info("getCurrentSegments called for stream {}/{}.", request.getScope(), request.getStream());
  authenticateExecuteAndProcessResults(() -> this.authHelper.checkAuthorizationAndCreateToken(request.getScope() + "/" +
          request.getStream(), AuthHandler.Permissions.READ_UPDATE),
      delegationToken -> controllerService.getCurrentSegments(request.getScope(), request.getStream())
                  .thenApply(segmentRanges -> SegmentRanges.newBuilder()
                                      .addAllSegmentRanges(segmentRanges)
                                      .setDelegationToken(delegationToken)
                                      .build()),
      responseObserver);
}

@Override
public void checkTransactionState(TxnRequest request, StreamObserver<TxnState> responseObserver) {
  log.info("checkTransactionState called for stream {}/{}, txnId={}.", request.getStreamInfo().getScope(),
      request.getStreamInfo().getStream(), request.getTxnId());
  authenticateExecuteAndProcessResults(() -> this.authHelper.checkAuthorization(request.getStreamInfo().getScope() + "/" +
          request.getStreamInfo().getStream(), AuthHandler.Permissions.READ_UPDATE),
      delegationToken -> controllerService.checkTransactionStatus(request.getStreamInfo().getScope(),
          request.getStreamInfo().getStream(),
          request.getTxnId()),
      responseObserver);
}

@Override
public void pingTransaction(PingTxnRequest request,
    StreamObserver<PingTxnStatus> responseObserver) {
  if (request.getStreamInfo().getStream().equals("stream1")) {
    responseObserver.onNext(PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.OK).build());
    responseObserver.onCompleted();
  } else {
    responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
  }
}

@Override
public void getDelegationToken(StreamInfo request, StreamObserver<DelegationToken> responseObserver)  {
  log.info("getDelegationToken called for stream {}/{}.", request.getScope(), request.getStream());
  authenticateExecuteAndProcessResults(() -> this.authHelper.checkAuthorizationAndCreateToken(request.getScope() + "/" +
          request.getStream(), AuthHandler.Permissions.READ_UPDATE),
      delegationToken -> CompletableFuture.completedFuture(Controller.DelegationToken
          .newBuilder()
          .setDelegationToken(delegationToken)
          .build()),
      responseObserver);
}

@Override
public void sealStream(StreamInfo request, StreamObserver<UpdateStreamStatus> responseObserver) {
  RequestTag requestTag = requestTracker.initializeAndTrackRequestTag(requestIdGenerator.get(), "sealStream",
      request.getScope(), request.getStream());
  log.info(requestTag.getRequestId(), "sealStream called for stream {}/{}.",
      request.getScope(), request.getStream());
  authenticateExecuteAndProcessResults(() -> this.authHelper.checkAuthorization(request.getScope() + "/" +
          request.getStream(), AuthHandler.Permissions.READ_UPDATE),
      delegationToken -> controllerService.sealStream(request.getScope(), request.getStream()), responseObserver, requestTag);
}

@Override
public void isStreamCutValid(Controller.StreamCut request, StreamObserver<Controller.StreamCutValidityResponse> responseObserver) {
  log.info("isStreamCutValid called for stream {}/{} streamcut {}.", request.getStreamInfo().getScope(),
      request.getStreamInfo().getStream(), request.getCutMap());
  authenticateExecuteAndProcessResults(() -> this.authHelper.checkAuthorizationAndCreateToken(request.getStreamInfo().getScope() + "/" +
          request.getStreamInfo().getStream(), AuthHandler.Permissions.READ_UPDATE),
      delegationToken -> controllerService.isStreamCutValid(request.getStreamInfo().getScope(),
          request.getStreamInfo().getStream(),
          request.getCutMap())
          .thenApply(bRes -> Controller.StreamCutValidityResponse.newBuilder().setResponse(bRes).build()),
      responseObserver);
}

@Override
public void checkScale(ScaleStatusRequest request, StreamObserver<ScaleStatusResponse> responseObserver) {
  if (request.getStreamInfo().getStream().equals("stream1")) {
    responseObserver.onNext(ScaleStatusResponse.newBuilder()
        .setStatus(ScaleStatusResponse.ScaleStatus.SUCCESS).build());
    responseObserver.onCompleted();
  } else {
    responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
  }
}

@Override
public void getURI(SegmentId request, StreamObserver<NodeUri> responseObserver) {
  log.info("getURI called for segment {}/{}/{}.", request.getStreamInfo().getScope(),
      request.getStreamInfo().getStream(), request.getSegmentId());
  authenticateExecuteAndProcessResults(() -> this.authHelper.checkAuthorization(request.getStreamInfo().getScope() + "/" +
          request.getStreamInfo().getStream(), AuthHandler.Permissions.READ_UPDATE),
      delegationToken -> controllerService.getURI(request),
      responseObserver);
}

/**
 * <code>string stream = 2;</code>
 */
public Builder clearStream() {
 
 stream_ = getDefaultInstance().getStream();
 onChanged();
 return this;
}
/**

@Override
public void checkScale(ScaleStatusRequest request, StreamObserver<ScaleStatusResponse> responseObserver) {
  log.debug("check scale status called for stream {}/{}.", request.getStreamInfo().getScope(),
      request.getStreamInfo().getStream());
  authenticateExecuteAndProcessResults(() -> this.authHelper.checkAuthorization(request.getStreamInfo().getScope() + "/" +
          request.getStreamInfo().getStream(), AuthHandler.Permissions.READ_UPDATE),
      delegationToken -> controllerService.checkScale(request.getStreamInfo().getScope(), request.getStreamInfo().getStream(),
          request.getEpoch()), responseObserver);
}

@Override
public void getURI(SegmentId request, StreamObserver<NodeUri> responseObserver) {
  if (request.getStreamInfo().getStream().equals("stream1")) {
    responseObserver.onNext(NodeUri.newBuilder().setEndpoint("localhost").
        setPort(SERVICE_PORT).build());
    responseObserver.onCompleted();
  } else {
    responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
  }
}

@Test
public void createSuccessorResponse() {
  Controller.SegmentRange segmentRange = createSegmentRange(0.1, 0.5);
  Map<Controller.SegmentRange, List<Long>> inputMap = new HashMap<>(1);
  inputMap.put(segmentRange, Arrays.asList(1L));
  Controller.SuccessorResponse successorResponse = ModelHelper.createSuccessorResponse(inputMap).build();
  Assert.assertEquals(1, successorResponse.getSegmentsCount());
  final SegmentId resultSegmentID = successorResponse.getSegments(0).getSegment().getSegmentId();
  assertEquals("testScope", resultSegmentID.getStreamInfo().getScope());
  assertEquals("testStream", resultSegmentID.getStreamInfo().getStream());
}

@Override
public void deleteStream(StreamInfo request, StreamObserver<DeleteStreamStatus> responseObserver) {
  RequestTag requestTag = requestTracker.initializeAndTrackRequestTag(requestIdGenerator.get(), "deleteStream",
      request.getScope(), request.getStream());
  log.info(requestTag.getRequestId(), "deleteStream called for stream {}/{}.",
      request.getScope(), request.getStream());
  authenticateExecuteAndProcessResults(() -> this.authHelper.checkAuthorization(request.getScope() + "/" +
          request.getStream(), AuthHandler.Permissions.READ_UPDATE),
      delegationToken -> controllerService.deleteStream(request.getScope(), request.getStream()), responseObserver, requestTag);
}

@Test
public void decodeSegmentId() {
  final String streamName = "stream1";
  SegmentId segmentID = ModelHelper.decode(createSegmentId(streamName, 2));
  assertEquals(streamName, segmentID.getStreamInfo().getStream());
  assertEquals("scope", segmentID.getStreamInfo().getScope());
  assertEquals(2, segmentID.getSegmentId());
}

Javadoc

string stream = 2;

Popular methods of Controller$StreamInfo

Popular in Java

Reactive rest calls using spring rest template
getContentResolver (Context)
orElseThrow (Optional)
addToBackStack (FragmentTransaction)
BufferedImage (java.awt.image)
The BufferedImage subclass describes an java.awt.Image with an accessible buffer of image data. All
NumberFormat (java.text)
The abstract base class for all number formats. This class provides the interface for formatting and
Scanner (java.util)
A parser that parses a text string of primitive types and strings with the help of regular expressio
StringTokenizer (java.util)
The string tokenizer class allows an application to break a string into tokens. The tokenization met
ServletException (javax.servlet)
Defines a general exception a servlet can throw when it encounters difficulty.
HttpServlet (javax.servlet.http)
Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site. A sub

How to use getStreammethodin io.pravega.controller.stream.api.grpc.v1.Controller$StreamInfo

Best Java code snippets using io.pravega.controller.stream.api.grpc.v1.Controller$StreamInfo.getStream (Showing top 20 results out of 315)

How to use
getStream
method
in
io.pravega.controller.stream.api.grpc.v1.Controller$StreamInfo