BeanDesc.java

package org.objectweb.jonas_ejb.deployment.api;

import java.lang.reflect.Modifier;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;

import org.omg.CSI.ITTAbsent;
import org.omg.CSI.ITTAnonymous;
import org.omg.CSI.ITTDistinguishedName;
import org.omg.CSI.ITTPrincipalName;
import org.omg.CSI.ITTX509CertChain;
import org.omg.CSIIOP.Confidentiality;
import org.omg.CSIIOP.EstablishTrustInClient;
import org.omg.CSIIOP.EstablishTrustInTarget;
import org.omg.CSIIOP.IdentityAssertion;
import org.omg.CSIIOP.Integrity;

import org.objectweb.carol.util.csiv2.SasComponent;
import org.objectweb.carol.util.csiv2.struct.AsStruct;
import org.objectweb.carol.util.csiv2.struct.SasStruct;
import org.objectweb.carol.util.csiv2.struct.TransportStruct;

import org.objectweb.jonas_ejb.container.BeanFactory;
import org.objectweb.jonas_ejb.container.TraceEjb;
import org.objectweb.jonas_ejb.deployment.xml.AsContextMapping;
import org.objectweb.jonas_ejb.deployment.xml.AssemblyDescriptor;
import org.objectweb.jonas_ejb.deployment.xml.CommonEjb;
import org.objectweb.jonas_ejb.deployment.xml.ContainerTransaction;
import org.objectweb.jonas_ejb.deployment.xml.IorSecurityConfigMapping;
import org.objectweb.jonas_ejb.deployment.xml.JonasCommonEjb;
import org.objectweb.jonas_ejb.deployment.xml.Method;
import org.objectweb.jonas_ejb.deployment.xml.MethodPermission;
import org.objectweb.jonas_ejb.deployment.xml.SasContextMapping;
import org.objectweb.jonas_ejb.deployment.xml.TransportConfigMapping;
import org.objectweb.jonas_ejb.lib.BeanNaming;
import org.objectweb.jonas_ejb.lib.JavaType;

import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.jonas_lib.deployment.api.EjbLocalRefDesc;
import org.objectweb.jonas_lib.deployment.api.EjbRefDesc;
import org.objectweb.jonas_lib.deployment.api.EnvEntryDesc;
import org.objectweb.jonas_lib.deployment.api.JndiEnvRefsGroupDesc;
import org.objectweb.jonas_lib.deployment.api.MessageDestinationRefDesc;
import org.objectweb.jonas_lib.deployment.api.ResourceEnvRefDesc;
import org.objectweb.jonas_lib.deployment.api.ResourceRefDesc;
import org.objectweb.jonas_lib.deployment.api.SecurityRoleRefDesc;
import org.objectweb.jonas_lib.deployment.xml.JLinkedList;
import org.objectweb.jonas_lib.deployment.xml.RunAs;
import org.objectweb.jonas_lib.deployment.xml.SecurityRole;
import org.objectweb.jonas_lib.deployment.xml.SecurityRoleRef;

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

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

public abstract class BeanDesc extends JndiEnvRefsGroupDesc {

    protected static final int BEAN_TRANSACTION_TYPE = 1;

    protected static final int CONTAINER_TRANSACTION_TYPE = 2;

    protected static final String[] TRANS = {null, "BEAN_TRANSACTION_TYPE", "CONTAINER_TRANSACTION_TYPE"};

    private static final String ejb10PropertiesPrefix = "ejb10-properties/";

    private static final String REMOTEDEFAULTSUFFIX = "Home";

    private static final String LOCALDEFAULTSUFFIX = "_L";

    protected String ejbName = null;

    protected String jndiName = null;

    protected String jndiLocalName = null;

    protected Class home = null;

    protected Class remote = null;

    protected Class localhome = null;

    protected Class local = null;

    protected Class ejbClass = null;

    protected Properties ejb10EnvProps = new Properties();

    protected Logger logger = null;

    private ArrayList methodDesc = new ArrayList();

    private HashMap methodDescMap = new HashMap();

    protected List securityRoleRefDescList = null;

    protected DeploymentDesc deploymentDesc = null;

    private String fullWrpRemoteName = null;

    private String wrpRemoteName = null;

    private String fullWrpHomeName = null;

    private String wrpHomeName = null;

    private String fullWrpLocalName = null;

    private String wrpLocalName = null;

    private String fullWrpLocalHomeName = null;

    private String wrpLocalHomeName = null;

    private String fullWrpHandleName = null;

    private String wrpHandleName = null;

    protected String fullDerivedBeanName = null;

    protected String derivedBeanName = null;

    private String runAsRole = null;

    private String runAsPrincipalName = null;

    protected int poolMin = 0;

    protected int cacheMax = 0;

    private SasComponent sasComponent = null;

    protected int timerTxAttribute = MethodDesc.TX_REQUIRES_NEW; // default

    protected String ejbTimeoutSignature;

    protected BeanFactory bf = null;

