Java Code Examples for javax.transaction.xa.Xid#getFormatId()

protected void writeXaPrepare(NetConnection conn) throws SqlException {
    NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
    Xid xid = callInfo.xid_;
    // don't forget that xars.prepare() does not have flags, assume TMNOFLAGS
    int xaFlags = XAResource.TMNOFLAGS;

    createCommand();

    // save the length bytes for later update
    markLengthBytes(CodePoint.SYNCCTL);

    // SYNCTYPE
    writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_PREPARE);

    if (xid.getFormatId() != -1) {
        writeXID(CodePoint.XID, xid);
    } else
    // write the null XID for local transaction on XA connection
    {
        writeNullXID(CodePoint.XID);
    }

    writeXAFlags(CodePoint.XAFLAGS, xaFlags);
    updateLengthBytes();
}
 

void writeXID(int codepoint, Xid xid) throws SqlException {
    int len = 0;
    int formatId = xid.getFormatId();
    byte[] gtrid = xid.getGlobalTransactionId();
    byte[] bqual = xid.getBranchQualifier();

    markLengthBytes(codepoint);

    len = 4;                    // length of formatId
    len += (bqual.length + 4);  // bqual length
    len += (gtrid.length + 4);  // gtrid length

    write4Bytes(formatId);
    write4Bytes(gtrid.length);
    write4Bytes(bqual.length);

    writeBytes(gtrid);
    writeBytes(bqual);

    updateLengthBytes();

}
 

/**
 * {@inheritDoc}
 */
public boolean equals(Object object)
{
   if (object == this)
      return true;

   if (object == null || !(object instanceof Xid))
      return false;  

   Xid other = (Xid)object;
   return
      (
         formatId == other.getFormatId() && 
         Arrays.equals(globalTransactionId, other.getGlobalTransactionId()) &&
         Arrays.equals(branchQualifier, other.getBranchQualifier())
      );
}
 

void buildSYNCCTLCommit(int xaFlags, Xid xid) throws SqlException {
    createCommand();

    // save the length bytes for later update
    markLengthBytes(CodePoint.SYNCCTL);

    // SYNCTYPE
    writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_COMMITTED);

    if (xid.getFormatId() != -1) {
        writeXID(CodePoint.XID, xid);
    } else
    // write the null XID for local transaction on XA connection
    {
        writeNullXID(CodePoint.XID);
    }

    writeXAFlags(CodePoint.XAFLAGS, xaFlags);

    updateLengthBytes();
}
 

protected void writeXaCommit(NetConnection conn, Xid xid) throws SqlException {
    NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
    int xaFlags = callInfo.xaFlags_;

    // create DSS command with no reply.
    createCommand();

    // save the length bytes for later update
    markLengthBytes(CodePoint.SYNCCTL);

    // SYNCTYPE
    writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_COMMITTED);

    if (xid.getFormatId() != -1) {
        writeXID(CodePoint.XID, xid);
    } else
    // write the null XID for local transaction on XA connection
    {
        writeNullXID(CodePoint.XID);
    }

    writeXAFlags(CodePoint.XAFLAGS, xaFlags);
    updateLengthBytes();
}
 

@Override
public boolean equals(Object o) {
  if (o == this) {
    // optimization for the common case.
    return true;
  }

  if (!(o instanceof Xid)) {
    return false;
  }

  Xid other = (Xid) o;
  if (other.getFormatId() != formatId) {
    return false;
  }
  if (!Arrays.equals(globalTransactionId, other.getGlobalTransactionId())) {
    return false;
  }
  return Arrays.equals(branchQualifier, other.getBranchQualifier());
}
 

private static byte[] toByteArray(final Xid xid) {
   byte[] branchQualifier = xid.getBranchQualifier();
   byte[] globalTransactionId = xid.getGlobalTransactionId();
   int formatId = xid.getFormatId();

   byte[] hashBytes = new byte[branchQualifier.length + globalTransactionId.length + 4];
   System.arraycopy(branchQualifier, 0, hashBytes, 0, branchQualifier.length);
   System.arraycopy(globalTransactionId, 0, hashBytes, branchQualifier.length, globalTransactionId.length);
   byte[] intBytes = new byte[4];
   for (int i = 0; i < 4; i++) {
      intBytes[i] = (byte) ((formatId >> i * 8) % 0xFF);
   }
   System.arraycopy(intBytes, 0, hashBytes, branchQualifier.length + globalTransactionId.length, 4);
   return hashBytes;
}
 

public void forgetQuietly(Xid xid) {
	TransactionParticipant compensableCoordinator = this.beanFactory.getCompensableNativeParticipant();
	TransactionParticipant transactionCoordinator = this.beanFactory.getTransactionNativeParticipant();

	int formatId = xid.getFormatId();
	if (XidFactory.JTA_FORMAT_ID == formatId) {
		transactionCoordinator.forgetQuietly(xid);
	} else if (XidFactory.TCC_FORMAT_ID == formatId) {
		compensableCoordinator.forgetQuietly(xid);
	}
}
 

