| package org.apache.juddi.adminconsole.hub; |
| |
| /* |
| * Copyright 2001-2013 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. |
| * |
| */ |
| import java.io.InputStream; |
| import java.io.StringReader; |
| import java.io.StringWriter; |
| import java.math.BigInteger; |
| import java.net.URL; |
| import java.rmi.RemoteException; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| import javax.persistence.EntityManager; |
| import javax.persistence.EntityTransaction; |
| import javax.persistence.Query; |
| import javax.servlet.ServletContext; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpSession; |
| import javax.xml.XMLConstants; |
| import javax.xml.bind.JAXB; |
| import javax.xml.datatype.DatatypeConfigurationException; |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.transform.OutputKeys; |
| import javax.xml.transform.Transformer; |
| import javax.xml.transform.TransformerFactory; |
| import javax.xml.transform.dom.DOMSource; |
| import javax.xml.transform.stream.StreamResult; |
| import javax.xml.transform.stream.StreamSource; |
| import javax.xml.ws.BindingProvider; |
| import javax.xml.ws.Holder; |
| import org.apache.commons.configuration.Configuration; |
| import org.apache.commons.configuration.ConfigurationException; |
| import org.apache.commons.lang.StringEscapeUtils; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| import org.apache.juddi.api_v3.Clerk; |
| import org.apache.juddi.api_v3.ClientSubscriptionInfoDetail; |
| import org.apache.juddi.api_v3.DeleteClientSubscriptionInfo; |
| import org.apache.juddi.api_v3.DeletePublisher; |
| import org.apache.juddi.api_v3.GetAllPublisherDetail; |
| import org.apache.juddi.api_v3.GetPublisherDetail; |
| import org.apache.juddi.api_v3.Node; |
| import org.apache.juddi.api_v3.Publisher; |
| import org.apache.juddi.api_v3.PublisherDetail; |
| import org.apache.juddi.api_v3.SaveClerk; |
| import org.apache.juddi.api_v3.SaveClientSubscriptionInfo; |
| import org.apache.juddi.api_v3.SaveNode; |
| import org.apache.juddi.api_v3.SavePublisher; |
| import org.apache.juddi.api_v3.SyncSubscription; |
| import org.apache.juddi.api_v3.SyncSubscriptionDetail; |
| import org.apache.juddi.v3.client.UDDIConstants; |
| import org.apache.juddi.v3.client.config.ClientConfig; |
| import org.apache.juddi.v3.client.config.UDDIClient; |
| import org.apache.juddi.v3.client.config.UDDINode; |
| import org.apache.juddi.v3.client.transport.Transport; |
| import org.apache.juddi.v3_service.JUDDIApiPortType; |
| import org.apache.juddi.adminconsole.AES; |
| import org.apache.juddi.adminconsole.resources.ResourceLoader; |
| import org.apache.juddi.api.impl.JUDDIApiImpl; |
| import org.apache.juddi.api.impl.UDDIInquiryImpl; |
| import org.apache.juddi.api.impl.UDDIPublicationImpl; |
| import org.apache.juddi.api.impl.UDDIReplicationImpl; |
| import org.apache.juddi.api_v3.AdminSaveBusiness; |
| import org.apache.juddi.api_v3.AdminSaveSubscriptionRequest; |
| import org.apache.juddi.api_v3.AdminSaveSubscriptionResponse; |
| import org.apache.juddi.api_v3.AdminSaveTModel; |
| import org.apache.juddi.api_v3.ClerkList; |
| import org.apache.juddi.api_v3.ClientSubscriptionInfo; |
| import org.apache.juddi.api_v3.DeleteClerk; |
| import org.apache.juddi.api_v3.DeleteNode; |
| import org.apache.juddi.api_v3.GetEntityHistoryMessageRequest; |
| import org.apache.juddi.api_v3.GetEntityHistoryMessageResponse; |
| import org.apache.juddi.api_v3.GetFailedReplicationChangeRecordsMessageRequest; |
| import org.apache.juddi.api_v3.GetFailedReplicationChangeRecordsMessageResponse; |
| import org.apache.juddi.api_v3.NodeList; |
| import org.apache.juddi.api_v3.SubscriptionWrapper; |
| import org.apache.juddi.config.AppConfig; |
| import org.apache.juddi.config.PersistenceManager; |
| import org.apache.juddi.config.Property; |
| import org.apache.juddi.model.BindingTemplate; |
| import org.apache.juddi.subscription.notify.SMTPNotifier; |
| import org.apache.juddi.v3.client.cryptor.XmlUtils; |
| import org.uddi.api_v3.AuthToken; |
| import org.uddi.api_v3.BusinessDetail; |
| import org.uddi.api_v3.BusinessEntity; |
| import org.uddi.api_v3.BusinessService; |
| import org.uddi.api_v3.DeleteBusiness; |
| import org.uddi.api_v3.DeleteTModel; |
| import org.uddi.api_v3.DiscardAuthToken; |
| import org.uddi.api_v3.DispositionReport; |
| import org.uddi.api_v3.FindBusiness; |
| import org.uddi.api_v3.FindQualifiers; |
| import org.uddi.api_v3.GetAuthToken; |
| import org.uddi.api_v3.GetBusinessDetail; |
| import org.uddi.api_v3.Name; |
| import org.uddi.api_v3.SaveBusiness; |
| import org.uddi.repl_v3.ChangeRecordIDType; |
| import org.uddi.repl_v3.ChangeRecords; |
| import org.uddi.repl_v3.GetChangeRecords; |
| import org.uddi.repl_v3.HighWaterMarkVectorType; |
| import org.uddi.repl_v3.ReplicationConfiguration; |
| import org.uddi.sub_v3.Subscription; |
| import org.uddi.sub_v3.SubscriptionResultsList; |
| import org.uddi.subr_v3.NotifySubscriptionListener; |
| |
| import org.uddi.v3_service.DispositionReportFaultMessage; |
| import org.uddi.v3_service.UDDISecurityPortType; |
| import org.w3c.dom.Document; |
| import org.xml.sax.InputSource; |
| |
| /** |
| * UddiHub - The hub acts as a single point for managing browser to uddi |
| * services. At most 1 instance is allowed per http session. In general, all |
| * methods in the class trigger web service call outs. All callouts also support |
| * expired UDDI tokens and will attempt to reauthenticate and retry the request. |
| * |
| * @author <a href="mailto:alexoree@apache.org">Alex O'Ree</a> |
| */ |
| public class UddiAdminHub { |
| |
| /** |
| * The logger name |
| */ |
| public static final String LOGGER_NAME = "org.apache.juddi"; |
| transient AuthStyle style = null; |
| Properties properties = null; |
| /** |
| * The Log4j logger. This is also referenced from the Builders class, |
| * thus it is public |
| */ |
| public static final Log log = LogFactory.getLog(LOGGER_NAME); |
| |
| private UddiAdminHub() throws DatatypeConfigurationException { |
| // df = DatatypeFactory.newInstance(); |
| } |
| |
| /** |
| * removes the Hub from the current http session |
| * |
| * @param _session |
| */ |
| public static void reset(HttpSession _session) { |
| _session.removeAttribute("hub"); |
| // token = null; |
| } |
| |
| /** |
| * This kills any authentication tokens, logs the user out and nulls out |
| * all services |
| */ |
| public void die() { |
| if (token != null && security != null) { |
| DiscardAuthToken da = new DiscardAuthToken(); |
| da.setAuthInfo(token); |
| try { |
| security.discardAuthToken(da); |
| } catch (Exception ex) { |
| HandleException(ex); |
| } |
| } |
| token = null; |
| security = null; |
| juddi = null; |
| } |
| /** |
| * the name of the 'node' property in the config |
| */ |
| public static final String PROP_CONFIG_NODE = "config.props.node"; |
| /** |
| * |
| */ |
| public static final String PROP_AUTH_TYPE = "config.props.authtype"; |
| /** |
| * |
| */ |
| public static final String PROP_AUTO_LOGOUT = "config.props.automaticLogouts.enable"; |
| /** |
| * |
| */ |
| public static final String PROP_AUTO_LOGOUT_TIMER = "config.props.automaticLogouts.duration"; |
| /** |
| * |
| */ |
| public static final String PROP_PREFIX = "config.props."; |
| /** |
| * |
| * |
| */ |
| public static final String PROP_ADMIN_LOCALHOST_ONLY = "config.props.configLocalHostOnly"; |
| |
| private transient UDDISecurityPortType security = null; |
| private transient JUDDIApiPortType juddi = null; |
| private transient String token = null; |
| private transient HttpSession session; |
| private transient Transport transport = null; |
| private transient ClientConfig clientConfig; |
| private static final long serialVersionUID = 1L; |
| private String nodename = "default"; |
| private final String clientName = "juddigui"; |
| private boolean WS_Transport = false; |
| private boolean WS_securePorts = false; |
| |
| /** |
| * This is the singleton accessor UddiHub. There should be at most 1 |
| * instance per HTTP Session (user login) |
| * |
| * @param application |
| * @param _session |
| * @return instance |
| * @throws Exception |
| */ |
| public static UddiAdminHub getInstance(ServletContext application, HttpSession _session) throws Exception { |
| Object j = _session.getAttribute("hub"); |
| if (j == null) { |
| UddiAdminHub hub = new UddiAdminHub(application, _session); |
| _session.setAttribute("hub", hub); |
| return hub; |
| } |
| |
| return (UddiAdminHub) j; |
| } |
| String locale = "en"; |
| |
| private UddiAdminHub(ServletContext application, HttpSession _session) throws Exception { |
| URL prop = application.getResource("/WEB-INF/config.properties"); |
| if (prop == null) { |
| application.getResource("WEB-INF/config.properties"); |
| } |
| if (prop == null) { |
| throw new Exception("Cannot locate the configuration file."); |
| } |
| session = _session; |
| |
| InputStream in = prop.openStream(); |
| Properties p = new Properties(); |
| p.load(in); |
| in.close(); |
| session = _session; |
| properties = p; |
| EnsureConfig(); |
| } |
| |
| private void EnsureConfig() { |
| if (clientConfig == null) { |
| try { |
| UDDIClient client = new UDDIClient(); |
| |
| clientConfig = client.getClientConfig(); |
| try { |
| style = AuthStyle.valueOf(clientConfig.getConfiguration().getString(PROP_AUTH_TYPE)); |
| } catch (Exception ex) { |
| log.warn("'UDDI_AUTH' is not defined in the config (" + PROP_AUTH_TYPE + ")! defaulting to UDDI_AUTH"); |
| style = AuthStyle.UDDI_AUTH; |
| } |
| |
| nodename = clientConfig.getConfiguration().getString(PROP_CONFIG_NODE); |
| if (nodename == null || nodename.equals("")) { |
| log.warn("'node' is not defined in the config! defaulting to 'default'"); |
| nodename = "default"; |
| } |
| UDDINode uddiNode = clientConfig.getUDDINode(nodename); |
| |
| String clazz = uddiNode.getProxyTransport(); |
| if (clazz.contains("JAXWSTransport")) { |
| WS_Transport = true; |
| } |
| |
| transport = client.getTransport(nodename); |
| security = transport.getUDDISecurityService(); |
| juddi = transport.getJUDDIApiService(); |
| if (WS_Transport) { |
| if (uddiNode.getJuddiApiUrl().toLowerCase().startsWith("https://") |
| && (uddiNode.getSecurityUrl() != null && uddiNode.getSecurityUrl().toLowerCase().startsWith("https://"))) { |
| WS_securePorts = true; |
| } |
| } |
| |
| } catch (Exception ex) { |
| HandleException(ex); |
| } |
| } |
| |
| } |
| |
| /** |
| * This function provides a basic error handling rutine that will pull |
| * out the true error message in a UDDI fault message, returning |
| * bootstrap stylized html error message |
| * |
| * @param ex |
| * @return |
| */ |
| private String HandleException(Exception ex) { |
| if (ex instanceof DispositionReportFaultMessage) { |
| DispositionReportFaultMessage f = (DispositionReportFaultMessage) ex; |
| log.error(ex.getMessage() + (f.detail != null && f.detail.getMessage() != null ? StringEscapeUtils.escapeHtml(f.detail.getMessage()) : "")); |
| log.debug(ex.getMessage(), ex); |
| return ResourceLoader.GetResource(session, "errors.generic") + " " + StringEscapeUtils.escapeHtml(ex.getMessage()) + " " + (f.detail != null && f.detail.getMessage() != null ? StringEscapeUtils.escapeHtml(f.detail.getMessage()) : ""); |
| } else if (ex instanceof RemoteException) { |
| RemoteException f = (RemoteException) ex; |
| log.error("RemoteException " + ex.getMessage()); |
| log.debug("RemoteException " + ex.getMessage(), ex); |
| return ResourceLoader.GetResource(session, "errors.generic") + " " + StringEscapeUtils.escapeHtml(ex.getMessage()) + " " + (f.detail != null && f.detail.getMessage() != null ? StringEscapeUtils.escapeHtml(f.detail.getMessage()) : ""); |
| } else if (ex instanceof NullPointerException) { |
| log.error("NPE! Please report! " + ex.getMessage(), ex); |
| log.debug("NPE! Please report! " + ex.getMessage(), ex); |
| return ResourceLoader.GetResource(session, "errors.generic") + " " + StringEscapeUtils.escapeHtml(ex.getMessage()); |
| } else { |
| log.error("Unexpected error " + ex.getMessage(), ex); |
| //log.debug(ex.getMessage(), ex); |
| return ResourceLoader.GetResource(session, "errors.generic") + " " + StringEscapeUtils.escapeHtml(ex.getMessage()); |
| } |
| } |
| |
| /** |
| * returns true if we are using JAXWS transport AND all of the URLs |
| * start with https:// |
| * |
| * @return true/false |
| */ |
| public boolean isSecure() { |
| |
| EnsureConfig(); |
| return WS_securePorts; |
| } |
| |
| /** |
| * gets a reference to the current juddi client config file. this is a |
| * live instance changes can be stored to disk, usually |
| * |
| * @return client config |
| * @throws ConfigurationException g |
| */ |
| public ClientConfig GetJuddiClientConfig() throws ConfigurationException { |
| EnsureConfig(); |
| return clientConfig; |
| } |
| |
| /** |
| * Handles all API calls to the juddi web service |
| * |
| * @param parameters |
| * @return html formatted status message |
| */ |
| public String go(HttpServletRequest parameters) { |
| try { |
| String action = parameters.getParameter("soapaction"); |
| if (action.equalsIgnoreCase("adminDelete_tmodel")) { |
| return adminDelete_tmodel(parameters); |
| } else if (action.equalsIgnoreCase("delete_ClientSubscriptionInfo")) { |
| return delete_ClientSubscriptionInfo(parameters); |
| } else if (action.equalsIgnoreCase("delete_publisher")) { |
| return delete_publisher(parameters); |
| } else if (action.equalsIgnoreCase("getAllPublisherDetail")) { |
| return getAllPublisherDetail(parameters); |
| } else if (action.equalsIgnoreCase("get_publisherDetail")) { |
| return get_publisherDetail(parameters); |
| } else if (action.equalsIgnoreCase("invoke_SyncSubscription")) { |
| return invoke_SyncSubscription(parameters); |
| } else if (action.equalsIgnoreCase("save_Clerk")) { |
| return save_Clerk(parameters); |
| } else if (action.equalsIgnoreCase("save_ClientSubscriptionInfo")) { |
| return save_ClientSubscriptionInfo(parameters); |
| } else if (action.equalsIgnoreCase("save_Node")) { |
| return save_Node(parameters); |
| } else if (action.equalsIgnoreCase("save_publisher")) { |
| return save_publisher(parameters); |
| } else if (action.equalsIgnoreCase("send_EmailTest")) { |
| return sendTestEmail(parameters); |
| } else if (action.equalsIgnoreCase("get_AllNodes")) { |
| return getAllNodes(parameters); |
| } else if (action.equalsIgnoreCase("get_AllClerks")) { |
| return getAllClerks(parameters); |
| } else if (action.equalsIgnoreCase("delete_Node")) { |
| return deleteNode(parameters); |
| } else if (action.equalsIgnoreCase("delete_Clerk")) { |
| return deleteClerk(parameters); |
| } else if (action.equalsIgnoreCase("admin_DeleteSubscription")) { |
| return deleteSubscription(parameters); |
| } else if (action.equalsIgnoreCase("admin_SaveBusiness")) { |
| return adminSaveBusiness(parameters); |
| } else if (action.equalsIgnoreCase("admin_SaveTModel")) { |
| return adminSaveTmodel(parameters); |
| } else if (action.equalsIgnoreCase("get_AllClientSubscriptionInfo")) { |
| return getAllClientSubscriptionInfo(parameters); |
| } else if (action.equalsIgnoreCase("set_ReplicationNodes")) { |
| return setReplicationConfig(parameters); |
| } else if (action.equalsIgnoreCase("get_ReplicationNodes")) { |
| return getReplicationNodes(parameters); |
| } else if (action.equalsIgnoreCase("admin_SaveSubscription")) { |
| return adminSaveSubscription(parameters); |
| } else if (action.equalsIgnoreCase("get_EntityHistory")) { |
| return getEntityHistory(parameters); |
| } else if (action.equalsIgnoreCase("change_NodeID")) { |
| return change_NodeID(parameters); |
| } else if (action.equalsIgnoreCase("changeRecord")) { |
| return getChangeRecord(parameters); |
| } else if (action.equalsIgnoreCase("getFailedReplicationChangeRecords")) { |
| return getFailedReplicationChangeRecords(parameters); |
| } |
| |
| } catch (Exception ex) { |
| return "Error!" + HandleException(ex); |
| } |
| return "not yet implemented!"; |
| } |
| |
| private String save_Clerk(HttpServletRequest parameters) { |
| SaveClerk sc = new SaveClerk(); |
| sc.setAuthInfo(GetToken()); |
| Clerk c = new Clerk(); |
| c.setName(parameters.getParameter("CLERKsetName")); |
| Node node = new Node(); |
| node.setClientName(parameters.getParameter("CLERKNODEsetClientName")); |
| node.setCustodyTransferUrl(parameters.getParameter("CLERKNODEsetCustodyTransferUrl")); |
| node.setDescription(parameters.getParameter("CLERKNODEsetDescription")); |
| node.setFactoryInitial(parameters.getParameter("CLERKNODEsetFactoryInitial")); |
| node.setFactoryNamingProvider(parameters.getParameter("CLERKNODEsetFactoryNamingProvider")); |
| node.setFactoryURLPkgs(parameters.getParameter("CLERKNODEsetFactoryURLPkgs")); |
| node.setInquiryUrl(parameters.getParameter("CLERKNODEsetInquiryUrl")); |
| node.setJuddiApiUrl(parameters.getParameter("CLERKNODEsetJuddiApiUrl")); |
| node.setName(parameters.getParameter("CLERKNODEsetName")); |
| node.setProxyTransport(parameters.getParameter("CLERKNODEsetProxyTransport")); |
| node.setPublishUrl(parameters.getParameter("CLERKNODEsetPublishUrl")); |
| node.setReplicationUrl(parameters.getParameter("CLERKNODEsetReplicationUrl")); |
| node.setSecurityUrl(parameters.getParameter("CLERKNODEsetSecurityUrl")); |
| node.setSubscriptionListenerUrl(parameters.getParameter("CLERKNODEsetSubscriptionListenerUrl")); |
| node.setSubscriptionUrl(parameters.getParameter("CLERKNODEsetSubscriptionUrl")); |
| c.setNode(node); |
| c.setPassword(parameters.getParameter("CLERKsetPassword")); |
| c.setPublisher(parameters.getParameter("CLERKsetPublisher")); |
| |
| sc.getClerk().add(c); |
| try { |
| juddi.saveClerk(sc); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| sc.setAuthInfo(GetToken()); |
| try { |
| juddi.saveClerk(sc); |
| } catch (Exception ex1) { |
| return "Error!" + HandleException(ex1); |
| } |
| |
| } else { |
| return "Error!" + HandleException(ex); |
| } |
| } |
| return "Success"; |
| } |
| |
| private String save_Node(HttpServletRequest parameters) { |
| SaveNode sn = new SaveNode(); |
| sn.setAuthInfo(GetToken()); |
| Node node = new Node(); |
| node.setClientName(parameters.getParameter("NODEsetClientName")); |
| node.setCustodyTransferUrl(parameters.getParameter("NODEsetCustodyTransferUrl")); |
| node.setDescription(parameters.getParameter("NODEsetDescription")); |
| node.setFactoryInitial(parameters.getParameter("NODEsetFactoryInitial")); |
| node.setFactoryNamingProvider(parameters.getParameter("NODEsetFactoryNamingProvider")); |
| node.setFactoryURLPkgs(parameters.getParameter("NODEsetFactoryURLPkgs")); |
| node.setInquiryUrl(parameters.getParameter("NODEsetInquiryUrl")); |
| node.setJuddiApiUrl(parameters.getParameter("NODEsetJuddiApiUrl")); |
| node.setName(parameters.getParameter("NODEsetName")); |
| node.setProxyTransport(parameters.getParameter("NODEsetProxyTransport")); |
| node.setPublishUrl(parameters.getParameter("NODEsetPublishUrl")); |
| node.setReplicationUrl(parameters.getParameter("NODEsetReplicationUrl")); |
| node.setSecurityUrl(parameters.getParameter("NODEsetSecurityUrl")); |
| node.setSubscriptionListenerUrl(parameters.getParameter("NODEsetSubscriptionListenerUrl")); |
| node.setSubscriptionUrl(parameters.getParameter("NODEsetSubscriptionUrl")); |
| sn.getNode().add(node); |
| |
| try { |
| juddi.saveNode(sn); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| sn.setAuthInfo(GetToken()); |
| try { |
| juddi.saveNode(sn); |
| } catch (Exception ex1) { |
| return "Error!" + HandleException(ex1); |
| } |
| |
| } else { |
| return "Error!" + HandleException(ex); |
| } |
| } |
| return "Success"; |
| } |
| |
| private String sendTestEmail(HttpServletRequest parameters) { |
| try { |
| |
| String to = parameters.getParameter("send_EmailTestEMAIL"); |
| if (!to.startsWith("mailto:")) { |
| to = "mailto:" + to; |
| } |
| BindingTemplate modellbt = new BindingTemplate("test", null, "endpoint", to, null, null, null, null, null); |
| org.apache.juddi.subscription.notify.SMTPNotifier smtp = new SMTPNotifier(modellbt); |
| NotifySubscriptionListener body = new NotifySubscriptionListener(); |
| |
| body.setSubscriptionResultsList(new SubscriptionResultsList()); |
| body.getSubscriptionResultsList().setSubscription(new Subscription()); |
| body.getSubscriptionResultsList().getSubscription().setSubscriptionKey("TEST"); |
| smtp.notifySubscriptionListener(body); |
| return "Success"; |
| } catch (Exception ex) { |
| return "Failure!" + HandleException(ex); |
| } |
| } |
| |
| private String getAllNodes(HttpServletRequest parameters) { |
| NodeList allNodes = null; |
| try { |
| |
| allNodes = juddi.getAllNodes(GetToken()); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| try { |
| allNodes = juddi.getAllNodes(GetToken()); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| try { |
| return PrettyPrintJaxbObject(allNodes); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| |
| } |
| |
| private String getAllClerks(HttpServletRequest parameters) { |
| ClerkList allNodes = null; |
| try { |
| |
| allNodes = juddi.getAllClerks(GetToken()); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| try { |
| allNodes = juddi.getAllClerks(GetToken()); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| try { |
| return PrettyPrintJaxbObject(allNodes); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| |
| private String getAllClientSubscriptionInfo(HttpServletRequest parameters) { |
| List<SubscriptionWrapper> allClientSubscriptionInfo = null; |
| try { |
| |
| allClientSubscriptionInfo = juddi.getAllClientSubscriptionInfo(GetToken()); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| try { |
| allClientSubscriptionInfo = juddi.getAllClientSubscriptionInfo(GetToken()); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| try { |
| return PrettyPrintJaxbObject(allClientSubscriptionInfo); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| |
| private String getReplicationNodes(HttpServletRequest parameters) { |
| ReplicationConfiguration cfg = null; |
| try { |
| |
| cfg = juddi.getReplicationNodes(GetToken()); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| try { |
| cfg = juddi.getReplicationNodes(GetToken()); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| try { |
| return PrettyPrintJaxbObject(cfg); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| |
| private String deleteNode(HttpServletRequest parameters) { |
| DeleteNode cfg = new DeleteNode(); |
| cfg.setAuthInfo(GetToken()); |
| cfg.setNodeID(parameters.getParameter("delete_NodeName")); |
| try { |
| |
| juddi.deleteNode(cfg); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| try { |
| cfg.setAuthInfo(GetToken()); |
| juddi.deleteNode(cfg); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| |
| return "Success"; |
| } |
| |
| private String deleteSubscription(HttpServletRequest parameters) { |
| List<String> keys = new ArrayList<String>(); |
| keys.add(parameters.getParameter("admin_DeleteSubscriptionKey")); |
| try { |
| |
| juddi.adminDeleteSubscription(GetToken(), keys); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| try { |
| juddi.adminDeleteSubscription(GetToken(), keys); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| |
| return "Success"; |
| } |
| |
| private String deleteClerk(HttpServletRequest parameters) { |
| DeleteClerk cfg = new DeleteClerk(); |
| cfg.setAuthInfo(GetToken()); |
| cfg.setClerkID(parameters.getParameter("delete_ClerkName")); |
| try { |
| |
| juddi.deleteClerk(cfg); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| try { |
| cfg.setAuthInfo(GetToken()); |
| juddi.deleteClerk(cfg); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| |
| return "Success"; |
| } |
| |
| private String setReplicationConfig(HttpServletRequest parameters) { |
| ReplicationConfiguration cfg = (ReplicationConfiguration) JUDDIRequestsAsXML.getObjectJuddi("set_ReplicationNodes", parameters.getParameter("set_ReplicationNodesXML")); |
| DispositionReport setReplicationNodes = null; |
| try { |
| |
| setReplicationNodes = juddi.setReplicationNodes(GetToken(), cfg); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| try { |
| setReplicationNodes = juddi.setReplicationNodes(GetToken(), cfg); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| try { |
| return PrettyPrintJaxbObject(setReplicationNodes); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| |
| private String adminSaveBusiness(HttpServletRequest parameters) { |
| //admin_SaveBusiness |
| AdminSaveBusiness cfg = (AdminSaveBusiness) JUDDIRequestsAsXML.getObjectJuddi("admin_SaveBusiness", parameters.getParameter("admin_SaveBusinessXML")); |
| DispositionReport setReplicationNodes = null; |
| try { |
| |
| setReplicationNodes = juddi.adminSaveBusiness(GetToken(), cfg.getValues()); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| try { |
| setReplicationNodes = juddi.adminSaveBusiness(GetToken(), cfg.getValues()); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| try { |
| return PrettyPrintJaxbObject(setReplicationNodes); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| |
| private String adminSaveTmodel(HttpServletRequest parameters) { |
| //admin_SaveTModel |
| AdminSaveTModel cfg = (AdminSaveTModel) JUDDIRequestsAsXML.getObjectJuddi("admin_SaveTModel", parameters.getParameter("admin_SaveTModelXML")); |
| //JAXB.marshal(cfg, System.out); |
| DispositionReport setReplicationNodes = null; |
| try { |
| |
| setReplicationNodes = juddi.adminSaveTModel(GetToken(), cfg.getValues()); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| try { |
| setReplicationNodes = juddi.adminSaveTModel(GetToken(), cfg.getValues()); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| try { |
| return PrettyPrintJaxbObject(setReplicationNodes); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| |
| private String adminSaveSubscription(HttpServletRequest parameters) { |
| // |
| AdminSaveSubscriptionRequest cfg = (AdminSaveSubscriptionRequest) JUDDIRequestsAsXML.getObjectJuddi("admin_SaveSubscription", parameters.getParameter("admin_SaveSubscriptionXML")); |
| |
| Holder<List<Subscription>> holder = new Holder<List<Subscription>>(cfg.getSubscriptions()); |
| try { |
| |
| juddi.adminSaveSubscription(GetToken(), cfg.getPublisherOrUsername(), holder); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| try { |
| juddi.adminSaveSubscription(GetToken(), cfg.getPublisherOrUsername(), holder); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| AdminSaveSubscriptionResponse res = new AdminSaveSubscriptionResponse(); |
| res.getSubscriptions().addAll(holder.value); |
| try { |
| return PrettyPrintJaxbObject(res); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| |
| private String getEntityHistory(HttpServletRequest parameters) { |
| GetEntityHistoryMessageRequest sn = new GetEntityHistoryMessageRequest(); |
| sn.setAuthInfo(GetToken()); |
| sn.setEntityKey(parameters.getParameter("get_EntityHistoryKey")); |
| GetEntityHistoryMessageResponse entityHistory = null; |
| try { |
| sn.setMaxRecords(Long.parseLong(parameters.getParameter("get_EntityHistoryMaxCount"))); |
| sn.setOffset(Long.parseLong(parameters.getParameter("get_EntityHistoryOffset"))); |
| entityHistory = juddi.getEntityHistory(sn); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| sn.setAuthInfo(GetToken()); |
| try { |
| entityHistory = juddi.getEntityHistory(sn); |
| } catch (Exception ex1) { |
| return "Error!" + HandleException(ex1); |
| } |
| |
| } else { |
| return "Error!" + HandleException(ex); |
| } |
| } |
| if (entityHistory == null) { |
| return "Something went wrong!"; |
| } |
| try { |
| return PrettyPrintJaxbObject(entityHistory); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| |
| } |
| |
| private String change_NodeID(HttpServletRequest parameters) { |
| //check replication config |
| |
| EntityManager em = PersistenceManager.getEntityManager(); |
| EntityTransaction tx = em.getTransaction(); |
| |
| try { |
| |
| ReplicationConfiguration replicationNodes = new JUDDIApiImpl().getReplicationNodes(GetToken()); |
| if (replicationNodes.getOperator().size() > 1) { |
| throw new Exception("Replication is configured with " + replicationNodes.getOperator() + " nodes. Node rename aborted"); |
| } |
| Configuration configuration = AppConfig.getConfiguration(); |
| //this is going to break a few design rules. |
| String currentnode = configuration.getString(Property.JUDDI_NODE_ID); |
| String newnode = parameters.getParameter("change_NodeIDKey"); |
| if (newnode == null) { |
| throw new Exception("The new node id was not specified"); |
| } |
| newnode = newnode.trim(); |
| newnode = newnode.toLowerCase(); |
| log.warn("AUDIT - Renaming Node ID from " + currentnode + " to " + newnode); |
| |
| UDDIPublicationImpl pub = new UDDIPublicationImpl(); |
| UDDIInquiryImpl inquire = new UDDIInquiryImpl(); |
| |
| GetBusinessDetail gbd = new GetBusinessDetail(); |
| gbd.setAuthInfo(GetToken()); |
| gbd.getBusinessKey().add(newnode); |
| BusinessDetail businessDetail = null; |
| try { |
| businessDetail = inquire.getBusinessDetail(gbd); |
| } catch (Exception ex) { |
| //business doesn't exist |
| } |
| if (businessDetail == null || businessDetail.getBusinessEntity().isEmpty()) { |
| //copy the existing Root Node and rekey it with the new key |
| //incase the destination key generator is valid, we'll abort. |
| gbd.getBusinessKey().clear(); |
| gbd.getBusinessKey().add(AppConfig.getConfiguration().getString(Property.JUDDI_NODE_ROOT_BUSINESS)); |
| businessDetail = inquire.getBusinessDetail(gbd); |
| BusinessEntity get = businessDetail.getBusinessEntity().get(0); |
| get.setBusinessKey(newnode); |
| get.getSignature().clear(); |
| if (get.getBusinessServices() != null) { |
| for (BusinessService bs : get.getBusinessServices().getBusinessService()) { |
| bs.setBusinessKey(newnode); |
| bs.getSignature().clear(); |
| //we also need to rekey all of the services and bindings wait do we? |
| //bs.setServiceKey(bs.getServiceKey()); |
| } |
| } |
| SaveBusiness sb = new SaveBusiness(); |
| sb.setAuthInfo(GetToken()); |
| sb.getBusinessEntity().add(get); |
| //if there's something wrong with the new key, this will throw |
| BusinessDetail saveBusiness = pub.saveBusiness(sb); |
| newnode = saveBusiness.getBusinessEntity().get(0).getBusinessKey(); |
| } |
| |
| tx.begin(); |
| //rekey all entities with the new node id |
| Query createQuery = em.createQuery("Update UddiEntity ue set ue.nodeId=:node where ue.nodeId=:oldnode"); |
| createQuery.setParameter("node", newnode); |
| createQuery.setParameter("oldnode", currentnode); |
| int records = createQuery.executeUpdate(); |
| //rekey all the existing change records with the new node id |
| createQuery = em.createQuery("Update ChangeRecord ue set ue.nodeID=:node where ue.nodeID=:oldnode"); |
| createQuery.setParameter("node", newnode); |
| createQuery.setParameter("oldnode", currentnode); |
| records += createQuery.executeUpdate(); |
| |
| //rekey is_replaced_by references? nah |
| tx.commit(); |
| try { |
| DeleteBusiness db = new DeleteBusiness(); |
| db.setAuthInfo(GetToken()); |
| db.getBusinessKey().add(currentnode); |
| pub.deleteBusiness(db); |
| } catch (Exception ex) { |
| log.warn("Node id change error: ", ex); |
| } |
| |
| //finally update the xml config and resave it |
| AppConfig.setJuddiProperty(Property.JUDDI_NODE_ID, newnode); |
| AppConfig.setJuddiProperty(Property.JUDDI_NODE_ROOT_BUSINESS, newnode); |
| |
| return "Sucess, Records update: " + records + " current node id is now " + AppConfig.getConfiguration().getString(Property.JUDDI_NODE_ID); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } finally { |
| if (tx.isActive()) { |
| tx.rollback(); |
| } |
| em.close(); |
| } |
| } |
| |
| private String getChangeRecord(HttpServletRequest parameters) { |
| try { |
| GetChangeRecords req = new GetChangeRecords(); |
| |
| req.setRequestingNode(AppConfig.getConfiguration().getString(Property.JUDDI_NODE_ID)); |
| |
| req.setResponseLimitCount(BigInteger.ONE); |
| req.setChangesAlreadySeen(new HighWaterMarkVectorType()); |
| req.getChangesAlreadySeen().getHighWaterMark().add( |
| new ChangeRecordIDType(parameters.getParameter("nodeid"), |
| Long.parseLong(parameters.getParameter("recordid")))); |
| ChangeRecords changeRecords = new UDDIReplicationImpl().getChangeRecords(req); |
| return PrettyPrintJaxbObject(changeRecords); |
| |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| |
| /** |
| * returns html/xml escaped, pretty printed pre formated xml string |
| * |
| * @param jaxb |
| * @return |
| * @throws Exception |
| */ |
| private String PrettyPrintJaxbObject(Object jaxb) throws Exception { |
| DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); |
| dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true); |
| DocumentBuilder db = dbf.newDocumentBuilder(); |
| StringWriter sw = new StringWriter(); |
| JAXB.marshal(jaxb, sw); |
| InputSource is = new InputSource(new StringReader(sw.toString())); |
| |
| TransformerFactory transFactory = TransformerFactory.newInstance(); |
| transFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, ""); |
| transFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, ""); |
| Transformer transformer = transFactory.newTransformer(); |
| transformer.setOutputProperty(OutputKeys.INDENT, "yes"); |
| //initialize StreamResult with File object to save to file |
| StreamResult result = new StreamResult(new StringWriter()); |
| Document document = db.parse(is); |
| DOMSource source = new DOMSource(document); |
| transformer.transform(source, result); |
| String xmlString = result.getWriter().toString(); |
| |
| return "<pre>" + StringEscapeUtils.escapeXml(xmlString) + "</pre>"; |
| } |
| |
| private String getFailedReplicationChangeRecords(HttpServletRequest parameters) { |
| try { |
| |
| GetFailedReplicationChangeRecordsMessageRequest req = new GetFailedReplicationChangeRecordsMessageRequest(); |
| req.setAuthInfo(GetToken()); |
| req.setMaxRecords(Integer.parseInt(parameters.getParameter("getFailedReplicationChangeRecordsMaxCount"))); |
| req.setOffset(0); |
| req.setOffset(Integer.parseInt(parameters.getParameter("getFailedReplicationChangeRecordsOffset"))); |
| GetFailedReplicationChangeRecordsMessageResponse failedReplicationChangeRecords = null; |
| try { |
| failedReplicationChangeRecords = juddi.getFailedReplicationChangeRecords(req); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| req.setAuthInfo(GetToken()); |
| try { |
| failedReplicationChangeRecords = juddi.getFailedReplicationChangeRecords(req); |
| } catch (Exception ex1) { |
| return "Error!" + HandleException(ex1); |
| } |
| |
| } else { |
| return "Error!" + HandleException(ex); |
| } |
| } |
| |
| return PrettyPrintJaxbObject(failedReplicationChangeRecords); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| |
| public enum AuthStyle { |
| |
| /** |
| * Http |
| */ |
| HTTP, |
| /** |
| * UDDI Authentication via the Security API |
| */ |
| UDDI_AUTH |
| } |
| |
| private String GetToken() { |
| EnsureConfig(); |
| if (style != AuthStyle.UDDI_AUTH) { |
| BindingProvider bp = null; |
| if (WS_Transport) { |
| Map<String, Object> context = null; |
| bp = (BindingProvider) juddi; |
| context = bp.getRequestContext(); |
| context.put(BindingProvider.USERNAME_PROPERTY, session.getAttribute("username")); |
| context.put(BindingProvider.USERNAME_PROPERTY, session.getAttribute(AES.Decrypt("password", (String) properties.get("key")))); |
| } |
| return null; |
| } else { |
| if (token != null) { |
| return token; |
| } |
| GetAuthToken req = new GetAuthToken(); |
| if (session.getAttribute("username") != null |
| && session.getAttribute("password") != null) { |
| req.setUserID((String) session.getAttribute("username")); |
| req.setCred(AES.Decrypt((String) session.getAttribute("password"), (String) properties.get("key"))); |
| try { |
| AuthToken authToken = security.getAuthToken(req); |
| token = authToken.getAuthInfo(); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| } |
| return token; |
| } |
| |
| private String delete_publisher(HttpServletRequest parameters) { |
| DeletePublisher sb = new DeletePublisher(); |
| sb.setAuthInfo(GetToken()); |
| sb.getPublisherId().add(parameters.getParameter("delete_publisherKEY")); |
| try { |
| juddi.deletePublisher(sb); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| sb.setAuthInfo(GetToken()); |
| try { |
| juddi.deletePublisher(sb); |
| } catch (Exception e) { |
| return HandleException(e); |
| } |
| |
| } else { |
| return HandleException(ex); |
| } |
| } |
| return "Success"; |
| } |
| |
| private String getAllPublisherDetail(HttpServletRequest parameters) { |
| StringBuilder ret = new StringBuilder(); |
| GetAllPublisherDetail sb = new GetAllPublisherDetail(); |
| sb.setAuthInfo(GetToken()); |
| PublisherDetail d = null; |
| try { |
| d = juddi.getAllPublisherDetail(sb); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| sb.setAuthInfo(GetToken()); |
| try { |
| d = juddi.getAllPublisherDetail(sb); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| |
| } else { |
| return HandleException(ex); |
| } |
| } |
| if (d != null) { |
| ret.append("<table class=\"table table-hover\"><tr><th>Name</th><th>Info</th></tr>"); |
| for (int i = 0; i < d.getPublisher().size(); i++) { |
| ret.append("<tr><td>").append(StringEscapeUtils.escapeHtml(d.getPublisher().get(i).getPublisherName())) |
| .append("</td><td>"); |
| ret.append(PrintPublisherDetail(d.getPublisher().get(i))) |
| .append("</td></tr>"); |
| } |
| ret.append("</table>"); |
| } else { |
| ret.append("No data returned"); |
| } |
| return ret.toString(); |
| } |
| |
| private String PrintPublisherDetail(Publisher p) { |
| StringBuilder ret = new StringBuilder(); |
| |
| ret.append("Authorized Name = ").append(StringEscapeUtils.escapeHtml(p.getAuthorizedName())) |
| .append("<br>") |
| .append("Publisher Name = ").append(StringEscapeUtils.escapeHtml(p.getPublisherName())) |
| .append("<br>") |
| .append("Email = ") |
| .append(StringEscapeUtils.escapeHtml(p.getEmailAddress())) |
| .append("<br>") |
| .append("Administrator = ") |
| .append((p.isIsAdmin())) |
| .append("<br>") |
| .append("Enabled = ") |
| .append((p.isIsEnabled())) |
| .append("<br>") |
| .append("Max Bindings per = ") |
| .append(p.getMaxBindingsPerService()) |
| .append("<br>") |
| .append("Max Businesses = ") |
| .append(p.getMaxBusinesses()) |
| .append("<br>") |
| .append("Max Services per = ") |
| .append(p.getMaxServicePerBusiness()) |
| .append("<br>") |
| .append("Max tModels = ") |
| .append(p.getMaxTModels()) |
| .append(""); |
| return ret.toString(); |
| } |
| |
| private String get_publisherDetail(HttpServletRequest parameters) { |
| StringBuilder ret = new StringBuilder(); |
| GetPublisherDetail sb = new GetPublisherDetail(); |
| sb.getPublisherId().add(parameters.getParameter("get_publisherDetailKEY")); |
| sb.setAuthInfo(GetToken()); |
| PublisherDetail d = null; |
| try { |
| d = juddi.getPublisherDetail(sb); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| sb.setAuthInfo(GetToken()); |
| try { |
| d = juddi.getPublisherDetail(sb); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| |
| } else { |
| return HandleException(ex); |
| } |
| } |
| if (d != null) { |
| ret.append("<table class=\"table table-hover\"><tr><th>Name</th><th>Info</th></tr>"); |
| for (int i = 0; i < d.getPublisher().size(); i++) { |
| ret.append("<tr><td>").append(StringEscapeUtils.escapeHtml(d.getPublisher().get(i).getPublisherName())) |
| .append("</td><td>"); |
| ret.append(PrintPublisherDetail(d.getPublisher().get(i))) |
| .append("</td></tr>"); |
| } |
| ret.append("</table>"); |
| } else { |
| ret.append("No data returned"); |
| } |
| return ret.toString(); |
| } |
| |
| private String invoke_SyncSubscription(HttpServletRequest parameters) { |
| StringBuilder ret = new StringBuilder(); |
| SyncSubscription sb = new SyncSubscription(); |
| |
| SyncSubscriptionDetail d = null; |
| try { |
| StringReader sr = new StringReader(parameters.getParameter("invoke_SyncSubscriptionXML").trim()); |
| sb = (SyncSubscription) (XmlUtils.unmarshal(sr, SyncSubscription.class)); |
| sb.setAuthInfo(GetToken()); |
| d = juddi.invokeSyncSubscription(sb); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| sb.setAuthInfo(GetToken()); |
| try { |
| d = juddi.invokeSyncSubscription(sb); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| |
| } else { |
| return HandleException(ex); |
| } |
| } |
| if (d != null) { |
| try { |
| ret.append(PrettyPrintJaxbObject(d)); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| |
| } else { |
| ret.append("No data returned"); |
| } |
| return ret.toString(); |
| } |
| |
| private static String PrettyPrintXML(String input) { |
| try { |
| TransformerFactory transFactory = TransformerFactory.newInstance(); |
| transFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, ""); |
| transFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, ""); |
| Transformer transformer = transFactory.newTransformer(); |
| transformer.setOutputProperty(OutputKeys.INDENT, "yes"); |
| //initialize StreamResult with File object to save to file |
| StreamResult result = new StreamResult(new StringWriter()); |
| StreamSource source = new StreamSource(new StringReader(input)); |
| transformer.transform(source, result); |
| String xmlString = result.getWriter().toString(); |
| return (xmlString); |
| } catch (Exception ex) { |
| } |
| return null; |
| } |
| |
| public String getSampleSave_ClientSubscriptionInfo() { |
| SaveClientSubscriptionInfo x = new SaveClientSubscriptionInfo(); |
| x.setAuthInfo(""); |
| x.getClientSubscriptionInfo().add(new ClientSubscriptionInfo()); |
| x.getClientSubscriptionInfo().get(0).setFromClerk(new Clerk()); |
| x.getClientSubscriptionInfo().get(0).setToClerk(new Clerk()); |
| x.getClientSubscriptionInfo().get(0).setSubscriptionKey("subscription key"); |
| x.getClientSubscriptionInfo().get(0).setLastModified(null); |
| x.getClientSubscriptionInfo().get(0).setLastNotified(null); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().setName("ClerkName"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().setPublisher("username"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().setPassword("password"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().setNode(new Node()); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().getNode().setClientName("clientname"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().getNode().setName("nodename"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().getNode().setDescription("description"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().getNode().setInquiryUrl("http://localhost:8080/juddiv3/services/inquiry"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().getNode().setPublishUrl("http://localhost:8080/juddiv3/services/publish"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().getNode().setCustodyTransferUrl("http://localhost:8080/juddiv3/services/custody-transfer"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().getNode().setSubscriptionUrl("http://localhost:8080/juddiv3/services/subscription"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().getNode().setSubscriptionListenerUrl("http://localhost:8080/juddiv3/services/subscription-listener"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().getNode().setJuddiApiUrl("http://localhost:8080/juddiv3/services/juddi-api"); |
| x.getClientSubscriptionInfo().get(0).getFromClerk().getNode().setReplicationUrl("http://localhost:8080/juddiv3/services/replication"); |
| |
| x.getClientSubscriptionInfo().get(0).getToClerk().setName("ClerkName"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().setPublisher("username"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().setPassword("password"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().setNode(new Node()); |
| x.getClientSubscriptionInfo().get(0).getToClerk().getNode().setClientName("clientname"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().getNode().setName("nodename"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().getNode().setDescription("description"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().getNode().setInquiryUrl("http://localhost:8080/juddiv3/services/inquiry"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().getNode().setPublishUrl("http://localhost:8080/juddiv3/services/publish"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().getNode().setCustodyTransferUrl("http://localhost:8080/juddiv3/services/custody-transfer"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().getNode().setSubscriptionUrl("http://localhost:8080/juddiv3/services/subscription"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().getNode().setSubscriptionListenerUrl("http://localhost:8080/juddiv3/services/subscription-listener"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().getNode().setJuddiApiUrl("http://localhost:8080/juddiv3/services/juddi-api"); |
| x.getClientSubscriptionInfo().get(0).getToClerk().getNode().setReplicationUrl("http://localhost:8080/juddiv3/services/replication"); |
| StringWriter sw = new StringWriter(); |
| JAXB.marshal(x, sw); |
| return sw.toString(); |
| } |
| |
| private String save_ClientSubscriptionInfo(HttpServletRequest parameters) { |
| StringBuilder ret = new StringBuilder(); |
| SaveClientSubscriptionInfo sb = new SaveClientSubscriptionInfo(); |
| |
| if (parameters.getParameter("ClientSubscriptionInfoDetailXML") == null) { |
| return "No input!"; |
| } |
| ClientSubscriptionInfoDetail d = null; |
| try { |
| StringReader sr = new StringReader(parameters.getParameter("ClientSubscriptionInfoDetailXML").trim()); |
| sb = (JAXB.unmarshal(sr, SaveClientSubscriptionInfo.class)); |
| sb.setAuthInfo(GetToken()); |
| d = juddi.saveClientSubscriptionInfo(sb); |
| } catch (Exception ex) { |
| if (ex instanceof DispositionReportFaultMessage) { |
| DispositionReportFaultMessage f = (DispositionReportFaultMessage) ex; |
| if (f.getFaultInfo().countainsErrorCode(DispositionReport.E_AUTH_TOKEN_EXPIRED)) { |
| token = null; |
| sb.setAuthInfo(GetToken()); |
| try { |
| d = juddi.saveClientSubscriptionInfo(sb); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| if (d != null) { |
| try { |
| ret.append(PrettyPrintJaxbObject(d)); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| |
| } else { |
| ret.append("No data returned"); |
| } |
| return ret.toString(); |
| } |
| |
| /** |
| * return true if the word expire is in the exception or the UDDI error |
| * code representing an expired token |
| * |
| * @param ex |
| * @return r |
| */ |
| public static boolean isExceptionExpiration(Exception ex) { |
| if (ex == null) { |
| return false; |
| } |
| if (ex instanceof DispositionReportFaultMessage) { |
| DispositionReportFaultMessage f = (DispositionReportFaultMessage) ex; |
| if (f.getFaultInfo().countainsErrorCode(DispositionReport.E_AUTH_TOKEN_EXPIRED) || ex.getMessage().contains(DispositionReport.E_AUTH_TOKEN_EXPIRED) || ex.getMessage().toLowerCase().contains("expired")) { |
| return true; |
| } |
| } |
| |
| if (ex.getMessage() == null) { |
| return false; |
| } |
| if (ex.getMessage().toLowerCase().contains("expire")) { |
| return true; |
| } |
| |
| if (ex.getMessage().toLowerCase().contains(DispositionReport.E_AUTH_TOKEN_EXPIRED.toLowerCase())) { |
| return true; |
| } |
| if (ex.getLocalizedMessage() == null) { |
| return false; |
| } |
| if (ex.getLocalizedMessage().toLowerCase().contains("expire")) { |
| return true; |
| } |
| return false; |
| } |
| |
| private String save_publisher(HttpServletRequest parameters) { |
| |
| SavePublisher sb = new SavePublisher(); |
| Publisher p = new Publisher(); |
| p.setAuthorizedName(parameters.getParameter("savePublisherAuthorizedName")); |
| p.setPublisherName(parameters.getParameter("savePublisherNAME")); |
| p.setEmailAddress(parameters.getParameter("savePublisherEMAIL")); |
| try { |
| p.setIsAdmin(Boolean.parseBoolean(parameters.getParameter("savePublisherIsAdmin"))); |
| } catch (Exception ex) { |
| } |
| try { |
| p.setIsEnabled(Boolean.parseBoolean(parameters.getParameter("savePublisherIsEnabled"))); |
| } catch (Exception ex) { |
| } |
| |
| PublisherDetail d = null; |
| sb.setAuthInfo(GetToken()); |
| try { |
| if (parameters.getParameter("savePublisherMaxBindings") != null) { |
| p.setMaxBindingsPerService(Integer.parseInt(parameters.getParameter("savePublisherMaxBindings"))); |
| } |
| } catch (Exception ex) { |
| } |
| try { |
| if (parameters.getParameter("savePublisherMaxServices") != null) { |
| p.setMaxServicePerBusiness(Integer.parseInt(parameters.getParameter("savePublisherMaxServices"))); |
| } |
| } catch (Exception ex) { |
| } |
| try { |
| if (parameters.getParameter("savePublisherMaxBusiness") != null) { |
| p.setMaxBusinesses(Integer.parseInt(parameters.getParameter("savePublisherMaxBusiness"))); |
| } |
| } catch (Exception ex) { |
| } |
| try { |
| if (parameters.getParameter("savePublisherMaxTModels") != null) { |
| p.setMaxTModels(Integer.parseInt(parameters.getParameter("savePublisherMaxTModels"))); |
| } |
| } catch (Exception ex) { |
| } |
| sb.getPublisher().add(p); |
| try { |
| |
| d = juddi.savePublisher(sb); |
| } catch (Exception ex) { |
| |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| sb.setAuthInfo(GetToken()); |
| try { |
| d = juddi.savePublisher(sb); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| return "Success"; |
| } |
| |
| private String adminDelete_tmodel(HttpServletRequest parameters) { |
| DeleteTModel sb = new DeleteTModel(); |
| sb.getTModelKey().add(parameters.getParameter("adminDelete_tmodelKEY")); |
| sb.setAuthInfo(GetToken()); |
| try { |
| juddi.adminDeleteTModel(sb); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| sb.setAuthInfo(GetToken()); |
| try { |
| juddi.adminDeleteTModel(sb); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| } else { |
| return HandleException(ex); |
| } |
| } |
| return "Success"; |
| } |
| |
| private String delete_ClientSubscriptionInfo(HttpServletRequest parameters) { |
| DeleteClientSubscriptionInfo sb = new DeleteClientSubscriptionInfo(); |
| sb.getSubscriptionKey().add(parameters.getParameter("delete_ClientSubscriptionInfoKEY")); |
| sb.setAuthInfo(GetToken()); |
| try { |
| juddi.deleteClientSubscriptionInfo(sb); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| sb.setAuthInfo(GetToken()); |
| try { |
| juddi.deleteClientSubscriptionInfo(sb); |
| } catch (Exception ex1) { |
| return HandleException(ex1); |
| } |
| |
| } else { |
| return HandleException(ex); |
| } |
| } |
| return "Success"; |
| } |
| |
| /** |
| * If false, the configuration page will be available from anywhere. If |
| * true, it will only be accessible from the server hosting juddi-gui. |
| * if not defined, the result is true. |
| * |
| * @return true/false |
| */ |
| public boolean isAdminLocalhostOnly() { |
| return clientConfig.getConfiguration().getBoolean(PROP_ADMIN_LOCALHOST_ONLY, true); |
| } |
| |
| public String verifyLogin() { |
| EnsureConfig(); |
| if (style != AuthStyle.UDDI_AUTH) { |
| if (WS_Transport) { |
| BindingProvider bp = null; |
| Map<String, Object> context = null; |
| |
| bp = (BindingProvider) juddi; |
| context = bp.getRequestContext(); |
| context.put(BindingProvider.USERNAME_PROPERTY, session.getAttribute("username")); |
| context.put(BindingProvider.USERNAME_PROPERTY, session.getAttribute(AES.Decrypt("password", (String) properties.get("key")))); |
| } |
| FindBusiness fb = new FindBusiness(); |
| fb.setListHead(0); |
| fb.setMaxRows(1); |
| fb.setFindQualifiers(new FindQualifiers()); |
| fb.getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH); |
| fb.getName().add(new Name(UDDIConstants.WILDCARD, null)); |
| try { |
| GetPublisherDetail publisherDetail = new GetPublisherDetail(); |
| publisherDetail.getPublisherId().add((String) session.getAttribute("username")); |
| juddi.getPublisherDetail(publisherDetail); |
| |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| /* |
| bp = (BindingProvider) juddi; |
| context = bp.getRequestContext(); |
| context.put(BindingProvider.USERNAME_PROPERTY, session.getAttribute("username")); |
| context.put(BindingProvider.USERNAME_PROPERTY, session.getAttribute(AES.Decrypt("password", (String) properties.get("key"))));*/ |
| return null; |
| } else { |
| if (token != null) { |
| return token; |
| } |
| if (WS_Transport) { |
| BindingProvider bp = null; |
| Map<String, Object> context = null; |
| |
| bp = (BindingProvider) juddi; |
| context = bp.getRequestContext(); |
| context.remove(BindingProvider.USERNAME_PROPERTY); |
| context.remove(BindingProvider.PASSWORD_PROPERTY); |
| } |
| GetAuthToken req = new GetAuthToken(); |
| try { |
| if (security == null) { |
| security = transport.getUDDISecurityService(); |
| } |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| if (session.getAttribute("username") != null |
| && session.getAttribute("password") != null) { |
| req.setUserID((String) session.getAttribute("username")); |
| req.setCred(AES.Decrypt((String) session.getAttribute("password"), (String) properties.get("key"))); |
| log.info("AUDIT: fetching auth token for " + req.getUserID() + " Auth Mode is " + ((security == null) ? "HTTP" : "AUTH_TOKEN")); |
| try { |
| AuthToken authToken = security.getAuthToken(req); |
| token = authToken.getAuthInfo(); |
| return null; |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| } |
| return "Unexpected error"; |
| } |
| |
| public String SendAdvanced(Object request, String method) { |
| StringWriter sw = new StringWriter(); |
| Object result=null; |
| try { |
| if (method.equalsIgnoreCase("save_ClientSubscriptionInfo")) { |
| SaveClientSubscriptionInfo x = (SaveClientSubscriptionInfo) request; |
| x.setAuthInfo(GetToken()); |
| ClientSubscriptionInfoDetail saveClientSubscriptionInfo = null; |
| try { |
| result = juddi.saveClientSubscriptionInfo(x); |
| sw.append("Success:<br>"); |
| //JAXB.marshal(saveClientSubscriptionInfo, sw); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| x.setAuthInfo(GetToken()); |
| result = juddi.saveClientSubscriptionInfo(x); |
| sw.append("Success:<br>"); |
| //JAXB.marshal(saveClientSubscriptionInfo, sw); |
| |
| } else { |
| throw ex; |
| } |
| } |
| |
| } |
| if (method.equalsIgnoreCase("invoke_SyncSubscription")) { |
| SyncSubscription x = (SyncSubscription) request; |
| x.setAuthInfo(GetToken()); |
| SyncSubscriptionDetail invokeSyncSubscription = null; |
| try { |
| result = juddi.invokeSyncSubscription(x); |
| sw.append("Success:<br>"); |
| //JAXB.marshal(invokeSyncSubscription, sw); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| x.setAuthInfo(GetToken()); |
| result = juddi.invokeSyncSubscription(x); |
| sw.append("Success:<br>"); |
| //JAXB.marshal(invokeSyncSubscription, sw); |
| |
| } else { |
| throw ex; |
| } |
| } |
| |
| } |
| if (method.equalsIgnoreCase("admin_SaveBusiness")) { |
| AdminSaveBusiness x = (AdminSaveBusiness) request; |
| |
| DispositionReport adminSaveBusiness = null; |
| |
| try { |
| result = juddi.adminSaveBusiness(GetToken(), x.getValues()); |
| sw.append("Success:<br>"); |
| //JAXB.marshal(adminSaveBusiness, sw); |
| |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| x.setAuthInfo(GetToken()); |
| result = juddi.adminSaveBusiness(GetToken(), x.getValues()); |
| sw.append("Success:<br>"); |
| // JAXB.marshal(adminSaveBusiness, sw); |
| |
| } else { |
| throw ex; |
| } |
| } |
| } |
| if (method.equalsIgnoreCase("admin_SaveTModel")) { |
| AdminSaveTModel x = (AdminSaveTModel) request; |
| |
| DispositionReport adminSaveTModel = null; |
| try { |
| result = juddi.adminSaveTModel(GetToken(), x.getValues()); |
| sw.append("Success:<br>"); |
| //JAXB.marshal(adminSaveTModel, sw); |
| |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| x.setAuthInfo(GetToken()); |
| result = juddi.adminSaveTModel(GetToken(), x.getValues()); |
| sw.append("Success:<br>"); |
| //JAXB.marshal(adminSaveTModel, sw); |
| |
| } else { |
| throw ex; |
| } |
| } |
| |
| } |
| |
| if (method.equalsIgnoreCase("admin_SaveSubscription")) { |
| AdminSaveSubscriptionRequest x = (AdminSaveSubscriptionRequest) request; |
| Holder<List<Subscription>> holder = new Holder<List<Subscription>>(x.getSubscriptions()); |
| try { |
| juddi.adminSaveSubscription(GetToken(), x.getPublisherOrUsername(), holder); |
| sw.append("Success:<br>"); |
| result=holder; |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| |
| juddi.adminSaveSubscription(GetToken(), x.getPublisherOrUsername(), holder); |
| sw.append("Success:<br>"); |
| result=holder; |
| |
| } else { |
| throw ex; |
| } |
| } |
| } |
| if (method.equalsIgnoreCase("set_ReplicationNodes")) { |
| ReplicationConfiguration x = (ReplicationConfiguration) request; |
| // Holder<List<Subscription>> holder = new Holder<List<Subscription>>(x.getSubscriptions()); |
| try { |
| result = juddi.setReplicationNodes(GetToken(), x); |
| sw.append("Success:<br>"); |
| // JAXB.marshal(setReplicationNodes, sw); |
| } catch (Exception ex) { |
| if (isExceptionExpiration(ex)) { |
| token = null; |
| |
| result = juddi.setReplicationNodes(GetToken(), x); |
| sw.append("Success:<br>"); |
| //JAXB.marshal(setReplicationNodes, sw); |
| |
| } else { |
| throw ex; |
| } |
| } |
| } |
| |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| if (result!=null){ |
| try { |
| return sw.toString() + "<br>" + PrettyPrintJaxbObject(result); |
| } catch (Exception ex) { |
| return HandleException(ex); |
| } |
| } |
| return "Error! no work was done?"; |
| |
| } |
| |
| } |
