Examples with ApplicationException org.apache.openejb.ApplicationException used on opensource projects

Example 26 with ApplicationException

use of org.apache.openejb.ApplicationException in project tomee by apache.

the class SingletonInstanceManager method getInstance.

public Instance getInstance(final ThreadContext callContext) throws OpenEJBException {
    final BeanContext beanContext = callContext.getBeanContext();
    final Data data = (Data) beanContext.getContainerData();
    final AtomicReference<Future<Instance>> singleton = data.singleton;
    try {
        // Has the singleton been created yet?
        // If there is a Future object in the AtomicReference, then
        // it's either been created or is being created now.
        Future<Instance> singletonFuture = singleton.get();
        if (singletonFuture != null) {
            return singletonFuture.get();
        }
        // The singleton has not been created nor is being created
        // We will construct this FutureTask and compete with the
        // other threads for the right to create the singleton
        final FutureTask<Instance> task = new FutureTask<Instance>(new Callable<Instance>() {

            public Instance call() throws Exception {
                return createInstance(callContext, beanContext);
            }
        });
        do {
            // the singleton while the others wait.
            if (singleton.compareAndSet(null, task)) {
                task.run();
            }
        // If we didn't win the slot and no other FutureTask
        // has been set by a different thread, than we need
        // to try again.
        } while ((singletonFuture = singleton.get()) == null);
        // At this point we can safely return the singleton
        return singletonFuture.get();
    } catch (final InterruptedException e) {
        Thread.interrupted();
        throw new ApplicationException(new NoSuchEJBException("Singleton initialization interrupted").initCause(e));
    } catch (final ExecutionException e) {
        final Throwable throwable = e.getCause();
        if (throwable instanceof ApplicationException) {
            throw (ApplicationException) throwable;
        }
        throw new ApplicationException(new NoSuchEJBException("Singleton initialization failed").initCause(e.getCause()));
    }
}

Example 27 with ApplicationException

use of org.apache.openejb.ApplicationException in project tomee by apache.

the class SingletonInstanceManager method createInstance.

private Instance createInstance(final ThreadContext callContext, final BeanContext beanContext) throws ApplicationException {
    try {
        initializeDependencies(beanContext);
        final InstanceContext context = beanContext.newInstance();
        if (context.getBean() instanceof SessionBean) {
            final Operation originalOperation = callContext.getCurrentOperation();
            try {
                callContext.setCurrentOperation(Operation.CREATE);
                final Method create = beanContext.getCreateMethod();
                final InterceptorStack ejbCreate = new InterceptorStack(context.getBean(), create, Operation.CREATE, new ArrayList<InterceptorData>(), new HashMap());
                ejbCreate.invoke();
            } finally {
                callContext.setCurrentOperation(originalOperation);
            }
        }
        final ReadWriteLock lock;
        if (beanContext.isBeanManagedConcurrency()) {
            // Bean-Managed Concurrency
            lock = new BeanManagedLock();
        } else {
            // Container-Managed Concurrency
            lock = new ReentrantReadWriteLock();
        }
        return new Instance(context.getBean(), context.getInterceptors(), context.getCreationalContext(), lock);
    } catch (Throwable e) {
        if (e instanceof InvocationTargetException) {
            e = ((InvocationTargetException) e).getTargetException();
        }
        final String t = "The bean instance " + beanContext.getDeploymentID() + " threw a system exception:" + e;
        logger.error(t, e);
        throw new ApplicationException(new NoSuchEJBException("Singleton failed to initialize").initCause(e));
    }
}

Example 28 with ApplicationException

use of org.apache.openejb.ApplicationException in project tomee by apache.

the class StatefulContainer method removeEJBObject.

