/*
* 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.deployment.wsdd;
import org.apache.axis.ConfigurationException;
import org.apache.axis.EngineConfiguration;
import org.apache.axis.Handler;
import org.apache.axis.components.logger.LogFactory;
import org.apache.axis.encoding.SerializationContext;
import org.apache.axis.providers.java.JavaProvider;
import org.apache.axis.utils.ClassUtils;
import org.apache.axis.utils.JavaUtils;
import org.apache.axis.utils.LockableHashtable;
import org.apache.axis.utils.XMLUtils;
import org.apache.commons.logging.Log;
import org.w3c.dom.Element;
import org.xml.sax.helpers.AttributesImpl;
import javax.xml.namespace.QName;
import java.io.IOException;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* WSDD DeployableItem complexType
*
*/
public abstract class WSDDDeployableItem
extends WSDDElement
{
public static final int SCOPE_PER_ACCESS = 0;
public static final int SCOPE_PER_REQUEST = 1;
public static final int SCOPE_SINGLETON = 2;
public static String [] scopeStrings = { "per-access",
"per-request",
"singleton" };
protected static Log log =
LogFactory.getLog(WSDDDeployableItem.class.getName());
/** Our parameters */
protected LockableHashtable parameters;
/** Our name */
protected QName qname;
/** Our type */
protected QName type;
/** Scope for this item (default is singleton) */
protected int scope = SCOPE_SINGLETON;
/** Placeholder for hanging on to singleton object */
protected Handler singletonInstance = null;
/**
* Default constructor
*/
public WSDDDeployableItem()
{
}
/**
*
* @param e (Element) XXX
* @throws WSDDException XXX
*/
public WSDDDeployableItem(Element e)
throws WSDDException
{
super(e);
String name = e.getAttribute(ATTR_NAME);
if (name != null && !name.equals("")) {
// qname = XMLUtils.getQNameFromString(name, e);
qname = new QName("", name);
}
String typeStr = e.getAttribute(ATTR_TYPE);
if (typeStr != null && !typeStr.equals("")) {
type = XMLUtils.getQNameFromString(typeStr, e);
}
// Figure out our scope - right now if a non-recognized scope
// attribute appears, we will ignore it and use the default
// scope. Is this right, or should we throw an error?
String scopeStr = e.getAttribute(JavaProvider.OPTION_SCOPE);
if (scopeStr != null) {
for (int i = 0; i < scopeStrings.length; i++) {
if (scopeStr.equals(scopeStrings[i])) {
scope = i;
break;
}
}
}
parameters = new LockableHashtable();
// Load up our params
Element [] paramElements = getChildElements(e, ELEM_WSDD_PARAM);
for (int i = 0; i < paramElements.length; i++) {
Element param = paramElements[i];
String pname = param.getAttribute(ATTR_NAME);
String value = param.getAttribute(ATTR_VALUE);
String locked = param.getAttribute(ATTR_LOCKED);
parameters.put(pname, value, JavaUtils.isTrueExplicitly(locked));
}
}
/**
*
* @param name XXX
*/
public void setName(String name)
{
qname = new QName(null, name);
}
public void setQName(QName qname)
{
this.qname = qname;
}
/**
*
* @return XXX
*/
public QName getQName()
{
return qname;
}
/**
*
* @return XXX
*/
public QName getType()
{
return type;
}
/**
*
* @param type XXX
*/
public void setType(QName type)
{
this.type = type;
}
/**
* Set a parameter
*/
public void setParameter(String name, String value)
{
if (parameters == null) {
parameters = new LockableHashtable();
}
parameters.put(name, value);
}
/**
* Get the value of one of our parameters
*/
public String getParameter(String name)
{
if (name == null || parameters == null) {
return null;
}
return (String)parameters.get(name);
}
/**
* Returns the config parameters as a hashtable (lockable)
* @return XXX
*/
public LockableHashtable getParametersTable()
{
return parameters;
}
/**
* Convenience method for using old deployment XML with WSDD.
* This allows us to set the options directly after the Admin class
* has parsed them out of the old format.
*/
public void setOptionsHashtable(Hashtable hashtable)
{
if (hashtable == null)
return;
parameters = new LockableHashtable(hashtable);
}
public void writeParamsToContext(SerializationContext context)
throws IOException
{
if (parameters == null)
return;
Set entries = parameters.entrySet();
Iterator i = entries.iterator();
while (i.hasNext()) {
Map.Entry entry = (Map.Entry) i.next();
String name = (String) entry.getKey();
AttributesImpl attrs = new AttributesImpl();
attrs.addAttribute("", ATTR_NAME, ATTR_NAME, "CDATA", name);
attrs.addAttribute("", ATTR_VALUE, ATTR_VALUE, "CDATA",
entry.getValue().toString());
if (parameters.isKeyLocked(name)) {
attrs.addAttribute("", ATTR_LOCKED, ATTR_LOCKED, "CDATA", "true");
}
context.startElement(QNAME_PARAM, attrs);
context.endElement();
}
}
/**
*
* @param name XXX
*/
public void removeParameter(String name)
{
if (parameters != null) {
parameters.remove(name);
}
}
/**
*
* @param registry XXX
* @return XXX
* @throws ConfigurationException XXX
*/
public final Handler getInstance(EngineConfiguration registry)
throws ConfigurationException
{
if (scope == SCOPE_SINGLETON) {
synchronized (this) {
if (singletonInstance == null)
singletonInstance = getNewInstance(registry);
}
return singletonInstance;
}
return getNewInstance(registry);
}
private Handler getNewInstance(EngineConfiguration registry)
throws ConfigurationException
{
QName type = getType();
if (type == null ||
WSDDConstants.URI_WSDD_JAVA.equals(type.getNamespaceURI())) {
return makeNewInstance(registry);
} else {
return registry.getHandler(type);
}
}
/**
* Creates a new instance of this deployable. if the
* java class is not found, the registry is queried to
* find a suitable item
* @param registry XXX
* @return XXX
* @throws ConfigurationException XXX
*/
protected Handler makeNewInstance(EngineConfiguration registry)
throws ConfigurationException
{
Class c = null;
Handler h = null;
try {
c = getJavaClass();
} catch (ClassNotFoundException e) {
throw new ConfigurationException(e);
}
if (c != null) {
try {
h = (Handler)createInstance(c);
} catch (Exception e) {
throw new ConfigurationException(e);
}
if (h != null) {
if ( qname != null )
h.setName(qname.getLocalPart());
h.setOptions(getParametersTable());
try{
h.init();
}catch(Exception e){
String msg=e + JavaUtils.LS + JavaUtils.stackToString(e);
log.debug(msg);
throw new ConfigurationException(e);
}catch(Error e){
String msg=e + JavaUtils.LS + JavaUtils.stackToString(e);
log.debug(msg);
throw new ConfigurationException(msg);
}
}
} else {
// !!! Should never get here!
h = registry.getHandler(getType());
}
return h;
}
/**
*
* @param _class XXX
* @return XXX
*/
Object createInstance(Class _class)
throws InstantiationException, IllegalAccessException
{
return _class.newInstance();
}
/**
*
* @return XXX
* @throws ClassNotFoundException XXX
*/
public Class getJavaClass()
throws ClassNotFoundException
{
QName type = getType();
if (type != null &&
URI_WSDD_JAVA.equals(type.getNamespaceURI())) {
return ClassUtils.forName(type.getLocalPart());
}
return null;
}
}
|
