axis-rt-core/src/main/java/org/apache/axis/client/ServiceFactory.java

/*
 * Copyright 2001-2004 The Apache Software Foundation.
 * 
 * Licensed 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.
 */

package org.apache.axis.client;

import org.apache.axis.EngineConfiguration;
import org.apache.axis.configuration.EngineConfigurationFactoryFinder;
import org.apache.axis.utils.ClassUtils;
import org.apache.axis.utils.Messages;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.Name;
import javax.naming.NamingException;
import javax.naming.RefAddr;
import javax.naming.Reference;
import javax.naming.spi.ObjectFactory;
import javax.xml.namespace.QName;
import javax.xml.rpc.ServiceException;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.util.Hashtable;
import java.util.Map;
import java.util.Properties;

/**
 * Helper class for obtaining Services from JNDI.
 *
 * !!! WORK IN PROGRESS
 * 
 * @author Glen Daniels (gdaniels@apache.org)
 */ 

public class ServiceFactory extends javax.xml.rpc.ServiceFactory
        implements ObjectFactory
{
    // Constants for RefAddrs in the Reference.
    public static final String SERVICE_CLASSNAME  = "service classname";
    public static final String WSDL_LOCATION      = "WSDL location";
    public static final String MAINTAIN_SESSION   = "maintain session";
    public static final String SERVICE_NAMESPACE  = "service namespace";
    public static final String SERVICE_LOCAL_PART = "service local part";
    public static final String SERVICE_IMPLEMENTATION_NAME_PROPERTY = "serviceImplementationName";

    private static final String SERVICE_IMPLEMENTATION_SUFFIX = "Locator";

    private static EngineConfiguration _defaultEngineConfig = null;

    private static ThreadLocal threadDefaultConfig = new ThreadLocal();

    public static void setThreadDefaultConfig(EngineConfiguration config)
    {
        threadDefaultConfig.set(config);
    }
    
    private static EngineConfiguration getDefaultEngineConfig() {
        if (_defaultEngineConfig == null) {
            _defaultEngineConfig =
                EngineConfigurationFactoryFinder.newFactory().getClientEngineConfig();
        }
        return _defaultEngineConfig;
    }

    /**
     * Obtain an AxisClient reference, using JNDI if possible, otherwise
     * creating one using the standard Axis configuration pattern.  If we
     * end up creating one and do have JNDI access, bind it to the passed
     * name so we find it next time.
     *
     * @param environment
     * @return a service
     */
    public static Service getService(Map environment)
    {
        Service service = null;
        InitialContext context = null;

        EngineConfiguration configProvider =
            (EngineConfiguration)environment.get(EngineConfiguration.PROPERTY_NAME);

        if (configProvider == null)
            configProvider = (EngineConfiguration)threadDefaultConfig.get();

        if (configProvider == null)
            configProvider = getDefaultEngineConfig();

        // First check to see if JNDI works
        // !!! Might we need to set up context parameters here?
        try {
            context = new InitialContext();
        } catch (NamingException e) {
        }
        
        if (context != null) {
            String name = (String)environment.get("jndiName");
            if (name == null) {
                name = "axisServiceName";
            }

            // We've got JNDI, so try to find an AxisClient at the
            // specified name.
            try {
                service = (Service)context.lookup(name);
            } catch (NamingException e) {
                service = new Service(configProvider);
                try {
                    context.bind(name, service);
                } catch (NamingException e1) {
                    // !!! Couldn't do it, what should we do here?
                }
            }
        } else {
            service = new Service(configProvider);
        }

        return service;
    }

    public Object getObjectInstance(Object refObject, Name name,
            Context nameCtx, Hashtable environment) throws Exception
    {
        Object instance = null;
        if (refObject instanceof Reference) {
            Reference ref = (Reference) refObject;

            RefAddr addr = ref.get(SERVICE_CLASSNAME);
            Object obj = null;
            // If an explicit service classname is provided, then this is a
            // generated Service class.  Just use its default constructor.
            if (addr != null && (obj = addr.getContent()) instanceof String) {
                instance = ClassUtils.forName((String) obj).newInstance();
            }
            // else this is an instance of the Service class, so grab the
            // reference data...
            else {
                // Get the WSDL location...
                addr = ref.get(WSDL_LOCATION);
                if (addr != null && (obj = addr.getContent()) instanceof String) {
                    URL wsdlLocation = new URL((String) obj);

                    // Build the service qname...
                    addr = ref.get(SERVICE_NAMESPACE);
                    if (addr != null
                        && (obj = addr.getContent()) instanceof String) {
                        String namespace = (String) obj;
                        addr = ref.get(SERVICE_LOCAL_PART);
                        if (addr != null
                            && (obj = addr.getContent()) instanceof String) {
                            String localPart = (String) obj;
                            QName serviceName = new QName(namespace, localPart);

                            // Construct an instance of the service
                            Class[] formalArgs = new Class[]
                                    {URL.class, QName.class};
                            Object[] actualArgs = new Object[]
                                    {wsdlLocation, serviceName};
                            Constructor ctor =
                                    Service.class.getDeclaredConstructor(
                                    formalArgs);
                            instance = ctor.newInstance(actualArgs);
                        }
                    }
                }
            }
            // If maintainSession should be set to true, there will be an
            // addr for it.
            addr = ref.get(MAINTAIN_SESSION);
            if (addr != null && instance instanceof Service) {
                ((Service) instance).setMaintainSession(true);
            }
        }
        return instance;
    } // getObjectInstance

    /**
     *  Create a Service instance.
     *  @param   wsdlDocumentLocation URL for the WSDL document location
                              for the service
     *  @param   serviceName  QName for the service.
     *  @return  Service.
     *  @throws  ServiceException If any error in creation of the specified service
     */
    public javax.xml.rpc.Service createService(URL wsdlDocumentLocation,
            QName serviceName) throws ServiceException {
        return new Service(wsdlDocumentLocation, serviceName);
    } // createService

    /**
     * Create a Service instance.  Since the WSDL file is not provided
     * here, the Service object returned is quite simpleminded.
     * Likewise, the Call object that service.createCall will return
     * will also be simpleminded.  The caller must explicitly fill in
     * all the info on the Call object (ie., endpoint address, etc.).
     *
     *  @param   serviceName QName for the service
     *  @return  Service.
     *  @throws  ServiceException If any error in creation of the specified service
     */
    public javax.xml.rpc.Service createService(QName serviceName)
            throws ServiceException {
        return new Service(serviceName);
    } // createService

    /**
     * Create an instance of the generated service implementation class 
     * for a given service interface, if available. 
     *
     *  @param   serviceInterface Service interface 
     *  @return  Service.
     *  @throws  ServiceException If there is any error while creating the specified service, 
     *      including the case where a generated service implementation class cannot be located
     */
    public javax.xml.rpc.Service loadService(Class serviceInterface) throws ServiceException {
        if (serviceInterface == null) {
            throw new IllegalArgumentException(
                    Messages.getMessage("serviceFactoryIllegalServiceInterface"));
        }
        if (!(javax.xml.rpc.Service.class).isAssignableFrom(serviceInterface))
        {
            throw new ServiceException(
                    Messages.getMessage("serviceFactoryServiceInterfaceRequirement", serviceInterface.getName()));
        } else {
            String serviceImplementationName = serviceInterface.getName() + SERVICE_IMPLEMENTATION_SUFFIX;
            Service service = createService(serviceImplementationName);
            return service;
        }
    }

    /**
     * Create an instance of the generated service implementation class 
     * for a given service interface, if available. 
     * An implementation may use the provided wsdlDocumentLocation and properties 
     * to help locate the generated implementation class. 
     * If no such class is present, a ServiceException will be thrown.
     *
     *  @param   wsdlDocumentLocation URL for the WSDL document location for the service or null 
     *  @param   serviceInterface Service interface 
     *  @param   properties A set of implementation-specific properties 
     *      to help locate the generated service implementation class 
     *  @return  Service.
     *  @throws  ServiceException If there is any error while creating the specified service, 
     *      including the case where a generated service implementation class cannot be located
     */
    public javax.xml.rpc.Service loadService(URL wsdlDocumentLocation, 
            Class serviceInterface, Properties properties) throws ServiceException {
        if (serviceInterface == null) {
            throw new IllegalArgumentException(
                    Messages.getMessage("serviceFactoryIllegalServiceInterface"));
        }
        if (!(javax.xml.rpc.Service.class).isAssignableFrom(serviceInterface))
        {
            throw new ServiceException(
                    Messages.getMessage("serviceFactoryServiceInterfaceRequirement", serviceInterface.getName()));
        } else {
            String serviceImplementationName = serviceInterface.getName() + SERVICE_IMPLEMENTATION_SUFFIX;
            Service service = createService(serviceImplementationName);
            return service;
        }
    }

    /**
     * Create an instance of the generated service implementation class 
     * for a given service, if available. 
     * The service is uniquely identified by the wsdlDocumentLocation and serviceName arguments. 
     * An implementation may use the provided properties to help locate the generated implementation class. 
     * If no such class is present, a ServiceException will be thrown. 
     *
     *  @param   wsdlDocumentLocation URL for the WSDL document location for the service or null 
     *  @param   serviceName Qualified name for the service 
     *  @param   properties A set of implementation-specific properties 
     *      to help locate the generated service implementation class 
     *  @return  Service.
     *  @throws  ServiceException If there is any error while creating the specified service, 
     *      including the case where a generated service implementation class cannot be located
     */
    public javax.xml.rpc.Service loadService(URL wsdlDocumentLocation, 
            QName serviceName, Properties properties) throws ServiceException {
        String serviceImplementationName = properties.getProperty(SERVICE_IMPLEMENTATION_NAME_PROPERTY);
        javax.xml.rpc.Service service = createService(serviceImplementationName);
        if (service.getServiceName().equals(serviceName)) {
            return service;
        } else {
            throw new ServiceException(
                    Messages.getMessage("serviceFactoryServiceImplementationNotFound", serviceImplementationName));
        }
    }

    private Service createService(String serviceImplementationName) throws ServiceException {
        if(serviceImplementationName == null) {
            throw new IllegalArgumentException(Messages.getMessage("serviceFactoryInvalidServiceName"));
        }
        try {
            Class serviceImplementationClass;
            serviceImplementationClass = Thread.currentThread().getContextClassLoader().loadClass(serviceImplementationName);
            if (!(org.apache.axis.client.Service.class).isAssignableFrom(serviceImplementationClass)) {
                throw new ServiceException(
                        Messages.getMessage("serviceFactoryServiceImplementationRequirement", serviceImplementationName));
            }
            Service service = (Service) serviceImplementationClass.newInstance();
            if (service.getServiceName() != null) {
                return service;
            } else {
                throw new ServiceException(Messages.getMessage("serviceFactoryInvalidServiceName"));
            }
        } catch (ServiceException e) {
            throw e;
        } catch (Exception e){
            throw new ServiceException(e);
        }
        
    }
}