/** * '$RCSfile$' * Purpose: A Class that implements administrative methods * Copyright: 2008 Regents of the University of California and the * National Center for Ecological Analysis and Synthesis * Authors: Michael Daigle * * '$Author: leinfelder $' * '$Date: 2011-02-04 14:17:53 +0000 (Fri, 04 Feb 2011) $' * '$Revision: 5914 $' * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 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 General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package edu.ucsb.nceas.metacat.util; import java.io.InputStream; import java.io.InputStreamReader; import java.io.IOException; import java.io.BufferedReader; import java.io.PrintWriter; import java.net.MalformedURLException; import java.net.URL; import java.net.URLConnection; import java.util.ArrayList; import java.util.Enumeration; import java.util.HashMap; import java.util.Hashtable; import java.util.Iterator; import java.util.List; import java.util.Set; import java.util.Vector; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.http.Cookie; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import org.apache.commons.io.IOUtils; import org.apache.http.HttpException; import org.apache.http.HttpResponse; import org.apache.http.HttpVersion; import org.apache.http.NameValuePair; import org.apache.http.client.HttpClient; import org.apache.http.client.entity.UrlEncodedFormEntity; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.DefaultHttpClient; import org.apache.http.message.BasicNameValuePair; import org.apache.http.params.CoreProtocolPNames; import org.apache.log4j.Logger; import edu.ucsb.nceas.metacat.properties.PropertyService; import edu.ucsb.nceas.metacat.service.SessionService; import edu.ucsb.nceas.metacat.shared.MetacatUtilException; import edu.ucsb.nceas.utilities.PropertyNotFoundException; public class RequestUtil { private static Logger logMetacat = Logger.getLogger(RequestUtil.class); private static String encoding = "UTF-8"; /** * private constructor - all methods are static so there is no * no need to instantiate. */ private RequestUtil() {} /** * Forward a request that was received by this servlet on to another JSP * page or servlet to continue handling the request. * * @param request * to be forwarded * @param response * that can be used for writing output to the client * @param destination * the context-relative URL to which the request is forwarded * @param params the request parameters. these will be added to the request */ public static void forwardRequest(HttpServletRequest request, HttpServletResponse response, String destinationUrl, Hashtable params) throws MetacatUtilException { destinationUrl += "?" + paramsToQuery(params); logMetacat.debug("Forwarding request to " + destinationUrl); ServletContext servletContext = request.getSession() .getServletContext(); try { servletContext.getRequestDispatcher(destinationUrl).forward(request, response); } catch (IOException ioe) { throw new MetacatUtilException("RequestUtil.forwardRequest - I/O error when forwarding to " + destinationUrl + " : " + ioe.getMessage()); } catch (ServletException se) { throw new MetacatUtilException("RequestUtil.forwardRequest - Servlet error when forwarding to " + destinationUrl + " : " + se.getMessage()); } } /** * Forward a request that was received by this servlet on to another JSP * page or servlet to continue handling the request. In this case, the page * must be referenced in a paramter named "forwardto". If the qformat is * provided, the file will be retrieved from that skin. Otherwise, the file * will be retrieved from the system default skin. * * For more specific file location, use: forwardRequest(request,response, destinationUrl, params) * * @param request * to be forwarded * @param response * that can be used for writing output to the client * @param params * the request parameters. these will be added to the request. */ public static void forwardRequest(HttpServletRequest request, HttpServletResponse response, Hashtable params) throws MetacatUtilException { String forwardTos[] = params.get("forwardto"); if (forwardTos == null || forwardTos[0].equals("")) { throw new MetacatUtilException("RequestUtil.forwardRequest - forwardto must be set in parameters when forwarding."); } String forwardTo = forwardTos[0]; String qformat = null; String qformats[] = params.get("qformat"); if (qformats == null || qformats.length == 0) { try { qformat = PropertyService.getProperty("application.default-style"); } catch (PropertyNotFoundException pnfe) { qformat = "default"; logMetacat.warn("RequestUtil.forwardRequest - could not get property " + "'application.default-style'. Using 'default'"); } } else { qformat = qformats[0]; } String destinationUrl = "/style/skins/" + qformat + "/" + forwardTo; destinationUrl += "?" + paramsToQuery(params); logMetacat.debug("RequestUtil.forwardRequest - Forwarding request to " + destinationUrl); ServletContext servletContext = request.getSession() .getServletContext(); try { servletContext.getRequestDispatcher(destinationUrl).forward(request, response); } catch (IOException ioe) { throw new MetacatUtilException("RequestUtil.forwardRequest - I/O error when forwarding to " + destinationUrl + " : " + ioe.getMessage()); } catch (ServletException se) { throw new MetacatUtilException("RequestUtil.forwardRequest - Servlet error when forwarding to " + destinationUrl + " : " + se.getMessage()); } } /** * Post a request and return the response body * * @param httpClient * The HttpClient to use in the post. This is passed in because * the same client may be used in several posts * @param url * the url to post to * @param paramMap * map of parameters to add to the post * @returns a string holding the response body */ public static String post(HttpClient httpclient, String url, HashMap paramMap) throws IOException, HttpException { httpclient.getParams().setParameter( CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1); httpclient.getParams().setParameter( CoreProtocolPNames.HTTP_CONTENT_CHARSET, encoding ); HttpPost post = new HttpPost(url); //set the params List nameValuePairs = new ArrayList(); Iterator keys = paramMap.keySet().iterator(); while (keys.hasNext()) { String key = keys.next(); String value = paramMap.get(key); NameValuePair nvp = new BasicNameValuePair(key, value); nameValuePairs.add(nvp); } post.setEntity(new UrlEncodedFormEntity(nameValuePairs, encoding)); //post.setHeader("Cookie", "JSESSIONID="+ sessionId); HttpResponse httpResponse = httpclient.execute(post); if (httpResponse.getStatusLine().getStatusCode() != -1) { InputStream result = httpResponse.getEntity().getContent(); String contents = IOUtils.toString(result, encoding); return contents; } return null; } public static String get(String urlString, Hashtable params) throws MetacatUtilException { try { URL url = new URL(urlString); URLConnection urlConn = url.openConnection(); urlConn.setDoOutput(true); PrintWriter pw = new PrintWriter(urlConn.getOutputStream()); String queryString = paramsToQuery(params); logMetacat.debug("Sending get request: " + urlString + "?" + queryString); pw.print(queryString); pw.close(); // get the input from the request BufferedReader in = new BufferedReader(new InputStreamReader(urlConn.getInputStream())); StringBuffer sb = new StringBuffer(); String line; while ((line = in.readLine()) != null) { sb.append(line); } in.close(); return sb.toString(); } catch (MalformedURLException mue) { throw new MetacatUtilException("URL error when contacting: " + urlString + " : " + mue.getMessage()); } catch (IOException ioe) { throw new MetacatUtilException("I/O error when contacting: " + urlString + " : " + ioe.getMessage()); } } /** * Get a cookie from a request by the cookie name * * @param request * the request from which to get the cookie * @param cookieName * the name of the cookie to look for */ public static Cookie getCookie(HttpServletRequest request, String cookieName) { Cookie sessionCookies[] = request.getCookies(); if (sessionCookies == null) { return null; } for (int i = 0; i < sessionCookies.length; i++) { if(sessionCookies[i].getName().equals(cookieName)) { return sessionCookies[i]; } } return null; } /** * Get the session data from a request. The Scenarios we can run across * here: * -- the session id parameter was set in the request parameters * -- request.getSession returns a new session. There is a chance that the * session id was set in a cookie. Check for a JSESSIONID cookie and use * that id if provided. * -- request.getSession returns a session that is a) * preexisting or b) new but without a JSESSIONID cookie. Use the session id * from this session * * @param request * the request from which to get the session data * @return the session data object representing the active session for this * request. If there is no active session, the public session data * is returned */ public static SessionData getSessionData(HttpServletRequest request) { SessionData sessionData = null; String sessionId = null; Hashtable params = getParameters(request); if (params.containsKey("sessionid")) { // the session id is specified in the request parameters sessionId = ((String[]) params.get("sessionid"))[0]; logMetacat.debug("session ID provided in request properties: " + sessionId); } else { HttpSession session = request.getSession(true); if (session.isNew()) { // this is a new session Cookie sessionCookie = RequestUtil.getCookie(request, "JSESSIONID"); if (sessionCookie != null) { // and there is a JSESSIONID cookie sessionId = sessionCookie.getValue(); logMetacat.debug("session ID provided in request cookie: " + sessionId); } } if (sessionId == null) { // there is an existing session (session is old) sessionId = session.getId(); logMetacat.debug("session ID retrieved from request: " + sessionId); } } // if the session id is registered in SessionService, get the // SessionData for it. Otherwise, use the public session. if (SessionService.getInstance().isSessionRegistered(sessionId)) { logMetacat.debug("retrieving session data from session service " + "for session id " + sessionId); sessionData = SessionService.getInstance().getRegisteredSession(sessionId); } else { logMetacat.debug("using public session. Given session id is " + "registered: " + sessionId); sessionData = SessionService.getInstance().getPublicSession(); } return sessionData; } /** * Get a cookie from a request by the cookie name * * @param request * the request from which to get the cookie * @param cookieName * the name of the cookie to look for */ @SuppressWarnings("unchecked") public static Hashtable getParameters(HttpServletRequest request) { Hashtable params = new Hashtable(); Enumeration paramlist = (Enumeration)request.getParameterNames(); while (paramlist.hasMoreElements()) { String name = (String) paramlist.nextElement(); String[] value = request.getParameterValues(name); params.put(name, value); } return params; } /** * Add a list of errors to the request. The pages will pick up the errors * and display them where appropriate. * * @param request * the request that will get forwarded * @param errorVector * a list of error strings */ public static void setRequestErrors(HttpServletRequest request, Vector errorVector) { request.setAttribute("formErrors", "true"); request.setAttribute("processingErrors", errorVector); } /** * Add a list of form errors to the request. The pages will pick up the * errors and display them where appropriate. * * @param request * the request that will get forwarded * @param errorVector * a list of form error strings */ public static void setRequestFormErrors(HttpServletRequest request, Vector errorVector) { request.setAttribute("formErrors", "true"); request.setAttribute("formFieldErrors", errorVector); } /** * Add a list of success messages to the request. The pages will pick up the * messages and display them where appropriate. * * @param request * the request that will get forwarded * @param errorVector * a list of success message strings */ public static void setRequestSuccess(HttpServletRequest request, Vector successVector) { request.setAttribute("formSuccess", "true"); request.setAttribute("processingSuccess", successVector); } /** * Add a list of general messages to the request. The pages will pick up the * messages and display them where appropriate. * * @param request * the request that will get forwarded * @param errorVector * a list of general message strings */ public static void setRequestMessage(HttpServletRequest request, Vector messageVector) { request.setAttribute("formMessage", "true"); request.setAttribute("processingMessage", messageVector); } /** * Add a list of general messages to the request. The pages will pick up the * messages and display them where appropriate. * * @param request * the request that will get forwarded * @param errorVector * a list of general message strings */ public static void clearRequestMessages(HttpServletRequest request) { request.setAttribute("formMessage", null); request.setAttribute("formSuccess", null); request.setAttribute("formErrors", null); request.setAttribute("processingMessage", null); request.setAttribute("processingSuccess", null); request.setAttribute("formFieldErrors", null); request.setAttribute("processingErrors", null); } /** * Add the user's login id to the session on this request * * @param request * the request that will get forwarded * @param userId * the user's login id */ public static void setUserId(HttpServletRequest request, String userId) { request.getSession().setAttribute("userId", userId); } private static String paramsToQuery(Hashtable params) { String query = ""; if (params != null) { boolean firstParam = true; for (String paramName : params.keySet()) { if (firstParam) { firstParam = false; } else { query += "&"; } query += paramName + "=" + params.get(paramName)[0]; } } return query; } }