    public BeanDesc(ClassLoader classLoader, CommonEjb ejb, JonasCommonEjb jonasEjb, AssemblyDescriptor asd,
            JLinkedList jMDRList, String fileName) throws DeploymentDescException {

        super(classLoader, ejb, jonasEjb, fileName);
        securityRoleRefDescList = new LinkedList();
        if (ejb.getEjbName() != null) {
            ejbName = ejb.getEjbName();
        } else {
            ejbName = null;
        }

        // If no value given specifically, we use ejbName+Home as JNDI name.
        if (jonasEjb.getJndiName() != null) {
            jndiName = jonasEjb.getJndiName();
        } else {
            jndiName = ejbName + REMOTEDEFAULTSUFFIX;
        }
        // If no value given specifically, we use jndiName+_L as JNDI local
        // name.
        if (jonasEjb.getJndiLocalName() != null) {
            jndiLocalName = jonasEjb.getJndiLocalName();
        } else {
            jndiLocalName = jndiName + LOCALDEFAULTSUFFIX;
        }

        // classes
        // --------------------------------------------------
        if (ejb.getHome() != null) {
            try {
                this.home = classLoader.loadClass(ejb.getHome());
                // check home extends javax.ejb.EJBHome
                if (!javax.ejb.EJBHome.class.isAssignableFrom(this.home)) {
                    throw new DeploymentDescException("Home class '" + ejb.getHome()
                            + "' doesn't not extends javax.ejb.EJBHome");
                }
            } catch (ClassNotFoundException e) {
                throw new DeploymentDescException("Home class not found for bean " + ejbName, e);
            }
        }

        if (ejb.getRemote() != null) {
            try {
                this.remote = classLoader.loadClass(ejb.getRemote());
                // check remote extends javax.ejb.EJBObject
                if (!javax.ejb.EJBObject.class.isAssignableFrom(this.remote)) {
                    throw new DeploymentDescException("Remote class '" + ejb.getRemote()
                            + "' doesn't not extends javax.ejb.EJBObject");
                }
            } catch (ClassNotFoundException e) {
                throw new DeploymentDescException("Remote class not found for bean " + ejbName, e);
            }
        }

        String localhomename = ejb.getLocalHome();
        // Note: Should do this only if bean is implied in a relation.
        if (localhomename == null && this instanceof EntityCmp2Desc) {
            localhomename = "javax.ejb.EJBLocalHome";
        }
        if (localhomename != null) {
            try {
                this.localhome = classLoader.loadClass(localhomename);
                // check localhome extends javax.ejb.EJBLocalHome
                if (!javax.ejb.EJBLocalHome.class.isAssignableFrom(this.localhome)) {
                    throw new DeploymentDescException("LocalHome class '" + localhomename
                            + "' doesn't not extends javax.ejb.EJBLocalHome");
                }
            } catch (ClassNotFoundException e) {
                throw new DeploymentDescException("LocalHome class not found for bean " + ejbName, e);
            }
        }

        String localname = ejb.getLocal();
        // Note: Should do this only if bean is implied in a relation.
        if (localname == null && this instanceof EntityCmp2Desc) {
            localname = "javax.ejb.EJBLocalObject";
        }
        if (localname != null) {
            try {
                this.local = classLoader.loadClass(localname);
                // check local extends javax.ejb.EJBLocalObject
                if (!javax.ejb.EJBLocalObject.class.isAssignableFrom(this.local)) {
                    throw new DeploymentDescException("Local class '" + localname
                            + "' doesn't not extends javax.ejb.EJBLocalObject");
                }
            } catch (ClassNotFoundException e) {
                throw new DeploymentDescException("Local class not found for bean " + ejbName, e);
            }
        }

        // permit to load service-endpoint class
        loadExtraClasses(ejb, classLoader);

        try {
            this.ejbClass = classLoader.loadClass(ejb.getEjbClass());
            // check ejb-class extends javax.ejb.EnterpriseBean
            if (!javax.ejb.EnterpriseBean.class.isAssignableFrom(this.ejbClass)) {
                throw new DeploymentDescException("Ejb class '" + ejb.getEjbClass()
                        + "' doesn't not extends javax.ejb.EnterpriseBean");
            }
        } catch (ClassNotFoundException e) {
            throw new DeploymentDescException("Ejb class not found for bean " + ejbName, e);
        }

        // Set EJB 1.0 Environment properties from env entries
        EnvEntryDesc[] envt = getEnvEntryDesc();
        for (int i = 0; i < envt.length; i++) {
            if (envt[i].getName().startsWith(ejb10PropertiesPrefix)) {
                String newName = envt[i].getName().substring(ejb10PropertiesPrefix.length());
                String value = new String();
                if (envt[i].hasValue()) {
                    value = envt[i].getValue().toString();
                }
                ejb10EnvProps.put(newName, value);
            }
        }

        // run-as
        if (ejb.getSecurityIdentity() != null) {
            RunAs runAsElem = ejb.getSecurityIdentity().getRunAs();
            if (runAsElem != null) {
                String roleName = runAsElem.getRoleName();
                if (roleName != null) {
                    runAsRole = roleName;
                    boolean runAsRoleFound = false;
                    for (Iterator j = asd.getSecurityRoleList().iterator(); j.hasNext();) {
                        SecurityRole securityRole = (SecurityRole) j.next();
                        // role name of a security-role element defined in the
                        // assembly descriptor
                        String r = securityRole.getRoleName();
                        if (r.equals(runAsRole)) {
                            runAsRoleFound = true;
                        }
                    }
                    //if there are no matching run-as and security-role
                    if (!runAsRoleFound) {
                        throw new DeploymentDescException("There is no security-role defined for the run-as role: "
                                + runAsRole);
                    }
                }
                // Run-as principal name
                runAsPrincipalName = jonasEjb.getRunAsPrincipalName();
                // if no principal name set in JOnAS DD, set it to run-as role
                if (runAsPrincipalName == null) {
                    runAsPrincipalName = runAsRole;
                }
            }
        }

        // populate array with all methods
        try {
            java.lang.reflect.Method[] m;
            int beginIdx = methodDesc.size();
            int len = 0;
            if ((this.home != null) && (this.remote != null)) {
                // session bean or entity bean with remote interface
                m = this.home.getMethods();
                for (int i = 0; i < m.length; i++) {
                    if (!m[i].getDeclaringClass().equals(javax.ejb.EJBHome.class)
                        || m[i].getName().equals("remove")) {
                        addMethodDesc(m[i]);
                        len++;
                        // check RemoteException is thrown
                        checkRemoteException(m[i], true);
                        /*
                         * // arguments and return types must be valid types for
                         * RMI if
                         * (!m[i].getDeclaringClass().equals(javax.ejb.EJBHome.class) &&
                         * !m[i].getName().equals("findByPrimaryKey")) {
                         * checkValidTypesForRmi(m[i]); }
                         */
                    }
                }

                m = this.remote.getMethods();
                for (int i = 0; i < m.length; i++) {
                    if (!m[i].getDeclaringClass().equals(javax.ejb.EJBObject.class)
                        || m[i].getName().equals("remove")) {
                        addMethodDesc(m[i]);
                        len++;
                        // check RemoteException is thrown
                        checkRemoteException(m[i], true);
                        /*
                         * // arguments and return types must be valid for RMI
                         * if
                         * (!m[i].getDeclaringClass().equals(javax.ejb.EJBObject.class)) {
                         * checkValidTypesForRmi(m[i]); }
                         */
                    }
                }
            }
            if ((this.localhome != null) && (this.local != null)) {
                // session bean or entity bean with local interface
                m = this.localhome.getMethods();
                for (int i = 0; i < m.length; i++) {
                    if (!m[i].getDeclaringClass().equals(javax.ejb.EJBLocalHome.class)
                            || m[i].getName().equals("remove")) {
                        addMethodDesc(m[i]);
                        len++;
                        // check RemoteException is NOT thrown
                        checkRemoteException(m[i], false);
                    }
                }
                m = this.local.getMethods();
                for (int i = 0; i < m.length; i++) {
                    if (!m[i].getDeclaringClass().equals(javax.ejb.EJBLocalObject.class)
                        || m[i].getName().equals("remove")) {
                        addMethodDesc(m[i]);
                        len++;
                        // check RemoteException is NOT thrown
                        checkRemoteException(m[i], false);
                    }
                }
            }
            if (this.home == null && this.localhome == null) {

                if (ejb.getMessagingType() != null) {
                    // message driven bean & endpoints
                    String msgType = ejb.getMessagingType();
                    try {
                        m = classLoader.loadClass(msgType).getMethods();
                        for (int i = 0; i < m.length; i++) {
                            addMethodDesc(m[i]);
                            len++;
                        }
                    } catch (Exception ex) {
                        throw new DeploymentDescException("Cannot load messaging type class (" + msgType + ") for "
                                + ejbName);
                    }
                }
                // (web)service-endpoints may have no home or local-home too !!
            }

            if (javax.ejb.EntityBean.class.isAssignableFrom(this.ejbClass)) {
                // ejbSelect methods
                m = this.ejbClass.getMethods();
                for (int i = 0; i < m.length; i++) {
                    if (m[i].getName().startsWith("ejbSelect") && Modifier.isAbstract(m[i].getModifiers())) {
                        addMethodDesc(m[i]);
                        len++;
                    }
                }
            }

            if (javax.ejb.TimedObject.class.isAssignableFrom(this.ejbClass)) {
                try {
                    java.lang.reflect.Method timeout = this.ejbClass.getMethod("ejbTimeout",
                            new Class[]{javax.ejb.Timer.class});
                    addMethodDesc(timeout);
                    len++;
                } catch (NoSuchMethodException e) {
                    throw new DeploymentDescException("ejbTimeout not implemented in " + ejbName);
                }
            }

            len = addEJBMethodDesc(len);
            orderMethodDesc(methodDesc, beginIdx, len);
        } catch (SecurityException e) {
            throw new DeploymentDescException("Cannot use java reflection on " + ejbName);
        }

        // populate HashMap with all security role references
        // for each security-role-ref of the bean
        if (ejb.getSecurityRoleRefList() != null) {
            for (Iterator i = ejb.getSecurityRoleRefList().iterator(); i.hasNext();) {
                SecurityRoleRef sRoleRef = (SecurityRoleRef) i.next();
                // test if the assembly-descriptor element exists
                if (asd == null) {
                    throw new DeploymentDescException(
                            "No assembly-descriptor element (and security-role elements) whereas security-role-ref element(s) are defined");
                } else {
                    // test if the assembly-descriptor element contains
                    // security-role elements
                    if (asd.getSecurityRoleList().isEmpty()) {
                        throw new DeploymentDescException(
                                "No security-role elements defined in the assembly-descriptor element  whereas security-role-ref element(s) are defined");
                    }
                }
                // test if the role-link element of the security-role-ref
                // element exists
                if (sRoleRef.getRoleLink() == null) {
                    throw new DeploymentDescException(
                            "No role-link element in a security-role-ref element with role-name element : "
                                    + sRoleRef.getRoleName());
                }
                String roleLink = sRoleRef.getRoleLink();
                // correspond to role-name element in security-role-ref element
                String roleRefName = sRoleRef.getRoleName();
                // to know if there are corresponding roleLink and roleRefName
                boolean correspondingRoles = false;
                for (Iterator j = asd.getSecurityRoleList().iterator(); j.hasNext();) {
                    SecurityRole securityRole = (SecurityRole) j.next();
                    // role name of a security-role element defined in the
                    // assembly descriptor
                    String roleName = securityRole.getRoleName();
                    if (roleName.equals(roleLink)) {
                        securityRoleRefDescList.add(new SecurityRoleRefDesc(ejbName, sRoleRef, true));
                        correspondingRoles = true;
                    }
                }
                //if there are no matching roleLink and roleName
                if (!correspondingRoles) {
                    throw new DeploymentDescException(
                            "No corresponding role-name in a security-role element for role-link : " + roleLink);
                }
            }
        }

        // check if there are corresponding role-name element in security-role
        // and method-permission element of the Assembly Descriptor
        if (asd != null) {
            verifyRoleName(asd);
            // set method descriptor values for method permissions
            for (Iterator i = asd.getMethodPermissionList().iterator(); i.hasNext();) {
                MethodPermission methodPermission = (MethodPermission) i.next();
                for (Iterator j = methodPermission.getMethodList().iterator(); j.hasNext();) {
                    Method m = ((Method) j.next());
                    // check method applies to current bean
                    if (!m.getEjbName().equals(ejbName)) {
                        continue;
                    }
                    // selection of interface home/remote
                    Class pClass = null;
                    if (m.getMethodIntf() != null) {
                        pClass = getParentClass(m.getMethodIntf());
                    }
                    for (int k = 0; k < methodDesc.size(); k++) {
                        MethodDesc md = (MethodDesc) methodDesc.get(k);
                        int matchStatus = md.matchPattern(pClass, m.getMethodName(), m.getMethodParams());
                        for (Iterator l = methodPermission.getRoleNameList().iterator(); l.hasNext();) {
                            String roleName = (String) l.next();
                            // Add only if it greater than APPLY_TO_NOTHING
                            if (matchStatus > MethodDesc.APPLY_TO_NOTHING) {
                                md.addRoleName(roleName);
                            }
                        }
                    }
                }
            }
        }

        // Set excluded method
        if (asd != null && asd.getExcludeList() != null) {
            // For each excluded method, find a methodDesc corresponding to this excluded method
            for (Iterator i = asd.getExcludeList().getMethodList().iterator(); i.hasNext();) {
                Method m = (Method) i.next();
                // check method applies to current bean
                if (!m.getEjbName().equals(ejbName)) {
                    continue;
                }
                // selection of interface home/remote
                Class pClass = null;
                if (m.getMethodIntf() != null) {
                    pClass = getParentClass(m.getMethodIntf());
                }
                // Find methodDesc with matching pattern of excluded method
                for (int k = 0; k < methodDesc.size(); k++) {
                    MethodDesc md = (MethodDesc) methodDesc.get(k);
                    int matchStatus = md.matchPattern(pClass, m.getMethodName(), m.getMethodParams());
                    // Add only if it greater than APPLY_TO_NOTHING
                    if (matchStatus > MethodDesc.APPLY_TO_NOTHING) {
                        md.setExcluded(true);
                    }
                }
            }
        }

        // set method descriptor values for container transactions
        if (asd != null) {
            // Loop on ContainerTransaction list
            Iterator i = asd.getContainerTransactionList().iterator();
            while (i.hasNext()) {
                ContainerTransaction cotr = (ContainerTransaction) i.next();
                // Loop on Method list
                Iterator j = cotr.getMethodList().iterator();
                while (j.hasNext()) {
                    Method m = (Method) j.next();
                    // check method applies to current bean
                    if (!m.getEjbName().equals(ejbName)) {
                        continue;
                    }

                    // selection of interface home/remote
                    Class pClass = null;
                    if (m.getMethodIntf() != null) {
                        pClass = getParentClass(m.getMethodIntf());
                    }

                    // loop on methods in the array
                    boolean found = false;
                    for (int k = 0; k < methodDesc.size(); k++) {
                        MethodDesc md = (MethodDesc) methodDesc.get(k);
                        int matchStatus = md.matchPattern(pClass, m.getMethodName(), m.getMethodParams());
                        if (matchStatus != MethodDesc.APPLY_TO_NOTHING) {
                            found = true;
                        }
                        // set if proper level of assignation
                        String transAttribute = null;
                        if (cotr.getTransAttribute() != null) {
                            transAttribute = cotr.getTransAttribute();
                        }
                        md.overwriteTxAttribute(transAttribute, matchStatus);
                    }
                    if (!found) {
                        // The method defined via the <method> element is not a
                        // declared method
                        TraceEjb.dd.log(BasicLevel.WARN, "Invalid container-transaction: method '"
                                + MethodDesc.methodElementToString(m) + "' not declared in bean " + ejbName);
                    }
                }
            }
        }

        String packageName = "";
        String ejbIdentifier = getIdentifier();

        if (getRemoteClass() != null) {
            packageName = BeanNaming.getPackageName(getRemoteClass().getName());
            wrpRemoteName = new String("JOnAS" + ejbIdentifier + "Remote");
            wrpHandleName = new String("JOnAS" + ejbIdentifier + "Handle");
            fullWrpRemoteName = BeanNaming.getClassName(packageName, wrpRemoteName);
            fullWrpHandleName = BeanNaming.getClassName(packageName, wrpHandleName);
        }

        if (getLocalClass() != null) {
            packageName = BeanNaming.getPackageName(getLocalClass().getName());
            wrpLocalName = new String("JOnAS" + ejbIdentifier + "Local");
            fullWrpLocalName = BeanNaming.getClassName(packageName, wrpLocalName);
        }

        if (getHomeClass() != null) {
            packageName = BeanNaming.getPackageName(getHomeClass().getName());
            wrpHomeName = new String("JOnAS" + ejbIdentifier + "Home");
            fullWrpHomeName = BeanNaming.getClassName(packageName, wrpHomeName);
        }

        if (getLocalHomeClass() != null) {
            packageName = BeanNaming.getPackageName(getLocalHomeClass().getName());
            wrpLocalHomeName = new String("JOnAS" + ejbIdentifier + "LocalHome");
            fullWrpLocalHomeName = BeanNaming.getClassName(packageName, wrpLocalHomeName);
        }

        fullDerivedBeanName = getEjbClass().getName();
        derivedBeanName = BeanNaming.getBaseName(getEjbClass().getName());

        IorSecurityConfigMapping iorSecurityConfigMapping = jonasEjb.getIorSecurityConfig();
        if (iorSecurityConfigMapping != null) {
            processIorSecurityConfig(iorSecurityConfigMapping);
        }

    }

