javax.resource.spi.UnavailableException Java Examples

/**
 * Invokes endpoint factory to create message endpoint (event driven bean).
 * It will retry if the event driven bean is not yet available.
 */
private MessageEndpoint createMessageEndpoint() {
    MessageEndpoint ep = null;
    for (int i = 0; i < MAX_ATTEMPTS; i++) {
        try {
            ep = endpointFactory.createEndpoint(null);
            break;
        } catch (UnavailableException e) {
            LOG.fine("Target endpoint activation in progress.  Will retry.");
            try {
                Thread.sleep(RETRY_SLEEP);
            } catch (InterruptedException e1) {
                // ignore
            }
        }
    }

    return ep;
}
 

@Override
public MessageEndpoint createEndpoint(final XAResource xaResource, final long timeout) throws UnavailableException {
    if (timeout <= 0) {
        return createEndpoint(xaResource);
    }

    final long end = System.currentTimeMillis() + timeout;
    MessageEndpoint messageEndpoint = null;

    while (System.currentTimeMillis() <= end) {
        try {
            messageEndpoint = createEndpoint(xaResource);
            break;
        } catch (final Exception ex) {
            // ignore so we can keep trying
        }
    }

    if (messageEndpoint != null) {
        return messageEndpoint;
    } else {
        throw new UnavailableException("Unable to create end point within the specified timeout " + timeout);
    }
}
 

public Object invoke(final Object deploymentId, final InterfaceType type, final Class callInterface, final Method method, final Object[] args, final Object primKey) throws OpenEJBException {
    final BeanContext beanContext = getBeanContext(deploymentId);

    final EndpointFactory endpointFactory = (EndpointFactory) beanContext.getContainerData();
    final MdbInstanceFactory instanceFactory = endpointFactory.getInstanceFactory();
    final Instance instance;
    try {
        instance = (Instance) instanceFactory.createInstance(true);
    } catch (final UnavailableException e) {
        throw new SystemException("Unable to create instance for invocation", e);
    }

    try {
        beforeDelivery(beanContext, instance, method, null);
        final Object value = invoke(instance, method, type, args);
        afterDelivery(instance);
        return value;
    } finally {
        instanceFactory.freeInstance(instance, true);
    }
}
 

public void afterDelivery() throws ApplicationServerInternalException, UnavailableException {
    switch (state) {
        case RELEASED:
            throw new IllegalStateException("Message endpoint factory has been released");
        case NONE:
            throw new IllegalStateException("afterDelivery may only be called if message delivery began with a beforeDelivery call");
    }


    // call afterDelivery on the container
    boolean exceptionThrown = false;
    try {
        container.afterDelivery(instance);
    } catch (final SystemException se) {
        exceptionThrown = true;

        final Throwable throwable = se.getRootCause() != null ? se.getRootCause() : se;
        throw new ApplicationServerInternalException(throwable);
    } finally {
        if (state == State.SYSTEM_EXCEPTION) {
            recreateInstance(exceptionThrown);
        }
        // we are now in the default NONE state
        state = State.NONE;
    }
}
 

public void afterDelivery() throws ApplicationServerInternalException, UnavailableException {
    // verify current state
    switch (state) {
        case RELEASED:
            throw new IllegalStateException("Message endpoint factory has been released");
        case NONE:
            throw new IllegalStateException("afterDelivery may only be called if message delivery began with a beforeDelivery call");
    }


    // call afterDelivery on the container
    try {
        container.afterDelivery(instance);
    } catch (final SystemException se) {
        final Throwable throwable = se.getRootCause() != null ? se.getRootCause() : se;
        throw new ApplicationServerInternalException(throwable);
    } finally {
        // we are now in the default NONE state
        state = State.NONE;
        this.instance = null;
    }
}
 

/**
 * The standard JCA 1.5 version of {@code createEndpoint}.
 * <p>This implementation delegates to {@link #createEndpointInternal()},
 * initializing the endpoint's XAResource before the endpoint gets invoked.
 */
