org.geowebcache.rest.RESTDispatcher.java Source code

Introduction

Here is the source code for org.geowebcache.rest.RESTDispatcher.java

Source

/**
 * 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 David Winslow / The Open Planning Project 2008 
 */
package org.geowebcache.rest;

import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.geowebcache.GeoWebCacheExtensions;
import org.restlet.Restlet;
import org.restlet.Router;
import org.restlet.resource.StringRepresentation;
import org.springframework.beans.BeansException;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

import com.noelios.restlet.ext.servlet.ServletConverter;

/**
 * Simple AbstractController implementation that does the translation between
 * Spring requests and Restlet requests.
 */
public class RESTDispatcher extends AbstractController {
    private static Log log = LogFactory.getLog(org.geowebcache.rest.RESTDispatcher.class);

    public static final String METHOD_PUT = "PUT";

    public static final String METHOD_DELETE = "DELETE";

    ServletConverter myConverter;

    private Router myRouter = new Router();

    public RESTDispatcher() {
        super();
        setSupportedMethods(new String[] { METHOD_GET, METHOD_POST, METHOD_PUT, METHOD_DELETE, METHOD_HEAD });

        int numRoutes = 0;
        for (RESTMapping mapping : GeoWebCacheExtensions.extensions(RESTMapping.class)) {
            Map<String, Object> routes = mapping.getRoutes();
            addRoutes(routes);
            numRoutes += routes.size();
        }

        myRouter.attach("", new IndexRestlet(myRouter));

        log.info("Created RESTDispatcher with " + numRoutes + " paths");
    }

    protected void initApplicationContext() throws BeansException {
        super.initApplicationContext();

        myConverter = new ServletConverter(getServletContext());
        myConverter.setTarget(myRouter);
    }

    protected ModelAndView handleRequestInternal(HttpServletRequest req, HttpServletResponse resp)
            throws Exception {

        try {
            myConverter.service(req, resp);
        } catch (Exception e) {
            RestletException re = null;
            if (e instanceof RestletException) {
                re = (RestletException) e;
            }
            if (re == null && e.getCause() instanceof RestletException) {
                re = (RestletException) e.getCause();
            }

            if (re != null) {
                resp.setStatus(re.getStatus().getCode());
                // This does not actually write anything?
                //re.getRepresentation().write(resp.getOutputStream());

                String reStr = re.getRepresentation().getText();
                resp.getOutputStream().write(reStr.getBytes());

                resp.getOutputStream().flush();
            } else {
                resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                new StringRepresentation(e.getMessage()).write(resp.getOutputStream());
                resp.getOutputStream().flush();
            }
        }

        return null;
    }

    private void addRoutes(Map<String, Object> m) {
        Iterator<Entry<String, Object>> it = m.entrySet().iterator();

        while (it.hasNext()) {
            Entry<String, Object> entry = it.next();

            if (entry.getValue() instanceof GWCResource) {
                myRouter.attach(entry.getKey().toString(), ((GWCResource) entry.getValue()).getClass());
            } else if (entry.getValue() instanceof Restlet) {
                myRouter.attach(entry.getKey().toString(), (Restlet) entry.getValue());
            } else {
                log.error("Unexpected " + entry.getValue());
            }
        }
    }
}