docs: final void rollback(boolean beginner, EJBKey key, EJBMethodInfoImpl methodInfo)
                      throws CSIException
      {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          LocalTransactionCoordinator lCoord = ltcCurrent.getLocalTranCoord();
  
          // If local tx exists; process it.  There must not be a global tx.
          if (lCoord != null)
          {
              if (lCoord.isASScoped()) // d130989
              {
                  endASLocalTx(key, methodInfo, lCoord, true); // RTC103197
              }
              // Otherwise, sticky local tx not required so end local tx now.
              else
              {
                  try
                  {
                      // d171555.3.2
                      //                     int resolver = (((EJBComponentMetaData)methodInfo.getComponentMetaData()).getLocalTranConfigData()).getValueResolver();
                      //
                      //                     // Is this an EJB 2.0 or newer component && the container is responsible for begin / end
                      //                     // of connection specific local transactions (ie. RMLTs)?  For EJB 1.1 beans local
                      //                     // tx resolver is never set to ContainerAtBoundary.  This is enforced by a
                      //                     // check in BeanMetaData.
                      //
                      //                     if (resolver == LocalTranConfigData.RESOLVER_CONTAINER_AT_BOUNDARY) {    //d135218
                      //
                      //                        // Complete the LTC context so enlisted resources will be rolled back.
                      //                        // When Container is responsible to automatically begin / end connections,
                      //                        // (i.e. local trancation resolver = containerAtBoundary) the connection
                      //                        // manager enlists each connection as a resource in the local transaction
                      //                        // context.  The enlist causes LocalTransaction.begin to occur on the
                      //                        // connection.  Here we are "completing" the context which causes
                      //                        // LocalTransaction.rollback to occur for the enlisted connections.
                      //
                      //                        if (isTraceOn && tc.isEventEnabled()) {
                      //                           Tr.event(tc, "Completing LTC cntxt with rollback due to bean " +
                      //                                    "exception: " + System.identityHashCode(lCoord));
                      //                        }
                      //                        lCoord.complete(LocalTransactionCoordinator.EndModeRollBack);
                      //
                      //                        // d165585 Begins
                      //                        if( TETxLifeCycleInfo.isTraceEnabled() )              // PQ74774
                      //                        {
                      //                            if( lCoord != null )
                      //                            {
                      //                                TETxLifeCycleInfo.traceLocalTxRollback( "" + System.identityHashCode( lCoord ), "Rollback Local Tx - complete" );
                      //                            }
                      //                        }
                      //                        // d165585 Ends
                      //                     } else {
                      //
                      //                        // Cleanup the LTC context so resources enlisted for cleanup will catch any
                      //                        // application errors.  When resolver = application, the application code is
                      //                        // responsible to do begin / end of the connections.  In this case the
                      //                        // connection manager enlists the connections for cleanup in the local
                      //                        // transaction context.  They are delisted iff the application remembers to
                      //                        // end them (ie. commit or rollback).  Here we end the context with
                      //                        // "cleanup" and "force" rollback of any remaining connections.  Rollback
                      //                        // of any remaining connections will occur despite the configuration
                      //                        // setting for unresolved-action (ie. COMMIT or ROLLBACK) because we first
                      //                        // call setRollbackOnly.
                      //
                      //                        if (isTraceOn && tc.isEventEnabled()) {
                      //                            Tr.event(tc, "Ending LTC cntxt with rollback due to bean " +
                      //                                    "exception: " + System.identityHashCode(lCoord));
                      //                        }
                      //                        lCoord.setRollbackOnly();
                      //                        lCoord.cleanup();
                      //
                      //                        // d165585 Begins
                      //                        if( TETxLifeCycleInfo.isTraceEnabled() )              // PQ74774
                      //                        {
                      //                            if( lCoord != null )
                      //                            {
                      //                                TETxLifeCycleInfo.traceLocalTxRollback( "" + System.identityHashCode( lCoord ), "Rollback Local Tx - cleanup" );
                      //                            }
                      //                        }
                      //                        // d165585 Ends
                      //                     } // end else
                      if (isTraceOn && tc.isEventEnabled())
                      {
                          Tr.event(tc, "Completing LTC cntxt with rollback due to bean " +
                                       "exception: tid=" +
                                       Integer.toHexString(lCoord.hashCode()) + "(LTC)");
                      }
  
                      lCoord.setRollbackOnly();
                      lCoord.end(LocalTransactionCoordinator.EndModeRollBack); // d171555.3.2
  
                      if (isTraceOn && // d527372
                          TETxLifeCycleInfo.isTraceEnabled()) // d171555.3.2
                      {
                          TETxLifeCycleInfo.traceLocalTxRollback("" + System.identityHashCode(lCoord), "Rollback Local Tx - end");
                      }
                  } catch (RolledbackException ex)
                  {
                      // do nothing... this is normal on setRollback, followed by cleanup
                      FFDCFilter.processException(ex, CLASS_NAME + ".rollback", "375", this);
                  } catch (UOWCompensatedException ex)
                  {
                      // UOWCompensatedException is only thrown to insure some
                      // exception is reported when setCompensateOnly has been
                      // called. However, if the method has already reported an
                      // exception, then the UOWCEx should not override it.
                      // Since the compensation code cannot currently tell when
                      // the method reported an exception, it will always throw
                      // the exception, and it will be handled here.           dPM45328
                      EJSDeployedSupport s = EJSContainer.getMethodContext();
                      if (s.getException() == null)
                      {
                          FFDCFilter.processException(ex, CLASS_NAME + ".rollback", "1129", this);
                          String errStr = "Could not complete local tx";
                          if (isTraceOn && tc.isEventEnabled()) {
                              Tr.event(tc, errStr, ex);
                          }
                          throw new CSIException(errStr, ex);
                      }
                      else
                      {
                          if (isTraceOn && tc.isDebugEnabled()) {
                              Tr.debug(tc, "Ignoring UOWCompensatedException; " +
                                           "another exception already reported : " +
                                           s.getException(), ex);
                          }
                      }
                  } catch (Exception ex)
                  {
                      FFDCFilter.processException(ex, CLASS_NAME + ".rollback", "378", this);
                      String errStr = "Could not complete local tx";
                      if (isTraceOn && tc.isEventEnabled()) {
                          Tr.event(tc, errStr, ex);
                      }
                      throw new CSIException(errStr, ex);
                  }
              } // end else (not a sticky local tx)
          } // end if local tx
  
          // There was no local tx so a global tx must exist
          else
          {
              try
              {
                  if (beginner)
                  {
                      if (isTraceOn && tc.isEventEnabled()) {
                          Tr.event(tc, "Rolling back TX cntxt due to bean " +
                                       "exception: " + txCtrl.txService.getTransaction()); //LIDB1673.2.1.5
                      }
                      txCtrl.txService.rollback();
  
                      // d165585 Begins
                      if (isTraceOn && // d527372
                          TETxLifeCycleInfo.isTraceEnabled()) // PQ74774
                      {
                          TETxLifeCycleInfo.traceGlobalTxRollback("NoTx", "Rollback Global Tx");
                      }
                      // d165585 Ends
                  }
                  else
                  {
                      if (isTraceOn && tc.isEventEnabled()) {
                          Tr.event(tc, "Marking TX cntxt for rollback due to bean " +
                                       "exception: " + txCtrl.txService.getTransaction()); //LIDB1673.2.1.5
                      }
                      txCtrl.txService.setRollbackOnly(); //LIDB1673.2.1.5
                  }
              } catch (Exception ex)
              {
                  FFDCFilter.processException(ex, CLASS_NAME + ".rollback", "405", this);
                  String errStr = "Could not roll back global tx";
                  if (isTraceOn && tc.isEventEnabled()) {
                      Tr.event(tc, errStr, ex);
                  }
                  throw new CSIException(errStr, ex);
              }
          }
      }