{code:title=CoreContext.java}
/**
 * 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);
}
{code}

{code:title=EntityContext.java}
/**
 * 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);
    }

}
{code}