How to use

getScope

method

in

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

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

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

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

/**
 * <code>string scope = 1;</code>
 */
public Builder clearScope() {
 
 scope_ = getDefaultInstance().getScope();
 onChanged();
 return this;
}
/**

@Override
public void pingTransaction(PingTxnRequest request, StreamObserver<PingTxnStatus> responseObserver) {
  log.info("pingTransaction 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),
      delegationToken  -> controllerService.pingTransaction(request.getStreamInfo().getScope(),
          request.getStreamInfo().getStream(),
          request.getTxnId(),
          request.getLease()),
      responseObserver);
}

/**
 * Helper to convert Segment Id into Segment object.
 *
 * @param segment The Segment Id.
 * @return New instance of Segment.
 */
public static final Segment encode(final SegmentId segment) {
  Preconditions.checkNotNull(segment, "segment");
  return new Segment(segment.getStreamInfo().getScope(),
      segment.getStreamInfo().getStream(),
      segment.getSegmentId());
}

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

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

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

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