    protected void loadExtraClasses(CommonEjb ce, ClassLoader loader) throws DeploymentDescException {
        // do nothing by default
    }

    protected int addEJBMethodDesc(int len) throws DeploymentDescException {
        return len;
    }

    protected Class getParentClass(String intfType) throws DeploymentDescException {
        Class pClass = null;
        if (intfType.equals("Home")) {
            pClass = javax.ejb.EJBHome.class;
        } else if (intfType.equals("Remote")) {
            pClass = javax.ejb.EJBObject.class;
        } else if (intfType.equals("LocalHome")) {
            pClass = javax.ejb.EJBLocalHome.class;
        } else if (intfType.equals("Local")) {
            pClass = javax.ejb.EJBLocalObject.class;
        } else {
            throw new DeploymentDescException(intfType + " is invalid value for method-intf on bean " + ejbName);
        }
        return pClass;
    }

    protected String getHashCodeForIdentifier() {
        String hash = "";
        if (getJndiName() != null) {
            hash += getJndiName();
        }
        if (getJndiLocalName() != null) {
            hash += getJndiLocalName();
        }
        return Integer.toString(hash.hashCode());
    }

    protected String getIdentifier() {

        String identifier = getEjbName();
        identifier += getHashCodeForIdentifier();

        char[] tabChar = new char[identifier.length()];
        for (int i = 0; i < identifier.length(); i++) {
            if (!Character.isJavaIdentifierPart(identifier.charAt(i))) {
                tabChar[i] = '_';
            } else {
                tabChar[i] = identifier.charAt(i);
            }
        }
        return new String(tabChar);
    }

