org.apache.ws.scout.registry.RegistryImpl.java Source code

Java tutorial

Introduction

Here is the source code for org.apache.ws.scout.registry.RegistryImpl.java

Source

/*
 * Copyright 2001-2004 The Apache Software Foundation.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.ws.scout.registry;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.StringReader;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Arrays;
import java.util.Properties;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.registry.InvalidRequestException;
import javax.xml.transform.stream.StreamSource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ws.scout.model.uddi.v2.AssertionStatusReport;
import org.apache.ws.scout.model.uddi.v2.AuthToken;
import org.apache.ws.scout.model.uddi.v2.BindingDetail;
import org.apache.ws.scout.model.uddi.v2.BindingTemplate;
import org.apache.ws.scout.model.uddi.v2.BusinessDetail;
import org.apache.ws.scout.model.uddi.v2.BusinessEntity;
import org.apache.ws.scout.model.uddi.v2.BusinessList;
import org.apache.ws.scout.model.uddi.v2.BusinessService;
import org.apache.ws.scout.model.uddi.v2.CategoryBag;
import org.apache.ws.scout.model.uddi.v2.DeleteBinding;
import org.apache.ws.scout.model.uddi.v2.DeleteBusiness;
import org.apache.ws.scout.model.uddi.v2.DeletePublisherAssertions;
import org.apache.ws.scout.model.uddi.v2.DeleteService;
import org.apache.ws.scout.model.uddi.v2.DeleteTModel;
import org.apache.ws.scout.model.uddi.v2.DiscoveryURLs;
import org.apache.ws.scout.model.uddi.v2.DispositionReport;
import org.apache.ws.scout.model.uddi.v2.FindBinding;
import org.apache.ws.scout.model.uddi.v2.FindBusiness;
import org.apache.ws.scout.model.uddi.v2.FindQualifiers;
import org.apache.ws.scout.model.uddi.v2.FindService;
import org.apache.ws.scout.model.uddi.v2.FindTModel;
import org.apache.ws.scout.model.uddi.v2.GetAssertionStatusReport;
import org.apache.ws.scout.model.uddi.v2.GetAuthToken;
import org.apache.ws.scout.model.uddi.v2.GetBusinessDetail;
import org.apache.ws.scout.model.uddi.v2.GetPublisherAssertions;
import org.apache.ws.scout.model.uddi.v2.GetRegisteredInfo;
import org.apache.ws.scout.model.uddi.v2.GetServiceDetail;
import org.apache.ws.scout.model.uddi.v2.GetTModelDetail;
import org.apache.ws.scout.model.uddi.v2.IdentifierBag;
import org.apache.ws.scout.model.uddi.v2.Name;
import org.apache.ws.scout.model.uddi.v2.ObjectFactory;
import org.apache.ws.scout.model.uddi.v2.PublisherAssertion;
import org.apache.ws.scout.model.uddi.v2.PublisherAssertions;
import org.apache.ws.scout.model.uddi.v2.RegisteredInfo;
import org.apache.ws.scout.model.uddi.v2.SaveBinding;
import org.apache.ws.scout.model.uddi.v2.SaveBusiness;
import org.apache.ws.scout.model.uddi.v2.SaveService;
import org.apache.ws.scout.model.uddi.v2.SaveTModel;
import org.apache.ws.scout.model.uddi.v2.ServiceDetail;
import org.apache.ws.scout.model.uddi.v2.ServiceList;
import org.apache.ws.scout.model.uddi.v2.SetPublisherAssertions;
import org.apache.ws.scout.model.uddi.v2.TModel;
import org.apache.ws.scout.model.uddi.v2.TModelBag;
import org.apache.ws.scout.model.uddi.v2.TModelDetail;
import org.apache.ws.scout.model.uddi.v2.TModelList;
import org.apache.ws.scout.transport.Transport;
import org.apache.ws.scout.transport.TransportException;
import org.apache.ws.scout.util.XMLUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * RegistryImpl is the implementation of IRegistry.
 * 
 * <p>The execute() function signature has been changed slightly from the jUDDI
 * version, since the URL can no longer be decided dynamically (in an easy
 * enough manner) as we don't use jUDDI data types anymore.</p>
 * 
 * <i>The function code is borrowed from jUDDI, with appropriate modifications so
 * that xmlbeans data types are used intead of jUDDI data types.</i>
 * 
 */

