package org.astrogrid.samp.xmlrpc.internal;
import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;
import org.astrogrid.samp.SampUtils;
import org.astrogrid.samp.xmlrpc.SampXmlRpcClient;
/**
* XML-RPC client implementation suitable for use with SAMP.
* This implementation is completely freestanding and requires no other
* libraries.
*
* @author Mark Taylor
* @since 26 Aug 2008
*/
public class InternalClient implements SampXmlRpcClient {
private final URL endpoint_;
private final String userAgent_;
private static final Logger logger_ =
Logger.getLogger( InternalClient.class.getName() );
/**
* Constructor.
*
* @param endpoint endpoint
*/
public InternalClient( URL endpoint ) {
endpoint_ = endpoint;
userAgent_ = "JSAMP/" + SampUtils.getSoftwareVersion();
}
public Object callAndWait( String method, List params )
throws IOException {
HttpURLConnection connection =
(HttpURLConnection) endpoint_.openConnection();
byte[] callBuf = serializeCall( method, params );
connection.setDoOutput( true );
connection.setDoInput( true );
connection.setRequestMethod( "POST" );
connection.setRequestProperty( "Content-Type", "text/xml" );
connection.setRequestProperty( "Content-Length",
Integer.toString( callBuf.length ) );
connection.setRequestProperty( "User-Agent", userAgent_ );
connection.connect();
OutputStream out = connection.getOutputStream();
out.write( callBuf );
out.flush();
out.close();
int responseCode = connection.getResponseCode();
if ( responseCode != HttpURLConnection.HTTP_OK ) {
throw new IOException( responseCode + " "
+ connection.getResponseMessage() );
}
InputStream in = new BufferedInputStream( connection.getInputStream() );
Object result = deserializeResponse( in );
connection.disconnect();
return result;
}
// NOTE: if this method is invoked from a shutdownHook thread,
// the call may not complete because it is completed from a new thread.
public void callAndForget( String method, List params )
throws IOException {
final HttpURLConnection connection =
(HttpURLConnection) endpoint_.openConnection();
byte[] callBuf = serializeCall( method, params );
connection.setDoOutput( true );
connection.setDoInput( true );
connection.setRequestMethod( "POST" );
connection.setRequestProperty( "Content-Type", "text/xml" );
connection.setRequestProperty( "Content-Length",
Integer.toString( callBuf.length ) );
connection.setRequestProperty( "User-Agent", userAgent_ );
connection.connect();
OutputStream out = connection.getOutputStream();
out.write( callBuf );
out.flush();
out.close();
// It would be nice to just not read the input stream at all.
// However, connection.setDoInput(false) and doing no reads causes
// trouble - probably the call doesn't complete at the other end or
// something. So read it to the end asynchronously.
new Thread() {
public void run() {
try {
InputStream in =
new BufferedInputStream( connection.getInputStream() );
while ( in.read() >= 0 ) {}
int responseCode = connection.getResponseCode();
if ( responseCode != HttpURLConnection.HTTP_OK ) {
logger_.warning( responseCode + " " +
connection.getResponseMessage() );
}
}
catch ( IOException e ) {
}
finally {
connection.disconnect();
}
}
}.start();
}
/**
* Generates the XML methodCall document corresponding
* to an XML-RPC method call.
*
* @param method methodName string
* @param paramList list of XML-RPC parameters
* @return XML document as byte array
*/
protected byte[] serializeCall( String method, List paramList )
throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
XmlWriter xout = new XmlWriter( bos, 2 );
xout.start( "methodCall" );
xout.inline( "methodName", method );
if ( ! paramList.isEmpty() ) {
xout.start( "params" );
for ( Iterator it = paramList.iterator(); it.hasNext(); ) {
xout.start( "param" );
xout.sampValue( it.next() );
xout.end( "param" );
}
xout.end( "params" );
}
xout.end( "methodCall" );
xout.close();
return bos.toByteArray();
}
/**
* Deserializes an XML-RPC methodResponse document to a
* Java object.
*
* @param in input stream containing response document
*/
protected Object deserializeResponse( InputStream in )
throws IOException {
try {
Document doc = XmlUtils.createDocumentBuilder().parse( in );
Element top =
XmlUtils.getChild( XmlUtils.getChild( doc, "methodResponse" ) );
String topName = top.getTagName();
if ( "fault".equals( topName ) ) {
Element value = XmlUtils.getChild( top, "value" );
XmlUtils.getChild( value, "struct" );
Map faultMap = (Map) XmlUtils.parseSampValue( value );
Object fcode = faultMap.get( "faultCode" );
Object fmsg = faultMap.get( "faultString" );
int code = fcode instanceof Integer
? ((Integer) fcode).intValue()
: -9999;
final String msg = String.valueOf( fmsg );
throw new XmlRpcFault( code, msg );
}
else if ( "params".equals( topName ) ) {
Element value =
XmlUtils.getChild( XmlUtils.getChild( top, "param" ),
"value" );
return XmlUtils.parseSampValue( value );
}
else {
throw new XmlRpcFormatException( "Not or ?" );
}
}
catch ( ParserConfigurationException e ) {
throw (IOException) new IOException( "Trouble with XML parsing" )
.initCause( e );
}
catch ( SAXException e ) {
throw (IOException) new IOException( "Trouble with XML parsing" )
.initCause( e );
}
catch ( DOMException e ) {
throw (IOException) new IOException( "Trouble with XML parsing" )
.initCause( e );
}
}
/**
* IOException representing an incoming XML-RPC fault.
*/
private static class XmlRpcFault extends IOException {
public XmlRpcFault( int code, String msg ) {
super( "XML-RPC Fault (" + code + ": " + msg + ")" );
}
}
}