    public void checkRemoteException(java.lang.reflect.Method m, boolean shouldThrow) throws DeploymentDescException {
        Class[] excepts = m.getExceptionTypes();
        for (int j = 0; j < excepts.length; j++) {
            if (RemoteException.class.isAssignableFrom(excepts[j])) {
                if (shouldThrow) {
                    return;
                } else {
                    throw new DeploymentDescException("Method " + m.getName() + " of " + m.getDeclaringClass()
                            + " should NOT throw RemoteException");
                }
            }
        }
        if (shouldThrow) {
            throw new DeploymentDescException("Method " + m.getName() + " of " + m.getDeclaringClass()
                    + " must throw RemoteException");
        } else {
            return;
        }

    }

    public void checkValidTypesForRmi(java.lang.reflect.Method m) {
        boolean isValid = true;
        Class[] paramTypes = m.getParameterTypes();
        for (int i = 0; i < paramTypes.length; i++) {
            if (!JavaType.isValidForRmi(paramTypes[i])) {
                isValid = false;
            }
        }
        if (!JavaType.isValidForRmi(m.getReturnType()) && !JavaType.isVoid(m.getReturnType())
                && !JavaType.isCollecOrEnum(m.getReturnType())) {
            // Allow Collection or Enumeration type (finder methods)
            isValid = false;
        }
        if (!isValid) {
            // TODO the trace of this warning uses a static variable into
            // TraceEjb class
            // because this.logger is not yet initialized
            TraceEjb.dd.log(BasicLevel.WARN, "Method " + m.getName() + " of " + m.getDeclaringClass()
                    + " may be have an invalid argument or return type for RMI");
        }
    }

