How to use

getStream

method

in

io.pravega.controller.stream.api.grpc.v1.Controller$StreamInfo

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);
}

@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());
}

@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());
}

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

@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 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 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 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 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 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 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 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 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 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);
}

@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());
  }
}

@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);
}