package org.apache.continuum.distributed.commons.utils;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import com.atlassian.xmlrpc.Binder;
import com.atlassian.xmlrpc.BinderTypeFactory;
import com.atlassian.xmlrpc.BindingException;
import com.atlassian.xmlrpc.ConnectionInfo;
import com.atlassian.xmlrpc.ServiceObject;
import com.atlassian.xmlrpc.XmlRpcClientProvider;
import com.atlassian.xmlrpc.XmlRpcInvocationHandler;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
import org.apache.xmlrpc.XmlRpcException;
import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
import org.apache.xmlrpc.client.XmlRpcCommonsTransportFactory;
import java.lang.reflect.Proxy;
import java.net.URL;
import java.util.Vector;
/**
* Used to bind the given XML-RPC service to an instance of
* the given interface type.
*
* This implementation uses the Apache XML-RPC client.
*
* This is derived from ApacheBinder from the atlassian-xmlrpc-binder project. In this version, we customise the
* transport used for better connection management. It is thread-safe and should be reused.
*
* @author <a href="mailto:james@atlassian.com">James William Dumay</a>
*/
public class ContinuumXmlRpcBinder
implements Binder
{
private final HttpClient httpClient;
private static ContinuumXmlRpcBinder binder = new ContinuumXmlRpcBinder();
private ContinuumXmlRpcBinder()
{
this.httpClient = new HttpClient( new MultiThreadedHttpConnectionManager() );
}
public <T> T bind( Class<T> bindClass, URL url )
throws BindingException
{
return bind( bindClass, url, new ConnectionInfo() );
}
public <T> T bind( Class<T> bindClass, URL url, ConnectionInfo connectionInfo )
throws BindingException
{
if ( !bindClass.isInterface() )
{
throw new BindingException( "Class " + bindClass.getName() + "is not an interface" );
}
ServiceObject serviceObject = bindClass.getAnnotation( ServiceObject.class );
if ( serviceObject == null )
{
throw new BindingException( "Could not find ServiceObject annotation on " + bindClass.getName() );
}
final XmlRpcClient client = getXmlRpcClient( url, connectionInfo );
XmlRpcInvocationHandler handler = new XmlRpcInvocationHandler( new XmlRpcClientProvider()
{
public Object execute( String serviceName, String methodName, Vector arguments )
throws BindingException
{
try
{
return client.execute( serviceName + "." + methodName, arguments );
}
catch ( XmlRpcException e )
{
throw new BindingException( e );
}
}
} );
return (T) Proxy.newProxyInstance( getClass().getClassLoader(), new Class[]{bindClass}, handler );
}
private XmlRpcClient getXmlRpcClient( URL url, ConnectionInfo connectionInfo )
{
XmlRpcClientConfigImpl clientConfig = new XmlRpcClientConfigImpl();
clientConfig.setServerURL( url );
clientConfig.setEnabledForExceptions( true );
if ( connectionInfo != null )
{
clientConfig.setBasicUserName( connectionInfo.getUsername() );
clientConfig.setBasicPassword( connectionInfo.getPassword() );
clientConfig.setBasicEncoding( connectionInfo.getEncoding() );
clientConfig.setGzipCompressing( connectionInfo.isGzip() );
clientConfig.setGzipRequesting( connectionInfo.isGzip() );
clientConfig.setReplyTimeout( connectionInfo.getTimeout() );
clientConfig.setConnectionTimeout( connectionInfo.getTimeout() );
clientConfig.setTimeZone( connectionInfo.getTimeZone() );
}
final XmlRpcClient client = new XmlRpcClient();
client.setTypeFactory( new BinderTypeFactory( client ) );
XmlRpcCommonsTransportFactory factory = new XmlRpcCommonsTransportFactory( client );
// Alternative - use simple connection manager, but make sure it closes the connection each time
// This would be set here since it would not be thread-safe
// factory.setHttpClient( new HttpClient( new SimpleHttpConnectionManager( true ) ) );
factory.setHttpClient( httpClient );
client.setConfig( clientConfig );
return client;
}
public static ContinuumXmlRpcBinder getInstance()
{
return binder;
}
}