Java Code Examples for javax.ws.rs.container.AsyncResponse#setTimeout()

@GET
@Path("/async-hello")
@Produces(MediaType.TEXT_PLAIN)
public void getAsyncData(@Suspended final AsyncResponse response,
                         @QueryParam("d") @DefaultValue("1") final int delaySec) throws IOException {

    response.setTimeout(6, TimeUnit.SECONDS);

    new Thread(() -> {
        try {
            Thread.sleep(delaySec * 1000);

            if (!response.isSuspended()) {
                System.out.println("Async response is not suspended");
                return;
            }

            if (!response.resume(Response.ok(helloWord.say()).build())) {
                System.out.println("Async response not resumed");
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }).start();
}
 

@GET
public void getAsync(final @Suspended AsyncResponse res) {
    res.setTimeoutHandler(
        (ar) -> {
            ar.resume(Response.status(Response.Status.SERVICE_UNAVAILABLE)
                .entity("Operation timed out --- please try again.").build());
        }
    );
    res.setTimeout(1000, TimeUnit.MILLISECONDS);
    executor.submit(() -> {
        //do long run operations.
        try {
            LOG.log(Level.INFO, " execute long run task in AsyncResource");
            //Thread.sleep(new Random().nextInt(1005));
            Thread.sleep(500);
        } catch (InterruptedException ex) {
            LOG.log(Level.SEVERE, "error :{0}", ex.getMessage());
        }
        res.resume(Response.ok("asynchronous resource").build());
    });
}
 

@GET
public void getAsync(final @Suspended AsyncResponse res) {
    res.setTimeoutHandler(
            (ar) -> {
                ar.resume(Response.status(Response.Status.SERVICE_UNAVAILABLE)
                        .entity("Operation timed out --- please try again.").build());
            }
    );
    res.setTimeout(1000, TimeUnit.MILLISECONDS);
    executor.submit(() -> {
        //do long run operations.
        try {
            LOG.log(Level.INFO, " execute long run task in AsyncResource");
            //Thread.sleep(new Random().nextInt(1005));
            Thread.sleep(500);
        } catch (InterruptedException ex) {
            LOG.log(Level.SEVERE, "error :" + ex.getMessage());
        }
        res.resume(Response.ok("asynchronous resource").build());
    });
}
 

private void bindMetricsResponse(
    final AsyncResponse response,
    final AsyncFuture<QueryResult> callback,
    final QueryContext queryContext
) {
    response.setTimeout(300, TimeUnit.SECONDS);

    httpAsync.bind(response, callback, r -> {
        final QueryMetricsResponse qmr =
            new QueryMetricsResponse(queryContext.queryId(), r.getRange(), r.getGroups(),
                r.getErrors(), r.getTrace(), r.getLimits(),
                Optional.of(r.getPreAggregationSampleSize()), r.getCache());
        queryLogger.logFinalResponse(queryContext, qmr);
        return qmr;
    });
}
 

@GET
@Path("/disconnect")
public void handleClientDisconnects(@Suspended AsyncResponse response) {
    response.setTimeout(0, TimeUnit.SECONDS);

    response.register(new ConnectionCallback() {
        @Override
        public void onDisconnect(AsyncResponse disconnected) {
            System.out.println("ConnectionCallback: onDisconnect, client disconnects");
        }
    });

    try {
        Thread.sleep(3000);
    } catch (InterruptedException ex) {
        // ignore
    }

    response.resume(books.values().toString());
}
 

@Override
public void importBot(InputStream zippedBotConfigFiles, AsyncResponse response) {
    try {
        if (response != null) response.setTimeout(60, TimeUnit.SECONDS);
        File targetDir = new File(FileUtilities.buildPath(tmpPath.toString(), UUID.randomUUID().toString()));
        importBotZipFile(zippedBotConfigFiles, targetDir, response);
    } catch (IOException e) {
        log.error(e.getLocalizedMessage(), e);
        response.resume(new InternalServerErrorException());
    }
}
 

@GET
@Path("/books/timeouthandlerresume/{id}")
public void getBookDescriptionWithHandlerResumeOnly(@PathParam("id") String id,
                                                    @Suspended AsyncResponse async) {
    async.setTimeout(1000, TimeUnit.MILLISECONDS);
    async.setTimeoutHandler(new TimeoutHandlerImpl(id, true));
}
 

@Override
public void handleTimeout(AsyncResponse asyncResponse) {
    if (queue.isEmpty()) {
        asyncResponse.setTimeout(asyncTimeout, TimeUnit.MILLISECONDS);
    } else {
        resumeAsyncResponse();
    }

}
 

@GET
@Path("/books/cancel")
public void getBookDescriptionWithCancel(@PathParam("id") String id,
                                         @Suspended AsyncResponse async) {
    PhaseInterceptorChain.getCurrentMessage().getClass();
    async.setTimeout(2000, TimeUnit.MILLISECONDS);
    async.setTimeoutHandler(new CancelTimeoutHandlerImpl());
}
 

@GET
@Path("heavy")
public void getHeavyMessage(@Suspended AsyncResponse ar) {
    service.getHeavyMessage(ar::resume);
    ar.setTimeoutHandler(this::onTimeout);
    ar.setTimeout(TIMEOUT_IN_SECONDS, TimeUnit.SECONDS);
}
 

@GET
@Path("light")
public void getLightMessage(@Suspended AsyncResponse ar) {
    service.getLightMessage(ar::resume);
    ar.setTimeoutHandler(this::onTimeout);
    ar.setTimeout(TIMEOUT_IN_SECONDS, TimeUnit.SECONDS);
}
 

@GET
@Path(ASYNC_TIMEOUT_PATH)
public void getAsyncTimeout(@Suspended AsyncResponse asyncResponse) {
    logger.info("Async timeout endpoint hit");

    asyncResponse.setTimeout(SLEEP_TIME_MILLIS, TimeUnit.MILLISECONDS);
}
 

public StreamingAsyncSubscriber(AsyncResponse ar, String openTag, String closeTag, String sep,
                                long pollTimeout, long asyncTimeout) {
    super(ar);
    this.openTag = openTag;
    this.closeTag = closeTag;
    this.separator = sep;
    this.pollTimeout = pollTimeout;
    this.asyncTimeout = 0;
    if (asyncTimeout > 0) {
        ar.setTimeout(asyncTimeout, TimeUnit.MILLISECONDS);
        ar.setTimeoutHandler(new TimeoutHandlerImpl());
    }
}
 

public static void setTimeout(long timeout, AsyncResponse asyncResponse) {
    asyncResponse.setTimeout(timeout, TimeUnit.MILLISECONDS);
    asyncResponse.setTimeoutHandler(resp -> resp.resume(
            Response.status(Response.Status.GATEWAY_TIMEOUT)
                    .entity("HTTP GET timed out after " + timeout + " ms\n")
                    .build()));
}
 

@Produces(TEXT_PLAIN)
@Path("/suspended/resume-timeout")
@GET
public void getAsyncResponseResumeTimeout(@Suspended final AsyncResponse ar) {
    ar.resume("DONE");
    ar.setTimeout(1, MINUTES);
}
 

@Produces(TEXT_PLAIN)
@Path("/suspended/timeout-expire-handled")
@GET
public void getAsyncResponseTimeoutExpireHandled(@Suspended final AsyncResponse ar) {
    ar.setTimeoutHandler(ar2 -> ar2.resume(status(GATEWAY_TIMEOUT).build()));
    ar.setTimeout(1, NANOSECONDS);
}
 

@Produces(TEXT_PLAIN)
@Path("/suspended/timeout-expire")
@GET
public void getAsyncResponseTimeoutExpire(@Suspended final AsyncResponse ar) {
    // Set timeout twice to ensure users can update it at will
    ar.setTimeout(1, MINUTES);
    ar.setTimeout(1, NANOSECONDS);
}
 

@Override
public void handleTimeout(AsyncResponse asyncResponse) {
    if (!resumeOnly && timeoutExtendedCounter.addAndGet(1) <= 2) {
        asyncResponse.setTimeout(1, TimeUnit.SECONDS);
    } else {
        asyncResponse.resume(books.get(id));
    }
}
 

@Path("/suspended")
@GET
public void getForeverSuspended(@Suspended final AsyncResponse ar) {
    // The scheduled task in DefaultContainerResponseWriter will never complete
    ar.setTimeout(7, DAYS);
}
 

@GET
@Path("/books/defaulttimeout")
public void getBookDescriptionWithTimeout(@Suspended AsyncResponse async) {
    async.register(new CallbackImpl());
    async.setTimeout(2000, TimeUnit.MILLISECONDS);
}