/*****************************************************************************/
/*                                                                           */
/* (c) Copyright IBM Corp. 2006  All rights reserved.                        */
/*                                                                           */
/* This sample program is owned by International Business Machines           */
/* Corporation or one of its subsidiaries ("IBM") and is copyrighted         */
/* and licensed, not sold.                                                   */
/*                                                                           */
/* You may copy, modify, and distribute this sample program in any           */
/* form without payment to IBM,  for any purpose including developing,       */
/* using, marketing or distributing programs that include or are             */
/* derivative works of the sample program.                                   */
/*                                                                           */
/* The sample program is provided to you on an "AS IS" basis, without        */
/* warranty of any kind.  IBM HEREBY  EXPRESSLY DISCLAIMS ALL WARRANTIES,    */
/* EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.       */
/* Some jurisdictions do not allow for the exclusion or limitation of        */
/* implied warranties, so the above limitations or exclusions may not        */
/* apply to you.  IBM shall not be liable for any damages you suffer as      */
/* a result of using, modifying or distributing the sample program or        */
/* its derivatives.                                                          */
/*                                                                           */
/*****************************************************************************/
/*                                                                           */
/* Program name: backout                                                     */
/*                                                                           */
/* Description: Sample java program that shows moving a poisoned message     */
/*              to the backout queue.                                        */
/*                                                                           */
/*****************************************************************************/
/*                                                                           */
/* Function:                                                                 */
/*                                                                           */
/*   This program will get a single message off of a queue enough times      */
/*   to exceed the backout threshold on the queue.  It will then move the    */
/*   message to the backout queue specified for the queue.                   */
/*                                                                           */
/* This program is run as follows:                                           */
/*                                                                           */
/*     java backout -qm ... -q ...                                           */
/*                                                                           */
/* where                                                                     */
/*     -qm is the queue manager name                                         */
/*     -q  is the queue name                                                 */
/*                                                                           */
/* In order to run this program, a queue will need to be defined that has a  */
/* a backout queue and backout threshold specified.  In addition, an actual  */
/* queue will need to be defined for the backout queue.  This can be done    */
/* using runmqsc with the following commands:                                */
/*                                                                           */
/*   define ql(ORIG.Q) boqname(ORIG.Q.BACKOUT) bothresh(5)                   */
/*   define ql(ORIG.Q.BACKOUT)                                               */
/*                                                                           */
/* A message can then put put on the ORIG.Q.  This backout program will then */
/* read the message 6 times and move it to ORIG.Q.BACKOUT.                   */
/*                                                                           */
/* This program has been tested with WebSphere MQ v6.0.1.0 and JDK 1.5.0.    */
/*                                                                           */
/*****************************************************************************/
/* Note: This program requires SupportPac MS0B in order to be compiled and   */
/*       executed.  You will also need to add the appropriate jar file to    */
/*       your classpath (com.ibm.mq.pcf.jar).                                */
/*****************************************************************************/
import com.ibm.mq.*;            // Include the WMQ package
import com.ibm.mq.pcf.*;        // Include the WMQ PCF package

public class backout {

  private String myQmgr = "";
  private String myQname;
  private MQQueueManager qMgr;

  private int[]  selectors = {
                     CMQC.MQIA_BACKOUT_THRESHOLD,
                     CMQC.MQCA_BACKOUT_REQ_Q_NAME };
  private int[]  intAttrs = new int[1];
  private byte[] charAttrs = new byte[MQC.MQ_Q_NAME_LENGTH];

  private int    boThresh;

  /***********************************************************************/
  /* Start everything up ....                                            */
  /***********************************************************************/
  public static void main (String args[]) {
    backout mySample = new backout(args);
    mySample.init();
    mySample.start();
    System.exit(0);
  }

