Author: heiko.braun(a)jboss.com Date: 2008-10-27 05:47:51 -0400 (Mon, 27 Oct 2008) New Revision: 2624 Added: projects/gwt-console/trunk/war/XML_HTTP_PROXY.txt projects/gwt-console/trunk/war/src/main/java/jmaki/ projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/ projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/HttpClient.java projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/XmlHttpProxy.java projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/XmlHttpProxyServlet.java projects/gwt-console/trunk/war/src/main/resources/jmaki/ projects/gwt-console/trunk/war/src/main/resources/jmaki/xhp/ projects/gwt-console/trunk/war/src/main/resources/jmaki/xhp/xhp.json Modified: projects/gwt-console/trunk/war/pom.xml projects/gwt-console/trunk/war/src/main/java/org/jboss/bpm/console/client/Authentication.java projects/gwt-console/trunk/war/src/main/java/org/jboss/bpm/console/client/util/JSONRequest.java projects/gwt-console/trunk/war/src/main/resources/org/jboss/bpm/console/Application.gwt.xml projects/gwt-console/trunk/war/src/main/webapp/WEB-INF/web.xml projects/gwt-console/trunk/war/src/test/java/org/jboss/bpm/console/client/GwtTestApplication.java Log: start http proxy integration to simplify testing Added: projects/gwt-console/trunk/war/XML_HTTP_PROXY.txt =================================================================== --- projects/gwt-console/trunk/war/XML_HTTP_PROXY.txt (rev 0) +++ projects/gwt-console/trunk/war/XML_HTTP_PROXY.txt 2008-10-27 09:47:51 UTC (rev 2624) @@ -0,0 +1,3 @@ +See https://ajax.dev.java.net/xmlhttpproxy.html for further details. + + Property changes on: projects/gwt-console/trunk/war/XML_HTTP_PROXY.txt ___________________________________________________________________ Name: svn:keywords + Id Revision Name: svn:eol-style + LF Modified: projects/gwt-console/trunk/war/pom.xml =================================================================== --- projects/gwt-console/trunk/war/pom.xml 2008-10-27 06:21:47 UTC (rev 2623) +++ projects/gwt-console/trunk/war/pom.xml 2008-10-27 09:47:51 UTC (rev 2624) @@ -66,10 +66,22 @@ </dependency> <dependency> <groupId>javax.activation</groupId> - <artifactId>activation</artifactId> + <artifactId>activation</artifactId> <scope>provided</scope> </dependency> + <dependency> + <groupId>com.servletsuite</groupId> + <artifactId>httpProxy</artifactId> + <version>1.0</version> + </dependency> + + <dependency> + <groupId>org.json</groupId> + <artifactId>org.json</artifactId> + <version>0.0.1</version> + </dependency> + </dependencies> <!-- Plugins --> <build> @@ -144,6 +156,7 @@ <artifactId>maven-war-plugin</artifactId> <configuration> <webXml>target/web.xml</webXml> + <warSourceExcludes>.gwt-tmp/**</warSourceExcludes> </configuration> </plugin> <plugin> Added: projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/HttpClient.java =================================================================== --- projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/HttpClient.java (rev 0) +++ projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/HttpClient.java 2008-10-27 09:47:51 UTC (rev 2624) @@ -0,0 +1,240 @@ +/* Copyright 2006-2008 Sun Microsystems, Inc. All rights reserved. You may not modify, use, reproduce, or distribute this software except in compliance with the terms of the License at: + http://developer.sun.com/berkeley_license.html + $Id$ +*/package jmaki.xhp; + +import java.io.*; +import java.util.Map; +import java.util.Iterator; +import java.net.*; +import java.util.logging.*; +import java.security.Security; + +/** + * @author Yutaka Yoshida, Greg Murray + * + * Minimum set of HTTPclient supporting both http and https. + * It's aslo capable of POST, but it doesn't provide doGet because + * the caller can just read the inputstream. + */ +public class HttpClient { + + private static Logger logger; + private String proxyHost = null; + private int proxyPort = -1; + private boolean isHttps = false; + private boolean isProxy = false; + private HttpURLConnection urlConnection = null; + private Map headers; + + /** + * @param phost PROXY host name + * @param pport PROXY port string + * @param url URL string + * @param headers Map + */ + public HttpClient(String phost, + int pport, + String url, + Map headers, + String method) + throws MalformedURLException { + if (phost != null && pport != -1) { + this.isProxy = true; + } + this.proxyHost = phost; + this.proxyPort = pport; + if (url.trim().startsWith("https:")) { + isHttps = true; + } + this.urlConnection = getURLConnection(url); + try { + this.urlConnection.setRequestMethod(method); + } catch (java.net.ProtocolException pe) { + HttpClient.getLogger().severe("Unable protocol method to " + method + " : " + pe); + } + this.headers = headers; + // seat headers + if (headers != null) { + Iterator it = headers.keySet().iterator(); + if (it != null) { + while (it.hasNext()) { + String key = (String)it.next(); + String value = (String)headers.get(key); + this.urlConnection.setRequestProperty (key, value); + } + } + } + } + + /** + * @param phost PROXY host name + * @param pport PROXY port string + * @param url URL string + * @param headers Map + * @param userName string + * @param password string + */ + public HttpClient(String phost, + int pport, + String url, + Map headers, + String method, + String userName, + String password) + throws MalformedURLException { + try { + if (phost != null && pport != -1) { + this.isProxy = true; + } + this.proxyHost = phost; + this.proxyPort = pport; + if (url.trim().startsWith("https:")) { + isHttps = true; + } + this.urlConnection = getURLConnection(url); + try { + this.urlConnection.setRequestMethod(method); + } catch (java.net.ProtocolException pe) { + HttpClient.getLogger().severe("Unable protocol method to " + method + " : " + pe); + } + // set basic authentication information + String auth = userName + ":" + password; + String encoded = new sun.misc.BASE64Encoder().encode (auth.getBytes()); + // set basic authorization + this.urlConnection.setRequestProperty ("Authorization", "Basic " + encoded); + this.headers = headers; + // seat headers + if (headers != null) { + Iterator it = headers.entrySet().iterator(); + if (it != null) { + while (it.hasNext()) { + String key = (String)it.next(); + String value = (String)headers.get(key); + this.urlConnection.setRequestProperty (key, value); + } + } + } + } catch (Exception ex) { + HttpClient.getLogger().severe("Unable to set basic authorization for " + userName + " : " +ex); + } + } + + /** + * private method to get the URLConnection + * @param str URL string + */ + private HttpURLConnection getURLConnection(String str) + throws MalformedURLException { + try { + if (isHttps) { + /* when communicating with the server which has unsigned or invalid + * certificate (https), SSLException or IOException is thrown. + * the following line is a hack to avoid that + */ + Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider()); + System.setProperty("java.protocol.handler.pkgs", "com.sun.net.ssl.internal.www.protocol"); + if (isProxy) { + System.setProperty("https.proxyHost", proxyHost); + System.setProperty("https.proxyPort", proxyPort + ""); + } + } else { + if (isProxy) { + System.setProperty("http.proxyHost", proxyHost); + System.setProperty("http.proxyPort", proxyPort + ""); + } + } + URL url = new URL(str); + HttpURLConnection uc = (HttpURLConnection)url.openConnection(); + // if this header has not been set by a request set the user agent. + if (headers == null || + (headers != null && headers.get("user-agent") == null)) { + // set user agent to mimic a common browser + String ua="Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; .NET CLR 1.1.4322)"; + uc.setRequestProperty("user-agent", ua); + } + return uc; + } catch (MalformedURLException me) { + throw new MalformedURLException(str + " is not a valid URL"); + } catch (Exception e) { + e.printStackTrace(); + return null; + } + } + + /** + * returns the inputstream from URLConnection + * @return InputStream + */ + public InputStream getInputStream() { + try { + return (this.urlConnection.getInputStream()); + } catch (Exception e) { + e.printStackTrace(); + return null; + } + } + + /** + * return the OutputStream from URLConnection + * @return OutputStream + */ + public OutputStream getOutputStream() { + + try { + return (this.urlConnection.getOutputStream()); + } catch (Exception e) { + e.printStackTrace(); + return null; + } + } + + /** + * posts data to the inputstream and returns the InputStream. + * @param postData data to be posted. must be url-encoded already. + * @param contentType allows you to set the contentType of the request. + * @return InputStream input stream from URLConnection + */ + public InputStream doPost(String postData, String contentType) { + this.urlConnection.setDoOutput(true); + if (contentType != null) this.urlConnection.setRequestProperty( "Content-type", contentType ); + + OutputStream os = this.getOutputStream(); + PrintStream ps = new PrintStream(os); + ps.print(postData); + ps.close(); + return (this.getInputStream()); + } + + public String getContentEncoding() { + if (this.urlConnection == null) return null; + return (this.urlConnection.getContentEncoding()); + } + public int getContentLength() { + if (this.urlConnection == null) return -1; + return (this.urlConnection.getContentLength()); + } + public String getContentType() { + if (this.urlConnection == null) return null; + return (this.urlConnection.getContentType()); + } + public long getDate() { + if (this.urlConnection == null) return -1; + return (this.urlConnection.getDate()); + } + public String getHeader(String name) { + if (this.urlConnection == null) return null; + return (this.urlConnection.getHeaderField(name)); + } + public long getIfModifiedSince() { + if (this.urlConnection == null) return -1; + return (this.urlConnection.getIfModifiedSince()); + } + + public static Logger getLogger() { + if (logger == null) { + logger = Logger.getLogger("jmaki.xhp.Log"); + } + return logger; + } +} \ No newline at end of file Property changes on: projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/HttpClient.java ___________________________________________________________________ Name: svn:keywords + Id Revision Name: svn:eol-style + LF Added: projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/XmlHttpProxy.java =================================================================== --- projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/XmlHttpProxy.java (rev 0) +++ projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/XmlHttpProxy.java 2008-10-27 09:47:51 UTC (rev 2624) @@ -0,0 +1,389 @@ +/* Copyright 2007 You may not modify, use, reproduce, or distribute this software except in compliance with the terms of the License at: + http://developer.sun.com/berkeley_license.html + $Id$ +*/ +package jmaki.xhp; + +/* Copyright 2007 You may not modify, use, reproduce, or distribute this software except in compliance with the terms of the License at: + http://developer.sun.com/berkeley_license.html + $Id$ +*/ + +import java.io.*; +import java.net.MalformedURLException; +import java.net.URL; +import java.util.*; +import java.util.logging.*; + +import javax.xml.transform.*; +import javax.xml.transform.stream.*; + +import org.json.*; + +public class XmlHttpProxy { + + public static String GET = "GET"; + public static String POST = "POST"; + public static String DELETE = "DELETE"; + public static String PUT = "PUT"; + + private String userName = null; + private String password = null; + private static Logger logger; + private String proxyHost = ""; + int proxyPort = -1; + private JSONObject config; + private static String USAGE = "Usage: -url service_URL -id service_key [-url or -id required] -xslurl xsl_url [optional] -format json|xml [optional] -callback[optional] -config [optional] -resources base_directory_containing XSL stylesheets [optional]"; + + public XmlHttpProxy() {} + + public XmlHttpProxy(String proxyHost, int proxyPort) { + this.proxyHost = proxyHost; + this.proxyPort = proxyPort; + } + + public XmlHttpProxy(String proxyHost, int proxyPort, + String userName, String password) { + this.proxyHost = proxyHost; + this.proxyPort = proxyPort; + this.userName = userName; + this.password = password; + } + + /** + * This method will go out and make the call and it will apply an XSLT Transformation with the + * set of parameters provided. + * + * @param urlString - The URL which you are looking up + * @param out - The OutputStream to which the resulting document is written + * @param xslInputStream - An input Stream to an XSL style sheet that is provided to the XSLT processor. If set to null there will be no transformation + * @param paramsMap - A Map of parameters that are feed to the XSLT Processor. These params may be used when generating content. This may be set to null if no parameters are necessary. + * @param method - The HTTP method used. + * + */ + public void processRequest(String urlString, + OutputStream out, + InputStream xslInputStream, + Map paramsMap, + Map headers, + String method, + String userName, + String password) throws IOException, MalformedURLException { + doProcess(urlString, out, xslInputStream, paramsMap, headers,method, null,null, userName,password); + } + /** + * This method will go out and make the call and it will apply an XSLT Transformation with the + * set of parameters provided. + * + * @param urlString - The URL which you are looking up + * @param out - The OutputStream to which the resulting document is written + * + */ + public void doPost(String urlString, + OutputStream out, + InputStream xslInputStream, + Map paramsMap, + Map headers, + String postData, + String postContentType, + String userName, + String password) throws IOException, MalformedURLException { + doProcess(urlString, out, xslInputStream, paramsMap, headers, XmlHttpProxy.POST, postData, postContentType, userName, password); + } + + /** + * This method will go out and make the call and it will apply an XSLT Transformation with the + * set of parameters provided. + * + * @param urlString - The URL which you are looking up + * @param out - The OutputStream to which the resulting document is written + * @param xslInputStream - An input Stream to an XSL style sheet that is provided to the XSLT processor. If set to null there will be no transformation + * @param paramsMap - A Map of parameters that are feed to the XSLT Processor. These params may be used when generating content. This may be set to null if no parameters are necessary. + * @param method - the HTTP method used. + * @param postData - A String of the bodyContent to be posted. A doPost will be used if this is parameter is not null. + * @param postContentType - The request contentType used when posting data. Will not be set if this parameter is null. + * @param userName - userName used for basic authorization + * @param password - password used for basic authorization + */ + public void doProcess(String urlString, + OutputStream out, + InputStream xslInputStream, + Map paramsMap, + Map headers, + String method, + String postData, + String postContentType, + String userName, + String password) throws IOException, MalformedURLException { + + if (paramsMap == null) { + paramsMap = new HashMap(); + } + + String format = (String)paramsMap.get("format"); + if (format == null) { + format = "xml"; + } + + InputStream in = null; + BufferedOutputStream os = null; + + HttpClient httpclient = null; + + if (userName != null && + password != null) { + httpclient = new HttpClient(proxyHost, proxyPort, urlString, headers, method, userName, password); + } else { + httpclient = new HttpClient(proxyHost, proxyPort, urlString, headers, method); + } + + // post data determines whether we are going to do a get or a post + if (postData == null) { + in = httpclient.getInputStream(); + } else { + in = httpclient.doPost(postData, postContentType); + } + + // read the encoding from the incoming document and default to UTF-8 + // if an encoding is not provided + String ce = httpclient.getContentEncoding(); + if (ce == null) { + String ct = httpclient.getContentType(); + if (ct != null) { + int idx = ct.lastIndexOf("charset="); + if (idx >= 0) { + ce = ct.substring(idx+8); + } else { + ce = "UTF-8"; + } + } else { + ce = "UTF-8"; + } + } + // get the content type + String cType = null; + // write out the content type + //http://www.ietf.org/rfc/rfc4627.txt + if (format.equals("json")) { + cType = "application/json;charset="+ce; + } else { + cType = "text/xml;charset="+ce; + } + try { + byte[] buffer = new byte[1024]; + int read = 0; + if (xslInputStream == null) { + while (true) { + read = in.read(buffer); + if (read <= 0) break; + out.write(buffer, 0, read ); + } + } else { + transform(in, xslInputStream, paramsMap, out, ce); + } + } catch (Exception e) { + getLogger().severe("XmlHttpProxy transformation error: " + e); + } finally { + try { + if (in != null) { + in.close(); + } + if (out != null) { + out.flush(); + out.close(); + } + } catch (Exception e) { + // do nothing + } + } + } + + /** + * Do the XSLT transformation + */ + public void transform( InputStream xmlIS, + InputStream xslIS, + Map params, + OutputStream result, + String encoding) { + try { + TransformerFactory trFac = TransformerFactory.newInstance(); + Transformer transformer = trFac.newTransformer(new StreamSource(xslIS)); + Iterator it = params.keySet().iterator(); + while (it.hasNext()) { + String key = (String)it.next(); + transformer.setParameter(key, (String)params.get(key)); + } + transformer.setOutputProperty("encoding", encoding); + transformer.transform(new StreamSource(xmlIS), new StreamResult(result)); + } catch (Exception e) { + getLogger().severe("XmlHttpProxy: Exception with xslt " + e); + } + } + + /** + * + * CLI to the XmlHttpProxy + */ + public static void main(String[] args) + throws IOException, MalformedURLException { + + getLogger().info("XmlHttpProxy 1.8"); + XmlHttpProxy xhp = new XmlHttpProxy(); + + if (args.length == 0) { + System.out.println(USAGE); + } + + String method = XmlHttpProxy.GET; + InputStream xslInputStream = null; + String serviceKey = null; + String urlString = null; + String xslURLString = null; + String format = "xml"; + String callback = null; + String urlParams = null; + String configURLString = "xhp.json"; + String resourceBase = "file:src/conf/META-INF/resources/xsl/"; + String username = null; + String password = null; + + // read in the arguments + int index = 0; + while (index < args.length) { + if (args[index].toLowerCase().equals("-url") && index + 1 < args.length) { + urlString = args[++index]; + } else if (args[index].toLowerCase().equals("-key") && index + 1 < args.length) { + serviceKey = args[++index]; + } else if (args[index].toLowerCase().equals("-id") && index + 1 < args.length) { + serviceKey = args[++index]; + } else if (args[index].toLowerCase().equals("-callback") && index + 1 < args.length) { + callback = args[++index]; + } else if (args[index].toLowerCase().equals("-xslurl") && index + 1 < args.length) { + xslURLString = args[++index]; + } else if (args[index].toLowerCase().equals("-method") && index + 1 < args.length) { + method = args[++index]; + } else if (args[index].toLowerCase().equals("-username") && index + 1 < args.length) { + username = args[++index]; + } else if (args[index].toLowerCase().equals("-password") && index + 1 < args.length) { + password = args[++index]; + } else if (args[index].toLowerCase().equals("-urlparams") && index + 1 < args.length) { + urlParams = args[++index]; + } else if (args[index].toLowerCase().equals("-config") && index + 1 < args.length) { + configURLString = args[++index]; + } else if (args[index].toLowerCase().equals("-resources") && index + 1 < args.length) { + resourceBase = args[++index]; + } + index++; + } + + if (serviceKey != null) { + try { + InputStream is = (new URL(configURLString)).openStream(); + JSONObject services = loadServices(is); + JSONObject service = services.getJSONObject(serviceKey); + // default to the service default if no url parameters are specified + if (urlParams == null && service.has("defaultURLParams")) { + urlParams = service.getString("defaultURLParams"); + } + String serviceURL = service.getString("url"); + // build the URL properly + if (urlParams != null && serviceURL.indexOf("?") == -1){ + serviceURL += "?"; + } else if (urlParams != null){ + serviceURL += "&"; + } + String apiKey = ""; + if (service.has("apikey")) apiKey = service.getString("apikey"); + urlString = serviceURL + apiKey + "&" + urlParams; + if (service.has("xslStyleSheet")) { + xslURLString = service.getString("xslStyleSheet"); + // check if the url is correct of if to load from the classpath + + } + } catch (Exception ex) { + getLogger().severe("XmlHttpProxy Error loading service: " + ex); + System.exit(1); + } + } else if (urlString == null) { + System.out.println(USAGE); + System.exit(1); + } + // The parameters are feed to the XSL Stylsheet during transformation. + // These parameters can provided data or conditional information. + Map paramsMap = new HashMap(); + if (format != null) { + paramsMap.put("format", format); + } + if (callback != null) { + paramsMap.put("callback", callback); + } + + if (xslURLString != null) { + URL xslURL = new URL(xslURLString); + if (xslURL != null) { + xslInputStream = xslURL.openStream(); + } else { + getLogger().severe("Error: Unable to locate XSL at URL " + xslURLString); + } + } + xhp.processRequest(urlString, System.out, xslInputStream, paramsMap, null, method, username, password); + } + + public static Logger getLogger() { + if (logger == null) { + logger = Logger.getLogger("jmaki.xhp.Log"); + } + return logger; + } + + public static JSONObject loadServices(InputStream is) + { + JSONObject config = null; + JSONObject services = new JSONObject(); + try + { + config = loadJSONObject(is).getJSONObject("xhp"); + JSONArray sA = config.getJSONArray("services"); + for (int l=0; l < sA.length(); l++) { + JSONObject value = sA.getJSONObject(l); + String key = value.getString("id"); + services.put(key,value); + } + } + catch (Exception ex) + { + getLogger().severe("XmlHttpProxy error loading services." + ex); + } + return services; + } + + public static JSONObject loadJSONObject(InputStream in) { + ByteArrayOutputStream out = null; + try { + byte[] buffer = new byte[1024]; + int read = 0; + out = new ByteArrayOutputStream(); + while (true) { + read = in.read(buffer); + if (read <= 0) break; + out.write(buffer, 0, read ); + } + return new JSONObject(out.toString()); + } catch (Exception e) { + getLogger().severe("XmlHttpProxy error reading in json " + e); + } finally { + try { + if (in != null) { + in.close(); + } + if (out != null) { + out.flush(); + out.close(); + } + } catch (Exception e) { + } + } + return null; + } +} \ No newline at end of file Property changes on: projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/XmlHttpProxy.java ___________________________________________________________________ Name: svn:keywords + Id Revision Name: svn:eol-style + LF Added: projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/XmlHttpProxyServlet.java =================================================================== --- projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/XmlHttpProxyServlet.java (rev 0) +++ projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/XmlHttpProxyServlet.java 2008-10-27 09:47:51 UTC (rev 2624) @@ -0,0 +1,428 @@ +/* Copyright 2007 You may not modify, use, reproduce, or distribute this software except in compliance with the terms of the License at: + http://developer.sun.com/berkeley_license.html + $Id$ +*/ +package jmaki.xhp; + +import java.io.*; +import java.util.*; +import java.net.URL; +import java.net.URLConnection; +import java.util.logging.*; + +import javax.servlet.*; +import javax.servlet.http.*; + +import org.json.*; + +/** XmlHttpProxyServlet + * @author Greg Murray + */ +public class XmlHttpProxyServlet extends HttpServlet +{ + + public static String REMOTE_USER = "REMOTE_USER"; + + private static String XHP_LAST_MODIFIED = "xhp_last_modified_key"; + private static String XHP_CONFIG = "xhp.json"; + + private static boolean allowXDomain = false; + private static boolean requireSession = false; + private static boolean createSession = false; + private static String responseContentType = "application/json;charset=UTF-8"; + private static boolean rDebug = false; + private Logger logger = null; + private XmlHttpProxy xhp = null; + private ServletContext ctx; + private JSONObject services = null; + private String resourcesDir = "/resources/"; + private String classpathResourcesDir = "/META-INF/resources/"; + private String headerToken = "jmaki-"; + + public XmlHttpProxyServlet() { + if (rDebug) { + logger = getLogger(); + } + } + + public void init(ServletConfig config) throws ServletException { + super.init(config); + ctx = config.getServletContext(); + // set the response content type + if (ctx.getInitParameter("responseContentType") != null) { + responseContentType = ctx.getInitParameter("responseContentType"); + } + // allow for resources dir over-ride at the xhp level otherwise allow + // for the jmaki level resources + if (ctx.getInitParameter("jmaki-xhp-resources") != null) { + resourcesDir = ctx.getInitParameter("jmaki-xhp-resources"); + } else if (ctx.getInitParameter("jmaki-resources") != null) { + resourcesDir = ctx.getInitParameter("jmaki-resources"); + } + // allow for resources dir over-ride + if (ctx.getInitParameter("jmaki-classpath-resources") != null) { + classpathResourcesDir = ctx.getInitParameter("jmaki-classpath-resources"); + } + String requireSessionString = ctx.getInitParameter("requireSession"); + if (requireSessionString == null) requireSessionString = ctx.getInitParameter("jmaki-requireSession"); + if (requireSessionString != null) { + if ("false".equals(requireSessionString)) { + requireSession = false; + getLogger().severe("XmlHttpProxyServlet: intialization. Session requirement disabled."); + } else if ("true".equals(requireSessionString)) { + requireSession = true; + getLogger().severe("XmlHttpProxyServlet: intialization. Session requirement enabled."); + } + } + String xdomainString = ctx.getInitParameter("allowXDomain"); + if (xdomainString == null) xdomainString = ctx.getInitParameter("jmaki-allowXDomain"); + if (xdomainString != null) { + if ("true".equals(xdomainString)) { + allowXDomain = true; + getLogger().severe("XmlHttpProxyServlet: intialization. xDomain access is enabled."); + } else if ("false".equals(xdomainString)) { + allowXDomain = false; + getLogger().severe("XmlHttpProxyServlet: intialization. xDomain access is disabled."); + } + } + String createSessionString = ctx.getInitParameter("jmaki-createSession"); + if (createSessionString != null) { + if ("true".equals(createSessionString)) { + createSession = true; + getLogger().severe("XmlHttpProxyServlet: intialization. create session is enabled."); + } else if ("false".equals(xdomainString)) { + createSession = false; + getLogger().severe("XmlHttpProxyServlet: intialization. create session is disabled."); + } + } + // if there is a proxyHost and proxyPort specified create an HttpClient with the proxy + String proxyHost = ctx.getInitParameter("proxyHost"); + String proxyPortString = ctx.getInitParameter("proxyPort"); + if (proxyHost != null && proxyPortString != null) { + int proxyPort = 8080; + try { + proxyPort= new Integer(proxyPortString).intValue(); + xhp = new XmlHttpProxy(proxyHost, proxyPort); + } catch (NumberFormatException nfe) { + getLogger().severe("XmlHttpProxyServlet: intialization error. The proxyPort must be a number"); + throw new ServletException("XmlHttpProxyServlet: intialization error. The proxyPort must be a number"); + } + } else { + xhp = new XmlHttpProxy(); + } + } + + private void getServices(HttpServletResponse res) + { + InputStream is = null; + try + { + URL url = ctx.getResource(resourcesDir + XHP_CONFIG); + // use classpath if not found locally. + //if (url == null) url = XmlHttpProxyServlet.class.getResource(classpathResourcesDir + XHP_CONFIG); + if (url == null) url = XmlHttpProxyServlet.class.getResource(XHP_CONFIG); // same package + is = url.openStream(); + } + catch (Exception ex) + { + try + { + getLogger().severe("XmlHttpProxyServlet error loading xhp.json : " + ex); + PrintWriter writer = res.getWriter(); + writer.write("XmlHttpProxyServlet Error: Error loading xhp.json. Make sure it is available in the /resources directory of your applicaton."); + writer.flush(); + } + catch (Exception iox) {} + } + services = xhp.loadServices(is); + } + + public void doDelete(HttpServletRequest req, HttpServletResponse res) { + doProcess(req,res, XmlHttpProxy.DELETE); + } + + public void doGet(HttpServletRequest req, HttpServletResponse res) { + doProcess(req,res, XmlHttpProxy.GET); + } + + public void doPost(HttpServletRequest req, HttpServletResponse res) { + doProcess(req,res, XmlHttpProxy.POST); + } + + public void doPut(HttpServletRequest req, HttpServletResponse res) { + doProcess(req,res, XmlHttpProxy.PUT); + } + + public void doProcess(HttpServletRequest req, HttpServletResponse res, String method) + { + + boolean isPost = XmlHttpProxy.POST.equals(method); + StringBuffer bodyContent = null; + OutputStream out = null; + PrintWriter writer = null; + String serviceKey = null; + /*try { + BufferedReader in = req.getReader(); + String line = null; + while ((line = in.readLine()) != null) { + if (bodyContent == null) bodyContent = new StringBuffer(); + bodyContent.append(line); + } + } catch (Exception e) { + } */ + + try + { + HttpSession session = null; + // it really does not make sense to use create session with require session as + // the create session will always result in a session created and the requireSession + // will always succeed. Leaving the logic for now. + if (createSession) { + session = req.getSession(true); + } + if (requireSession) { + // check to see if there was a session created for this request + // if not assume it was from another domain and blow up + // Wrap this to prevent Portlet exeptions + session = req.getSession(false); + if (session == null) { + res.setStatus(HttpServletResponse.SC_FORBIDDEN); + return; + } + } + serviceKey = req.getParameter("id"); + // only to preven regressions - Remove before 1.0 + if (serviceKey == null) serviceKey = req.getParameter("key"); + // check if the services have been loaded or if they need to be reloaded + if (services == null || configUpdated()) { + getServices(res); + } + String urlString = null; + String xslURLString = null; + String userName = null; + String password = null; + String format = "json"; + String callback = req.getParameter("callback"); + String urlParams = req.getParameter("urlparams"); + String countString = req.getParameter("count"); + // encode the url to prevent spaces from being passed along + if (urlParams != null) { + urlParams = urlParams.replace(' ', '+'); + } + // get the headers to pass through + Map headers = null; + // Forward all request headers starting with the header token jmaki- + // and chop off the jmaki- + Enumeration hnum = req.getHeaderNames(); + while (hnum.hasMoreElements()) { + String name = (String)hnum.nextElement(); + if (name.startsWith(headerToken)) { + if (headers == null) headers = new HashMap(); + + String value = ""; + // handle multi-value headers + Enumeration vnum = req.getHeaders(name); + while (vnum.hasMoreElements()) { + value += (String)vnum.nextElement(); + if (vnum.hasMoreElements()) value += ";"; + } + String sname = name.substring(headerToken.length(), name.length()); + headers.put(sname,value); + } + } + try + { + + if (services.has(serviceKey)) + { + JSONObject service = services.getJSONObject(serviceKey); + // default to the service default if no url parameters are specified + if (urlParams == null && service.has("defaultURLParams")) { + urlParams = service.getString("defaultURLParams"); + } + String serviceURL = service.getString("url"); + // build the URL + if (urlParams != null && serviceURL.indexOf("?") == -1){ + serviceURL += "?"; + } else if (urlParams != null) { + serviceURL += "&"; + } + String apikey = ""; + if (service.has("username")) userName = service.getString("username"); + if (service.has("password")) password = service.getString("password"); + if (service.has("apikey")) apikey = service.getString("apikey"); + urlString = serviceURL + apikey; + if (urlParams != null) urlString += "&" + urlParams; + if (service.has("xslStyleSheet")) { + xslURLString = service.getString("xslStyleSheet"); + } + } + else + { + writer = res.getWriter(); + if (serviceKey == null) writer.write("XmlHttpProxyServlet Error: id parameter specifying serivce required."); + else writer.write("XmlHttpProxyServlet Error : service for id '" + serviceKey + "' not found."); + writer.flush(); + return; + } + } + catch (Exception ex) + { + getLogger().severe("XmlHttpProxyServlet Error loading service: " + ex); + res.setStatus(500); + } + + Map paramsMap = new HashMap(); + paramsMap.put("format", format); + // do not allow for xdomain unless the context level setting is enabled. + if (callback != null && allowXDomain) { + paramsMap.put("callback", callback); + } + if (countString != null) { + paramsMap.put("count", countString); + } + + InputStream xslInputStream = null; + + if (urlString == null) { + writer = res.getWriter(); + writer.write("XmlHttpProxyServlet parameters: id[Required] urlparams[Optional] format[Optional] callback[Optional]"); + writer.flush(); + return; + } + // support for session properties and also authentication name + if (urlString.indexOf("${") != -1) { + urlString = processURL(urlString, req, res); + } + // default to JSON + res.setContentType(responseContentType); + out = res.getOutputStream(); + // get the stream for the xsl stylesheet + if (xslURLString != null) { + // check the web root for the resource + URL xslURL = null; + xslURL = ctx.getResource(resourcesDir + "xsl/"+ xslURLString); + // if not in the web root check the classpath + if (xslURL == null) { + xslURL = XmlHttpProxyServlet.class.getResource(classpathResourcesDir + "xsl/" + xslURLString); + } + if (xslURL != null) { + xslInputStream = xslURL.openStream(); + } else { + String message = "Could not locate the XSL stylesheet provided for service id " + serviceKey + ". Please check the XMLHttpProxy configuration."; + getLogger().severe(message); + res.setStatus(500); + try { + out.write(message.getBytes()); + out.flush(); + return; + } catch (java.io.IOException iox){ + } + } + } + if (!isPost) { + xhp.processRequest(urlString, out, xslInputStream, paramsMap, headers, method, userName, password); + } else { + if (bodyContent == null) getLogger().info("XmlHttpProxyServlet attempting to post to url " + urlString + " with no body content"); + xhp.doPost(urlString, out, xslInputStream, paramsMap, headers, bodyContent.toString(), req.getContentType(), userName, password); + } + } catch (Exception iox) { + iox.printStackTrace(); + getLogger().severe("XmlHttpProxyServlet: caught " + iox); + res.setStatus(500); + try { + writer = res.getWriter(); + writer.write("XmlHttpProxyServlet error loading service for " + serviceKey + " . Please notify the administrator."); + writer.flush(); + } catch (java.io.IOException ix) { + ix.printStackTrace(); + } + return; + } finally { + try { + if (out != null) out.close(); + if (writer != null) writer.close(); + } catch (java.io.IOException iox){ + } + } + } + + /* Allow for a EL style replacements in the serviceURL + * + * The constant REMOTE_USER will replace the contents of ${REMOTE_USER} + * with the return value of request.getRemoteUserver() if it is not null + * otherwise the ${REMOTE_USER} is replaced with a blank. + * + * If you use ${session.somekey} the ${session.somekey} will be replaced with + * the String value of the session varialble somekey or blank if the session key + * does not exist. + * + */ + private String processURL(String url, HttpServletRequest req, HttpServletResponse res) { + String serviceURL = url; + int start = url.indexOf("${"); + int end = url.indexOf("}", start); + if (end != -1) { + String prop = url.substring(start + 2, end).trim(); + // no matter what we will remove the ${} + // default to blank like the JSP EL + String replace = ""; + if (REMOTE_USER.equals(prop)) { + if (req.getRemoteUser() != null) replace = req.getRemoteUser(); + } + if (prop.toLowerCase().startsWith("session.")) { + String sessionKey = prop.substring("session.".length(), prop.length()); + if (req.getSession().getAttribute(sessionKey) != null) { + // force to a string + replace = req.getSession().getAttribute(sessionKey).toString(); + } + } + serviceURL = serviceURL.substring(0, start) + + replace + + serviceURL.substring(end + 1, serviceURL.length()); + } + // call recursively to process more than one instance of a ${ in the serviceURL + if (serviceURL.indexOf("${") != -1) serviceURL = processURL(serviceURL, req, res); + return serviceURL; + } + + /** + * Check to see if the configuration file has been updated so that it may be reloaded. + */ + private boolean configUpdated() { + try { + URL url = ctx.getResource(resourcesDir + XHP_CONFIG); + URLConnection con; + if (url == null) return false ; + con = url.openConnection(); + long lastModified = con.getLastModified(); + long XHP_LAST_MODIFIEDModified = 0; + if (ctx.getAttribute(XHP_LAST_MODIFIED) != null) { + XHP_LAST_MODIFIEDModified = ((Long)ctx.getAttribute(XHP_LAST_MODIFIED)).longValue(); + } else { + ctx.setAttribute(XHP_LAST_MODIFIED, new Long(lastModified)); + return false; + } + if (XHP_LAST_MODIFIEDModified < lastModified) { + ctx.setAttribute(XHP_LAST_MODIFIED, new Long(lastModified)); + return true; + } + } catch (Exception ex) { + getLogger().severe("XmlHttpProxyServlet error checking configuration: " + ex); + } + return false; + } + + public Logger getLogger() { + if (logger == null) { + logger = Logger.getLogger("jmaki.services.xhp.Log"); + } + return logger; + } + + private void logMessage(String message) { + if (rDebug) { + getLogger().info(message); + } + } +} \ No newline at end of file Property changes on: projects/gwt-console/trunk/war/src/main/java/jmaki/xhp/XmlHttpProxyServlet.java ___________________________________________________________________ Name: svn:keywords + Id Revision Name: svn:eol-style + LF Modified: projects/gwt-console/trunk/war/src/main/java/org/jboss/bpm/console/client/Authentication.java =================================================================== --- projects/gwt-console/trunk/war/src/main/java/org/jboss/bpm/console/client/Authentication.java 2008-10-27 06:21:47 UTC (rev 2623) +++ projects/gwt-console/trunk/war/src/main/java/org/jboss/bpm/console/client/Authentication.java 2008-10-27 09:47:51 UTC (rev 2624) @@ -67,6 +67,8 @@ RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, loginUrl); + System.out.println("Authentication against: " + rb.getUrl()); + if(user!=null&&pass!=null) { rb.setUser(user); @@ -80,6 +82,7 @@ public void onResponseReceived(Request request, Response response) { + System.out.println("! Auth Success"); // parse roles rolesAssigned = DTOParser.parseRolesAssigned(response.getText()); if(callback!=null) callback.onLoginSuccess(request, response); @@ -87,6 +90,8 @@ public void onError(Request request, Throwable t) { + System.out.println("! Auth failed"); + // auth failed if(callback!=null) callback.onLoginFailed(request, t); Modified: projects/gwt-console/trunk/war/src/main/java/org/jboss/bpm/console/client/util/JSONRequest.java =================================================================== --- projects/gwt-console/trunk/war/src/main/java/org/jboss/bpm/console/client/util/JSONRequest.java 2008-10-27 06:21:47 UTC (rev 2623) +++ projects/gwt-console/trunk/war/src/main/java/org/jboss/bpm/console/client/util/JSONRequest.java 2008-10-27 09:47:51 UTC (rev 2624) @@ -22,6 +22,8 @@ package org.jboss.bpm.console.client.util; /** + * Request helper, to bypass SOP restrictions.<br> + * Can only be used to retrieve Json data, wrapped in a script tag. * @author Heiko.Braun <heiko.braun(a)jboss.com&gt; */ public class JSONRequest { Added: projects/gwt-console/trunk/war/src/main/resources/jmaki/xhp/xhp.json =================================================================== --- projects/gwt-console/trunk/war/src/main/resources/jmaki/xhp/xhp.json (rev 0) +++ projects/gwt-console/trunk/war/src/main/resources/jmaki/xhp/xhp.json 2008-10-27 09:47:51 UTC (rev 2624) @@ -0,0 +1,10 @@ +{"xhp": { + "version": "1.1", + "services": [ + {"id": "jboss", + "url":"http://localhost:8080", + "passthrough":true + } + ] + } +} \ No newline at end of file Modified: projects/gwt-console/trunk/war/src/main/resources/org/jboss/bpm/console/Application.gwt.xml =================================================================== --- projects/gwt-console/trunk/war/src/main/resources/org/jboss/bpm/console/Application.gwt.xml 2008-10-27 06:21:47 UTC (rev 2623) +++ projects/gwt-console/trunk/war/src/main/resources/org/jboss/bpm/console/Application.gwt.xml 2008-10-27 09:47:51 UTC (rev 2624) @@ -7,11 +7,14 @@ <inherits name='com.googlecode.gchart.GChart'/> <!-- Specify the app entry point class. --> - <entry-point class='org.jboss.bpm.console.client.Application' /> + <entry-point class='org.jboss.bpm.console.client.Application' /> + <servlet path="/xhp" class="jmaki.xhp.XmlHttpProxyServlet"/> + <!-- Specify a css to load into your gwt application --> <stylesheet src='console.css' /> <stylesheet src="js/ext/resources/css/ext-all.css" /> <script src="js/ext/adapter/ext/ext-base.js" /> <script src="js/ext/ext-all.js" /> + </module> \ No newline at end of file Modified: projects/gwt-console/trunk/war/src/main/webapp/WEB-INF/web.xml =================================================================== --- projects/gwt-console/trunk/war/src/main/webapp/WEB-INF/web.xml 2008-10-27 06:21:47 UTC (rev 2623) +++ projects/gwt-console/trunk/war/src/main/webapp/WEB-INF/web.xml 2008-10-27 09:47:51 UTC (rev 2624) @@ -4,17 +4,20 @@ <web-app> <display-name>Archetype Created Web Application</display-name> - <servlet> - <servlet-name>HttpServlet</servlet-name> - <servlet-class>com.totsp.mavenplugin.gwt.sample.server.HttpServlet</servlet-class> + + <!--servlet> + <servlet-name>com.jsos.httpproxy.HttpProxyServlet/org.jboss.bpm.console.Application/proxy</servlet-name> + <servlet-class>com.jsos.httpproxy.HttpProxyServlet</servlet-class> + <init-param> + <param-name>host</param-name> + <param-value>http://localhost:8080/</param-value> + </init-param> </servlet> + <servlet-mapping> - <servlet-name>HttpServlet</servlet-name> - <url-pattern>/HttpServlet</url-pattern> - </servlet-mapping> + <servlet-name>com.jsos.httpproxy.HttpProxyServlet/org.jboss.bpm.console.Application/proxy</servlet-name> + <url-pattern>/org.jboss.bpm.console.Application/proxy</url-pattern> + </servlet-mapping--> - <welcome-file-list> - <welcome-file>index.html</welcome-file> - </welcome-file-list> - + </web-app> \ No newline at end of file Modified: projects/gwt-console/trunk/war/src/test/java/org/jboss/bpm/console/client/GwtTestApplication.java =================================================================== --- projects/gwt-console/trunk/war/src/test/java/org/jboss/bpm/console/client/GwtTestApplication.java 2008-10-27 06:21:47 UTC (rev 2623) +++ projects/gwt-console/trunk/war/src/test/java/org/jboss/bpm/console/client/GwtTestApplication.java 2008-10-27 09:47:51 UTC (rev 2624) @@ -22,6 +22,8 @@ package org.jboss.bpm.console.client; import com.google.gwt.junit.client.GWTTestCase; +import com.google.gwt.core.client.GWT; +import com.google.gwt.user.client.Timer; import com.gwtext.client.widgets.ComponentMgr; import org.jboss.bpm.console.client.process.ProcessDefinitionListEditor; import org.jboss.bpm.console.client.process.ProcessDefinitionList; @@ -39,7 +41,7 @@ public String getModuleName() { - return "org.jboss.bpm.console.Application"; + return "org.jboss.bpm.console.Application"; } @@ -50,11 +52,6 @@ { application = new Application(); application.onModuleLoad(); - - /*URLBuilder urlBuilder = new URLBuilder("localhost:8080", "gwt-console-server"); - Authentication auth = new Authentication(urlBuilder.getUserInRoleURL(ConsoleView.KNOWN_ROLES)); - auth.doLogin("admin", "admin"); - System.out.println("Assigned roles: " + auth.getRolesAssigned() );*/ } } @@ -64,20 +61,39 @@ ConsoleView view = application.getConsoleView(); assertNotNull("View not initialized", view); - /*ProcessDefinitionListEditor procListEditor = - (ProcessDefinitionListEditor)ComponentMgr.getComponent(ProcessDefinitionListEditor.ID); - assertNotNull("ProcessDefinitionListEditor not initialized", procListEditor); - // load process definitions - ProcessDefinitionList procDefList = procListEditor.getProcessDefinitionList(); - procDefList.reloadStore(); - - List<ProcessDefinition> available = procDefList.getAvailableProcessDefinitions(); - assertFalse("No process definitions available", available.isEmpty()); + Timer timer = new Timer() + { + public void run() + { + System.out.println("! Execute timer"); + URLBuilder urlBuilder = new URLBuilder(GWT.getModuleBaseURL(), "xhp"); + String inRoleURL = urlBuilder.getUserInRoleURL(ConsoleView.KNOWN_ROLES); + Authentication auth = new Authentication(inRoleURL+"&id=jboss"); + auth.doLogin("admin", "admin"); + System.out.println("Assigned roles: " + auth.getRolesAssigned() ); + finishTest(); + } + }; - for(ProcessDefinition def : available) - { - System.out.println(def); - } */ + timer.schedule(200); + delayTestFinish(500); } + + /*ProcessDefinitionListEditor procListEditor = + (ProcessDefinitionListEditor)ComponentMgr.getComponent(ProcessDefinitionListEditor.ID); + assertNotNull("ProcessDefinitionListEditor not initialized", procListEditor); + + // load process definitions + ProcessDefinitionList procDefList = procListEditor.getProcessDefinitionList(); + procDefList.reloadStore(); + + List<ProcessDefinition> available = procDefList.getAvailableProcessDefinitions(); + assertFalse("No process definitions available", available.isEmpty()); + + for(ProcessDefinition def : available) + { + System.out.println(def); + } */ + }