/*
* 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.description.validator;
import org.apache.axis2.jaxws.description.EndpointDescription;
import org.apache.axis2.jaxws.description.EndpointDescriptionJava;
import org.apache.axis2.jaxws.description.EndpointDescriptionWSDL;
import org.apache.axis2.jaxws.description.EndpointInterfaceDescription;
import org.apache.axis2.jaxws.description.builder.MDQConstants;
import org.apache.axis2.jaxws.description.impl.DescriptionUtils;
import org.apache.axis2.jaxws.i18n.Messages;
import javax.wsdl.Port;
import javax.wsdl.Service;
import javax.xml.namespace.QName;
import javax.xml.ws.WebServiceFeature;
import javax.xml.ws.http.HTTPBinding;
import javax.xml.ws.soap.AddressingFeature;
import javax.xml.ws.soap.SOAPBinding;
import javax.xml.ws.spi.WebServiceFeatureAnnotation;
import java.lang.annotation.Annotation;
import java.util.Iterator;
import java.util.List;
/**
*
*/
public class EndpointDescriptionValidator extends Validator {
EndpointDescription endpointDesc;
EndpointDescriptionJava endpointDescJava;
EndpointDescriptionWSDL endpointDescWSDL;
public EndpointDescriptionValidator(EndpointDescription toValidate) {
endpointDesc = toValidate;
endpointDescJava = (EndpointDescriptionJava)endpointDesc;
endpointDescWSDL = (EndpointDescriptionWSDL)endpointDesc;
}
public boolean validate() {
if (getValidationLevel() == ValidationLevel.OFF) {
return VALID;
}
//The following phase II validation can only happen on the server side
if (endpointDesc.getServiceDescription().isServerSide()) {
if (!validateWSDLPort()) {
return INVALID;
}
if (!validateWSDLBindingType()) {
return INVALID;
}
if (!validateRespectBinding()) {
return INVALID;
}
}
if (!validateEndpointInterface()) {
return INVALID;
}
return VALID;
}
private boolean validateWSDLBindingType() {
boolean isBindingValid = false;
//Get the binding type from the annotation
String bindingType = endpointDesc.getBindingType();
// The wsdl binding type that we now receive has been previously mapped to the expected
// SOAP and HTTP bindings. So, there is now limited validation to perform.
//
// IMPORTANT NOTE: The value returned is NOT the WSDL Binding Type value; it has been
// normalized to be the value corresponding to the JAXWS BindingType annotations.
// That means when we log this value below we need to un-normalize it so the value
// is one that actuall appears in the WSDL. This isn't an issue for SOAP11 because
// the values are the same; but it IS an issue for SOAP12.
String wsdlBindingType = endpointDescWSDL.getWSDLBindingType();
if (bindingType == null) {
// I don't think this can happen; the Description layer should provide a default
addValidationFailure(this,
"Annotation binding type is null and did not have a default");
isBindingValid = false;
}
// Validate that the annotation value specified is valid.
else if (!SOAPBinding.SOAP11HTTP_BINDING.equals(bindingType) &&
!SOAPBinding.SOAP11HTTP_MTOM_BINDING.equals(bindingType) &&
!SOAPBinding.SOAP12HTTP_BINDING.equals(bindingType) &&
!SOAPBinding.SOAP12HTTP_MTOM_BINDING.equals(bindingType) &&
!MDQConstants.SOAP11JMS_BINDING.equals(bindingType) &&
!MDQConstants.SOAP11JMS_MTOM_BINDING.equals(bindingType) &&
!MDQConstants.SOAP12JMS_BINDING.equals(bindingType) &&
!MDQConstants.SOAP12JMS_MTOM_BINDING.equals(bindingType) &&
!HTTPBinding.HTTP_BINDING.equals(bindingType) &&
!MDQConstants.SOAP_HTTP_BINDING.equals(bindingType)) {
addValidationFailure(this,
"Invalid annotation binding value specified: " + bindingType);
isBindingValid = false;
}
else if(bindingType.equals(MDQConstants.SOAP_HTTP_BINDING) && endpointDesc.isEndpointBased()){
addValidationFailure(this,
"A SOAP_HTTP_BINDING was found on a @Bindingtype SEI based Endpoint." +
" SOAP_HTTP_BINDING is supported on Provider Endpoints only.");
isBindingValid = false;
}
// If there's no WSDL, then there will be no WSDL Binding Type to validate against
else if (wsdlBindingType == null) {
isBindingValid = true;
}
// Validate that the WSDL value is valid
else if (!SOAPBinding.SOAP11HTTP_BINDING.equals(wsdlBindingType)
&& !SOAPBinding.SOAP12HTTP_BINDING.equals(wsdlBindingType)
&& !javax.xml.ws.http.HTTPBinding.HTTP_BINDING.equals(wsdlBindingType)) {
addValidationFailure(this, "Invalid wsdl binding value specified: "
+ DescriptionUtils.mapBindingTypeAnnotationToWsdl(wsdlBindingType));
isBindingValid = false;
}
// Validate that the WSDL and annotations values indicate the same type of binding
else if (wsdlBindingType.equals(SOAPBinding.SOAP11HTTP_BINDING)
&& (bindingType.equals(SOAPBinding.SOAP11HTTP_BINDING) ||
bindingType.equals(SOAPBinding.SOAP11HTTP_MTOM_BINDING))) {
isBindingValid = true;
} else if (wsdlBindingType.equals(SOAPBinding.SOAP12HTTP_BINDING)
&& (bindingType.equals(SOAPBinding.SOAP12HTTP_BINDING) ||
bindingType.equals(SOAPBinding.SOAP12HTTP_MTOM_BINDING))) {
isBindingValid = true;
} else if (wsdlBindingType.equals(HTTPBinding.HTTP_BINDING)
&& bindingType.equals(HTTPBinding.HTTP_BINDING)) {
isBindingValid = true;
}
// The HTTP binding is not valid on a Java Bean SEI-based endpoint; only on a Provider based one.
else if (wsdlBindingType.equals(HTTPBinding.HTTP_BINDING) &&
endpointDesc.isEndpointBased()) {
addValidationFailure(this,
"An HTTPBinding was found on an @WebService SEI based endpoint. " +
"This is not supported. " +
"An HTTPBinding must use an @WebServiceProvider endpoint.");
isBindingValid = false;
}
// If wsdl binding is not HTTP binding and BindingType annotation is SOAP_HTTP_BINDING then
// wsdl is valid and JAX-WS needs to support both soap 11 and soap 12 on Provider endpoints.
else if(!wsdlBindingType.equals(HTTPBinding.HTTP_BINDING)
&& bindingType.equals(MDQConstants.SOAP_HTTP_BINDING) && endpointDesc.isProviderBased()){
isBindingValid = true;
}
else {
// Mismatched bindings
String wsdlInsert = "[" + bindingHumanReadableDescription(wsdlBindingType) + "]" +
"namespace = {" + DescriptionUtils.mapBindingTypeAnnotationToWsdl(wsdlBindingType) +"}";
String annotationInsert = "[" + bindingHumanReadableDescription(bindingType) + "]" +
"namespace = {" + bindingType +"}";
String message = Messages.getMessage("endpointDescriptionValidation",
wsdlInsert, annotationInsert);
addValidationFailure(this, message);
isBindingValid = false;
}
return isBindingValid;
}
private boolean validateWSDLPort() {
// VALIDATION: If the service is specified in the WSDL, then the port must also be specified.
// If the service is NOT in the WSDL, then this is "partial wsdl" and there is nothing to validate
// against the WSDL
Service wsdlService = endpointDescWSDL.getWSDLService();
if (wsdlService != null) {
Port wsdlPort = endpointDescWSDL.getWSDLPort();
if (wsdlPort == null) {
addValidationFailure(this,
"Serivce exists in WSDL, but Port does not. Not a valid Partial WSDL. Service: "
+ endpointDesc.getServiceQName() + "; Port: " +
endpointDesc.getPortQName());
return INVALID;
}
}
return VALID;
}
private boolean validateEndpointInterface() {
EndpointInterfaceDescription eid = endpointDesc.getEndpointInterfaceDescription();
if (eid != null) {
EndpointInterfaceDescriptionValidator eidValidator =
new EndpointInterfaceDescriptionValidator(eid);
boolean isEndpointInterfaceValid = eidValidator.validate();
if (!isEndpointInterfaceValid) {
addValidationFailure(eidValidator, "Invalid Endpoint Interface");
return INVALID;
}
}
return VALID;
}
/*
* If the @RespectBinding annotation is present, then we must also have a WSDL
*/
private boolean validateRespectBinding() {
// If a WSDL with a valid <wsdl:port> was present, then the WSDL is considered
// fully specified. Without that, the @RespectBinding annotation is invalid.
if (endpointDesc.respectBinding()) {
String wsdlLocation = null;
if (!endpointDesc.isProviderBased()) {
wsdlLocation = endpointDescJava.getAnnoWebServiceWSDLLocation();
}
else {
wsdlLocation = endpointDescJava.getAnnoWebServiceProvider().wsdlLocation();
}
if (wsdlLocation == null || wsdlLocation.length() == 0) {
addValidationFailure(this, "Annotation @RespectBinding requires that a WSDL file be specified.");
return Validator.INVALID;
}
// We will validate the configured bindings based on their mapping
// to a known WebServiceFeature element. If there is not a WebServiceFeature
// annotation for a given binding, a validation error will be returned.
List required = endpointDesc.getRequiredBindings();
if (required.size() > 0) {
Iterator i = required.iterator();
while (i.hasNext()) {
QName name = (QName) i.next();
String featureName = getFeatureForBinding(name);
if (featureName != null && featureName.length() > 0) {
EndpointDescriptionJava edj = (EndpointDescriptionJava) endpointDesc;
Annotation anno = edj.getAnnoFeature(featureName);
WebServiceFeatureAnnotation feature = getFeatureFromAnnotation(anno);
if (feature == null) {
addValidationFailure(this, "Annotation @RespectBinding was enabled, but the " +
"corresponding feature " + featureName + " was not enabled.");
return Validator.INVALID;
}
}
else {
addValidationFailure(this, "Annotation @RespectBinding was enabled, but extensibility element " +
name + " was not recognized.");
return Validator.INVALID;
}
}
}
}
return Validator.VALID;
}
private WebServiceFeatureAnnotation getFeatureFromAnnotation(Annotation a) {
return a.annotationType().getAnnotation(WebServiceFeatureAnnotation.class);
}
private static String bindingHumanReadableDescription(String ns) {
if (SOAPBinding.SOAP11HTTP_BINDING.equals(ns)) {
return "SOAP 1.1 HTTP Binding";
} else if (SOAPBinding.SOAP11HTTP_MTOM_BINDING.equals(ns)) {
return "SOAP 1.1 MTOM HTTP Binding";
} else if (SOAPBinding.SOAP12HTTP_BINDING.equals(ns)) {
return "SOAP 1.2 HTTP Binding";
} else if (SOAPBinding.SOAP12HTTP_MTOM_BINDING.equals(ns)) {
return "SOAP 1.2 MTOM HTTP Binding";
} else if (MDQConstants.SOAP11JMS_BINDING.equals(ns)) {
return "SOAP 1.1 JMS Binding";
} else if (MDQConstants.SOAP11JMS_MTOM_BINDING.equals(ns)) {
return "SOAP 1.1 MTOM JMS Binding";
} else if (MDQConstants.SOAP12JMS_BINDING.equals(ns)) {
return "SOAP 1.2 JMS Binding";
} else if (MDQConstants.SOAP12JMS_MTOM_BINDING.equals(ns)) {
return "SOAP 1.2 MTOM JMS Binding";
} else if (HTTPBinding.HTTP_BINDING.equals(ns)) {
return "XML HTTP Binding";
} else {
return "Unknown Binding";
}
}
private static String getFeatureForBinding(QName name) {
if (name.equals(new QName("http://www.w3.org/2006/05/addressing/wsdl", "UsingAddressing"))) {
return AddressingFeature.ID;
}
else {
return null;
}
}
}