RandomCSDBServlet.java
package server.restful.servlets;
import com.beust.jcommander.Parameter;
import com.beust.jcommander.Parameters;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import jakarta.servlet.AsyncContext;
import jakarta.servlet.annotation.HttpConstraint;
import jakarta.servlet.annotation.ServletSecurity;
import jakarta.servlet.annotation.WebServlet;
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.parameter.ServletParameterParser;
import server.restful.common.parameter.UsageParameter;
import server.restful.common.parameter.requestpath.impl.FileRequestPathServletParametersImpl;
import server.restful.common.validator.MaxRowsValidator;
import server.restful.common.validator.RatingValidator;
import server.restful.common.validator.YearValidator;
import ui.assembly64.*;
import ui.common.Convenience;
import java.io.*;
import java.net.URISyntaxException;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import static java.lang.Integer.MIN_VALUE;
import static java.lang.String.valueOf;
import static java.util.stream.Collectors.toList;
import static server.restful.JSIDPlay2Server.*;
import static server.restful.common.IServletSystemProperties.RandomCSDBServlet.MAX_RANDOM_CSDB_IN_PARALLEL;
import static server.restful.common.IServletSystemProperties.RandomCSDBServlet.RANDOM_CSDB_ASYNC_TIMEOUT;
import static server.restful.common.ServletUtil.error;
import static server.restful.common.ServletUtil.info;
@WebServlet(name = "RandomCSDBServlet", displayName = "RandomCSDBServlet", asyncSupported = true, urlPatterns = CONTEXT_ROOT_SERVLET
+ "/random-csdb", description = "Get random CSDB content")
@ServletSecurity(value = @HttpConstraint(rolesAllowed = {ROLE_USER, ROLE_ADMIN}))
public class RandomCSDBServlet extends JSIDPlay2Servlet {
@SuppressWarnings("unused")
@Parameters(resourceBundle = "server.restful.servlets.RandomCSDBServletParameters")
public static class RandomCSDBServletParameters extends UsageParameter {
private Integer serverId;
public Integer getServerId() {
return serverId;
}
@Parameter(names = {"--serverId"}, descriptionKey = "SERVER_ID", order = MIN_VALUE + 1)
public void setServerId(Integer serverId) {
this.serverId = serverId;
}
private Integer maxRows = 200;
public Integer getMaxRows() {
return maxRows;
}
@Parameter(names = {
"--maxRows"}, descriptionKey = "MAX_ROWS", validateWith = MaxRowsValidator.class, order = MIN_VALUE + 2)
public void setMaxRows(Integer maxRows) {
this.maxRows = maxRows;
}
private String category = "music";
public String getCategory() {
return category;
}
@Parameter(names = {"--category"}, descriptionKey = "CATEGORY", order = MIN_VALUE + 3)
public void setCategory(String category) {
this.category = category;
}
private List<String> types;
public List<String> getTypes() {
return types;
}
@Parameter(names = {"--types"}, descriptionKey = "TYPES", order = MIN_VALUE + 4)
public void setTypes(List<String> types) {
this.types = types;
}
private Integer minRating;
public Integer getMinRating() {
return minRating;
}
@Parameter(names = {
"--minRating"}, descriptionKey = "RATING", validateWith = RatingValidator.class, order = MIN_VALUE + 5)
public void setMinRating(Integer rating) {
this.minRating = rating;
}
private Integer fromYear;
public Integer getFromYear() {
return fromYear;
}
@Parameter(names = {
"--fromYear"}, descriptionKey = "FROM_YEAR", validateWith = YearValidator.class, order = MIN_VALUE + 6)
public void setFromYear(Integer fromYear) {
this.fromYear = fromYear;
}
private Integer toYear;
public Integer getToYear() {
return toYear;
}
@Parameter(names = {
"--toYear"}, descriptionKey = "TO_YEAR", validateWith = YearValidator.class, order = MIN_VALUE + 7)
public void setToYear(Integer toYear) {
this.toYear = toYear;
}
private String handle = "";
public String getHandle() {
return handle;
}
@Parameter(names = {"--handle"}, descriptionKey = "HANDLE", order = MIN_VALUE + 8)
public void setHandle(String handle) {
this.handle = handle;
}
}
private ExecutorService executorService;
@Override
public void init() {
executorService = Executors.newFixedThreadPool(MAX_RANDOM_CSDB_IN_PARALLEL,
new DefaultThreadFactory("/random-csdb"));
}
@Override
public void destroy() {
executorService.shutdown();
}
/**
* Get random CSDB SID tune.
* <p>
* E.g. {@code http://haendel.ddns.net:8080/jsidplay2service/JSIDPlay2REST/random-csdb }
*/
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) {
AsyncContext asyncContext = request.startAsync(request, response);
asyncContext.setTimeout(RANDOM_CSDB_ASYNC_TIMEOUT);
executorService.execute(new HttpAsyncContextRunnable(asyncContext, getServletContext()) {
private Assembly64Client assembly64Client;
private Integer serverId;
private String categoryType;
public void run(HttpServletRequest request, HttpServletResponse response) {
try {
final RandomCSDBServletParameters servletParameters = new RandomCSDBServletParameters();
ServletParameterParser parser = new ServletParameterParser(request, response, servletParameters);
if (servletParameters.getHelp() || parser.hasException()) {
parser.usage();
return;
}
serverId = servletParameters.getServerId();
assembly64Client = new Assembly64Client(configuration, serverId, request.isUserInRole(ROLE_ADMIN));
Integer maxRows = servletParameters.getMaxRows();
String category = servletParameters.getCategory();
List<String> types = servletParameters.getTypes();
Integer minRating = servletParameters.getMinRating();
Integer fromYear = servletParameters.getFromYear();
Integer toYear = servletParameters.getToYear();
String handle = servletParameters.getHandle();
SearchResult searchResult = getRandomSearchResult(maxRows, category, types, minRating, fromYear,
toYear, handle);
File result = fetchRandomCSDB(parser, searchResult, types);
info(getServletContext(), String.format("randomCSDB: %s", result));
if (!isComplete()) {
response.setHeader("category", searchResult.getCategory().getName());
response.setHeader("name", searchResult.getName());
response.setHeader("group", searchResult.getGroup());
response.setHeader("event", searchResult.getEvent());
response.setHeader("handle", searchResult.getHandle());
response.setHeader("release",
searchResult.getReleased() != null ? valueOf(searchResult.getReleased()) : null);
response.setHeader("rating", valueOf(searchResult.getRating()));
setOutput(request, response, valueOf(result).replace("\\", "/"));
}
} catch (FileNotFoundException t) {
response.setStatus(HttpServletResponse.SC_NO_CONTENT);
} catch (Throwable t) {
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
error(getServletContext(), t);
setOutput(response, t);
}
}
private SearchResult getRandomSearchResult(Integer maxRows, String category, List<String> types,
Integer minRating, Integer fromYear, Integer toYear, String handle)
throws URISyntaxException, IOException {
Collection<Presets> presets = assembly64Client.getPresets();
List<Category> categories = Assembly64Client.categories(presets);
categoryType = Assembly64Client.categoryType(presets);
String query = createSearchQuery(category, types, minRating, fromYear, toYear, handle);
SearchResult[] searchResults = createObjectMapper(categories).readerFor(SearchResult[].class)
.readValue(assembly64Client.search(query, 0, maxRows));
int max = Math.min(searchResults.length, maxRows);
SearchResult searchResult = searchResults.length > 0 ? searchResults[RANDOM.nextInt(max)] : null;
if (searchResult == null) {
throw new FileNotFoundException("No search results found!");
}
return searchResult;
}
private File fetchRandomCSDB(ServletParameterParser parser, SearchResult searchResult, List<String> types)
throws IOException, URISyntaxException {
List<ContentEntry> contentEntries = fetchContentEntries(searchResult.getId(),
searchResult.getCategory().getId());
final ContentEntry randomAudioContentEntry = getRandomContentEntry(types, contentEntries);
FileRequestPathServletParametersImpl randomFileRequestPathServletParameters = new FileRequestPathServletParametersImpl() {
@Override
public Integer getServerId() {
return serverId;
}
@Override
public String getItemId() {
return searchResult.getId();
}
@Override
public String getFilePath() {
return "/" + randomAudioContentEntry.getPath();
}
@Override
public String getCategoryId() {
return valueOf(searchResult.getCategory().getId());
}
};
return randomFileRequestPathServletParameters.fetchFile(configuration, directoryProperties, parser,
hasAdminAccess(request));
}
private ContentEntry getRandomContentEntry(List<String> types, List<ContentEntry> contentEntries) throws FileNotFoundException {
if (types != null) {
for (String type : types) {
List<ContentEntry> filtered = contentEntries.stream().filter(
entry -> new File(entry.getPath()).getName().toLowerCase(Locale.ENGLISH).endsWith(type))
.collect(toList());
if (!filtered.isEmpty()) {
return filtered.get(RANDOM.nextInt(filtered.size()));
}
}
} else {
if (!contentEntries.isEmpty()) {
return contentEntries.get(RANDOM.nextInt(contentEntries.size()));
}
}
throw new FileNotFoundException("No content entries found!");
}
private String createSearchQuery(String category, List<String> types, Integer minRating,
Integer fromYear, Integer toYear, String handle) {
List<String> terms = new ArrayList<>();
if (category != null && !category.isBlank()) terms.add(categoryType + ":" + category);
if (types != null && !types.isEmpty()) terms.add("type:" + String.join(",", types));
if (minRating != null && minRating != 0) terms.add("rating:>=" + minRating);
if (fromYear != null && toYear != null) {
int year = (int) (Math.random() * (toYear - fromYear + 1)) + fromYear;
terms.add("date:" + year);
}
if (handle != null && !handle.isBlank()) terms.add("handle:\"" + handle + "\"");
return String.join(" ", terms);
}
private List<ContentEntry> fetchContentEntries(String id, Integer categoryId) throws IOException {
return assembly64Client.entries(id, String.valueOf(categoryId)).getContentEntry().stream()
.filter(e -> e.getPath() != null && !e.getPath().startsWith(Convenience.MACOSX)).collect(toList());
}
private ObjectMapper createObjectMapper(List<Category> categories) {
ObjectMapper objectMapper = new ObjectMapper();
JavaTimeModule module = new JavaTimeModule();
module.addDeserializer(Category.class, new CategoryDeserializer(categories));
objectMapper.registerModule(module);
return objectMapper;
}
});
}
}