javax.resource.spi.ConnectionEventListener Java Examples

public void onClose(GFConnectionImpl conn) throws ResourceException
{
  conn.invalidate();
  this.connections.remove(conn);
  synchronized (this.listeners) {
    Iterator<ConnectionEventListener> itr = this.listeners.iterator();
    ConnectionEvent ce = new ConnectionEvent(this,
        ConnectionEvent.CONNECTION_CLOSED);
    ce.setConnectionHandle(conn);
    while (itr.hasNext()) {
      itr.next().connectionClosed(ce);
    }
  }
  if (this.connections.isEmpty()) {
    // safe to dissociate this managedconnection so that it can go to pool
    if (this.initDone && !this.cache.isClosed()) {
      this.localTran = new JCALocalTransaction(this.cache, this.gfTxMgr);
    }
    else {
      this.localTran = new JCALocalTransaction();
    }
  }

}
 

/**
 * {@inheritDoc}
 */
public void commit() throws ResourceException
{
   if (txCommitDuration > 0)
   {
      try
      {
         Thread.sleep(txCommitDuration);
      }
      catch (Exception e)
      {
         // Ignore
      }
   }

   ConnectionEvent ce = new ConnectionEvent(this, ConnectionEvent.LOCAL_TRANSACTION_COMMITTED);
   
   for (ConnectionEventListener cel : listeners)
   {
      cel.localTransactionCommitted(ce);
   }
}
 

/**
 * Destroys the underline physical connection to EIS.
 * 
 * @param connectionObject connection Object.
 */
@Override
void destroyPooledConnection(Object connectionObject) {
  try {
    ((ManagedConnection) connectionObject)
        .removeConnectionEventListener((ConnectionEventListener) connEventListner);
    ((ManagedConnection) connectionObject).destroy();
    connectionObject = null;
  }
  catch (ResourceException rex) {
    LogWriterI18n writer = TransactionUtils.getLogWriterI18n();
    if (writer.finerEnabled())
        writer
            .finer(
                "ManagedPoolcacheImpl::destroyPooledConnection:Exception in closing the connection.Ignoring it. The exeption is "
                    + rex.toString(), rex);
  }
}
 

protected void sendEventToListener(ConnectionEvent coEvent, ConnectionEventListener listener) {
    if (coEvent.getId() == ConnectionEvent.CONNECTION_CLOSED) {
        listener.connectionClosed(coEvent);
        LOG.log(Level.FINE, "CONNECTION_CLOSED_EVENT_FIRED", new Object[] {listener});
    }

    if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_COMMITTED) {
        listener.localTransactionCommitted(coEvent);
        LOG.log(Level.FINE, "LOCAL_TX_COMMITTED_EVENT_FIRED", new Object[] {listener});
    }

    if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK) {
        listener.localTransactionRolledback(coEvent);
        LOG.log(Level.FINE, "LOCAL_TX_ROLLEDBACK_EVENT_FIRED", new Object[] {listener});
    }

    if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_STARTED) {
        listener.localTransactionStarted(coEvent);
        LOG.log(Level.FINE, "LOCAL_TX_STARTED_EVENT_FIRED", new Object[] {listener});
    }

    if (coEvent.getId() == ConnectionEvent.CONNECTION_ERROR_OCCURRED) {
        listener.connectionErrorOccurred(coEvent);
        LOG.log(Level.FINE, "CTX_ERROR_OCURRED_EVENT_FIRED", new Object[] {listener});
    }
}
 

@Test
public void testRemoveConnectionEventListener() throws Exception {
    ConnectionEvent event = new ConnectionEvent(mc, ConnectionEvent.CONNECTION_ERROR_OCCURRED);

    ConnectionEventListener listener = EasyMock.createMock(ConnectionEventListener.class);
    mc.addConnectionEventListener(listener);
    listener.connectionErrorOccurred(EasyMock.isA(ConnectionEvent.class));
    EasyMock.expectLastCall();
    EasyMock.replay(listener);
    mc.sendEvent(event);
    EasyMock.verify(listener);

    mc.removeConnectionEventListener(listener);
    mc.sendEvent(event);

}
 

/**
 * {@inheritDoc}
 */
public void rollback() throws ResourceException
{
   if (txCommitDuration > 0)
   {
      try
      {
         Thread.sleep(txCommitDuration);
      }
      catch (Exception e)
      {
         // Ignore
      }
   }

   ConnectionEvent ce = new ConnectionEvent(this, ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK);
   
   for (ConnectionEventListener cel : listeners)
   {
      cel.localTransactionRolledback(ce);
   }
}
 

