/* 
    * Copyright (c) 2007, Fraunhofer-Gesellschaft
    * 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 disclaimer at the end.
   *     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.
   * 
   * (2) Neither the name of Fraunhofer nor the names of its
   *     contributors may be used to endorse or promote products derived
   *     from this software without specific prior written permission.
   * 
   * DISCLAIMER
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS 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 THE COPYRIGHT
   * OWNER OR 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.
   *  
   */
  package org.ogf.graap.wsag.client.wsrf.impl;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.math.BigInteger;
  import java.net.URL;
  import java.security.cert.X509Certificate;
  import java.text.MessageFormat;
  import java.util.Properties;
  import java.util.Set;
  import java.util.Vector;
  
  import javax.security.auth.login.LoginContext;
  import javax.xml.namespace.QName;
  import javax.xml.stream.XMLStreamException;
  import javax.xml.stream.XMLStreamReader;
  
  import org.apache.axiom.om.OMElement;
  import org.apache.axiom.om.util.StAXUtils;
  import org.apache.axiom.soap.SOAPEnvelope;
  import org.apache.axiom.soap.impl.builder.StAXSOAPModelBuilder;
  import org.apache.axis2.AxisFault;
  import org.apache.axis2.client.OperationClient;
  import org.apache.axis2.client.ServiceClient;
  import org.apache.axis2.context.ConfigurationContext;
  import org.apache.axis2.context.ConfigurationContextFactory;
  import org.apache.axis2.context.MessageContext;
  import org.apache.axis2.transport.http.HTTPConstants;
  import org.apache.log4j.Logger;
  import org.apache.muse.util.messages.Messages;
  import org.apache.muse.util.messages.MessagesFactory;
  import org.apache.muse.util.xml.XmlUtils;
  import org.apache.muse.ws.addressing.EndpointReference;
  import org.apache.muse.ws.addressing.soap.SimpleSoapClient;
  import org.apache.muse.ws.addressing.soap.SoapConstants;
  import org.apache.muse.ws.addressing.soap.SoapFault;
  import org.apache.ws.security.WSConstants;
  import org.apache.ws.security.WSSecurityEngineResult;
  import org.apache.ws.security.WSSecurityException;
  import org.apache.ws.security.components.crypto.Crypto;
  import org.apache.ws.security.handler.WSHandlerConstants;
  import org.apache.ws.security.handler.WSHandlerResult;
  import org.apache.xmlbeans.XmlException;
  import org.apache.xmlbeans.XmlObject;
  import org.ogf.graap.wsag.api.configuration.WSAG4JConfiguration;
  import org.ogf.graap.wsag.api.logging.LogMessage;
  import org.ogf.graap.wsag.api.security.ISecurityProperties;
  import org.ogf.graap.wsag.api.security.SecurityConstants;
  import org.ogf.graap.wsag.client.wsrf.security.ClientSecurityHandler;
  import org.ogf.graap.wsag4j.types.configuration.ConfigurationDocument;
  import org.ogf.graap.wsag4j.types.configuration.ConfigurationType;
  import org.ogf.graap.wsag4j.types.configuration.HandlerType;
  import org.ogf.graap.wsag4j.types.configuration.WSRFClientConfigurationType;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  
  /**
   * Basic implementation of a SOAP client. The client implements the capabilities to send SOAP messages to a
   * WSAG4J server and performs basic security processing operations. The client implementation is NOT
   * thread-safe. Multi-threading applications must use multiple client objects in order to perform multiple
   * operations in parallel.
   * 
   * @author Oliver Waeldrich
  * 
  */
 public class Axis2SoapClient extends SimpleSoapClient
 {
 
     /**
      * user provided WSAG4J WSRF client configuration file name, this will overwrite the default configuration
      */
     public static final String WSAG4J_WSRF_CLIENT_CONFIG_FILE = "/wsrf-client.config";
 
     /**
      * default WSAG4J WSRF client configuration file name
      */
     public static final String WSAG4J_WSRF_CLIENT_CONFIG_FILE_DEFAULT = "/META-INF/wsrf-client.config";
 
     /**
      * Default location of the Axis2 configuration files. The path must contain an Axis2 configuration file
      * with the name <code>client.axis2.xml</code>. Implementations may change this property before the first
      * invocation in order to provide an alternative configuration path.
      */
     private static String defaultAxis2ConfigurationPath = "/axis2-client";
 
     /**
      * The SOAP client timeout in milliseconds.
      */
     // CHECKSTYLE:OFF - DEFAULT VARIABLE
     public static int DEFAULT_TIME_OUT_IN_MILLI_SECONDS = 2 * 60 * 1000;
 
     // CHECKSTYLE:ON
 
     private static final Logger LOG = Logger.getLogger( Axis2SoapClient.class );
 
     //
     // WSAG4J client configuration file
     //
     private static ConfigurationType config = null;
 
     //
     // AXIS2 configuration context
     //
     private static ConfigurationContext configurationContext = null;
 
     /**
      * Returns the current Axis2 configuration context used for the SOAP communication.
      * 
      * @return the configurationContext
      */
     public static ConfigurationContext getConfigurationContext()
     {
         return configurationContext;
     }
 
     /**
      * Enables implementations to provide an alternative Axis2 configuration context that will be used for
      * communicating with the WSAG4J server.
      * 
      * @param configurationContext
      *            the configurationContext to set
      */
     public static void setConfigurationContext( ConfigurationContext configurationContext )
     {
         Axis2SoapClient.configurationContext = configurationContext;
     }
 
     //
     // default definition of an empty SOAP header array
     //
     private static final Element[] EMPTY_ARRAY = new Element[0];
 
     //
     // Used to lookup all exception messages
     //
     private static final Messages MESSAGES = MessagesFactory.get( SimpleSoapClient.class );
 
     //
     // the properties are used for storing the results of the security processing
     //
     private Properties properties = new Properties();
 
     //
     // the security properties
     //
     private final ISecurityProperties securityProperties;
 
     private Crypto crypto;
 
     /**
      * Creates a new SOAP client with the given security properties.
      * 
      * @param securityProperties
      *            the security properties to use
      */
     public Axis2SoapClient( Properties properties, ISecurityProperties securityProperties )
     {
         super();
         this.securityProperties = securityProperties;
         this.properties.putAll( properties );
         initialize();
     }
 
     /**
      * initializes this client instance
      */
     protected void initialize()
     {
         //
         // get the login context and read the crypto from the login context
         //
         LoginContext context = securityProperties.getLoginContext();
 
         if ( context != null )
         {
             Set<Crypto> userCrypto = context.getSubject().getPrivateCredentials( Crypto.class );
             if ( !userCrypto.isEmpty() )
             {
                 crypto = userCrypto.iterator().next();
             }
         }
 
         //
         // read the client configuration file on the first client invocation
         //
         synchronized ( Axis2SoapClient.class )
         {
 
             try
             {
                 //
                 // first try to lookup user provided client configuration, if this can't be found use the
                 // default configuration
                 //
                 if ( config == null )
                 {
                     config = findWSAG4JConfiguration( WSAG4J_WSRF_CLIENT_CONFIG_FILE );
 
                     if ( config == null )
                     {
                         config = findWSAG4JConfiguration( WSAG4J_WSRF_CLIENT_CONFIG_FILE_DEFAULT );
                     }
                 }
             }
             catch ( IOException e )
             {
                 Object[] filler = new Object[] { WSAG4J_WSRF_CLIENT_CONFIG_FILE };
                 String message =
                     MessageFormat.format( "Failed to read wsag4j client configuration file {0}.", filler );
                 throw new RuntimeException( message );
             }
 
             try
             {
                 //
                 // the repository URL needs an / at the end,
                 // otherwise the repository is not loaded correctly
                 // from the wsag4j-client-resources bundle
                 //
                 if ( configurationContext == null )
                 {
                     URL repoURL =
                         Axis2SoapClient.class.getResource( getDefaultAxis2ConfigurationPath() + "/" );
                     URL fileURL =
                         Axis2SoapClient.class.getResource( getDefaultAxis2ConfigurationPath()
                             + "/client.axis2.xml" );
                     configurationContext =
                         ConfigurationContextFactory.createConfigurationContextFromURIs( fileURL, repoURL );
 
                     /*
                      * The following code block is commented out since we use still the default configuration
                      * of the MultiThreadedHttpConnectionManager.
                      * 
                      * There was a problem that the connections are not returned to the connection pool of the
                      * MultiThreadedHttpConnectionManager after a SOAP call. This issue was solved by calling
                      * the oc.complete( currentContext ) method after the SOAP call ( see doAxisCall ->
                      * finalize block )
                      */
 
                     /*
                      * MultiThreadedHttpConnectionManager multiThreadedHttpConnectionManager = new
                      * MultiThreadedHttpConnectionManager();
                      * 
                      * HttpConnectionManagerParams params = new HttpConnectionManagerParams();
                      * params.setDefaultMaxConnectionsPerHost(20);
                      * multiThreadedHttpConnectionManager.setParams(params); HttpClient httpClient = new
                      * HttpClient(multiThreadedHttpConnectionManager);
                      * configurationContext.setProperty(HTTPConstants.CACHED_HTTP_CLIENT, httpClient);
                      */
                 }
             }
             catch ( Exception e )
             {
                 Object[] filler = new Object[] { e.getMessage() };
                 String message =
                     MessageFormat.format( "Failed to read axis2 client configuration. Error:  {0}.", filler );
                 throw new RuntimeException( message, e );
             }
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     protected Element createMessage( EndpointReference source, EndpointReference destination, String action,
                                      Element[] bodyElements, Element[] extraHeaders )
     {
         Element[] additionalHeaders = generateExtraHeaders();
         if ( additionalHeaders == null )
         {
             additionalHeaders = EMPTY_ARRAY;
         }
 
         Element[] headers;
 
         if ( extraHeaders.length == 0 )
         {
             // extra headers is usually empty
             headers = additionalHeaders;
         }
         else
         {
             // merge the extra headers with the additional headers
             Vector<Element> tmpHeaders = new Vector<Element>();
             for ( int i = 0; i < extraHeaders.length; i++ )
             {
                 tmpHeaders.add( extraHeaders[i] );
             }
 
             for ( int i = 0; i < additionalHeaders.length; i++ )
             {
                 tmpHeaders.add( additionalHeaders[i] );
             }
 
             headers = tmpHeaders.toArray( new Element[tmpHeaders.size()] );
         }
 
         // then we let our parent create the SOAP message
         return super.createMessage( source, destination, action, bodyElements, headers );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Element[] send( EndpointReference src, EndpointReference dest, String wsaAction, Element[] body,
                            Element[] extraHeaders )
     {
         if ( dest == null )
         {
             throw new NullPointerException( MESSAGES.get( "NullDestinationEPR" ) );
         }
 
         if ( wsaAction == null )
         {
             throw new NullPointerException( MESSAGES.get( "NullActionURI" ) );
         }
 
         if ( body == null )
         {
             body = EMPTY_ARRAY;
         }
 
         if ( extraHeaders == null )
         {
             extraHeaders = EMPTY_ARRAY;
         }
 
         //
         // create the request message
         //
         Element soapRequest = createMessage( src, dest, wsaAction, body, extraHeaders );
 
         if ( isUsingTrace() )
         {
             trace( soapRequest, false );
         }
 
         Element soapResponse = null;
 
         try
         {
 
             //
             // read in the response and build an XML document from it
             //
             soapResponse = doAxisCall( soapRequest, dest, wsaAction );
         }
 
         //
         // handle errors that are thrown by axis
         // and create a Muse SOAP fault
         //
         catch ( AxisFault error )
         {
             SoapFault soapFault = new SoapFault( error.getMessage(), error );
             if ( error.getFaultCode() != null )
             {
                 soapFault.setCode( error.getFaultCode() );
             }
 
             if ( ( error.getFaultSubCodes() != null ) && ( error.getFaultSubCodes().size() > 0 ) )
             {
                 soapFault.setSubCode( (QName) error.getFaultSubCodes().get( 0 ) );
             }
 
             try
             {
                 OMElement detail = error.getDetail();
 
                 ByteArrayOutputStream detailOut = new ByteArrayOutputStream();
                 detail.serialize( detailOut );
 
                 ByteArrayInputStream detailIn = new ByteArrayInputStream( detailOut.toByteArray() );
                 soapFault.setDetail( XmlUtils.createDocument( detailIn ).getDocumentElement() );
             }
             catch ( Exception e )
             {
                 return new Element[] { soapFault.toXML() };
             }
             return new Element[] { soapFault.toXML() };
         }
 
         // handle any other runtime/IO exceptions as best we can
         catch ( Throwable error )
         {
             SoapFault soapFault = new SoapFault( error.getMessage(), error );
             return new Element[] { soapFault.toXML() };
         }
 
         if ( isUsingTrace() )
         {
             trace( soapResponse, true );
         }
 
         //
         // return the elements inside the SOAP body
         //
         Element responseBody = XmlUtils.getElement( soapResponse, SoapConstants.BODY_QNAME );
         return XmlUtils.getAllElements( responseBody );
     }
 
     /**
      * Executes a SOAP call by using the Axis 2 SOAP engine.
      * 
      * @param soapRequest
      *            the SOAP request as a DOM element
      * @param dest
      *            the destination EPR
      * @param wsaAction
      *            the web service action
      * 
      * @return the SOAP response as a DOM element
      * @throws AxisFault
      *             indicates a SOAP fault during the request
      */
     protected Element doAxisCall( Element soapRequest, EndpointReference dest, String wsaAction )
         throws AxisFault
     {
         //
         // remove old security processing results from properties
         //
         properties.remove( SecurityConstants.X509_SERVER_CERTIFICATE );
         properties.remove( SecurityConstants.X509_SERVER_CERTIFICATE_CHAIN );
 
         //
         // prepare the AXIS call by saving the old AXIS2 MessageContext
         // and creating a new MessageContext for the subsequent call.
         // This MessageContext is used to pass the client crypto to our
         // Merlin implementation.
         //
         MessageContext currentContext = new MessageContext();
         MessageContext oldContext = MessageContext.getCurrentMessageContext();
         MessageContext.setCurrentMessageContext( currentContext );
 
         ServiceClient client = new org.apache.axis2.client.ServiceClient( configurationContext, null );
 
         org.apache.axis2.addressing.EndpointReference to =
             new org.apache.axis2.addressing.EndpointReference( dest.getAddress().toString() );
         client.getOptions().setTo( to );
 
         // during the initialization of the service client, a set
         // of operation clients was created. The following types are available:
         // [ANON_OUT_IN_OP], [ANON_OUT_ONLY_OP], [ANON_ROBUST_OUT_ONLY_OP]
         OperationClient oc = client.createClient( ServiceClient.ANON_OUT_IN_OP );
 
         try
         {
 
             // serialize the message and read it via StAX
             String serializedMessage = XmlUtils.toString( soapRequest, false, false );
             InputStream in = new ByteArrayInputStream( serializedMessage.getBytes() );
 
             XMLStreamReader reader;
 
             try
             {
                 reader = StAXUtils.createXMLStreamReader( in );
             }
             catch ( XMLStreamException e )
             {
                 String message = "Error creating axis call from SOAP request";
                 throw new AxisFault( message, e );
             }
             StAXSOAPModelBuilder builder = new StAXSOAPModelBuilder( reader );
 
             // since we have parsed a new created SOAP 1.2 request,
             // the result of this process is a org.apache.axiom.soap.SOAPEnvelope
             SOAPEnvelope envelope = (SOAPEnvelope) builder.getDocumentElement();
 
             // add the user signing crypto
             currentContext.setProperty( SecurityConstants.CRYPTO_SIGN, getCrypto() );
             currentContext.setProperty( HTTPConstants.AUTO_RELEASE_CONNECTION, new Boolean( true ) );
             // currentContext.getOptions().setUseSeparateListener(true);
 
             currentContext.getOptions().setTimeOutInMilliSeconds( DEFAULT_TIME_OUT_IN_MILLI_SECONDS );
 
             currentContext.setEnvelope( envelope );
 
             oc.addMessageContext( currentContext );
             oc.getOptions().setAction( wsaAction );
 
             // oc.getOptions().setProperty(HTTPConstants.SO_TIMEOUT,new Integer(600000));
             // oc.getOptions().setProperty(HTTPConstants.CONNECTION_TIMEOUT,new Integer(600000));
             // oc.getOptions().setProperty(HTTPConstants.REUSE_HTTP_CLIENT, new Boolean(true));
 
             //
             // execute the operation client
             //
             if ( LOG.isTraceEnabled() )
             {
                 LOG.trace( MessageFormat.format( "starting call to ", new Object[] { dest.getAddress() } ) );
             }
 
             oc.execute( true );
 
             if ( LOG.isTraceEnabled() )
             {
                 LOG.trace( MessageFormat.format( "received response from  ",
                     new Object[] { dest.getAddress() } ) );
             }
 
             //
             // now we read the response from the MessageContext,
             // parse the result and return
             //
             MessageContext returnMessageContext =
                 oc.getMessageContext( org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE );
 
             SOAPEnvelope returnEnv = returnMessageContext.getEnvelope();
 
             XMLStreamReader resultReader = returnEnv.getXMLStreamReaderWithoutCaching();
 
             //
             // Read security handler results from response message context
             // and place them in the properties object.
             //
             processSecurityResults( returnMessageContext );
 
             return parseResponse( resultReader );
 
         }
         finally
         {
             oc.complete( currentContext );
             MessageContext.setCurrentMessageContext( oldContext );
         }
     }
 
     @SuppressWarnings( "unchecked" )
     private void processSecurityResults( MessageContext context ) throws AxisFault
     {
         try
         {
             Vector<WSHandlerResult> handlerResults =
                 (Vector<WSHandlerResult>) context.getProperty( WSHandlerConstants.RECV_RESULTS );
 
             //
             // Only process security handler results if present
             //
             if ( handlerResults != null )
             {
 
                 for ( int i = 0; i < handlerResults.size(); i++ )
                 {
                     WSHandlerResult currentResult = handlerResults.get( i );
 
                     Vector<WSSecurityEngineResult> wsSecEngineResults = currentResult.getResults();
 
                     for ( int j = 0; j < wsSecEngineResults.size(); j++ )
                     {
                         WSSecurityEngineResult wser = wsSecEngineResults.get( j );
                         if ( ( (Integer) wser.get( WSSecurityEngineResult.TAG_ACTION ) ).intValue() == WSConstants.SIGN
                             && wser.get( WSSecurityEngineResult.TAG_X509_CERTIFICATE ) != null )
                         {
 
                             // put the server certificate into the client properties
                             X509Certificate certificate =
                                 (X509Certificate) wser.get( WSSecurityEngineResult.TAG_X509_CERTIFICATE );
                             properties.put( SecurityConstants.X509_SERVER_CERTIFICATE, certificate );
 
                             String issuerString = certificate.getIssuerDN().getName();
                             BigInteger issuerSerial = certificate.getSerialNumber();
                             String alias = getCrypto().getAliasForX509Cert( issuerString, issuerSerial );
 
                             if ( alias != null )
                             {
                                 // Retrieve the certificate for the alias from the keystore
                                 try
                                 {
                                     X509Certificate[] certs = getCrypto().getCertificates( alias );
                                     properties.put( SecurityConstants.X509_SERVER_CERTIFICATE_CHAIN, certs );
                                 }
                                 catch ( WSSecurityException ex )
                                 {
                                     String msgError =
                                         "Axis2SoapClient: Could not get certificates for alias " + alias;
                                     throw new WSSecurityException( msgError, ex );
                                 }
                             }
                         }
 
                         if ( ( (Integer) wser.get( WSSecurityEngineResult.TAG_ACTION ) ).intValue() == WSConstants.BST
                             && wser.get( WSSecurityEngineResult.TAG_X509_CERTIFICATES ) != null )
                         {
 
                             // put the server certificates into the client properties
                             X509Certificate[] certificates =
                                 (X509Certificate[]) wser.get( WSSecurityEngineResult.TAG_X509_CERTIFICATES );
                             properties.put( SecurityConstants.X509_SERVER_CERTIFICATE_CHAIN, certificates );
                         }
                     }
 
                 }
             }
         }
         catch ( Exception e )
         {
             throw new AxisFault( "Axis2SoapClient: Error while processing security handler results.", e );
         }
     }
 
     private Element parseResponse( XMLStreamReader reader ) throws AxisFault
     {
         try
         {
             XmlObject parsedResult = XmlObject.Factory.parse( reader );
 
             if ( parsedResult.getDomNode() instanceof Document )
             {
                 return XmlUtils.getFirstElement( parsedResult.getDomNode() );
             }
             if ( parsedResult.getDomNode() instanceof Element )
             {
                 return (Element) parsedResult.getDomNode();
             }
 
             String message = "Response document is not of type document or element or null.";
             throw new AxisFault( message );
         }
         catch ( Exception e )
         {
             String message = "Error in deserializing the Axis response.";
             throw new AxisFault( message, e );
         }
     }
 
     /**
      * 
      * @return Returns a set of extra header elements that is included in the SOAP message.
      * @throws SecurityException
      */
     protected Element[] generateExtraHeaders()
     {
 
         Vector<Element> extraHeaders = new Vector<Element>();
 
         ClientSecurityHandler[] handler;
         try
         {
             handler = getSecurityHandler();
         }
         catch ( Exception e )
         {
             LOG.error( e.getMessage(), e );
             throw new RuntimeException( "failed to load security handler", e );
         }
 
         for ( int i = 0; i < handler.length; i++ )
         {
             Element[] tmpHeaders = handler[i].createHeader( securityProperties );
             for ( int j = 0; j < tmpHeaders.length; j++ )
             {
                 extraHeaders.add( tmpHeaders[j] );
             }
         }
 
         return extraHeaders.toArray( new Element[extraHeaders.size()] );
     }
 
     /**
      * @return the security handler of this client instance
      */
     protected ClientSecurityHandler[] getSecurityHandler()
     {
 
         if ( config == null )
         {
             Object[] filler = new Object[] { WSAG4J_WSRF_CLIENT_CONFIG_FILE };
             String message =
                 MessageFormat.format( "The client configuration file {0} was not found.", filler );
             LOG.warn( message );
 
             return new ClientSecurityHandler[0];
         }
 
         WSRFClientConfigurationType wsrfConfig = config.getWSRFClientConfiguration();
 
         if ( wsrfConfig.isSetSecurityHandlerChain() )
         {
             HandlerType[] handler = wsrfConfig.getSecurityHandlerChain().getHandlerArray();
             ClientSecurityHandler[] result = new ClientSecurityHandler[handler.length];
 
             for ( int i = 0; i < handler.length; i++ )
             {
                 String implementationClass = handler[i].getImplementationClass();
                 String handlerName = handler[i].getHandlerName();
 
                 try
                 {
                     @SuppressWarnings( "unchecked" )
                     Class<ClientSecurityHandler> implementation =
                         (Class<ClientSecurityHandler>) Class.forName( implementationClass );
                     result[i] = implementation.newInstance();
                 }
                 catch ( ClassNotFoundException e )
                 {
                     Object[] filler = new Object[] { implementationClass, handlerName };
                     String message =
                         MessageFormat.format(
                             "The implementation class {0} for handler {1} could not be found.", filler );
                     throw new RuntimeException( message );
                 }
                 catch ( IllegalAccessException e )
                 {
                     Object[] filler = new Object[] { implementationClass, handlerName, e.getMessage() };
                     String msgError =
                         "The implementation class {0} for handler {1} could not be accessed. [{2}]";
                     String message = MessageFormat.format( msgError, filler );
                     throw new RuntimeException( message );
                 }
                 catch ( InstantiationException e )
                 {
                     Object[] filler = new Object[] { implementationClass, handlerName, e.getMessage() };
                     String msgError =
                         "The implementation class {0} for handler {1} could not be instantiated. [{2}]";
                     String message = MessageFormat.format( msgError, filler );
                     throw new RuntimeException( message );
                 }
                 catch ( ClassCastException e )
                 {
                     Object[] filler =
                         new Object[] { implementationClass, ClientSecurityHandler.class.getName() };
                     String msgError = "The implementation class {0} does not implement the interface {1}.";
                     String message = MessageFormat.format( msgError, filler );
                     throw new RuntimeException( message );
                 }
             }
 
             return result;
         }
         else
         {
             return new ClientSecurityHandler[0];
         }
 
     }
 
     /**
      * @return the properties
      */
     public Properties getProperties()
     {
         return properties;
     }
 
     /**
      * @param properties
      *            the properties to set
      */
     public void setProperties( Properties properties )
     {
         this.properties = properties;
     }
 
     /**
      * @return the crypto
      */
     public Crypto getCrypto()
     {
         return crypto;
     }
 
     /**
      * Returns the default location of the Axis2 configuration files. The path must be available in the
      * classpath and must contain an Axis2 configuration file with the name <code>client.axis2.xml</code> and
      * all required modules.
      * 
      * @return the Axis2 configuration path
      */
     public static String getDefaultAxis2ConfigurationPath()
     {
         return defaultAxis2ConfigurationPath;
     }
 
     /**
      * Sets the default location of the Axis2 configuration files. The path must be available in the classpath
      * and must contain an Axis2 configuration file with the name <code>client.axis2.xml</code> and all
      * required modules. Implementations may change the default path in order to provide an alternative
      * configuration path and recreate the default Axis2 configuration context.
      * 
      * @param defaultAxis2ConfigurationPath
      *            the Axis2 configuration path
      * 
      * @throws Exception
      *             indicates that the creation of the new Axis2 configuration context failed
      */
     public static void setDefaultAxis2ConfigurationPath( String defaultAxis2ConfigurationPath )
         throws Exception
     {
         try
         {
             URL repoURL = Axis2SoapClient.class.getResource( defaultAxis2ConfigurationPath + "/" );
             URL fileURL =
                 Axis2SoapClient.class.getResource( defaultAxis2ConfigurationPath + "/client.axis2.xml" );
             configurationContext =
                 ConfigurationContextFactory.createConfigurationContextFromURIs( fileURL, repoURL );
 
             Axis2SoapClient.defaultAxis2ConfigurationPath = defaultAxis2ConfigurationPath;
         }
         catch ( AxisFault e )
         {
             throw new Exception( "failed to create configuration context", e );
         }
     }
 
     /**
      * @param fileName
      *            The file name of the requested XML configuration file.
      * @return The XML configuration file as an {@link org.apache.xmlbeans.XmlObject}.
      * @throws IOException
      *             the configuration file could not be read or a related error occurred
      */
     public static ConfigurationType findWSAG4JConfiguration( String fileName ) throws IOException
     {
         try
         {
 
             InputStream resourceInput = WSAG4JConfiguration.findResource( fileName );
 
             ConfigurationType result = null;
 
             if ( resourceInput != null )
             {
                 try
                 {
                     result = ConfigurationDocument.Factory.parse( resourceInput ).getConfiguration();
                 }
                 catch ( IOException e )
                 {
                     String msgText = "Error reading the configuration file {0}. Error: {1}";
                     String message = LogMessage.format( msgText, fileName, e.getMessage() );
 
                     LOG.error( message );
                     throw new IOException( message );
 
                 }
                 catch ( XmlException e )
                 {
                     String msgText = "Error reading the configuration file {0}. Description: {1}";
                     String message = LogMessage.format( msgText, fileName, e.getMessage() );
 
                     LOG.error( message );
                     throw new IOException( message );
                 }
             }
 
             return result;
         }
         catch ( Exception ex )
         {
             String msgText = "Failed to load configuration file [{0}]. Message: {1}";
             String message = LogMessage.format( msgText, fileName, ex.getMessage() );
             LOG.trace( message );
 
             return null;
         }
     }
 }