    public void check() throws DeploymentDescException {
        // check business methods transaction attribute
        for (int i = 0; i < methodDesc.size(); i++) {
            checkTxAttribute(((MethodDesc) methodDesc.get(i)));
        }
        checkRunAsMapping();
    }

    public void checkRunAsMapping() throws DeploymentDescException {
        if (runAsPrincipalName != null) {
            // verify roles of run-as principal name
            String[] runAsPrincipalRoles = deploymentDesc.getRolesForRunAsPrincipal(runAsPrincipalName);
            // Check that the run-as role is included in principal roles
            if (runAsPrincipalRoles != null) {
                boolean isIncluded = false;
                for (int r = 0; r < runAsPrincipalRoles.length; r++) {
                    if (runAsPrincipalRoles[r].equals(runAsRole)) {
                        isIncluded = true;
                    }
                }
                if (!isIncluded) {
                    throw new DeploymentDescException("The run-as roles defined for the runas principal name '"
                            + runAsPrincipalName + "' does not contains the run-as role '"
                            + runAsRole + "' in bean '" + getEjbName() + ".");
                }
            }
        }
    }

    protected abstract void checkTxAttribute(MethodDesc md) throws DeploymentDescException;

    protected void verifyRoleName(AssemblyDescriptor asd) throws DeploymentDescException {
        boolean verify;
        List methodPermission = asd.getMethodPermissionList();
        if (methodPermission != null) {
            for (Iterator i = methodPermission.iterator(); i.hasNext();) {
                MethodPermission mPermission = (MethodPermission) i.next();
                for (Iterator j = mPermission.getRoleNameList().iterator(); j.hasNext();) {
                    verify = false;
                    String mpRoleName = (String) j.next();
                    for (Iterator k = asd.getSecurityRoleList().iterator(); k.hasNext();) {
                        String srRoleName = ((SecurityRole) k.next()).getRoleName();
                        if (mpRoleName.equals(srRoleName)) {
                            verify = true;
                        }
                    }
                    if (!verify) {
                        throw new DeploymentDescException(
                                "a method-permission element defined a role-name element \""
                                        + mpRoleName
                                        + "\" which doesn't correspond to any security-role element of the Deployment Descriptor");
                    }
                }
            }
        }
    }

