001: /*
002: * The Apache Software License, Version 1.1
003: *
004: * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
005: *
006: * Redistribution and use in source and binary forms, with or without
007: * modification, are permitted provided that the following conditions
008: * are met:
009: *
010: * 1. Redistributions of source code must retain the above copyright
011: * notice, this list of conditions and the following disclaimer.
012: *
013: * 2. Redistributions in binary form must reproduce the above copyright
014: * notice, this list of conditions and the following disclaimer in
015: * the documentation and/or other materials provided with the
016: * distribution.
017: *
018: * 3. The end-user documentation included with the redistribution, if
019: * any, must include the following acknowlegement:
020: * "This product includes software developed by the
021: * Caucho Technology (http://www.caucho.com/)."
022: * Alternately, this acknowlegement may appear in the software itself,
023: * if and wherever such third-party acknowlegements normally appear.
024: *
025: * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
026: * endorse or promote products derived from this software without prior
027: * written permission. For written permission, please contact
028: * info@caucho.com.
029: *
030: * 5. Products derived from this software may not be called "Resin"
031: * nor may "Resin" appear in their names without prior written
032: * permission of Caucho Technology.
033: *
034: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
035: * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
036: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
037: * DISCLAIMED. IN NO EVENT SHALL CAUCHO TECHNOLOGY OR ITS CONTRIBUTORS
038: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
039: * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
040: * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
041: * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
042: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
043: * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
044: * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
045: *
046: * @author Scott Ferguson
047: */
048:
049: package com.caucho.burlap.client;
050:
051: import com.caucho.burlap.io.AbstractBurlapInput;
052: import com.caucho.burlap.io.BurlapOutput;
053:
054: import java.io.FileNotFoundException;
055: import java.io.IOException;
056: import java.io.InputStream;
057: import java.io.OutputStream;
058: import java.lang.reflect.InvocationHandler;
059: import java.lang.reflect.Method;
060: import java.lang.reflect.Proxy;
061: import java.net.HttpURLConnection;
062: import java.net.URL;
063: import java.net.URLConnection;
064: import java.util.logging.*;
065:
066: /**
067: * Proxy implementation for Burlap clients. Applications will generally
068: * use BurlapProxyFactory to create proxy clients.
069: */
070: public class BurlapProxy implements InvocationHandler {
071: private static final Logger log = Logger
072: .getLogger(BurlapProxy.class.getName());
073:
074: private BurlapProxyFactory _factory;
075: private URL _url;
076:
077: BurlapProxy(BurlapProxyFactory factory, URL url) {
078: _factory = factory;
079: _url = url;
080: }
081:
082: /**
083: * Returns the proxy's URL.
084: */
085: public URL getURL() {
086: return _url;
087: }
088:
089: /**
090: * Handles the object invocation.
091: *
092: * @param proxy the proxy object to invoke
093: * @param method the method to call
094: * @param args the arguments to the proxy object
095: */
096: public Object invoke(Object proxy, Method method, Object[] args)
097: throws Throwable {
098: String methodName = method.getName();
099: Class[] params = method.getParameterTypes();
100:
101: // equals and hashCode are special cased
102: if (methodName.equals("equals") && params.length == 1
103: && params[0].equals(Object.class)) {
104: Object value = args[0];
105: if (value == null || !Proxy.isProxyClass(value.getClass()))
106: return new Boolean(false);
107:
108: BurlapProxy handler = (BurlapProxy) Proxy
109: .getInvocationHandler(value);
110:
111: return new Boolean(_url.equals(handler.getURL()));
112: } else if (methodName.equals("hashCode") && params.length == 0)
113: return new Integer(_url.hashCode());
114: else if (methodName.equals("getBurlapType"))
115: return proxy.getClass().getInterfaces()[0].getName();
116: else if (methodName.equals("getBurlapURL"))
117: return _url.toString();
118: else if (methodName.equals("toString") && params.length == 0)
119: return "[BurlapProxy " + _url + "]";
120:
121: InputStream is = null;
122:
123: URLConnection conn = null;
124: HttpURLConnection httpConn = null;
125: try {
126: conn = _factory.openConnection(_url);
127: conn.setRequestProperty("Content-Type", "text/xml");
128:
129: OutputStream os;
130:
131: try {
132: os = conn.getOutputStream();
133: } catch (Exception e) {
134: throw new BurlapRuntimeException(e);
135: }
136:
137: BurlapOutput out = _factory.getBurlapOutput(os);
138:
139: if (!_factory.isOverloadEnabled()) {
140: } else if (args != null)
141: methodName = methodName + "__" + args.length;
142: else
143: methodName = methodName + "__0";
144:
145: if (log.isLoggable(Level.FINE))
146: log.fine(this + " calling " + methodName + " ("
147: + method + ")");
148:
149: out.call(methodName, args);
150:
151: try {
152: os.flush();
153: } catch (Exception e) {
154: throw new BurlapRuntimeException(e);
155: }
156:
157: if (conn instanceof HttpURLConnection) {
158: httpConn = (HttpURLConnection) conn;
159: int code = 500;
160:
161: try {
162: code = httpConn.getResponseCode();
163: } catch (Exception e) {
164: }
165:
166: if (code != 200) {
167: StringBuffer sb = new StringBuffer();
168: int ch;
169:
170: try {
171: is = httpConn.getInputStream();
172:
173: if (is != null) {
174: while ((ch = is.read()) >= 0)
175: sb.append((char) ch);
176:
177: is.close();
178: }
179:
180: is = httpConn.getErrorStream();
181: if (is != null) {
182: while ((ch = is.read()) >= 0)
183: sb.append((char) ch);
184: }
185: } catch (FileNotFoundException e) {
186: throw new BurlapRuntimeException(code + ": "
187: + String.valueOf(e));
188: } catch (IOException e) {
189: }
190:
191: if (is != null)
192: is.close();
193:
194: throw new BurlapProtocolException(code + ": "
195: + sb.toString());
196: }
197: }
198:
199: is = conn.getInputStream();
200:
201: AbstractBurlapInput in = _factory.getBurlapInput(is);
202:
203: return in.readReply(method.getReturnType());
204: } catch (BurlapProtocolException e) {
205: throw new BurlapRuntimeException(e);
206: } finally {
207: try {
208: if (is != null)
209: is.close();
210: } catch (IOException e) {
211: }
212:
213: if (httpConn != null)
214: httpConn.disconnect();
215: }
216: }
217:
218: public String toString() {
219: return getClass().getSimpleName() + "[" + _url + "]";
220: }
221: }
|