org.apache.axis2.util.Utils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of axis2-kernel Show documentation
Show all versions of axis2-kernel Show documentation
Core Parts of Axis2. This includes Axis2 engine, Client API, Addressing support, etc.,
/*
* 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.
*/
package org.apache.axis2.util;
import org.apache.axiom.om.util.UUIDGenerator;
import org.apache.axiom.soap.SOAPBody;
import org.apache.axiom.soap.SOAPEnvelope;
import org.apache.axiom.soap.SOAPFault;
import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.transport.TransportListener;
import org.apache.axis2.context.ConfigurationContext;
import org.apache.axis2.context.ConfigurationContextFactory;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.context.ServiceContext;
import org.apache.axis2.context.ServiceGroupContext;
import org.apache.axis2.description.AxisModule;
import org.apache.axis2.description.AxisOperation;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.description.Flow;
import org.apache.axis2.description.HandlerDescription;
import org.apache.axis2.description.InOnlyAxisOperation;
import org.apache.axis2.description.InOutAxisOperation;
import org.apache.axis2.description.OutInAxisOperation;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.description.PhaseRule;
import org.apache.axis2.description.WSDL2Constants;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.axis2.engine.AxisError;
import org.apache.axis2.engine.Handler;
import org.apache.axis2.engine.MessageReceiver;
import org.apache.axis2.i18n.Messages;
import org.apache.axis2.receivers.RawXMLINOutMessageReceiver;
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.xml.namespace.QName;
import java.io.File;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Enumeration;
import java.net.SocketException;
import java.net.NetworkInterface;
import java.net.InetAddress;
public class Utils {
private static final Log log = LogFactory.getLog(Utils.class);
public static void addHandler(Flow flow, Handler handler, String phaseName) {
HandlerDescription handlerDesc = new HandlerDescription(handler.getName());
PhaseRule rule = new PhaseRule(phaseName);
handlerDesc.setRules(rule);
handler.init(handlerDesc);
handlerDesc.setHandler(handler);
flow.addHandler(handlerDesc);
}
/**
* @see org.apache.axis2.util.MessageContextBuilder:createOutMessageContext()
* @deprecated (post1.1branch)
*/
public static MessageContext createOutMessageContext(MessageContext inMessageContext)
throws AxisFault {
return MessageContextBuilder.createOutMessageContext(inMessageContext);
}
public static AxisService createSimpleService(QName serviceName, String className, QName opName)
throws AxisFault {
return createSimpleService(serviceName, new RawXMLINOutMessageReceiver(), className,
opName);
}
public static AxisService createSimpleServiceforClient(QName serviceName, String className,
QName opName)
throws AxisFault {
return createSimpleServiceforClient(serviceName, new RawXMLINOutMessageReceiver(),
className,
opName);
}
public static AxisService createSimpleInOnlyService(QName serviceName,
MessageReceiver messageReceiver,
QName opName)
throws AxisFault {
AxisService service = new AxisService(serviceName.getLocalPart());
service.setClassLoader(getContextClassLoader_DoPriv());
AxisOperation axisOp = new InOnlyAxisOperation(opName);
axisOp.setMessageReceiver(messageReceiver);
axisOp.setStyle(WSDLConstants.STYLE_RPC);
service.addOperation(axisOp);
service.mapActionToOperation(Constants.AXIS2_NAMESPACE_URI + "/" + opName.getLocalPart(),
axisOp);
return service;
}
private static ClassLoader getContextClassLoader_DoPriv() {
return (ClassLoader) org.apache.axis2.java.security.AccessController.doPrivileged(
new PrivilegedAction() {
public ClassLoader run() {
return Thread.currentThread().getContextClassLoader();
}
}
);
}
public static AxisService createSimpleService(QName serviceName,
MessageReceiver messageReceiver, String className,
QName opName)
throws AxisFault {
AxisService service = new AxisService(serviceName.getLocalPart());
service.setClassLoader(getContextClassLoader_DoPriv());
service.addParameter(new Parameter(Constants.SERVICE_CLASS, className));
AxisOperation axisOp = new InOutAxisOperation(opName);
axisOp.setMessageReceiver(messageReceiver);
axisOp.setStyle(WSDLConstants.STYLE_RPC);
service.addOperation(axisOp);
service.mapActionToOperation(Constants.AXIS2_NAMESPACE_URI + "/" + opName.getLocalPart(),
axisOp);
return service;
}
public static AxisService createSimpleServiceforClient(QName serviceName,
MessageReceiver messageReceiver,
String className,
QName opName)
throws AxisFault {
AxisService service = new AxisService(serviceName.getLocalPart());
service.setClassLoader(getContextClassLoader_DoPriv());
service.addParameter(new Parameter(Constants.SERVICE_CLASS, className));
AxisOperation axisOp = new OutInAxisOperation(opName);
axisOp.setMessageReceiver(messageReceiver);
axisOp.setStyle(WSDLConstants.STYLE_RPC);
service.addOperation(axisOp);
return service;
}
public static ServiceContext fillContextInformation(AxisService axisService,
ConfigurationContext configurationContext)
throws AxisFault {
// 2. if null, create new opCtxt
// fill the service group context and service context info
return fillServiceContextAndServiceGroupContext(axisService, configurationContext);
}
private static ServiceContext fillServiceContextAndServiceGroupContext(AxisService axisService,
ConfigurationContext configurationContext)
throws AxisFault {
String serviceGroupContextId = UUIDGenerator.getUUID();
ServiceGroupContext serviceGroupContext =
configurationContext.createServiceGroupContext(axisService.getAxisServiceGroup());
serviceGroupContext.setId(serviceGroupContextId);
configurationContext.addServiceGroupContextIntoSoapSessionTable(serviceGroupContext);
return serviceGroupContext.getServiceContext(axisService);
}
/**
* Break a full path into pieces
*
* @return an array where element [0] always contains the service, and element 1, if not null, contains
* the path after the first element. all ? parameters are discarded.
*/
public static String[] parseRequestURLForServiceAndOperation(String path, String servicePath) {
if (log.isDebugEnabled()) {
log.debug("parseRequestURLForServiceAndOperation : [" + path + "][" + servicePath + "]");
}
if (path == null) {
return null;
}
String[] values = new String[2];
// TODO. This is kind of brittle. Any service with the name /services would cause fun.
int index = path.lastIndexOf(servicePath);
String service;
if (-1 != index) {
int serviceStart = index + servicePath.length();
if (path.length() > serviceStart + 1) {
service = path.substring(serviceStart + 1);
int queryIndex = service.indexOf('?');
if (queryIndex > 0) {
service = service.substring(0, queryIndex);
}
int operationIndex = service.indexOf('/');
if (operationIndex > 0) {
values[0] = service.substring(0, operationIndex);
values[1] = service.substring(operationIndex + 1);
operationIndex = values[1].lastIndexOf('/');
if (operationIndex > 0) {
values[1] = values[1].substring(operationIndex + 1);
}
} else {
values[0] = service;
}
}
} else {
if (log.isDebugEnabled()) {
log.debug("Unable to parse request URL [" + path + "][" + servicePath + "]");
}
}
return values;
}
public static ConfigurationContext getNewConfigurationContext(String repositry)
throws Exception {
final File file = new File(repositry);
boolean exists = exists(file);
if (!exists) {
throw new Exception("repository directory " + file.getAbsolutePath()
+ " does not exists");
}
File axis2xml = new File(file, "axis.xml");
String axis2xmlString = null;
if (exists(axis2xml)) {
axis2xmlString = axis2xml.getName();
}
String path = (String) org.apache.axis2.java.security.AccessController.doPrivileged(
new PrivilegedAction() {
public String run() {
return file.getAbsolutePath();
}
}
);
return ConfigurationContextFactory
.createConfigurationContextFromFileSystem(path, axis2xmlString);
}
private static boolean exists(final File file) {
Boolean exists = (Boolean) org.apache.axis2.java.security.AccessController.doPrivileged(
new PrivilegedAction() {
public Boolean run() {
return new Boolean(file.exists());
}
}
);
return exists.booleanValue();
}
public static String getParameterValue(Parameter param) {
if (param == null) {
return null;
} else {
return (String) param.getValue();
}
}
/**
* Get the name of the module , where archive name is combination of module name + its version
* The format of the name is as follows:
* moduleName-00.0000
* Example: "addressing-01.0001.mar" would return "addressing"
*
* @param moduleName the name of the module archive
* @return the module name parsed out of the file name
*/
public static String getModuleName(String moduleName) {
if (moduleName.endsWith("-SNAPSHOT")) {
return moduleName.substring(0, moduleName.indexOf("-SNAPSHOT"));
}
char delimiter = '-';
int version_index = moduleName.lastIndexOf(delimiter);
if (version_index > 0) {
String versionString = getModuleVersion(moduleName);
if (versionString == null) {
return moduleName;
} else {
return moduleName.substring(0, version_index);
}
} else {
return moduleName;
}
}
public static String getModuleVersion(String moduleName) {
if (moduleName.endsWith("-SNAPSHOT")) {
return "SNAPSHOT";
}
char version_seperator = '-';
int version_index = moduleName.lastIndexOf(version_seperator);
if (version_index > 0) {
String versionString = moduleName.substring(version_index + 1, moduleName.length());
try {
Float.parseFloat(versionString);
return versionString;
} catch (NumberFormatException e) {
return null;
}
} else {
return null;
}
}
public static String getModuleName(String moduleName, String moduleVersion) {
if (moduleVersion != null && moduleVersion.length() != 0) {
moduleName = moduleName + "-" + moduleVersion;
}
return moduleName;
}
/**
* - if he trying to engage the same module then method will returen false
* - else it will return true
*
*/
public static boolean checkVersion(String module1version,
String module2version) throws AxisFault {
if ((module1version !=null && !module1version.equals(module2version)) ||
module2version !=null && !module2version.equals(module1version)) {
throw new AxisFault("trying to engage two different module versions " +
module1version + " : " + module2version);
}
return true;
}
public static void calculateDefaultModuleVersion(HashMap modules,
AxisConfiguration axisConfig) {
Iterator allModules = modules.values().iterator();
HashMap defaultModules = new HashMap();
while (allModules.hasNext()) {
AxisModule axisModule = (AxisModule) allModules.next();
String moduleName = axisModule.getName();
String moduleNameString;
String moduleVersionString;
if (AxisModule.VERSION_SNAPSHOT.equals(axisModule.getVersion())) {
moduleNameString = axisModule.getName();
moduleVersionString = axisModule.getVersion();
} else {
if (axisModule.getVersion() == null) {
moduleNameString = getModuleName(moduleName);
moduleVersionString = getModuleVersion(moduleName);
if (moduleVersionString != null) {
try {
Float.valueOf(moduleVersionString);
axisModule.setVersion(moduleVersionString);
axisModule.setName(moduleName);
} catch (NumberFormatException e) {
moduleVersionString = null;
}
}
} else {
moduleNameString = axisModule.getName();
moduleVersionString = axisModule.getVersion();
}
}
String currentDefaultVerison = (String) defaultModules.get(moduleNameString);
if (currentDefaultVerison != null) {
// if the module version is null then , that will be ignore in this case
if (!AxisModule.VERSION_SNAPSHOT.equals(currentDefaultVerison)) {
if (moduleVersionString != null &&
isLatest(moduleVersionString, currentDefaultVerison)) {
defaultModules.put(moduleNameString, moduleVersionString);
}
}
} else {
defaultModules.put(moduleNameString, moduleVersionString);
}
}
Iterator def_mod_itr = defaultModules.keySet().iterator();
while (def_mod_itr.hasNext()) {
String moduleName = (String) def_mod_itr.next();
axisConfig.addDefaultModuleVersion(moduleName, (String) defaultModules.get(moduleName));
}
}
public static boolean isLatest(String moduleVersion, String currentDefaultVersion) {
if (AxisModule.VERSION_SNAPSHOT.equals(moduleVersion)) {
return true;
} else {
float m_version = Float.parseFloat(moduleVersion);
float m_c_vresion = Float.parseFloat(currentDefaultVersion);
return m_version > m_c_vresion;
}
}
/**
* Check if a MessageContext property is true.
*
* @param messageContext the MessageContext
* @param propertyName the property name
* @return true if the property is Boolean.TRUE, "true", 1, etc. or false otherwise
* @deprecated please use MessageContext.isTrue(propertyName) instead
*/
public static boolean isExplicitlyTrue(MessageContext messageContext, String propertyName) {
Object flag = messageContext.getProperty(propertyName);
return JavaUtils.isTrueExplicitly(flag);
}
/**
* Maps the String URI of the Message exchange pattern to a integer.
* Further, in the first lookup, it will cache the looked
* up value so that the subsequent method calls are extremely efficient.
*/
public static int getAxisSpecifMEPConstant(String messageExchangePattern) {
int mepConstant = WSDLConstants.MEP_CONSTANT_INVALID;
if (WSDL2Constants.MEP_URI_IN_OUT.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2006Constants.MEP_URI_IN_OUT.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2004_Constants.MEP_URI_IN_OUT.equals(messageExchangePattern)) {
mepConstant = WSDLConstants.MEP_CONSTANT_IN_OUT;
} else if (
WSDL2Constants.MEP_URI_IN_ONLY.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2006Constants.MEP_URI_IN_ONLY.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2004_Constants.MEP_URI_IN_ONLY
.equals(messageExchangePattern)) {
mepConstant = WSDLConstants.MEP_CONSTANT_IN_ONLY;
} else if (WSDL2Constants.MEP_URI_IN_OPTIONAL_OUT
.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2006Constants.MEP_URI_IN_OPTIONAL_OUT
.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2004_Constants.MEP_URI_IN_OPTIONAL_OUT
.equals(messageExchangePattern)) {
mepConstant = WSDLConstants.MEP_CONSTANT_IN_OPTIONAL_OUT;
} else if (WSDL2Constants.MEP_URI_OUT_IN.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2006Constants.MEP_URI_OUT_IN.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2004_Constants.MEP_URI_OUT_IN
.equals(messageExchangePattern)) {
mepConstant = WSDLConstants.MEP_CONSTANT_OUT_IN;
} else if (WSDL2Constants.MEP_URI_OUT_ONLY.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2006Constants.MEP_URI_OUT_ONLY
.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2004_Constants
.MEP_URI_OUT_ONLY.equals(messageExchangePattern)) {
mepConstant = WSDLConstants.MEP_CONSTANT_OUT_ONLY;
} else if (WSDL2Constants.MEP_URI_OUT_OPTIONAL_IN.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2006Constants.MEP_URI_OUT_OPTIONAL_IN
.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2004_Constants.MEP_URI_OUT_OPTIONAL_IN
.equals(messageExchangePattern)) {
mepConstant = WSDLConstants.MEP_CONSTANT_OUT_OPTIONAL_IN;
} else if (WSDL2Constants.MEP_URI_ROBUST_IN_ONLY.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2006Constants.MEP_URI_ROBUST_IN_ONLY
.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2004_Constants.MEP_URI_ROBUST_IN_ONLY
.equals(messageExchangePattern)) {
mepConstant = WSDLConstants.MEP_CONSTANT_ROBUST_IN_ONLY;
} else if (WSDL2Constants.MEP_URI_ROBUST_OUT_ONLY.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2006Constants.MEP_URI_ROBUST_OUT_ONLY
.equals(messageExchangePattern) ||
WSDLConstants.WSDL20_2004_Constants.MEP_URI_ROBUST_OUT_ONLY
.equals(messageExchangePattern)) {
mepConstant = WSDLConstants.MEP_CONSTANT_ROBUST_OUT_ONLY;
}
if (mepConstant == WSDLConstants.MEP_CONSTANT_INVALID) {
throw new AxisError(Messages.getMessage("mepmappingerror"));
}
return mepConstant;
}
/**
* Get an AxisFault object to represent the SOAPFault in the SOAPEnvelope attached
* to the provided MessageContext. This first check for an already extracted AxisFault
* and otherwise does a simple extract.
*
* MUST NOT be passed a MessageContext which does not contain a SOAPFault
*
* @param messageContext
* @return
*/
public static AxisFault getInboundFaultFromMessageContext(MessageContext messageContext) {
// Get the fault if it's already been extracted by a handler
AxisFault result = (AxisFault) messageContext.getProperty(Constants.INBOUND_FAULT_OVERRIDE);
// Else, extract it from the SOAPBody
if (result == null) {
SOAPEnvelope envelope = messageContext.getEnvelope();
SOAPFault soapFault;
SOAPBody soapBody;
if (envelope != null && (soapBody = envelope.getBody()) != null) {
if ((soapFault = soapBody.getFault()) != null) {
return new AxisFault(soapFault, messageContext);
}
// If its a REST response the content is not a SOAP envelop and hence we will
// Have use the soap body as the exception
if (messageContext.isDoingREST() && soapBody.getFirstElement() != null) {
return new AxisFault(soapBody.getFirstElement().toString());
}
}
// Not going to be able to
throw new IllegalArgumentException(
"The MessageContext does not have an associated SOAPFault.");
}
return result;
}
/**
* This method will provide the logic needed to retrieve an Object's classloader
* in a Java 2 Security compliant manner.
*/
public static ClassLoader getObjectClassLoader(final Object object) {
if(object == null) {
return null;
}
else {
return (ClassLoader) AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return object.getClass().getClassLoader();
}
});
}
}
public static int getMtomThreshold(MessageContext msgCtxt){
Integer value = null;
if(!msgCtxt.isServerSide()){
value = (Integer)msgCtxt.getProperty(Constants.Configuration.MTOM_THRESHOLD);
}else{
Parameter param = msgCtxt.getParameter(Constants.Configuration.MTOM_THRESHOLD);
if(param!=null){
value = (Integer)param.getValue();
}
}
int threshold = (value!=null)?value.intValue():0;
if(log.isDebugEnabled()){
log.debug("MTOM optimized Threshold value ="+threshold);
}
return threshold;
}
/**
* Returns the ip address to be used for the replyto epr
* CAUTION:
* This will go through all the available network interfaces and will try to return an ip address.
* First this will try to get the first IP which is not loopback address (127.0.0.1). If none is found
* then this will return this will return 127.0.0.1.
* This will not consider IPv6 addresses.
*
* TODO:
* - Improve this logic to genaralize it a bit more
* - Obtain the ip to be used here from the Call API
*
* @return Returns String.
* @throws java.net.SocketException
*/
public static String getIpAddress() throws SocketException {
Enumeration e = NetworkInterface.getNetworkInterfaces();
String address = "127.0.0.1";
while (e.hasMoreElements()) {
NetworkInterface netface = (NetworkInterface) e.nextElement();
Enumeration addresses = netface.getInetAddresses();
while (addresses.hasMoreElements()) {
InetAddress ip = (InetAddress) addresses.nextElement();
if (!ip.isLoopbackAddress() && isIP(ip.getHostAddress())) {
return ip.getHostAddress();
}
}
}
return address;
}
/**
* First check whether the hostname parameter is there in AxisConfiguration (axis2.xml) ,
* if it is there then this will retun that as the host name , o.w will return the IP address.
*/
public static String getIpAddress(AxisConfiguration axisConfiguration) throws SocketException {
if(axisConfiguration!=null){
Parameter param = axisConfiguration.getParameter(TransportListener.HOST_ADDRESS);
if (param != null) {
String hostAddress = ((String) param.getValue()).trim();
if(hostAddress!=null){
return hostAddress;
}
}
}
return getIpAddress();
}
/**
* First check whether the hostname parameter is there in AxisConfiguration (axis2.xml) ,
* if it is there then this will return that as the host name , o.w will return the IP address.
* @param axisConfiguration
* @return hostname
*/
public static String getHostname(AxisConfiguration axisConfiguration) {
if(axisConfiguration!=null){
Parameter param = axisConfiguration.getParameter(TransportListener.HOST_ADDRESS);
if (param != null) {
String hostAddress = ((String) param.getValue()).trim();
if(hostAddress!=null){
return hostAddress;
}
}
}
return null;
}
private static boolean isIP(String hostAddress) {
return hostAddress.split("[.]").length == 4;
}
}