private void onError(Exception e)
{

  this.localTran = null;

  synchronized (this.connections) {
    Iterator<GFConnectionImpl> connsItr = this.connections.iterator();
    while (connsItr.hasNext()) {
      GFConnectionImpl conn = connsItr.next();
      conn.invalidate();
      synchronized (this.listeners) {
        Iterator<ConnectionEventListener> itr = this.listeners.iterator();
        ConnectionEvent ce = new ConnectionEvent(this,
            ConnectionEvent.CONNECTION_ERROR_OCCURRED, e);
        ce.setConnectionHandle(conn);
        while (itr.hasNext()) {
          itr.next().connectionErrorOccurred(ce);
        }
      }
      connsItr.remove();
    }
  }

}
 

private void onError(Exception e)
{

  this.localTran = null;

  synchronized (this.connections) {
    Iterator<GFConnectionImpl> connsItr = this.connections.iterator();
    while (connsItr.hasNext()) {
      GFConnectionImpl conn = connsItr.next();
      conn.invalidate();
      synchronized (this.listeners) {
        Iterator<ConnectionEventListener> itr = this.listeners.iterator();
        ConnectionEvent ce = new ConnectionEvent(this,
            ConnectionEvent.CONNECTION_ERROR_OCCURRED, e);
        ce.setConnectionHandle(conn);
        while (itr.hasNext()) {
          itr.next().connectionErrorOccurred(ce);
        }
      }
      connsItr.remove();
    }
  }

}
 

private void sendEventToListener(ConnectionEventListener listener,
        ConnectionEvent coEvent) {
    if (coEvent.getId() == ConnectionEvent.CONNECTION_CLOSED) {
        listener.connectionClosed(coEvent);
    }

    if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_COMMITTED) {
        listener.localTransactionCommitted(coEvent);
    }

    if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK) {
        listener.localTransactionRolledback(coEvent);
    }

    if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_STARTED) {
        listener.localTransactionStarted(coEvent);
    }

    if (coEvent.getId() == ConnectionEvent.CONNECTION_ERROR_OCCURRED) {
        listener.connectionErrorOccurred(coEvent);
    }

}
 

/**
 * Destroys the underline physical connection to EIS.
 * 
 * @param connectionObject connection Object.
 */
@Override
void destroyPooledConnection(Object connectionObject) {
  try {
    ((ManagedConnection) connectionObject)
        .removeConnectionEventListener((ConnectionEventListener) connEventListner);
    ((ManagedConnection) connectionObject).destroy();
    connectionObject = null;
  }
  catch (ResourceException rex) {
    LogWriterI18n writer = TransactionUtils.getLogWriterI18n();
    if (writer.finerEnabled())
        writer
            .finer(
                "ManagedPoolcacheImpl::destroyPooledConnection:Exception in closing the connection.Ignoring it. The exeption is "
                    + rex.toString(), rex);
  }
}
 

/**
 * default constructor
 * @param mcf mcf
 */
public HelloWorldManagedConnection(HelloWorldManagedConnectionFactory mcf)
{
   this.mcf = mcf;
   this.logWriter = null;
   this.listeners = Collections.synchronizedList(new ArrayList<ConnectionEventListener>(1));
   this.connections = new HashSet<HelloWorldConnectionImpl>();
}
 

/**
 * Default constructor
 * @param mcf mcf
 */
public TxLogManagedConnection(TxLogManagedConnectionFactory mcf)
{
   this.mcf = mcf;
   this.id = Integer.toHexString(System.identityHashCode(this));
   this.logwriter = null;
   this.listeners = Collections.synchronizedList(new ArrayList<ConnectionEventListener>(1));
   this.connections = new HashSet<TxLogConnectionImpl>();
   this.inPool = true;
}
 

public void addConnectionEventListener(ConnectionEventListener listener) {
    log.finest("addConnectionEventListener()");

    if (listener == null) {
        throw new IllegalArgumentException("Listener is null");
    }

    listeners.add(listener);
}
 

/**
 * Close handle
 */
void closeHandle()
{
   ConnectionEvent closeEvent = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
   closeEvent.setConnectionHandle(connection);

   List<ConnectionEventListener> copy = new ArrayList<ConnectionEventListener>(listeners);
   for (ConnectionEventListener cel : copy)
   {
      cel.connectionClosed(closeEvent);
   }
}
 

/**
 * Adds a connection event listener to the ManagedConnection instance.
 *
 * @param listener A new ConnectionEventListener to be registered
 */
public void addConnectionEventListener(ConnectionEventListener listener)
{
   if (listener == null)
      throw new IllegalArgumentException("Listener is null");

   listeners.add(listener);
}
 

/**
 * Removes an already registered connection event listener 
 * from the ManagedConnection instance.
 *
 * @param listener Already registered connection event listener to be removed
 */
public void removeConnectionEventListener(ConnectionEventListener listener)
{
   if (listener == null)
      throw new IllegalArgumentException("Listener is null");

   listeners.remove(listener);
}
 

