This project has retired. For details please refer to its Attic page.
JAXWSTransport.java

JAXWSTransport.java

  1. /*
  2.  * Copyright 2001-2009 The Apache Software Foundation.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *      http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  *
  16.  */
  17. package org.apache.juddi.v3.client.transport;

  18. import java.util.Map;
  19. import java.util.Properties;

  20. import javax.xml.ws.BindingProvider;

  21. import org.apache.commons.configuration.ConfigurationException;
  22. import org.apache.commons.logging.Log;
  23. import org.apache.commons.logging.LogFactory;
  24. import org.apache.juddi.v3.client.JUDDIApiService;
  25. import org.apache.juddi.v3.client.UDDIService;
  26. import org.apache.juddi.v3.client.config.Property;
  27. import org.apache.juddi.v3.client.config.UDDIClient;
  28. import org.apache.juddi.v3.client.config.UDDIClientContainer;
  29. import org.apache.juddi.v3.client.cryptor.CryptorFactory;
  30. import org.apache.juddi.v3_service.JUDDIApiPortType;
  31. import org.uddi.v3_service.UDDICustodyTransferPortType;
  32. import org.uddi.v3_service.UDDIInquiryPortType;
  33. import org.uddi.v3_service.UDDIPublicationPortType;
  34. import org.uddi.v3_service.UDDISecurityPortType;
  35. import org.uddi.v3_service.UDDISubscriptionListenerPortType;
  36. import org.uddi.v3_service.UDDISubscriptionPortType;

  37. public class JAXWSTransport extends Transport {

  38.         private static Log logger = LogFactory.getLog(JAXWSTransport.class);

  39.         String nodeName = null;
  40.         String clientName = null;
  41.         UDDIInquiryPortType inquiryService = null;
  42.         UDDISecurityPortType securityService = null;
  43.         UDDIPublicationPortType publishService = null;
  44.         UDDISubscriptionPortType subscriptionService = null;
  45.         UDDISubscriptionListenerPortType subscriptionListenerService = null;
  46.         UDDICustodyTransferPortType custodyTransferService = null;
  47.         JUDDIApiPortType publisherService = null;

  48.         public JAXWSTransport() {
  49.                 super();
  50.                 this.nodeName = Transport.DEFAULT_NODE_NAME;
  51.         }

  52.         public JAXWSTransport(String nodeName) {
  53.                 super();
  54.                 this.nodeName = nodeName;
  55.         }

  56.         public JAXWSTransport(String clientName, String nodeName) {
  57.                 super();
  58.                 this.clientName = clientName;
  59.                 this.nodeName = nodeName;
  60.         }

  61.         public UDDIInquiryPortType getUDDIInquiryService(String endpointURL) throws TransportException {
  62.                 try {
  63.                         if (inquiryService == null) {
  64.                                 if (endpointURL == null) {
  65.                                         UDDIClient client = UDDIClientContainer.getUDDIClient(clientName);
  66.                                         endpointURL = client.getClientConfig().getUDDINode(nodeName).getInquiryUrl();
  67.                                 }
  68.                                 UDDIService service = new UDDIService();
  69.                                 inquiryService = service.getUDDIInquiryPort();
  70.                         }
  71.                         Map<String, Object> requestContext = ((BindingProvider) inquiryService).getRequestContext();
  72.                         if (endpointURL != null) {
  73.                        
  74.                                 requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointURL);
  75.                         }
  76.                         setCredentials(requestContext);
  77.                 } catch (Exception e) {
  78.                         throw new TransportException(e.getMessage(), e);
  79.                 }
  80.                 return inquiryService;
  81.         }

  82.         public UDDISecurityPortType getUDDISecurityService(String endpointURL) throws TransportException {
  83.                 try {
  84.                         if (securityService == null) {
  85.                                 if (endpointURL == null) {
  86.                                         UDDIClient client = UDDIClientContainer.getUDDIClient(clientName);
  87.                                         endpointURL = client.getClientConfig().getUDDINode(nodeName).getSecurityUrl();
  88.                                 }
  89.                                 UDDIService service = new UDDIService();
  90.                                 securityService = service.getUDDISecurityPort();
  91.                         }
  92.                         if (endpointURL != null) {
  93.                                 if (endpointURL.toLowerCase().startsWith("http:")){
  94.                                         logger.warn("You should consider using a secure protocol (https) when sending your password!");
  95.                                 }
  96.                                 Map<String, Object> requestContext = ((BindingProvider) securityService).getRequestContext();
  97.                                 requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointURL);
  98.                                 setCredentials(requestContext);
  99.                         }
  100.                 } catch (Exception e) {
  101.                         throw new TransportException(e.getMessage(), e);
  102.                 }
  103.                 return securityService;
  104.         }

  105.         public UDDIPublicationPortType getUDDIPublishService(String endpointURL) throws TransportException {
  106.                 try {
  107.                         if (publishService == null) {

  108.                                 if (endpointURL == null) {
  109.                                         UDDIClient client = UDDIClientContainer.getUDDIClient(clientName);
  110.                                         endpointURL = client.getClientConfig().getUDDINode(nodeName).getPublishUrl();
  111.                                 }
  112.                                 UDDIService service = new UDDIService();
  113.                                 publishService = service.getUDDIPublicationPort();
  114.                         }
  115.                         Map<String, Object> requestContext = ((BindingProvider) publishService).getRequestContext();
  116.                         if (endpointURL != null)
  117.                                 requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointURL);
  118.                         setCredentials(requestContext);
  119.                 } catch (Exception e) {
  120.                         throw new TransportException(e.getMessage(), e);
  121.                 }
  122.                 return publishService;
  123.         }

  124.         public UDDISubscriptionPortType getUDDISubscriptionService(String endpointURL) throws TransportException {
  125.                 try {
  126.                         if (subscriptionService == null) {
  127.                                 if (endpointURL == null) {
  128.                                         UDDIClient client = UDDIClientContainer.getUDDIClient(clientName);
  129.                                         endpointURL = client.getClientConfig().getUDDINode(nodeName).getSubscriptionUrl();
  130.                                 }
  131.                                 UDDIService service = new UDDIService();
  132.                                 subscriptionService = service.getUDDISubscriptionPort();
  133.                         }
  134.                         if (endpointURL != null) {
  135.                                 Map<String, Object> requestContext = ((BindingProvider) subscriptionService).getRequestContext();
  136.                                 requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointURL);
  137.                                 setCredentials(requestContext);
  138.                         }
  139.                 } catch (Exception e) {
  140.                         throw new TransportException(e.getMessage(), e);
  141.                 }
  142.                 return subscriptionService;
  143.         }

  144.         public UDDISubscriptionListenerPortType getUDDISubscriptionListenerService(String endpointURL) throws TransportException {
  145.                 try {
  146.                         if (subscriptionListenerService == null) {
  147.                                 if (endpointURL == null) {
  148.                                         UDDIClient client = UDDIClientContainer.getUDDIClient(clientName);
  149.                                         endpointURL = client.getClientConfig().getUDDINode(nodeName).getSubscriptionListenerUrl();
  150.                                 }
  151.                                 UDDIService service = new UDDIService();
  152.                                 subscriptionListenerService = service.getUDDISubscriptionListenerPort();
  153.                         }
  154.                         if (endpointURL != null) {
  155.                                 Map<String, Object> requestContext = ((BindingProvider) subscriptionListenerService).getRequestContext();
  156.                                 requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointURL);
  157.                                 setCredentials(requestContext);
  158.                         }
  159.                 } catch (Exception e) {
  160.                         throw new TransportException(e.getMessage(), e);
  161.                 }
  162.                 return subscriptionListenerService;
  163.         }

  164.         public UDDICustodyTransferPortType getUDDICustodyTransferService(String endpointURL) throws TransportException {
  165.                 try {
  166.                         if (custodyTransferService == null) {
  167.                                 if (endpointURL == null) {
  168.                                         UDDIClient client = UDDIClientContainer.getUDDIClient(clientName);
  169.                                         endpointURL = client.getClientConfig().getUDDINode(nodeName).getCustodyTransferUrl();
  170.                                 }
  171.                                 UDDIService service = new UDDIService();
  172.                                 custodyTransferService = service.getUDDICustodyPort();
  173.                         }
  174.                         if (endpointURL != null) {
  175.                                 Map<String, Object> requestContext = ((BindingProvider) custodyTransferService).getRequestContext();
  176.                                 requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointURL);
  177.                                 setCredentials(requestContext);
  178.                         }
  179.                 } catch (Exception e) {
  180.                         throw new TransportException(e.getMessage(), e);
  181.                 }
  182.                 return custodyTransferService;
  183.         }

  184.         /**
  185.          * This is a jUDDI specific API
  186.          */
  187.         public JUDDIApiPortType getJUDDIApiService(String endpointURL) throws TransportException {
  188.                 try {
  189.                         if (publisherService == null) {
  190.                                 if (endpointURL == null) {
  191.                                         UDDIClient client = UDDIClientContainer.getUDDIClient(clientName);
  192.                                         endpointURL = client.getClientConfig().getUDDINode(nodeName).getJuddiApiUrl();
  193.                                 }
  194.                                 JUDDIApiService service = new JUDDIApiService();
  195.                                 publisherService = (JUDDIApiPortType) service.getPort(JUDDIApiPortType.class);
  196.                         }
  197.                         if (endpointURL != null) {
  198.                                 Map<String, Object> requestContext = ((BindingProvider) publisherService).getRequestContext();
  199.                                 requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointURL);
  200.                                 setCredentials(requestContext);
  201.                         }
  202.                 } catch (Exception e) {
  203.                         throw new TransportException(e.getMessage(), e);
  204.                 }
  205.                 return publisherService;
  206.         }

  207.         public String getNodeName() {
  208.                 return nodeName;
  209.         }

  210.         public void setNodeName(String nodeName) {
  211.                 this.nodeName = nodeName;
  212.         }

  213.         /**
  214.          * Sets the credentials on the RequestContext if the services are
  215.          * protected by Basic Authentication. The username and password are
  216.          * obtained from the uddi.xml.
  217.          *
  218.          * @param requestContext
  219.          * @throws ConfigurationException
  220.          */
  221.         private void setCredentials(Map<String, Object> requestContext) throws ConfigurationException {
  222.                 UDDIClient client = UDDIClientContainer.getUDDIClient(clientName);
  223.                 Properties properties = client.getClientConfig().getUDDINode(nodeName).getProperties();
  224.                 if (properties != null) {
  225.                         String username = null;
  226.                         String password = null;
  227.                         if (properties.containsKey(Property.BASIC_AUTH_USERNAME)) {
  228.                                 username = properties.getProperty(Property.BASIC_AUTH_USERNAME);
  229.                         }
  230.                         if (properties.containsKey(Property.BASIC_AUTH_PASSWORD)) {
  231.                                 password = properties.getProperty(Property.BASIC_AUTH_PASSWORD);
  232.                         }
  233.                         String cipher = null;
  234.                         boolean isEncrypted = false;
  235.                         if (properties.containsKey(Property.BASIC_AUTH_PASSWORD_CP)) {
  236.                                 cipher = properties.getProperty(Property.BASIC_AUTH_PASSWORD_CP);
  237.                         }
  238.                         if (properties.containsKey(Property.BASIC_AUTH_PASSWORD_IS_ENC)) {
  239.                                 isEncrypted = Boolean.parseBoolean(properties.getProperty(Property.BASIC_AUTH_PASSWORD_IS_ENC));
  240.                         }
  241.                         if (username != null && password != null) {
  242.                                 requestContext.put(BindingProvider.USERNAME_PROPERTY, username);
  243.                                 if (isEncrypted) {
  244.                                         try {
  245.                                                 requestContext.put(BindingProvider.PASSWORD_PROPERTY, CryptorFactory.getCryptor(cipher).decrypt(password));
  246.                                         } catch (Exception ex) {
  247.                                                 logger.error("Unable to decrypt password!", ex);
  248.                                         }
  249.                                 } else {
  250.                                         requestContext.put(BindingProvider.PASSWORD_PROPERTY, password);
  251.                                 }
  252.                         }
  253.                 }
  254.         }

  255. }