org.apache.cxf.ws.policy.EndpointPolicyImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cxf-bundle-minimal Show documentation
Show all versions of cxf-bundle-minimal Show documentation
Apache CXF Minimal Bundle Jar
The newest version!
/**
* 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.cxf.ws.policy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ResourceBundle;
import java.util.Set;
import javax.xml.namespace.QName;
import org.apache.cxf.common.i18n.BundleUtils;
import org.apache.cxf.interceptor.Interceptor;
import org.apache.cxf.message.Message;
import org.apache.cxf.service.model.BindingFaultInfo;
import org.apache.cxf.service.model.BindingOperationInfo;
import org.apache.cxf.service.model.EndpointInfo;
import org.apache.neethi.Assertion;
import org.apache.neethi.ExactlyOne;
import org.apache.neethi.Policy;
import org.apache.neethi.PolicyContainingAssertion;
/**
*
*/
public class EndpointPolicyImpl implements EndpointPolicy {
private static final ResourceBundle BUNDLE = BundleUtils.getBundle(EndpointPolicyImpl.class);
private Policy policy;
private Collection chosenAlternative;
private volatile Collection vocabulary;
private Collection faultVocabulary;
private volatile List> interceptors;
private List> faultInterceptors;
private EndpointInfo ei;
private PolicyEngineImpl engine;
private boolean requestor;
private Assertor assertor;
public EndpointPolicyImpl() {
}
public EndpointPolicyImpl(Policy p) {
policy = p;
}
public EndpointPolicyImpl(EndpointInfo ei,
PolicyEngineImpl engine,
boolean requestor,
Assertor assertor) {
this.ei = ei;
this.engine = engine;
this.requestor = requestor;
this.assertor = assertor;
}
public Policy getPolicy() {
return policy;
}
public Assertor getAssertor() {
return assertor;
}
public EndpointPolicy updatePolicy(Policy p) {
EndpointPolicyImpl epi = createEndpointPolicy();
if (!PolicyUtils.isEmptyPolicy(p)) {
Policy normalizedPolicy
= p.normalize(engine == null ? null : engine.getRegistry(), true);
epi.setPolicy(getPolicy().merge(normalizedPolicy));
} else {
Policy clonedPolicy = new Policy();
clonedPolicy.addPolicyComponents(getPolicy().getPolicyComponents());
epi.setPolicy(clonedPolicy);
}
epi.checkExactlyOnes();
epi.finalizeConfig();
return epi;
}
public Collection getChosenAlternative() {
return chosenAlternative;
}
public Collection getVocabulary() {
if (vocabulary == null) {
initializeVocabulary();
}
return vocabulary;
}
public Collection getFaultVocabulary() {
if (vocabulary == null) {
initializeVocabulary();
}
return faultVocabulary;
}
public List> getInterceptors() {
if (interceptors == null) {
initializeInterceptors();
}
return interceptors;
}
public List> getFaultInterceptors() {
if (interceptors == null) {
initializeInterceptors();
}
return faultInterceptors;
}
public void initialize() {
initializePolicy();
checkExactlyOnes();
finalizeConfig();
}
void finalizeConfig() {
chooseAlternative();
}
void initializePolicy() {
if (engine != null) {
policy = engine.getAggregatedServicePolicy(ei.getService());
policy = policy.merge(engine.getAggregatedEndpointPolicy(ei));
if (!policy.isEmpty()) {
policy = policy.normalize(engine.getRegistry(), true);
}
}
}
void chooseAlternative() {
Collection alternative = null;
if (requestor) {
if (engine.isEnabled()) {
alternative = engine.getAlternativeSelector().selectAlternative(policy, engine, assertor, null);
} else {
// use an empty list to avoid getting NPE
alternative = Collections.emptyList();
}
} else {
alternative = getSupportedAlternatives();
}
if (null == alternative) {
throw new PolicyException(new org.apache.cxf.common.i18n.Message("NO_ALTERNATIVE_EXC", BUNDLE));
} else {
setChosenAlternative(alternative);
}
}
protected Collection getSupportedAlternatives() {
Collection alternatives = new ArrayList();
for (Iterator> it = policy.getAlternatives(); it.hasNext();) {
List alternative = it.next();
if (engine.supportsAlternative(alternative, assertor)) {
alternatives.addAll(alternative);
}
}
return alternatives;
}
private void addAll(Collection target, Collection l1) {
for (Assertion l : l1) {
if (!target.contains(l)) {
target.add(l);
}
}
}
synchronized void initializeVocabulary() {
if (vocabulary != null) {
return;
}
List v = new ArrayList();
List fv = null;
if (requestor) {
fv = new ArrayList();
}
// vocabulary of alternative chosen for endpoint
if (getChosenAlternative() != null) {
for (Assertion a : getChosenAlternative()) {
if (a.isOptional()) {
continue;
}
v.add(a);
if (null != fv) {
fv.add(a);
}
}
}
// add assertions for specific inbound (in case of a server endpoint) or outbound
// (in case of a client endpoint) messages
for (BindingOperationInfo boi : ei.getBinding().getOperations()) {
EffectivePolicy p = null;
if (!this.requestor) {
p = engine.getEffectiveServerRequestPolicy(ei, boi);
Collection c = engine.getAssertions(p, false);
if (c != null) {
addAll(v, c);
}
} else {
p = engine.getEffectiveClientResponsePolicy(ei, boi);
Collection c = engine.getAssertions(p, false);
if (c != null) {
addAll(v, c);
if (null != fv) {
addAll(fv, c);
}
}
if (boi.getFaults() != null && null != fv) {
for (BindingFaultInfo bfi : boi.getFaults()) {
p = engine.getEffectiveClientFaultPolicy(ei, boi, bfi);
c = engine.getAssertions(p, false);
if (c != null) {
addAll(fv, c);
}
}
}
}
}
if (requestor) {
faultVocabulary = fv;
}
vocabulary = v;
}
Collection getSupportedAlternatives(Policy p) {
Collection alternatives = new ArrayList();
for (Iterator> it = p.getAlternatives(); it.hasNext();) {
List alternative = it.next();
if (engine.supportsAlternative(alternative, null)) {
alternatives.addAll(alternative);
}
}
return alternatives;
}
void initializeInterceptors(PolicyInterceptorProviderRegistry reg,
Set> out, Assertion a,
boolean fault) {
QName qn = a.getName();
List> i
= fault ? reg.getInFaultInterceptorsForAssertion(qn)
: reg.getInInterceptorsForAssertion(qn);
out.addAll(i);
if (a instanceof PolicyContainingAssertion) {
Policy p = ((PolicyContainingAssertion)a).getPolicy();
if (p != null) {
for (Assertion a2 : getSupportedAlternatives(p)) {
initializeInterceptors(reg, out, a2, fault);
}
}
}
}
synchronized void initializeInterceptors() {
if (interceptors != null) {
return;
}
if (engine == null || engine.getBus() == null
|| engine.getBus().getExtension(PolicyInterceptorProviderRegistry.class) == null) {
return;
}
PolicyInterceptorProviderRegistry reg
= engine.getBus().getExtension(PolicyInterceptorProviderRegistry.class);
Set> out = new LinkedHashSet>();
if (getChosenAlternative() != null) {
for (Assertion a : getChosenAlternative()) {
initializeInterceptors(reg, out, a, false);
}
}
List> tmp = null;
if (requestor) {
tmp = new ArrayList>(out);
out.clear();
for (Assertion a : getChosenAlternative()) {
initializeInterceptors(reg, out, a, true);
}
faultInterceptors = new ArrayList>(out);
} else if (ei != null && ei.getBinding() != null) {
for (BindingOperationInfo boi : ei.getBinding().getOperations()) {
EffectivePolicy p = engine.getEffectiveServerRequestPolicy(ei, boi);
if (p == null || p.getPolicy() == null || p.getPolicy().isEmpty()) {
continue;
}
Collection c = engine.getAssertions(p, true);
if (c != null) {
for (Assertion a : c) {
initializeInterceptors(reg, out, a, false);
initializeInterceptors(reg, out, a, true);
}
}
}
tmp = new ArrayList>(out);
} else {
tmp = new ArrayList>(out);
}
interceptors = tmp;
}
// for test
void setPolicy(Policy ep) {
policy = ep;
}
void setChosenAlternative(Collection c) {
chosenAlternative = c;
}
void setVocabulary(Collection v) {
vocabulary = v;
}
void setFaultVocabulary(Collection v) {
faultVocabulary = v;
}
void setInterceptors(List> in) {
interceptors = in;
}
void setFaultInterceptors(List> inFault) {
faultInterceptors = inFault;
}
protected EndpointPolicyImpl createEndpointPolicy() {
return new EndpointPolicyImpl(this.ei,
this.engine,
this.requestor,
this.assertor);
}
void checkExactlyOnes() {
// Policy has been normalized and merged by now but unfortunately
// ExactlyOnce have not been normalized properly by Neethi, for ex
//
//
// this is what we can see after the normalization happens but in fact this
// is still unnormalized expression, should be
//
//
List assertions = policy.getPolicyComponents();
if (assertions.size() <= 1) {
return;
}
Policy p = new Policy();
ExactlyOne alternatives = new ExactlyOne();
p.addPolicyComponent(alternatives);
for (Object a : assertions) {
alternatives.addPolicyComponents(((ExactlyOne)a).getPolicyComponents());
}
setPolicy(p);
}
}