software.amazon.awssdk.services.kinesis.model.ListShardsResponse Java Examples

public static void listKinShards(KinesisClient kinesisClient, String name) {

        try {
        ListShardsRequest request = ListShardsRequest.builder()
                .streamName(name)
                .build();

            ListShardsResponse response = kinesisClient.listShards(request);
            System.out.println(request.streamName() + " has " + response.shards());

        } catch (KinesisException e) {
            System.err.println(e.getMessage());
            System.exit(1);
        }
        System.out.println("Done");
    }
 

public static Shard getShard(final KinesisClient kinesisClient, final String streamName, final String shardIdStart)
		throws Exception {
	LOG.debug(String.format("Getting Shard %s for Stream %s", shardIdStart, streamName));

	KinesisOperation describe = new KinesisOperation() {
		public Object run(KinesisClient client) {
			// reduce the shardIdStart by 1 as the API uses it as an exclusive start key not
			// a filter
			String shardIdToQuery = new BigDecimal(shardIdStart).subtract(new BigDecimal("1")).toString();
			ListShardsRequest req = ListShardsRequest.builder().streamName(streamName)
					.exclusiveStartShardId(shardIdToQuery).build();
			ListShardsResponse result = client.listShards(req);

			return result.shards().get(0);
		}
	};
	return (Shard) doOperation(kinesisClient, describe, streamName, DESCRIBE_RETRIES, false);
}
 

@Override
@Synchronized
public List<Shard> listShards() {
    final List<Shard> shards = new ArrayList<>();
    ListShardsResponse result;
    String nextToken = null;

    do {
        result = listShards(nextToken);

        if (result == null) {
            /*
             * If listShards ever returns null, we should bail and return null. This indicates the stream is not
             * in ACTIVE or UPDATING state and we may not have accurate/consistent information about the stream.
             */
            return null;
        } else {
            shards.addAll(result.shards());
            nextToken = result.nextToken();
        }
    } while (StringUtils.isNotEmpty(result.nextToken()));

    cachedShardMap(shards);
    return shards;
}
 

@Test
public void testGetShardNewShardForceRefresh() {
    final String shardId = String.format(SHARD_ID, 5);
    final List<Shard> shards = new ArrayList<>(createShardList());
    shards.add(Shard.builder().shardId(shardId).build());

    final CompletableFuture<ListShardsResponse> future = CompletableFuture
            .completedFuture(ListShardsResponse.builder().shards(shards).build());

    shardDetector.cachedShardMap(createShardList());

    when(client.listShards(any(ListShardsRequest.class))).thenReturn(future);

    final List<Shard> responses = IntStream.range(0, MAX_CACHE_MISSES_BEFORE_RELOAD + 1)
            .mapToObj(x -> shardDetector.shard(shardId)).collect(Collectors.toList());

    IntStream.range(0, MAX_CACHE_MISSES_BEFORE_RELOAD).forEach(x -> {
        assertThat(responses.get(x), nullValue());
    });

    assertThat(responses.get(MAX_CACHE_MISSES_BEFORE_RELOAD), equalTo(Shard.builder().shardId(shardId).build()));
    verify(client).listShards(any(ListShardsRequest.class));
}
 

@Test
public void testGetShardNonExistentShardForceRefresh() {
    final String shardId = String.format(SHARD_ID, 5);
    final CompletableFuture<ListShardsResponse> future = CompletableFuture
            .completedFuture(ListShardsResponse.builder().shards(createShardList()).build());

    shardDetector.cachedShardMap(createShardList());

    when(client.listShards(any(ListShardsRequest.class))).thenReturn(future);

    final List<Shard> responses = IntStream.range(0, MAX_CACHE_MISSES_BEFORE_RELOAD + 1)
            .mapToObj(x -> shardDetector.shard(shardId)).collect(Collectors.toList());

    responses.forEach(response -> assertThat(response, nullValue()));
    assertThat(shardDetector.cacheMisses().get(), equalTo(0));
    verify(client).listShards(any(ListShardsRequest.class));
}
 

public static List<Shard> listShards(final KinesisClient kinesisClient, final String streamName,
		final String shardIdStart) throws Exception {
	LOG.debug(String.format("Listing Stream %s from Shard %s", streamName, shardIdStart));

	KinesisOperation describe = new KinesisOperation() {
		public Object run(KinesisClient client) {
			ListShardsRequest.Builder builder = ListShardsRequest.builder().streamName(streamName);
			ListShardsRequest req = null;
			boolean hasMoreResults = true;
			List<Shard> shards = new ArrayList<>();

			while (hasMoreResults) {
				if (shardIdStart != null && (req != null && req.nextToken() == null)) {
					builder.exclusiveStartShardId(shardIdStart);
				}
				ListShardsResponse result = client.listShards(builder.build());
				shards.addAll(result.shards());

				if (result.nextToken() == null) {
					hasMoreResults = false;
				} else {
					req = ListShardsRequest.builder().nextToken(result.nextToken()).build();
				}

			}
			return shards;
		}
	};
	return (List<Shard>) doOperation(kinesisClient, describe, streamName, DESCRIBE_RETRIES, false);
}
 

@Test(expected = IllegalStateException.class)
public void testListShardsNullResponse() {
    final CompletableFuture<ListShardsResponse> future = CompletableFuture.completedFuture(null);

    when(client.listShards(any(ListShardsRequest.class))).thenReturn(future);

    try {
        shardDetector.listShards();
    } finally {
        verify(client, times(MAX_LIST_SHARDS_RETRY_ATTEMPTS))
                .listShards(any(ListShardsRequest.class));
    }
}
 

@Test
public void testListShardsResouceInUse() {
    final CompletableFuture<ListShardsResponse> future = CompletableFuture.supplyAsync(() -> {
        throw ResourceInUseException.builder().build();
    });

    when(client.listShards(any(ListShardsRequest.class))).thenReturn(future);

    final List<Shard> shards = shardDetector.listShards();

    assertThat(shards, nullValue());
    verify(client).listShards(any(ListShardsRequest.class));

}
 

@Test(expected = LimitExceededException.class)
public void testListShardsThrottled() {
    final CompletableFuture<ListShardsResponse> future = CompletableFuture.supplyAsync(() -> {
        throw LimitExceededException.builder().build();
    });

    when(client.listShards(any(ListShardsRequest.class))).thenReturn(future);

    try {
        shardDetector.listShards();
    } finally {
        verify(client, times(MAX_LIST_SHARDS_RETRY_ATTEMPTS))
                .listShards(any(ListShardsRequest.class));
    }
}
 

@Test(expected = ResourceNotFoundException.class)
public void testListShardsResourceNotFound() {
    final CompletableFuture<ListShardsResponse> future = CompletableFuture.supplyAsync(() -> {
        throw ResourceNotFoundException.builder().build();
    });

    when(client.listShards(any(ListShardsRequest.class))).thenReturn(future);

    try {
        shardDetector.listShards();
    } finally {
        verify(client).listShards(any(ListShardsRequest.class));
    }
}
 

@Test
public void testGetShardEmptyCache() {
    final String shardId = String.format(SHARD_ID, 1);
    final CompletableFuture<ListShardsResponse> future = CompletableFuture
            .completedFuture(ListShardsResponse.builder().shards(createShardList()).build());

    when(client.listShards(any(ListShardsRequest.class))).thenReturn(future);

    final Shard shard = shardDetector.shard(shardId);

    assertThat(shard, equalTo(Shard.builder().shardId(shardId).build()));
    verify(client).listShards(any(ListShardsRequest.class));
}