    public String getEjbName() {
        return ejbName;
    }

    public String getJndiName() {
        return jndiName;
    }

    public String getJndiLocalName() {
        return jndiLocalName;
    }

    public Class getHomeClass() {
        return home;
    }

    public Class getRemoteClass() {
        return remote;
    }

    public Class getLocalHomeClass() {
        return localhome;
    }

    public Class getLocalClass() {
        return local;
    }

    public Class getEjbClass() {
        return ejbClass;
    }

    public Properties getEjb10Environment() {
        Properties ret = new Properties(ejb10EnvProps);
        return ret;
    }

    public MethodDesc getMethodDesc(java.lang.reflect.Method method) {

        if (!methodDescMap.containsKey(method)) {
            throw new Error(method.getName() + " is not a method of home/remote interfaces for bean " + getEjbName());
        }
        return (MethodDesc) methodDescMap.get(method);
    }

    public Iterator getMethodDescIterator() {
        return methodDesc.iterator();
    }

    public MethodDesc getMethodDesc(int index) {
        return (MethodDesc) methodDesc.get(index);
    }

    public List getSecurityRoleRefDescList() {
        return securityRoleRefDescList;
    }

    public int getPoolMin() {
        return poolMin;
    }

    public int getCacheMax() {
        return cacheMax;
    }

    public String getRunAsRole() {
        return runAsRole;
    }

    public int getTimerTxAttribute() {
        return timerTxAttribute;
    }

    public String getEjbTimeoutSignature() {
        return ejbTimeoutSignature;
    }

    public BeanFactory getBeanFactory() {
        return bf;
    }

    public void setBeanFactory(BeanFactory factory) {
        bf = factory;
    }

