public class FBManagedConnection
extends java.lang.Object
implements ManagedConnection, XAResource, org.firebirdsql.gds.impl.GDSHelper.GDSHelperErrorListener
addConnectionEventListener
public void addConnectionEventListener(ConnectionEventListener listener)
Add an ConnectionEventListener
listener. The listener will
be notified when a ConnectionEvent
occurs.
listener
- The ConnectionEventListener
to be added
associateConnection
public void associateConnection(Object connection)
throws ResourceException
Used by the container to change the association of an application-level
connection handle with a ManagedConneciton instance. The container should
find the right ManagedConnection instance and call the
associateConnection method.
The resource adapter is required to implement the associateConnection
method. The method implementation for a ManagedConnection should
dissociate the connection handle (passed as a parameter) from its
currently associated ManagedConnection and associate the new connection
handle with itself.
connection
- Application-level connection handle
cleanup
public void cleanup()
throws ResourceException
Application server calls this method to force any cleanup on the
ManagedConnection
instance.
The method
ManagedConnection.cleanup
initiates a cleanup of the
any client-specific state as maintained by a ManagedConnection instance.
The cleanup should invalidate all connection handles that had been
created using this
ManagedConnection
instance. Any attempt
by an application component to use the connection handle after cleanup of
the underlying
ManagedConnection
should result in an
exception.
The cleanup of ManagedConnection is always driven by an application
server. An application server should not invoke
ManagedConnection.cleanup
when there is an uncompleted
transaction (associated with a ManagedConnection instance) in progress.
The invocation of
ManagedConnection.cleanup
method on an already
cleaned-up connection should not throw an exception.
The cleanup of
ManagedConnection
instance resets its
client specific state and prepares the connection to be put back in to a
connection pool. The cleanup method should not cause resource adapter to
close the physical pipe and reclaim system resources associated with the
physical connection.
close
public void close(AbstractConnection c)
Close this connection with regards to a wrapping
AbstractConnection
.
c
- The AbstractConnection
that is being closed
commit
public void commit(Xid id,
boolean onePhase)
throws XAException
Commits a transaction.
destroy
public void destroy()
throws ResourceException
Destroys the physical connection to the underlying resource manager. To
manage the size of the connection pool, an application server can
explictly call ManagedConnection.destroy
to destroy a physical
connection. A resource adapter should destroy all allocated system
resources for this ManagedConnection
instance when the
method destroy is called.
end
public void end(Xid id,
int flags)
throws XAException
Dissociates a resource from a global transaction.
errorOccured
public void errorOccured(GDSException ex)
Notify GDS container that error occured, if the ex
represents a "fatal" one
FatalGDSErrorHelper.isFatal(GDSException)
forget
public void forget(Xid id)
throws javax.transaction.xa.XAException
Indicates that no further action will be taken on behalf of this
transaction (after a heuristic failure). It is assumed this will be
called after a failed commit or rollback. This should actually never be
called since we don't use heuristic tx completion on timeout.
getConnection
public Object getConnection(Subject subject,
ConnectionRequestInfo cri)
throws ResourceException
Creates a new connection handle for the underlying physical connection
represented by the
ManagedConnection
instance. This
connection handle is used by the application code to refer to the
underlying physical connection. A connection handle is tied to its
ManagedConnection
instance in a resource adapter
implementation specific way.
The
ManagedConnection
uses the Subject and additional
ConnectionRequestInfo
(which is specific to resource
adapter and opaque to application server) to set the state of the
physical connection.
subject
- security context as JAAS subjectcri
- ConnectionRequestInfo instance
- generic
Object
instance representing the
connection handle. For CCI, the connection handle created by a
ManagedConnection
instance is of the type
javax.resource.cci.Connection
.
getConnectionRequestInfo
public FBConnectionRequestInfo getConnectionRequestInfo()
Get information about the current connection parameters.
getDatabase
public String getDatabase()
getGDSHelper
public org.firebirdsql.gds.impl.GDSHelper getGDSHelper()
throws GDSException
Get instance of GDSHelper
connected with this managed connection.
getLocalTransaction
public LocalTransaction getLocalTransaction()
Returns a javax.resource.spi.LocalTransaction
instance.
The LocalTransaction interface is used by the container to manage local
transactions for a RM instance.
- LocalTransaction instance
getLogWriter
public PrintWriter getLogWriter()
Gets the log writer for this ManagedConnection instance.
The log writer is a character output stream to which all logging and
tracing messages for this ManagedConnection instance will be printed.
ConnectionManager
manages the association of output stream
with the
ManagedConnection
instance based on the
connection pooling requirements.
The Log writer associated with a
ManagedConnection
instance can be one set as default from the ManagedConnectionFactory
(that created this connection) or one set specifically for this instance
by the application server.
- Character ourput stream associated with this
ManagedConnection
getManagedConnectionFactory
public ManagedConnectionFactory getManagedConnectionFactory()
Get the managed connection factory that created this managed connection.
- instance of
ManagedConnectionFactory
.
getMetaData
public ManagedConnectionMetaData getMetaData()
throws ResourceException
Gets the metadata information for this connection's underlying EIS
resource manager instance. The ManagedConnectionMetaData interface
provides information about the underlying EIS instance associated with
the ManagedConenction instance.
- ManagedConnectionMetaData instance
getTransactionIsolation
public int getTransactionIsolation()
throws ResourceException
Get the transaction isolation level of this connection. The level is one
of the static final fields of java.sql.Connection
(i.e.
TRANSACTION_READ_COMMITTED
,
TRANSACTION_READ_UNCOMMITTED
,
TRANSACTION_REPEATABLE_READ
,
TRANSACTION_SERIALIZABLE
.
- Value representing a transaction isolation level defined in
java.sql.Connection
.
getTransactionTimeout
public int getTransactionTimeout()
throws javax.transaction.xa.XAException
Gets the transaction timeout.
getXAResource
public javax.transaction.xa.XAResource getXAResource()
Return an XA resource to the caller.
In both
javax.sql.XAConnection
and
javax.resource.spi.MangagedConnection
.
inTransaction
public boolean inTransaction()
internalStart
public void internalStart(Xid id,
int flags)
throws XAException,
GDSException
Perform the internal processing to start associate a JDBC connection with
a global transaction.
id
- A global transaction identifier to be associated with the
resourceflags
- One of TMNOFLAGS, TMJOIN, or TMRESUME
isConnectionSharing
public boolean isConnectionSharing()
Check if connection sharing is enabled. When connection sharing is
enabled, multiple connection handles (
AbstractConnection
instances)
can access this managed connection in thread-safe manner (they synchronize
on this instance). This feature can be enabled only in JCA environment,
any other environment must not use connection sharing.
true
if connection sharing is enabled.
isManagedEnvironment
public boolean isManagedEnvironment()
isReadOnly
public boolean isReadOnly()
Retrieve whether this connection is readonly.
true
if this connection is readonly,
false
otherwise
isSameRM
public boolean isSameRM(XAResource res)
throws javax.transaction.xa.XAException
Retrieve whether this FBManagedConnection
uses the same
ResourceManager as res
. This method relies on
res
being a Firebird implementation of
XAResource
.
res
- The other XAResource
to compare to
true
if res
uses the same
ResourceManager, false
otherwise
prepare
public int prepare(Xid xid)
throws javax.transaction.xa.XAException
Prepares a transaction to commit.
recover
public Xid[] recover(int flag)
throws javax.transaction.xa.XAException
Obtain a list of prepared transaction branches from a resource manager.
The transaction manager calls this method during recovery to obtain the
list of transaction branches that are currently in prepared or
heuristically completed states.
flag
- One of TMSTARTRSCAN, TMENDRSCAN, TMNOFLAGS. TMNOFLAGS must be
used when no other flags are set in flags.
- The resource manager returns zero or more XIDs for the
transaction branches that are currently in a prepared or
heuristically completed state. If an error occurs during the
operation, the resource manager should throw the appropriate
XAException.
removeConnectionEventListener
public void removeConnectionEventListener(ConnectionEventListener listener)
Remove a ConnectionEventListner
from the listing of
listeners that will be notified for a ConnectionEvent
.
listener
- The ConnectionEventListener
to be removed
rollback
public void rollback(Xid id)
throws XAException
Rolls back the work, assuming it was done on behalf of the specified
transaction.
setConnectionSharing
public void setConnectionSharing(boolean connectionSharing)
connectionSharing
- true
if connection sharing must be
enabled.
setLogWriter
public void setLogWriter(PrintWriter out)
Sets the log writer for this ManagedConnection instance.
The log writer is a character output stream to which all logging and
tracing messages for this ManagedConnection instance will be printed.
Application Server manages the association of output stream with the
ManagedConnection instance based on the connection pooling requirements.
When a ManagedConnection object is initially created, the default log
writer associated with this instance is obtained from the
ManagedConnectionFactory
. An application server can set a
log writer specific to this ManagedConnection to log/trace this instance
using setLogWriter method.
out
- Character Output stream to be associated
setManagedEnvironment
public void setManagedEnvironment(boolean managedEnvironment)
throws ResourceException
setReadOnly
public void setReadOnly(boolean readOnly)
Set whether this connection is to be readonly
readOnly
- If true
, the connection will be set read-only,
otherwise it will be writable
setTransactionIsolation
public void setTransactionIsolation(int isolation)
throws ResourceException
Set the transaction level for this connection. The level is one of the
static final fields of java.sql.Connection
(i.e.
TRANSACTION_READ_COMMITTED
,
TRANSACTION_READ_UNCOMMITTED
,
TRANSACTION_REPEATABLE_READ
,
TRANSACTION_SERIALIZABLE
.
isolation
- Value representing a transaction isolation level defined in
java.sql.Connection
.
setTransactionTimeout
public boolean setTransactionTimeout(int timeout)
throws javax.transaction.xa.XAException
Sets the transaction timeout. This is saved, but the value is not used by
the current implementation.
timeout
- The timeout to be set in seconds
start
public void start(Xid id,
int flags)
throws XAException
Associates a JDBC connection with a global transaction. We assume that
end will be called followed by prepare, commit, or rollback. If start is
called after end but before commit or rollback, there is no way to
distinguish work done by different transactions on the same connection).
If start is called more than once before end, either it's a duplicate
transaction ID or illegal transaction ID (since you can't have two
transactions associated with one DB connection).
id
- A global transaction identifier to be associated with the
resourceflags
- One of TMNOFLAGS, TMJOIN, or TMRESUME