javax.resource.spi.ActivationSpec Java Examples

/**
 * Prepares the message endpoint, and automatically activates it
 * if the "autoStartup" flag is set to "true".
 */
@Override
public void afterPropertiesSet() throws ResourceException {
	if (getResourceAdapter() == null) {
		throw new IllegalArgumentException("Property 'resourceAdapter' is required");
	}
	if (getMessageEndpointFactory() == null) {
		throw new IllegalArgumentException("Property 'messageEndpointFactory' is required");
	}
	ActivationSpec activationSpec = getActivationSpec();
	if (activationSpec == null) {
		throw new IllegalArgumentException("Property 'activationSpec' is required");
	}

	if (activationSpec.getResourceAdapter() == null) {
		activationSpec.setResourceAdapter(getResourceAdapter());
	}
	else if (activationSpec.getResourceAdapter() != getResourceAdapter()) {
		throw new IllegalArgumentException("ActivationSpec [" + activationSpec +
				"] is associated with a different ResourceAdapter: " + activationSpec.getResourceAdapter());
	}
}
 

/**
 * Prepares the message endpoint, and automatically activates it
 * if the "autoStartup" flag is set to "true".
 */
@Override
public void afterPropertiesSet() throws ResourceException {
	if (getResourceAdapter() == null) {
		throw new IllegalArgumentException("Property 'resourceAdapter' is required");
	}
	if (getMessageEndpointFactory() == null) {
		throw new IllegalArgumentException("Property 'messageEndpointFactory' is required");
	}
	ActivationSpec activationSpec = getActivationSpec();
	if (activationSpec == null) {
		throw new IllegalArgumentException("Property 'activationSpec' is required");
	}

	if (activationSpec.getResourceAdapter() == null) {
		activationSpec.setResourceAdapter(getResourceAdapter());
	}
	else if (activationSpec.getResourceAdapter() != getResourceAdapter()) {
		throw new IllegalArgumentException("ActivationSpec [" + activationSpec +
				"] is associated with a different ResourceAdapter: " + activationSpec.getResourceAdapter());
	}
}
 

/**
 * Get XA resources
 *
 * @param specs The activation specs
 * @return The XA resources
 * @throws ResourceException Thrown if an error occurs or unsupported
 */
@Override
public XAResource[] getXAResources(final ActivationSpec[] specs) throws ResourceException {
   if (logger.isTraceEnabled()) {
      logger.trace("getXAResources(" + Arrays.toString(specs) + ")");
   }

   if (useAutoRecovery) {
      // let the TM handle the recovery
      return null;
   } else {
      List<XAResource> xaresources = new ArrayList<>();
      for (ActivationSpec spec : specs) {
         ActiveMQActivation activation = activations.get(spec);
         if (activation != null) {
            xaresources.addAll(activation.getXAResources());
         }
      }
      return xaresources.toArray(new XAResource[xaresources.size()]);
   }
}
 

/**
 * Endpoint activation
 *
 * @param endpointFactory The endpoint factory
 * @param spec            The activation spec
 * @throws ResourceException Thrown if an error occurs
 */
@Override
public void endpointActivation(final MessageEndpointFactory endpointFactory,
                               final ActivationSpec spec) throws ResourceException {
   if (spec == null) {
      throw ActiveMQRABundle.BUNDLE.noActivationSpec();
   }
   if (!configured.getAndSet(true)) {
      try {
         setup();
      } catch (ActiveMQException e) {
         throw new ResourceException("Unable to create activation", e);
      }
   }
   if (logger.isTraceEnabled()) {
      logger.trace("endpointActivation(" + endpointFactory + ", " + spec + ")");
   }

   ActiveMQActivation activation = new ActiveMQActivation(this, endpointFactory, (ActiveMQActivationSpec) spec);
   activations.put(spec, activation);
   activation.start();
}
 

/**
 * {@inheritDoc}
 */
@Override
public void initialize() throws Exception
{
   if (rar != null)
   {
      for (XAResource xar : rar.getXAResources(new ActivationSpec[] {as}))
      {
         // Trigger a recovery pass
         xar.recover(XAResource.TMSTARTRSCAN);
         xar.recover(XAResource.TMENDRSCAN);
      }
   }
   else
   {
      // Create ManagedConnection
      mc = mcf.createManagedConnection(subjectFactory.createSubject(securityDomain), null);
      
      // Trigger a recovery pass
      mc.getXAResource().recover(XAResource.TMSTARTRSCAN);
      mc.getXAResource().recover(XAResource.TMENDRSCAN);
   }
}
 