    public String toString() {
        StringBuffer ret = new StringBuffer();
        ret.append("\ngetDisplayName()=" + getDisplayName());
        ret.append("\ngetEjbName()=" + getEjbName());
        if (jndiName != null) {
            ret.append("\ngetJndiName()=" + getJndiName());
        }
        if (home != null) {
            ret.append("\ngetHomeClass()=" + getHomeClass().toString());
        }
        if (remote != null) {
            ret.append("\ngetRemoteClass()=" + getRemoteClass().toString());
        }
        if (localhome != null) {
            ret.append("\ngetLocalHomeClass()=" + getLocalHomeClass().toString());
        }
        if (local != null) {
            ret.append("\ngetLocalClass()=" + getLocalClass().toString());
        }
        ret.append("\ngetEjbClass()=" + getEjbClass().toString());
        EnvEntryDesc[] envE = getEnvEntryDesc();
        for (int i = 0; i < envE.length; i++) {
            ret.append("\ngetEnvEntryDesc(" + i + ")=" + envE[i].toString());
        }
        ServiceRefDesc[] sr = getServiceRefDesc();
        for (int i = 0; i < sr.length; i++) {
            ret.append("\ngetServiceRefDesc(" + i + ")=" + sr[i].toString());
        }
        ResourceEnvRefDesc[] resEnvR = getResourceEnvRefDesc();
        for (int i = 0; i < resEnvR.length; i++) {
            ret.append("\ngetResourceEnvRefDesc(" + i + ")=" + resEnvR[i].toString());
        }
        ResourceRefDesc[] resR = getResourceRefDesc();
        for (int i = 0; i < resR.length; i++) {
            ret.append("\ngetResourceRefDesc(" + i + ")=" + resR[i].toString());
        }
        EjbRefDesc[] ejbR = getEjbRefDesc();
        for (int i = 0; i < ejbR.length; i++) {
            ret.append("\ngetEjbRefDesc(" + i + ")=" + ejbR[i].toString());
        }
        EjbLocalRefDesc[] ejbLR = getEjbLocalRefDesc();
        for (int i = 0; i < ejbLR.length; i++) {
            ret.append("\ngetEjbLocalRefDesc(" + i + ")=" + ejbLR[i].toString());
        }
        MessageDestinationRefDesc[] mdR = getMessageDestinationRefDesc();
        for (int i = 0; i < mdR.length; i++) {
            ret.append("\ngetMessageDestinationRefDesc(" + i + ")=" + mdR[i].toString());
        }
        for (int i = 0; i < methodDesc.size(); i++) {
            MethodDesc md = (MethodDesc) methodDesc.get(i);
            ret.append("\ngetMethodDesc(" + i + ")=" + md.getClass().getName());
            ret.append(md.toString());
        }

        if (securityRoleRefDescList != null) {
            for (Iterator i = securityRoleRefDescList.iterator(); i.hasNext();) {
                SecurityRoleRefDesc sRoleRefDesc = (SecurityRoleRefDesc) i.next();
                ret.append("\nsecurity-role-ref, role-name = '" + sRoleRefDesc.getRoleName() + "', role-link = '"
                        + sRoleRefDesc.getRoleLink() + "'");
            }
        }
        ret.append("\ngetFullWrpRemoteName() = " + getFullWrpRemoteName());
        ret.append("\ngetFullWrpHomeName() = " + getFullWrpHomeName());
        ret.append("\ngetFullWrpLocalName() = " + getFullWrpLocalName());
        ret.append("\ngetFullWrpLocalHomeName() = " + getFullWrpLocalHomeName());
        ret.append("\ngetFullWrpHandleName() = " + getFullWrpHandleName());
        ret.append("\ngetFullDerivedBeanName() = " + getFullDerivedBeanName());
        ret.append("\ngetRunAsRole() = " + getRunAsRole());
        return ret.toString();
    }

    protected MethodDesc newMethodDescInstance(java.lang.reflect.Method meth, int index) {
        return new MethodDesc(this, meth, index);
    }

    protected MethodDesc addMethodDesc(java.lang.reflect.Method meth) {
        MethodDesc md = newMethodDescInstance(meth, methodDesc.size());
        methodDesc.add(md);
        methodDescMap.put(meth, md);
        return md;
    }

    public String getFullWrpRemoteName() {
        return fullWrpRemoteName;
    }

    public String getFullWrpLocalName() {
        return fullWrpLocalName;
    }

    public String getWrpRemoteName() {
        return wrpRemoteName;
    }

    public String getWrpLocalName() {
        return wrpLocalName;
    }

    public String getFullWrpHandleName() {
        return fullWrpHandleName;
    }

    public String getWrpHandleName() {
        return wrpHandleName;
    }

    public String getFullWrpHomeName() {
        return fullWrpHomeName;
    }

    public String getFullWrpLocalHomeName() {
        return fullWrpLocalHomeName;
    }

    public String getWrpHomeName() {
        return wrpHomeName;
    }

    public String getWrpLocalHomeName() {
        return wrpLocalHomeName;
    }

    public String getFullDerivedBeanName() {
        return fullDerivedBeanName;
    }

    public String getDerivedBeanName() {
        return derivedBeanName;
    }

    public DeploymentDesc getDeploymentDesc() {
        return deploymentDesc;
    }

