drdaxaprotocol.java

derby database source code.good for you.

	 *
	 */
	private void rollbackLocalTransaction() throws DRDAProtocolException
	{
		int xaRetVal = XAResource.XA_OK;
		try {
			connThread.getDatabase().rollback();
		}
		catch  (Exception e)
		{
			xaRetVal = XAException.XAER_RMFAIL;
			if (SanityManager.DEBUG)
			{
				connThread.getServer().consoleExceptionPrint(e);
			}
			
		}
		writeSYNCCRD(CodePoint.SYNCTYPE_COMMITTED, 
					 xaRetVal, null);

	}

	/**
	 *  Rollback the xa transaction. Send SYNCCRD response.
	 * 
	 *  @param xid - XID 
	 *  @throws DRDAProtocolException
	 */
	private void rollbackXATransaction(Xid xid) throws DRDAProtocolException
	{
		XAResource xaResource = getXAResource();
		int xaRetVal = xaResource.XA_OK;

		try {
			xaResource.rollback(xid);
			if (SanityManager.DEBUG)
			{
				connThread.trace("rollback  XA transaction: xaRetVal=" + xaRetVal); 
			}
		} catch (XAException xe)
		{
			xaRetVal = processXAException(xe);
		}
		writeSYNCCRD(CodePoint.SYNCTYPE_ROLLBACK,
					 xaRetVal, null);
		
	}

	/**
	 *  End  the xa transaction. Send SYNCRRD response
	 * 
	 *  @param xid - XID 
	 *  @param xaflags - xaflags
	 *  @throws DRDAProtocolException
	 */
	private void endXA(Xid xid, int xaflags) throws DRDAProtocolException
	{
		XAResource xaResource = getXAResource();		
		int xaRetVal = xaResource.XA_OK;

		try {
			xaResource.end(xid,xaflags);
			if (SanityManager.DEBUG)
			{
				connThread.trace("ended XA transaction. xid =  " + xid +
							   " xaflags =" + xaflags + 
								 "xaRetVal=" + xaRetVal); 
			}
		} catch (XAException xe)
		{
			xaRetVal = processXAException(xe);
		}
		writeSYNCCRD(CodePoint.SYNCTYPE_END_UOW,
					 xaRetVal, null);		
	}


	/**
	 *  Prepare the xa transaction. Send SYNCCRD response.
	 * 
	 *  @param xid - XID 
	 *  @throws DRDAProtocolException
	 */
	private void prepareXATransaction(Xid xid) throws DRDAProtocolException
	{
		XAResource xaResource = getXAResource();
		int xaRetVal = xaResource.XA_OK;

		try {
			xaRetVal = xaResource.prepare(xid);
			if (SanityManager.DEBUG)
			{
				connThread.trace("prepared xa transaction: xaRetVal=" +
								xaRetVal); 
			}
		} catch (XAException xe)
		{			
			xaRetVal = processXAException(xe);
		}
		writeSYNCCRD(CodePoint.SYNCTYPE_PREPARE,
					 xaRetVal, null);		
	}

	/**
	 *  Forget the xa transaction. Send SYNCCRD response.
	 * 
	 *  @param xid - XID 
	 *  @throws DRDAProtocolException
	 */
	private void forgetXATransaction(Xid xid) throws DRDAProtocolException
	{
		XAResource xaResource = getXAResource();
		int xaRetVal = xaResource.XA_OK;

		try {
			xaResource.forget(xid);
			if (SanityManager.DEBUG)
			{
				connThread.trace("forgot xa transaction: xaRetVal=" + xaRetVal);
			}
		} catch (XAException xe)
		{
			xaRetVal = processXAException(xe);
		}
		writeSYNCCRD(CodePoint.SYNCTYPE_REQ_FORGET,
					 xaRetVal, null);		
	}

	// JCC doesn't send xaflags but always wants TMSTARTRSCAN.  
	//So default to that if we got no xaflags
	private void recoverXA() throws DRDAProtocolException
	{
		recoverXA(XAResource.TMSTARTRSCAN);
	}

	/**
	 * Call recover. Send SYNCCRD response with indoubt list
	 * 
	 *  @throws DRDAProtocolException
	 */
	private void recoverXA(int xaflags) throws DRDAProtocolException
	{
		XAResource xaResource = getXAResource();
		int xaRetVal = xaResource.XA_OK;
		Xid[] indoubtXids = null;
		try {
			indoubtXids = xaResource.recover(xaflags);
		} catch (XAException xe)
		{
			xaRetVal = processXAException(xe);
		}
		writeSYNCCRD(CodePoint.SYNCTYPE_INDOUBT,
					 xaRetVal, indoubtXids);		
	}

	/** Write SYNCCRD (SYNCCTL response)
	 * @param synctype - XA Command to send response for see  parseSYNCTYPE
	 * @param xaRetVal - return value from XA command
	 * @param xids - list of xids to return for recover. 
	 *               null for other commands
	 * @throws DRDAProtocolException
	 */
	private void writeSYNCCRD (int synctype, int xaRetVal, Xid[] xids) throws DRDAProtocolException
	{
		writer.createDssReply();
		writer.startDdm(CodePoint.SYNCCRD);
		writer.startDdm(CodePoint.XARETVAL);
		writer.writeInt(xaRetVal);
		writer.endDdm();
		if (xids != null)
			writePRPHRCLST(xids);
		writer.endDdmAndDss();
	}

	/** write PRPHRCLST (indoubt list)
	 * 
	 * @param xids - list of indoubt xa transactions obtained from recover
	 * @throws DRDAProtocolException
	 */
	private void writePRPHRCLST(Xid[] xids) throws DRDAProtocolException
	{
		int xidcnt = (xids == null ? 0 : xids.length);
		writer.startDdm(CodePoint.PRPHRCLST);
		writer.writeScalar2Bytes(CodePoint.XIDCNT, xidcnt);
		for (int i = 0; i < xidcnt; i++)
			writeXID(xids[i]);
		writer.endDdm();
	}

	/** write XID
	 * 
	 * @param xid - XID to write
	 * @throws DRDAProtocolException
	 */
	
	private void writeXID(Xid xid) throws DRDAProtocolException
	{
		writer.startDdm(CodePoint.XID);
		int formatId = xid.getFormatId();
		byte[] gtrid = xid.getGlobalTransactionId();
		byte[] bqual = xid.getBranchQualifier();
		
		writer.writeInt(formatId);
		writer.writeInt(gtrid.length);
		writer.writeInt(bqual.length);
		writer.writeBytes(gtrid);
		writer.writeBytes(bqual);
		writer.endDdm();
	}
	

	/** get XAResource for the connection
	 *
	 * @return XAResource
	 */
	private XAResource getXAResource()
	{
		return ((XADatabase) connThread.getDatabase()).getXAResource();
		
	}
	
	/** printable syncType for debug output
	 * @param syncType
	 * @return - sync type meaning
	 */
	private String syncTypeToString(int syncType)
	{
		switch (syncType)
		{  
			case CodePoint.SYNCTYPE_NEW_UOW:
				return "SYNCTYPE_NEW_UOW";
				
			case CodePoint.SYNCTYPE_END_UOW:
				return "SYNCTYPE_END_UOW";
				
			case CodePoint.SYNCTYPE_PREPARE:
				return "SYNCTYPE_PREPARE";
				
			case CodePoint.SYNCTYPE_MIGRATE:
				return "SYNCTYPE_MIGRATE";
							
			case CodePoint.SYNCTYPE_REQ_COMMIT:
				return "SYNCTYPE_REQ_COMMIT";
				
			case CodePoint.SYNCTYPE_COMMITTED:
				return "SYNCTYPE_COMMITTED";
				
			case CodePoint.SYNCTYPE_REQ_FORGET:
				return "SYNCTYPE_FORGET";
				
			case CodePoint.SYNCTYPE_ROLLBACK:
				return "SYNCTYPE_ROLLBACK";
				
			case CodePoint.SYNCTYPE_REQ_LOG:
				return "SYNCTYPE_REQ_LOG";
				
			case   CodePoint.SYNCTYPE_MIGRATED:
				return "SYNCTYPE_MIGRATED";
				
			case CodePoint.SYNCTYPE_INDOUBT:
				return "SYNCTYPE_INDOUBT";
				
			default:
				return "UNKNOWN SYNCTYPE";
 		}
	}

	/** 
	 * printable xaflags
	 * @param xaflags
	 * @return printable xaflags for debug output
	 */
	private String xaflagsToString(int xaflags)
	{
		switch (xaflags)
		{
			case XAResource.TMENDRSCAN :
				return "XAResource.TMENDRSCAN";
				
			case XAResource.TMFAIL:
				return "XAResource.TMFAIL";
				
			case XAResource.TMNOFLAGS:
				return "XAResource.TMNOFLAGS";
				
			case XAResource.TMJOIN:
				return "XAResource.TMJOIN";
				
			case XAResource.TMONEPHASE:
				return "XAResource.TMONEPHASE";
				
			case XAResource.TMRESUME:
				return "XAResource.TMRESUME";
				
			case XAResource.TMSTARTRSCAN:
				return "XAResource.TMSTARTRSCAN";
				
			case XAResource.TMSUCCESS:
				return "XAResource.TMSUCCESS";
				
			case XAResource.TMSUSPEND:
				return "XAResource.TMSUSPEND";
				
			default:
				return "UNRECOGNIZED flags:" + xaflags;
				
		}
	}

	/** 
	 * return xa exception errorCode.
	 * print to console for debug output.
	 * @param xe - XA Exception
	 */
	private int processXAException(XAException xe)
	{
		int xaRetVal = xe.errorCode;
		if (SanityManager.DEBUG)
		{
			connThread.getServer().consoleExceptionPrint(xe);
		}
		return xaRetVal;
	}

}