ConnectorMessageBeanClient.java

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2013 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package com.sun.enterprise.connectors.inbound;

import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.resource.spi.ActivationSpec;
import javax.resource.spi.ResourceAdapter;
import javax.resource.spi.UnavailableException;
import javax.resource.spi.endpoint.MessageEndpoint;
import javax.resource.spi.endpoint.MessageEndpointFactory;
import javax.transaction.xa.XAResource;

import com.sun.appserv.connectors.internal.api.ConnectorConstants;
import com.sun.appserv.connectors.internal.api.ConnectorRuntimeException;
import com.sun.appserv.connectors.internal.api.ConnectorsUtil;
import com.sun.enterprise.config.serverbeans.Cluster;
import com.sun.enterprise.config.serverbeans.Domain;
import com.sun.enterprise.connectors.ActiveResourceAdapter;
import com.sun.enterprise.connectors.ConnectorRegistry;
import com.sun.enterprise.connectors.ConnectorRuntime;
import com.sun.enterprise.connectors.util.SetMethodAction;
import com.sun.enterprise.deployment.ConnectorDescriptor;
import com.sun.enterprise.deployment.EjbMessageBeanDescriptor;
import com.sun.enterprise.deployment.MessageListener;
import com.sun.enterprise.resource.ResourceHandle;
import com.sun.enterprise.util.i18n.StringManager;
import com.sun.logging.LogDomains;
import org.glassfish.ejb.api.MessageBeanListener;
import org.glassfish.ejb.api.MessageBeanProtocolManager;
import org.glassfish.ejb.spi.MessageBeanClient;
import org.glassfish.internal.api.Globals;
import org.glassfish.server.ServerEnvironmentImpl;

/**
 * Main helper implementation for message-beans associated with
 * a queue. Uses connection consumer for concurrent message
 * delivery.
 *
 * @author Qingqing Ouyang
 */
