/* * The Apache Software License, Version 1.1 * * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * 3. The end-user documentation included with the redistribution, if * any, must include the following acknowlegement: * "This product includes software developed by the * Caucho Technology (http://www.caucho.com/)." * Alternately, this acknowlegement may appear in the software itself, * if and wherever such third-party acknowlegements normally appear. * * 4. The names "Burlap", "Resin", and "Caucho" must not be used to * endorse or promote products derived from this software without prior * written permission. For written permission, please contact * info@caucho.com. * * 5. Products derived from this software may not be called "Resin" * nor may "Resin" appear in their names without prior written * permission of Caucho Technology. * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL CAUCHO TECHNOLOGY OR ITS CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * @author Scott Ferguson */ package com.caucho.burlap.client; import com.caucho.burlap.io.AbstractBurlapInput; import com.caucho.burlap.io.BurlapInput; import com.caucho.burlap.io.BurlapOutput; import com.caucho.burlap.io.BurlapRemoteObject; import com.caucho.burlap.io.BurlapRemoteResolver; import com.caucho.services.client.ServiceProxyFactory; import javax.naming.Context; import javax.naming.Name; import javax.naming.NamingException; import javax.naming.RefAddr; import javax.naming.Reference; import javax.naming.spi.ObjectFactory; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.lang.reflect.Proxy; import java.net.HttpURLConnection; import java.net.MalformedURLException; import java.net.URL; import java.net.URLConnection; import java.util.Hashtable; /** * Factory for creating Burlap client stubs. The returned stub will * call the remote object for all methods. * * <pre> * String url = "http://localhost:8080/ejb/hello"; * HelloHome hello = (HelloHome) factory.create(HelloHome.class, url); * </pre> * * After creation, the stub can be like a regular Java class. Because * it makes remote calls, it can throw more exceptions than a Java class. * In particular, it may throw protocol exceptions. * * The factory can also be configured as a JNDI resource. The factory * expects to parameters: "type" and "url", corresponding to the two * arguments to <code>create</code> * * In Resin 3.0, the above example would be configured as: * <pre> * <reference> * <name>hessian/hello</name> * <factory>com.caucho.hessian.client.HessianProxyFactory</factory> * <init url="http://localhost:8080/ejb/hello"/> * type="test.HelloHome"/> * </reference> * </pre> * * To get the above resource, use JNDI as follows: * <pre> * Context ic = new InitialContext(); * HelloHome hello = (HelloHome) ic.lookup("java:comp/env/burlap/hello"); * * System.out.println("Hello: " + hello.helloWorld()); * </pre> * * <h3>Authentication</h3> * * <p>The proxy can use HTTP basic authentication if the user and the * password are set. */ public class BurlapProxyFactory implements ServiceProxyFactory, ObjectFactory { private BurlapRemoteResolver _resolver; private String _user; private String _password; private String _basicAuth; private boolean _isOverloadEnabled = false; /** * Creates the new proxy factory. */ public BurlapProxyFactory() { _resolver = new BurlapProxyResolver(this); } /** * Sets the user. */ public void setUser(String user) { _user = user; _basicAuth = null; } /** * Sets the password. */ public void setPassword(String password) { _password = password; _basicAuth = null; } /** * Returns true if overloaded methods are allowed (using mangling) */ public boolean isOverloadEnabled() { return _isOverloadEnabled; } /** * set true if overloaded methods are allowed (using mangling) */ public void setOverloadEnabled(boolean isOverloadEnabled) { _isOverloadEnabled = isOverloadEnabled; } /** * Returns the remote resolver. */ public BurlapRemoteResolver getRemoteResolver() { return _resolver; } /** * Creates the URL connection. */ protected URLConnection openConnection(URL url) throws IOException { URLConnection conn = url.openConnection(); conn.setDoOutput(true); if (_basicAuth != null) conn.setRequestProperty("Authorization", _basicAuth); else if (_user != null && _password != null) { _basicAuth = "Basic " + base64(_user + ":" + _password); conn.setRequestProperty("Authorization", _basicAuth); } return conn; } /** * Creates a new proxy with the specified URL. The API class uses * the java.api.class value from _hessian_ * * @param url the URL where the client object is located. * * @return a proxy to the object with the specified interface. */ public Object create(String url) throws MalformedURLException, ClassNotFoundException { BurlapMetaInfoAPI metaInfo; metaInfo = (BurlapMetaInfoAPI) create(BurlapMetaInfoAPI.class, url); String apiClassName = (String) metaInfo._burlap_getAttribute("java.api.class"); if (apiClassName == null) throw new BurlapRuntimeException(url + " has an unknown api."); ClassLoader loader = Thread.currentThread().getContextClassLoader(); Class apiClass = Class.forName(apiClassName, false, loader); return create(apiClass, url); } /** * Creates a new proxy with the specified URL. The returned object * is a proxy with the interface specified by api. * * <pre> * String url = "http://localhost:8080/ejb/hello"); * HelloHome hello = (HelloHome) factory.create(HelloHome.class, url); * </pre> * * @param api the interface the proxy class needs to implement * @param url the URL where the client object is located. * * @return a proxy to the object with the specified interface. */ public Object create(Class api, String urlName) throws MalformedURLException { if (api == null) throw new NullPointerException(); URL url = new URL(urlName); try { // clear old keepalive connections HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setRequestProperty("Connection", "close"); InputStream is = conn.getInputStream(); is.close(); conn.disconnect(); } catch (IOException e) { } BurlapProxy handler = new BurlapProxy(this, url); return Proxy.newProxyInstance(api.getClassLoader(), new Class[] { api, BurlapRemoteObject.class }, handler); } public AbstractBurlapInput getBurlapInput(InputStream is) { AbstractBurlapInput in = new BurlapInput(is); in.setRemoteResolver(getRemoteResolver()); return in; } public BurlapOutput getBurlapOutput(OutputStream os) { BurlapOutput out = new BurlapOutput(os); return out; } /** * JNDI object factory so the proxy can be used as a resource. */ public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?,?> environment) throws Exception { Reference ref = (Reference) obj; String api = null; String url = null; String user = null; String password = null; for (int i = 0; i < ref.size(); i++) { RefAddr addr = ref.get(i); String type = addr.getType(); String value = (String) addr.getContent(); if (type.equals("type")) api = value; else if (type.equals("url")) url = value; else if (type.equals("user")) setUser(value); else if (type.equals("password")) setPassword(value); } if (url == null) throw new NamingException("`url' must be configured for BurlapProxyFactory."); // XXX: could use meta protocol to grab this if (api == null) throw new NamingException("`type' must be configured for BurlapProxyFactory."); ClassLoader loader = Thread.currentThread().getContextClassLoader(); Class apiClass = Class.forName(api, false, loader); return create(apiClass, url); } /** * Creates the Base64 value. */ private String base64(String value) { StringBuffer cb = new StringBuffer(); int i = 0; for (i = 0; i + 2 < value.length(); i += 3) { long chunk = (int) value.charAt(i); chunk = (chunk << 8) + (int) value.charAt(i + 1); chunk = (chunk << 8) + (int) value.charAt(i + 2); cb.append(encode(chunk >> 18)); cb.append(encode(chunk >> 12)); cb.append(encode(chunk >> 6)); cb.append(encode(chunk)); } if (i + 1 < value.length()) { long chunk = (int) value.charAt(i); chunk = (chunk << 8) + (int) value.charAt(i + 1); chunk <<= 8; cb.append(encode(chunk >> 18)); cb.append(encode(chunk >> 12)); cb.append(encode(chunk >> 6)); cb.append('='); } else if (i < value.length()) { long chunk = (int) value.charAt(i); chunk <<= 16; cb.append(encode(chunk >> 18)); cb.append(encode(chunk >> 12)); cb.append('='); cb.append('='); } return cb.toString(); } public static char encode(long d) { d &= 0x3f; if (d < 26) return (char) (d + 'A'); else if (d < 52) return (char) (d + 'a' - 26); else if (d < 62) return (char) (d + '0' - 52); else if (d == 62) return '+'; else return '/'; } }