/**
 * Close handle
 * @param handle The handle
 */
void closeHandle(HelloWorldConnection handle)
{
   connections.remove((HelloWorldConnectionImpl)handle);

   ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
   event.setConnectionHandle(handle);

   for (ConnectionEventListener cel : listeners)
   {
      cel.connectionClosed(event);
   }
}
 

void closeHandle(JcaExecutorServiceConnection handle) {
  ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
  event.setConnectionHandle(handle);
  for (ConnectionEventListener cel : listeners) {
    cel.connectionClosed(event);
  }

}
 

/**
 * Constructor
 * @param mcf mcf
 */
public HelloWorldManagedConnection(HelloWorldManagedConnectionFactory mcf)
{
   this.mcf = mcf;
   this.logWriter = null;
   this.listeners = Collections.synchronizedList(new ArrayList<ConnectionEventListener>(1));
   this.connections = new HashSet<HelloWorldConnectionImpl>();
}
 

/**
 * Error handle
 */
void errorHandle()
{
   ConnectionEvent errorEvent = new ConnectionEvent(this, ConnectionEvent.CONNECTION_ERROR_OCCURRED,
                                                    new Exception());
   errorEvent.setConnectionHandle(connection);

   List<ConnectionEventListener> copy = new ArrayList<ConnectionEventListener>(listeners);
   for (ConnectionEventListener cel : copy)
   {
      cel.connectionErrorOccurred(errorEvent);
   }
}
 

/**
 * Error handle
 *
 * @param handle The handle
 * @param exception The exception
 */
void errorHandle(TxLogConnection handle, Exception exception)
{
   connections.remove((TxLogConnectionImpl)handle);

   ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_ERROR_OCCURRED, exception);
   event.setConnectionHandle(handle);

   List<ConnectionEventListener> copy = new ArrayList<ConnectionEventListener>(listeners);
   for (ConnectionEventListener cel : copy)
   {
      cel.connectionErrorOccurred(event);
   }
}
 

/**
 * Removes an already registered connection event listener from the ManagedConnection instance.
 *
 * @param listener already registered connection event listener to be removed
 */
public void removeConnectionEventListener(ConnectionEventListener listener)
{
   if (listener == null)
      throw new IllegalArgumentException("Listener is null");

   listeners.remove(listener);
}
 

public void addConnectionEventListener(ConnectionEventListener listener) {
    log.finest("addConnectionEventListener()");

    if (listener == null) {
        throw new IllegalArgumentException("Listener is null");
    }

    listeners.add(listener);
}
 

/**
 * Default constructor
 * @param mcf mcf
 * @param tb Transaction begin duration
 * @param tc Transaction commit duration
 */
public PerfManagedConnection(PerfManagedConnectionFactory mcf, long tb, long tc)
{
   this.mcf = mcf;
   this.txBeginDuration = tb;
   this.txCommitDuration = tc;
   this.logwriter = null;
   this.listeners = Collections.synchronizedList(new ArrayList<ConnectionEventListener>(1));
   this.connection = new PerfConnectionImpl(this);
}
 

@Override
public void removeConnectionEventListener(final ConnectionEventListener listener) {
    if (listener == null) {
        throw new IllegalArgumentException("Listener is null");
    }

    listeners.remove(listener);
}
 

/**
 * Close handle
 * @param handle The handle
 */
void closeHandle(HelloWorldConnection handle)
{
   connections.remove((HelloWorldConnectionImpl)handle);

   ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
   event.setConnectionHandle(handle);

   for (ConnectionEventListener cel : listeners)
   {
      cel.connectionClosed(event);
   }
}
 

/**
 * Adds a connection event listener to the ManagedConnection instance.
 *
 * @param listener A new ConnectionEventListener to be registered
 */
public void addConnectionEventListener(ConnectionEventListener listener)
{
   log.trace("addConnectionEventListener()");
   if (listener == null)
      throw new IllegalArgumentException("Listener is null");
   listeners.add(listener);
}
 

/**
 * Close handle
 *
 * @param handle The handle
 */
void closeHandle(WorkConnection handle)
{
   ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
   event.setConnectionHandle(handle);
   for (ConnectionEventListener cel : listeners)
   {
      cel.connectionClosed(event);
   }

}
 

/**
 * Removes an already registered connection event listener from the ManagedConnection instance.
 *
 * @param listener already registered connection event listener to be removed
 */
public void removeConnectionEventListener(ConnectionEventListener listener)
{
   if (listener == null)
      throw new IllegalArgumentException("Listener is null");
   listeners.remove(listener);
}
 

public void close() {

		Enumeration list = listeners.elements();
		ConnectionEvent event =
			new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
		event.setConnectionHandle(connection);
		while (list.hasMoreElements()) {
			((ConnectionEventListener) list.nextElement()).connectionClosed(event);
		}
	}