@Override
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException {
	AbstractMessageEndpoint endpoint = createEndpointInternal();
	endpoint.initXAResource(xaResource);
	return endpoint;
}
 

@Override
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException {
   TestEndpoint retEnd = new TestEndpoint();
   if (xaResource != null) {
      retEnd.setXAResource(xaResource);
   }
   return retEnd;
}
 

@Override
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException {
   if (xaResource != null) {
      endpoint.setXAResource(xaResource);
   }
   return endpoint;
}
 

/**
 * Wrap each concrete endpoint instance with an AOP proxy,
 * exposing the message listener's interfaces as well as the
 * endpoint SPI through an AOP introduction.
 */
@Override
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException {
	GenericMessageEndpoint endpoint = (GenericMessageEndpoint) super.createEndpoint(xaResource);
	ProxyFactory proxyFactory = new ProxyFactory(this.messageListener);
	DelegatingIntroductionInterceptor introduction = new DelegatingIntroductionInterceptor(endpoint);
	introduction.suppressInterface(MethodInterceptor.class);
	proxyFactory.addAdvice(introduction);
	return (MessageEndpoint) proxyFactory.getProxy();
}
 

@Override
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException {
    if (xaResource != null && xaResourceWrapper != null) {
        xaResource = xaResourceWrapper.wrap(xaResource, container.getContainerID().toString());
    }

    InvocationHandler endpointHandler = null;
    if (usePool) {
        endpointHandler = new PoolEndpointHandler(container, beanContext, instanceManager, xaResource);
    } else {
        endpointHandler = new EndpointHandler(container, beanContext, instanceFactory, xaResource);
    }

    try {
        return (MessageEndpoint) LocalBeanProxyFactory.constructProxy(proxy, endpointHandler);
    } catch (final InternalError e) { // should be useless
        //try to create the proxy with tccl once again.
        try {
            return MessageEndpoint.class.cast(LocalBeanProxyFactory.newProxyInstance(Thread.currentThread().getContextClassLoader(), endpointHandler, beanContext.getBeanClass(), interfaces));
        } catch (final InternalError ie) {
            try {
                return MessageEndpoint.class.cast(LocalBeanProxyFactory.newProxyInstance(classLoader, endpointHandler, beanContext.getBeanClass(), interfaces));
            } catch (final InternalError ie2) {
                // no-op
            }
        }
        throw e;
    }
}
 

/**
 * The standard JCA 1.5 version of {@code createEndpoint}.
 * <p>This implementation delegates to {@link #createEndpointInternal()},
 * initializing the endpoint's XAResource before the endpoint gets invoked.
 */
@Override
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException {
	AbstractMessageEndpoint endpoint = createEndpointInternal();
	endpoint.initXAResource(xaResource);
	return endpoint;
}
 

/**
 * Creates a new mdb instance preforming all necessary lifecycle callbacks
 *
 * @param ignoreInstanceCount
 * @return a new message driven bean instance
 * @throws UnavailableException if the instance limit has been exceeded or
 *                              if an exception occurs while creating the bean instance
 */
public Object createInstance(final boolean ignoreInstanceCount) throws UnavailableException {
    if (!ignoreInstanceCount) {
        synchronized (this) {
            // check the instance limit
            if (instanceLimit > 0 && instanceCount >= instanceLimit) {
                throw new UnavailableException("Only " + instanceLimit + " instances can be created");
            }
            // increment the instance count
            instanceCount++;
        }
    }

    try {
        final Object bean = constructBean();
        return bean;
    } catch (final UnavailableException e) {
        // decrement the instance count
        if (!ignoreInstanceCount) {
            synchronized (this) {
                instanceCount--;
            }
        }

        throw e;
    }
}
 

/**
 * Wrap each concrete endpoint instance with an AOP proxy,
 * exposing the message listener's interfaces as well as the
 * endpoint SPI through an AOP introduction.
 */
