Java tutorial
/* * Copyright 2001-2011 The Apache Software Foundation. * * Licensed 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.juddi.v3.client.mapping; import java.lang.management.ManagementFactory; import java.net.BindException; import java.net.MalformedURLException; import java.net.URL; import java.rmi.RemoteException; import java.util.ArrayList; import java.util.Map; import java.util.Properties; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import javax.management.MBeanServer; import javax.management.MBeanServerFactory; import javax.management.ObjectName; import javax.wsdl.Definition; import javax.wsdl.WSDLException; import javax.xml.datatype.DatatypeConfigurationException; import javax.xml.datatype.DatatypeFactory; import javax.xml.datatype.Duration; import javax.xml.namespace.QName; import javax.xml.ws.Endpoint; import org.apache.commons.configuration.ConfigurationException; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.juddi.v3.client.config.UDDIClerk; import org.apache.juddi.v3.client.config.UDDIKeyConvention; import org.apache.juddi.v3.client.mapping.wsdl.ReadWSDL; import org.apache.juddi.v3.client.mapping.wsdl.WSDL2UDDI; import org.apache.juddi.v3.client.transport.TransportException; import org.uddi.api_v3.FindQualifiers; import org.uddi.api_v3.FindService; import org.uddi.api_v3.Name; import org.uddi.sub_v3.Subscription; import org.uddi.sub_v3.SubscriptionFilter; import org.uddi.v3_service.UDDISubscriptionListenerPortType; /** * The UDDIServiceCache maintains a cache of the service bindingTemplates of all service * the lookupService method is called for. * * To prevent the cache from going stale it * registers an Subscription with the UDDI server. The subscription matches any update * on any service. When the subscription is matched, the UDDI server will callback to * the UDDIClientSubscriptionListenerService which is a WebService Endpoint brought * up by this cache. * * The Cache also registers an MBean which allows the * * @author <a href="mailto:kstam@apache.org">Kurt T Stam</a> * @see UDDIClientSubscriptionListenerImpl * @see UDDIServiceCacheMBean * @see UDDISubscriptionListenerPortType * @see ServiceLocator */ public class UDDIServiceCache implements UDDIServiceCacheMBean { public static final String UDDI_ORG_NS = "urn:uddi-org:v3_service"; public static final String UDDI_CLIENT_SUBSCRIPTION_LISTENER = "UDDIClientSubscriptionListenerService"; public static final QName SUBSCRIPTION_LISTENER_SERVICE_NAME = new QName(UDDI_ORG_NS, UDDI_CLIENT_SUBSCRIPTION_LISTENER); public static final String SUBSCRIPTION_LISTENER_PORT_NAME = "UDDIClientSubscriptionListenerImplPort"; public static final String DEFAULT_SUBSCRIPTION_LISTENER_URL = "http://localhost:8080/subscriptionlistener_uddi_client"; private Log log = LogFactory.getLog(this.getClass()); private UDDIClerk clerk = null; private URLLocalizer urlLocalizer = null; private Properties properties = null; private String subscriptionKey = null; private Endpoint listenerEndpoint = null; private URL listenerServiceUrl = null; private ObjectName mbeanName = null; private ConcurrentHashMap<String, Topology> serviceLocationMap = new ConcurrentHashMap<String, Topology>(); public UDDIServiceCache() { super(); } public UDDIServiceCache(UDDIClerk clerk) throws MalformedURLException { super(); this.clerk = clerk; this.urlLocalizer = new URLLocalizerDefaultImpl(null); this.properties = clerk.getUDDINode().getProperties(); } public UDDIServiceCache(UDDIClerk clerk, URL callbackBaseUrl) { super(); this.clerk = clerk; this.urlLocalizer = new URLLocalizerDefaultImpl(callbackBaseUrl); this.properties = clerk.getUDDINode().getProperties(); } public UDDIServiceCache(UDDIClerk clerk, URLLocalizer urlLocalizer, Properties properties) throws DatatypeConfigurationException, MalformedURLException, RemoteException, ConfigurationException, WSDLException, TransportException, Exception { super(); this.clerk = clerk; this.urlLocalizer = urlLocalizer; Properties properties2 = clerk.getUDDINode().getProperties(); if (properties2 != null) { properties2.putAll(properties); } else { properties2 = properties; } this.properties = properties2; } public UDDIClerk getClerk() { return clerk; } public void publishAndRegisterHttpCallbackEndpoint() throws BindException { if (clerk != null && listenerEndpoint == null) { try { listenerServiceUrl = new URL(urlLocalizer.rewrite(new URL(DEFAULT_SUBSCRIPTION_LISTENER_URL))); WSDL2UDDI wsdl2UDDI = new WSDL2UDDI(clerk, urlLocalizer, properties); Definition wsdlDefinition = new ReadWSDL() .readWSDL("org/apache/juddi/v3/client/mapping/UDDIClientSubscriptionListener.wsdl"); String bindingKey = wsdl2UDDI .registerBusinessService(SUBSCRIPTION_LISTENER_SERVICE_NAME, SUBSCRIPTION_LISTENER_PORT_NAME, listenerServiceUrl, wsdlDefinition) .getBindingKey(); UDDISubscriptionListenerPortType subscriptionListener = new UDDIClientSubscriptionListenerImpl( bindingKey, this); log.info("Bringing up a UDDIClientSubscriptionListenerImpl on Endpoint " + listenerServiceUrl.toExternalForm()); listenerEndpoint = Endpoint.create(subscriptionListener); listenerEndpoint.publish(listenerServiceUrl.toExternalForm()); log.info("Registering a CallbackSubscription to this endpoint using bindingKey " + bindingKey); registerSubscription(bindingKey); } catch (RuntimeException t) { listenerEndpoint = null; if (t.getCause() instanceof BindException) { throw new BindException(t.getCause().getMessage()); } else { throw t; } } catch (Exception e) { log.error("Cannot publish or register the CallbackEndpoint " + e.getMessage(), e); } } } public boolean hasListener() { if (listenerEndpoint == null) return false; return listenerEndpoint.isPublished(); } public void registerAsMBean() { try { if (clerk != null) { mbeanName = new ObjectName("apache.juddi.client:type=UDDIServerCache-" + clerk.getManagerName() + "-" + clerk.getName()); } else { mbeanName = new ObjectName("apache.juddi.client:type=UDDIServerCache-" + this); } MBeanServer mbeanServer = getMBeanServer(); if (mbeanServer != null) { mbeanServer.registerMBean(this, mbeanName); } else { mbeanServer = null; } } catch (Exception e) { log.error("Not able to register the UDDIServiceCache MBean " + e.getMessage(), e); } } public void shutdown() { if (subscriptionKey != null) { clerk.unRegisterSubscription(subscriptionKey); } if (listenerEndpoint != null) { listenerEndpoint.stop(); WSDL2UDDI wsdl2UDDI; try { wsdl2UDDI = new WSDL2UDDI(clerk, urlLocalizer, properties); wsdl2UDDI.unRegisterBusinessService(SUBSCRIPTION_LISTENER_SERVICE_NAME, SUBSCRIPTION_LISTENER_PORT_NAME, listenerServiceUrl); } catch (Exception e) { /* we did our best*/ log.debug(e.getMessage(), e); } } if (mbeanName != null) { try { MBeanServer mbeanServer = getMBeanServer(); if (mbeanServer != null) { mbeanServer.unregisterMBean(mbeanName); } } catch (Exception e) { /* we did our best*/ log.debug(e.getMessage(), e); } } } public void removeAll() { log.info("Flushing the client side " + clerk.getManagerName() + " UDDIServiceCache "); for (String key : serviceLocationMap.keySet()) { serviceLocationMap.get(key); } } /** * Adds or updates epr information for the given serviceKey. * @param serviceKey * @param topology */ public void addService(String serviceKey, Topology topology) { serviceLocationMap.put(serviceKey, topology); } public Topology lookupService(String serviceKey) { return serviceLocationMap.get(serviceKey); } public void removeService(String serviceKey) { serviceLocationMap.remove(serviceKey); } /** * Create a subscription for changes in any Service in the Registry * @throws DatatypeConfigurationException * @param bindingKey the binding key */ public void registerSubscription(String bindingKey) throws DatatypeConfigurationException { String subscriptionKey = UDDIKeyConvention.getSubscriptionKey(properties); //Create a subscription for changes in any Service in the Registry FindService findAllServices = new FindService(); FindQualifiers qualifiers = new FindQualifiers(); qualifiers.getFindQualifier().add("approximateMatch"); findAllServices.setFindQualifiers(qualifiers); Name name = new Name(); name.setValue("%"); findAllServices.getName().add(name); SubscriptionFilter filter = new SubscriptionFilter(); filter.setFindService(findAllServices); Subscription subscription = new Subscription(); subscription.setSubscriptionFilter(filter); subscription.setBindingKey(bindingKey); subscription.setBrief(true); Duration oneMinute = DatatypeFactory.newInstance().newDuration("PT1M"); subscription.setNotificationInterval(oneMinute); subscription.setSubscriptionKey(subscriptionKey); clerk.register(subscription); this.subscriptionKey = subscriptionKey; } public Map<String, Topology> getServiceCacheMap() { return serviceLocationMap; } private MBeanServer getMBeanServer() { MBeanServer mbserver = null; ArrayList<MBeanServer> mbservers = MBeanServerFactory.findMBeanServer(null); if (mbservers.size() > 0) { mbserver = (MBeanServer) mbservers.get(0); } if (mbserver != null && log.isDebugEnabled()) { log.debug("Found MBean server"); } else { mbserver = ManagementFactory.getPlatformMBeanServer(); } return mbserver; } /** Method callable from the mbean */ @Override public int getServiceCacheSize() { return serviceLocationMap.size(); } /** Method callable from the mbean */ @Override public Set<String> getCacheEntries() { return serviceLocationMap.keySet(); } /** Method callable from the mbean */ @Override public void resetCache() { serviceLocationMap.clear(); } }