javax.resource.spi.work.WorkCompletedException Java Examples

@Override
public void run() {
	if (this.acceptOnExecution) {
		this.workListener.workAccepted(new WorkEvent(this, WorkEvent.WORK_ACCEPTED, this.work, null));
	}
	synchronized (this.monitor) {
		this.started = true;
		this.monitor.notify();
	}
	this.workListener.workStarted(new WorkEvent(this, WorkEvent.WORK_STARTED, this.work, null));
	try {
		this.work.run();
	}
	catch (RuntimeException | Error ex) {
		this.workListener.workCompleted(
				new WorkEvent(this, WorkEvent.WORK_COMPLETED, this.work, new WorkCompletedException(ex)));
		throw ex;
	}
	this.workListener.workCompleted(new WorkEvent(this, WorkEvent.WORK_COMPLETED, this.work, null));
}
 

@Override
public void run() {
	if (this.acceptOnExecution) {
		this.workListener.workAccepted(new WorkEvent(this, WorkEvent.WORK_ACCEPTED, work, null));
	}
	synchronized (this.monitor) {
		this.started = true;
		this.monitor.notify();
	}
	this.workListener.workStarted(new WorkEvent(this, WorkEvent.WORK_STARTED, this.work, null));
	try {
		this.work.run();
	}
	catch (RuntimeException ex) {
		this.workListener.workCompleted(
				new WorkEvent(this, WorkEvent.WORK_COMPLETED, this.work, new WorkCompletedException(ex)));
		throw ex;
	}
	catch (Error err) {
		this.workListener.workCompleted(
				new WorkEvent(this, WorkEvent.WORK_COMPLETED, this.work, new WorkCompletedException(err)));
		throw err;
	}
	this.workListener.workCompleted(new WorkEvent(this, WorkEvent.WORK_COMPLETED, this.work, null));
}
 

@Override
public void run() {
	if (this.acceptOnExecution) {
		this.workListener.workAccepted(new WorkEvent(this, WorkEvent.WORK_ACCEPTED, this.work, null));
	}
	synchronized (this.monitor) {
		this.started = true;
		this.monitor.notify();
	}
	this.workListener.workStarted(new WorkEvent(this, WorkEvent.WORK_STARTED, this.work, null));
	try {
		this.work.run();
	}
	catch (RuntimeException | Error ex) {
		this.workListener.workCompleted(
				new WorkEvent(this, WorkEvent.WORK_COMPLETED, this.work, new WorkCompletedException(ex)));
		throw ex;
	}
	this.workListener.workCompleted(new WorkEvent(this, WorkEvent.WORK_COMPLETED, this.work, null));
}
 

/**
 * Test for bullet 4 Section 3.3.6
 * When the application server is unable to recreate an execution context if it is  
 *                      specified for the submitted Work instance, it must throw a
 *                      WorkCompletedException set to an appropriate error code.
 * @throws Throwable throwable exception 
 */
@Test(expected = WorkCompletedException.class)
public void testThrowWorkCompletedException() throws Throwable
{
   ExecutionContext ec = new ExecutionContext();
   ShortRunningWork work = new ShortRunningWork();
   ec.setXid(new XidImpl());
   ec.setTransactionTimeout(Long.MAX_VALUE);

   WorkConnection wc = wcf.getConnection();
   try
   {
      wc.doWork(work, WorkManager.INDEFINITE, ec, null);
   }
   finally
   {
      wc.close();
   }
}
 

@Override
public void run() {
	if (this.acceptOnExecution) {
		this.workListener.workAccepted(new WorkEvent(this, WorkEvent.WORK_ACCEPTED, work, null));
	}
	synchronized (this.monitor) {
		this.started = true;
		this.monitor.notify();
	}
	this.workListener.workStarted(new WorkEvent(this, WorkEvent.WORK_STARTED, this.work, null));
	try {
		this.work.run();
	}
	catch (RuntimeException ex) {
		this.workListener.workCompleted(
				new WorkEvent(this, WorkEvent.WORK_COMPLETED, this.work, new WorkCompletedException(ex)));
		throw ex;
	}
	catch (Error err) {
		this.workListener.workCompleted(
				new WorkEvent(this, WorkEvent.WORK_COMPLETED, this.work, new WorkCompletedException(err)));
		throw err;
	}
	this.workListener.workCompleted(new WorkEvent(this, WorkEvent.WORK_COMPLETED, this.work, null));
}
 

