com.microsoft.sqlserver.jdbc.SQLServerXAResource Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of mssql-jdbc Show documentation
Show all versions of mssql-jdbc Show documentation
Microsoft JDBC Driver for SQL Server.
/*
* Microsoft JDBC Driver for SQL Server Copyright(c) Microsoft Corporation All rights reserved. This program is made
* available under the terms of the MIT License. See the LICENSE file in the project root for more information.
*/
package com.microsoft.sqlserver.jdbc;
import java.sql.CallableStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLTimeoutException;
import java.sql.Statement;
import java.sql.Types;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.transaction.xa.XAException;
import javax.transaction.xa.XAResource;
import javax.transaction.xa.Xid;
/**
* Implements Transaction id used to recover transactions.
*/
final class XidImpl implements Xid {
private final int formatId;
private final byte gtrid[];
private final byte bqual[];
private final String traceID;
/*
* XA Flags public static final int TMENDRSCAN = 8388608; public static final int TMFAIL = 536870912; public static
* final int TMJOIN = 2097152; public static final int TMNOFLAGS = 0; public static final int TMONEPHASE =
* 1073741824; public static final int TMRESUME = 134217728; public static final int TMSTARTRSCAN = 16777216; public
* static final int TMSUCCESS = 67108864; public static final int TMSUSPEND = 33554432; public static final int
* XA_RDONLY = 3; public static final int XA_OK = 0;
*/
/**
* Constructs a XidImpl.
*
* @param formatId
* format id
* @param gtrid
* global id
* @param bqual
* branch id
*/
public XidImpl(int formatId, byte gtrid[], byte bqual[]) {
this.formatId = formatId;
this.gtrid = gtrid;
this.bqual = bqual;
traceID = " XID:" + xidDisplay(this);
}
public byte[] getGlobalTransactionId() {
return gtrid;
}
public byte[] getBranchQualifier() {
return bqual;
}
public int getFormatId() {
return formatId;
}
/**
* Returns trace id used for tracing.
*
* @return traceID string
*/
public String toString() {
return traceID;
}
// Returns displayable representation of xid for logging purposes.
static String xidDisplay(Xid xid) {
if (null == xid)
return "(null)";
StringBuilder sb = new StringBuilder(300);
sb.append("formatId=");
sb.append(xid.getFormatId());
sb.append(" gtrid=");
sb.append(Util.byteToHexDisplayString(xid.getGlobalTransactionId()));
sb.append(" bqual=");
sb.append(Util.byteToHexDisplayString(xid.getBranchQualifier()));
return sb.toString();
}
}
final class XAReturnValue {
int nStatus;
byte bData[];
}
/**
* Provides an XAResource for XA distributed transaction management. XA transactions are implemented over SQL Server
* using Microsoft Distributed Transaction Manager (DTC). SQLServerXAResource makes calls to a SQL Server extended dll
* called SQLServer_XA.dll which interfaces with DTC.
*
* XA calls received by SQLServerXAResource (XA_START, XA_END, XA_PREPARE etc) are mapped to the corresponding calls to
* DTC functions.
*
* SQLServerXAResource may also be configured not to use DTC. In this case distributed transactions are simply
* implemented as local transactions.
*/
public final class SQLServerXAResource implements javax.transaction.xa.XAResource {
/*
* In the Java transaction API doc a 'resource manager' appears to be (for JDBC) a 'particular DBMS server that
* participates in distributed transaction'. More accurately an instance of a connection to a database since
* commit/rollback is done at the DB connection level. A resource adapter is the implementation below
*/
/*
* In the JDBC XA spec the 'middle tier server' is the application server. We assume that this module implements the
* pooling of connections since it must also pass the XAResouce obtained when a connection is handed to an
* application to the transaction manager. IE JPoolingDataSource is not used - the JConnectionPoolDataSource and
* JPoolied connections are managed for pooling by the app server.
*/
/* Examples http://oradoc.photo.net/ora816/java.816/a81354/xadistr1.htm#1064452 */
/*
* Note that EJB componenents performing getConnection() may be using the same XAConnection/XAResource since it is a
* pooled connection
*/
private int timeoutSeconds;
final static int XA_START = 0;
final static int XA_END = 1;
final static int XA_PREPARE = 2;
final static int XA_COMMIT = 3;
final static int XA_ROLLBACK = 4;
final static int XA_FORGET = 5;
final static int XA_RECOVER = 6;
final static int XA_PREPARE_EX = 7;
final static int XA_ROLLBACK_EX = 8;
final static int XA_FORGET_EX = 9;
final static int XA_INIT = 10;
private SQLServerConnection controlConnection;
private SQLServerConnection con; // original connection
private boolean serverInfoRetrieved;
private String version, instanceName;
private int architectureMSSQL, architectureOS;
private static boolean xaInitDone;
private static final Object xaInitLock;
private String sResourceManagerId;
private int enlistedTransactionCount;
final private Logger xaLogger;
static private final AtomicInteger baseResourceID = new AtomicInteger(0); // Unique id generator for each instance
// (used for logging).
private int tightlyCoupled = 0;
private int isTransacrionTimeoutSet = 0; // set to 1 if setTransactionTimeout() is called
/**
* Used to allow the tightly coupled XA transactions, which have different XA branch transaction IDs (XIDs) but have
* the same global transaction ID (GTRID)
*/
public static final int SSTRANSTIGHTLYCPLD = 0x8000;
private SQLServerCallableStatement[] xaStatements = {null, null, null, null, null, null, null, null, null, null};
private final String traceID;
/**
* Variable that shows how many times we attempt the recovery, e.g in case of MSDTC restart
*/
private int recoveryAttempt = 0;
static {
xaInitLock = new Object();
}
@Override
public String toString() {
return traceID;
}
SQLServerXAResource(SQLServerConnection original, SQLServerConnection control, String loginfo) {
traceID = " XAResourceID:" + nextResourceID();
// Grab SQLServerXADataSource's static XA logger instance.
xaLogger = SQLServerXADataSource.xaLogger;
controlConnection = control;
con = original;
Properties p = original.activeConnectionProperties;
if (p == null)
sResourceManagerId = "";
else {
sResourceManagerId = p.getProperty(SQLServerDriverStringProperty.SERVER_NAME.toString()) + "."
+ p.getProperty(SQLServerDriverStringProperty.DATABASE_NAME.toString()) + "."
+ p.getProperty(SQLServerDriverIntProperty.PORT_NUMBER.toString());
}
if (xaLogger.isLoggable(Level.FINE))
xaLogger.fine(toString() + " created by (" + loginfo + ")");
// Information about the server, needed for XA timeout logic in the DLL.
serverInfoRetrieved = false;
version = "0";
instanceName = "";
architectureMSSQL = 0;
architectureOS = 0;
}
private synchronized SQLServerCallableStatement getXACallableStatementHandle(int number) throws SQLServerException {
assert number >= XA_START && number <= XA_FORGET_EX;
assert number < xaStatements.length;
if (null != xaStatements[number])
return xaStatements[number];
CallableStatement CS = null;
switch (number) {
case SQLServerXAResource.XA_START:
CS = controlConnection.prepareCall(
"{call master..xp_sqljdbc_xa_start(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)}");
break;
case SQLServerXAResource.XA_END:
CS = controlConnection.prepareCall("{call master..xp_sqljdbc_xa_end(?, ?, ?, ?, ?, ?, ?)}");
break;
case SQLServerXAResource.XA_PREPARE:
CS = controlConnection.prepareCall("{call master..xp_sqljdbc_xa_prepare(?, ?, ?, ?, ?)}");
break;
case SQLServerXAResource.XA_COMMIT:
CS = controlConnection.prepareCall("{call master..xp_sqljdbc_xa_commit(?, ?, ?, ?, ?, ?)}");
break;
case SQLServerXAResource.XA_ROLLBACK:
CS = controlConnection.prepareCall("{call master..xp_sqljdbc_xa_rollback(?, ?, ?, ?, ?)}");
break;
case SQLServerXAResource.XA_FORGET:
CS = controlConnection.prepareCall("{call master..xp_sqljdbc_xa_forget(?, ?, ?, ?, ?)}");
break;
case SQLServerXAResource.XA_RECOVER:
CS = controlConnection.prepareCall("{call master..xp_sqljdbc_xa_recover(?, ?, ?, ?)}");
break;
case SQLServerXAResource.XA_PREPARE_EX:
CS = controlConnection.prepareCall("{call master..xp_sqljdbc_xa_prepare_ex(?, ?, ?, ?, ?, ?)}");
break;
case SQLServerXAResource.XA_ROLLBACK_EX:
CS = controlConnection.prepareCall("{call master..xp_sqljdbc_xa_rollback_ex(?, ?, ?, ?, ?, ?)}");
break;
case SQLServerXAResource.XA_FORGET_EX:
CS = controlConnection.prepareCall("{call master..xp_sqljdbc_xa_forget_ex(?, ?, ?, ?, ?, ?)}");
break;
default:
assert false : "Bad handle request:" + number;
break;
}
xaStatements[number] = (SQLServerCallableStatement) CS;
return xaStatements[number];
}
private synchronized void closeXAStatements() throws SQLServerException {
for (int i = 0; i < xaStatements.length; i++)
if (null != xaStatements[i]) {
xaStatements[i].close();
xaStatements[i] = null;
}
}
final synchronized void close() throws SQLServerException {
try {
closeXAStatements();
} catch (Exception e) {
if (xaLogger.isLoggable(Level.WARNING))
xaLogger.warning(toString() + "Closing exception ignored: " + e);
}
if (null != controlConnection)
controlConnection.close();
}
// Returns displayable representation of XID flags for logging purposes.
private String flagsDisplay(int flags) {
// Handle default most common case first.
// Note TMNOFLAGS is 0 so this means no other bits are set.
if (TMNOFLAGS == flags)
return "TMNOFLAGS";
// Build displayable bitmask of rest of flags.
StringBuilder sb = new StringBuilder(100);
if (0 != (TMENDRSCAN & flags))
sb.append("TMENDRSCAN");
if (0 != (TMFAIL & flags)) {
if (sb.length() > 0)
sb.append("|");
sb.append("TMFAIL");
}
if (0 != (TMJOIN & flags)) {
if (sb.length() > 0)
sb.append("|");
sb.append("TMJOIN");
}
if (0 != (TMONEPHASE & flags)) {
if (sb.length() > 0)
sb.append("|");
sb.append("TMONEPHASE");
}
if (0 != (TMRESUME & flags)) {
if (sb.length() > 0)
sb.append("|");
sb.append("TMRESUME");
}
if (0 != (TMSTARTRSCAN & flags)) {
if (sb.length() > 0)
sb.append("|");
sb.append("TMSTARTRSCAN");
}
if (0 != (TMSUCCESS & flags)) {
if (sb.length() > 0)
sb.append("|");
sb.append("TMSUCCESS");
}
if (0 != (TMSUSPEND & flags)) {
if (sb.length() > 0)
sb.append("|");
sb.append("TMSUSPEND");
}
if (0 != (SSTRANSTIGHTLYCPLD & flags)) {
if (sb.length() > 0)
sb.append("|");
sb.append("SSTRANSTIGHTLYCPLD");
}
return sb.toString();
}
// Returns displayable representation of XID cookie for logging purposes.
private String cookieDisplay(byte[] cookie) {
return Util.byteToHexDisplayString(cookie);
}
// Returns displayable representation of XA type flag.
private String typeDisplay(int type) {
switch (type) {
case XA_START:
return "XA_START";
case XA_END:
return "XA_END";
case XA_PREPARE:
return "XA_PREPARE";
case XA_COMMIT:
return "XA_COMMIT";
case XA_ROLLBACK:
return "XA_ROLLBACK";
case XA_FORGET:
return "XA_FORGET";
case XA_RECOVER:
return "XA_RECOVER";
default:
return "UNKNOWN" + type;
}
}
private XAReturnValue DTC_XA_Interface(int nType, Xid xid, int xaFlags) throws XAException {
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " Calling XA function for type:" + typeDisplay(nType) + " flags:"
+ flagsDisplay(xaFlags) + " xid:" + XidImpl.xidDisplay(xid));
int formatId = 0;
byte gid[] = null;
byte bid[] = null;
if (xid != null) {
formatId = xid.getFormatId();
gid = xid.getGlobalTransactionId();
bid = xid.getBranchQualifier();
}
String sContext = "DTC_XA_";
int n = 1;
int nStatus = 0;
XAReturnValue returnStatus = new XAReturnValue();
SQLServerCallableStatement cs = null;
try {
synchronized (this) {
if (!xaInitDone) {
try {
synchronized (xaInitLock) {
SQLServerCallableStatement initCS = null;
initCS = (SQLServerCallableStatement) controlConnection
.prepareCall("{call master..xp_sqljdbc_xa_init_ex(?, ?,?)}");
initCS.registerOutParameter(1, Types.INTEGER); // Return status
initCS.registerOutParameter(2, Types.CHAR); // Return error message
initCS.registerOutParameter(3, Types.CHAR); // Return version number
try {
initCS.execute();
} catch (SQLServerException eX) {
try {
initCS.close();
// Mapping between control connection and xaresource is 1:1
controlConnection.close();
} catch (SQLException e3) {
// we really want to ignore this failue
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString()
+ " Ignoring exception when closing failed execution. exception:" + e3);
}
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " exception:" + eX);
throw eX;
} catch (SQLTimeoutException e4) {
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " exception:" + e4);
throw new SQLServerException(e4.getMessage(), SQLState.STATEMENT_CANCELED,
DriverError.NOT_SET, null);
}
// Check for error response from xp_sqljdbc_xa_init.
int initStatus = initCS.getInt(1);
String initErr = initCS.getString(2);
String versionNumberXADLL = initCS.getString(3);
if (xaLogger.isLoggable(Level.FINE))
xaLogger.fine(toString() + " Server XA DLL version:" + versionNumberXADLL);
initCS.close();
if (XA_OK != initStatus) {
assert null != initErr && initErr.length() > 1;
controlConnection.close();
MessageFormat form = new MessageFormat(
SQLServerException.getErrString("R_failedToInitializeXA"));
Object[] msgArgs = {String.valueOf(initStatus), initErr};
XAException xex = new XAException(form.format(msgArgs));
xex.errorCode = initStatus;
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " exception:" + xex);
throw xex;
}
}
} catch (SQLServerException e1) {
MessageFormat form = new MessageFormat(
SQLServerException.getErrString("R_failedToCreateXAConnection"));
Object[] msgArgs = {e1.getMessage()};
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " exception:" + form.format(msgArgs));
SQLServerException.makeFromDriverError(null, null, form.format(msgArgs), null, true);
}
xaInitDone = true;
}
}
switch (nType) {
case XA_START:
if (!serverInfoRetrieved) {
String query = "select convert(varchar(100), SERVERPROPERTY('Edition'))as edition, "
+ " convert(varchar(100), SERVERPROPERTY('InstanceName'))as instance,"
+ " convert(varchar(100), SERVERPROPERTY('ProductVersion')) as version, @@VERSION;";
try (Statement stmt = controlConnection.createStatement();
ResultSet rs = stmt.executeQuery(query);) {
serverInfoRetrieved = true;
rs.next();
String edition = rs.getString(1);
architectureMSSQL = ((null != edition) && (edition.contains("(64-bit)"))) ? 64 : 32;
// if InstanceName is null use the default instance without name (MSSQLSERVER)
instanceName = (rs.getString(2) == null) ? "MSSQLSERVER" : rs.getString(2);
version = rs.getString(3);
if (null == version) {
version = "0";
} else if (-1 != version.indexOf('.')) {
version = version.substring(0, version.indexOf('.'));
}
/*
* @@VERSION returns single nvarchar string with SQL version, architecture, build date,
* edition and OS version.
*/
String buildInfo = rs.getString(4);
// SQL Server Linux is x64-compatible only.
if (null != buildInfo && (buildInfo.contains("Linux") || buildInfo.contains("Microsoft SQL Azure"))) {
architectureOS = 64;
} else if (null != buildInfo) {
architectureOS = Integer.parseInt(buildInfo.substring(buildInfo.lastIndexOf('<') + 2,
buildInfo.lastIndexOf('>')));
}
}
// Catch only the thrown exceptions, do not catch run time exceptions.
catch (Exception e) {
if (xaLogger.isLoggable(Level.WARNING))
xaLogger.warning(
toString() + " Cannot retrieve server information: :" + e.getMessage());
}
}
sContext = "START:";
cs = getXACallableStatementHandle(XA_START);
cs.registerOutParameter(n++, Types.INTEGER); // Return status
cs.registerOutParameter(n++, Types.CHAR); // Return error message
cs.setBytes(n++, gid); // Global XID
cs.setBytes(n++, bid); // Branch ID
cs.setInt(n++, xaFlags); // XA transaction flags
cs.registerOutParameter(n++, Types.BINARY); // Returned OLE transaction cookie
cs.setInt(n++, timeoutSeconds); // Transaction timeout in seconds.
cs.setInt(n++, formatId); // Format ID
cs.registerOutParameter(n++, Types.CHAR); // DLL Version number
cs.setInt(n++, Integer.parseInt(version)); // Version of SQL Server
cs.setInt(n++, instanceName.length()); // Length of SQL Server instance name
cs.setBytes(n++, instanceName.getBytes()); // SQL Server instance name
cs.setInt(n++, architectureMSSQL); // Architecture of SQL Server
cs.setInt(n++, architectureOS); // Architecture of OS running SQL Server
cs.setInt(n++, isTransacrionTimeoutSet); // pass 1 if setTransactionTimeout() is called
cs.registerOutParameter(n++, Types.BINARY); // Return UoW
break;
case XA_END:
sContext = "END:";
cs = getXACallableStatementHandle(XA_END);
cs.registerOutParameter(n++, Types.INTEGER);
cs.registerOutParameter(n++, Types.CHAR);
cs.setBytes(n++, gid);
cs.setBytes(n++, bid);
cs.setInt(n++, xaFlags);
cs.setInt(n++, formatId);
cs.registerOutParameter(n++, Types.BINARY); // Return UoW
break;
case XA_PREPARE:
sContext = "PREPARE:";
if ((SSTRANSTIGHTLYCPLD & xaFlags) == SSTRANSTIGHTLYCPLD)
cs = getXACallableStatementHandle(XA_PREPARE_EX);
else
cs = getXACallableStatementHandle(XA_PREPARE);
cs.registerOutParameter(n++, Types.INTEGER);
cs.registerOutParameter(n++, Types.CHAR);
cs.setBytes(n++, gid);
cs.setBytes(n++, bid);
if ((SSTRANSTIGHTLYCPLD & xaFlags) == SSTRANSTIGHTLYCPLD)
cs.setInt(n++, xaFlags); // XA transaction flags
cs.setInt(n++, formatId); // Format ID n=5 for loosely coupled, n=6 for tightly coupled
break;
case XA_COMMIT:
sContext = "COMMIT:";
cs = getXACallableStatementHandle(XA_COMMIT);
cs.registerOutParameter(n++, Types.INTEGER);
cs.registerOutParameter(n++, Types.CHAR);
cs.setBytes(n++, gid);
cs.setBytes(n++, bid);
cs.setInt(n++, xaFlags);
cs.setInt(n++, formatId);
break;
case XA_ROLLBACK:
sContext = "ROLLBACK:";
if ((SSTRANSTIGHTLYCPLD & xaFlags) == SSTRANSTIGHTLYCPLD)
cs = getXACallableStatementHandle(XA_ROLLBACK_EX);
else
cs = getXACallableStatementHandle(XA_ROLLBACK);
cs.registerOutParameter(n++, Types.INTEGER);
cs.registerOutParameter(n++, Types.CHAR);
cs.setBytes(n++, gid);
cs.setBytes(n++, bid);
if ((SSTRANSTIGHTLYCPLD & xaFlags) == SSTRANSTIGHTLYCPLD)
cs.setInt(n++, xaFlags); // XA transaction flags
cs.setInt(n++, formatId); // Format ID n=5 for loosely coupled, n=6 for tightly coupled
break;
case XA_FORGET:
sContext = "FORGET:";
if ((SSTRANSTIGHTLYCPLD & xaFlags) == SSTRANSTIGHTLYCPLD)
cs = getXACallableStatementHandle(XA_FORGET_EX);
else
cs = getXACallableStatementHandle(XA_FORGET);
cs.registerOutParameter(n++, Types.INTEGER);
cs.registerOutParameter(n++, Types.CHAR);
cs.setBytes(n++, gid);
cs.setBytes(n++, bid);
if ((SSTRANSTIGHTLYCPLD & xaFlags) == SSTRANSTIGHTLYCPLD)
cs.setInt(n++, xaFlags); // XA transaction flags
cs.setInt(n++, formatId); // Format ID n=5 for loosely coupled, n=6 for tightly coupled
break;
case XA_RECOVER:
sContext = "RECOVER:";
cs = getXACallableStatementHandle(XA_RECOVER);
cs.registerOutParameter(n++, Types.INTEGER);
cs.registerOutParameter(n++, Types.CHAR);
cs.setInt(n++, xaFlags);
cs.registerOutParameter(n++, Types.BINARY);
// Format Id need not be sent for recover action
break;
default:
assert false : "Unknown execution type:" + nType;
break;
}
/* execute the interface procedure */
cs.execute();
nStatus = cs.getInt(1);
String sErr = cs.getString(2);
if (nType == XA_START) {
String versionNumberXADLL = cs.getString(9);
if (xaLogger.isLoggable(Level.FINE)) {
xaLogger.fine(toString() + " Server XA DLL version:" + versionNumberXADLL);
if (null != cs.getString(16)) {
StringBuffer strBuf = new StringBuffer(cs.getString(16));
strBuf.insert(20, '-');
strBuf.insert(16, '-');
strBuf.insert(12, '-');
strBuf.insert(8, '-');
xaLogger.fine(toString() + " XID to UoW mapping for XA type:XA_START XID: "
+ XidImpl.xidDisplay(xid) + " UoW: " + strBuf.toString());
}
}
}
if (nType == XA_END) {
if (xaLogger.isLoggable(Level.FINE)) {
if (null != cs.getString(7)) {
StringBuffer strBuf = new StringBuffer(cs.getString(7));
strBuf.insert(20, '-');
strBuf.insert(16, '-');
strBuf.insert(12, '-');
strBuf.insert(8, '-');
xaLogger.fine(toString() + " XID to UoW mapping for XA type:XA_END XID: "
+ XidImpl.xidDisplay(xid) + " UoW: " + strBuf.toString());
}
}
}
if (XA_RECOVER == nType && XA_OK != nStatus && recoveryAttempt < 1) {
// if recover failed, attempt to start again - adding the variable to check to attempt only once
// otherwise throw exception that recovery fails
// this is added since before this change, if we restart the MSDTC and attempt to do recovery, driver
// will throw exception
// "The function RECOVER: failed. The status is: -3"
recoveryAttempt++;
DTC_XA_Interface(XA_START, xid, TMNOFLAGS);
return DTC_XA_Interface(XA_RECOVER, xid, xaFlags);
}
// prepare and end can return XA_RDONLY
// Think should we just check for nStatus to be greater than or equal to zero instead of this check
if (((XA_RDONLY == nStatus) && (XA_END != nType && XA_PREPARE != nType))
|| (XA_OK != nStatus && XA_RDONLY != nStatus)) {
assert (null != sErr) && (sErr.length() > 1);
MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_failedFunctionXA"));
Object[] msgArgs = {sContext, String.valueOf(nStatus), sErr};
XAException e = new XAException(form.format(msgArgs));
e.errorCode = nStatus;
// if the request is end make sure we delist from the DTC transaction on rm failure.
if (nType == XA_END && (XAException.XAER_RMFAIL == nStatus)) {
try {
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " Begin un-enlist, enlisted count:" + enlistedTransactionCount);
con.JTAUnenlistConnection();
enlistedTransactionCount--;
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " End un-enlist, enlisted count:" + enlistedTransactionCount);
} catch (SQLServerException e1) {
// ignore this message as the previous error message is more important.
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " Ignoring exception:" + e1);
}
}
throw e;
} else {
if (nType == XA_START) {
// A physical connection may not have been enlisted yet so always enlist.
byte transactionCookie[] = cs.getBytes(6);
if (transactionCookie == null) {
MessageFormat form = new MessageFormat(
SQLServerException.getErrString("R_noTransactionCookie"));
Object[] msgArgs = {sContext};
SQLServerException.makeFromDriverError(null, null, form.format(msgArgs), null, true);
} else {
try {
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(
toString() + " Begin enlisting, cookie:" + cookieDisplay(transactionCookie)
+ " enlisted count:" + enlistedTransactionCount);
con.JTAEnlistConnection(transactionCookie);
enlistedTransactionCount++;
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " End enlisting, cookie:" + cookieDisplay(transactionCookie)
+ " enlisted count:" + enlistedTransactionCount);
} catch (SQLServerException e1) {
MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_failedToEnlist"));
Object[] msgArgs = {e1.getMessage()};
SQLServerException.makeFromDriverError(null, null, form.format(msgArgs), null, true);
}
}
}
if (nType == XA_END) {
try {
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " Begin un-enlist, enlisted count:" + enlistedTransactionCount);
con.JTAUnenlistConnection();
enlistedTransactionCount--;
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " End un-enlist, enlisted count:" + enlistedTransactionCount);
} catch (SQLServerException e1) {
MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_failedToUnEnlist"));
Object[] msgArgs = {e1.getMessage()};
SQLServerException.makeFromDriverError(null, null, form.format(msgArgs), null, true);
}
}
if (nType == XA_RECOVER)
{
try {
returnStatus.bData = cs.getBytes(4);
} catch (SQLServerException e1) {
MessageFormat form = new MessageFormat(
SQLServerException.getErrString("R_failedToReadRecoveryXIDs"));
Object[] msgArgs = {e1.getMessage()};
SQLServerException.makeFromDriverError(null, null, form.format(msgArgs), null, true);
}
}
}
} catch (SQLServerException | SQLTimeoutException ex) {
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " exception:" + ex);
XAException e = new XAException(ex.toString());
e.errorCode = XAException.XAER_RMERR;
throw e;
}
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " Status:" + nStatus);
returnStatus.nStatus = nStatus;
return returnStatus;
}
@Override
public void start(Xid xid, int flags) throws XAException {
/*
* Transaction mgr will use this resource in the global transaction. After this call the app server will call
* getConnection() to get a connection to give the application The xid holds the global transaction id + the
* transaction branch id. The getGlobalTransactionId should be the same for each call until the transaction is
* committed
*/
/*
* XA API DOC : Start work on behalf of a transaction branch specified in xid If TMJOIN is specified, the start
* is for joining a transaction previously seen by the resource manager. If TMRESUME is specified, the start is
* to resume a suspended transaction specified in the parameter xid. If neither TMJOIN nor TMRESUME is specified
* and the transaction specified by xid has previously been seen by the resource manager, the resource manager
* throws the XAException exception with XAER_DUPID error code.
*/
// TMNOFLAGS indicates this is the first time this physical connection has seen the transaction.
// EG if the physical connection has generated multiple connection handles only work on the first
// of those will be prefixed by the transaction manager with a call to start with TMNOFLAGS
tightlyCoupled = flags & SSTRANSTIGHTLYCPLD;
DTC_XA_Interface(XA_START, xid, flags);
}
@Override
public void end(Xid xid, int flags) throws XAException {
// Called by the transaction mgr after the app closes the connection it was given from this physical
// connection
/*
* Ends the work performed on behalf of a transaction branch. The resource manager disassociates the XA resource
* from the transaction branch specified and let the transaction be completed. If TMSUSPEND is specified in
* flags, the transaction branch is temporarily suspended in incomplete state. The transaction context is in
* suspened state and must be resumed via start with TMRESUME specified. If TMFAIL is specified, the portion of
* work has failed. The resource manager may mark the transaction as rollback-only. If TMSUCCESS is specified,
* the portion of work has completed successfully.
*/
DTC_XA_Interface(XA_END, xid, flags | tightlyCoupled);
}
@Override
public int prepare(Xid xid) throws XAException {
/*
* Ask the resource manager to prepare for a transaction commit of the transaction specified in xid. Parameters:
* xid - A global transaction identifier Returns: A value indicating the resource manager's vote on the outcome
* of the transaction. The possible values are: XA_RDONLY or XA_OK. If the resource manager wants to roll back
* the transaction, it should do so by raising an appropriate XAException in the prepare method.
*/
int nStatus = XA_OK;
XAReturnValue r = DTC_XA_Interface(XA_PREPARE, xid, tightlyCoupled);
nStatus = r.nStatus;
return nStatus;
}
@Override
public void commit(Xid xid, boolean onePhase) throws XAException {
DTC_XA_Interface(XA_COMMIT, xid, ((onePhase) ? TMONEPHASE : TMNOFLAGS) | tightlyCoupled);
}
@Override
public void rollback(Xid xid) throws XAException {
DTC_XA_Interface(XA_ROLLBACK, xid, tightlyCoupled);
}
@Override
public void forget(Xid xid) throws XAException {
DTC_XA_Interface(XA_FORGET, xid, tightlyCoupled);
}
@Override
public Xid[] recover(int flags) throws XAException {
XAReturnValue r = DTC_XA_Interface(XA_RECOVER, null, flags | tightlyCoupled);
int offset = 0;
ArrayList al = new ArrayList<>();
// If no XID's found, return zero length XID array (don't return null).
//
// Per Java 1.4.2 spec:
//
// The resource manager returns zero or more XIDs of 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.
if (null == r.bData)
return new XidImpl[0];
while (offset < r.bData.length) {
int power = 1;
int formatId = 0;
for (int i = 0; i < 4; i++) {
int x = (r.bData[offset + i] & 0x00FF);
x = x * power;
formatId += x;
power = power * 256;
}
try {
offset += 4;
int gid_len = (r.bData[offset++] & 0x00FF);
int bid_len = (r.bData[offset++] & 0x00FF);
byte gid[] = new byte[gid_len];
byte bid[] = new byte[bid_len];
System.arraycopy(r.bData, offset, gid, 0, gid_len);
offset += gid_len;
System.arraycopy(r.bData, offset, bid, 0, bid_len);
offset += bid_len;
XidImpl xid = new XidImpl(formatId, gid, bid);
al.add(xid);
} catch (ArrayIndexOutOfBoundsException e) {
MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_indexOutOfRange"));
Object[] msgArgs = {offset};
XAException xex = new XAException(form.format(msgArgs));
xex.errorCode = XAException.XAER_RMERR;
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " exception:" + xex);
throw xex;
}
}
XidImpl xids[] = new XidImpl[al.size()];
for (int i = 0; i < al.size(); i++) {
xids[i] = al.get(i);
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + xids[i].toString());
}
return xids;
}
@Override
public boolean isSameRM(XAResource xares) throws XAException {
// A Resource Manager (RM) is an instance of a connection to a DB
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " xares:" + xares);
// Change to return true if its the same database physical connection
if (!(xares instanceof SQLServerXAResource))
return false;
SQLServerXAResource jxa = (SQLServerXAResource) xares;
return jxa.sResourceManagerId.equals(this.sResourceManagerId);
}
@Override
public boolean setTransactionTimeout(int seconds) throws XAException {
isTransacrionTimeoutSet = 1;
timeoutSeconds = seconds;
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " TransactionTimeout:" + seconds);
return true;
}
@Override
public int getTransactionTimeout() throws XAException {
return timeoutSeconds;
}
// Returns unique id for each PooledConnection instance.
private static int nextResourceID() {
return baseResourceID.incrementAndGet();
}
}