JSIDPlay2Servlet.java

package server.restful.common;

import client.teavm.common.parameter.StringBuilderConsole;
import client.teavm.common.parameter.event.ExportEventParameters;
import client.teavm.common.parameter.usage.EventDiscriminatorUsageFormatter;
import com.beust.jcommander.Parameters;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.annotation.ServletSecurity;
import jakarta.servlet.http.*;
import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.JAXBException;
import libsidplay.sidtune.SidTune;
import libsidplay.sidtune.SidTuneError;
import libsidutils.IOUtils;
import libsidutils.siddatabase.SidDatabase;
import libsidutils.stil.STIL;
import server.restful.common.converter.WebResourceConverter;
import server.restful.common.parameter.ServletParameterParser;
import server.restful.common.parameter.UsageParameter;
import sidplay.filefilter.AudioTuneFileFilter;
import sidplay.filefilter.VideoTuneFileFilter;
import ui.assembly64.Assembly64AccessDeniedException;
import ui.common.filefilter.CartFileFilter;
import ui.common.filefilter.DiskFileFilter;
import ui.common.filefilter.TapeFileFilter;
import ui.entities.config.Configuration;

import javax.inject.Inject;
import javax.xml.transform.stream.StreamSource;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.util.*;

import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.Arrays.asList;
import static java.util.Optional.ofNullable;
import static libsidutils.IOUtils.convertStreamToString;
import static libsidutils.IOUtils.copy;
import static org.apache.http.HttpHeaders.ACCEPT;
import static server.restful.JSIDPlay2Server.ROLE_ADMIN;
import static server.restful.common.ContentTypeAndFileExtensions.*;
import static server.restful.common.ServletUtil.error;
import static server.restful.common.ServletUtil.isSecured;

@SuppressWarnings("serial")
public abstract class JSIDPlay2Servlet extends HttpServlet {

    @Parameters(resourceBundle = "server.restful.common.UsageParameter")
    public static class PureUsageParameter extends UsageParameter {

    }

    public static final Random RANDOM = new Random();
    public static final AudioTuneFileFilter AUDIO_TUNE_FILE_FILTER = new AudioTuneFileFilter();
    public static final VideoTuneFileFilter VIDEO_TUNE_FILE_FILTER = new VideoTuneFileFilter();
    public static final DiskFileFilter DISK_FILE_FILTER = new DiskFileFilter();
    public static final TapeFileFilter TAPE_FILE_FILTER = new TapeFileFilter();
    public static final CartFileFilter CART_FILE_FILTER = new CartFileFilter();
    public static final ObjectMapper OBJECT_MAPPER = new ObjectMapper().registerModule(new JavaTimeModule())
            .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

    public static final String C64_MUSIC = "/C64Music";
    public static final String CGSC = "/CGSC";

    protected static final String SERVLET_PATH = "<ServletPath>";
    public static final String DEV_TOOLS_SECTION1 = convertStreamToString(
            new WebResourceConverter(SERVLET_PATH).convert("/teavm/devtools_section_1.js"), UTF_8);
    public static final String DEV_TOOLS_SECTION2 = convertStreamToString(
            new WebResourceConverter(SERVLET_PATH).convert("/teavm/devtools_section_2.js"), UTF_8);
    public static final StringBuilder DISCRIMINATOR_PATH = new StringBuilder();

    static {
        ExportEventParameters.usage(new StringBuilderConsole(DISCRIMINATOR_PATH),
                EventDiscriminatorUsageFormatter::new);
    }

    @Inject
    protected Configuration configuration;

    @Inject
    protected SidDatabase sidDatabase;

    @Inject
    protected STIL stil;

    @Inject
    protected Properties directoryProperties;

    public Map<Class<? extends HttpFilter>, Map<String, String>> getServletFiltersParameterMap() {
        return Collections.emptyMap();
    }

    protected boolean hasAdminAccess(HttpServletRequest request) {
        ServletSecurity servletSecurity = JSIDPlay2Servlet.this.getClass().getAnnotation(ServletSecurity.class);
        return !isSecured(servletSecurity) || request.isUserInRole(ROLE_ADMIN);
    }