@Override
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException {
	GenericMessageEndpoint endpoint = (GenericMessageEndpoint) super.createEndpoint(xaResource);
	ProxyFactory proxyFactory = new ProxyFactory(this.messageListener);
	DelegatingIntroductionInterceptor introduction = new DelegatingIntroductionInterceptor(endpoint);
	introduction.suppressInterface(MethodInterceptor.class);
	proxyFactory.addAdvice(introduction);
	return (MessageEndpoint) proxyFactory.getProxy();
}
 

/**
 * Recreates a bean instance that has thrown a system exception.  As required by the EJB specification, lifecycle
 * callbacks are not invoked.  To normally free a bean instance call the freeInstance method.
 *
 * @param bean the bean instance to discard
 * @return the new replacement bean instance
 */
public Object recreateInstance(final Object bean) throws UnavailableException {
    if (bean == null) {
        throw new NullPointerException("bean is null");
    }
    final Object newBean = constructBean();
    return newBean;
}
 

private Object constructBean() throws UnavailableException {
    final BeanContext beanContext = this.beanContext;

    final ThreadContext callContext = new ThreadContext(beanContext, null, Operation.INJECTION);
    final ThreadContext oldContext = ThreadContext.enter(callContext);

    try {
        final InstanceContext context = beanContext.newInstance();

        if (context.getBean() instanceof MessageDrivenBean) {
            callContext.setCurrentOperation(Operation.CREATE);
            final Method create = beanContext.getCreateMethod();
            final InterceptorStack ejbCreate = new InterceptorStack(context.getBean(), create, Operation.CREATE, new ArrayList(), new HashMap());
            ejbCreate.invoke();
        }

        return new Instance(context.getBean(), context.getInterceptors(), context.getCreationalContext());
    } catch (Throwable e) {
        if (e instanceof InvocationTargetException) {
            e = ((InvocationTargetException) e).getTargetException();
        }
        final String message = "The bean instance threw a system exception:" + e;
        MdbInstanceFactory.logger.error(message, e);
        throw new UnavailableException(message, e);
    } finally {
        ThreadContext.exit(oldContext);
    }
}
 

/**
 * The standard JCA 1.5 version of {@code createEndpoint}.
 * <p>This implementation delegates to {@link #createEndpointInternal()},
 * initializing the endpoint's XAResource before the endpoint gets invoked.
 */
@Override
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException {
	AbstractMessageEndpoint endpoint = createEndpointInternal();
	endpoint.initXAResource(xaResource);
	return endpoint;
}
 

public EndpointHandler(final BaseMdbContainer container, final BeanContext deployment, final MdbInstanceFactory instanceFactory, final XAResource xaResource) throws UnavailableException {
    super(container);
    this.deployment = deployment;
    this.instanceFactory = instanceFactory;
    this.xaResource = xaResource;
    instance = instanceFactory.createInstance(false);
}
 

@Override
protected void recreateInstance(final boolean exceptionAlreadyThrown) throws UnavailableException {
    try {
        instance = instanceFactory.recreateInstance(instance);
    } catch (final UnavailableException e) {
        // an error occured wile attempting to create the replacement instance
        // this endpoint is now failed
        state = State.RELEASED;

        // if bean threw an exception, do not override that exception
        if (!exceptionAlreadyThrown) {
            throw e;
        }
    }
}
 

public PoolEndpointHandler(final BaseMdbContainer container, final BeanContext deployment, final MdbInstanceManager instanceManager, final XAResource xaResource) throws UnavailableException {
    super(container);
    this.deployment = deployment;
    this.instanceManager = instanceManager;
    this.xaResource = xaResource;
    this.callContext = ThreadContext.getThreadContext();
}
 

/**
 * Wrap each concrete endpoint instance with an AOP proxy,
 * exposing the message listener's interfaces as well as the
 * endpoint SPI through an AOP introduction.
 */