@SuppressWarnings("unchecked")
@Override
public void after(final SecurityContext securityContext) throws WorkCompletedException {
    final SecurityService securityService = SystemInstance.get().getComponent(SecurityService.class);
    final Object loginObj = securityService.disassociate();
    if (loginObj != null) {
        try {
            securityService.logout(loginObj);
        } catch (final LoginException e) {
            //Ignore
        }
    }
}
 

@Override
public void before(final SecurityContext securityContext) throws WorkCompletedException {
    if (securityContext != null) {
        callbackHandler = new ConnectorCallbackHandler(securityRealmName);

        final Subject clientSubject = new Subject();
        securityContext.setupSecurityContext(callbackHandler, clientSubject, null);
    }
}
 

/**
 * {@inheritDoc}
 */
public void startWork(Work work, Xid xid) throws WorkCompletedException
{
}
 

/**
 * Test that a work instance can report a failure
 * @throws Throwable throwable exception
 */
@Test
public void testFailure() throws Throwable
{
   Context context = new InitialContext();

   WorkConnectionFactory wcf = (WorkConnectionFactory) context.lookup("java:/eis/WorkConnectionFactory");

   assertNotNull(wcf);

   WorkConnection wc = wcf.getConnection();
   DistributedWorkManager dwm = null;
   try
   {
      assertNotNull(wc.getWorkManager());
      assertTrue(wc.getWorkManager() instanceof javax.resource.spi.work.DistributableWorkManager);

      dwm = (DistributedWorkManager)wc.getWorkManager();
      verifyConfig(dwm);
      dwm.getStatistics().clear();
      dwm.getDistributedStatistics().clear();

      wc.doWork(new MyDistributableFailureWork());

      fail("Expected WorkException");
   }
   catch (WorkException we)
   {
      assertTrue(we instanceof WorkCompletedException);

      WorkException wce = (WorkException)we;

      assertNotNull(wce.getCause());

      assertTrue(wce.getCause() instanceof RuntimeException);
      
      RuntimeException re = (RuntimeException)wce.getCause();

      assertEquals("FAILURE", re.getMessage());
   }
   finally
   {
      assertNotNull(dwm);
      assertNotNull(dwm.getDistributedStatistics());
      assertEquals(1, dwm.getDistributedStatistics().getWorkFailed());

      wc.close();
   }
}
 

/**
 * {@inheritDoc}
 */
public void registerWork(Work work, Xid xid, long timeout) throws WorkCompletedException
{
}
 

/**
 * {@inheritDoc}
 */
public void registerWork(Work work, Xid xid, long timeout) throws WorkCompletedException
{
}
 

/**
 * {@inheritDoc}
 */
public void startWork(Work work, Xid xid) throws WorkCompletedException
{
}
 

/**
 * Run
 */
public void run()
{
   ClassLoader oldCL = SecurityActions.getThreadContextClassLoader();
   SecurityActions.setThreadContextClassLoader(work.getClass().getClassLoader());

   org.ironjacamar.core.spi.security.SecurityContext oldSC = securityIntegration.getSecurityContext();

   try
   {
      start();
      workManager.addWorkWrapper(this);

      if (startedLatch != null)
         startedLatch.countDown();

      work.run();

      end();
   }
   catch (Throwable t)
   {
      exception = new WorkCompletedException(t.getMessage(), t);

      cancel();
   } 
   finally
   {
      workManager.removeWorkWrapper(this);
      work.release();

      if (workListener != null)
      {
         WorkEvent event = new WorkEvent(workManager, WorkEvent.WORK_COMPLETED, work, exception);
         workListener.workCompleted(event);
      }

      securityIntegration.setSecurityContext(oldSC);
      SecurityActions.setThreadContextClassLoader(oldCL);

      if (startedLatch != null)
      {
         while (startedLatch.getCount() != 0)
            startedLatch.countDown();
      }

      if (completedLatch != null)
         completedLatch.countDown();

      if (trace)
         log.tracef("Executed work: %s", this);
   }
}
 