/**
 * Return a string that describes any Xid instance.
 */
static String toString(Xid id) {
    if (id == null)
        return "[NULL Xid]";

    String s = id.getClass().getName();
    s = s.substring(s.lastIndexOf('.') + 1);
    s = s + " [FormatId=" + id.getFormatId() +
            ", GlobalId=" + new String(id.getGlobalTransactionId()).trim() +
            ", BranchQual=" + new String(id.getBranchQualifier()).trim() + "]";

    return s;
}
 

/**
 * Compare for equality.
 * <p>
 * Instances are considered equal if they are both instances of XidImpl,
 * and if they have the same global transaction id and transaction
 * branch qualifier.
 * </p>
 */
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (!(obj instanceof Xid)) return false;

    Xid other = (Xid) obj;

    boolean result = formatId == other.getFormatId();
    byte[] otherGlobalID = other.getGlobalTransactionId();
    byte[] otherBranchID = other.getBranchQualifier();
    result &= Arrays.equals(globalId, otherGlobalID);
    result &= Arrays.equals(branchId, otherBranchID);

    return result;
}
 

private static byte[] toByteArray(final Xid xid) {
   byte[] branchQualifier = xid.getBranchQualifier();
   byte[] globalTransactionId = xid.getGlobalTransactionId();
   int formatId = xid.getFormatId();

   byte[] hashBytes = new byte[branchQualifier.length + globalTransactionId.length + 4];
   System.arraycopy(branchQualifier, 0, hashBytes, 0, branchQualifier.length);
   System.arraycopy(globalTransactionId, 0, hashBytes, branchQualifier.length, globalTransactionId.length);
   byte[] intBytes = new byte[4];
   for (int i = 0; i < 4; i++) {
      intBytes[i] = (byte) ((formatId >> i * 8) % 0xFF);
   }
   System.arraycopy(intBytes, 0, hashBytes, branchQualifier.length + globalTransactionId.length, 4);
   return hashBytes;
}
 

/**
 * Equal implementation.
 *
 * @param obj object to compare
 * @return true if object is MariaDbXi and as same parameters
 */
public boolean equals(Object obj) {
  if (obj instanceof Xid) {
    Xid other = (Xid) obj;
    return formatId == other.getFormatId()
        && Arrays.equals(globalTransactionId, other.getGlobalTransactionId())
        && Arrays.equals(branchQualifier, other.getBranchQualifier());
  }
  return false;
}
 

public boolean equals(Object other) 
  {
if (other == this)
	return true;

if (other == null)
	return false;
	
try
   {
	if (other instanceof GlobalXact)
		return super.equals(other);
	// Just cast it and catch the exception rather than doing the type
	// checking twice.
	Xid other_xid = (Xid) other;

	return(
		   java.util.Arrays.equals(
							other_xid.getGlobalTransactionId(),
							this.global_id)          &&
		   java.util.Arrays.equals(
							other_xid.getBranchQualifier(),
							this.branch_id)          &&
		   other_xid.getFormatId() == this.format_id);

   }
catch(ClassCastException cce)
   {
	// this class only knows how to compare with other Xids
	if (SanityManager.DEBUG)
		SanityManager.THROWASSERT("comparing XAXactId with " + 
								  other.getClass().getName(), cce); 

	return false;
   }
  }
 

public static boolean xidsEqual(Xid xid1, Xid xid2) { // determine if the 2 xids contain the same values even if not same object
    // comapre the format ids
    if (xid1.getFormatId() != xid2.getFormatId()) {
        return false; // format ids are not the same
    }

    // compare the global transaction ids
    int xid1Length = xid1.getGlobalTransactionId().length;
    if (xid1Length != xid2.getGlobalTransactionId().length) {
        return false; // length of the global trans ids are not the same
    }
    byte[] xid1Bytes = xid1.getGlobalTransactionId();
    byte[] xid2Bytes = xid2.getGlobalTransactionId();
    int i;
    for (i = 0; i < xid1Length; ++i) { // check all bytes are the same
        if (xid1Bytes[i] != xid2Bytes[i]) {
            return false; // bytes in the global trans ids are not the same
        }
    }

    // compare the branch qualifiers
    xid1Length = xid1.getBranchQualifier().length;
    if (xid1Length != xid2.getBranchQualifier().length) {
        return false; // length of the global trans ids are not the same
    }
    xid1Bytes = xid1.getBranchQualifier();
    xid2Bytes = xid2.getBranchQualifier();
    for (i = 0; i < xid1Length; ++i) { // check all bytes are the same
        if (xid1Bytes[i] != xid2Bytes[i]) {
            return false; // bytes in the global trans ids are not the same
        }
    }

    return true; // all of the fields are the same, xid1 == xid2
}
 

/**
 * Create a {@link SerializableXid}, copying the format ID, GTRID and BQUAL of an existing {@link Xid}.
 *
 * @param xid a {@link Xid} implementation.
 */