public class RegistryImpl implements IRegistry {

    public static final String DEFAULT_ADMIN_ENDPOINT = "http://localhost:8080/juddi/admin";
    public static final String DEFAULT_TRANSPORT_CLASS = "org.apache.ws.scout.transport.SaajTransport";
    public static final String DEFAULT_SECURITY_PROVIDER = "com.sun.net.ssl.internal.ssl.Provider";
    public static final String DEFAULT_PROTOCOL_HANDLER = "com.sun.net.ssl.internal.www.protocol";
    public static final String DEFAULT_UDDI_VERSION = "2.0";
    public static final String DEFAULT_UDDI_NAMESPACE = "urn:uddi-org:api_v2";

    private URI adminURI;
    private URI inquiryURI;
    private URI publishURI;
    private URI securityURI;

    private Transport transport;

    private String securityProvider;
    private String protocolHandler;
    private String uddiVersion;
    private String uddiNamespace;

    private ObjectFactory objectFactory = new ObjectFactory();

    private Marshaller marshaller = null;
    private Unmarshaller unmarshaller = null;

    private static Log log = LogFactory.getLog(RegistryImpl.class);

    /**
     * Creates a new instance of RegistryImpl.
     * @throws InvalidRequestException 
     */
    public RegistryImpl(Properties props) throws InvalidRequestException {
        super();

        this.init(props);
    }

