docs: static void rcvCommitTransaction(CommsByteBuffer request, Conversation conversation,
                                      int requestNumber, boolean allocatedFromBufferPool,
                                      boolean partOfExchange)
     {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "rcvCommitTransaction",
                                             new Object[]
                                             {
                                                request,
                                                conversation,
                                                ""+requestNumber,
                                                ""+allocatedFromBufferPool
                                              });
  
        short connectionObjectId = request.getShort();  // BIT16 ConnectionObjectId
        int clientTransactionId = request.getInt();     // BIT32 Client transaction Id
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        {
           SibTr.debug(tc, "SICoreConnection Id:", connectionObjectId);
           SibTr.debug(tc, "Client transaction Id:", clientTransactionId);
        }
  
        try
        {
           // Get the transaction out of the table
           ServerLinkLevelState linkState = (ServerLinkLevelState) conversation.getLinkLevelAttachment();
           SITransaction tran = linkState.getTransactionTable().get(clientTransactionId);
  
           // An earlier failure may mean that this transaction is rollback only
           boolean tranIsRollbackOnly =
              (tran == IdToTransactionTable.INVALID_TRANSACTION) ||
              linkState.getTransactionTable().isLocalTransactionRollbackOnly(clientTransactionId);
  
           if (tranIsRollbackOnly)
           {
              Throwable t = linkState.getTransactionTable().getExceptionForRollbackOnlyLocalTransaction(clientTransactionId);
  
              // At this point here the transaction will either be committed or rolled back.
              // Therefore, any subsequent operations will be invalid and will be thrown out
              // by the client. As such, remove it from the table.
              linkState.getTransactionTable().removeLocalTransaction(clientTransactionId);
  
              SIUncoordinatedTransaction siTran = (SIUncoordinatedTransaction)tran;
  
              //We don't want to rollback if this is IdToTransactionTable.INVALID_TRANSACTION
              if (siTran != null && siTran != IdToTransactionTable.INVALID_TRANSACTION) siTran.rollback();
  
              // And respond with an error
              SIRollbackException r = new SIRollbackException(
                 nls.getFormattedMessage("TRANSACTION_MARKED_AS_ERROR_SICO2008",
                                         new Object[]{ t },
                                         null),
                 t
              );
  
              StaticCATHelper.sendExceptionToClient(r,
                                                    null,
                                                    conversation, requestNumber);
           }
           else
           {
              // At this point here the transaction will either be committed or rolled back.
              // Therefore, any subsequent operations will be invalid and will be thrown out
              // by the client. As such, remove it from the table.
              linkState.getTransactionTable().removeLocalTransaction(clientTransactionId);
  
              // Otherwise commit - note this cannot be null here, otherwise we would be marked as error
              SIUncoordinatedTransaction siTran = (SIUncoordinatedTransaction)tran;
              siTran.commit();
  
              // Respond to the client
              try
              {
                 conversation.send(poolManager.allocate(),
                                   JFapChannelConstants.SEG_COMMIT_TRANSACTION_R,
                                   requestNumber,
                                   JFapChannelConstants.PRIORITY_MEDIUM,
                                   true,
                                   ThrottlingPolicy.BLOCK_THREAD,
                                   null);
              }
              catch (SIException e)
              {
                 FFDCFilter.processException(e,
                                             CLASS_NAME + ".rcvCommitTransaction",
                                             CommsConstants.STATICCATTRANSACTION_COMMIT_01);
  
                 if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
  
                 SibTr.error(tc, "COMMUNICATION_ERROR_SICO2026", e);
              }
           }
        }
        catch (SIException e)
        {
           //No FFDC code needed
           //Only FFDC if we haven't received a meTerminated event.
           if(!((ConversationState)conversation.getAttachment()).hasMETerminated())
           {
              FFDCFilter.processException(e,
                                          CLASS_NAME + ".rcvCommitTransaction",
                                          CommsConstants.STATICCATTRANSACTION_COMMIT_02);
           }
  
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
  
           StaticCATHelper.sendExceptionToClient(e,
                                                 CommsConstants.STATICCATTRANSACTION_COMMIT_02,
                                                 conversation, requestNumber);
        }
  
        request.release(allocatedFromBufferPool);
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "rcvCommitTransaction");
     }