Example 1 with SubscribersResponse
use of io.pravega.controller.stream.api.grpc.v1.Controller.SubscribersResponse in project pravega by pravega.
the class ControllerImplTest method setup.
@Before
public void setup() throws IOException {
// Setup test server generating different success and failure responses.
testServerImpl = new ControllerServiceImplBase() {
@Override
public void listScopes(Controller.ScopesRequest request, StreamObserver<Controller.ScopesResponse> responseObserver) {
if (Strings.isNullOrEmpty(request.getContinuationToken().getToken())) {
List<String> list1 = new LinkedList<>();
list1.add("scope1");
list1.add("scope2");
responseObserver.onNext(Controller.ScopesResponse.newBuilder().addAllScopes(list1).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("myToken").build()).build());
responseObserver.onCompleted();
} else if (request.getContinuationToken().getToken().equals("myToken")) {
List<String> list2 = new LinkedList<>();
list2.add("scope3");
responseObserver.onNext(Controller.ScopesResponse.newBuilder().addAllScopes(list2).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("myToken2").build()).build());
responseObserver.onCompleted();
} else if (request.getContinuationToken().getToken().equals("myToken2")) {
List<String> list3 = new LinkedList<>();
responseObserver.onNext(Controller.ScopesResponse.newBuilder().addAllScopes(list3).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("myToken2").build()).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void checkScopeExists(ScopeInfo request, StreamObserver<Controller.ExistsResponse> responseObserver) {
if (!request.getScope().equals("throwing")) {
responseObserver.onNext(Controller.ExistsResponse.newBuilder().setExists(request.getScope().equals("scope1")).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void checkStreamExists(StreamInfo request, StreamObserver<Controller.ExistsResponse> responseObserver) {
if (!request.getScope().equals("throwing")) {
responseObserver.onNext(Controller.ExistsResponse.newBuilder().setExists(request.getStream().equals("stream1")).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void createStream(StreamConfig request, StreamObserver<CreateStreamStatus> responseObserver) {
if (request.getStreamInfo().getStream().equals("stream1") || request.getStreamInfo().getStream().equals("stream8")) {
responseObserver.onNext(CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream2")) {
responseObserver.onNext(CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream3")) {
responseObserver.onNext(CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.SCOPE_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream4")) {
responseObserver.onNext(CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.STREAM_EXISTS).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream5")) {
responseObserver.onNext(CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.INVALID_STREAM_NAME).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("streamparallel")) {
// Simulating delay in sending response.
Exceptions.handleInterrupted(() -> Thread.sleep(500));
responseObserver.onNext(CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("streamdelayed")) {
// Simulating delay in sending response. This is used for the keepalive test,
// where response time > 30 seconds is required to simulate a failure.
Exceptions.handleInterrupted(() -> Thread.sleep(KEEP_ALIVE_TEST_STREAM_CREATE_DELAY_MILLIS));
responseObserver.onNext(CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("streamretryfailure")) {
responseObserver.onError(Status.UNKNOWN.withDescription("Transport error").asRuntimeException());
} else if (request.getStreamInfo().getStream().equals("streamretrysuccess")) {
if (retryAttempts.incrementAndGet() > 3) {
responseObserver.onNext(CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void getStreamConfiguration(StreamInfo request, StreamObserver<StreamConfig> responseObserver) {
StreamConfiguration cfg = StreamConfiguration.builder().scalingPolicy(ScalingPolicy.fixed(3)).tag("tx").build();
if (request.getStream().equals("stream1")) {
responseObserver.onNext(decode(request.getScope(), request.getStream(), cfg));
responseObserver.onCompleted();
} else if (request.getStream().equals("stream2")) {
responseObserver.onNext(decode(request.getScope(), request.getStream(), cfg.toBuilder().clearTags().build()));
responseObserver.onCompleted();
} else if (request.getStream().equals("stream3")) {
responseObserver.onError(Status.NOT_FOUND.asRuntimeException());
} else if (request.getStream().equals("deadline")) {
// do not send any response.
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void updateStream(StreamConfig request, StreamObserver<UpdateStreamStatus> responseObserver) {
if (request.getStreamInfo().getStream().equals("stream1")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream2")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream3")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.SCOPE_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream4")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.STREAM_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream5")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.UNRECOGNIZED).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void listSubscribers(StreamInfo request, StreamObserver<SubscribersResponse> responseObserver) {
if (request.getStream().equals("stream1")) {
responseObserver.onNext(SubscribersResponse.newBuilder().setStatus(SubscribersResponse.Status.SUCCESS).addSubscribers("sub1").addSubscribers("sub2").addSubscribers("sub3").build());
responseObserver.onCompleted();
} else if (request.getStream().equals("stream2")) {
responseObserver.onNext(SubscribersResponse.newBuilder().setStatus(SubscribersResponse.Status.STREAM_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void createReaderGroup(ReaderGroupConfiguration request, StreamObserver<CreateReaderGroupResponse> responseObserver) {
if (request.getReaderGroupName().equals("rg1")) {
responseObserver.onNext(CreateReaderGroupResponse.newBuilder().setConfig(request).setStatus(CreateReaderGroupResponse.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getReaderGroupName().equals("rg2")) {
responseObserver.onNext(CreateReaderGroupResponse.newBuilder().setConfig(request).setStatus(CreateReaderGroupResponse.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getReaderGroupName().equals("rg3")) {
responseObserver.onNext(CreateReaderGroupResponse.newBuilder().setConfig(request).setStatus(CreateReaderGroupResponse.Status.SCOPE_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getReaderGroupName().equals("rg4")) {
responseObserver.onNext(CreateReaderGroupResponse.newBuilder().setConfig(request).setStatus(CreateReaderGroupResponse.Status.INVALID_RG_NAME).build());
responseObserver.onCompleted();
}
}
@Override
public void updateReaderGroup(ReaderGroupConfiguration request, StreamObserver<UpdateReaderGroupResponse> responseObserver) {
if (request.getReaderGroupName().equals("rg1")) {
responseObserver.onNext(UpdateReaderGroupResponse.newBuilder().setStatus(UpdateReaderGroupResponse.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getReaderGroupName().equals("rg2")) {
responseObserver.onNext(UpdateReaderGroupResponse.newBuilder().setStatus(UpdateReaderGroupResponse.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getReaderGroupName().equals("rg3")) {
responseObserver.onNext(UpdateReaderGroupResponse.newBuilder().setStatus(UpdateReaderGroupResponse.Status.RG_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getReaderGroupName().equals("rg4")) {
responseObserver.onNext(UpdateReaderGroupResponse.newBuilder().setStatus(UpdateReaderGroupResponse.Status.INVALID_CONFIG).build());
responseObserver.onCompleted();
}
}
@Override
public void deleteReaderGroup(ReaderGroupInfo request, StreamObserver<DeleteReaderGroupStatus> responseObserver) {
if (request.getReaderGroup().equals("rg1")) {
responseObserver.onNext(DeleteReaderGroupStatus.newBuilder().setStatus(DeleteReaderGroupStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getReaderGroup().equals("rg2")) {
responseObserver.onNext(DeleteReaderGroupStatus.newBuilder().setStatus(DeleteReaderGroupStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getReaderGroup().equals("rg3")) {
responseObserver.onNext(DeleteReaderGroupStatus.newBuilder().setStatus(DeleteReaderGroupStatus.Status.RG_NOT_FOUND).build());
responseObserver.onCompleted();
}
}
@Override
public void getReaderGroupConfig(ReaderGroupInfo request, StreamObserver<ReaderGroupConfigResponse> responseObserver) {
final Segment seg0 = new Segment("scope1", "stream1", 0L);
final Segment seg1 = new Segment("scope1", "stream1", 1L);
ImmutableMap<Segment, Long> startStreamCut = ImmutableMap.of(seg0, 10L, seg1, 10L);
Map<Stream, StreamCut> startSC = ImmutableMap.of(Stream.of("scope1", "stream1"), new StreamCutImpl(Stream.of("scope1", "stream1"), startStreamCut));
ImmutableMap<Segment, Long> endStreamCut = ImmutableMap.of(seg0, 200L, seg1, 300L);
Map<Stream, StreamCut> endSC = ImmutableMap.of(Stream.of("scope1", "stream1"), new StreamCutImpl(Stream.of("scope1", "stream1"), endStreamCut));
ReaderGroupConfig rgConfig = ReaderGroupConfig.builder().automaticCheckpointIntervalMillis(30000L).groupRefreshTimeMillis(20000L).maxOutstandingCheckpointRequest(2).retentionType(ReaderGroupConfig.StreamDataRetention.AUTOMATIC_RELEASE_AT_LAST_CHECKPOINT).startingStreamCuts(startSC).endingStreamCuts(endSC).build();
rgConfig = ReaderGroupConfig.cloneConfig(rgConfig, UUID.randomUUID(), 0L);
if (request.getReaderGroup().equals("rg1")) {
responseObserver.onNext(ReaderGroupConfigResponse.newBuilder().setStatus(ReaderGroupConfigResponse.Status.SUCCESS).setConfig(decode("scope1", "rg1", rgConfig)).build());
responseObserver.onCompleted();
} else if (request.getReaderGroup().equals("rg2")) {
responseObserver.onNext(ReaderGroupConfigResponse.newBuilder().setStatus(ReaderGroupConfigResponse.Status.FAILURE).setConfig(ReaderGroupConfiguration.getDefaultInstance()).build());
responseObserver.onCompleted();
} else if (request.getReaderGroup().equals("rg3")) {
responseObserver.onNext(ReaderGroupConfigResponse.newBuilder().setStatus(ReaderGroupConfigResponse.Status.RG_NOT_FOUND).setConfig(ReaderGroupConfiguration.getDefaultInstance()).build());
responseObserver.onCompleted();
}
}
@Override
public void updateSubscriberStreamCut(SubscriberStreamCut request, StreamObserver<UpdateSubscriberStatus> responseObserver) {
if (request.getStreamCut().getStreamInfo().getStream().equals("stream1")) {
responseObserver.onNext(UpdateSubscriberStatus.newBuilder().setStatus(UpdateSubscriberStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getStreamCut().getStreamInfo().getStream().equals("stream2")) {
responseObserver.onNext(UpdateSubscriberStatus.newBuilder().setStatus(UpdateSubscriberStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getStreamCut().getStreamInfo().getStream().equals("stream3")) {
responseObserver.onNext(UpdateSubscriberStatus.newBuilder().setStatus(UpdateSubscriberStatus.Status.STREAM_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStreamCut().getStreamInfo().getStream().equals("stream4")) {
responseObserver.onNext(UpdateSubscriberStatus.newBuilder().setStatus(UpdateSubscriberStatus.Status.UNRECOGNIZED).build());
responseObserver.onCompleted();
} else if (request.getStreamCut().getStreamInfo().getStream().equals("stream5")) {
responseObserver.onNext(UpdateSubscriberStatus.newBuilder().setStatus(UpdateSubscriberStatus.Status.STREAM_CUT_NOT_VALID).build());
responseObserver.onCompleted();
} else if (request.getStreamCut().getStreamInfo().getStream().equals("stream6")) {
responseObserver.onNext(UpdateSubscriberStatus.newBuilder().setStatus(UpdateSubscriberStatus.Status.SUBSCRIBER_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStreamCut().getStreamInfo().getStream().equals("stream7")) {
responseObserver.onNext(UpdateSubscriberStatus.newBuilder().setStatus(UpdateSubscriberStatus.Status.GENERATION_MISMATCH).build());
responseObserver.onCompleted();
} else if (request.getStreamCut().getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void truncateStream(Controller.StreamCut request, StreamObserver<UpdateStreamStatus> responseObserver) {
if (request.getStreamInfo().getStream().equals("stream1")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream2")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream3")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.SCOPE_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream4")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.STREAM_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream5")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.UNRECOGNIZED).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void sealStream(StreamInfo request, StreamObserver<UpdateStreamStatus> responseObserver) {
if (request.getStream().equals("stream1")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("stream2")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("stream3")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.SCOPE_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("stream4")) {
responseObserver.onNext(UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.STREAM_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void deleteStream(StreamInfo request, StreamObserver<DeleteStreamStatus> responseObserver) {
if (request.getStream().equals("stream1")) {
responseObserver.onNext(DeleteStreamStatus.newBuilder().setStatus(DeleteStreamStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("stream2")) {
responseObserver.onNext(DeleteStreamStatus.newBuilder().setStatus(DeleteStreamStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("stream3")) {
responseObserver.onNext(DeleteStreamStatus.newBuilder().setStatus(DeleteStreamStatus.Status.STREAM_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("stream4")) {
responseObserver.onNext(DeleteStreamStatus.newBuilder().setStatus(DeleteStreamStatus.Status.STREAM_NOT_SEALED).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void getCurrentSegments(StreamInfo request, StreamObserver<SegmentRanges> responseObserver) {
if (request.getStream().equals("stream1")) {
responseObserver.onNext(SegmentRanges.newBuilder().addSegmentRanges(ModelHelper.createSegmentRange("scope1", "stream1", 6, 0.0, 0.4)).addSegmentRanges(ModelHelper.createSegmentRange("scope1", "stream1", 7, 0.4, 1.0)).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("stream8")) {
responseObserver.onNext(SegmentRanges.newBuilder().addSegmentRanges(ModelHelper.createSegmentRange("scope1", "stream8", 9, 0.0, 0.5)).addSegmentRanges(ModelHelper.createSegmentRange("scope1", "stream8", 10, 0.5, 1.0)).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("streamparallel")) {
Exceptions.handleInterrupted(() -> Thread.sleep(500));
responseObserver.onNext(SegmentRanges.newBuilder().addSegmentRanges(ModelHelper.createSegmentRange("scope1", "streamparallel", 0, 0.0, 0.4)).addSegmentRanges(ModelHelper.createSegmentRange("scope1", "streamparallel", 1, 0.4, 1.0)).build());
responseObserver.onCompleted();
} else if (request.getStream().equals("deadline")) {
// dont send any response
} else if (request.getStream().equals("sealedStream")) {
// empty response if the Stream is sealed.
responseObserver.onNext(SegmentRanges.newBuilder().build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void getEpochSegments(GetEpochSegmentsRequest request, StreamObserver<io.pravega.controller.stream.api.grpc.v1.Controller.SegmentRanges> responseObserver) {
if (request.getStreamInfo().getStream().equals("stream1")) {
responseObserver.onNext(SegmentRanges.newBuilder().addSegmentRanges(ModelHelper.createSegmentRange("scope1", "stream1", 6, 0.0, 0.4)).addSegmentRanges(ModelHelper.createSegmentRange("scope1", "stream1", 7, 0.4, 1.0)).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void getSegments(GetSegmentsRequest request, StreamObserver<SegmentsAtTime> responseObserver) {
if (request.getStreamInfo().getStream().equals("stream1")) {
SegmentId segment1 = ModelHelper.createSegmentId("scope1", "stream1", 0);
SegmentId segment2 = ModelHelper.createSegmentId("scope1", "stream1", 1);
responseObserver.onNext(SegmentsAtTime.newBuilder().addSegments(SegmentLocation.newBuilder().setSegmentId(segment1).setOffset(10).build()).addSegments(SegmentLocation.newBuilder().setSegmentId(segment2).setOffset(20).build()).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream8")) {
SegmentId segment1 = ModelHelper.createSegmentId("scope1", "stream8", 0);
SegmentId segment2 = ModelHelper.createSegmentId("scope1", "stream8", 1);
SegmentId segment3 = ModelHelper.createSegmentId("scope1", "stream8", 2);
responseObserver.onNext(SegmentsAtTime.newBuilder().addSegments(SegmentLocation.newBuilder().setSegmentId(segment1).setOffset(10).build()).addSegments(SegmentLocation.newBuilder().setSegmentId(segment2).setOffset(20).build()).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void getSegmentsImmediatelyFollowing(SegmentId request, StreamObserver<SuccessorResponse> responseObserver) {
if (request.getStreamInfo().getStream().equals("stream1")) {
Map<SegmentId, Pair<Double, Double>> result = new HashMap<>();
if (request.getSegmentId() == 0) {
result.put(ModelHelper.createSegmentId("scope1", "stream1", 2), Pair.of(0.0, 0.25));
result.put(ModelHelper.createSegmentId("scope1", "stream1", 3), Pair.of(0.25, 0.5));
} else if (request.getSegmentId() == 1) {
result.put(ModelHelper.createSegmentId("scope1", "stream1", 4), Pair.of(0.5, 0.75));
result.put(ModelHelper.createSegmentId("scope1", "stream1", 5), Pair.of(0.75, 1.0));
} else if (request.getSegmentId() == 2 || request.getSegmentId() == 3) {
result.put(ModelHelper.createSegmentId("scope1", "stream1", 6), Pair.of(0.0, 0.5));
} else if (request.getSegmentId() == 4 || request.getSegmentId() == 5) {
result.put(ModelHelper.createSegmentId("scope1", "stream1", 7), Pair.of(0.5, 0.25));
}
val builder = SuccessorResponse.newBuilder();
for (Entry<SegmentId, Pair<Double, Double>> entry : result.entrySet()) {
builder.addSegments(SuccessorResponse.SegmentEntry.newBuilder().setSegment(Controller.SegmentRange.newBuilder().setSegmentId(entry.getKey()).setMinKey(entry.getValue().getLeft()).setMaxKey(entry.getValue().getRight()).build()).addValue(10 * entry.getKey().getSegmentId()).build());
}
responseObserver.onNext(builder.build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream8")) {
Map<SegmentId, Pair<Double, Double>> result = new HashMap<>();
if (request.getSegmentId() == 0) {
result.put(ModelHelper.createSegmentId("scope1", "stream8", 3), Pair.of(0.0, 0.2));
result.put(ModelHelper.createSegmentId("scope1", "stream8", 4), Pair.of(0.2, 0.33));
} else if (request.getSegmentId() == 1) {
result.put(ModelHelper.createSegmentId("scope1", "stream8", 5), Pair.of(0.33, 0.5));
result.put(ModelHelper.createSegmentId("scope1", "stream8", 6), Pair.of(0.5, 0.66));
} else if (request.getSegmentId() == 2) {
result.put(ModelHelper.createSegmentId("scope1", "stream8", 7), Pair.of(0.66, 0.8));
result.put(ModelHelper.createSegmentId("scope1", "stream8", 8), Pair.of(0.8, 1.0));
} else if (request.getSegmentId() == 3 || request.getSegmentId() == 4 || request.getSegmentId() == 5) {
result.put(ModelHelper.createSegmentId("scope1", "stream8", 9), Pair.of(0.0, 0.5));
} else if (request.getSegmentId() == 6 || request.getSegmentId() == 7 || request.getSegmentId() == 8) {
result.put(ModelHelper.createSegmentId("scope1", "stream8", 10), Pair.of(0.5, 1.0));
}
val builder = SuccessorResponse.newBuilder();
for (Entry<SegmentId, Pair<Double, Double>> entry : result.entrySet()) {
builder.addSegments(SuccessorResponse.SegmentEntry.newBuilder().setSegment(Controller.SegmentRange.newBuilder().setSegmentId(entry.getKey()).setMinKey(entry.getValue().getLeft()).setMaxKey(entry.getValue().getRight()).build()).addValue(10 * entry.getKey().getSegmentId()).build());
}
responseObserver.onNext(builder.build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void getSegmentsBetween(Controller.StreamCutRange request, StreamObserver<Controller.StreamCutRangeResponse> responseObserver) {
if (request.getStreamInfo().getStream().equals("stream1")) {
SegmentId segment1 = ModelHelper.createSegmentId("scope1", "stream1", 0L);
SegmentId segment2 = ModelHelper.createSegmentId("scope1", "stream1", 1L);
responseObserver.onNext(Controller.StreamCutRangeResponse.newBuilder().addSegments(segment1).addSegments(segment2).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void scale(ScaleRequest request, StreamObserver<ScaleResponse> responseObserver) {
if (request.getStreamInfo().getStream().equals("stream1")) {
responseObserver.onNext(ScaleResponse.newBuilder().setStatus(ScaleResponse.ScaleStreamStatus.STARTED).addSegments(ModelHelper.createSegmentRange("scope1", "stream1", 0, 0.0, 0.5)).addSegments(ModelHelper.createSegmentRange("scope1", "stream1", 1, 0.5, 1.0)).setEpoch(0).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send response
} 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 if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@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 if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void isSegmentValid(SegmentId request, StreamObserver<SegmentValidityResponse> responseObserver) {
if (request.getStreamInfo().getStream().equals("stream1")) {
responseObserver.onNext(SegmentValidityResponse.newBuilder().setResponse(true).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream2")) {
responseObserver.onNext(SegmentValidityResponse.newBuilder().setResponse(false).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void createTransaction(CreateTxnRequest request, StreamObserver<Controller.CreateTxnResponse> responseObserver) {
Controller.CreateTxnResponse.Builder builder = Controller.CreateTxnResponse.newBuilder();
if (request.getStreamInfo().getStream().equals("stream1")) {
builder.setTxnId(TxnId.newBuilder().setHighBits(11L).setLowBits(22L).build());
builder.addActiveSegments(ModelHelper.createSegmentRange("scope1", "stream1", 0, 0.0, 0.5));
builder.addActiveSegments(ModelHelper.createSegmentRange("scope1", "stream1", 1, 0.5, 1.0));
responseObserver.onNext(builder.build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream2")) {
builder.addActiveSegments(ModelHelper.createSegmentRange("scope1", "stream2", 0, 0.0, 1.0));
builder.setTxnId(TxnId.newBuilder().setHighBits(33L).setLowBits(44L).build());
responseObserver.onNext(builder.build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void commitTransaction(TxnRequest request, StreamObserver<Controller.TxnStatus> responseObserver) {
lastRequest.set(request);
if (request.getStreamInfo().getStream().equals("stream1")) {
responseObserver.onNext(Controller.TxnStatus.newBuilder().setStatus(Controller.TxnStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream2")) {
responseObserver.onNext(Controller.TxnStatus.newBuilder().setStatus(Controller.TxnStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream3")) {
responseObserver.onNext(Controller.TxnStatus.newBuilder().setStatus(Controller.TxnStatus.Status.STREAM_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream4")) {
responseObserver.onNext(Controller.TxnStatus.newBuilder().setStatus(Controller.TxnStatus.Status.TRANSACTION_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void abortTransaction(TxnRequest request, StreamObserver<Controller.TxnStatus> responseObserver) {
if (request.getStreamInfo().getStream().equals("stream1")) {
responseObserver.onNext(Controller.TxnStatus.newBuilder().setStatus(Controller.TxnStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream2")) {
responseObserver.onNext(Controller.TxnStatus.newBuilder().setStatus(Controller.TxnStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream3")) {
responseObserver.onNext(Controller.TxnStatus.newBuilder().setStatus(Controller.TxnStatus.Status.STREAM_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream4")) {
responseObserver.onNext(Controller.TxnStatus.newBuilder().setStatus(Controller.TxnStatus.Status.TRANSACTION_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void pingTransaction(PingTxnRequest request, StreamObserver<PingTxnStatus> responseObserver) {
switch(request.getStreamInfo().getStream()) {
case "stream1":
responseObserver.onNext(PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.OK).build());
responseObserver.onCompleted();
break;
case "stream2":
responseObserver.onNext(PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.LEASE_TOO_LARGE).build());
responseObserver.onCompleted();
break;
case "stream3":
responseObserver.onNext(PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.MAX_EXECUTION_TIME_EXCEEDED).build());
responseObserver.onCompleted();
break;
case "stream4":
responseObserver.onNext(PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.DISCONNECTED).build());
responseObserver.onCompleted();
break;
case "stream5":
responseObserver.onNext(PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.COMMITTED).build());
responseObserver.onCompleted();
break;
case "stream6":
responseObserver.onNext(PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.ABORTED).build());
responseObserver.onCompleted();
break;
case "stream8":
responseObserver.onNext(PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.UNKNOWN).build());
responseObserver.onCompleted();
break;
case "deadline":
break;
default:
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
break;
}
}
@Override
public void checkTransactionState(TxnRequest request, StreamObserver<TxnState> responseObserver) {
if (request.getStreamInfo().getStream().equals("stream1")) {
responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.OPEN).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream2")) {
responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.UNKNOWN).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream3")) {
responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.COMMITTING).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream4")) {
responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.COMMITTED).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream5")) {
responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.ABORTING).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("stream6")) {
responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.ABORTED).build());
responseObserver.onCompleted();
} else if (request.getStreamInfo().getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void createScope(ScopeInfo request, StreamObserver<CreateScopeStatus> responseObserver) {
if (request.getScope().equals("scope1")) {
responseObserver.onNext(CreateScopeStatus.newBuilder().setStatus(CreateScopeStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getScope().equals("scope2")) {
responseObserver.onNext(CreateScopeStatus.newBuilder().setStatus(CreateScopeStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getScope().equals("scope3")) {
responseObserver.onNext(CreateScopeStatus.newBuilder().setStatus(CreateScopeStatus.Status.INVALID_SCOPE_NAME).build());
responseObserver.onCompleted();
} else if (request.getScope().equals("scope4")) {
responseObserver.onNext(CreateScopeStatus.newBuilder().setStatus(CreateScopeStatus.Status.SCOPE_EXISTS).build());
responseObserver.onCompleted();
} else if (request.getScope().equals("deadline")) {
// dont send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void getDelegationToken(StreamInfo request, StreamObserver<Controller.DelegationToken> responseObserver) {
if (request.getStream().equals("deadline")) {
// dont send any response
} else {
responseObserver.onNext(Controller.DelegationToken.newBuilder().setDelegationToken("token").build());
responseObserver.onCompleted();
}
}
@Override
public void deleteScope(ScopeInfo request, StreamObserver<DeleteScopeStatus> responseObserver) {
if (request.getScope().equals("scope1")) {
responseObserver.onNext(DeleteScopeStatus.newBuilder().setStatus(DeleteScopeStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getScope().equals("scope2")) {
responseObserver.onNext(DeleteScopeStatus.newBuilder().setStatus(DeleteScopeStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getScope().equals("scope3")) {
responseObserver.onNext(DeleteScopeStatus.newBuilder().setStatus(DeleteScopeStatus.Status.SCOPE_NOT_EMPTY).build());
responseObserver.onCompleted();
} else if (request.getScope().equals("scope4")) {
responseObserver.onNext(DeleteScopeStatus.newBuilder().setStatus(DeleteScopeStatus.Status.SCOPE_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getScope().equals("deadline")) {
// don't send any response
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void deleteScopeRecursive(ScopeInfo request, StreamObserver<Controller.DeleteScopeStatus> responseObserver) {
if (request.getScope().equals("scope1")) {
responseObserver.onNext(Controller.DeleteScopeStatus.newBuilder().setStatus(Controller.DeleteScopeStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getScope().equals("scope2")) {
responseObserver.onNext(Controller.DeleteScopeStatus.newBuilder().setStatus(Controller.DeleteScopeStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getScope().equals("scope3")) {
responseObserver.onNext(Controller.DeleteScopeStatus.newBuilder().setStatus(Controller.DeleteScopeStatus.Status.SCOPE_NOT_FOUND).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void listStreamsInScope(Controller.StreamsInScopeRequest request, StreamObserver<Controller.StreamsInScopeResponse> responseObserver) {
if (request.getScope().getScope().equals(NON_EXISTENT)) {
responseObserver.onNext(Controller.StreamsInScopeResponse.newBuilder().setStatus(Controller.StreamsInScopeResponse.Status.SCOPE_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getScope().getScope().equals("deadline")) {
// dont send any response
} else if (request.getScope().getScope().equals(FAILING)) {
responseObserver.onNext(Controller.StreamsInScopeResponse.newBuilder().setStatus(Controller.StreamsInScopeResponse.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (Strings.isNullOrEmpty(request.getContinuationToken().getToken())) {
List<StreamInfo> list1 = new LinkedList<>();
list1.add(StreamInfo.newBuilder().setScope(request.getScope().getScope()).setStream("stream1").build());
list1.add(StreamInfo.newBuilder().setScope(request.getScope().getScope()).setStream("stream2").build());
responseObserver.onNext(Controller.StreamsInScopeResponse.newBuilder().setStatus(Controller.StreamsInScopeResponse.Status.SUCCESS).addAllStreams(list1).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("myToken").build()).build());
responseObserver.onCompleted();
} else if (request.getContinuationToken().getToken().equals("myToken")) {
List<StreamInfo> list2 = new LinkedList<>();
list2.add(StreamInfo.newBuilder().setScope(request.getScope().getScope()).setStream("stream3").build());
responseObserver.onNext(Controller.StreamsInScopeResponse.newBuilder().addAllStreams(list2).setStatus(Controller.StreamsInScopeResponse.Status.SUCCESS).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("myToken2").build()).build());
responseObserver.onCompleted();
} else if (request.getContinuationToken().getToken().equals("myToken2")) {
List<StreamInfo> list3 = new LinkedList<>();
responseObserver.onNext(Controller.StreamsInScopeResponse.newBuilder().addAllStreams(list3).setStatus(Controller.StreamsInScopeResponse.Status.SUCCESS).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("").build()).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void listStreamsInScopeForTag(Controller.StreamsInScopeWithTagRequest request, StreamObserver<Controller.StreamsInScopeResponse> responseObserver) {
if (request.getScope().getScope().equals(NON_EXISTENT)) {
responseObserver.onNext(Controller.StreamsInScopeResponse.newBuilder().setStatus(Controller.StreamsInScopeResponse.Status.SCOPE_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getScope().getScope().equals("deadline")) {
// dont send any response
} else if (request.getScope().getScope().equals(FAILING)) {
responseObserver.onNext(Controller.StreamsInScopeResponse.newBuilder().setStatus(Controller.StreamsInScopeResponse.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (Strings.isNullOrEmpty(request.getContinuationToken().getToken())) {
List<StreamInfo> list1 = new LinkedList<>();
list1.add(StreamInfo.newBuilder().setScope(request.getScope().getScope()).setStream("stream1").build());
list1.add(StreamInfo.newBuilder().setScope(request.getScope().getScope()).setStream("stream2").build());
responseObserver.onNext(Controller.StreamsInScopeResponse.newBuilder().setStatus(Controller.StreamsInScopeResponse.Status.SUCCESS).addAllStreams(list1).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("chunk0").build()).build());
responseObserver.onCompleted();
} else if (request.getContinuationToken().getToken().equals("chunk0")) {
List<StreamInfo> list2 = new LinkedList<>();
list2.add(StreamInfo.newBuilder().setScope(request.getScope().getScope()).setStream("stream3").build());
responseObserver.onNext(Controller.StreamsInScopeResponse.newBuilder().addAllStreams(list2).setStatus(Controller.StreamsInScopeResponse.Status.SUCCESS).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("chunk1").build()).build());
responseObserver.onCompleted();
} else if (request.getContinuationToken().getToken().equals("chunk1")) {
List<StreamInfo> list3 = new LinkedList<>();
responseObserver.onNext(Controller.StreamsInScopeResponse.newBuilder().addAllStreams(list3).setStatus(Controller.StreamsInScopeResponse.Status.SUCCESS).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("chunk24").build()).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void isStreamCutValid(Controller.StreamCut request, StreamObserver<Controller.StreamCutValidityResponse> responseObserver) {
if (request.getStreamInfo().getStream().equals("deadline")) {
// do nothing
} else {
responseObserver.onNext(Controller.StreamCutValidityResponse.newBuilder().setResponse(true).build());
responseObserver.onCompleted();
}
}
@Override
public void removeWriter(Controller.RemoveWriterRequest request, StreamObserver<Controller.RemoveWriterResponse> responseObserver) {
if (request.getStream().getStream().equals("deadline")) {
// do nothing
} else {
responseObserver.onNext(Controller.RemoveWriterResponse.newBuilder().setResult(Controller.RemoveWriterResponse.Status.SUCCESS).build());
responseObserver.onCompleted();
}
}
@Override
public void noteTimestampFromWriter(Controller.TimestampFromWriter request, StreamObserver<Controller.TimestampResponse> responseObserver) {
if (request.getWriter().equals("deadline")) {
// do nothing
} else {
responseObserver.onNext(Controller.TimestampResponse.newBuilder().setResult(Controller.TimestampResponse.Status.SUCCESS).build());
responseObserver.onCompleted();
}
}
@Override
public void createKeyValueTable(KeyValueTableConfig request, StreamObserver<CreateKeyValueTableStatus> responseObserver) {
if (request.getKvtName().equals("kvtable1")) {
responseObserver.onNext(CreateKeyValueTableStatus.newBuilder().setStatus(CreateKeyValueTableStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getKvtName().equals("kvtable2")) {
responseObserver.onNext(CreateKeyValueTableStatus.newBuilder().setStatus(CreateKeyValueTableStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getKvtName().equals("kvtable3")) {
responseObserver.onNext(CreateKeyValueTableStatus.newBuilder().setStatus(CreateKeyValueTableStatus.Status.SCOPE_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getKvtName().equals("kvtable4")) {
responseObserver.onNext(CreateKeyValueTableStatus.newBuilder().setStatus(CreateKeyValueTableStatus.Status.TABLE_EXISTS).build());
responseObserver.onCompleted();
} else if (request.getKvtName().equals("kvtable5")) {
responseObserver.onNext(CreateKeyValueTableStatus.newBuilder().setStatus(CreateKeyValueTableStatus.Status.INVALID_TABLE_NAME).build());
responseObserver.onCompleted();
}
}
@Override
public void getCurrentSegmentsKeyValueTable(Controller.KeyValueTableInfo request, StreamObserver<SegmentRanges> responseObserver) {
if (request.getKvtName().equals("kvtable1")) {
responseObserver.onNext(SegmentRanges.newBuilder().addSegmentRanges(ModelHelper.createSegmentRange("scope1", "kvtable1", 4, 0.0, 0.4)).addSegmentRanges(ModelHelper.createSegmentRange("scope1", "kvtable1", 5, 0.4, 1.0)).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void listKeyValueTablesInScope(Controller.KVTablesInScopeRequest request, StreamObserver<Controller.KVTablesInScopeResponse> responseObserver) {
if (request.getScope().getScope().equals(NON_EXISTENT)) {
responseObserver.onNext(Controller.KVTablesInScopeResponse.newBuilder().setStatus(Controller.KVTablesInScopeResponse.Status.SCOPE_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getScope().getScope().equals(FAILING)) {
responseObserver.onNext(Controller.KVTablesInScopeResponse.newBuilder().setStatus(Controller.KVTablesInScopeResponse.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (Strings.isNullOrEmpty(request.getContinuationToken().getToken())) {
List<KeyValueTableInfo> list1 = new LinkedList<>();
list1.add(KeyValueTableInfo.newBuilder().setScope(request.getScope().getScope()).setKvtName("kvtable1").build());
list1.add(KeyValueTableInfo.newBuilder().setScope(request.getScope().getScope()).setKvtName("kvtable2").build());
responseObserver.onNext(Controller.KVTablesInScopeResponse.newBuilder().setStatus(Controller.KVTablesInScopeResponse.Status.SUCCESS).addAllKvtables(list1).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("myToken").build()).build());
responseObserver.onCompleted();
} else if (request.getContinuationToken().getToken().equals("myToken")) {
List<KeyValueTableInfo> list2 = new LinkedList<>();
list2.add(KeyValueTableInfo.newBuilder().setScope(request.getScope().getScope()).setKvtName("kvtable3").build());
responseObserver.onNext(Controller.KVTablesInScopeResponse.newBuilder().addAllKvtables(list2).setStatus(Controller.KVTablesInScopeResponse.Status.SUCCESS).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("myToken2").build()).build());
responseObserver.onCompleted();
} else if (request.getContinuationToken().getToken().equals("myToken2")) {
List<KeyValueTableInfo> list3 = new LinkedList<>();
responseObserver.onNext(Controller.KVTablesInScopeResponse.newBuilder().addAllKvtables(list3).setStatus(Controller.KVTablesInScopeResponse.Status.SUCCESS).setContinuationToken(Controller.ContinuationToken.newBuilder().setToken("").build()).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void getKeyValueTableConfiguration(KeyValueTableInfo request, StreamObserver<KeyValueTableConfigResponse> responseObserver) {
KeyValueTableConfiguration config = KeyValueTableConfiguration.builder().partitionCount(3).primaryKeyLength(Integer.BYTES).secondaryKeyLength(Long.BYTES).build();
if (request.getKvtName().equals("kvtable")) {
responseObserver.onNext(KeyValueTableConfigResponse.newBuilder().setConfig(ModelHelper.decode(request.getScope(), request.getKvtName(), config)).setStatus(KeyValueTableConfigResponse.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getKvtName().equals(NON_EXISTENT)) {
responseObserver.onNext(KeyValueTableConfigResponse.newBuilder().setStatus(KeyValueTableConfigResponse.Status.TABLE_NOT_FOUND).build());
responseObserver.onCompleted();
} else if (request.getKvtName().equals(FAILING)) {
responseObserver.onNext(KeyValueTableConfigResponse.newBuilder().setStatus(KeyValueTableConfigResponse.Status.FAILURE).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
@Override
public void deleteKeyValueTable(KeyValueTableInfo request, StreamObserver<DeleteKVTableStatus> responseObserver) {
if (request.getKvtName().equals("kvtable1")) {
responseObserver.onNext(DeleteKVTableStatus.newBuilder().setStatus(DeleteKVTableStatus.Status.SUCCESS).build());
responseObserver.onCompleted();
} else if (request.getKvtName().equals("kvtable2")) {
responseObserver.onNext(DeleteKVTableStatus.newBuilder().setStatus(DeleteKVTableStatus.Status.FAILURE).build());
responseObserver.onCompleted();
} else if (request.getKvtName().equals("kvtable3")) {
responseObserver.onNext(DeleteKVTableStatus.newBuilder().setStatus(DeleteKVTableStatus.Status.TABLE_NOT_FOUND).build());
responseObserver.onCompleted();
} else {
responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
}
}
};
serverPort = TestUtils.getAvailableListenPort();
serverBuilder = NettyServerBuilder.forPort(serverPort).addService(testServerImpl);
if (testSecure) {
serverBuilder = serverBuilder.useTransportSecurity(new File(SecurityConfigDefaults.TLS_SERVER_CERT_PATH), new File(SecurityConfigDefaults.TLS_SERVER_PRIVATE_KEY_PATH));
}
testGRPCServer = serverBuilder.build().start();
executor = ExecutorServiceHelpers.newScheduledThreadPool(1, "test");
controllerClient = new ControllerImpl(ControllerImplConfig.builder().clientConfig(ClientConfig.builder().controllerURI(URI.create((testSecure ? "tls://" : "tcp://") + "localhost:" + serverPort)).credentials(new DefaultCredentials("1111_aaaa", "admin")).trustStore(SecurityConfigDefaults.TLS_CA_CERT_PATH).build()).retryAttempts(1).build(), executor);
}
Also used :
ScaleStatusRequest(io.pravega.controller.stream.api.grpc.v1.Controller.ScaleStatusRequest)
DeleteKVTableStatus(io.pravega.controller.stream.api.grpc.v1.Controller.DeleteKVTableStatus)
CreateReaderGroupResponse(io.pravega.controller.stream.api.grpc.v1.Controller.CreateReaderGroupResponse)
SuccessorResponse(io.pravega.controller.stream.api.grpc.v1.Controller.SuccessorResponse)
ScaleRequest(io.pravega.controller.stream.api.grpc.v1.Controller.ScaleRequest)
ReaderGroupConfig(io.pravega.client.stream.ReaderGroupConfig)
lombok.val(lombok.val)
KeyValueTableInfo(io.pravega.controller.stream.api.grpc.v1.Controller.KeyValueTableInfo)
KeyValueTableConfig(io.pravega.controller.stream.api.grpc.v1.Controller.KeyValueTableConfig)
ScaleStatusResponse(io.pravega.controller.stream.api.grpc.v1.Controller.ScaleStatusResponse)
PingTxnRequest(io.pravega.controller.stream.api.grpc.v1.Controller.PingTxnRequest)
TxnState(io.pravega.controller.stream.api.grpc.v1.Controller.TxnState)
CreateTxnRequest(io.pravega.controller.stream.api.grpc.v1.Controller.CreateTxnRequest)
Map(java.util.Map)
ImmutableMap(com.google.common.collect.ImmutableMap)
HashMap(java.util.HashMap)
SegmentsAtTime(io.pravega.controller.stream.api.grpc.v1.Controller.SegmentsAtTime)
DeleteReaderGroupStatus(io.pravega.controller.stream.api.grpc.v1.Controller.DeleteReaderGroupStatus)
ReaderGroupConfiguration(io.pravega.controller.stream.api.grpc.v1.Controller.ReaderGroupConfiguration)
PingTxnStatus(io.pravega.controller.stream.api.grpc.v1.Controller.PingTxnStatus)
Entry(java.util.Map.Entry)
UpdateReaderGroupResponse(io.pravega.controller.stream.api.grpc.v1.Controller.UpdateReaderGroupResponse)
SubscribersResponse(io.pravega.controller.stream.api.grpc.v1.Controller.SubscribersResponse)
Controller(io.pravega.controller.stream.api.grpc.v1.Controller)
DeleteScopeStatus(io.pravega.controller.stream.api.grpc.v1.Controller.DeleteScopeStatus)
DeleteStreamStatus(io.pravega.controller.stream.api.grpc.v1.Controller.DeleteStreamStatus)
UpdateSubscriberStatus(io.pravega.controller.stream.api.grpc.v1.Controller.UpdateSubscriberStatus)
HashMap(java.util.HashMap)
ReaderGroupConfigResponse(io.pravega.controller.stream.api.grpc.v1.Controller.ReaderGroupConfigResponse)
NettyServerBuilder(io.grpc.netty.shaded.io.grpc.netty.NettyServerBuilder)
NettyChannelBuilder(io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder)
PingTxnRequest(io.pravega.controller.stream.api.grpc.v1.Controller.PingTxnRequest)
CreateTxnRequest(io.pravega.controller.stream.api.grpc.v1.Controller.CreateTxnRequest)
TxnRequest(io.pravega.controller.stream.api.grpc.v1.Controller.TxnRequest)
UpdateStreamStatus(io.pravega.controller.stream.api.grpc.v1.Controller.UpdateStreamStatus)
KeyValueTableConfigResponse(io.pravega.controller.stream.api.grpc.v1.Controller.KeyValueTableConfigResponse)
CreateScopeStatus(io.pravega.controller.stream.api.grpc.v1.Controller.CreateScopeStatus)
ArrayList(java.util.ArrayList)
List(java.util.List)
LinkedList(java.util.LinkedList)
SubscriberStreamCut(io.pravega.controller.stream.api.grpc.v1.Controller.SubscriberStreamCut)
KeyValueTableConfiguration(io.pravega.client.tables.KeyValueTableConfiguration)
NodeUri(io.pravega.controller.stream.api.grpc.v1.Controller.NodeUri)
PravegaNodeUri(io.pravega.shared.protocol.netty.PravegaNodeUri)
LinkedList(java.util.LinkedList)
ImmutableMap(com.google.common.collect.ImmutableMap)
SegmentRanges(io.pravega.controller.stream.api.grpc.v1.Controller.SegmentRanges)
CreateKeyValueTableStatus(io.pravega.controller.stream.api.grpc.v1.Controller.CreateKeyValueTableStatus)
GetSegmentsRequest(io.pravega.controller.stream.api.grpc.v1.Controller.GetSegmentsRequest)
File(java.io.File)
StreamCutImpl(io.pravega.client.stream.impl.StreamCutImpl)
SegmentValidityResponse(io.pravega.controller.stream.api.grpc.v1.Controller.SegmentValidityResponse)
Segment(io.pravega.client.segment.impl.Segment)
KeyValueTableInfo(io.pravega.controller.stream.api.grpc.v1.Controller.KeyValueTableInfo)
DefaultCredentials(io.pravega.shared.security.auth.DefaultCredentials)
StreamConfiguration(io.pravega.client.stream.StreamConfiguration)
Pair(org.apache.commons.lang3.tuple.Pair)
ReaderGroupInfo(io.pravega.controller.stream.api.grpc.v1.Controller.ReaderGroupInfo)
ControllerServiceImplBase(io.pravega.controller.stream.api.grpc.v1.ControllerServiceGrpc.ControllerServiceImplBase)
CreateStreamStatus(io.pravega.controller.stream.api.grpc.v1.Controller.CreateStreamStatus)
SegmentId(io.pravega.controller.stream.api.grpc.v1.Controller.SegmentId)
StreamConfig(io.pravega.controller.stream.api.grpc.v1.Controller.StreamConfig)
ScaleResponse(io.pravega.controller.stream.api.grpc.v1.Controller.ScaleResponse)
ScopeInfo(io.pravega.controller.stream.api.grpc.v1.Controller.ScopeInfo)
GetEpochSegmentsRequest(io.pravega.controller.stream.api.grpc.v1.Controller.GetEpochSegmentsRequest)
StreamInfo(io.pravega.controller.stream.api.grpc.v1.Controller.StreamInfo)
PingTxnStatus(io.pravega.controller.stream.api.grpc.v1.Controller.PingTxnStatus)
Before(org.junit.Before)
Example 2 with SubscribersResponse
use of io.pravega.controller.stream.api.grpc.v1.Controller.SubscribersResponse in project pravega by pravega.
the class StreamMetadataTasks method listSubscribers.
/**
* Get list of subscribers for a Stream.
* Subscribers are ReaderGroups reading from a Stream such that their reads impact data retention in the Stream.
* @param scope scope.
* @param stream stream name.
* @param requestId request id
* @return update status.
*/
public CompletableFuture<SubscribersResponse> listSubscribers(String scope, String stream, long requestId) {
final OperationContext context = streamMetadataStore.createStreamContext(scope, stream, requestId);
return streamMetadataStore.checkStreamExists(scope, stream, context, executor).thenCompose(exists -> {
if (!exists) {
return CompletableFuture.completedFuture(SubscribersResponse.newBuilder().setStatus(SubscribersResponse.Status.STREAM_NOT_FOUND).build());
}
// 2. get subscribers
return streamMetadataStore.listSubscribers(scope, stream, context, executor).thenApply(result -> SubscribersResponse.newBuilder().setStatus(SubscribersResponse.Status.SUCCESS).addAllSubscribers(result).build()).exceptionally(ex -> {
log.error(requestId, "Exception trying to get list of subscribers for Stream {}. Cause {}", NameUtils.getScopedStreamName(scope, stream), ex);
Throwable cause = Exceptions.unwrap(ex);
if (cause instanceof TimeoutException) {
throw new CompletionException(cause);
} else {
return SubscribersResponse.newBuilder().setStatus(SubscribersResponse.Status.FAILURE).build();
}
});
});
}
Also used :
OperationContext(io.pravega.controller.store.stream.OperationContext)
UpdateStreamEvent(io.pravega.shared.controller.event.UpdateStreamEvent)
StreamCut(io.pravega.controller.stream.api.grpc.v1.Controller.StreamCut)
EventStreamWriter(io.pravega.client.stream.EventStreamWriter)
StreamConfiguration(io.pravega.client.stream.StreamConfiguration)
AbstractStreamMetadataStore(io.pravega.controller.store.stream.AbstractStreamMetadataStore)
StoreException(io.pravega.controller.store.stream.StoreException)
TaskMetadataStore(io.pravega.controller.store.task.TaskMetadataStore)
Duration(java.time.Duration)
Map(java.util.Map)
RGStreamCutRecord(io.pravega.shared.controller.event.RGStreamCutRecord)
LockFailedException(io.pravega.controller.store.task.LockFailedException)
ReaderGroupConfig(io.pravega.client.stream.ReaderGroupConfig)
DeleteScopeStatus(io.pravega.controller.stream.api.grpc.v1.Controller.DeleteScopeStatus)
StreamCutReferenceRecord(io.pravega.controller.store.stream.records.StreamCutReferenceRecord)
StreamTruncationRecord(io.pravega.controller.store.stream.records.StreamTruncationRecord)
DeleteStreamEvent(io.pravega.shared.controller.event.DeleteStreamEvent)
Set(java.util.Set)
GuardedBy(javax.annotation.concurrent.GuardedBy)
ControllerEvent(io.pravega.shared.controller.event.ControllerEvent)
Serializable(java.io.Serializable)
ReaderGroupState(io.pravega.controller.store.stream.ReaderGroupState)
StreamMetadataStore(io.pravega.controller.store.stream.StreamMetadataStore)
Futures(io.pravega.common.concurrent.Futures)
GrpcAuthHelper(io.pravega.controller.server.security.auth.GrpcAuthHelper)
StreamMetrics(io.pravega.controller.metrics.StreamMetrics)
CreateReaderGroupResponse(io.pravega.controller.stream.api.grpc.v1.Controller.CreateReaderGroupResponse)
TransactionMetrics(io.pravega.controller.metrics.TransactionMetrics)
RetentionPolicy(io.pravega.client.stream.RetentionPolicy)
Exceptions(io.pravega.common.Exceptions)
TruncateStreamEvent(io.pravega.shared.controller.event.TruncateStreamEvent)
RetentionSet(io.pravega.controller.store.stream.records.RetentionSet)
Supplier(java.util.function.Supplier)
UpdateSubscriberStatus(io.pravega.controller.stream.api.grpc.v1.Controller.UpdateSubscriberStatus)
ArrayList(java.util.ArrayList)
ReaderGroupConfigRecord(io.pravega.controller.store.stream.records.ReaderGroupConfigRecord)
ReaderGroupConfiguration(io.pravega.controller.stream.api.grpc.v1.Controller.ReaderGroupConfiguration)
StreamInfo(io.pravega.controller.stream.api.grpc.v1.Controller.StreamInfo)
ScheduledExecutorService(java.util.concurrent.ScheduledExecutorService)
EventHelper(io.pravega.controller.task.EventHelper)
CreateReaderGroupEvent(io.pravega.shared.controller.event.CreateReaderGroupEvent)
RetryHelper(io.pravega.controller.util.RetryHelper)
Task(io.pravega.controller.task.Task)
Executor(java.util.concurrent.Executor)
CreateStreamResponse(io.pravega.controller.store.stream.CreateStreamResponse)
WireCommands(io.pravega.shared.protocol.netty.WireCommands)
SegmentRange(io.pravega.controller.stream.api.grpc.v1.Controller.SegmentRange)
AtomicLong(java.util.concurrent.atomic.AtomicLong)
StreamConfigurationRecord(io.pravega.controller.store.stream.records.StreamConfigurationRecord)
TreeMap(java.util.TreeMap)
WireCommandFailedException(io.pravega.controller.server.WireCommandFailedException)
Preconditions(com.google.common.base.Preconditions)
DeleteReaderGroupStatus(io.pravega.controller.stream.api.grpc.v1.Controller.DeleteReaderGroupStatus)
ScalingPolicy(io.pravega.client.stream.ScalingPolicy)
ControllerEventProcessors(io.pravega.controller.server.eventProcessor.ControllerEventProcessors)
StreamSegmentRecord(io.pravega.controller.store.stream.records.StreamSegmentRecord)
DeleteReaderGroupEvent(io.pravega.shared.controller.event.DeleteReaderGroupEvent)
LoggerFactory(org.slf4j.LoggerFactory)
TimeoutException(java.util.concurrent.TimeoutException)
SealStreamEvent(io.pravega.shared.controller.event.SealStreamEvent)
TagLogger(io.pravega.common.tracing.TagLogger)
VersionedMetadata(io.pravega.controller.store.VersionedMetadata)
TaskStepsRetryHelper.withRetries(io.pravega.controller.task.Stream.TaskStepsRetryHelper.withRetries)
Stream(io.pravega.client.stream.Stream)
SubscribersResponse(io.pravega.controller.stream.api.grpc.v1.Controller.SubscribersResponse)
Controller(io.pravega.controller.stream.api.grpc.v1.Controller)
EpochTransitionRecord(io.pravega.controller.store.stream.records.EpochTransitionRecord)
CreateStreamStatus(io.pravega.controller.stream.api.grpc.v1.Controller.CreateStreamStatus)
ImmutableSet(com.google.common.collect.ImmutableSet)
ImmutableMap(com.google.common.collect.ImmutableMap)
EpochTransitionOperationExceptions(io.pravega.controller.store.stream.EpochTransitionOperationExceptions)
DeleteScopeEvent(io.pravega.shared.controller.event.DeleteScopeEvent)
CompletionException(java.util.concurrent.CompletionException)
UUID(java.util.UUID)
Collectors(java.util.stream.Collectors)
RetriesExhaustedException(io.pravega.common.util.RetriesExhaustedException)
List(java.util.List)
Config(io.pravega.controller.util.Config)
RetryableException(io.pravega.controller.retryable.RetryableException)
Optional(java.util.Optional)
Resource(io.pravega.controller.store.task.Resource)
IntStream(java.util.stream.IntStream)
OperationContext(io.pravega.controller.store.stream.OperationContext)
SegmentHelper(io.pravega.controller.server.SegmentHelper)
ModelHelper(io.pravega.client.control.impl.ModelHelper)
AtomicBoolean(java.util.concurrent.atomic.AtomicBoolean)
ScaleStatusResponse(io.pravega.controller.stream.api.grpc.v1.Controller.ScaleStatusResponse)
HashMap(java.util.HashMap)
CompletableFuture(java.util.concurrent.CompletableFuture)
AtomicReference(java.util.concurrent.atomic.AtomicReference)
Function(java.util.function.Function)
BucketStore(io.pravega.controller.store.stream.BucketStore)
DeleteStreamStatus(io.pravega.controller.stream.api.grpc.v1.Controller.DeleteStreamStatus)
EventStreamClientFactory(io.pravega.client.EventStreamClientFactory)
NameUtils.getQualifiedStreamSegmentName(io.pravega.shared.NameUtils.getQualifiedStreamSegmentName)
ScaleResponse(io.pravega.controller.stream.api.grpc.v1.Controller.ScaleResponse)
EventWriterConfig(io.pravega.client.stream.EventWriterConfig)
ControllerService(io.pravega.controller.server.ControllerService)
UpdateReaderGroupResponse(io.pravega.controller.stream.api.grpc.v1.Controller.UpdateReaderGroupResponse)
NameUtils(io.pravega.shared.NameUtils)
Iterator(java.util.Iterator)
TaskBase(io.pravega.controller.task.TaskBase)
StreamCutRecord(io.pravega.controller.store.stream.records.StreamCutRecord)
Timer(io.pravega.common.Timer)
AbstractMap(java.util.AbstractMap)
EpochRecord(io.pravega.controller.store.stream.records.EpochRecord)
UpdateStreamStatus(io.pravega.controller.stream.api.grpc.v1.Controller.UpdateStreamStatus)
State(io.pravega.controller.store.stream.State)
VisibleForTesting(com.google.common.annotations.VisibleForTesting)
UpdateReaderGroupEvent(io.pravega.shared.controller.event.UpdateReaderGroupEvent)
Comparator(java.util.Comparator)
ReaderGroupConfigResponse(io.pravega.controller.stream.api.grpc.v1.Controller.ReaderGroupConfigResponse)
ScaleOpEvent(io.pravega.shared.controller.event.ScaleOpEvent)
CompletionException(java.util.concurrent.CompletionException)
TimeoutException(java.util.concurrent.TimeoutException)
Example 3 with SubscribersResponse
use of io.pravega.controller.stream.api.grpc.v1.Controller.SubscribersResponse in project pravega by pravega.
the class StreamMetadataTasksTest method updateSubscriberStreamCutTest.
@Test(timeout = 30000)
public void updateSubscriberStreamCutTest() throws InterruptedException, ExecutionException {
final String stream1ScopedName = NameUtils.getScopedStreamName(SCOPE, stream1);
final UUID rgId = UUID.randomUUID();
ReaderGroupConfig rgConfigSubscriber = ReaderGroupConfig.builder().stream(stream1ScopedName).automaticCheckpointIntervalMillis(30000L).groupRefreshTimeMillis(20000L).maxOutstandingCheckpointRequest(2).retentionType(ReaderGroupConfig.StreamDataRetention.AUTOMATIC_RELEASE_AT_LAST_CHECKPOINT).build();
rgConfigSubscriber = ReaderGroupConfig.cloneConfig(rgConfigSubscriber, rgId, 0L);
doReturn(CompletableFuture.completedFuture(Controller.CreateStreamStatus.Status.SUCCESS)).when(streamMetadataTasks).createRGStream(anyString(), anyString(), any(), anyLong(), anyInt(), anyLong());
WriterMock requestEventWriter = new WriterMock(streamMetadataTasks, executor);
streamMetadataTasks.setRequestEventWriter(requestEventWriter);
String subscriber1 = "subscriber1";
CompletableFuture<Controller.CreateReaderGroupResponse> createStatus = streamMetadataTasks.createReaderGroup(SCOPE, subscriber1, rgConfigSubscriber, System.currentTimeMillis(), 0L);
assertTrue(Futures.await(processEvent(requestEventWriter)));
assertEquals(Controller.CreateReaderGroupResponse.Status.SUCCESS, createStatus.join().getStatus());
String subscriber2 = "subscriber2";
createStatus = streamMetadataTasks.createReaderGroup(SCOPE, subscriber2, rgConfigSubscriber, System.currentTimeMillis(), 0L);
assertTrue(Futures.await(processEvent(requestEventWriter)));
assertEquals(Controller.CreateReaderGroupResponse.Status.SUCCESS, createStatus.join().getStatus());
SubscribersResponse listSubscribersResponse = streamMetadataTasks.listSubscribers(SCOPE, stream1, 0L).get();
assertEquals(SubscribersResponse.Status.SUCCESS, listSubscribersResponse.getStatus());
assertEquals(2, listSubscribersResponse.getSubscribersCount());
final String subscriber1Name = NameUtils.getScopedReaderGroupName(SCOPE, subscriber1);
ImmutableMap<Long, Long> streamCut1 = ImmutableMap.of(0L, 50L, 1L, 20L);
UpdateSubscriberStatus.Status updateStatus = streamMetadataTasks.updateSubscriberStreamCut(SCOPE, stream1, subscriber1Name, rgConfigSubscriber.getReaderGroupId().toString(), 0L, streamCut1, 0L).get();
assertEquals(UpdateSubscriberStatus.Status.SUCCESS, updateStatus);
final String subscriber2Name = NameUtils.getScopedReaderGroupName(SCOPE, subscriber2);
updateStatus = streamMetadataTasks.updateSubscriberStreamCut(SCOPE, stream1, subscriber2Name, rgConfigSubscriber.getReaderGroupId().toString(), 0L, streamCut1, 0L).get();
assertEquals(UpdateSubscriberStatus.Status.SUCCESS, updateStatus);
ImmutableMap<Long, Long> streamCut2 = ImmutableMap.of(0L, 70L, 1L, 30L);
updateStatus = streamMetadataTasks.updateSubscriberStreamCut(SCOPE, stream1, subscriber2Name, rgConfigSubscriber.getReaderGroupId().toString(), 0L, streamCut2, 0L).get();
assertEquals(UpdateSubscriberStatus.Status.SUCCESS, updateStatus);
ImmutableMap<Long, Long> streamCut3 = ImmutableMap.of(0L, 20L, 1L, 1L);
updateStatus = streamMetadataTasks.updateSubscriberStreamCut(SCOPE, stream1, subscriber2Name, rgConfigSubscriber.getReaderGroupId().toString(), 0L, streamCut3, 0L).get();
assertEquals(UpdateSubscriberStatus.Status.STREAM_CUT_NOT_VALID, updateStatus);
ImmutableMap<Long, Long> streamCut4 = ImmutableMap.of(0L, 25L);
updateStatus = streamMetadataTasks.updateSubscriberStreamCut(SCOPE, stream1, subscriber2Name, rgConfigSubscriber.getReaderGroupId().toString(), 0L, streamCut4, 0L).get();
assertEquals(UpdateSubscriberStatus.Status.STREAM_CUT_NOT_VALID, updateStatus);
// update non-existing stream
updateStatus = streamMetadataTasks.updateSubscriberStreamCut(SCOPE, "nostream", subscriber2Name, rgConfigSubscriber.getReaderGroupId().toString(), 0L, streamCut1, 0L).get();
assertEquals(UpdateSubscriberStatus.Status.STREAM_NOT_FOUND, updateStatus);
// update non-existing subscriber
updateStatus = streamMetadataTasks.updateSubscriberStreamCut(SCOPE, stream1, "nosubscriber", UUID.randomUUID().toString(), 0L, streamCut1, 0L).get();
assertEquals(UpdateSubscriberStatus.Status.SUBSCRIBER_NOT_FOUND, updateStatus);
}
Also used :
ReaderGroupConfig(io.pravega.client.stream.ReaderGroupConfig)
AtomicLong(java.util.concurrent.atomic.AtomicLong)
ArgumentMatchers.anyLong(org.mockito.ArgumentMatchers.anyLong)
UpdateSubscriberStatus(io.pravega.controller.stream.api.grpc.v1.Controller.UpdateSubscriberStatus)
ArgumentMatchers.anyString(org.mockito.ArgumentMatchers.anyString)
UUID(java.util.UUID)
ControllerEventStreamWriterMock(io.pravega.controller.mocks.ControllerEventStreamWriterMock)
EventStreamWriterMock(io.pravega.controller.mocks.EventStreamWriterMock)
SubscribersResponse(io.pravega.controller.stream.api.grpc.v1.Controller.SubscribersResponse)
Test(org.junit.Test)
Example 4 with SubscribersResponse
use of io.pravega.controller.stream.api.grpc.v1.Controller.SubscribersResponse in project pravega by pravega.
the class StreamMetadataTasksTest method readerGroupsTest.
@Test(timeout = 30000)
public void readerGroupsTest() throws InterruptedException, ExecutionException {
// no subscribers found for existing Stream
SubscribersResponse listSubscribersResponse = streamMetadataTasks.listSubscribers(SCOPE, stream1, 0L).get();
assertEquals(SubscribersResponse.Status.SUCCESS, listSubscribersResponse.getStatus());
assertEquals(0, listSubscribersResponse.getSubscribersList().size());
// subscribers for non-existing stream
listSubscribersResponse = streamMetadataTasks.listSubscribers(SCOPE, "somestream", 0L).get();
assertEquals(SubscribersResponse.Status.STREAM_NOT_FOUND, listSubscribersResponse.getStatus());
assertEquals(0, listSubscribersResponse.getSubscribersList().size());
doReturn(CompletableFuture.completedFuture(Controller.CreateStreamStatus.Status.SUCCESS)).when(streamMetadataTasks).createRGStream(anyString(), anyString(), any(), anyLong(), anyInt(), anyLong());
doReturn(CompletableFuture.completedFuture(Controller.DeleteStreamStatus.Status.SUCCESS)).when(streamMetadataTasks).deleteStream(anyString(), anyString(), anyLong());
doReturn(CompletableFuture.completedFuture(Controller.UpdateStreamStatus.Status.SUCCESS)).when(streamMetadataTasks).sealStream(anyString(), anyString(), any());
final String stream1ScopedName = NameUtils.getScopedStreamName(SCOPE, stream1);
final String stream2ScopedName = NameUtils.getScopedStreamName(SCOPE, stream2);
final String stream3ScopedName = NameUtils.getScopedStreamName(SCOPE, stream3);
final UUID rgIdSub1 = UUID.randomUUID();
ReaderGroupConfig rgConfigSubscriber1 = ReaderGroupConfig.builder().stream(stream1ScopedName).stream(stream2ScopedName).automaticCheckpointIntervalMillis(30000L).groupRefreshTimeMillis(20000L).maxOutstandingCheckpointRequest(2).retentionType(ReaderGroupConfig.StreamDataRetention.AUTOMATIC_RELEASE_AT_LAST_CHECKPOINT).build();
rgConfigSubscriber1 = ReaderGroupConfig.cloneConfig(rgConfigSubscriber1, rgIdSub1, 0L);
final UUID rgIdSub2 = UUID.randomUUID();
ReaderGroupConfig rgConfigSubscriber2 = ReaderGroupConfig.builder().stream(stream1ScopedName).stream(stream2ScopedName).automaticCheckpointIntervalMillis(30000L).groupRefreshTimeMillis(20000L).maxOutstandingCheckpointRequest(2).retentionType(ReaderGroupConfig.StreamDataRetention.AUTOMATIC_RELEASE_AT_LAST_CHECKPOINT).build();
rgConfigSubscriber2 = ReaderGroupConfig.cloneConfig(rgConfigSubscriber2, rgIdSub2, 0L);
final UUID rgIdSub3 = UUID.randomUUID();
ReaderGroupConfig rgConfigSubscriber3 = ReaderGroupConfig.builder().stream(stream1ScopedName).stream(stream3ScopedName).automaticCheckpointIntervalMillis(30000L).groupRefreshTimeMillis(20000L).maxOutstandingCheckpointRequest(2).retentionType(ReaderGroupConfig.StreamDataRetention.MANUAL_RELEASE_AT_USER_STREAMCUT).build();
rgConfigSubscriber3 = ReaderGroupConfig.cloneConfig(rgConfigSubscriber3, rgIdSub3, 0L);
ReaderGroupConfig rgConfigNonSubscriber = ReaderGroupConfig.builder().disableAutomaticCheckpoints().stream(stream1ScopedName).stream(stream3ScopedName).build();
assertTrue(ReaderGroupConfig.DEFAULT_UUID.equals(rgConfigNonSubscriber.getReaderGroupId()));
assertEquals(ReaderGroupConfig.StreamDataRetention.NONE, rgConfigNonSubscriber.getRetentionType());
WriterMock requestEventWriter = new WriterMock(streamMetadataTasks, executor);
streamMetadataTasks.setRequestEventWriter(requestEventWriter);
// Create ReaderGroup 1
CompletableFuture<Controller.CreateReaderGroupResponse> createFuture = streamMetadataTasks.createReaderGroup(SCOPE, "rg1", rgConfigSubscriber1, System.currentTimeMillis(), 0L);
assertTrue(Futures.await(processEvent(requestEventWriter)));
Controller.CreateReaderGroupResponse createResponse = createFuture.join();
assertEquals(Controller.CreateReaderGroupResponse.Status.SUCCESS, createResponse.getStatus());
assertEquals(0L, createResponse.getConfig().getGeneration());
// Create ReaderGroup 2
createFuture = streamMetadataTasks.createReaderGroup(SCOPE, "rg2", rgConfigSubscriber2, System.currentTimeMillis(), 0L);
assertTrue(Futures.await(processEvent(requestEventWriter)));
assertEquals(Controller.CreateReaderGroupResponse.Status.SUCCESS, createFuture.join().getStatus());
// Create ReaderGroup 2 again, and check that it returns success, but RG is not re-created
createResponse = streamMetadataTasks.createReaderGroup(SCOPE, "rg2", rgConfigSubscriber3, System.currentTimeMillis(), 0L).join();
assertEquals(Controller.CreateReaderGroupResponse.Status.SUCCESS, createResponse.getStatus());
assertEquals(rgIdSub2, UUID.fromString(createResponse.getConfig().getReaderGroupId()));
assertEquals(rgConfigSubscriber2.getRetentionType().ordinal(), createResponse.getConfig().getRetentionType());
createFuture = streamMetadataTasks.createReaderGroupInternal(SCOPE, "bad_rg_name", rgConfigSubscriber3, System.currentTimeMillis(), 0L);
assertEquals(Controller.CreateReaderGroupResponse.Status.INVALID_RG_NAME, createFuture.join().getStatus());
createFuture = streamMetadataTasks.createReaderGroupInternal("badscope", "rg3", rgConfigSubscriber3, System.currentTimeMillis(), 0L);
assertEquals(Controller.CreateReaderGroupResponse.Status.SCOPE_NOT_FOUND, createFuture.join().getStatus());
// Create ReaderGroup 3
createResponse = streamMetadataTasks.createReaderGroupInternal(SCOPE, "rg3", rgConfigSubscriber3, System.currentTimeMillis(), 0L).join();
assertEquals(Controller.CreateReaderGroupResponse.Status.SUCCESS, createResponse.getStatus());
assertEquals(0L, createResponse.getConfig().getGeneration());
assertFalse(ReaderGroupConfig.DEFAULT_UUID.toString().equals(createResponse.getConfig().getReaderGroupId()));
// Create ReaderGroup 4
createResponse = streamMetadataTasks.createReaderGroupInternal(SCOPE, "rg4", rgConfigNonSubscriber, System.currentTimeMillis(), 0L).join();
assertEquals(Controller.CreateReaderGroupResponse.Status.SUCCESS, createResponse.getStatus());
assertEquals(0L, createResponse.getConfig().getGeneration());
assertFalse(ReaderGroupConfig.DEFAULT_UUID.toString().equals(createResponse.getConfig().getReaderGroupId()));
// List all subscriber ReaderGroup, there should be 3
listSubscribersResponse = streamMetadataTasks.listSubscribers(SCOPE, stream1, 0L).get();
assertEquals(SubscribersResponse.Status.SUCCESS, listSubscribersResponse.getStatus());
assertEquals(3, listSubscribersResponse.getSubscribersList().size());
ReaderGroupConfigResponse responseRG2 = streamMetadataTasks.getReaderGroupConfig(SCOPE, "rg2", 0L).get();
assertEquals(ReaderGroupConfigResponse.Status.SUCCESS, responseRG2.getStatus());
assertNotNull(responseRG2.getConfig());
assertEquals(rgConfigSubscriber1.getAutomaticCheckpointIntervalMillis(), responseRG2.getConfig().getAutomaticCheckpointIntervalMillis());
assertEquals(rgConfigSubscriber1.getGroupRefreshTimeMillis(), responseRG2.getConfig().getGroupRefreshTimeMillis());
assertEquals(rgConfigSubscriber1.getRetentionType().ordinal(), responseRG2.getConfig().getRetentionType());
assertEquals(rgConfigSubscriber1.getGeneration(), responseRG2.getConfig().getGeneration());
assertEquals(rgConfigSubscriber1.getStartingStreamCuts().size(), responseRG2.getConfig().getStartingStreamCutsCount());
assertEquals(rgConfigSubscriber1.getEndingStreamCuts().size(), responseRG2.getConfig().getEndingStreamCutsCount());
ReaderGroupConfig newConfig = ReaderGroupConfig.builder().disableAutomaticCheckpoints().stream(stream2ScopedName).stream(stream3ScopedName).groupRefreshTimeMillis(40000L).maxOutstandingCheckpointRequest(5).retentionType(ReaderGroupConfig.StreamDataRetention.MANUAL_RELEASE_AT_USER_STREAMCUT).build();
newConfig = ReaderGroupConfig.cloneConfig(newConfig, rgIdSub2, 0L);
// update configuration of Reader Group :rg2
CompletableFuture<Controller.UpdateReaderGroupResponse> updateResponse = streamMetadataTasks.updateReaderGroup(SCOPE, "rg2", newConfig, 0L);
assertTrue(Futures.await(processEvent(requestEventWriter)));
Controller.UpdateReaderGroupResponse updateResponseResult = updateResponse.join();
assertEquals(Controller.UpdateReaderGroupResponse.Status.SUCCESS, updateResponseResult.getStatus());
assertEquals(1L, updateResponseResult.getGeneration());
responseRG2 = streamMetadataTasks.getReaderGroupConfig(SCOPE, "rg2", 0L).get();
assertEquals(ReaderGroupConfigResponse.Status.SUCCESS, responseRG2.getStatus());
assertNotNull(responseRG2.getConfig());
assertEquals(newConfig.getAutomaticCheckpointIntervalMillis(), responseRG2.getConfig().getAutomaticCheckpointIntervalMillis());
assertEquals(newConfig.getGroupRefreshTimeMillis(), responseRG2.getConfig().getGroupRefreshTimeMillis());
assertEquals(newConfig.getRetentionType().ordinal(), responseRG2.getConfig().getRetentionType());
assertEquals(newConfig.getGeneration() + 1, responseRG2.getConfig().getGeneration());
assertEquals(newConfig.getStartingStreamCuts().size(), responseRG2.getConfig().getStartingStreamCutsCount());
assertEquals(newConfig.getEndingStreamCuts().size(), responseRG2.getConfig().getEndingStreamCutsCount());
// "rg2" no longer subscribes to stream1, so this should show only 2 subscribers now
listSubscribersResponse = streamMetadataTasks.listSubscribers(SCOPE, stream1, 0L).get();
assertEquals(2, listSubscribersResponse.getSubscribersCount());
ReaderGroupConfig nonSubscriberStreamChangeConfig = ReaderGroupConfig.builder().automaticCheckpointIntervalMillis(10000L).stream(stream2ScopedName).stream(stream3ScopedName).build();
nonSubscriberStreamChangeConfig = ReaderGroupConfig.cloneConfig(nonSubscriberStreamChangeConfig, UUID.fromString(createResponse.getConfig().getReaderGroupId()), createResponse.getConfig().getGeneration());
// StreamDataRetention stays NONE
// streams change from (stream1, stream3) to (stream2, stream3) for "rg4"
assertEquals(ReaderGroupConfig.StreamDataRetention.NONE, nonSubscriberStreamChangeConfig.getRetentionType());
updateResponse = streamMetadataTasks.updateReaderGroup(SCOPE, "rg4", nonSubscriberStreamChangeConfig, 0L);
assertTrue(Futures.await(processEvent(requestEventWriter)));
updateResponseResult = updateResponse.join();
assertEquals(Controller.UpdateReaderGroupResponse.Status.SUCCESS, updateResponseResult.getStatus());
assertEquals(1L, updateResponseResult.getGeneration());
ReaderGroupConfigResponse responseRG4 = streamMetadataTasks.getReaderGroupConfig(SCOPE, "rg4", 0L).get();
assertEquals(ReaderGroupConfigResponse.Status.SUCCESS, responseRG4.getStatus());
assertNotNull(responseRG4.getConfig());
assertEquals(nonSubscriberStreamChangeConfig.getAutomaticCheckpointIntervalMillis(), responseRG4.getConfig().getAutomaticCheckpointIntervalMillis());
assertEquals(nonSubscriberStreamChangeConfig.getGroupRefreshTimeMillis(), responseRG4.getConfig().getGroupRefreshTimeMillis());
assertEquals(nonSubscriberStreamChangeConfig.getRetentionType().ordinal(), responseRG4.getConfig().getRetentionType());
assertEquals(nonSubscriberStreamChangeConfig.getGeneration() + 1, responseRG4.getConfig().getGeneration());
assertEquals(nonSubscriberStreamChangeConfig.getStartingStreamCuts().size(), responseRG4.getConfig().getStartingStreamCutsCount());
assertEquals(nonSubscriberStreamChangeConfig.getEndingStreamCuts().size(), responseRG4.getConfig().getEndingStreamCutsCount());
ReaderGroupConfig subscriberConfig = ReaderGroupConfig.builder().disableAutomaticCheckpoints().stream(stream3ScopedName).retentionType(ReaderGroupConfig.StreamDataRetention.MANUAL_RELEASE_AT_USER_STREAMCUT).build();
subscriberConfig = ReaderGroupConfig.cloneConfig(subscriberConfig, nonSubscriberStreamChangeConfig.getReaderGroupId(), 1L);
// Update Config from Non-Subscriber to Subscriber
// streams change from stream2, stream3 to stream3 only
updateResponse = streamMetadataTasks.updateReaderGroup(SCOPE, "rg4", subscriberConfig, 0L);
assertTrue(Futures.await(processEvent(requestEventWriter)));
updateResponseResult = updateResponse.join();
assertEquals(Controller.UpdateReaderGroupResponse.Status.SUCCESS, updateResponseResult.getStatus());
assertEquals(2L, updateResponseResult.getGeneration());
listSubscribersResponse = streamMetadataTasks.listSubscribers(SCOPE, stream3, 0L).get();
assertEquals(3, listSubscribersResponse.getSubscribersCount());
CompletableFuture<DeleteReaderGroupStatus.Status> deleteStatus = streamMetadataTasks.deleteReaderGroup(SCOPE, "rg2", rgIdSub2.toString(), 0L);
assertTrue(Futures.await(processEvent(requestEventWriter)));
assertEquals(DeleteReaderGroupStatus.Status.SUCCESS, deleteStatus.join());
responseRG2 = streamMetadataTasks.getReaderGroupConfig(SCOPE, "rg2", 0L).get();
assertEquals(ReaderGroupConfigResponse.Status.RG_NOT_FOUND, responseRG2.getStatus());
listSubscribersResponse = streamMetadataTasks.listSubscribers(SCOPE, stream3, 0L).get();
assertEquals(2, listSubscribersResponse.getSubscribersCount());
// Update Config from Subscriber to Non-Subscriber
ReaderGroupConfig subscriberToNonSubscriberConfig = ReaderGroupConfig.builder().disableAutomaticCheckpoints().stream(stream2ScopedName).build();
subscriberToNonSubscriberConfig = ReaderGroupConfig.cloneConfig(subscriberToNonSubscriberConfig, rgIdSub3, 0L);
updateResponse = streamMetadataTasks.updateReaderGroup(SCOPE, "rg3", subscriberToNonSubscriberConfig, 0L);
assertTrue(Futures.await(processEvent(requestEventWriter)));
Controller.UpdateReaderGroupResponse updateRGResponse = updateResponse.join();
assertTrue(Controller.UpdateReaderGroupResponse.Status.SUCCESS.equals(updateRGResponse.getStatus()));
assertEquals(1L, updateRGResponse.getGeneration());
listSubscribersResponse = streamMetadataTasks.listSubscribers(SCOPE, stream3, 0L).get();
// rg4
assertEquals(1, listSubscribersResponse.getSubscribersCount());
listSubscribersResponse = streamMetadataTasks.listSubscribers(SCOPE, stream2, 0L).get();
// rg1
assertEquals(1, listSubscribersResponse.getSubscribersCount());
listSubscribersResponse = streamMetadataTasks.listSubscribers(SCOPE, stream1, 0L).get();
// rg1
assertEquals(1, listSubscribersResponse.getSubscribersCount());
ReaderGroupConfigResponse responseRG3 = streamMetadataTasks.getReaderGroupConfig(SCOPE, "rg3", 0L).get();
assertEquals(ReaderGroupConfigResponse.Status.SUCCESS, responseRG3.getStatus());
assertEquals(subscriberToNonSubscriberConfig.getReaderGroupId(), UUID.fromString(responseRG3.getConfig().getReaderGroupId()));
assertEquals(subscriberToNonSubscriberConfig.getRetentionType().ordinal(), responseRG3.getConfig().getRetentionType());
assertEquals(subscriberToNonSubscriberConfig.getGeneration() + 1, responseRG3.getConfig().getGeneration());
assertEquals(subscriberToNonSubscriberConfig.getAutomaticCheckpointIntervalMillis(), responseRG3.getConfig().getAutomaticCheckpointIntervalMillis());
assertEquals(subscriberToNonSubscriberConfig.getStartingStreamCuts().size(), responseRG3.getConfig().getStartingStreamCutsCount());
assertEquals(subscriberToNonSubscriberConfig.getEndingStreamCuts().size(), responseRG3.getConfig().getEndingStreamCutsCount());
}
Also used :
ReaderGroupConfig(io.pravega.client.stream.ReaderGroupConfig)
UpdateSubscriberStatus(io.pravega.controller.stream.api.grpc.v1.Controller.UpdateSubscriberStatus)
DeleteReaderGroupStatus(io.pravega.controller.stream.api.grpc.v1.Controller.DeleteReaderGroupStatus)
ScaleStreamStatus(io.pravega.controller.stream.api.grpc.v1.Controller.ScaleResponse.ScaleStreamStatus)
TxnStatus(io.pravega.controller.store.stream.TxnStatus)
UpdateStreamStatus(io.pravega.controller.stream.api.grpc.v1.Controller.UpdateStreamStatus)
ReaderGroupConfigResponse(io.pravega.controller.stream.api.grpc.v1.Controller.ReaderGroupConfigResponse)
ArgumentMatchers.anyString(org.mockito.ArgumentMatchers.anyString)
Controller(io.pravega.controller.stream.api.grpc.v1.Controller)
UUID(java.util.UUID)
ControllerEventStreamWriterMock(io.pravega.controller.mocks.ControllerEventStreamWriterMock)
EventStreamWriterMock(io.pravega.controller.mocks.EventStreamWriterMock)
SubscribersResponse(io.pravega.controller.stream.api.grpc.v1.Controller.SubscribersResponse)
Test(org.junit.Test)
Aggregations
ReaderGroupConfig (io.pravega.client.stream.ReaderGroupConfig)4
SubscribersResponse (io.pravega.controller.stream.api.grpc.v1.Controller.SubscribersResponse)4
UpdateSubscriberStatus (io.pravega.controller.stream.api.grpc.v1.Controller.UpdateSubscriberStatus)4
Controller (io.pravega.controller.stream.api.grpc.v1.Controller)3
DeleteReaderGroupStatus (io.pravega.controller.stream.api.grpc.v1.Controller.DeleteReaderGroupStatus)3
ReaderGroupConfigResponse (io.pravega.controller.stream.api.grpc.v1.Controller.ReaderGroupConfigResponse)3
UpdateStreamStatus (io.pravega.controller.stream.api.grpc.v1.Controller.UpdateStreamStatus)3
UUID (java.util.UUID)3
ImmutableMap (com.google.common.collect.ImmutableMap)2
StreamConfiguration (io.pravega.client.stream.StreamConfiguration)2
CreateReaderGroupResponse (io.pravega.controller.stream.api.grpc.v1.Controller.CreateReaderGroupResponse)2
CreateStreamStatus (io.pravega.controller.stream.api.grpc.v1.Controller.CreateStreamStatus)2
DeleteScopeStatus (io.pravega.controller.stream.api.grpc.v1.Controller.DeleteScopeStatus)2
DeleteStreamStatus (io.pravega.controller.stream.api.grpc.v1.Controller.DeleteStreamStatus)2
ReaderGroupConfiguration (io.pravega.controller.stream.api.grpc.v1.Controller.ReaderGroupConfiguration)2
ScaleResponse (io.pravega.controller.stream.api.grpc.v1.Controller.ScaleResponse)2
ScaleStatusResponse (io.pravega.controller.stream.api.grpc.v1.Controller.ScaleStatusResponse)2
StreamInfo (io.pravega.controller.stream.api.grpc.v1.Controller.StreamInfo)2
UpdateReaderGroupResponse (io.pravega.controller.stream.api.grpc.v1.Controller.UpdateReaderGroupResponse)2
ArrayList (java.util.ArrayList)2
