RegistryWSDLHandler.java

package org.objectweb.jonas.ws.handler;

import java.net.MalformedURLException;
import java.net.PasswordAuthentication;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Set;

import javax.wsdl.extensions.ExtensibilityElement;
import javax.wsdl.extensions.soap.SOAPAddress;
import javax.xml.registry.BulkResponse;
import javax.xml.registry.BusinessLifeCycleManager;
import javax.xml.registry.BusinessQueryManager;
import javax.xml.registry.Connection;
import javax.xml.registry.ConnectionFactory;
import javax.xml.registry.JAXRException;
import javax.xml.registry.LifeCycleManager;
import javax.xml.registry.RegistryException;
import javax.xml.registry.RegistryService;
import javax.xml.registry.infomodel.Classification;
import javax.xml.registry.infomodel.ClassificationScheme;
import javax.xml.registry.infomodel.Concept;
import javax.xml.registry.infomodel.ExternalLink;
import javax.xml.registry.infomodel.InternationalString;
import javax.xml.registry.infomodel.Key;
import javax.xml.registry.infomodel.Organization;
import javax.xml.registry.infomodel.PersonName;
import javax.xml.registry.infomodel.Service;
import javax.xml.registry.infomodel.ServiceBinding;
import javax.xml.registry.infomodel.SpecificationLink;
import javax.xml.registry.infomodel.User;

import org.w3c.dom.Element;

import org.objectweb.jonas_lib.I18n;

import org.objectweb.jonas_ws.deployment.api.ServiceDesc;

