docs: @POST
    @Path("/changeRequests")
    @Produces({MediaType.APPLICATION_JSON, SmileMediaTypes.APPLICATION_JACKSON_SMILE})
    @Consumes({MediaType.APPLICATION_JSON, SmileMediaTypes.APPLICATION_JACKSON_SMILE})
    public void applyDataSegmentChangeRequests(
        @QueryParam("timeout") long timeout,
        List<DataSegmentChangeRequest> changeRequestList,
        @Context final HttpServletRequest req
    ) throws IOException
    {
      if (loadDropRequestHandler == null) {
        sendErrorResponse(req, HttpServletResponse.SC_NOT_FOUND, "load/drop handler is not available.");
        return;
      }
  
      if (timeout <= 0) {
        sendErrorResponse(req, HttpServletResponse.SC_BAD_REQUEST, "timeout must be positive.");
        return;
      }
  
      if (changeRequestList == null || changeRequestList.isEmpty()) {
        sendErrorResponse(req, HttpServletResponse.SC_BAD_REQUEST, "No change requests provided.");
        return;
      }
  
      final ResponseContext context = createContext(req.getHeader("Accept"));
      final ListenableFuture<List<SegmentLoadDropHandler.DataSegmentChangeRequestAndStatus>> future = loadDropRequestHandler
          .processBatch(changeRequestList);
  
      final AsyncContext asyncContext = req.startAsync();
  
      asyncContext.addListener(
          new AsyncListener()
          {
            @Override
            public void onComplete(AsyncEvent event)
            {
            }
  
            @Override
            public void onTimeout(AsyncEvent event)
            {
  
              // HTTP 204 NO_CONTENT is sent to the client.
              future.cancel(true);
              event.getAsyncContext().complete();
            }
  
            @Override
            public void onError(AsyncEvent event)
            {
            }
  
            @Override
            public void onStartAsync(AsyncEvent event)
            {
            }
          }
      );
  
      Futures.addCallback(
          future,
          new FutureCallback<List<SegmentLoadDropHandler.DataSegmentChangeRequestAndStatus>>()
          {
            @Override
            public void onSuccess(List<SegmentLoadDropHandler.DataSegmentChangeRequestAndStatus> result)
            {
              try {
                HttpServletResponse response = (HttpServletResponse) asyncContext.getResponse();
                response.setStatus(HttpServletResponse.SC_OK);
                context.inputMapper.writerWithType(HttpLoadQueuePeon.RESPONSE_ENTITY_TYPE_REF)
                                   .writeValue(asyncContext.getResponse().getOutputStream(), result);
                asyncContext.complete();
              }
              catch (Exception ex) {
                log.debug(ex, "Request timed out or closed already.");
              }
            }
  
            @Override
            public void onFailure(Throwable th)
            {
              try {
                HttpServletResponse response = (HttpServletResponse) asyncContext.getResponse();
                if (th instanceof IllegalArgumentException) {
                  response.sendError(HttpServletResponse.SC_BAD_REQUEST, th.getMessage());
                } else {
                  response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, th.getMessage());
                }
                asyncContext.complete();
              }
              catch (Exception ex) {
                log.debug(ex, "Request timed out or closed already.");
              }
            }
          }
      );
  
      asyncContext.setTimeout(timeout);
    }