JServletEngineConfigurationFactory.java

package org.objectweb.jonas.ws.axis;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;

import org.w3c.dom.Document;

import org.apache.axis.EngineConfiguration;
import org.apache.axis.EngineConfigurationFactory;
import org.apache.axis.configuration.EngineConfigurationFactoryServlet;
import org.apache.axis.deployment.wsdd.WSDDDeployment;
import org.apache.axis.encoding.SerializationContext;
import org.apache.axis.utils.XMLUtils;

import org.objectweb.jonas.common.Log;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;


public class JServletEngineConfigurationFactory
    implements EngineConfigurationFactory {

    public static final String AXIS_SERVER_CONFIG_PARAM = "axis.serverConfigFile";

    public static final String SERVER_CONFIG_WSDD = "org/objectweb/jonas/ws/axis/server-config.wsdd";

    private static Logger logger = Log.getLogger(Log.JONAS_WS_PREFIX);

    private String serverConfigFile;

    private EngineConfigurationFactory delegate;

    private ServletContext ctx;

    private ServletConfig cfg;


    protected JServletEngineConfigurationFactory(ServletConfig conf) {
        // get the axis delegate
        cfg = conf;
        ctx = conf.getServletContext();
        delegate = EngineConfigurationFactoryServlet.newFactory(conf);
    }

    public static EngineConfigurationFactory newFactory(Object param) {

        if (param == null) {
            return null; // not for us.
        }

        if (param instanceof ServletConfig) {
            return new JServletEngineConfigurationFactory((ServletConfig) param);
        } else {
            return null;
        }
    }

    public EngineConfiguration getServerEngineConfig() {

        logger.log(BasicLevel.DEBUG, "Entering getServerEngineConfig for servlet " + cfg.getServletName());

        try {

            // retrieve init param specifying server-config.wsdd filename to be loaded
            serverConfigFile = cfg.getInitParameter(AXIS_SERVER_CONFIG_PARAM);

            logger.log(BasicLevel.DEBUG, "serverConfigFile=" + serverConfigFile);

            // if no config file specified, delegate to Axis Servlet EngineConfigurationFactory
            if (serverConfigFile == null) {
                return delegate.getServerEngineConfig();
            }

            if (logger.isLoggable(BasicLevel.DEBUG)) {
                logger.log(BasicLevel.DEBUG,
                           "Loading server-config file '" + serverConfigFile + "'");
            }

            /*
             * Use the WEB-INF directory
             * (so the config files can't get snooped by a browser)
             */
            String appWebInfPath = "/WEB-INF";

            Document deploy = null;

            String realWebInfPath = ctx.getRealPath(appWebInfPath);

            if (realWebInfPath == null
                || !(new File(realWebInfPath, serverConfigFile)).exists()) {

                String name = appWebInfPath + "/" + serverConfigFile;
                InputStream is = ctx.getResourceAsStream(name);

                if (is != null) {
                    deploy = XMLUtils.newDocument(is);
                }

                if (deploy == null) {
                    String err = "Cannot get config file '" + serverConfigFile + "' as Resource.";
                    logger.log(BasicLevel.ERROR, err);
                }
            }

            if (deploy == null  &&  realWebInfPath != null) {
                try {
                    InputStream is = new FileInputStream(new File(realWebInfPath, serverConfigFile));
                    deploy = XMLUtils.newDocument(is);
                } catch (IOException e) {
                    String err = "Cannot get config file '" + serverConfigFile + "' as File Resource.";
                    logger.log(BasicLevel.ERROR, err);
                }
            }

            // if all attempts fails, delegate to Axis...
            if (deploy == null) {
                return delegate.getServerEngineConfig();
            }

            // get Base Deployment desc as Resource of ClassLoader
            ClassLoader cl = Thread.currentThread().getContextClassLoader();
            InputStream is = cl.getResourceAsStream(SERVER_CONFIG_WSDD);
            Document base = XMLUtils.newDocument(is);

            // Combine the 2 DD
            WSDDDeployment deployWSDD = new WSDDDeployment(deploy.getDocumentElement());
            WSDDDeployment configWSDD = new WSDDDeployment(base.getDocumentElement());

            deployWSDD.deployToRegistry(configWSDD);

            if (logger.isLoggable(BasicLevel.DEBUG)) {
                StringWriter sw = new StringWriter();
                SerializationContext ctx = new SerializationContext(sw);

                try {
                    configWSDD.writeToContext(ctx);
                } catch (Exception ioe) {
                    logger.log(BasicLevel.DEBUG, "Cannot serialize Axis wsdd for servlet " + cfg.getServletName());
                }
                logger.log(BasicLevel.DEBUG, sw.getBuffer().toString());
            }

            return configWSDD;
        } catch (Exception e) {
            // if exception occurs, set a default server-config.wsdd
            String err = "Cannot configure axis server from '" + serverConfigFile + "'. Use axis default. Caused by : " + e.getMessage();
            e.printStackTrace();
            logger.log(BasicLevel.ERROR, err);
            return delegate.getServerEngineConfig();
        }
    }

    public EngineConfiguration getClientEngineConfig() {
        return null;
    }
}

---