import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.ws.WSServiceException;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class RegistryWSDLHandler implements WSDLHandler {

    private static final String PUBLISH_URL_PROP
        = "javax.xml.registry.lifeCycleManagerURL";

    private static final String INQUIRY_URL_PROP
        = "javax.xml.registry.queryManagerURL";

    private static final String USERNAME
        = "jonas.service.publish.uddi.username";

    private static final String PASSWORD
        = "jonas.service.publish.uddi.password";

    private static final String ORGANIZATION_NAME
        = "jonas.service.publish.uddi.organization.name";

    private static final String ORGANIZATION_DESC
        = "jonas.service.publish.uddi.organization.desc";

    private static final String PERSON_NAME
        = "jonas.service.publish.uddi.organization.person_name";


    private ConnectionFactory connFactory;

    private PasswordAuthentication passAuth;

    private Properties props;

    private static Logger logger = Log.getLogger(Log.JONAS_PUBLISH_PREFIX);

    private static I18n i18n = I18n.getInstance(RegistryWSDLHandler.class);

    public RegistryWSDLHandler(Properties props) throws WSServiceException {

        this.props = props;

        //Check minimal properties
        String publishURL = props.getProperty(PUBLISH_URL_PROP);
        String queryURL = props.getProperty(INQUIRY_URL_PROP);
        String username = props.getProperty(USERNAME);
        String password = props.getProperty(PASSWORD);

        // Check if publishURL is an URL
        try {
            new URL(publishURL);
        } catch (MalformedURLException mue) {
            String err = i18n.getMessage("RegistryWSDLHandler.constr.mue", publishURL);
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err, mue);
        }

        try {
            new URL(queryURL);
        } catch (MalformedURLException mue) {
            String err = i18n.getMessage("RegistryWSDLHandler.constr.mue", queryURL);
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err, mue);
        }

        try {
            // Create the ConnectionFactory
            connFactory = ConnectionFactory.newInstance();
            connFactory.setProperties(props);
        } catch (JAXRException jaxre) {
            String err = i18n.getMessage("RegistryWSDLHandler.constr.jaxrException");
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err, jaxre);
        }

        // Create the Authentication
        if (username != null && password != null) {
            passAuth = new PasswordAuthentication(username, password.toCharArray());
        } else {
            String err = i18n.getMessage("RegistryWSDLHandler.constr.noCreds");
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err);
        }

        // Check organization props
        String name = props.getProperty(ORGANIZATION_NAME);
        String person = props.getProperty(PERSON_NAME);
        if ((name == null) || (person == null)) {
            String err = i18n.getMessage("RegistryWSDLHandler.constr.missingProp");
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err);
        }
    }

    public void publish(ServiceDesc sd) throws WSServiceException {

        try {
            javax.wsdl.Definition def = sd.getWSDL().getDefinition();

            // Create the connection
            Connection connection = connFactory.createConnection();

            // Add Credentials
            Set creds = new HashSet();
            creds.add(passAuth);
            connection.setCredentials(creds);

            // Get the registry Service
            RegistryService rs = connection.getRegistryService();

            // get the Query API Manager
            BusinessQueryManager bqm = rs.getBusinessQueryManager();

            // get the Publish API Manager
            BusinessLifeCycleManager blcm = rs.getBusinessLifeCycleManager();

            // Reference a unique InternationalString
            InternationalString is = null;

            // Create the Organization with properties
            Organization org = blcm.createOrganization(props.getProperty(ORGANIZATION_NAME));
            String orgDesc = props.getProperty(ORGANIZATION_DESC);
            if (orgDesc != null) {
                is = blcm.createInternationalString(orgDesc);
                org.setDescription(is);
            }
            User contact = blcm.createUser();
            PersonName pName = blcm.createPersonName(props.getProperty(PERSON_NAME));
            contact.setPersonName(pName);
            org.setPrimaryContact(contact);

            Collection services = new ArrayList();
            // Create n Service (1 for each service)
            for (Iterator servicesIter = def.getServices().values().iterator();
                 servicesIter.hasNext();) {

                javax.wsdl.Service s = (javax.wsdl.Service) servicesIter.next();
                Service service = blcm.createService(s.getQName().getLocalPart());

                Element desc = s.getDocumentationElement();
                if (desc != null) {
                    String description = getDescription(desc);
                    is = blcm.createInternationalString(description);
                    service.setDescription(is);
                }

                // Create n ServiceBinding (1 for each port)
                Collection serviceBindings = new ArrayList();
                for (Iterator portsIter = s.getPorts().values().iterator();
                     portsIter.hasNext();) {

                    javax.wsdl.Port port = (javax.wsdl.Port) portsIter.next();

                    ServiceBinding binding = blcm.createServiceBinding();

                    Element pDesc = port.getDocumentationElement();
                    String pDescription = port.getName();
                    if (pDesc != null) {
                        pDescription += " " + getDescription(pDesc);
                    }
                    is = blcm.createInternationalString(pDescription);
                    binding.setDescription(is);

                    // we do not check URL validity because webapps
                    // are not deployed at this point.
                    binding.setValidateURI(false);
                    String url = getEndpoint(port);
                    binding.setAccessURI(url);

                    // Create the Concep for WSDL
                    Concept concept = blcm.createConcept(null, port.getName() + " Concept", "");
                    is = blcm.createInternationalString(pDescription + " Concept");
                    concept.setDescription(is);

                    ExternalLink extlink = blcm.createExternalLink("file://",
                                                                   "WSDL");
                    extlink.setValidateURI(false);
                    // !!! Axis specific !!!
                    extlink.setExternalURI(url + "?JWSDL");

                    concept.addExternalLink(extlink);

                    // The Concept is a WSDL Document
                    ClassificationScheme uddiOrgTypes =
                        bqm.findClassificationSchemeByName(null, "uddi-org:types");
                    Classification wsdlSpecClass = blcm.createClassification(uddiOrgTypes,
                                                                             "wsdlSpec",
                                                                             "wsdlSpec");
                    concept.addClassification(wsdlSpecClass);

                    // save into registry and get key
                    Collection concepts = new ArrayList();
                    concepts.add(concept);
                    BulkResponse br = blcm.saveConcepts(concepts);
                    String key = getKey(br);

                    // i18n RegistryWSDLHandler.publish.conceptKey
                    String msg = i18n.getMessage("RegistryWSDLHandler.publish.conceptKey",
                                                 port.getName(),
                                                 key);
                    logger.log(BasicLevel.INFO, msg);

                    // get the concept from registry
                    Concept c = (Concept) bqm.getRegistryObject(key, LifeCycleManager.CONCEPT);

                    SpecificationLink specLink = blcm.createSpecificationLink();
                    specLink.setSpecificationObject(c);
                    binding.addSpecificationLink(specLink);

                    serviceBindings.add(binding);
                }
                service.addServiceBindings(serviceBindings);
                services.add(service);
            }
            // Save into the Organisation
            org.addServices(services);

            Collection orgs = new ArrayList();
            orgs.add(org);

            BulkResponse br = blcm.saveOrganizations(orgs);
            String key = getKey(br);

            // i18n RegistryWSDLHandler.publish.organisationKey
            String msg = i18n.getMessage("RegistryWSDLHandler.publish.organisationKey",
                                         org,
                                         key);
            logger.log(BasicLevel.INFO, msg);


        } catch (JAXRException jaxre) {
            String err = i18n.getMessage("RegistryWSDLHandler.publish.jaxrException");
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err, jaxre);
        }
    }

    private String getEndpoint(javax.wsdl.Port port) {
        String url = null;
        List ee = port.getExtensibilityElements();
        for (Iterator ext = ee.iterator(); ext.hasNext();) {
            ExtensibilityElement elem = (ExtensibilityElement) ext.next();
            if (elem instanceof SOAPAddress) {
                SOAPAddress soap = (SOAPAddress) elem;
                url = soap.getLocationURI();
            }
        }
        return url;
    }

    private String getDescription(Element e) {
        return e.getFirstChild().getNodeValue();
    }

    private String getKey(BulkResponse br)
        throws WSServiceException, JAXRException {
        String keyStr = null;
        Collection exceptions = br.getExceptions();
        Key key = null;
        if (exceptions == null) {
            // save OK
            Collection keys = br.getCollection();
            Iterator keyIter = keys.iterator();
            if (keyIter.hasNext()) {
                // we have 1 key
                key = (Key) keyIter.next();
                keyStr = key.getId();
            } else {
                // no key
                // i18n RegistryWSDLHandler.getKey.noKeyReturned
                String err = i18n.getMessage("RegistryWSDLHandler.getKey.noKeyReturned");
                logger.log(BasicLevel.ERROR, err);
                throw new WSServiceException(err);
            }
        } else {

            // Exceptions in Server Side

            // i18n RegistryWSDLHandler.getKey.serverSideExceptions
            String err = i18n.getMessage("RegistryWSDLHandler.getKey.serverSideExceptions");

            // Get Server Side Cause
            Iterator exIter = exceptions.iterator();
            Exception cause = null;
            if (exIter.hasNext()) {
                // we have 1 Exception
                cause = (RegistryException) exIter.next();
            }
            logger.log(BasicLevel.ERROR, err);
            if (cause == null) {
                throw new WSServiceException(err);
            } else {
                throw new WSServiceException(err, cause);
            }
        }

        return keyStr;
    }
}

---