    /**
     * By default, provide a usage message even for POST requests. If no usage is requested, return status code 405
     * (Method not Allowed)
     * <p>
     * <B>Assumption:</B> All servlet methods are GET or POST and provide a usage.
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        final PureUsageParameter servletParameters = new PureUsageParameter();

        new ServletParameterParser(request, response, servletParameters, true);

        if (servletParameters.getHelp()) {
            doPost(new HttpServletRequestWrapper(request) {

                @Override
                public String getMethod() {
                    return "POST";
                }
            }, response);
        } else {
            // handle non-usage case, e.g., return status code 405 (Method not Allowed)
            super.doGet(request, response);
        }
    }

    protected String getCollectionName(File file) throws IOException, SidTuneError {
        String result = "";

        File hvscRoot = configuration.getSidplay2Section().getHvsc();
        if (hvscRoot != null) {
            // 1st Try from full path name...
            result = IOUtils.getCollectionName(hvscRoot, file);
            if (result.isEmpty()) {
                // ... then try from MD5
                result = sidDatabase != null ? sidDatabase.getPath(SidTune.load(file)) : "";
            }
        }
        return result;
    }

    protected <T> T getInput(HttpServletRequest request, Class<T> tClass) throws IOException {
        try (ServletInputStream inputStream = request.getInputStream()) {
            String contentType = request.getContentType();
            if (contentType == null || MIME_TYPE_JSON.isCompatible(contentType)) {
                return OBJECT_MAPPER.readValue(inputStream, tClass);
            } else if (MIME_TYPE_XML.isCompatible(contentType)) {
                return JAXBContext.newInstance(tClass).createUnmarshaller()
                        .unmarshal(new StreamSource(new InputStreamReader(inputStream, UTF_8)), tClass)
                        .getValue();
            } else /* file upload */ {
                for (Part part : request.getParts()) {
                    ByteArrayOutputStream result = new ByteArrayOutputStream();
                    try (InputStream itemInputStream = part.getInputStream()) {
                        IOUtils.copy(itemInputStream, result);
                    }
                    return tClass.getConstructor(new Class[]{byte[].class}).newInstance(result.toByteArray());
                }
                throw new IOException("Upload without content!");
            }
        } catch (IOException | JAXBException | InstantiationException | IllegalAccessException
                 | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException
                 | ServletException e) {
            throw new IOException(e);
        }
    }

    protected void setOutput(HttpServletRequest request, HttpServletResponse response, Object result) {
        try {
            Optional<String> optionalContentType = ofNullable(request.getHeader(ACCEPT))
                    .map(accept -> asList(accept.split(","))).orElse(Collections.emptyList()).stream().findFirst();
            if (!optionalContentType.isPresent() || MIME_TYPE_JSON.isCompatible(optionalContentType.get())) {
                setOutput(MIME_TYPE_JSON, response, result);
            } else if (MIME_TYPE_XML.isCompatible(optionalContentType.get())) {
                setOutput(MIME_TYPE_XML, response, result);
            } else {
                throw new IOException(String.format("Unsupported content type: %s!", optionalContentType.get()));
            }
        } catch (IOException e) {
            error(getServletContext(), e);
        }
    }

    protected void setOutput(ContentTypeAndFileExtensions ct, HttpServletResponse response, Object result) {
        if (result == null) {
            return;
        }
        try (ServletOutputStream out = response.getOutputStream()) {
            if (MIME_TYPE_JSON.isCompatible(ct.toString())) {
                response.setContentType(MIME_TYPE_JSON.toString());
                OBJECT_MAPPER.writeValue(out, result);
            } else if (MIME_TYPE_XML.isCompatible(ct.toString())) {
                response.setContentType(MIME_TYPE_XML.toString());
                JAXBContext.newInstance(result.getClass()).createMarshaller().marshal(result, out);
            } else {
                throw new IOException(String.format("Unsupported content type: %s!", ct));
            }
        } catch (IOException | JAXBException e) {
            error(getServletContext(), e);
        }
    }

    protected void setOutput(ContentTypeAndFileExtensions ct, HttpServletResponse response, InputStream is) {
        if (is == null) {
            return;
        }
        try (ServletOutputStream out = response.getOutputStream()) {
            response.setContentType(ct.toString());
            copy(is, out);
        } catch (IOException e) {
            error(getServletContext(), e);
        }
    }

    protected void setOutput(HttpServletResponse response, Throwable t) {
        if (t instanceof Assembly64AccessDeniedException) response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        setOutput(MIME_TYPE_TEXT, response, t.getClass().getSimpleName() + ": " + t.getMessage());
    }

    protected void setOutput(ContentTypeAndFileExtensions ct, HttpServletResponse response, String message) {
        response.setContentType(ct.toString());
        try (PrintStream out = new PrintStream(response.getOutputStream(), true,
                ofNullable(ct.getCharset()).orElse(UTF_8))) {
            out.print(message);
        } catch (IOException e) {
            error(getServletContext(), e);
        }
    }

}