PlaybackServlet.java

package server.restful.servlets;

import com.beust.jcommander.Parameter;
import com.beust.jcommander.Parameters;
import jakarta.servlet.AsyncContext;
import jakarta.servlet.annotation.HttpConstraint;
import jakarta.servlet.annotation.MultipartConfig;
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 jakarta.servlet.http.Part;
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 server.restful.common.playback.PlaybackLaunch;
import server.restful.common.playback.PlaybackService;
import ui.entities.config.Configuration;

import java.io.IOException;
import java.io.InputStream;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static java.lang.Integer.MIN_VALUE;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.apache.tomcat.util.http.fileupload.FileUploadBase.ATTACHMENT;
import static org.apache.tomcat.util.http.fileupload.FileUploadBase.CONTENT_DISPOSITION;
import static server.restful.JSIDPlay2Server.*;
import static server.restful.common.ContentTypeAndFileExtensions.MIME_TYPE_JSON;
import static server.restful.common.IServletSystemProperties.PlaybackServlet.MAX_PLAYBACKS_IN_PARALLEL;
import static server.restful.common.IServletSystemProperties.PlaybackServlet.PLAYBACK_ASYNC_TIMEOUT;
import static server.restful.common.IServletSystemProperties.UploadServlet.*;
import static server.restful.common.ServletUtil.error;
import static server.restful.common.filters.CounterBasedRateLimiterFilter.FILTER_PARAMETER_MAX_REQUESTS_PER_SERVLET;

@WebServlet(name = "PlaybackServlet", displayName = "PlaybackServlet", asyncSupported = true,
        urlPatterns = CONTEXT_ROOT_SERVLET + "/playback/*",
        description = "Resolve, share and download content with its companions")
@ServletSecurity(value = @HttpConstraint(rolesAllowed = {ROLE_USER, ROLE_ADMIN}))
@MultipartConfig(maxFileSize = UPLOADSERVLET_MAX_FILE_SIZE, maxRequestSize = UPLOADSERVLET_MAX_REQUEST_SIZE,
        fileSizeThreshold = UPLOADSERVLET_FILE_SIZE_THRESHOLD)
public class PlaybackServlet extends JSIDPlay2Servlet {

    @SuppressWarnings("unused")
    @Parameters(resourceBundle = "server.restful.servlets.PlaybackServletParameters")
    public static class PlaybackServletParameters extends UsageParameter {

        private String filePath;

        public String getFilePath() {
            return filePath;
        }

        @Parameter(descriptionKey = "FILE_PATH", order = MIN_VALUE + 1)
        public void setFilePath(String filePath) {
            this.filePath = filePath;
        }

        private Integer serverId;

        public Integer getServerId() {
            return serverId;
        }

        @Parameter(names = "--serverId", descriptionKey = "SERVER_ID", order = MIN_VALUE + 2)
        public void setServerId(Integer serverId) {
            this.serverId = serverId;
        }

        private String itemId;

        public String getItemId() {
            return itemId;
        }

        @Parameter(names = "--itemId", descriptionKey = "ITEM_ID", order = MIN_VALUE + 3)
        public void setItemId(String itemId) {
            this.itemId = itemId;
        }

        private String categoryId;

        public String getCategoryId() {
            return categoryId;
        }

        @Parameter(names = "--categoryId", descriptionKey = "CATEGORY_ID", order = MIN_VALUE + 4)
        public void setCategoryId(String categoryId) {
            this.categoryId = categoryId;
        }

        private String share;

        public String getShare() {
            return share;
        }

        @Parameter(names = "--share", descriptionKey = "SHARE", order = MIN_VALUE + 5)
        public void setShare(String share) {
            this.share = share;
        }

        private Boolean bundle = Boolean.FALSE;

        public Boolean getBundle() {
            return bundle;
        }

        @Parameter(names = "--bundle", arity = 1, descriptionKey = "BUNDLE", order = MIN_VALUE + 6)
        public void setBundle(Boolean bundle) {
            this.bundle = bundle;
        }

        private String manifest;

        public String getManifest() {
            return manifest;
        }