public final class ConnectorMessageBeanClient
        implements MessageBeanClient, MessageEndpointFactory {

    private String activationName;
    
    private ConnectorRegistry registry_;

    private MessageBeanProtocolManager messageBeanPM_;
    private final EjbMessageBeanDescriptor descriptor_;
    private final BasicResourceAllocator allocator_;
    private Class beanClass_;
    private boolean started_ = false;

    private final int CREATED = 0;
    private final int BLOCKED = 1;
    private final int UNBLOCKED = 2;
    private int myState = CREATED;

    private final long WAIT_TIME = 60000;

    private static final String RA_MID="com.sun.enterprise.connectors.inbound.ramid";

    private StringManager localStrings =
                StringManager.getManager(ConnectorMessageBeanClient.class);

    //unique identify a message-driven bean
    private String beanID_; //appName:modlueID:beanName

    private static final Logger logger =
            LogDomains.getLogger(ConnectorMessageBeanClient.class, LogDomains.RSR_LOGGER);

    /**
     * Creates an instance of <code>ConnectorMessageBeanClient</code>
     *
     * @param descriptor <code>EjbMessageBeanDescriptor</code> object.
     */
    public ConnectorMessageBeanClient(EjbMessageBeanDescriptor descriptor) {
        this.descriptor_ = descriptor;
        allocator_ = new BasicResourceAllocator();

        String appName = descriptor.getApplication().getName();

        String moduleID = descriptor.getEjbBundleDescriptor().getModuleID();

        String beanName = descriptor.getName();

        activationName = null;

        beanID_ = appName + ":" + moduleID + ":" + beanName;

        registry_ = ConnectorRegistry.getInstance();
    }

    /**
     * Gets executed as part of message bean deployment. Creates the
     * <code>ActivationSpec</code> javabean and does endpointfactory
     * activation with the resource adapter. This code also converts
     * all J2EE 1.3 MDB properties to MQ resource adapter activation
     * spec properties, if user doesnt specifies resource adapter
     * module name in sun-ejb-jar.xml of the MDB. This is done using
     * <code>com.sun.enterprise.connector.system.ActiveJmsResourceAdapter
     * </code>
     *
     * @param messageBeanPM <code>MessageBeanProtocolManager</code> object.
     */
    public void setup(MessageBeanProtocolManager messageBeanPM) throws Exception {

        ClassLoader loader = descriptor_.getEjbBundleDescriptor().getClassLoader();

        if (loader == null) {
            loader = Thread.currentThread().getContextClassLoader();
        }

        beanClass_ = loader.loadClass(descriptor_.getEjbClassName());

        messageBeanPM_ = messageBeanPM;

        String resourceAdapterMid = getResourceAdapterMid(descriptor_);

        ActiveInboundResourceAdapter aira = getActiveResourceAdapter(resourceAdapterMid);

        aira.updateMDBRuntimeInfo(descriptor_,
                                       messageBeanPM_.getPoolDescriptor());

        //the resource adapter this MDB client is deployed to
        ResourceAdapter ra = aira.getResourceAdapter();

        if(ra == null){
            String i18nMsg = localStrings.getString("msg-bean-client.ra.class.not.specified", resourceAdapterMid);
            throw new ConnectorRuntimeException(i18nMsg);
        }

        ConnectorDescriptor desc = aira.getDescriptor();

        MessageListener msgListener = getMessageListener(desc);

        String activationSpecClassName = null;
        if (msgListener != null) {
            activationSpecClassName = msgListener.getActivationSpecClass();
        }

        if (activationSpecClassName != null) {
            if (logger.isLoggable(Level.FINEST)) {
                String msg = "ActivationSpecClassName = " + activationSpecClassName;
                logger.log(Level.FINEST, msg);
            }

            try {
                ActivationSpec activationSpec = getActivationSpec(aira, activationSpecClassName);
                activationSpec.setResourceAdapter(ra);

                //at this stage, activation-spec is created, config properties merged with ejb-descriptor.
                //validate activation-spec now
                ConnectorRuntime runtime = ConnectorRuntime.getRuntime();
                runtime.getConnectorBeanValidator().validateJavaBean(activationSpec, resourceAdapterMid);

                aira.validateActivationSpec(activationSpec);

                myState = BLOCKED;

                ra.endpointActivation(this, activationSpec);

                aira.addEndpointFactoryInfo(beanID_,
                        new MessageEndpointFactoryInfo(this, activationSpec));

            } catch (Exception ex) {
                Object args[] = new Object[]{resourceAdapterMid, activationSpecClassName, ex};
                logger.log(Level.WARNING, "endpoint.activation.failure", args);
                throw (Exception) (new Exception()).initCause(ex);
            }
        } else {
            //FIXME  throw some exception here.
            throw new Exception("Unsupported message listener type");
        }
    }

    /**
     * derive the resource-adapter-mid in the following order <br/>
     * a) specified in the glassfish-ejb-jar / sun-ejb-jar descriptor<br/>
     * b) jms-ra message-listener of type javax.jms.MessageListener<br/>
     * c) Check the resource-adapters supporting the message-listener-type and
     * if there is only one use it, otherwise fail.<br/>
     * @param descriptor_ EJB Descriptor
     * @return resource-adapter-mid (resource-adapter-name)
     * @throws ConnectorRuntimeException
     */
    private String getResourceAdapterMid(EjbMessageBeanDescriptor descriptor_) throws ConnectorRuntimeException {
        String resourceAdapterMid = descriptor_.getResourceAdapterMid();
        if (resourceAdapterMid == null) {
            resourceAdapterMid = System.getProperty(RA_MID);
        }

        if (resourceAdapterMid == null) {
            String messageListener = descriptor_.getMessageListenerType();
            //DOL of MDB descriptor has default value as "javax.jms.MessageListener" which
            //will take care of the case when the message-listener-type is not specified in the DD
            if(ConnectorConstants.JMS_MESSAGE_LISTENER.equals(messageListener)){
                resourceAdapterMid = ConnectorRuntime.DEFAULT_JMS_ADAPTER;
                logger.fine("No ra-mid is specified, using default JMS Resource Adapter for message-listener-type " +
                        "["+descriptor_.getMessageListenerType()+"]");
            }else{
                List<String> resourceAdapters =
                        ConnectorRegistry.getInstance().getConnectorsSupportingMessageListener(messageListener);
                if(resourceAdapters.size() == 1){
                    resourceAdapterMid = resourceAdapters.get(0);
                    String message = localStrings.getString("msg-bean-client.defaulting.message-listener.supporting.rar",
                            resourceAdapterMid, messageListener);
                    logger.info(message);
                }else if(resourceAdapters.size()<=0){
                    String message = localStrings.getString("msg-bean-client.could-not-detect-ra-mid",
                            descriptor_.getMessageListenerType() );

                    throw new ConnectorRuntimeException(message);
                }else{
                    String message = localStrings.getString("msg-bean-client.multiple-ras-supporting-message-listener",
                            messageListener);
                    throw new ConnectorRuntimeException(message);
                }
            }
        }
        return resourceAdapterMid;
    }

    private ActivationSpec getActivationSpec(ActiveInboundResourceAdapter aira, String activationSpecClassName)
            throws Exception {
        ClassLoader cl = aira.getClassLoader();
        Class aClass = cl.loadClass(activationSpecClassName);

        if (logger.isLoggable(Level.FINEST)) {
            logger.log(Level.FINEST, "classloader = "
                    + aClass.getClassLoader());
            logger.log(Level.FINEST, "classloader parent = "
                    + aClass.getClassLoader().getParent());
        }

        ActivationSpec activationSpec =
                (ActivationSpec) aClass.newInstance();
        Set props = ConnectorsUtil.getMergedActivationConfigProperties(getDescriptor());

        AccessController.doPrivileged(new SetMethodAction(activationSpec, props));
        return activationSpec;
    }

    private MessageListener getMessageListener(ConnectorDescriptor desc) {
        String msgListenerType = getDescriptor().getMessageListenerType();
        if (msgListenerType == null || "".equals(msgListenerType))
            msgListenerType = "javax.jms.MessageListener";

        Iterator i =
                desc.getInboundResourceAdapter().getMessageListeners().iterator();

        MessageListener msgListener = null;
        while (i.hasNext()) {
            msgListener = (MessageListener) i.next();
            if (msgListenerType.equals(msgListener.getMessageListenerType()))
                break;
        }
        return msgListener;
    }

    private ActiveInboundResourceAdapter getActiveResourceAdapter(String resourceAdapterMid) throws Exception {
        Object activeRar = registry_.getActiveResourceAdapter(resourceAdapterMid);

        // Except system-rars, all other rars are loaded eagerly.
        // Check whether the rar is a system-rar.
        // (as of now, jms-ra is the only inbound system-rar)  
        if (activeRar == null && ConnectorsUtil.belongsToSystemRA(resourceAdapterMid)) {
            ConnectorRuntime crt = ConnectorRuntime.getRuntime();
            crt.loadDeferredResourceAdapter(resourceAdapterMid);
            activeRar = registry_.getActiveResourceAdapter(resourceAdapterMid);
        }

        if (activeRar == null) {
            String msg = "Resource adapter " + resourceAdapterMid + " is not deployed";
            throw new ConnectorRuntimeException(msg);
        }

        if (!(activeRar instanceof ActiveInboundResourceAdapter)) {
            throw new Exception("Resource Adapter selected doesn't support Inbound");
        }
        return (ActiveInboundResourceAdapter) activeRar;
    }

    /**
     * Marks the completion of MDB deployment. Unblocks the createEndPoint
     * method call.
     *
     * @throws Exception
     */
    public void start() throws Exception {
        logger.logp(Level.FINEST,
                "ConnectorMessageBeanClient", "start", "called...");
        started_ = true;
        synchronized (this) {
            myState = UNBLOCKED;
            notifyAll();
        }
    }

    /**
     * Does endpoint deactivation with the resource adapter.
     * Also remove sthe <code>MessageEndpointFactoryInfo</code>
     * from house keeping.
     */
    public void close() {
        logger.logp(Level.FINEST,
                "ConnectorMessageBeanClient", "close", "called...");

        started_ = false; //no longer available


        String resourceAdapterMid = null;
        try {
            resourceAdapterMid = getResourceAdapterMid(descriptor_);
        } catch (ConnectorRuntimeException e) {
            String message = localStrings.getString("msg-bean-client.could-not-derive-ra-mid", descriptor_.getName());
            logger.log(Level.WARNING, message, e);
        }

        ActiveResourceAdapter activeRar =
                registry_.getActiveResourceAdapter(resourceAdapterMid);

        if (activeRar instanceof ActiveInboundResourceAdapter) { //in case the RA is already undeployed
            ActiveInboundResourceAdapter rar = (ActiveInboundResourceAdapter) activeRar;
            MessageEndpointFactoryInfo info = rar.getEndpointFactoryInfo(beanID_);

            if (info != null) {
                rar.getResourceAdapter().endpointDeactivation(
                        info.getEndpointFactory(), info.getActivationSpec());

                rar.removeEndpointFactoryInfo(beanID_);
            } else {
                logger.log(Level.FINE, "Not de-activating the end point, since it is not activated");
            }
        }
    }

    private EjbMessageBeanDescriptor getDescriptor() {
        return descriptor_;
    }

    /**
     * Creates a MessageEndpoint. This method gets blocked either until start()
     * is called or until one minute. This is the time for completion
     * of MDB deployment.
     * <p/>
     * Internally this method creates a message bean listener from the MDB
     * container and a proxy object fo delivering messages.
     *
     * @return <code>MessageEndpoint</code> object.
     * @throws <code>UnavailableException</code>
     *          In case of any failure. This
     *          should change.
     */
    public MessageEndpoint
    createEndpoint(XAResource xa) throws UnavailableException {
        // This is a temporary workaround for blocking the the create enpoint
        // until the deployment completes.  One thread would wait for maximum a
        // a minute.
        return createEndpoint(xa, WAIT_TIME);
    }

    /**
     * Checks whether the message delivery is transacted for the method.
     *
     * @return true or false.
     */
    public boolean isDeliveryTransacted(Method method) {
        return messageBeanPM_.isDeliveryTransacted(method);
    }

    /**
     * @return beanID of the message bean client
     */
    public String toString() {
        return beanID_;
    }

    /**
     * {@inheritDoc}
     */
    public MessageEndpoint createEndpoint(XAResource xaResource, long timeout) throws UnavailableException {
        synchronized (this) {
            while (myState == BLOCKED) {
                try {
                    wait(timeout);
                } catch (Exception e) {
                    // This exception should not affect the functionality.
                } finally {

                    // Once the first thread comes out of wait, block is
                    // is removed. This makes sure that the time for which the
                    // the block remains is limited. Max 2x6000.
                    myState = UNBLOCKED;
                }
            }
        }

        if (!started_) {
            logger.log(Level.WARNING, "endpointfactory.unavailable");
            throw new UnavailableException(
                    "EndpointFactory is currently not available");
        }

        MessageEndpoint endpoint = null;
        try {
            ResourceHandle resourceHandle = allocator_.createResource(xaResource);

            MessageBeanListener listener =
                    messageBeanPM_.createMessageBeanListener(resourceHandle);

            MessageEndpointInvocationHandler handler =
                    new MessageEndpointInvocationHandler(listener, messageBeanPM_);
            endpoint = (MessageEndpoint) messageBeanPM_.createMessageBeanProxy(handler);
        } catch (Exception ex) {
            throw (UnavailableException)
                    (new UnavailableException()).initCause(ex);
        }
        return endpoint;
    }
    /**
     * {@inheritDoc}
     * @Override
     */
    public String getActivationName(){
      if(activationName == null){
        
        String appName = descriptor_.getApplication().getName();
        String moduleID = descriptor_.getEjbBundleDescriptor().getModuleID();
        int pound = moduleID.indexOf("#");
        if(pound>=0){
            // the module ID is in the format: appName#ejbName.jar
            // remove the appName part since it is duplicated
            moduleID = moduleID.substring(pound+1);
        }
        String mdbClassName = descriptor_.getEjbClassName();

        ServerEnvironmentImpl env = Globals.get(ServerEnvironmentImpl.class);
        String instanceName = env.getInstanceName();
        
        Domain domain = Globals.get(Domain.class);
        String domainName = domain.getName();
        Cluster cluster = domain.getServerNamed(instanceName).getCluster();

        String clusterName=null;
        if(cluster!=null){
          // this application is deployed in a cluster
          clusterName = cluster.getName();
        }
        
        if(clusterName!=null){
            // this application is deployed in a cluster
            activationName = combineString(domainName, clusterName, appName, moduleID, mdbClassName);
            
        }else{
            // this application is deployed in a stand-alone server instance.
            activationName = combineString(domainName, instanceName, appName, moduleID, mdbClassName);
        }
      }
      return activationName;
    }

//    /**
//     * Compute the activation name according to the names of domain, cluster, instance,
//     * application, module and MDB. 
//     * 
//     * Check whether the combination of the activation name and instance name
//     * is longer than 128 characters. If yes, then compact the activation name.
//     * 
//     */
//    public String computeActivationName(String domainName, String clusterName, 
//            String instanceName, String appName, String moduleID, String mdbName){
//        
//        if(clusterName!=null){
//            // this application is deployed in a cluster
//            String fullActivationName = combineString(domainName, clusterName, appName, moduleID, mdbName);
//            // Check if the combination of activation name and instance name is longer
//            // than 128 characters. If yes, then compact it.
//            // BootstrapContextImpl.getInstanceName() will return at most 24 characters
//            int instanceLenth = Math.min(instanceName.length(), BootstrapContextImpl.MAX_INSTANCE_LENGTH);
//            if((fullActivationName.length()+instanceLenth)>127){
//                String compactedName = compactActivationName(fullActivationName, domainName, 
//                        clusterName, instanceName, appName, moduleID, mdbName);
//                logger.log(Level.INFO, "The original activation is: "+fullActivationName
//                        +", because it is too long, compact it to: "+compactedName);
//                return compactedName;
//            }else{
//                return fullActivationName;
//            }
//
//        }else{
//            // this application is deployed in a stand-alone server instance.
//            String fullActivationName = combineString(domainName, instanceName, appName, moduleID, mdbName);
//            if(fullActivationName.length()>128){
//                String compactedName = compactActivationName(fullActivationName, domainName, 
//                        instanceName, appName, moduleID, mdbName);
//                logger.log(Level.INFO, "The original activation is: "+fullActivationName
//                        +", because it is too long, compact it to: "+compactedName);
//                return compactedName;
//            }else{
//                return fullActivationName;
//            }
//        }
//    }
//    /* 
//     * This method is called when the server is a clustered instance.
//     * 
//     * Compact the activationName so that the combination of it and instance name
//     * is no longer than 128 characters. The combination of activation name and
//     * instance name is of the format:
//     *   domain_cluster_application_module_mdb_MD5_instance
//     * 
//     * The basic idea is that: 
//     *   1. Add the MD5 digest of the original activationName. This can ensure the 
//     *      (almost) uniqueness of the activation name. The new activation name
//     *      will be of the format: domain_cluster_application_module_mdb_MD5 
//     *   2. The instance name is no longer than 24 characters, the method 
//     *      BootstrapContextImpl.getInstanceName() will truncate instance name 
//     *      if need.
//     *   3. Truncate the longest element among the domain, instance, application,
//     *      module and mdb names, until the combination of new activation 
//     *      name and instance name is no longer than 128 characters.
//     *      
//     */ 
//    private String compactActivationName(String originalActivationName, 
//            String domainName, String clusterName, String instanceName, 
//            String appName, String moduleID, String mdbName){
//
//        String[] names = new String[5];
//        names[0] = domainName;
//        names[1] = clusterName;
//        names[2] = appName;
//        names[3] = moduleID;
//        names[4] = mdbName;
//        
//        // the instanceName is longer than 24 characters.
//        int instanceLenth = Math.min(instanceName.length(), BootstrapContextImpl.MAX_INSTANCE_LENGTH);
//
//        // the MD5 digestion has 32 characters, the remaining capacity 
//        // is 128-(32 + size_of_instanceName + 2).
//        int maxTotal = 94 - instanceLenth;
//        StringBuilder compacted = compactString(names, maxTotal);
//
//        String digest = computeMD5(originalActivationName);
//        compacted.append("_").append(digest);
//        return compacted.toString();
//    }
//
//    /* 
//     * This method is called when the server is a stand-alone instance.
//     * 
//     * Compact the activationName so that it is no longer than 128 characters.
//     * The new activation name is of the format:
//     *   domain_instance_application_module_mdb_MD5
//     * 
//     * The basic idea is that: 
//     *   1. Add the MD5 digest of the original activationName which can ensure the 
//     *      (almost) uniqueness of the activation. 
//     *   2. Truncate the longest element among the domain, instance, application,
//     *      module and mdb names, until the combination of them and MD5 
//     *      digestion is no longer than 128 characters.
//     *      
//     */ 
//    private String compactActivationName(String originalActivationName, String domainName, 
//            String instanceName, String appName, String moduleID, String mdbName){
//
//        String[] names = new String[5];
//        names[0] = domainName;
//        names[1] = instanceName;
//        names[2] = appName;
//        names[3] = moduleID;
//        names[4] = mdbName;
//        // the MD5 digestion has 32 characters, the remaining capacity is 
//        // (128-32-1) = 95 characters. 
//        StringBuilder compacted = compactString(names, 95);
//
//        String digest = computeMD5(originalActivationName);
//        compacted.append("_").append(digest);
//        return compacted.toString();
//    }
//    
//    /* 
//     * Compact the given Strings so that their total size is no longer than
//     * maxTotal characters. 
//     *  
//     * Find the longest string, truncate its first half part, because in the most 
//     * cases, the last characters are more significant. Do this operation until 
//     * the total size is no longer than maxTotal:
//     * 
//     */ 
//    private StringBuilder compactString(String[] texts, int maxTotal){
//        int arrayLengh = texts.length;
//
//        int total=0;
//        for(int i=0; i<arrayLengh; i++ ){
//            total+=texts[i].length();
//        }
//        // add the size of delimiter characters between the strings
//        total+=arrayLengh-1;
//        
//        while(total>maxTotal){
//            // find the longest item
//            int longestLength = 0;
//            int longestIndex = 0;
//            for(int i=0; i<arrayLengh; i++ ){
//                if(texts[i].length()>longestLength){
//                    longestLength = texts[i].length();
//                    longestIndex=i;
//                }
//            }
//            // truncate the first half part of the string
//            // because it seems that the last characters are more significant. 
//            int trunctionSize= Math.min(longestLength>>1, total-maxTotal);
//            texts[longestIndex]=texts[longestIndex].substring(trunctionSize, longestLength);
//
//            // re-compute the total size
//            total -= trunctionSize;
//        }
//
//        StringBuilder sb = new StringBuilder(128);
//        sb.append(texts[0]);
//        for(int i=1; i<arrayLengh; i++ ){
//            sb.append("_").append(texts[i]);
//        }
//        return sb;
//    }
    
    private String combineString(String... names) {
        StringBuilder sb = new StringBuilder(128);
        sb.append(names[0]);
        for(int i=1; i<names.length; i++){
            sb.append("_").append(names[i]);
        }
        return sb.toString();
    }

    @Override
    public Class<?> getEndpointClass() {
        return beanClass_;
    }

//    private String computeMD5(String message){
//        StringBuilder sb = new StringBuilder(32);
//        try {
//            MessageDigest md5 = MessageDigest.getInstance("MD5");
//            md5.update(message.getBytes());
//            byte[] digest = md5.digest();
//
//            for(int i=0; i<digest.length; i++){
//                sb.append(Integer.toHexString((digest[i]>>4)&0x0F));
//                sb.append(Integer.toHexString(digest[i]&0x0F));
//            }
//            
//        } catch (NoSuchAlgorithmException ignore) {
//            ignore.printStackTrace();
//        }
//
//        return sb.toString();
//    }
}