    public void setDeploymentDesc(DeploymentDesc deploymentDesc) {
        this.deploymentDesc = deploymentDesc;
        logger = deploymentDesc.getLogger();
    }

    private void orderMethodDesc(ArrayList al, int begin, int length) {
        MethodDesc[] mds = new MethodDesc[length];
        for (int i = 0; i < length; i++) {
            mds[i] = (MethodDesc) al.get(begin + i);
        }
        Arrays.sort(mds, 0, length, new MethodDescComparator());
        for (int i = 0; i < length; i++) {
            al.set(begin + i, mds[i]);
            mds[i].setIndex(begin + i);
        }
    }

    private class MethodDescComparator implements Comparator {

        public int compare(Object o1, Object o2) {
            MethodDesc md1 = (MethodDesc) o1;
            MethodDesc md2 = (MethodDesc) o2;
            int res = md1.getMethod().getDeclaringClass().getName().compareTo(
                    md2.getMethod().getDeclaringClass().getName());
            if (res == 0) {
                res = md1.getMethod().getName().compareTo(md2.getMethod().getName());
                if (res == 0) {
                    // Same method name => compare the parameter types
                    Class[] p1 = md1.getMethod().getParameterTypes();
                    Class[] p2 = md2.getMethod().getParameterTypes();
                    res = p1.length - p2.length;
                    if (res == 0) {
                        //Same parameter size
                        for (int i = 0; i < p1.length && (res = p1[i].getName().compareTo(p2[i].getName())) == 0; i++) {
                            // compare each method
                        }
                    }
                }
            }
            return res;
        }
    }

    public String getRunAsPrincipalName() {
        return runAsPrincipalName;
    }

    public boolean hasDefinedLocalInterface() {
        if (localhome == null) {
            return false;
        } else {
            return (!"javax.ejb.EJBLocalHome".equals(localhome.getName()));
        }
    }

    private void processIorSecurityConfig(IorSecurityConfigMapping iorSecurityConfigMapping) {

        // Transport
        TransportStruct transportStruct = new TransportStruct();
        // As
        AsStruct asStruct = new AsStruct();
        // Sas
        SasStruct sasStruct = new SasStruct();

        // Now fill SasComponent with given ior values
        TransportConfigMapping transportConfigMapping = iorSecurityConfigMapping.getTransportConfig();
        AsContextMapping asContextMapping = iorSecurityConfigMapping.getAsContext();
        SasContextMapping sasContextMapping = iorSecurityConfigMapping.getSasContext();

        // target requires (if required)
        int targetRequires = 0;
        if (transportConfigMapping.getIntegrity().equals("required")) {
            targetRequires |=  Integrity.value;
        }
        if (transportConfigMapping.getConfidentiality().equals("required")) {
            targetRequires |=  Confidentiality.value;
        }
        if (transportConfigMapping.getEstablishTrustInClient().equals("required")) {
            targetRequires |=  EstablishTrustInClient.value;
        }
        if (transportConfigMapping.getEstablishTrustInTarget().equals("required")) {
            targetRequires |=  EstablishTrustInTarget.value;
        }
        transportStruct.setTargetRequires(targetRequires);


        // target supports (supported or required)
        int targetSupports = 0;
        if (transportConfigMapping.getIntegrity().equals("supported") || transportConfigMapping.getIntegrity().equals("required")) {
            targetSupports |=  Integrity.value;
        }
        if (transportConfigMapping.getConfidentiality().equals("supported") || transportConfigMapping.getConfidentiality().equals("required")) {
            targetSupports |=  Confidentiality.value;
        }
        if (transportConfigMapping.getEstablishTrustInClient().equals("supported") || transportConfigMapping.getEstablishTrustInClient().equals("required")) {
            targetSupports |=  EstablishTrustInClient.value;
        }
        if (transportConfigMapping.getEstablishTrustInTarget().equals("supported") || transportConfigMapping.getEstablishTrustInTarget().equals("required")) {
            targetSupports |=  EstablishTrustInTarget.value;
        }
        transportStruct.setTargetSupports(targetSupports);


        // As struct (if it is needed)
        if (!asContextMapping.getAuthMethod().equals("none")) {
            asStruct.setTargetName(asContextMapping.getRealm());
            asStruct.setTargetSupports(EstablishTrustInClient.value);
            if (asContextMapping.getRequired().equals("true")) {
                asStruct.setTargetRequires(EstablishTrustInClient.value);

            }
        }

        // Sas struct (if supported)
        if (sasContextMapping.getCallerPropagation().equals("supported")) {
            sasStruct.enableGSSUPSupportedNamingMechanisms();
            sasStruct.setSupportedIdentityTypes(ITTAbsent.value | ITTAnonymous.value | ITTPrincipalName.value | ITTX509CertChain.value | ITTDistinguishedName.value);
            sasStruct.setTargetSupports(IdentityAssertion.value);
        }

        // and then, set our SAS component
        sasComponent = new SasComponent(transportStruct, asStruct, sasStruct);


    }

    public SasComponent getSasComponent() {
        return sasComponent;
    }
    public void setSasComponent(SasComponent sasComponent) {
        this.sasComponent = sasComponent;
    }
}

---