Examples with DefaultHttpResponse com.couchbase.client.core.deps.io.netty.handler.codec.http.DefaultHttpResponse used on opensource projects

Example 6 with DefaultHttpResponse

use of com.couchbase.client.core.deps.io.netty.handler.codec.http.DefaultHttpResponse in project couchbase-jvm-clients by couchbase.

the class ManagerMessageHandlerTest method returnsNewConfigsWhenChunked.

/**
 * Configs can come in all shapes and sizes chunked, but only after the 4 newlines are pushed by the cluster
 * the config should be propagated into the flux.
 */
@Test
void returnsNewConfigsWhenChunked() throws Exception {
    CoreContext ctx = new CoreContext(mock(Core.class), 1, ENV, PasswordAuthenticator.create(USER, PASS));
    BaseEndpoint endpoint = mock(BaseEndpoint.class);
    EndpointContext endpointContext = mock(EndpointContext.class);
    when(endpointContext.environment()).thenReturn(ENV);
    when(endpoint.context()).thenReturn(endpointContext);
    EmbeddedChannel channel = new EmbeddedChannel(new ManagerMessageHandler(endpoint, ctx));
    BucketConfigStreamingRequest request = new BucketConfigStreamingRequest(Duration.ofSeconds(1), ctx, BestEffortRetryStrategy.INSTANCE, "bucket", ctx.authenticator());
    channel.write(request);
    HttpRequest outboundHeader = channel.readOutbound();
    assertEquals(HttpMethod.GET, outboundHeader.method());
    assertEquals("/pools/default/bs/bucket", outboundHeader.uri());
    assertEquals(HttpVersion.HTTP_1_1, outboundHeader.protocolVersion());
    CompletableFuture<BucketConfigStreamingResponse> response = request.response();
    assertFalse(response.isDone());
    HttpResponse inboundResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
    channel.writeInbound(inboundResponse);
    BucketConfigStreamingResponse completedResponse = request.response().get();
    final List<String> configsPushed = Collections.synchronizedList(new ArrayList<>());
    final AtomicBoolean terminated = new AtomicBoolean(false);
    Thread listener = new Thread(() -> completedResponse.configs().subscribe(configsPushed::add, (e) -> {
    }, () -> terminated.set(true)));
    listener.setDaemon(true);
    listener.start();
    ByteBuf fullContent = Unpooled.copiedBuffer(readResource("terse_stream_two_configs.json", ManagerMessageHandlerTest.class), StandardCharsets.UTF_8);
    while (fullContent.readableBytes() > 0) {
        int len = new Random().nextInt(fullContent.readableBytes() + 1);
        if (len == 0) {
            continue;
        }
        channel.writeInbound(new DefaultHttpContent(fullContent.readBytes(len)));
    }
    waitUntilCondition(() -> configsPushed.size() >= 1);
    for (String config : configsPushed) {
        assertTrue(config.startsWith("{"));
        assertTrue(config.endsWith("}"));
    }
    assertFalse(terminated.get());
    channel.writeInbound(new DefaultLastHttpContent());
    waitUntilCondition(terminated::get);
    ReferenceCountUtil.release(fullContent);
    channel.close().awaitUninterruptibly();
}

Example 7 with DefaultHttpResponse

use of com.couchbase.client.core.deps.io.netty.handler.codec.http.DefaultHttpResponse in project couchbase-jvm-clients by couchbase.

the class ClusterManagerBucketRefresherTest method shouldReconnectIfStreamCloses.

/**
 * Unsubscription is driven purely from up the stack, so if the config stream should close for some
 * reason the refresher needs to try to establish a new connection.
 */
@Test
void shouldReconnectIfStreamCloses() {
    final AtomicReference<BucketConfigStreamingResponse> responseRef = new AtomicReference<>();
    final AtomicInteger streamingRequestAttempts = new AtomicInteger();
    doAnswer(i -> {
        streamingRequestAttempts.incrementAndGet();
        BucketConfigStreamingRequest request = i.getArgument(0);
        HttpResponse httpResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
        BucketConfigStreamingResponse response = request.decode(httpResponse, null);
        responseRef.set(response);
        request.succeed(response);
        return null;
    }).when(core).send(any(BucketConfigStreamingRequest.class));
    refresher.register("bucketName").block();
    // Let's pretend the successfully opened stream closes for whatever reason
    responseRef.get().completeStream();
    waitUntilCondition(() -> streamingRequestAttempts.get() >= 2);
}

