001: /**
002: * Licensed to the Apache Software Foundation (ASF) under one
003: * or more contributor license agreements. See the NOTICE file
004: * distributed with this work for additional information
005: * regarding copyright ownership. The ASF licenses this file
006: * to you under the Apache License, Version 2.0 (the
007: * "License"); you may not use this file except in compliance
008: * with the License. You may obtain a copy of the License at
009: *
010: * http://www.apache.org/licenses/LICENSE-2.0
011: *
012: * Unless required by applicable law or agreed to in writing,
013: * software distributed under the License is distributed on an
014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015: * KIND, either express or implied. See the License for the
016: * specific language governing permissions and limitations
017: * under the License.
018: */package org.apache.cxf.endpoint;
019:
020: import java.util.ArrayList;
021: import java.util.List;
022:
023: import javax.annotation.PostConstruct;
024: import javax.xml.namespace.QName;
025:
026: import org.apache.cxf.Bus;
027: import org.apache.cxf.ws.addressing.EndpointReferenceType;
028:
029: /**
030: * This implementation class is responsible for mediating
031: * access to registered EndpointResolvers, which themselves map
032: * between abstract and concrete endpoint references, and/or
033: * facilitate renewal of stale references.
034: * <p>
035: * An underlying mechanism in the style of the OGSA WS-Naming
036: * specification is assumed, where an EPR maybe be fully abstract,
037: * or concrete but with sufficient information embedded to enable
038: * its renewal if necessary.
039: */
040: public class EndpointResolverRegistryImpl implements
041: EndpointResolverRegistry {
042:
043: private Bus bus;
044: private List<EndpointResolver> resolvers;
045:
046: /**
047: * Initialize registry, and expose as Bus extension.
048: */
049: @PostConstruct
050: public void init() {
051: resolvers = new ArrayList<EndpointResolver>();
052: if (bus != null) {
053: bus.setExtension(this , EndpointResolverRegistry.class);
054: }
055: }
056:
057: /**
058: * Register an endpoint resolver.
059: *
060: * @param resolver the EndpointResolver to add to the chain.
061: */
062: public synchronized void register(EndpointResolver resolver) {
063: resolvers.add(resolver);
064: }
065:
066: /**
067: * Unregister an endpoint resolver.
068: *
069: * @param resolver the EndpointResolver to remove from the chain.
070: */
071: public synchronized void unregister(EndpointResolver resolver) {
072: resolvers.remove(resolver);
073: }
074:
075: /**
076: * Walk the list of registered EndpointResolvers, so as to
077: * retrieve a concrete EPR corresponding to the given abstract EPR,
078: * returning a cached reference if already resolved.
079: * <p>
080: * This API is used by any actor that requires a concrete EPR (e.g.
081: * a transport-level Conduit), and must be called each and every
082: * time the EPR content is to be accessed (e.g. before each connection
083: * establishment attempt).
084: *
085: * @param logical the abstract EPR to resolve
086: * @return the resolved concrete EPR if appropriate, null otherwise
087: */
088: public synchronized EndpointReferenceType resolve(
089: EndpointReferenceType logical) {
090: EndpointReferenceType physical = null;
091: for (EndpointResolver resolver : resolvers) {
092: physical = resolver.resolve(logical);
093: if (physical != null) {
094: break;
095: }
096: }
097: return physical;
098: }
099:
100: /**
101: * Walk the list of registered EndpointResolvers, so as to force a fresh
102: * resolution of the given abstract EPR, discarding any previously cached
103: * reference.
104: * <p>
105: * This API may be used by say the transport-level Conduit when it
106: * detects a non-transient error on the outgoing connection, or
107: * by any other actor in the dispatch with the ability to infer
108: * server-side unavailability.
109: *
110: * @param logical the previously resolved abstract EPR
111: * @param physical the concrete EPR to refresh
112: * @return the renewed concrete EPR if appropriate, null otherwise
113: */
114: public EndpointReferenceType renew(EndpointReferenceType logical,
115: EndpointReferenceType physical) {
116: EndpointReferenceType fresh = null;
117: for (EndpointResolver resolver : resolvers) {
118: fresh = resolver.renew(logical, physical);
119: if (fresh != null) {
120: break;
121: }
122: }
123: return fresh;
124: }
125:
126: /**
127: * Walk the list of registered EndpointResolvers, so as to mint a new
128: * abstract EPR for a given service name.
129: *
130: * @param serviceName
131: * @return the newly minted EPR if appropriate, null otherwise
132: */
133: public EndpointReferenceType mint(QName serviceName) {
134: EndpointReferenceType logical = null;
135: for (EndpointResolver resolver : resolvers) {
136: logical = resolver.mint(serviceName);
137: if (logical != null) {
138: break;
139: }
140: }
141: return logical;
142: }
143:
144: /**
145: * Walk the list of registered EndpointResolvers, so as to mint a new
146: * abstract EPR for a gievn physical EPR.
147: *
148: * @param serviceName
149: * @return the newly minted EPR if appropriate, null otherwise
150: */
151: public EndpointReferenceType mint(EndpointReferenceType physical) {
152: EndpointReferenceType logical = null;
153: for (EndpointResolver resolver : resolvers) {
154: logical = resolver.mint(physical);
155: if (logical != null) {
156: break;
157: }
158: }
159: return logical;
160: }
161:
162: /**
163: * @return the encapsulated list of registered resolvers
164: */
165: protected List<EndpointResolver> getResolvers() {
166: return resolvers;
167: }
168:
169: /**
170: * @param b Bus to encapsulate
171: */
172: public void setBus(Bus b) {
173: bus = b;
174: }
175: }
|