/*
* 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.jaxws.util;
import org.apache.axis2.java.security.AccessController;
import org.apache.axis2.jaxws.ExceptionFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.io.IOException;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.Properties;
import java.util.StringTokenizer;
public class WSToolingUtils {
private static final Log log = LogFactory.getLog(WSToolingUtils.class);
/**
* A handy function to check for empty or null string
*
* @param str
* @return boolean
*
*/
public static boolean hasValue(String str) {
return ((str != null) && (str.length() > 0));
}
/**
* Retrieves the major version number of the WsGen class that we're using
*
* @return String
*
*/
public static String getWsGenVersion() throws ClassNotFoundException, IOException {
Class clazz = null;
try {
clazz = forName("com.sun.tools.ws.WsGen", false,
getContextClassLoader(null));
} catch (ClassNotFoundException e1) {
try {
clazz = forName("com.sun.tools.internal.ws.WsGen", false,
getContextClassLoader(null));
} catch (ClassNotFoundException e2) {
if (log.isDebugEnabled()) {
log.debug("Exception thrown from getWsGenVersion: " + e2.getMessage(), e2);
}
throw (ClassNotFoundException) e2;
}
}
Properties p = new Properties();
try {
p.load(clazz.getResourceAsStream("version.properties"));
} catch (IOException ioex) {
if (log.isDebugEnabled()) {
log.debug("Exception thrown from getWsGenVersion: " + ioex.getMessage(), ioex);
}
throw (IOException) ioex.getCause();
}
return (p.getProperty("major-version"));
}
/**
* @return ClassLoader
*/
private static ClassLoader getContextClassLoader(final ClassLoader classLoader) {
ClassLoader cl;
try {
cl = (ClassLoader) AccessController.doPrivileged(
new PrivilegedExceptionAction() {
public Object run() throws ClassNotFoundException {
return classLoader != null ? classLoader : Thread.currentThread().getContextClassLoader();
}
}
);
} catch (PrivilegedActionException e) {
if (log.isDebugEnabled()) {
log.debug("Exception thrown from AccessController: " + e.getMessage(), e);
}
throw ExceptionFactory.makeWebServiceException(e.getException());
}
return cl;
}
/**
* Return the class for this name
*
* @return Class
*/
private static Class forName(final String className, final boolean initialize,
final ClassLoader classloader) throws ClassNotFoundException {
Class cl = null;
try {
cl = (Class) AccessController.doPrivileged(
new PrivilegedExceptionAction() {
public Object run() throws ClassNotFoundException {
return Class.forName(className, initialize, classloader);
}
}
);
} catch (PrivilegedActionException e) {
if (log.isDebugEnabled()) {
log.debug("Exception thrown from AccessController: " + e.getMessage(), e);
}
throw (ClassNotFoundException) e.getException();
}
return cl;
}
/**
* Answer if the input version number is 2.1.6 or later. Version 2.1.6 is the Sun RI version that changed
* the WebMethod annotation semantics.
*
* @param wsGenVersion A version number separated by "." Up to the first 3 values will be checked.
* @return true if the version number is 2.1.6 or later, false otherwise.
*/
public static boolean isValidVersion(String wsGenVersion) {
if(log.isDebugEnabled()){
log.debug("Start isValidVersion(String)");
}
if (log.isDebugEnabled()) {
log.debug("isValidVersion: Determining if WsGen version: " +wsGenVersion
+" is appropriate version for using new SUN RI behavior");
}
if(wsGenVersion == null){
return false;
}
/*
* This algorithm is improvement over the old algorithm we had to validate the
* version. In this algorithm we don't assume that the format will be x.x.x.
* This algorithm looks for versionNumbers in a String token delimited by a
* ".", the idea is to look for the first digit in each token and compare that
* with the version validation requirements.
* we return false if version is less that 2.1.6.
* possible input version strings could be "JAX-WS RI 2.2-b05-", "2.1.6" "2.1.0" etc.
*/
// Minimum version required is 2.1.6
final int minimumVersionRequired[] = {2, 1, 6};
String version = wsGenVersion.trim();
StringTokenizer st = new StringTokenizer(version, ".");
if(st.countTokens() <= 0){
if(log.isDebugEnabled()){
log.debug("No Tokens to validate the tooling version, Input version String is invalid.");
}
return false;
}
// Check up to as many version values as we have values in the minimum required version
boolean lastCheckEqual = false;
int tokenCnt = 0;
for( ; tokenCnt < minimumVersionRequired.length && st.hasMoreTokens(); tokenCnt++) {
String token = st.nextToken();
if(token == null){
return false;
}
int versionNumber = getIntegerValue(token);
int minimumVersionNumber = minimumVersionRequired[tokenCnt];
if (versionNumber < minimumVersionNumber) {
// The version number is too low, so it is invalid
if(log.isDebugEnabled()){
log.debug("Validation failed on tokenCnt = " + tokenCnt);
log.debug("Input VersionNumber =" + versionNumber);
log.debug("Minimum Version Number required = " + minimumVersionNumber);
}
return false;
} else if (versionNumber > minimumVersionNumber) {
// The version number is higher than required, so it passes validation.
if(log.isDebugEnabled()){
log.debug("Validation passed on tokenCnt = " + tokenCnt);
log.debug("Input VersionNumber = " + versionNumber);
log.debug("Minimum Version Number required = " + minimumVersionNumber);
}
return true;
} else {
// The version number sub-value matches exactly, so we need to check the next sub-value.s
if(log.isDebugEnabled()){
log.debug("Validation unresolved on tokenCnt = " + tokenCnt);
log.debug("Input VersionNumber = " + versionNumber);
log.debug("Minimum Version Number required = " + minimumVersionNumber);
}
lastCheckEqual = true;
continue;
}
}
if(log.isDebugEnabled()){
log.debug("Exit isValidVersion(String)");
}
// If the version numbers we checked so far were equal to the minimum version BUT it was shorter
// in length, then return false. For example if the input is "2.1", that is actually "2.1.0"
// which would be less than "2.1.6".
if (lastCheckEqual && tokenCnt < minimumVersionRequired.length) {
return false;
}
return true;
}
/**
* Parse the input string and return an integer value based on it. It will look for the first numeric value
* in the string then use all digits up to the next non-numeric value or end of the string as the basis for
* the value. For example "JAX-WS RI 27" will return the value 27.
* @param s - String containing the integer to be returned.
* @return a value or -1 if not integer value was found in the token.
*/
private static int getIntegerValue(String s){
int returnValue = -1;
// Build up a buffer containing any digits up to the first non-numeric character.
StringBuffer valueString = new StringBuffer();
for(int i = 0; i < s.length(); i++){
char ch = s.charAt(i);
if(Character.isDigit(ch)){
valueString.append(Character.getNumericValue(ch));
} else if (valueString.length() > 0){
// We've found some numbers then encountered the first non-numeric value, so
// exit the loop and use those numbers as the value
break;
}
}
// If there were any numeric values found in the string, convert them to the integer return value
if (valueString.length() > 0) {
returnValue = Integer.valueOf(valueString.toString());
}
return returnValue;
}
}