DiskChangeSuggestServlet.java

package server.restful.servlets.autoplay;

import com.beust.jcommander.Parameter;
import com.beust.jcommander.Parameters;
import jakarta.servlet.AsyncContext;
import jakarta.servlet.annotation.HttpConstraint;
import jakarta.servlet.annotation.ServletSecurity;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import server.restful.common.JSIDPlay2Servlet;
import server.restful.common.async.DefaultThreadFactory;
import server.restful.common.async.HttpAsyncContextRunnable;
import server.restful.common.filters.CounterBasedRateLimiterFilter;
import server.restful.common.parameter.ServletParameterParser;
import server.restful.common.parameter.UsageParameter;
import ui.entities.statistics.service.NextDiskInfo;
import ui.entities.statistics.service.StatisticsService;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.*;

import static java.lang.Integer.MIN_VALUE;
import static java.lang.String.valueOf;
import static org.apache.http.HttpStatus.SC_TOO_MANY_REQUESTS;
import static server.restful.JSIDPlay2Server.*;
import static server.restful.common.ContentTypeAndFileExtensions.MIME_TYPE_OCTET_STREAM;
import static server.restful.common.IServletSystemProperties.DiskChangeSuggestServlet.*;
import static server.restful.common.ServletUtil.error;
import static server.restful.common.filters.CounterBasedRateLimiterFilter.FILTER_PARAMETER_MAX_REQUESTS_PER_SERVLET;

@WebServlet(name = "DiskChangeSuggestServlet", displayName = "DiskChangeSuggestServlet", asyncSupported = true, urlPatterns = CONTEXT_ROOT_SERVLET + "/disk-change-suggest", description = "Get next disk")
@ServletSecurity(value = @HttpConstraint(rolesAllowed = {ROLE_USER, ROLE_ADMIN}))
public class DiskChangeSuggestServlet extends JSIDPlay2Servlet {

    @Parameters(resourceBundle = "server.restful.servlets.autoplay.DiskChangeSuggestServletParameters")
    public static class DiskChangeSuggestServletParameters extends UsageParameter {

        private String diskMd5;

        public String getDiskMd5() {
            return diskMd5;
        }

        @Parameter(names = {"--diskMd5"}, descriptionKey = "DISK_MD5", required = true, order = MIN_VALUE + 1)
        public void setDiskMd5(String diskMd5) {
            this.diskMd5 = diskMd5;
        }

        private Boolean jiffyDos = true;

        public Boolean isJiffyDos() {
            return this.jiffyDos;
        }

        @Parameter(names = {"--jiffydos"}, arity = 1, descriptionKey = "JIFFYDOS", order = MIN_VALUE + 2)
        public void setJiffyDos(Boolean jiffyDos) {
            this.jiffyDos = jiffyDos;
        }

        Long id = 0L;

        public Long getId() {
            return this.id;
        }

        @Parameter(names = {"--id"}, descriptionKey = "ID", order = MIN_VALUE + 3)
        public void setId(Long id) {
            this.id = id;
        }

    }

    private ExecutorService executorService;

    @Override
    public void init() {
        executorService = new ThreadPoolExecutor(MAX_DISK_CHANGE_SUGGEST_IN_PARALLEL_CORE, MAX_DISK_CHANGE_SUGGEST_IN_PARALLEL, DISK_CHANGE_SUGGEST_KEEPALIVE_TIME, TimeUnit.SECONDS, new ArrayBlockingQueue<>(DISK_CHANGE_SUGGEST_QUEUE_SIZE), new DefaultThreadFactory("/disk-change-suggest"), new ThreadPoolExecutor.AbortPolicy());
    }

    @Override
    public void destroy() {
        executorService.shutdown();
    }

    @Override
    public Map<Class<? extends HttpFilter>, Map<String, String>> getServletFiltersParameterMap() {
        Map<Class<? extends HttpFilter>, Map<String, String>> result = new HashMap<>();

        Map<String, String> counterBasedRateLimiterFilterParameters = new HashMap<>();
        counterBasedRateLimiterFilterParameters.put(FILTER_PARAMETER_MAX_REQUESTS_PER_SERVLET, valueOf(MAX_DISK_CHANGE_SUGGEST));
        result.put(CounterBasedRateLimiterFilter.class, counterBasedRateLimiterFilterParameters);

        return result;
    }

    /**
     * Find the next disk to insert.
     * <p>
     * E.g. {@code http://haendel.ddns.net:8080/jsidplay2service/JSIDPlay2REST/disk-change-suggest }
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        AsyncContext asyncContext = request.startAsync(request, response);
        asyncContext.setTimeout(DISK_CHANGE_SUGGEST_ASYNC_TIMEOUT);

        try {
            executorService.execute(new HttpAsyncContextRunnable(asyncContext, getServletContext()) {
                public void run(HttpServletRequest request, HttpServletResponse response) {
                    try {
                        final DiskChangeSuggestServletParameters servletParameters = new DiskChangeSuggestServletParameters();

                        ServletParameterParser parser = new ServletParameterParser(request, response, servletParameters);

                        if (servletParameters.getHelp() || parser.hasException()) {
                            parser.usage();
                            return;
                        }
                        String diskMd5 = servletParameters.getDiskMd5();
                        boolean jiffyDos = servletParameters.isJiffyDos();
                        Long id = servletParameters.getId();

                        StatisticsService statisticsService = new StatisticsService(getStatisticsEntityManager());
                        Optional<NextDiskInfo> optionalNextDisk = statisticsService.findNextDisk(diskMd5, jiffyDos, id);

                        if (!isComplete()) {
                            byte[] data = optionalNextDisk.map(NextDiskInfo::getData).orElseGet(() -> new byte[0]);
                            response.setHeader("name", optionalNextDisk.map(NextDiskInfo::getName).orElse(""));
                            response.setHeader("ticks", valueOf(optionalNextDisk.map(NextDiskInfo::getTicks).orElse(0L)));
                            response.setHeader("id", valueOf(optionalNextDisk.map(NextDiskInfo::getId).orElse(0L)));
                            response.setContentLength(data.length);
                            setOutput(MIME_TYPE_OCTET_STREAM, response, new ByteArrayInputStream(data));
                        }
                    } catch (Throwable t) {
                        response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                        error(getServletContext(), t);
                        setOutput(response, t);
                    } finally {
                        freeStatisticsEntityManager();
                    }
                }
            });
        } catch (RejectedExecutionException e) {
            error(getServletContext(), e);
            response.sendError(SC_TOO_MANY_REQUESTS, "Too Many Requests");
        }
    }
}