/**
 * Constructor
 *
 * @param rar The resource adapter
 * @param as The activation spec
 * @param productName The product name
 * @param productVersion The product version
 */
public XAResourceRecoveryInflowImpl(ResourceAdapter rar, ActivationSpec as,
                                    String productName, String productVersion)
{
   if (rar == null)
      throw new IllegalArgumentException("ResourceAdapter is null");

   if (as == null)
      throw new IllegalArgumentException("ActivationSpec is null");

   this.resourceAdapter = rar;
   this.activationSpec = as;
   this.productName = productName;
   this.productVersion = productVersion;
   this.jndiName = null;
}
 

public void endpointDeactivation(MessageEndpointFactory mef, ActivationSpec as) {

        if  (!(as instanceof MDBActivationSpec)) {
            LOG.fine("Ignored unknown activation spec " + as);
            return;
        }

        MDBActivationSpec spec = (MDBActivationSpec)as;
        LOG.info("CXF resource adapter is deactivating " + spec.getDisplayName());

        InboundEndpoint endpoint = endpoints.remove(spec.getDisplayName());
        if (endpoint != null) {
            try {
                endpoint.shutdown();
            } catch (Exception e) {
                LOG.log(Level.WARNING, "Failed to stop endpoint "
                        + spec.getDisplayName(), e);
            }
        }
    }
 

/**
 * {@inheritDoc}
 */
public void endpointActivation(MessageEndpointFactory mef, ActivationSpec as) throws Exception
{
   if (mef == null)
      throw new Exception("MessageEndpointFactory is null");

   if (as == null)
      throw new Exception("ActivationSpec is null");

   as.setResourceAdapter(resourceAdapter);
   
   try
   {
      as.validate();
   }
   catch (UnsupportedOperationException uoe)
   {
      // Ignore
   }

   if (is16)
   {
      verifyBeanValidation(as);
   }
   
   resourceAdapter.endpointActivation(mef, as);

   InflowRecovery ir = null;
   if (transactionIntegration != null && transactionIntegration.getRecoveryRegistry() != null)
   {
      XAResourceRecovery xar = transactionIntegration.createXAResourceRecovery(resourceAdapter,
                                                                               as,
                                                                               productName, productVersion);

      ir = new InflowRecoveryImpl(mef, as, xar, transactionIntegration.getRecoveryRegistry());
      ir.activate();
   }

   activeEndpoints.put(new Endpoint(mef, as), ir);
}
 

public MdbActivationContext(final ClassLoader classLoader, final BeanContext beanContext, final ResourceAdapter resourceAdapter, final EndpointFactory endpointFactory, final ActivationSpec activationSpec) {
    this.classLoader = classLoader;
    this.beanContext = beanContext;
    this.resourceAdapter = resourceAdapter;
    this.endpointFactory = endpointFactory;
    this.activationSpec = activationSpec;
}
 

