/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.cxf.jca.core.resourceadapter;
import java.io.*;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.resource.NotSupportedException;
import javax.resource.ResourceException;
import javax.resource.spi.ConnectionEvent;
import javax.resource.spi.ConnectionEventListener;
import javax.resource.spi.ConnectionRequestInfo;
import javax.resource.spi.ManagedConnection;
import javax.resource.spi.ManagedConnectionMetaData;
import javax.security.auth.Subject;
import org.apache.cxf.common.logging.LogUtils;
import org.apache.cxf.jca.core.logging.LoggerHelper;
public abstract class AbstractManagedConnectionImpl implements ManagedConnection {
private static final Logger LOG = LogUtils.getL7dLogger(AbstractManagedConnectionImpl.class);
protected PrintWriter printWriter;
protected ConnectionRequestInfo crinfo;
protected Subject subject;
protected Set<ConnectionEventListener> connectionEventListeners =
new HashSet<ConnectionEventListener>();
private final AbstractManagedConnectionFactoryImpl managedConnectionFactory;
public AbstractManagedConnectionImpl(AbstractManagedConnectionFactoryImpl managedFactory,
ConnectionRequestInfo crInfo,
Subject sj) throws ResourceException {
this.managedConnectionFactory = managedFactory;
this.crinfo = (ConnectionRequestInfo)crInfo;
}
public void addConnectionEventListener(ConnectionEventListener aListener) {
LOG.log(Level.FINE, "ADD_EVENT_LISTENER_CALLED", new Object[] {this, aListener});
connectionEventListeners.add(aListener);
}
public void removeConnectionEventListener(ConnectionEventListener aListener) {
connectionEventListeners.remove(aListener);
}
public abstract void associateConnection(Object arg0) throws ResourceException;
//public abstract LocalTransaction getLocalTransaction() throws ResourceException;
//public abstract javax.transaction.xa.XAResource getXAResource() throws ResourceException;
public abstract Object getConnection(Subject aSubject, ConnectionRequestInfo aCrInfo)
throws ResourceException;
public abstract boolean isBound();
public void close(Object closingHandle) throws ResourceException {
LOG.fine("closing handle: " + closingHandle);
ConnectionEvent coEvent = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
coEvent.setConnectionHandle(closingHandle);
sendEvent(coEvent);
}
// going back in the pool
public void cleanup() throws ResourceException {
LOG.log(Level.FINE, "CLEANUP_CALLED", new Object[] {this});
}
// beging chucked from the pool
public void destroy() throws ResourceException {
LOG.log(Level.FINE, "DESTROY_CALLED", new Object[] {this});
connectionEventListeners = new HashSet<ConnectionEventListener>();
LoggerHelper.deleteLoggingOnWriter();
if (printWriter != null) {
printWriter.close();
}
}
public PrintWriter getLogWriter() throws ResourceException {
return printWriter;
}
public ManagedConnectionMetaData getMetaData() throws ResourceException {
throw new NotSupportedException("NOT_YET_IMPLEMENTED getMetaData");
}
public void setLogWriter(PrintWriter aPrintWriter) throws ResourceException {
printWriter = aPrintWriter;
if (printWriter != null) {
LoggerHelper.initializeLoggingOnWriter(printWriter);
}
}
public Subject getSubject() {
return subject;
}
public void setSubject(Subject sj) {
this.subject = sj;
}
protected ConnectionRequestInfo getConnectionRequestInfo() {
return crinfo;
}
protected void setConnectionRequestInfo(ConnectionRequestInfo info) {
this.crinfo = info;
}
protected void sendEvent(ConnectionEvent coEvent) {
Iterator iter = connectionEventListeners.iterator();
while (iter.hasNext()) {
sendEventToListener(coEvent, (ConnectionEventListener)iter.next());
}
}
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});
}
}
protected AbstractManagedConnectionFactoryImpl theManagedConnectionFactory() {
return managedConnectionFactory;
}
public String toString() {
return "[" + getClass().getName() + ":" + hashCode() + ":ManagedConnection[" + crinfo + "]";
}
public void error(Exception ex) {
LOG.warning(ex.toString());
sendEvent(new ConnectionEvent(this, ConnectionEvent.CONNECTION_ERROR_OCCURRED, ex));
}
}