  public backout(String args[]) {
     for (int i=0; i<args.length; i++) {
        String arg = args[i].toLowerCase();

        if( arg.equals("-qm") ) {
           if ( i+1<args.length ) {
              myQmgr = args[++i];
           } else {
              System.out.println("didn't specify queue manager, exiting");
              System.exit(-1);
           }

        } else if( arg.equals("-q") ) {
           if ( i+1<args.length ) {
              myQname = args[++i];
           } else {
              System.out.println("didn't specify queue, exiting");
              System.exit(-1);
           }

        } else {
           System.out.println( "Unknown argument: " + arg );
        }
     }
 
     if (myQname == null) {
        System.out.println("Usage:");
        System.out.println("java backout -qm ... -q ...");
        System.out.println("where -qm is the optional queue manager name");
        System.out.println("      -q is the required queue name");
        System.exit(-1);
     }
  }


  public void init() {
   /* initialization goes here */
  } // end of init


  /***********************************************************************/
  /* Actually run the program....                                        */
  /***********************************************************************/
  public void start() {

    try {
      /*****************************/
      /* Create a queue manager    */
      /*****************************/
      qMgr = new MQQueueManager(myQmgr);

      /****************************************************************/
      /* Open the queue for input and inquire.  The inquire is needed */
      /* so that the program can get the backout queue and threshold. */
      /****************************************************************/
      int openOptions = MQC.MQOO_INPUT_AS_Q_DEF | MQC.MQOO_INQUIRE 
                        | MQC.MQOO_SAVE_ALL_CONTEXT;
      MQQueue myQueue = qMgr.accessQueue(myQname, openOptions, null, null, null);

      /***********************************************/
      /* Get the values for the queue and threshold. */
      /***********************************************/
      MQManagedObject moMyQueue = (MQManagedObject)myQueue;
      moMyQueue.inquire(selectors, intAttrs, charAttrs);
      boThresh = intAttrs[0];
      String myPutQname = new String(charAttrs);
      System.out.println("Backout Threshold: " + boThresh);
      System.out.println("Backout Queue: " + myPutQname);

      /*****************************************************************/
      /* This program will get the first message on the queue and then */
      /* back it out until the backout threshold is reached.           */
      /*****************************************************************/
      MQGetMessageOptions gmo = new MQGetMessageOptions(); 
      gmo.options = MQC.MQGMO_SYNCPOINT;
      MQMessage myMessage = new MQMessage();
      while (true) {
         myMessage.clearMessage();
         myMessage.correlationId = MQC.MQCI_NONE;
         myMessage.messageId     = MQC.MQMI_NONE;
         myQueue.get(myMessage, gmo);

         /************************************/
         /* Have we gotten to the threshold? */
         /************************************/
         if (myMessage.backoutCount <= boThresh) {
            System.out.println("BackoutCount: " 
                    + myMessage.backoutCount + " of " + boThresh);
            qMgr.backout(); /* increase backout count by one */
         } else {
            /******************************************************/
            /* Threshold is reached.  Move message to the backout */
            /* queue.                                             */
            /******************************************************/
            System.out.println("Message is poison, moving to " + myPutQname);
            int openPutOptions = MQC.MQOO_OUTPUT
                               + MQC.MQOO_FAIL_IF_QUIESCING
                               + MQC.MQOO_PASS_ALL_CONTEXT;
            MQQueue myPutQueue = qMgr.accessQueue(myPutQname, openPutOptions,
                                                  null, null, null);
            MQPutMessageOptions pmo = new MQPutMessageOptions();
            pmo.options = pmo.options | MQC.MQPMO_SYNCPOINT 
                                      | MQC.MQPMO_PASS_ALL_CONTEXT;
            pmo.contextReference = myQueue;
            myPutQueue.put(myMessage, pmo);
            qMgr.commit();
            myPutQueue.close();
            break;
         }
      }

      myQueue.close();
      qMgr.disconnect();
    }

    /************************************/
    /* Catch any errors and report them */
    /************************************/
    catch (MQException ex) {
      System.out.println("An MQ error occurred : Completion code " +
                         ex.completionCode +
                         " Reason code " + ex.reasonCode);
    } catch (java.io.IOException ex) {
      System.out.println("An error occurred writing to message buffer: " +
                         ex);
    }

  } /* end of start */

} /* end of program */