public void endpointActivation(final MessageEndpointFactory messageEndpointFactory, final ActivationSpec activationSpec)
        throws ResourceException
{
    final SampleActivationSpec sampleActivationSpec = (SampleActivationSpec) activationSpec;

    try {
        targets.put(sampleActivationSpec, messageEndpointFactory);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

/**
 * {@inheritDoc}
 */
public XAResourceRecovery createXAResourceRecovery(ResourceAdapter rar,
                                                   ActivationSpec as,
                                                   String productName, String productVersion)
{
   return new XAResourceRecoveryInflowImpl(rar, as, productName, productVersion);
}
 

public void endpointActivation(MessageEndpointFactory mef, ActivationSpec as)
    throws ResourceException {

    if  (!(as instanceof MDBActivationSpec)) {
        LOG.fine("Ignored unknown activation spec " + as);
        return;
    }

    MDBActivationSpec spec = (MDBActivationSpec)as;
    LOG.info("CXF resource adapter is activating " + spec.getDisplayName());

    Work work = new MDBActivationWork(spec, mef, endpoints);
    ctx.getWorkManager().scheduleWork(work);

}
 

public void endpointDeactivation(MessageEndpointFactory endpointFactory, ActivationSpec spec) {
  try {
    if(jobHandlerActivation != null) {
      jobHandlerActivation.stop();
    }
  } finally {
    jobHandlerActivation = null;
  }
}
 

/**
 * Stop
 */
@Override
public void stop() {
   if (logger.isTraceEnabled()) {
      logger.trace("stop()");
   }

   for (Map.Entry<ActivationSpec, ActiveMQActivation> entry : activations.entrySet()) {
      try {
         entry.getValue().stop();
      } catch (Exception ignored) {
         ActiveMQRALogger.LOGGER.debug("Ignored", ignored);
      }
   }

   activations.clear();

   for (ActiveMQRAManagedConnectionFactory managedConnectionFactory : managedConnectionFactories) {
      managedConnectionFactory.stop();
   }

   managedConnectionFactories.clear();

   for (Pair<ActiveMQConnectionFactory, AtomicInteger> pair : knownConnectionFactories.values()) {
      pair.getA().close();
   }
   knownConnectionFactories.clear();

   if (defaultActiveMQConnectionFactory != null) {
      defaultActiveMQConnectionFactory.close();
   }

   if (recoveryActiveMQConnectionFactory != null) {
      recoveryActiveMQConnectionFactory.close();
   }

   recoveryManager.stop();

   ActiveMQRALogger.LOGGER.raStopped();
}
 

/**
 * This implementation always throws a NotSupportedException.
 */
@Override
public void endpointActivation(MessageEndpointFactory messageEndpointFactory, ActivationSpec activationSpec)
		throws ResourceException {

	throw new NotSupportedException("SpringContextResourceAdapter does not support message endpoints");
}
 

public void endpointDeactivation(final MessageEndpointFactory messageEndpointFactory, final ActivationSpec activationSpec) {
    final EmailAccountInfo accountInfo = (EmailAccountInfo) activationSpec;

    final EmailConsumer emailConsumer = consumers.remove(accountInfo.getAddress());
    final MessageEndpoint endpoint = (MessageEndpoint) emailConsumer;
    endpoint.release();
}
 

@Override
public void endpointDeactivation(MessageEndpointFactory endpointFactory, ActivationSpec spec) {
    log.log(Level.INFO, "deactivating endpoint");
}
 

/**
 * Constructor
 * @param mef The MessageEndpointFactory
 * @param as The ActivationSpec
 */
Endpoint(MessageEndpointFactory mef, ActivationSpec as)
{
   this.mef = mef;
   this.as = as;
}
 

protected ActiveMQActivation lookupActivation(ActiveMQResourceAdapter qResourceAdapter) {
   Map<ActivationSpec, ActiveMQActivation> activations = qResourceAdapter.getActivations();
   assertEquals(1, activations.size());

   return activations.values().iterator().next();
}
 

public XAResource[] getXAResources(ActivationSpec[] specs) throws ResourceException {
  log.finest("getXAResources()");
  return null;
}
 

@Override
public void endpointActivation(final MessageEndpointFactory endpointFactory, final ActivationSpec spec) throws ResourceException {
    // no-op
}
 

@Override
public void endpointActivation(MessageEndpointFactory messageEndpointFactory, ActivationSpec activationSpec) throws ResourceException {
}
 

public XAResource[] getXAResources(final ActivationSpec[] activationSpecs) throws ResourceException {
    return new XAResource[0];
}
 

public void endpointDeactivation(MessageEndpointFactory endpointFactory, ActivationSpec spec) {
}
 

/**
 * This implementation always returns {@code null}.
 */
@Override
public XAResource[] getXAResources(ActivationSpec[] activationSpecs) throws ResourceException {
	return null;
}
 

@Override
public XAResource[] getXAResources(ActivationSpec[] activationSpecs) throws ResourceException {
    return null;
}
 

@Override
public XAResource[] getXAResources(final ActivationSpec[] specs) throws ResourceException {
    return new XAResource[0];
}
 

/**
 * {@inheritDoc}
 */
public ActivationSpec createActivationSpec() throws Exception
{
   return activationSpecClass.newInstance();
}
 

/**
 * Constructor
 * @param rar The resource adapter
 * @param as The activation spec
 */
public XAResourceRecoveryImpl(ResourceAdapter rar, ActivationSpec as)
{
   this.rar = rar;
   this.as = as;
}
 

@Override
public void endpointDeactivation(final MessageEndpointFactory endpointFactory, final ActivationSpec spec) {
    // no-op
}