ServletParameterHelper.java
package server.restful.common.parameter;
import com.beust.jcommander.Parameter;
import com.beust.jcommander.Parameters;
import com.beust.jcommander.ParametersDelegate;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver;
import com.fasterxml.jackson.databind.ser.PropertyWriter;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import libsidutils.IOUtils;
import org.hibernate.type.descriptor.java.LocaleJavaType.LocaleComparator;
import server.restful.servlets.ConvertServlet;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.nio.ByteBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CodingErrorAction;
import java.util.AbstractMap.SimpleEntry;
import java.util.*;
import java.util.Map.Entry;
import java.util.ResourceBundle.Control;
import java.util.logging.Level;
import java.util.logging.Logger;
import static com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility.ANY;
import static java.lang.String.format;
import static java.nio.charset.StandardCharsets.US_ASCII;
import static java.util.stream.Collectors.toList;
import static libsidplay.common.ChipModel.MOS6581;
import static libsidplay.common.ChipModel.MOS8580;
import static libsidplay.common.Emulation.*;
import static server.restful.common.parameter.ConvertStubGenerator.createConvertMessagesStub;
import static server.restful.common.parameter.ConvertStubGenerator.createConvertOptionsStub;
import static sidplay.ini.IniDefaults.DEFAULTS;
/**
* Provides parameter default values and localization of ConvertServlet as well as parameter checks to spot development
* errors.
*
* @author ken
*
*/
public class ServletParameterHelper {
private static final Logger LOG = Logger.getLogger(ServletParameterHelper.class.getName());
private static final ResourceBundle ERRORS = ResourceBundle
.getBundle("server.restful.common.parameter.ServletParameterHelper");
public static final List<Locale> SUPPORTED_LOCALES = Collections
.unmodifiableList(Arrays.asList(Locale.ROOT /* ENGLISH */, Locale.GERMAN));
public static final String CONVERT_OPTIONS;
public static final String FILTER_NAMES_RESID_MOS6581;
public static final String FILTER_NAMES_RESID_MOS8580;
public static final String FILTER_NAMES_RESIDFP_MOS6581;
public static final String FILTER_NAMES_RESIDFP_CIRCUIT_MOS6581;
public static final String FILTER_NAMES_RESIDFP_MOS8580;
public static final String FILTER_NAMES_RESIDFP_CIRCUIT_MOS8580;
public static final Map<Locale, String> CONVERT_MESSAGES;
public static final String CONVERT_MESSAGES_TS;
public static final String CONVERT_OPTIONS_TS;
static {
try {
ObjectMapper objectMapper = new ObjectMapper();
CONVERT_OPTIONS = objectMapper.writeValueAsString(new ConvertServlet.ConvertServletParameters());
CONVERT_OPTIONS_TS = createConvertOptionsStub("convertOptions", new ConvertServlet.ConvertServletParameters());
FILTER_NAMES_RESID_MOS6581 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESID, MOS6581));
FILTER_NAMES_RESID_MOS8580 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESID, MOS8580));
FILTER_NAMES_RESIDFP_MOS6581 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESIDFP, MOS6581));
FILTER_NAMES_RESIDFP_MOS8580 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESIDFP, MOS8580));
FILTER_NAMES_RESIDFP_CIRCUIT_MOS6581 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESIDFP_CIRCUIT, MOS6581));
FILTER_NAMES_RESIDFP_CIRCUIT_MOS8580 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESIDFP_CIRCUIT, MOS8580));
Map<Locale, String> convertMessages = new HashMap<>();
for (Locale locale : SUPPORTED_LOCALES) {
convertMessages.put(locale, createObjectMapper(new BeanParameterLocalizer(locale))
.writeValueAsString(new ConvertServlet.ConvertServletParameters()));
}
CONVERT_MESSAGES = Collections.unmodifiableMap(convertMessages);
CONVERT_MESSAGES_TS = createConvertMessagesStub("convertMessages", new ConvertServlet.ConvertServletParameters());
} catch (JsonProcessingException e) {
throw new ExceptionInInitializerError(e);
}
}
/**
* Options have exactly one character.
*/
public static final int OPTION_MAX_LENGTH = 1;
/**
* GNU options have at least two characters.
*/
public static final int GNU_OPTION_MIN_LENGTH = 2;
public static void check(Class<?> servletParameterClass, boolean servletParameter)
throws ExceptionInInitializerError {
try {
LOG.info(servletParameterClass.getName());
Optional.ofNullable(servletParameterClass.getAnnotation(Parameters.class))
.orElseThrow(() -> new IllegalAccessException(
format(ERRORS.getString("CHECKED_CLASS_MUST_BE_ANNOTATED_WITH_PARAMETERS"),
servletParameterClass)));
if (servletParameterClass.getAnnotation(Parameters.class).resourceBundle().isEmpty()) {
throw new IllegalAccessException(
format(ERRORS.getString("RESOURCE_BUNDLE_ATTR_MISSING"), servletParameterClass));
}
Constructor<?> declaredConstructor = servletParameterClass.getDeclaredConstructor();
declaredConstructor.setAccessible(true);
BeanParameterChecker beanParameterChecker = new BeanParameterChecker(servletParameter);
createObjectMapper(beanParameterChecker).writeValueAsString(declaredConstructor.newInstance());
if (!(servletParameterClass.getAnnotation(Parameters.class).commandDescriptionKey() != null
/* command of a parameter */ || beanParameterChecker.hasUsage)) {
throw new ExceptionInInitializerError(
format(ERRORS.getString("CHECKED_CLASS_IS_MISSING_A_USAGE"), servletParameterClass));
}
} catch (JsonProcessingException | InstantiationException | IllegalAccessException | IllegalArgumentException
| InvocationTargetException | NoSuchMethodException | SecurityException e) {
throw new ExceptionInInitializerError(e);
}
}
private static final String FILTER_NAME = "localizer";
@JsonFilter(FILTER_NAME)
@JsonAutoDetect(fieldVisibility = ANY, getterVisibility = ANY, setterVisibility = ANY)
private static final class FilteredMixIn {
}
private static ObjectMapper createObjectMapper(SimpleBeanPropertyFilter filter) {
return new ObjectMapper().setMixInResolver(new MixInResolver() {
@Override
public Class<?> findMixInClassFor(Class<?> cls) {
return FilteredMixIn.class;
}
@Override
public MixInResolver copy() {
return this;
}
}).setFilterProvider(new SimpleFilterProvider().addFilter(FILTER_NAME, filter));
}
private static final class BeanParameterLocalizer extends SimpleBeanPropertyFilter {
private final Locale locale;
private BeanParameterLocalizer(Locale locale) {
this.locale = locale;
}
@Override
public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider prov, PropertyWriter writer)
throws Exception {
Parameters parameters = pojo.getClass().getAnnotation(Parameters.class);
Parameter parameter = writer.getAnnotation(Parameter.class);
if (parameters != null && parameter != null && !parameters.resourceBundle().isEmpty()) {
ResourceBundle resBundle = ResourceBundle.getBundle(parameters.resourceBundle(), locale);
jgen.writeStringField(writer.getName(), resBundle.getString(parameter.descriptionKey()));
} else if (writer.getAnnotation(ParametersDelegate.class) != null) {
super.serializeAsField(pojo, jgen, prov, writer);
}
}
}
private static final class BeanParameterChecker extends SimpleBeanPropertyFilter {
private static final LocaleComparator LOCALE_COMPARATOR = new LocaleComparator();
private static final Control CONTROL = ResourceBundle.Control.getControl(Control.FORMAT_PROPERTIES);
private static final CharsetDecoder US_ASCII_DECODER = US_ASCII.newDecoder()
.onMalformedInput(CodingErrorAction.REPORT);
private final Set<Integer> orders = new HashSet<>();
private final Set<String> checkedResourceBundles = new HashSet<>();
private final boolean servletParameter;
private boolean hasUsage;
private BeanParameterChecker(boolean servletParameter) {
this.servletParameter = servletParameter;
}
@Override
public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider prov, PropertyWriter writer)
throws Exception {
Parameters parameters = pojo.getClass().getAnnotation(Parameters.class);
Parameter parameter = writer.getAnnotation(Parameter.class);
if (parameter != null) {
if (parameter.help()) {
hasUsage = true;
}
if (!orders.add(parameter.order())) {
throw JsonMappingException.from(prov,
format(ERRORS.getString("AMBIGUOUS_ORDER"), parameter.order()));
}
if (servletParameter) {
for (String name : parameter.names()) {
if (name.startsWith("--")) {
if (name.length() < ("--".length() + GNU_OPTION_MIN_LENGTH)) {
throw JsonMappingException.from(prov, ERRORS.getString("GNU_OPTION_MIN_LENGTH_ERROR"));
}
} else if (name.startsWith("-")) {
if (name.length() > ("-".length() + OPTION_MAX_LENGTH)) {
throw JsonMappingException.from(prov, ERRORS.getString("OPTION_MAX_LENGTH_ERROR"));
}
} else {
throw JsonMappingException.from(prov, ERRORS.getString("OPTION_PREFIX_ERROR"));
}
}
if (Arrays.asList(Boolean.class, boolean.class).contains(writer.getType().getRawClass())
&& parameter.arity() != 1) {
throw JsonMappingException.from(prov,
format(ERRORS.getString("BOOLEAN_ARITY_ERROR"), parameter.arity()));
}
}
ResourceBundle rootResourceBundle = null;
for (Locale locale : SUPPORTED_LOCALES.stream().sorted(LOCALE_COMPARATOR).collect(toList())) {
checkEncoding(parameters.resourceBundle(), locale);
ResourceBundle resourceBundle = ResourceBundle.getBundle(parameters.resourceBundle(), locale);
if (locale == Locale.ROOT) {
rootResourceBundle = resourceBundle;
}
if (parameter.descriptionKey().isEmpty()) {
throw JsonMappingException.from(prov,
format(ERRORS.getString("DESCRIPTION_KEY_ATTR_MISSING"), pojo.getClass()));
}
throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle, parameter.descriptionKey());
if (servletParameter) {
if (parameter.help()) {
throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle, "USAGE_DESCRIPTION");
if (locale == Locale.ROOT) {
// RESTful API documentation, available only in english
throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle,
"USAGE_LONG_DESCRIPTION");
throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle,
"EXAMPLE_REQUEST_SERVLET_PATH");
throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle,
"EXAMPLE_REQUEST_PATH");
}
}
if (parameter.names().length == 0 /* main parameter */) {
throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle,
"EXAMPLE_REQUEST_PATH");
}
}
}
} else if (writer.getAnnotation(ParametersDelegate.class) != null) {
super.serializeAsField(pojo, jgen, prov, writer);
}
}
private void throwIfLocalizationMissing(SerializerProvider prov, ResourceBundle resourceBundle,
ResourceBundle rootResourceBundle, String key) throws JsonMappingException {
String bundleName = CONTROL.toBundleName(resourceBundle.getBaseBundleName(), resourceBundle.getLocale());
if (!isKeyOfBundle(resourceBundle, rootResourceBundle, key)) {
throw JsonMappingException.from(prov,
format(ERRORS.getString("LOCALIZATION_MISSING"), bundleName, key));
}
}
private boolean isKeyOfBundle(ResourceBundle resourceBundle, ResourceBundle rootResourceBundle, String key) {
//noinspection StringEquality
return resourceBundle.getLocale() == Locale.ROOT ? resourceBundle.containsKey(key)
: resourceBundle.getString(key) != rootResourceBundle.getString(key);
}
private void checkEncoding(String resourceBundleName, Locale locale) throws Exception {
String bundleName = CONTROL.toBundleName(resourceBundleName, locale);
String resourceName = CONTROL.toResourceName(bundleName, "properties");
if (checkedResourceBundles.add(resourceName)) {
LOG.fine(format("Check encoding of %s", resourceName));
ByteBuffer byteBuffer = null;
byte[] byteArray = null;
try {
InputStream resourceAsStream = getClass().getResourceAsStream("/" + resourceName);
if (resourceAsStream == null) {
throw new FileNotFoundException(resourceName);
}
byteArray = IOUtils.readAllBytes(resourceAsStream);
byteBuffer = ByteBuffer.wrap(byteArray);
US_ASCII_DECODER.decode(byteBuffer);
} catch (CharacterCodingException e) {
Entry<Integer, Integer> lineColumn = getLineColumn(byteArray, byteBuffer.position());
LOG.log(Level.SEVERE, format(ERRORS.getString("ILLEGAL_CHARACTERS_IN_RESOURCE_NAME"), resourceName,
lineColumn.getKey(), lineColumn.getValue()), e);
throw e;
} catch (IOException e) {
LOG.log(Level.SEVERE, format(ERRORS.getString("CHECK_ENCODING_FAILED"), resourceName), e);
throw e;
}
}
}
private Map.Entry<Integer, Integer> getLineColumn(byte[] byteArray, int bytePosition) {
int currentPos = 0, colNo = 1, lineNo = 1;
for (byte b : byteArray) {
if (currentPos == bytePosition) {
break;
}
if (b == '\n') {
lineNo++;
colNo = 0;
}
colNo++;
currentPos++;
}
return new SimpleEntry<>(lineNo, colNo);
}
}
}