Title: EjbContext Whiteboard
<DIV class="code panel" style="border-style: solid;border-width: 1px;"><DIV class="codeHeader panelHeader" style="border-bottom-width: 1px;border-bottom-style: solid;"><B>CoreContext.java</B></DIV><DIV class="codeContent panelContent">
    /**
     * Licensed to the Apache Software Foundation (ASF) under one or more
     * contributor license agreements.  See the NOTICE file distributed with
     * this work for additional information regarding copyright ownership.
     * The ASF licenses this file to You 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.openejb.core;
    
    import java.util.List;
    import javax.ejb.EJBHome;
    import javax.ejb.EJBLocalHome;
    import javax.ejb.EJBLocalObject;
    import javax.ejb.TimerService;
    import javax.naming.Context;
    import javax.naming.InitialContext;
    import javax.naming.NamingException;
    import javax.transaction.Status;
    import javax.transaction.TransactionManager;
    import javax.transaction.UserTransaction;
    import java.util.List;
    
    import org.apache.openejb.DeploymentInfo;
    import org.apache.openejb.InterfaceType;
    import org.apache.openejb.RpcContainer;
    import org.apache.openejb.InternalErrorException;
    import org.apache.openejb.core.ivm.EjbObjectProxyHandler;
    import org.apache.openejb.core.ivm.IntraVmProxy;
    import org.apache.openejb.spi.SecurityService;
    import org.apache.openejb.util.proxy.ProxyManager;
    
    
    public abstract class CoreContext implements java.io.Serializable {
    
        public static enum Call {
    	getEJBHome,
    	getCallerPrincipal,
    	getRollbackOnly,
    	isCallerInRole,
    	setRollbackOnly,
    	getEJBObject,
    	getPrimaryKey,
    	getUserTransaction
        }
    
        private final UserTransaction userTransaction;
        private final SecurityService securityService;
        private final TransactionManager transactionManager;
    
        public CoreContext(TransactionManager transactionManager,
SecurityService securityService) {
    	this.transactionManager = transactionManager;
    	this.securityService = securityService;
    	this.userTransaction = new CoreUserTransaction(transactionManager);
        }
    
        protected CoreContext(TransactionManager transactionManager,
SecurityService securityService, UserTransaction userTransaction) {
    	this.transactionManager = transactionManager;
    	this.securityService = securityService;
    	this.userTransaction = userTransaction;
        }
    
        private TransactionManager getTransactionManager() {
    	return transactionManager;
        }
    
        public abstract void checkBeanState(Call methodCategory) throws
IllegalStateException;
    
        public java.security.Principal getCallerPrincipal() {
    	checkBeanState(Call.getCallerPrincipal);
    	Object securityIdentity =
ThreadContext.getThreadContext().getSecurityIdentity();
    	return (java.security.Principal)
getSecurityService().translateTo(securityIdentity,
java.security.Principal.class);
        }
    
        private SecurityService getSecurityService() {
    	return securityService;
        }
    
        public boolean isCallerInRole(java.lang.String roleName) {
    	checkBeanState(Call.isCallerInRole);
    	ThreadContext threadContext = ThreadContext.getThreadContext();
    	org.apache.openejb.core.CoreDeploymentInfo di =
(org.apache.openejb.core.CoreDeploymentInfo)
threadContext.getDeploymentInfo();
    	List<String> physicalRoles = di.getPhysicalRole(roleName);
    	Object caller = threadContext.getSecurityIdentity();
    	return securityService.isCallerAuthorized(caller, physicalRoles);
        }
    
        public EJBHome getEJBHome() {
    	checkBeanState(Call.getEJBHome);
    
    	ThreadContext threadContext = ThreadContext.getThreadContext();
    	org.apache.openejb.core.CoreDeploymentInfo di =
(org.apache.openejb.core.CoreDeploymentInfo)
threadContext.getDeploymentInfo();
    
    	return di.getEJBHome();
        }
    
        public javax.ejb.EJBObject getEJBObject() {
    	checkBeanState(Call.getEJBObject);
    
    	ThreadContext threadContext = ThreadContext.getThreadContext();
    	org.apache.openejb.DeploymentInfo di =
threadContext.getDeploymentInfo();
    
    	EjbObjectProxyHandler handler = newEjbObjectHandler((RpcContainer)
di.getContainer(), threadContext.getPrimaryKey(), di.getDeploymentID(),
InterfaceType.EJB_OBJECT);
    	Object newProxy = null;
    	try {
                Class[]
 interfaces = new Class[]{di.getRemoteInterface(),
org.apache.openejb.core.ivm.IntraVmProxy.class};
    	    newProxy = ProxyManager.newProxyInstance(interfaces, handler);
    	} catch (IllegalAccessException iae) {
    	    throw new RuntimeException("Could not create IVM proxy for " +
di.getRemoteInterface() + " interface");
    	}
    	return (javax.ejb.EJBObject) newProxy;
        }
    
        public EJBLocalObject getEJBLocalObject() {
    	ThreadContext threadContext = ThreadContext.getThreadContext();
    	org.apache.openejb.DeploymentInfo di =
threadContext.getDeploymentInfo();
    
    	EjbObjectProxyHandler handler = newEjbObjectHandler((RpcContainer)
di.getContainer(), threadContext.getPrimaryKey(), di.getDeploymentID(),
InterfaceType.EJB_LOCAL);
    	handler.setLocal(true);
    	Object newProxy = null;
    	try {
                Class[]
 interfaces = new Class[]{di.getLocalInterface(),
org.apache.openejb.core.ivm.IntraVmProxy.class};
    	    newProxy = ProxyManager.newProxyInstance(interfaces, handler);
    	} catch (IllegalAccessException iae) {
    	    throw new RuntimeException("Could not create IVM proxy for " +
di.getLocalInterface() + " interface");
    	}
    	return (EJBLocalObject) newProxy;
        }
    
        public Object getBusinessObject(Class interfce) {
    	ThreadContext threadContext = ThreadContext.getThreadContext();
    	DeploymentInfo di = threadContext.getDeploymentInfo();
    
    	InterfaceType interfaceType;
    	if (di.getBusinessLocalInterface() != null &&
di.getBusinessLocalInterface().getName().equals(interfce.getName())) {
    	    interfaceType = InterfaceType.BUSINESS_LOCAL;
    	} else if (di.getBusinessRemoteInterface() != null &&
di.getBusinessRemoteInterface().getName().equals(interfce.getName())) {
    	    interfaceType = InterfaceType.BUSINESS_REMOTE;
    	} else {
    	    throw new IllegalArgumentException("Component has no such
interface " + interfce.getName());
    	}
    
    	Object newProxy;
    	try {
    	    EjbObjectProxyHandler handler =
newEjbObjectHandler((RpcContainer) di.getContainer(),
threadContext.getPrimaryKey(), di.getDeploymentID(), interfaceType);
                Class[]
 interfaces = new Class[]{interfce, IntraVmProxy.class};
    	    newProxy = ProxyManager.newProxyInstance(interfaces, handler);
    	} catch (IllegalAccessException iae) {
    	    throw new InternalErrorException("Could not create IVM proxy
for " + interfce.getName() + " interface", iae);
    	}
    	return newProxy;
        }
    
        public EJBLocalHome getEJBLocalHome() {
    	ThreadContext threadContext = ThreadContext.getThreadContext();
    	org.apache.openejb.core.CoreDeploymentInfo di =
threadContext.getDeploymentInfo();
    
    	return di.getEJBLocalHome();
        }
    
        public TimerService getTimerService() {
    	return null;
        }
    
        public Object getPrimaryKey() {
    	/*
    	* This method is only declared in the EntityContext interface and
is therefor
    	* unavailable in the SessionContext and doesn't not require a check
for bean kind (Entity vs Session).
    	*/
    	checkBeanState(Call.getPrimaryKey);
    
    	ThreadContext threadContext = ThreadContext.getThreadContext();
    	return threadContext.getPrimaryKey();
        }
    
        public boolean getRollbackOnly() {
    
    	ThreadContext threadContext = ThreadContext.getThreadContext();
    	org.apache.openejb.DeploymentInfo di =
threadContext.getDeploymentInfo();
    	if (di.isBeanManagedTransaction()) {
    	    throw new IllegalStateException("bean-managed transaction beans
can not access the getRollbackOnly( ) method");
    	}
    
    	checkBeanState(Call.getRollbackOnly);
    	try {
    	    int status = getTransactionManager().getStatus();
    	    if (status == Status.STATUS_MARKED_ROLLBACK || status ==
Status.STATUS_ROLLEDBACK) {
    		return true;
    	    } else if (status == Status.STATUS_NO_TRANSACTION) {
    		// this would be true for Supports tx attribute where no tx
was propagated
    		throw new IllegalStateException("No current transaction");
    	    } else {
    		return false;
    	    }
    	} catch (javax.transaction.SystemException se) {
    	    throw new RuntimeException("Transaction service has thrown a
SystemException");
    	}
        }
    
        public void setRollbackOnly() {
    	ThreadContext threadContext = ThreadContext.getThreadContext();
    	org.apache.openejb.DeploymentInfo di =
threadContext.getDeploymentInfo();
    	if (di.isBeanManagedTransaction()) {
    	    throw new IllegalStateException("bean-managed transaction beans
can not access the setRollbackOnly( ) method");
    	}
    
    	checkBeanState(Call.setRollbackOnly);
    
    	try {
    	    getTransactionManager().setRollbackOnly();
    	} catch (javax.transaction.SystemException se) {
    	    throw new RuntimeException("Transaction service has thrown a
SystemException");
    	}
    
        }
    
        public javax.transaction.UserTransaction getUserTransaction() {
    
    	ThreadContext threadContext = ThreadContext.getThreadContext();
    	org.apache.openejb.DeploymentInfo di =
threadContext.getDeploymentInfo();
    	if (di.isBeanManagedTransaction()) {
    	    checkBeanState(Call.getUserTransaction);
    	    return userTransaction;
    	} else {
    	    throw new java.lang.IllegalStateException("container-managed
transaction beans can not access the UserTransaction");
    	}
        }
    
        /**
         * Lookup a resource within the component's private naming context.
         *
         * @param name - Name of the entry (relative to java:comp/env).
         * @return The looked-up object.
         * @see
http://java.sun.com/javaee/5/docs/api/javax/ejb/EJBContext.html#lookup(java.lang.String)
         * @see EJB3.0 "Core Contracts and Requirements", section 4.5.2, table
2.
         */
        public Object lookup(String name) {
    	Context initialContext = null;
    	Object object = null;
    
    	try {
    	    initialContext = new InitialContext();
    	    object = initialContext.lookup("java:comp/env/" + name);
    	} catch (NamingException nex) {
    	    throw new IllegalArgumentException(nex);
    	}
    	return object;
        }
    
        /*----------------------------------------------------*/
        /* UNSUPPORTED DEPRICATED METHODS			  */
        /*----------------------------------------------------*/
    
        public boolean isCallerInRole(java.security.Identity role) {
    	throw new java.lang.UnsupportedOperationException();
        }
    
        public java.security.Identity getCallerIdentity() {
    	throw new java.lang.UnsupportedOperationException();
        }
    
        public java.util.Properties getEnvironment() {
    	throw new java.lang.UnsupportedOperationException();
        }
    
        protected abstract EjbObjectProxyHandler
newEjbObjectHandler(RpcContainer container, Object pk, Object depID,
InterfaceType interfaceType);
    }


<DIV class="code panel" style="border-style: solid;border-width: 1px;"><DIV class="codeHeader panelHeader" style="border-bottom-width: 1px;border-bottom-style: solid;"><B>EntityContext.java</B></DIV><DIV class="codeContent panelContent">
    /**
     * Licensed to the Apache Software Foundation (ASF) under one or more
     * contributor license agreements.  See the NOTICE file distributed with
     * this work for additional information regarding copyright ownership.
     * The ASF licenses this file to You 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.openejb.core.entity;
    
    import org.apache.openejb.RpcContainer;
    import org.apache.openejb.InterfaceType;
    import org.apache.openejb.spi.SecurityService;
    import org.apache.openejb.core.ThreadContext;
    import org.apache.openejb.core.Operation;
    import org.apache.openejb.core.ivm.EjbObjectProxyHandler;
    
    import javax.transaction.TransactionManager;
    
    public class EntityContext extends org.apache.openejb.core.CoreContext
implements javax.ejb.EntityContext {
    
        public EntityContext(TransactionManager transactionManager,
SecurityService securityService) {
    	super(transactionManager, securityService);
        }
    
        public void checkBeanState(Call methodCategory) throws
IllegalStateException {
    	/*
    	The super class, CoreContext determines if
Context.getUserTransaction( ) method
    	maybe called before invoking this.checkBeanState( ).  Only "bean
managed" transaction
    	beans may access this method.
    
    	The USER_TRANSACTION_METHOD constant will never be a methodCategory
    	because entity beans are not allowed to have "bean managed"
transactions.
    
    	USER_TRANSACTION_METHOD:
    	*/
    
    	ThreadContext callContext = ThreadContext.getThreadContext();
    	org.apache.openejb.DeploymentInfo di =
callContext.getDeploymentInfo();
    
    	Operation currentOperation = callContext.getCurrentOperation();
    	switch (currentOperation) {
    	    case SET_CONTEXT:
    	    case UNSET_CONTEXT:
    		switch(methodCategory){
    		    case getCallerPrincipal:
    		    case getRollbackOnly:
    		    case isCallerInRole:
    		    case setRollbackOnly:
    		    case getEJBObject:
    		    case getPrimaryKey:
    		    case getUserTransaction:
    			throw new IllegalStateException(methodCategory +
"cannot be called in " + currentOperation);
    		}
    		break;
    
    	    case CREATE:
    	    case FIND:
    	    case HOME:
    		switch(methodCategory){
    		    case getEJBObject:
    		    case getPrimaryKey:
    		    case getUserTransaction:
    			throw new IllegalStateException(methodCategory +
"cannot be called in " + currentOperation);
    		}
    		break;
    
    	    case ACTIVATE:
    	    case PASSIVATE:
    		switch(methodCategory){
    		    case getCallerPrincipal:
    		    case getRollbackOnly:
    		    case isCallerInRole:
    		    case setRollbackOnly:
    		    case getUserTransaction:
    			throw new IllegalStateException(methodCategory +
"cannot be called in " + currentOperation);
    		}
    		break;
    
    	    case POST_CREATE:
    	    case REMOVE:
    	    case LOAD:
    	    case STORE:
    		switch(methodCategory){
    		    case getUserTransaction:
    			throw new IllegalStateException(methodCategory +
"cannot be called in " + currentOperation);
    		}
    		break;
    
    	}
    
        }
    
        protected EjbObjectProxyHandler newEjbObjectHandler(RpcContainer
container, Object pk, Object depID, InterfaceType interfaceType) {
    	return new EntityEjbObjectHandler(container, pk, depID,
interfaceType);
        }
    
    }