Java tutorial
/** * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * * @author Marius Suta / The Open Planning Project 2008 * @author Arne Kepp / The Open Planning Project 2009 */ package org.geowebcache.rest.layers; import java.io.IOException; import java.io.InputStream; import java.io.StringWriter; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.util.ArrayList; import java.util.Collections; import java.util.List; import org.geowebcache.GeoWebCacheDispatcher; import org.geowebcache.GeoWebCacheException; import org.geowebcache.config.Configuration; import org.geowebcache.config.ContextualConfigurationProvider.Context; import org.geowebcache.config.XMLConfiguration; import org.geowebcache.filter.parameters.ParameterFilter; import org.geowebcache.layer.TileLayer; import org.geowebcache.layer.TileLayerDispatcher; import org.geowebcache.rest.GWCRestlet; import org.geowebcache.rest.RestletException; import org.geowebcache.rest.XstreamRepresentation; import org.geowebcache.service.HttpErrorCodeException; import org.geowebcache.util.NullURLMangler; import org.geowebcache.util.ServletUtils; import org.geowebcache.util.URLMangler; import org.json.JSONException; import org.json.JSONObject; import org.restlet.data.CharacterSet; import org.restlet.data.MediaType; import org.restlet.data.Method; import org.restlet.data.Request; import org.restlet.data.Response; import org.restlet.data.Status; import org.restlet.ext.json.JsonRepresentation; import org.restlet.resource.Representation; import org.restlet.resource.StringRepresentation; import com.thoughtworks.xstream.XStream; import com.thoughtworks.xstream.converters.ConversionException; import com.thoughtworks.xstream.converters.Converter; import com.thoughtworks.xstream.converters.MarshallingContext; import com.thoughtworks.xstream.converters.UnmarshallingContext; import com.thoughtworks.xstream.io.HierarchicalStreamDriver; import com.thoughtworks.xstream.io.HierarchicalStreamReader; import com.thoughtworks.xstream.io.HierarchicalStreamWriter; import com.thoughtworks.xstream.io.copy.HierarchicalStreamCopier; import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver; import com.thoughtworks.xstream.io.json.JsonHierarchicalStreamDriver; import com.thoughtworks.xstream.io.xml.DomDriver; import com.thoughtworks.xstream.io.xml.PrettyPrintWriter; /** * This is the TileLayer resource class required by the REST interface */ public class TileLayerRestlet extends GWCRestlet { private XMLConfiguration xmlConfig; private TileLayerDispatcher layerDispatcher; private URLMangler urlMangler = new NullURLMangler(); private GeoWebCacheDispatcher controller = null; // set by spring public void setUrlMangler(URLMangler urlMangler) { this.urlMangler = urlMangler; } // set by spring public void setController(GeoWebCacheDispatcher controller) { this.controller = controller; } @Override public void handle(Request request, Response response) { Method met = request.getMethod(); try { if (met.equals(Method.GET)) { doGet(request, response); } else { // These modify layers, so we reload afterwards if (met.equals(Method.POST)) { doPost(request, response); } else if (met.equals(Method.PUT)) { doPut(request, response); } else if (met.equals(Method.DELETE)) { doDelete(request, response); } else { throw new RestletException("Method not allowed", Status.CLIENT_ERROR_METHOD_NOT_ALLOWED); } } } catch (RestletException re) { response.setEntity(re.getRepresentation()); response.setStatus(re.getStatus()); } catch (HttpErrorCodeException httpException) { int errorCode = httpException.getErrorCode(); Status status = Status.valueOf(errorCode); response.setStatus(status); response.setEntity(httpException.getMessage(), MediaType.TEXT_PLAIN); } catch (Exception e) { // Either GeoWebCacheException or IOException response.setEntity(e.getMessage() + " " + e.toString(), MediaType.TEXT_PLAIN); response.setStatus(Status.SERVER_ERROR_INTERNAL); e.printStackTrace(); } } /** * GET outputs an existing layer * * @param req * @param resp * @throws RestletException * @throws */ protected void doGet(Request req, Response resp) throws RestletException { String layerName = (String) req.getAttributes().get("layer"); final String formatExtension = (String) req.getAttributes().get("extension"); Representation representation; if (layerName == null) { String restRoot = req.getRootRef().toString(); String contextPath = req.getRootRef().getPath(); String servletPrefix = null; if (controller != null) servletPrefix = controller.getServletPrefix(); String parentPath = ""; int spIndex = 0; if (servletPrefix != null) { spIndex = contextPath.indexOf(servletPrefix); parentPath = contextPath.substring(0, spIndex); } contextPath = contextPath.substring(spIndex, contextPath.length()); String baseURL = restRoot.substring(0, restRoot.length() - contextPath.length()); String prefix = req.getResourceRef().getParentRef().getPath(); prefix = prefix.substring(parentPath.length(), prefix.length()); representation = listLayers(formatExtension, baseURL, prefix); } else { try { layerName = URLDecoder.decode(layerName, "UTF-8"); } catch (UnsupportedEncodingException uee) { } representation = doGetInternal(layerName, formatExtension); } resp.setEntity(representation); } /** * @param extension * @param rootPath * @param contextPath * @return */ Representation listLayers(String extension, final String rootPath, final String contextPath) { if (null == extension) { extension = "xml"; } List<String> layerNames = new ArrayList<String>(layerDispatcher.getLayerNames()); Collections.sort(layerNames); Representation representation; if (extension.equalsIgnoreCase("xml")) { representation = new XstreamRepresentation(layerNames); representation.setCharacterSet(CharacterSet.UTF_8); final XStream xStream = ((XstreamRepresentation) representation).getXStream(); xStream.alias("layers", List.class); xmlConfig.getConfiguredXStreamWithContext(xStream, Context.REST); xStream.registerConverter(new Converter() { /** * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class) */ public boolean canConvert(@SuppressWarnings("rawtypes") Class type) { return List.class.isAssignableFrom(type); } /** * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object, * com.thoughtworks.xstream.io.HierarchicalStreamWriter, * com.thoughtworks.xstream.converters.MarshallingContext) */ public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) { @SuppressWarnings("unchecked") List<String> layers = (List<String>) source; for (String name : layers) { writer.startNode("layer"); writer.startNode("name"); writer.setValue(name); writer.endNode(); // name writer.startNode("atom:link"); writer.addAttribute("xmlns:atom", "http://www.w3.org/2005/Atom"); writer.addAttribute("rel", "alternate"); String href = urlMangler.buildURL(rootPath, contextPath, "/layers/" + ServletUtils.URLEncode(name) + ".xml"); writer.addAttribute("href", href); writer.addAttribute("type", MediaType.TEXT_XML.toString()); writer.endNode(); writer.endNode();// layer } } /** * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.HierarchicalStreamReader, * com.thoughtworks.xstream.converters.UnmarshallingContext) */ public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { throw new UnsupportedOperationException(); } }); } else if (extension.equalsIgnoreCase("html")) { throw new RestletException("Unknown or missing format extension : " + extension, Status.CLIENT_ERROR_BAD_REQUEST); } else { throw new RestletException("Unknown or missing format extension : " + extension, Status.CLIENT_ERROR_BAD_REQUEST); } return representation; } /** * We separate out the internal to make unit testing easier * * @param layerName * @param formatExtension * @return * @throws RestletException */ protected Representation doGetInternal(String layerName, String formatExtension) throws RestletException { TileLayer tl = findTileLayer(layerName, layerDispatcher); if (formatExtension.equalsIgnoreCase("xml")) { return getXMLRepresentation(tl); } else if (formatExtension.equalsIgnoreCase("json")) { return getJsonRepresentation(tl); } else { throw new RestletException("Unknown or missing format extension : " + formatExtension, Status.CLIENT_ERROR_BAD_REQUEST); } } /** * POST overwrites an existing layer * * @param req * @param resp * @throws RestletException */ private void doPost(Request req, Response resp) throws RestletException, IOException, GeoWebCacheException { TileLayer tl = deserializeAndCheckLayer(req, resp, false); try { Configuration configuration = layerDispatcher.modify(tl); configuration.save(); } catch (IllegalArgumentException e) { throw new RestletException("Layer " + tl.getName() + " is not known by the configuration." + "Maybe it was loaded from another source, or you're trying to add a new " + "layer and need to do an HTTP PUT ?", Status.CLIENT_ERROR_BAD_REQUEST); } } /** * PUT creates a new layer * * @param req * @param resp * @throws RestletException */ private void doPut(Request req, Response resp) throws RestletException, IOException, GeoWebCacheException { TileLayer tl = deserializeAndCheckLayer(req, resp, true); TileLayer testtl = null; try { testtl = findTileLayer(tl.getName(), layerDispatcher); } catch (RestletException re) { // This is the expected behavior, it should not exist } if (testtl == null) { Configuration config = layerDispatcher.addLayer(tl); config.save(); } else { throw new RestletException( "Layer with name " + tl.getName() + " already exists, " + "use POST if you want to replace it.", Status.CLIENT_ERROR_BAD_REQUEST); } } /** * DELETE removes an existing layer * * @param req * @param resp * @throws RestletException */ private void doDelete(Request req, Response resp) throws RestletException, GeoWebCacheException { String layerName = (String) req.getAttributes().get("layer"); findTileLayer(layerName, layerDispatcher); try { Configuration configuration = layerDispatcher.removeLayer(layerName); if (configuration == null) { throw new RestletException("Configuration to remove layer not found", Status.SERVER_ERROR_INTERNAL); } configuration.save(); } catch (IOException e) { throw new RestletException(e.getMessage(), Status.SERVER_ERROR_INTERNAL, e); } } protected TileLayer deserializeAndCheckLayer(Request req, Response resp, boolean isPut) throws RestletException, IOException { // TODO UTF-8 may not always be right here String layerName = ServletUtils.URLDecode((String) req.getAttributes().get("layer"), "UTF-8"); String formatExtension = (String) req.getAttributes().get("extension"); InputStream is = req.getEntity().getStream(); // If appropriate, check whether this layer exists if (!isPut) { findTileLayer(layerName, layerDispatcher); } return deserializeAndCheckLayerInternal(layerName, formatExtension, is); } /** * We separate out the internal to make unit testing easier * * @param layerName * @param formatExtension * @param is * @return * @throws RestletException * @throws IOException */ protected TileLayer deserializeAndCheckLayerInternal(String layerName, String formatExtension, InputStream is) throws RestletException, IOException { XStream xs = xmlConfig.getConfiguredXStreamWithContext(new XStream(new DomDriver()), Context.REST); TileLayer newLayer; try { if (formatExtension.equalsIgnoreCase("xml")) { newLayer = (TileLayer) xs.fromXML(is); } else if (formatExtension.equalsIgnoreCase("json")) { HierarchicalStreamDriver driver = new JettisonMappedXmlDriver(); HierarchicalStreamReader hsr = driver.createReader(is); // See http://jira.codehaus.org/browse/JETTISON-48 StringWriter writer = new StringWriter(); new HierarchicalStreamCopier().copy(hsr, new PrettyPrintWriter(writer)); writer.close(); newLayer = (TileLayer) xs.fromXML(writer.toString()); } else { throw new RestletException("Unknown or missing format extension: " + formatExtension, Status.CLIENT_ERROR_BAD_REQUEST); } } catch (ConversionException xstreamExceptionWrapper) { Throwable cause = xstreamExceptionWrapper.getCause(); if (cause instanceof Error) { throw (Error) cause; } if (cause instanceof RuntimeException) { throw (RuntimeException) cause; } if (cause != null) { throw new RestletException(cause.getMessage(), Status.SERVER_ERROR_INTERNAL, (Exception) cause); } else { throw new RestletException(xstreamExceptionWrapper.getMessage(), Status.SERVER_ERROR_INTERNAL, xstreamExceptionWrapper); } } if (!newLayer.getName().equals(layerName)) { throw new RestletException( "There is a mismatch between the name of the " + " layer in the submission and the URL you specified.", Status.CLIENT_ERROR_BAD_REQUEST); } // Check that the parameter filters deserialized correctly if (newLayer.getParameterFilters() != null) { try { for (@SuppressWarnings("unused") ParameterFilter filter : newLayer.getParameterFilters()) { // Don't actually need to do anything here. Just iterate over the elements // casting them into ParameterFilter } } catch (ClassCastException ex) { // By this point it has already been turned into a POJO, so the XML is no longer // available. Otherwise it would be helpful to include in the error message. throw new RestletException( "parameterFilters contains an element that is not " + "a known ParameterFilter", Status.CLIENT_ERROR_BAD_REQUEST); } } return newLayer; } /** * Returns a XMLRepresentation of the layer * * @param layer * @return */ public Representation getXMLRepresentation(TileLayer layer) { XStream xs = xmlConfig.getConfiguredXStreamWithContext(new XStream(), Context.REST); String xmlText = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + xs.toXML(layer); return new StringRepresentation(xmlText, MediaType.TEXT_XML); } /** * Returns a JsonRepresentation of the layer * * @param layer * @return */ public JsonRepresentation getJsonRepresentation(TileLayer layer) { JsonRepresentation rep = null; try { XStream xs = xmlConfig.getConfiguredXStreamWithContext(new XStream(new JsonHierarchicalStreamDriver()), Context.REST); JSONObject obj = new JSONObject(xs.toXML(layer)); rep = new JsonRepresentation(obj); } catch (JSONException jse) { jse.printStackTrace(); } return rep; } public void setTileLayerDispatcher(TileLayerDispatcher tileLayerDispatcher) { layerDispatcher = tileLayerDispatcher; } public void setXMLConfiguration(XMLConfiguration xmlConfig) { this.xmlConfig = xmlConfig; } }