UploadServlet.java

package server.restful.servlets;

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.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import libsidutils.IOUtils;
import libsidutils.ZipFileUtils;
import net.java.truevfs.access.TArchiveDetector;
import net.java.truevfs.access.TFile;
import server.restful.common.JSIDPlay2Servlet;
import server.restful.common.UploadContents;
import server.restful.common.async.DefaultThreadFactory;
import server.restful.common.async.HttpAsyncContextRunnable;
import server.restful.common.parameter.RequestResponseBodyParameter;
import server.restful.common.parameter.ServletParameterParser;
import server.restful.common.parameter.requestpath.NewFileRequestPathServletParameters;
import ui.common.util.Extract7ZipUtil;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.BiPredicate;
import java.util.zip.GZIPInputStream;

import static java.lang.String.format;
import static java.lang.String.valueOf;
import static libsidutils.IOUtils.getPhysicalSize;
import static server.restful.JSIDPlay2Server.*;
import static server.restful.common.IServletSystemProperties.UploadServlet.*;
import static server.restful.common.ServletUtil.error;
import static server.restful.common.ServletUtil.info;
import static ui.common.Convenience.*;

@WebServlet(name = "UploadServlet", displayName = "UploadServlet", asyncSupported = true, urlPatterns = CONTEXT_ROOT_SERVLET
        + "/upload/*", description = "Upload any C64 content to play it back")
@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 UploadServlet extends JSIDPlay2Servlet {

    @Parameters(resourceBundle = "server.restful.servlets.UploadServletParameters")
    public static class UploadServletParameters extends NewFileRequestPathServletParameters
            implements RequestResponseBodyParameter<UploadContents, String> {

        @Override
        public UploadContents getRequestBodyExample() {
            return new UploadContents(new byte[]{0x50, 0x53, 0x49, 0x44, 0x00, 0x02, 0x00, 0x7C, 0x00, 0x00, 0x10,
                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x6F, 0x6E,
                    0x67, 0x20, 0x4E, 0x61, 0x6D});
        }

        @Override
        public String getResponseBodyExample() {
            return "/path/to/file";
        }
    }

    private ExecutorService executorService;

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

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

    /**
     * Upload any C64 content to a temporary server location to play back (can be any C64 resource even packed
     * contents).
     * <p>
     * E.g. {@code http://haendel.ddns.net:8080/jsidplay2service/JSIDPlay2REST/upload/Outro.sid }
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) {

        AsyncContext asyncContext = request.startAsync(request, response);
        asyncContext.setTimeout(UPLOAD_ASYNC_TIMEOUT);

        executorService.execute(new HttpAsyncContextRunnable(asyncContext, getServletContext()) {

            public void run(HttpServletRequest request, HttpServletResponse response) {
                try {
                    final UploadServletParameters servletParameters = new UploadServletParameters();

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

                    if (servletParameters.getHelp() || parser.hasException()) {
                        parser.usage();
                        return;
                    }
                    UploadContents uploadContents = getInput(request, UploadContents.class);
                    File file = servletParameters.create(configuration, uploadContents.getContents());

                    info(getServletContext(), format("uploaded: %s (%s)", file, getPhysicalSize(file.length())));

                    File result = extractUploadFile(file);

                    if (!isComplete()) {
                        setOutput(request, response, valueOf(result).replace("\\", "/"));
                    }
                } catch (Throwable t) {
                    error(getServletContext(), t);
                    if (!isComplete()) {
                        response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                        setOutput(response, t);
                    }
                }
            }

            private File extractUploadFile(File file) throws IOException {
                File tmpDir = file.getParentFile();

                TFile tFile = new TFile(file);
                File uploadResult;

                if (file.getName().toLowerCase(Locale.ENGLISH).endsWith(".zip")) {
                    // uncompress zip
                    TFile.cp_rp(tFile, tmpDir, TArchiveDetector.ALL);
                    uploadResult = getUploadResult(tmpDir, LEXICALLY_FIRST_MEDIA, null);
                } else if (file.getName().toLowerCase(Locale.ENGLISH).endsWith(".gz")) {
                    // uncompress gzip
                    File dst = new File(tmpDir, IOUtils.getFilenameWithoutSuffix(file.getName()));
                    try (InputStream is = new GZIPInputStream(ZipFileUtils.newFileInputStream(file))) {
                        TFile.cp(is, dst);
                    }
                    uploadResult = getUploadResult(tmpDir, LEXICALLY_FIRST_MEDIA, null);
                } else if (file.getName().toLowerCase(Locale.ENGLISH).endsWith(".7z")) {
                    // uncompress 7zip
                    Extract7ZipUtil extract7Zip = new Extract7ZipUtil(tFile, tmpDir);
                    extract7Zip.extract();
                    uploadResult = getUploadResult(tmpDir, LEXICALLY_FIRST_MEDIA, null);
                } else {
                    uploadResult = file;
                }
                return uploadResult;
            }

            private File getUploadResult(File dir, BiPredicate<File, File> mediaTester, File uploadResult) {
                final File[] listFiles = dir.listFiles();
                if (listFiles == null) {
                    return null;
                }
                final List<File> asList = Arrays.asList(listFiles);
                asList.sort(TOP_LEVEL_FIRST_COMPARATOR);
                for (File member : asList) {
                    File memberFile = new File(dir, member.getName());
                    if (memberFile.isFile() && (CART_FILE_FILTER.accept(memberFile)
                            || AUDIO_TUNE_FILE_FILTER.accept(memberFile) || VIDEO_TUNE_FILE_FILTER.accept(memberFile)
                            || DISK_FILE_FILTER.accept(memberFile) || TAPE_FILE_FILTER.accept(memberFile))) {

                        if (mediaTester.test(memberFile, uploadResult)) {
                            uploadResult = memberFile;
                        }
                    } else if (memberFile.isDirectory() && !memberFile.getName().equals(MACOSX)) {
                        File toAttachChild = getUploadResult(memberFile, mediaTester, uploadResult);
                        if (toAttachChild != null) {
                            uploadResult = toAttachChild;
                        }
                    }
                }
                return uploadResult;
            }

        });
    }

}