        @Parameter(names = "--manifest", descriptionKey = "MANIFEST", hidden = true, order = MIN_VALUE + 7)
        public void setManifest(String manifest) {
            this.manifest = manifest;
        }

        public PlaybackLaunch fetchLaunch(Configuration configuration, Properties directoryProperties,
                                          ServletParameterParser parser, boolean hasAdminAccess) {
            if (getHelp() || parser.hasException()) return null;
            PlaybackService service = new PlaybackService(configuration, directoryProperties, hasAdminAccess);
            try {
                return getShare() == null
                        ? service.discover(new PlaybackLaunch.Resource(getFilePath(), getItemId(), getCategoryId(), getServerId()))
                        : service.read(getShare());
            } catch (IOException | URISyntaxException | IllegalArgumentException e) {
                parser.setException(e);
                return null;
            }
        }
    }

    private ExecutorService executorService;

    @Override
    public void init() {
        executorService = Executors.newFixedThreadPool(MAX_PLAYBACKS_IN_PARALLEL, new DefaultThreadFactory("/playback"));
    }

    @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,
                String.valueOf(MAX_PLAYBACKS_IN_PARALLEL));
        result.put(CounterBasedRateLimiterFilter.class, counterBasedRateLimiterFilterParameters);

        return result;
    }

    /**
     * Resolve a content path or saved share; optionally download a portable ZIP bundle.
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        AsyncContext asyncContext = request.startAsync(request, response);
        asyncContext.setTimeout(PLAYBACK_ASYNC_TIMEOUT);

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

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

                    final PlaybackLaunch launch = servletParameters.fetchLaunch(configuration, directoryProperties, parser,
                            hasAdminAccess(request));
                    if (launch == null || servletParameters.getHelp() || parser.hasException()) {
                        parser.usage();
                        return;
                    }
                    PlaybackService service = new PlaybackService(configuration, directoryProperties, hasAdminAccess(request));
                    if (!isComplete()) {
                        if (servletParameters.getBundle()) {
                            response.setContentType("application/zip");
                            response.setHeader(CONTENT_DISPOSITION, ATTACHMENT + "; filename=\"content-with-companions.zip\"");
                            service.bundle(launch, response.getOutputStream());
                        } else {
                            setOutput(MIME_TYPE_JSON, response, launch);
                        }
                    }
                } catch (Throwable t) {
                    error(getServletContext(), t, parentThread);
                    if (!isComplete()) {
                        response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                        setOutput(response, t);
                    }
                }
            }
        });
    }

    /**
     * Save a multipart launch and its local files, or import an uploaded ZIP bundle.
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) {
        AsyncContext asyncContext = request.startAsync(request, response);
        asyncContext.setTimeout(PLAYBACK_ASYNC_TIMEOUT);

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

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

                    if (servletParameters.getHelp() || parser.hasException()) {
                        parser.usage();
                        return;
                    }
                    PlaybackService service = new PlaybackService(configuration, directoryProperties, hasAdminAccess(request));
                    PlaybackLaunch launch;
                    Part bundle = request.getPart("bundle");
                    if (bundle != null) {
                        try (InputStream input = bundle.getInputStream()) {
                            launch = service.importBundle(input);
                        }
                    } else {
                        String manifest = servletParameters.getManifest();
                        if (manifest == null) {
                            Part part = request.getPart("manifest");
                            if (part == null) throw new IllegalArgumentException("Missing launch description");
                            try (InputStream input = part.getInputStream()) {
                                manifest = new String(input.readAllBytes(), UTF_8);
                            }
                        }
                        Map<String, Part> uploads = new HashMap<>();
                        for (Part part : request.getParts()) uploads.put(part.getName(), part);
                        launch = service.save(OBJECT_MAPPER.readValue(manifest, PlaybackLaunch.class), uploads);
                    }
                    if (!isComplete()) {
                        setOutput(MIME_TYPE_JSON, response, launch);
                    }
                } catch (Throwable t) {
                    error(getServletContext(), t, parentThread);
                    if (!isComplete()) {
                        response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                        setOutput(response, t);
                    }
                }
            }
        });
    }
}