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);
}
}
}
});
}
}