Example 8 with DefaultHttpResponse

use of com.couchbase.client.core.deps.io.netty.handler.codec.http.DefaultHttpResponse in project couchbase-jvm-clients by couchbase.

the class ClusterManagerBucketRefresherTest method shouldReconnectIfStreamErrors.

/**
 * Unsubscription is driven purely from up the stack, so if the config stream should error for some
 * reason the refresher needs to try to establish a new connection.
 */
@Test
void shouldReconnectIfStreamErrors() {
    final AtomicReference<BucketConfigStreamingResponse> responseRef = new AtomicReference<>();
    final AtomicInteger streamingRequestAttempts = new AtomicInteger();
    doAnswer(i -> {
        streamingRequestAttempts.incrementAndGet();
        BucketConfigStreamingRequest request = i.getArgument(0);
        HttpResponse httpResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
        BucketConfigStreamingResponse response = request.decode(httpResponse, null);
        responseRef.set(response);
        request.succeed(response);
        return null;
    }).when(core).send(any(BucketConfigStreamingRequest.class));
    refresher.register("bucketName").block();
    // Let's pretend the successfully opened stream fails for whatever reason
    responseRef.get().failStream(new RuntimeException("Something Happened"));
    waitUntilCondition(() -> streamingRequestAttempts.get() >= 2);
}

Example 9 with DefaultHttpResponse

use of com.couchbase.client.core.deps.io.netty.handler.codec.http.DefaultHttpResponse in project couchbase-jvm-clients by couchbase.

the class SearchMock method loadSearchTestCase.

/**
 * Given JSON in the form expected, e.g. those from https://github.com/chvck/sdk-testcases which contains the
 * returned JSON from the search service in a field "data", returns the completed SearchResult that the API
 * would return.
 */
public static SearchResult loadSearchTestCase(InputStream json) throws ExecutionException, InterruptedException, IOException {
    // The idea is to fake packets that have come from the search service.
    // Start by preparing the packets.
    JsonObject jo = JsonObject.fromJson(toByteArray(json));
    JsonObject data = jo.getObject("data");
    byte[] b = data.toString().getBytes(StandardCharsets.UTF_8);
    ByteBuf bytes = Unpooled.wrappedBuffer(b);
    HttpContent content = new DefaultLastHttpContent(bytes);
    HttpResponse resp = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
    // Fake some core stuff
    Core mockedCore = mock(Core.class);
    CoreEnvironment env = CoreEnvironment.create();
    CoreContext ctx = new CoreContext(mockedCore, 0, env, PasswordAuthenticator.create("Administrator", "password"));
    // Our ChunkedSearchMessageHandler needs to be initialised by pretending we've sent an outbound SearchRequest
    // through it
    SearchRequest req = new SearchRequest(Duration.ofSeconds(10), ctx, BestEffortRetryStrategy.INSTANCE, null, null, null, null);
    // ChunkedSearchMessageHandler will try to encode() the SearchRequest.  Rather than mocking everything required
    // to get that working, just mock the encode method.
    SearchRequest spiedReq = spy(req);
    doReturn(new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "localhost")).when(spiedReq).encode();
    doAnswer(v -> {
        EndpointContext endpointContext = new EndpointContext(ctx, new HostAndPort(null, 0), null, null, null, Optional.of("bucket"), null);
        BaseEndpoint endpoint = mock(BaseEndpoint.class);
        when(endpoint.context()).thenReturn(endpointContext);
        when(endpoint.pipelined()).thenReturn(false);
        // ChunkedSearchMessageHandler does most of the work in handling responses from the service
        ChunkedSearchMessageHandler handler = new ChunkedSearchMessageHandler(endpoint, endpointContext);
        // Netty's EmbeddedChannel lets us test ChannelHandlers like ChunkedSearchMessageHandler.  It's a Netty Channel
        // that doesn't touch the network at all.
        final EmbeddedChannel channel = new EmbeddedChannel(handler);
        // Writing the request is necessary to estabish some initial state inChunkedSearchMessageHandler
        channel.writeAndFlush(spiedReq);
        // Finally we can do the interesting bit of passing our fake FTS service response into
        // ChunkedSearchMessageHandler
        channel.writeInbound(resp);
        channel.writeInbound(content);
        return null;
    }).when(mockedCore).send(any());
    CompletableFuture<SearchResult> future = SearchAccessor.searchQueryAsync(mockedCore, req, DefaultJsonSerializer.create());
    SearchResult result = future.get();
    return result;
}