protected Object removeEJBObject(final BeanContext beanContext, final Object primKey, final Class callInterface, final Method callMethod, Object[] args, final InterfaceType interfaceType) throws OpenEJBException {
    if (primKey == null) {
        throw new NullPointerException("primKey is null");
    }
    final CdiEjbBean cdiEjbBean = beanContext.get(CdiEjbBean.class);
    if (cdiEjbBean != null) {
        final Class scope = cdiEjbBean.getScope();
        if (callMethod.getDeclaringClass() != BeanContext.Removable.class && scope != Dependent.class) {
            throw new UnsupportedOperationException("Can not call EJB Stateful Bean Remove Method without scoped @Dependent.  Found scope: @" + scope.getSimpleName());
        }
    }
    final boolean internalRemove = BeanContext.Removable.class == callMethod.getDeclaringClass();
    final ThreadContext callContext = new ThreadContext(beanContext, primKey);
    final ThreadContext oldCallContext = ThreadContext.enter(callContext);
    Object runAs = null;
    try {
        if (oldCallContext != null) {
            final BeanContext oldBc = oldCallContext.getBeanContext();
            if (oldBc.getRunAsUser() != null || oldBc.getRunAs() != null) {
                runAs = AbstractSecurityService.class.cast(securityService).overrideWithRunAsContext(callContext, beanContext, oldBc);
            }
        }
        // Security check
        if (!internalRemove) {
            checkAuthorization(callMethod, interfaceType);
        }
        // If a bean managed transaction is active, the bean can not be removed
        if (interfaceType.isComponent()) {
            final Instance instance = checkedOutInstances.get(primKey);
            /**
             * According to EJB 3.0 "4.4.4 Restrictions for Transactions" any remove methods
             * from home or component interfaces must not be allowed if the bean instance is
             * in a transaction.  Unfortunately, the Java EE 5 TCK has tests that ignore the
             * restrictions in 4.4.4 and expect beans in transactions can be removed via their
             * home or component interface.   The test to see if the bean instance implements
             * javax.ejb.SessionBean is a workaround for passing the TCK while the tests in
             * question can be challenged or the spec can be changed/updated.
             */
            if (instance != null && instance.bean instanceof SessionBean) {
                throw new ApplicationException(new RemoveException("A stateful EJB enrolled in a transaction can not be removed"));
            }
        }
        // Start transaction
        final TransactionPolicy txPolicy = EjbTransactionUtil.createTransactionPolicy(callContext.getBeanContext().getTransactionType(callMethod, interfaceType), callContext);
        Object returnValue = null;
        boolean retain = false;
        Instance instance = null;
        Method runMethod = null;
        try {
            // Obtain instance
            instance = obtainInstance(primKey, callContext, callMethod, beanContext.isPassivatingScope());
            // Resume previous Bean transaction if there was one
            if (txPolicy instanceof BeanTransactionPolicy) {
                // Resume previous Bean transaction if there was one
                final SuspendedTransaction suspendedTransaction = instance.getBeanTransaction();
                if (suspendedTransaction != null) {
                    instance.setBeanTransaction(null);
                    final BeanTransactionPolicy beanTxEnv = (BeanTransactionPolicy) txPolicy;
                    beanTxEnv.resumeUserTransaction(suspendedTransaction);
                }
            }
            if (!internalRemove) {
                // Register the entity managers
                registerEntityManagers(instance, callContext);
                // Register for synchronization callbacks
                registerSessionSynchronization(instance, callContext);
                // Setup for remove invocation
                callContext.setCurrentOperation(Operation.REMOVE);
                callContext.setCurrentAllowedStates(null);
                callContext.setInvokedInterface(callInterface);
                runMethod = beanContext.getMatchingBeanMethod(callMethod);
                callContext.set(Method.class, runMethod);
                // Do not pass arguments on home.remove(remote) calls
                final Class<?> declaringClass = callMethod.getDeclaringClass();
                if (declaringClass.equals(EJBHome.class) || declaringClass.equals(EJBLocalHome.class)) {
                    args = new Object[] {};
                }
                // Initialize interceptor stack
                final List<InterceptorData> interceptors = beanContext.getMethodInterceptors(runMethod);
                final InterceptorStack interceptorStack = new InterceptorStack(instance.bean, runMethod, Operation.REMOVE, interceptors, instance.interceptors);
                // Invoke
                final CdiEjbBean<Object> bean = beanContext.get(CdiEjbBean.class);
                if (bean != null) {
                    // TODO: see if it should be called before or after next call
                    bean.getInjectionTarget().preDestroy(instance.bean);
                }
                if (args == null) {
                    returnValue = interceptorStack.invoke();
                } else {
                    returnValue = interceptorStack.invoke(args);
                }
            }
        } catch (final InvalidateReferenceException e) {
            throw new ApplicationException(e.getRootCause());
        } catch (final Throwable e) {
            if (interfaceType.isBusiness()) {
                retain = beanContext.retainIfExeption(runMethod);
                handleException(callContext, txPolicy, e);
            } else {
                try {
                    handleException(callContext, txPolicy, e);
                } catch (final ApplicationException ae) {
                // Don't throw application exceptions for non-business interface removes
                }
            }
        } finally {
            if (runAs != null) {
                try {
                    securityService.associate(runAs);
                } catch (final LoginException e) {
                // no-op
                }
            }
            if (!retain) {
                try {
                    callContext.setCurrentOperation(Operation.PRE_DESTROY);
                    final List<InterceptorData> callbackInterceptors = beanContext.getCallbackInterceptors();
                    if (instance != null) {
                        final InterceptorStack interceptorStack = new InterceptorStack(instance.bean, null, Operation.PRE_DESTROY, callbackInterceptors, instance.interceptors);
                        interceptorStack.invoke();
                    }
                } catch (final Throwable t) {
                    final String logMessage = "An unexpected exception occured while invoking the preDestroy method on the Stateful SessionBean instance: " + (null != instance ? instance.bean.getClass().getName() : beanContext.getBeanClass().getName());
                    logger.error(logMessage, t);
                } finally {
                    callContext.setCurrentOperation(Operation.REMOVE);
                }
                discardInstance(primKey, instance);
            }
            // un register EntityManager
            final Map<EntityManagerFactory, JtaEntityManagerRegistry.EntityManagerTracker> unregisteredEntityManagers = unregisterEntityManagers(instance, callContext);
            // Commit transaction
            afterInvoke(callContext, txPolicy, instance);
            // Un register and close extended persistence contexts
            /*
                7.6.2 Container-managed Extended Persistence Context
                A container-managed extended persistence context can only be initiated within the scope of a stateful
                session bean. It exists from the point at which the stateful session bean that declares a dependency on an
                entity manager of type PersistenceContextType.EXTENDED is created, and is said to be bound
                to the stateful session bean. The dependency on the extended persistence context is declared by means
                of the PersistenceContext annotation or persistence-context-ref deployment descriptor element.
                The persistence context is closed by the container when the @Remove method of the stateful session
                bean completes (or the stateful session bean instance is otherwise destroyed).
                */
            closeEntityManagers(unregisteredEntityManagers);
        }
        return returnValue;
    } finally {
        ThreadContext.exit(oldCallContext);
    }
}

