juddi-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From alexo...@apache.org
Subject [06/12] juddi git commit: JUDDI-919 replication now works with ssl + client-cert authentication. In order to support this, we need to have two different war file (unfortunately). Included with this change set is number of typos in our deployment files (w
Date Mon, 16 Feb 2015 02:18:21 GMT
http://git-wip-us.apache.org/repos/asf/juddi/blob/5994cd06/juddiv3-war-repl/src/main/java/org/apache/juddi/adminconsole/hub/UddiAdminHub.java
----------------------------------------------------------------------
diff --git a/juddiv3-war-repl/src/main/java/org/apache/juddi/adminconsole/hub/UddiAdminHub.java b/juddiv3-war-repl/src/main/java/org/apache/juddi/adminconsole/hub/UddiAdminHub.java
new file mode 100644
index 0000000..7edd3a6
--- /dev/null
+++ b/juddiv3-war-repl/src/main/java/org/apache/juddi/adminconsole/hub/UddiAdminHub.java
@@ -0,0 +1,1709 @@
+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.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.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();
+                DocumentBuilder db = dbf.newDocumentBuilder();
+                StringWriter sw = new StringWriter();
+                JAXB.marshal(jaxb, sw);
+                InputSource is = new InputSource(new StringReader(sw.toString()));
+
+                Transformer transformer = TransformerFactory.newInstance().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 = (JAXB.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 {
+                        Transformer transformer = TransformerFactory.newInstance().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?";
+
+        }
+
+}


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@juddi.apache.org
For additional commands, e-mail: commits-help@juddi.apache.org


Mime
View raw message