/**
 * Runs the work.
 *
 * @throws WorkCompletedException if there is an error completing work execution
 */
protected void runWork() throws WorkCompletedException
{
   work.run();
}
 

/**
 * Invoked for transaction inflow of work
 * 
 * @param work The work starting
 * @param xid The xid of the work
 * @param timeout The transaction timeout
 * @throws WorkCompletedException with error code WorkException.TX_CONCURRENT_WORK_DISALLOWED
 *         when work is already present for the xid or whose completion is in progress, only
 *         the global part of the xid must be used for this check.
 */
public void registerWork(Work work, Xid xid, long timeout) throws WorkCompletedException;
 

/**
 * Invoked for transaction inflow of work
 * 
 * @param work The work starting
 * @param xid The xid of the work
 * @throws WorkCompletedException With error code WorkException.TX_RECREATE_FAILED if it is unable 
 *         to recreate the transaction context
 */
public void startWork(Work work, Xid xid) throws WorkCompletedException;
 

/**
 * Invoked for transaction inflow of work
 * 
 * @param work The work starting
 * @param xid The xid of the work
 * @param timeout The transaction timeout
 * @throws WorkCompletedException with error code WorkException.TX_CONCURRENT_WORK_DISALLOWED
 *         when work is already present for the xid or whose completion is in progress, only
 *         the global part of the xid must be used for this check.
 */
public void registerWork(Work work, Xid xid, long timeout) throws WorkCompletedException
{
   delegator.registerWork(work, xid, timeout);
}
 

/**
 * Invoked for transaction inflow of work
 * 
 * @param work The work starting
 * @param xid The xid of the work
 * @throws WorkCompletedException With error code WorkException.TX_RECREATE_FAILED if it is unable 
 *         to recreate the transaction context
 */
public void startWork(Work work, Xid xid) throws WorkCompletedException
{
   delegator.startWork(work, xid);
}
 

/**
 * Invoked for transaction inflow of work
 * 
 * @param work The work starting
 * @param xid The xid of the work
 * @param timeout The transaction timeout
 * @throws WorkCompletedException with error code WorkException.TX_CONCURRENT_WORK_DISALLOWED
 *         when work is already present for the xid or whose completion is in progress, only
 *         the global part of the xid must be used for this check.
 */
public void registerWork(Work work, Xid xid, long timeout) throws WorkCompletedException;
 

/**
 * Invoked for transaction inflow of work
 * 
 * @param work The work starting
 * @param xid The xid of the work
 * @throws WorkCompletedException With error code WorkException.TX_RECREATE_FAILED if it is unable 
 *         to recreate the transaction context
 */
public void startWork(Work work, Xid xid) throws WorkCompletedException;
 

/**
 * Invoked for transaction inflow of work
 * 
 * @param work The work starting
 * @param xid The xid of the work
 * @throws WorkCompletedException With error code WorkException.TX_RECREATE_FAILED if it is unable 
 *         to recreate the transaction context
 */
public void startWork(Work work, Xid xid) throws WorkCompletedException
{
   delegator.startWork(work, xid);
}
 

/**
 * Invoked for transaction inflow of work
 * 
 * @param work The work starting
 * @param xid The xid of the work
 * @param timeout The transaction timeout
 * @throws WorkCompletedException with error code WorkException.TX_CONCURRENT_WORK_DISALLOWED
 *         when work is already present for the xid or whose completion is in progress, only
 *         the global part of the xid must be used for this check.
 */
public void registerWork(Work work, Xid xid, long timeout) throws WorkCompletedException
{
   delegator.registerWork(work, xid, timeout);
}