Example 29 with ApplicationException

use of org.apache.openejb.ApplicationException in project tomee by apache.

the class StatefulContainer method handleException.

private void handleException(final ThreadContext callContext, final TransactionPolicy txPolicy, final Throwable e) throws ApplicationException {
    if (e instanceof ApplicationException) {
        throw (ApplicationException) e;
    }
    final ExceptionType type = callContext.getBeanContext().getExceptionType(e);
    if (type == ExceptionType.SYSTEM) {
        discardInstance(callContext.getPrimaryKey(), null);
        EjbTransactionUtil.handleSystemException(txPolicy, e, callContext);
    } else {
        EjbTransactionUtil.handleApplicationException(txPolicy, e, type == ExceptionType.APPLICATION_ROLLBACK);
    }
}

Example 30 with ApplicationException

use of org.apache.openejb.ApplicationException in project tomee by apache.

the class StatelessInstanceManager method getInstance.

/**
 * Removes an instance from the pool and returns it for use
 * by the container in business methods.
 * <p/>
 * If the pool is at it's limit the StrictPooling flag will
 * cause this thread to wait.
 * <p/>
 * If StrictPooling is not enabled this method will create a
 * new stateless bean instance performing all required injection
 * and callbacks before returning it in a method ready state.
 *
 * @param callContext ThreadContext
 * @return Object
 * @throws OpenEJBException
 */
public Instance getInstance(final ThreadContext callContext) throws OpenEJBException {
    final BeanContext beanContext = callContext.getBeanContext();
    final Data data = (Data) beanContext.getContainerData();
    Instance instance = null;
    try {
        final Pool<Instance>.Entry entry = data.poolPop();
        if (entry != null) {
            instance = entry.get();
            instance.setPoolEntry(entry);
        }
    } catch (final TimeoutException e) {
        final String msg = "No instances available in Stateless Session Bean pool.  Waited " + data.accessTimeout.toString();
        final ConcurrentAccessTimeoutException timeoutException = new ConcurrentAccessTimeoutException(msg);
        timeoutException.fillInStackTrace();
        throw new ApplicationException(timeoutException);
    } catch (final InterruptedException e) {
        Thread.interrupted();
        throw new OpenEJBException("Unexpected Interruption of current thread: ", e);
    }
    if (null == instance) {
        instance = createInstance(callContext, beanContext);
    }
    return instance;
}