public SerializableXid(Xid xid) {
  if (xid.getGlobalTransactionId() == null) {
    throw new NullPointerException();
  }
  if (xid.getBranchQualifier() == null) {
    throw new NullPointerException();
  }
  this.formatId = xid.getFormatId();
  this.globalTransactionId = xid.getGlobalTransactionId();
  this.branchQualifier = xid.getBranchQualifier();
}
 

/**
 * Return a string that describes any Xid instance.
 */
static String toString(Xid id) {
    if (id == null)
        return "[NULL Xid]";

    String s = id.getClass().getName();
    s = s.substring(s.lastIndexOf('.') + 1);
    s = s + " [FormatId=" + id.getFormatId() +
            ", GlobalId=" + new String(id.getGlobalTransactionId()).trim() +
            ", BranchQual=" + new String(id.getBranchQualifier()).trim() + "]";

    return s;
}
 

@Override
public boolean equals(final Object other) {
   if (this == other) {
      return true;
   }
   if (!(other instanceof Xid)) {
      return false;
   }
   Xid xother = (Xid) other;
   if (xother.getFormatId() != formatId) {
      return false;
   }
   if (xother.getBranchQualifier().length != branchQualifier.length) {
      return false;
   }
   if (xother.getGlobalTransactionId().length != globalTransactionId.length) {
      return false;
   }
   for (int i = 0; i < branchQualifier.length; i++) {
      byte[] otherBQ = xother.getBranchQualifier();
      if (branchQualifier[i] != otherBQ[i]) {
         return false;
      }
   }
   for (int i = 0; i < globalTransactionId.length; i++) {
      byte[] otherGtx = xother.getGlobalTransactionId();
      if (globalTransactionId[i] != otherGtx[i]) {
         return false;
      }
   }
   return true;
}
 

public void writeXaStartUnitOfWork(NetConnection conn) throws SqlException {
    NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
    Xid xid = callInfo.xid_;
    int xaFlags = callInfo.xaFlags_;
    long xaTimeout = callInfo.xaTimeoutMillis_;

    // create DSS command with reply.
    createCommand();

    // save the length bytes for later update
    markLengthBytes(CodePoint.SYNCCTL);

    // SYNCTYPE
    writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_NEW_UOW);

    if (xid.getFormatId() != -1) {
        writeXID(CodePoint.XID, xid);
    } else
    // write the null XID for local transaction on XA connection
    {
        writeNullXID(CodePoint.XID);
    }

    writeXAFlags(CodePoint.XAFLAGS, xaFlags);
    // Check whether the timeout value was specified.
    // Value less than 0 means no timeout is specified.
    if (xaTimeout >= 0) {
        writeXATimeout(CodePoint.TIMEOUT, xaTimeout);
    }
    updateLengthBytes();
}
 

/**
 * Copy constructor
 *
 * @param other
 */
public DummyXid(final Xid other) {
   branchQualifier = copyBytes(other.getBranchQualifier());
   formatId = other.getFormatId();
   globalTransactionId = copyBytes(other.getGlobalTransactionId());
}
 

public void compensableRecoveryResume(Xid xid) throws NotSupportedException, SystemException {
	CompensableManager compensableManager = this.beanFactory.getCompensableManager();
	TransactionRepository transactionRepository = this.beanFactory.getCompensableRepository();
	TransactionParticipant compensableCoordinator = this.beanFactory.getCompensableNativeParticipant();
	if (xid == null) {
		throw new IllegalStateException();
	} else if (TransactionXid.class.isInstance(xid) == false) {
		throw new IllegalStateException();
	} else if (xid.getFormatId() != XidFactory.TCC_FORMAT_ID) {
		throw new IllegalStateException();
	}

	TransactionXid compensableXid = (TransactionXid) xid;
	CompensableTransaction transaction = null;
	try {
		transaction = (CompensableTransaction) transactionRepository.getTransaction(compensableXid);
	} catch (TransactionException tex) {
		logger.error("Error occurred while getting transaction from transaction repository!", tex);
		throw new IllegalStateException();
	}

	if (transaction == null) {
		throw new IllegalStateException();
	} else if (CompensableTransaction.class.isInstance(transaction) == false) {
		throw new IllegalStateException();
	}

	CompensableTransaction compensable = compensableManager.getCompensableTransactionQuietly();

	TransactionContext transactionContext = transaction.getTransactionContext();
	if (transactionContext.isCoordinator() == false) {
		throw new IllegalStateException();
	} else if (transactionContext.isRecoveried()) {
		try {
			compensableCoordinator.start(transactionContext, XAResource.TMNOFLAGS);
		} catch (XAException ex) {
			logger.error("Error occurred while resuming an compensable transaction!", ex);
			throw new SystemException(ex.getMessage());
		}
	} else if (compensable == null) {
		throw new IllegalStateException();
	} else if (compensable.equals(transaction) == false) {
		throw new IllegalStateException();
	}

}