@Override
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException {
	GenericMessageEndpoint endpoint = (GenericMessageEndpoint) super.createEndpoint(xaResource);
	ProxyFactory proxyFactory = new ProxyFactory(getMessageListener());
	DelegatingIntroductionInterceptor introduction = new DelegatingIntroductionInterceptor(endpoint);
	introduction.suppressInterface(MethodInterceptor.class);
	proxyFactory.addAdvice(introduction);
	return (MessageEndpoint) proxyFactory.getProxy();
}
 

/**
 * The alternative JCA 1.6 version of {@code createEndpoint}.
 * <p>This implementation delegates to {@link #createEndpointInternal()},
 * ignoring the specified timeout. It is only here for JCA 1.6 compliance.
 */
@Override
public MessageEndpoint createEndpoint(XAResource xaResource, long timeout) throws UnavailableException {
	AbstractMessageEndpoint endpoint = createEndpointInternal();
	endpoint.initXAResource(xaResource);
	return endpoint;
}
 

/**
 * The standard JCA 1.5 version of {@code createEndpoint}.
 * <p>This implementation delegates to {@link #createEndpointInternal()},
 * initializing the endpoint's XAResource before the endpoint gets invoked.
 */
@Override
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException {
	AbstractMessageEndpoint endpoint = createEndpointInternal();
	endpoint.initXAResource(xaResource);
	return endpoint;
}
 

public void start(final BootstrapContext bootstrapContext) throws ResourceAdapterInternalException {
    assertFalse("Already started", started);
    assertNotNull("bootstrapContext is null", bootstrapContext);
    assertNotNull("bootstrapContext.getWorkManager() is null", bootstrapContext.getWorkManager());
    assertNotNull("bootstrapContext.getXATerminator() is null", bootstrapContext.getXATerminator());
    try {
        assertNotNull("bootstrapContext.createTimer() is null", bootstrapContext.createTimer());
    } catch (final UnavailableException e) {
        throw new ResourceAdapterInternalException("bootstrapContext.createTimer() threw an exception", e);
    }
}
 

public MessageEndpoint createEndpoint(final XAResource xaResource) throws UnavailableException {
    try {
        return new JmsEndpoint(connectionFactory);
    } catch (final JMSException e) {
        e.printStackTrace();
        throw new UnavailableException(e);
    }
}
 

/**
 * Wrap each concrete endpoint instance with an AOP proxy,
 * exposing the message listener's interfaces as well as the
 * endpoint SPI through an AOP introduction.
 */
@Override
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException {
	GenericMessageEndpoint endpoint = (GenericMessageEndpoint) super.createEndpoint(xaResource);
	ProxyFactory proxyFactory = new ProxyFactory(getMessageListener());
	DelegatingIntroductionInterceptor introduction = new DelegatingIntroductionInterceptor(endpoint);
	introduction.suppressInterface(MethodInterceptor.class);
	proxyFactory.addAdvice(introduction);
	return (MessageEndpoint) proxyFactory.getProxy();
}
 

/**
 * The alternative JCA 1.6 version of {@code createEndpoint}.
 * <p>This implementation delegates to {@link #createEndpointInternal()},
 * ignoring the specified timeout. It is only here for JCA 1.6 compliance.
 */
@Override
public MessageEndpoint createEndpoint(XAResource xaResource, long timeout) throws UnavailableException {
	AbstractMessageEndpoint endpoint = createEndpointInternal();
	endpoint.initXAResource(xaResource);
	return endpoint;
}
 

/**
 * {@inheritDoc}
 */
public MessageEndpoint createEndpoint(XAResource xaResource, long timeout) throws UnavailableException
{
   return new TestMessageEndpoint(this);
}
 

/**
 * {@inheritDoc}
 */
public MessageEndpoint createEndpoint(XAResource xaResource) throws UnavailableException
{
   return new TestMessageEndpoint(this);
}
 

@Override
public Timer createTimer() throws UnavailableException {
	return new Timer();
}
 

public MessageEndpoint createEndpoint(final XAResource xaResource, final long timeout) throws UnavailableException {
    return createEndpoint(xaResource);
}