    /**
     * @throws InvalidRequestException 
     * 
     */
    private void init(Properties props) throws InvalidRequestException {
        // We need to have a non-null Properties
        // instance so initialization takes place.
        if (props == null)
            props = new Properties();

        // Override defaults with specific specific values
        try {
            setInquiryURI(new URI(props.getProperty(ConnectionFactoryImpl.QUERYMANAGER_PROPERTY)));
            if (props.containsKey(ConnectionFactoryImpl.LIFECYCLEMANAGER_PROPERTY)) {
                setPublishURI(new URI(props.getProperty(ConnectionFactoryImpl.LIFECYCLEMANAGER_PROPERTY)));
            }
            String securityURL = props.getProperty(ConnectionFactoryImpl.SECURITYMANAGER_PROPERTY,
                    props.getProperty(ConnectionFactoryImpl.LIFECYCLEMANAGER_PROPERTY));
            if (securityURL != null)
                setSecurityURI(new URI(securityURL));
            setAdminURI(new URI(
                    props.getProperty(ConnectionFactoryImpl.ADMIN_ENDPOINT_PROPERTY, DEFAULT_ADMIN_ENDPOINT)));
            setSecurityProvider(
                    props.getProperty(ConnectionFactoryImpl.SECURITY_PROVIDER_PROPERTY, DEFAULT_SECURITY_PROVIDER));
            setProtocolHandler(
                    props.getProperty(ConnectionFactoryImpl.PROTOCOL_HANDLER_PROPERTY, DEFAULT_PROTOCOL_HANDLER));
            setUddiVersion(props.getProperty(ConnectionFactoryImpl.UDDI_VERSION_PROPERTY, DEFAULT_UDDI_VERSION));
            setUddiNamespace(
                    props.getProperty(ConnectionFactoryImpl.UDDI_NAMESPACE_PROPERTY, DEFAULT_UDDI_NAMESPACE));
            setTransport(getTransport(
                    props.getProperty(ConnectionFactoryImpl.TRANSPORT_CLASS_PROPERTY, DEFAULT_TRANSPORT_CLASS)));

            JAXBContext context = JAXBContextUtil.getContext(JAXBContextUtil.UDDI_V2_VERSION);
            unmarshaller = context.createUnmarshaller();
            marshaller = context.createMarshaller();
        } catch (URISyntaxException muex) {
            throw new InvalidRequestException(muex.getMessage(), muex);
        } catch (JAXBException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 
     * @param uddiRequest
     * @return String
     * @throws RegistryException
     */
    public String execute(String uddiRequest, String urltype) throws TransportException {
        URI endPointURL = null;
        if (urltype.equalsIgnoreCase("INQUIRY"))
            endPointURL = this.getInquiryURI();
        else
            endPointURL = this.getPublishURI();

        // A SOAP request is made and a SOAP response
        // is returned.

        return transport.send(uddiRequest, endPointURL);
    }

    /**
     * 
     */
    public JAXBElement<?> execute(JAXBElement<?> uddiRequest, URI endPointURI) throws RegistryException {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        Document doc;
        try {
            DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
            docBuilderFactory.setNamespaceAware(true);
            DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
            this.marshaller.marshal(uddiRequest, baos);
            doc = docBuilder.parse(new ByteArrayInputStream(baos.toByteArray()));
        } catch (SAXException saxe) {
            throw (new RegistryException(saxe));
        } catch (ParserConfigurationException pce) {
            throw (new RegistryException(pce));
        } catch (IOException ioe) {
            throw (new RegistryException(ioe));
        } catch (JAXBException ioe) {
            throw (new RegistryException(ioe));
        }
        Element request = doc.getDocumentElement();

        request.setAttribute("xmlns", this.getUddiNamespace());
        if (!"3.0".equals(this.getUddiVersion())) {
            request.setAttribute("generic", this.getUddiVersion());
        }
        //request.setAttributeNS("http://www.w3.org/2000/xmlns/","xmlns", this.getUddiNamespace());
        // A SOAP request is made and a SOAP response
        // is returned.

        Element response;
        try {
            response = transport.send(request, endPointURI);
        } catch (TransportException te) {
            throw new RegistryException(te);
        }
        /* if (response.hasAttributes()) {
            NamedNodeMap am = response.getAttributes();
            ArrayList<String> al = new ArrayList<String>();
            for (int i = 0; i < am.getLength(); i++) {
         Node n = am.item(i);
         String attribute = n.getNodeName();
         if (attribute!= null && attribute.startsWith("xmlns")) {
            al.add(attribute);
         }
            }
            for (String attr : al) {
         response.removeAttribute(attr);
            }
         }*/

        if (response.getNamespaceURI() == null) {
            response.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns", this.getUddiNamespace());
        }

        // If we are getting responses from a UDDI v3, remove the xmlns

        // First, let's make sure that a response
        // (any response) is found in the SOAP Body.

        String responseName = response.getLocalName();
        if (responseName == null) {
            throw new RegistryException("Unsupported response " + "from registry. A value was not present.");
        }

        if (responseName.toLowerCase().equals("fault")) {
            NodeList nodeList = null;

            // Child Elements
            String fCode = null;
            nodeList = response.getElementsByTagName("faultcode");
            if (nodeList.getLength() > 0)
                fCode = nodeList.item(0).getNodeValue();

            String fString = null;
            nodeList = response.getElementsByTagName("faultstring");
            if (nodeList.getLength() > 0)
                fString = nodeList.item(0).getNodeValue();

            String fActor = null;
            nodeList = response.getElementsByTagName("faultactor");
            if (nodeList.getLength() > 0)
                fActor = nodeList.item(0).getNodeValue();

            DispositionReport dispRpt = null;

            nodeList = response.getElementsByTagName("detail");
            if (nodeList.getLength() > 0) {
                nodeList = ((Element) nodeList.item(0)).getElementsByTagName("dispositionReport");
                if (nodeList.getLength() > 0) {
                    JAXBElement<DispositionReport> dispRptObj = null;
                    try {
                        dispRptObj = (JAXBElement<DispositionReport>) unmarshaller
                                .unmarshal((Element) nodeList.item(0));
                    } catch (JAXBException xmle) {
                        throw (new RegistryException(xmle));
                    }
                    dispRpt = dispRptObj.getValue();
                }
            }

            RegistryException e = new RegistryException(fCode, fString, fActor, dispRpt);

            // Create RegistryException instance and return
            throw e;
        }

        // Let's now try to determine which UDDI response
        // we received and unmarshal it appropriately or
        // throw a RegistryException if it's unknown.
        // Well, we have now determined that something was
        // returned and it is "a something" that we know
        // about so let's unmarshal it into a RegistryObject
        // Next, let's make sure we didn't recieve a SOAP
        // Fault. If it is a SOAP Fault then throw it
        // immediately.

        JAXBElement<?> uddiResponse = null;
        try {
            String xml = XMLUtils.convertNodeToXMLString(response);
            log.debug("Response is: " + xml);

            StringReader reader = new StringReader(xml);
            uddiResponse = (JAXBElement<?>) unmarshaller.unmarshal(new StreamSource(reader));
            //It is probably faster not to go to a String, but JAXB has issues with this
            //uddiResponse = (JAXBElement<?>) unmarshaller.unmarshal(response);

        } catch (JAXBException xmle) {
            throw (new RegistryException(xmle));
        }

        return uddiResponse;
    }

    /**
     * @return Returns the adminURL.
     */
    public URI getAdminURI() {
        return this.adminURI;
    }

    /**
     * @param url
     *            The adminURL to set.
     */
    public void setAdminURI(URI url) {
        this.adminURI = url;
    }

    /**
     * @return Returns the inquiryURL.
     */
    public URI getInquiryURI() {
        return this.inquiryURI;
    }

    /**
     * @param inquiryURI
     *            The inquiryURI to set.
     */
    public void setInquiryURI(URI inquiryURI) {
        this.inquiryURI = inquiryURI;
    }

    /**
     * @return Returns the protocolHandler.
     */
    public String getProtocolHandler() {
        return this.protocolHandler;
    }

    /**
     * @param protocolHandler
     *            The protocolHandler to set.
     */
    public void setProtocolHandler(String protocolHandler) {
        this.protocolHandler = protocolHandler;
    }

    /**
     * @return Returns the publishURL.
     */
    public URI getPublishURI() {
        return this.publishURI;
    }

    /**
     * @return Returns the publishURL.
     */
    public URI getSecurityURI() {
        return this.securityURI;
    }

    /**
     * @param publishURI
     *            The publishURI to set.
     */
    public void setPublishURI(URI publishURI) {
        this.publishURI = publishURI;
    }

    /**
     * @param publishURI
     *            The publishURI to set.
     */
    public void setSecurityURI(URI securityURI) {
        this.securityURI = securityURI;
    }

    /**
     * @return Returns the securityProvider.
     */
    public String getSecurityProvider() {
        return this.securityProvider;
    }

    /**
     * @param securityProvider
     *            The securityProvider to set.
     */
    public void setSecurityProvider(String securityProvider) {
        this.securityProvider = securityProvider;
    }

    /**
     * @return Returns the transport.
     */
    public Transport getTransport() {
        return transport;
    }

    /**
     * @param transport
     *            The transport to set.
     */
    public void setTransport(Transport transport) {
        this.transport = transport;
    }

    /**
     * @return Returns the uddiNS.
     */
    public String getUddiNamespace() {
        return this.uddiNamespace;
    }

    /**
     * @param uddiNS
     *            The uddiNS to set.
     */
    public void setUddiNamespace(String uddiNS) {
        this.uddiNamespace = uddiNS;
    }

    /**
     * @return Returns the uddiVersion.
     */
    public String getUddiVersion() {
        return this.uddiVersion;
    }

    /**
     * @param uddiVersion
     *            The uddiVersion to set.
     */
    public void setUddiVersion(String uddiVersion) {
        this.uddiVersion = uddiVersion;
    }

    /**
     * "Used to remove an existing bindingTemplate from the bindingTemplates
     * collection that is part of a specified businessService structure."
     * 
     * @exception RegistryException;
     */
    public DispositionReport deleteBinding(String authInfo, String[] bindingKeyArray) throws RegistryException {
        DeleteBinding request = this.objectFactory.createDeleteBinding();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        if (bindingKeyArray != null) {
            request.getBindingKey().addAll(Arrays.asList(bindingKeyArray));
        }

        DispositionReport dr;
        JAXBElement<?> o = execute(this.objectFactory.createDeleteBinding(request), this.getPublishURI());
        dr = (DispositionReport) o.getValue();

        return dr;
    }

    /**
     * "Used to delete registered businessEntity information from the registry."
     * 
     * @exception RegistryException;
     */
    public DispositionReport deleteBusiness(String authInfo, String[] businessKeyArray) throws RegistryException {
        DeleteBusiness request = this.objectFactory.createDeleteBusiness();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        if (businessKeyArray != null) {
            request.getBusinessKey().addAll(Arrays.asList(businessKeyArray));
        }

        DispositionReport dr;
        JAXBElement<?> o = execute(this.objectFactory.createDeleteBusiness(request), this.getPublishURI());
        dr = (DispositionReport) o.getValue();

        return dr;
    }

    /**
     * @exception RegistryException;
     */
    public DispositionReport deletePublisherAssertions(String authInfo, PublisherAssertion[] assertionArray)
            throws RegistryException {
        DeletePublisherAssertions request = this.objectFactory.createDeletePublisherAssertions();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        if (assertionArray != null) {
            request.getPublisherAssertion().addAll(Arrays.asList(assertionArray));
        }

        DispositionReport dr;
        JAXBElement<?> o = execute(this.objectFactory.createDeletePublisherAssertions(request),
                this.getPublishURI());
        dr = (DispositionReport) o.getValue();

        return dr;
    }

    /**
     * "Used to delete an existing businessService from the businessServices
     * collection that is part of a specified businessEntity."
     * 
     * @exception RegistryException;
     */
    public DispositionReport deleteService(String authInfo, String[] serviceKeyArray) throws RegistryException {
        DeleteService request = this.objectFactory.createDeleteService();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        if (serviceKeyArray != null) {
            request.getServiceKey().addAll(Arrays.asList(serviceKeyArray));
        }

        DispositionReport dr;
        JAXBElement<?> o = execute(this.objectFactory.createDeleteService(request), this.getPublishURI());
        dr = (DispositionReport) o.getValue();

        return dr;
    }

    /**
     * "Used to delete registered information about a tModel. If there are any
     * references to a tModel when this call is made, the tModel will be marked
     * deleted instead of being physically removed."
     * 
     * @exception RegistryException;
     */
    public DispositionReport deleteTModel(String authInfo, String[] tModelKeyArray) throws RegistryException {
        DeleteTModel request = this.objectFactory.createDeleteTModel();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        if (tModelKeyArray != null) {
            request.getTModelKey().addAll(Arrays.asList(tModelKeyArray));
        }

        DispositionReport dr;
        JAXBElement<?> o = execute(this.objectFactory.createDeleteTModel(request), this.getPublishURI());
        dr = (DispositionReport) o.getValue();

        return dr;
    }

    /**
     * Used to locate information about one or more businesses. Returns a
     * businessList message that matches the conditions specified.
     * 
     * @exception RegistryException;
     */
    public BusinessList findBusiness(Name[] nameArray, DiscoveryURLs discoveryURLs, IdentifierBag identifierBag,
            CategoryBag categoryBag, TModelBag tModelBag, FindQualifiers findQualifiers, int maxRows)
            throws RegistryException {
        FindBusiness request = this.objectFactory.createFindBusiness();

        if (nameArray != null) {
            request.getName().addAll(Arrays.asList(nameArray));
        }

        if (discoveryURLs != null) {
            request.setDiscoveryURLs(discoveryURLs);
        }

        if (identifierBag != null) {
            request.setIdentifierBag(identifierBag);
        }

        if (categoryBag != null) {
            request.setCategoryBag(categoryBag);
        }

        if (tModelBag != null) {
            request.setTModelBag(tModelBag);
        } else {
            request.setTModelBag(this.objectFactory.createTModelBag());
        }

        if (findQualifiers != null) {
            request.setFindQualifiers(findQualifiers);
        }

        request.setMaxRows(maxRows);

        BusinessList bl;
        JAXBElement<?> o = execute(this.objectFactory.createFindBusiness(request), this.getInquiryURI());
        bl = (BusinessList) o.getValue();

        return bl;
    }

    /**
     * "Used to locate specific bindings within a registered businessService.
     * Returns a bindingDetail message."
     * 
     * @exception RegistryException
     */
    public BindingDetail findBinding(String serviceKey, CategoryBag categoryBag, TModelBag tModelBag,
            FindQualifiers findQualifiers, int maxRows) throws RegistryException {
        // FIXME: Juddi's methods also set category bag (per uddi spec v3).
        // However, we are sticking to v2 for now, so categorybag doesn't
        // exist under FindBinding. It is fine for now, since the incoming
        // parameter value is always null anyways -- but this may change
        // in the future.

        FindBinding request = this.objectFactory.createFindBinding();

        if (serviceKey != null) {
            request.setServiceKey(serviceKey);
        }

        if (tModelBag != null) {
            request.setTModelBag(tModelBag);
        } else {
            TModelBag tmb = this.objectFactory.createTModelBag();
            request.setTModelBag(tmb);
        }

        if (findQualifiers != null) {
            request.setFindQualifiers(findQualifiers);
        }
        request.setMaxRows(maxRows);

        BindingDetail bd;
        JAXBElement<?> o = execute(this.objectFactory.createFindBinding(request), this.getInquiryURI());
        bd = (BindingDetail) o.getValue();

        return bd;
    }

    /**
     * "Used to locate specific services within a registered businessEntity.
     * Return a serviceList message." From the XML spec (API, p18) it appears
     * that the name, categoryBag, and tModelBag arguments are mutually
     * exclusive.
     * 
     * @exception RegistryException;
     */
    public ServiceList findService(String businessKey, Name[] nameArray, CategoryBag categoryBag,
            TModelBag tModelBag, FindQualifiers findQualifiers, int maxRows) throws RegistryException {
        FindService request = this.objectFactory.createFindService();

        if (businessKey != null) {
            request.setBusinessKey(businessKey);
        }

        if (nameArray != null) {
            request.getName().addAll(Arrays.asList(nameArray));
        }

        if (categoryBag != null) {
            request.setCategoryBag(categoryBag);
        }

        if (tModelBag != null) {
            request.setTModelBag(tModelBag);
        }

        if (findQualifiers != null) {
            request.setFindQualifiers(findQualifiers);
        }

        request.setMaxRows(maxRows);

        ServiceList sl;
        JAXBElement<?> o = execute(this.objectFactory.createFindService(request), this.getInquiryURI());
        sl = (ServiceList) o.getValue();

        return sl;
    }

    /**
     * "Used to locate one or more tModel information structures. Returns a
     * tModelList structure."
     * 
     * @exception RegistryException;
     */
    public TModelList findTModel(String name, CategoryBag categoryBag, IdentifierBag identifierBag,
            FindQualifiers findQualifiers, int maxRows) throws RegistryException {
        FindTModel request = this.objectFactory.createFindTModel();

        Name jaxbName = this.objectFactory.createName();

        if (name != null) {
            jaxbName.setValue(name);
        }

        request.setName(jaxbName);

        if (categoryBag != null) {
            request.setCategoryBag(categoryBag);
        }

        if (identifierBag != null) {
            request.setIdentifierBag(identifierBag);
        }

        if (findQualifiers != null) {
            request.setFindQualifiers(findQualifiers);
        }

        request.setMaxRows(maxRows);

        TModelList tml;
        JAXBElement<?> o = execute(this.objectFactory.createFindTModel(request), this.getInquiryURI());
        tml = (TModelList) o.getValue();

        return tml;
    }

    /**
     * @exception RegistryException;
     */
    public AssertionStatusReport getAssertionStatusReport(String authInfo, String completionStatus)
            throws RegistryException {
        GetAssertionStatusReport request = this.objectFactory.createGetAssertionStatusReport();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        if (completionStatus != null) {
            request.setCompletionStatus(completionStatus);
        }

        AssertionStatusReport asr;
        JAXBElement<?> o = execute(this.objectFactory.createGetAssertionStatusReport(request),
                this.getPublishURI());
        asr = (AssertionStatusReport) o.getValue();

        return asr;
    }

    /**
     * "Used to request an authentication token from an Operator Site.
     * Authentication tokens are required to use all other APIs defined in the
     * publishers API. This server serves as the program's equivalent of a login
     * request."
     * 
     * @exception RegistryException;
     */
    public AuthToken getAuthToken(String userID, String cred) throws RegistryException {
        GetAuthToken request = this.objectFactory.createGetAuthToken();

        if (userID != null) {
            request.setUserID(userID);
        }

        if (cred != null) {
            request.setCred(cred);
        }

        URI getAuthTokenURI = getSecurityURI();
        ;

        AuthToken at;
        JAXBElement<?> o = execute(this.objectFactory.createGetAuthToken(request), getAuthTokenURI);
        at = (AuthToken) o.getValue();

        return at;
    }

    /**
     * Used to get the full businessEntity information for a particular business
     * entity. Returns a businessDetail message.
     * 
     * @exception RegistryException;
     */
    public BusinessDetail getBusinessDetail(String businessKey) throws RegistryException {
        String[] keys = new String[1];
        keys[0] = businessKey;

        return getBusinessDetail(keys);
    }

    /**
     * "Used to get the full businessEntity information for one or more
     * businesses. Returns a businessDetail message."
     * 
     * @exception RegistryException;
     */
    public BusinessDetail getBusinessDetail(String[] businessKeyArray) throws RegistryException {
        GetBusinessDetail request = this.objectFactory.createGetBusinessDetail();

        if (businessKeyArray != null) {
            request.getBusinessKey().addAll(Arrays.asList(businessKeyArray));
        }

        BusinessDetail bd;
        JAXBElement<?> o = execute(this.objectFactory.createGetBusinessDetail(request), this.getInquiryURI());
        bd = (BusinessDetail) o.getValue();
        return bd;
    }

    /**
     * @exception RegistryException;
     */
    public PublisherAssertions getPublisherAssertions(String authInfo) throws RegistryException {
        GetPublisherAssertions request = this.objectFactory.createGetPublisherAssertions();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        PublisherAssertions pa;
        JAXBElement<?> o = execute(this.objectFactory.createGetPublisherAssertions(request), this.getPublishURI());
        pa = (PublisherAssertions) o.getValue();

        return pa;
    }

    /**
     * @exception RegistryException;
     */
    public RegisteredInfo getRegisteredInfo(String authInfo) throws RegistryException {
        GetRegisteredInfo request = this.objectFactory.createGetRegisteredInfo();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        RegisteredInfo ri;
        JAXBElement<?> o = execute(this.objectFactory.createGetRegisteredInfo(request), this.getPublishURI());
        ri = (RegisteredInfo) o.getValue();

        return ri;
    }

    /**
     * "Used to get full details for a particular registered businessService.
     * Returns a serviceDetail message."
     * 
     * @exception RegistryException;
     */
    public ServiceDetail getServiceDetail(String serviceKey) throws RegistryException {
        String[] keys = new String[1];
        keys[0] = serviceKey;

        return getServiceDetail(keys);
    }

    /**
     * "Used to get full details for a given set of registered businessService
     * data. Returns a serviceDetail message."
     * 
     * @exception RegistryException;
     */
    public ServiceDetail getServiceDetail(String[] serviceKeyArray) throws RegistryException {
        GetServiceDetail request = this.objectFactory.createGetServiceDetail();

        if (serviceKeyArray != null) {
            request.getServiceKey().addAll(Arrays.asList(serviceKeyArray));
        }

        ServiceDetail sd;
        JAXBElement<?> o = execute(this.objectFactory.createGetServiceDetail(request), this.getInquiryURI());
        sd = (ServiceDetail) o.getValue();

        return sd;
    }

    /**
     * "Used to get full details for a particular registered TModel. Returns a
     * tModelDetail message."
     * 
     * @exception RegistryException;
     */
    public TModelDetail getTModelDetail(String tModelKey) throws RegistryException {
        String[] keys = new String[1];
        keys[0] = tModelKey;

        return getTModelDetail(keys);
    }

    /**
     * "Used to get full details for a given set of registered tModel data.
     * Returns a tModelDetail message."
     * 
     * @exception RegistryException;
     */
    public TModelDetail getTModelDetail(String[] tModelKeyArray) throws RegistryException {
        GetTModelDetail request = this.objectFactory.createGetTModelDetail();

        if (tModelKeyArray != null) {
            request.getTModelKey().addAll(Arrays.asList(tModelKeyArray));
        }

        TModelDetail tmd;
        JAXBElement<?> o = execute(this.objectFactory.createGetTModelDetail(request), this.getInquiryURI());
        tmd = (TModelDetail) o.getValue();

        return tmd;
    }

    /**
     * @exception RegistryException;
     */
    public PublisherAssertions setPublisherAssertions(String authInfo, PublisherAssertion[] assertionArray)
            throws RegistryException {
        SetPublisherAssertions request = this.objectFactory.createSetPublisherAssertions();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        if (assertionArray != null) {
            request.getPublisherAssertion().addAll(Arrays.asList(assertionArray));
        }

        PublisherAssertions pa;
        JAXBElement<?> o = execute(this.objectFactory.createSetPublisherAssertions(request), this.getPublishURI());
        pa = (PublisherAssertions) o.getValue();

        return pa;
    }

    /**
     * "Used to register new bindingTemplate information or update existing
     * bindingTemplate information. Use this to control information about
     * technical capabilities exposed by a registered business."
     * 
     * @exception RegistryException;
     */
    public BindingDetail saveBinding(String authInfo, BindingTemplate[] bindingArray) throws RegistryException {
        SaveBinding request = this.objectFactory.createSaveBinding();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        if (bindingArray != null) {
            request.getBindingTemplate().addAll(Arrays.asList(bindingArray));
        }

        BindingDetail bd;
        JAXBElement<?> o = execute(this.objectFactory.createSaveBinding(request), this.getPublishURI());
        bd = (BindingDetail) o.getValue();

        return bd;
    }

    /**
     * "Used to register new businessEntity information or update existing
     * businessEntity information. Use this to control the overall information
     * about the entire business. Of the save_x APIs this one has the broadest
     * effect."
     * 
     * @exception RegistryException;
     */
    public BusinessDetail saveBusiness(String authInfo, BusinessEntity[] businessArray) throws RegistryException {
        SaveBusiness request = this.objectFactory.createSaveBusiness();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        if (businessArray != null) {
            request.getBusinessEntity().addAll(Arrays.asList(businessArray));
        }

        BusinessDetail bd;
        JAXBElement<?> o = execute(this.objectFactory.createSaveBusiness(request), this.getPublishURI());
        bd = (BusinessDetail) o.getValue();

        return bd;
    }

    /**
     * "Used to register or update complete information about a businessService
     * exposed by a specified businessEntity."
     * 
     * @exception RegistryException;
     */
    public ServiceDetail saveService(String authInfo, BusinessService[] serviceArray) throws RegistryException {
        SaveService request = this.objectFactory.createSaveService();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        if (serviceArray != null) {
            request.getBusinessService().addAll(Arrays.asList(serviceArray));
        }

        ServiceDetail sd;
        JAXBElement<?> o = execute(this.objectFactory.createSaveService(request), this.getPublishURI());
        sd = (ServiceDetail) o.getValue();

        return sd;
    }

    /**
     * "Used to register or update complete information about a tModel."
     * 
     * @exception RegistryException;
     */
    public TModelDetail saveTModel(String authInfo, TModel[] tModelArray) throws RegistryException {
        SaveTModel request = this.objectFactory.createSaveTModel();

        if (authInfo != null) {
            request.setAuthInfo(authInfo);
        }

        if (tModelArray != null) {
            request.getTModel().addAll(Arrays.asList(tModelArray));
        }

        TModelDetail tmd;
        JAXBElement<?> o = execute(this.objectFactory.createSaveTModel(request), this.getPublishURI());
        tmd = (TModelDetail) o.getValue();
        return tmd;
    }

    /**
     * Returns an implementation of Transport based on the className passed in.
     * If a null value is passed then the default Transport implementation
     * "org.apache.ws.scout.transport.AxisTransport" is created and returned.
     * 
     * @return Transport
     */
    public Transport getTransport(String className) {
        Transport transport = null;
        Class transportClass = null;

        // If a Transport class name isn't supplied use
        // the default Transport implementation.
        if (className == null)
            className = DEFAULT_TRANSPORT_CLASS;

        try {
            // instruct class loader to load the TransportFactory
            transportClass = getClassForName(className);
        } catch (ClassNotFoundException cnfex) {
            throw new RuntimeException(cnfex);
        }

        try {
            // try to instantiate the TransportFactory
            transport = (Transport) transportClass.newInstance();
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }

        return transport;
    }

    /**
     * 
     * @param name
     * @return The class object for the name given
     * @throws ClassNotFoundException
     * @throws NoClassDefFoundError
     */
    public static Class getClassForName(String name) throws ClassNotFoundException, NoClassDefFoundError {
        Class clazz = null;

        try {
            // log.info("Using the Context ClassLoader");
            ClassLoader ccl = AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
                public ClassLoader run() {
                    return Thread.currentThread().getContextClassLoader();
                }
            });

            clazz = Class.forName(name, true, ccl);
        } catch (Exception e) {
            log.debug("Failed to load the class " + name + " with context class loader " + e);
        }

        if (null == clazz) {
            ClassLoader scl = AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
                public ClassLoader run() {
                    return ClassLoader.getSystemClassLoader();
                }
            });

            try {
                clazz = Class.forName(name, true, scl);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        return clazz;
    }
}