[Ubermq-commits] jms/src/com/ubermq/kernel/overflow HandlerChain.java,NONE,1.1 ExponentialBackoff.java,1.4,1.5 KillReceiver.java,1.2,1.3 HeuristicWaitAndSee.java,1.3,NONE

[<ji...@us...>]

Update of /cvsroot/ubermq/jms/src/com/ubermq/kernel/overflow
In directory usw-pr-cvs1:/tmp/cvs-serv11700/src/com/ubermq/kernel/overflow

Modified Files:
	ExponentialBackoff.java KillReceiver.java 
Added Files:
	HandlerChain.java 
Removed Files:
	HeuristicWaitAndSee.java 
Log Message:
small bug fixes. also a new way to chain together overflow handlers.


--- NEW FILE: HandlerChain.java ---
package com.ubermq.kernel.overflow;

import com.ubermq.kernel.*;
import java.util.*;

/**
 * Constructs a chain of overflow handlers in one object.
 * The first overflow handler is entirely exhausted before
 * moving on to the second handler, and so on, for all specified
 * handlers.
 */
public class HandlerChain
	implements IConnectionOverflowHandler
{
	private List handlers;
	private ListIterator handlerSequence;
	
	private IOverflowHandler active;
	
	/**
	 * Constructs a chain from a List of overflow handler implementations.
	 * @param handlerSequence an ordered list of objects implementing
	 * <code>IOverflowHandler</code> and/or <code>IConnectionOverflowHandler</code>.
	 */
	public HandlerChain(List handlers)
	{
		// get the sequence by iterating. the collection should
		// not be modified while the chain is being used
		this.handlers = handlers;
		this.handlerSequence = handlers.listIterator();
		
		// start out at the first handler
		nextHandler();
	}
	
	/**
	 * Convenience constructor that takes a primary and secondary
	 * overflow handler.
	 * @param primary the primary overflow handler
	 * @param secondary the secondary overflow handler
	 */
	public HandlerChain(IOverflowHandler primary,
						IOverflowHandler secondary)
	{
		this(Arrays.asList(new IOverflowHandler[] { primary, secondary }));
	}
	
	/**
	 * Advances the active overflow handler to be the next overflow handler in
	 * the sequence. If there is no next handler, a suitable implementation
	 * is provided that returns false in all circumstances.
	 */
	private void nextHandler()
		throws NoSuchElementException
	{
		if (this.handlerSequence.hasNext())
			active = (IOverflowHandler)this.handlerSequence.next();
		else throw new NoSuchElementException();
	}
	
	/**
	 * Produces a new overflow handler to be used if the
	 * recommended retried output attempt fails again.
	 * This can be return null if the overflow()
	 * method never returns true.
	 */
	public IOverflowHandler getRetryHandler()
	{
		if (active == null)
			return null;
		else if (handlers.size() > 1) {
			return new HandlerChain(active.getRetryHandler(),
									new HandlerChain(handlers.subList(1, handlers.size() - 1)));
		} else {
			return active.getRetryHandler();
		}
	}
	
	/**
	 * Handles an overflow situation that is not related to outputting
	 * a datagram.
	 */
	public boolean overflow()
	{
		try {
			if (!active.overflow()) {
				nextHandler();
				return overflow();
			} else {
				return true;
			}
		} catch(NoSuchElementException e) {return false;}
	}
	
	/**
	 * Handles an overflow detected by a certain message processor
	 * on a specific connection.
	 * @param d the datagram that was being sent when the overflow
	 * occurred.
	 * @param connection the connection that was the target of the
	 * <code>output</code> call.
	 * @param messageProcessor the message processor that is calling
	 * this method.
	 */
	public boolean overflow(IDatagram d, IConnectionInfo connection, IMessageProcessor messageProcessor)
	{
		try {
			if (active instanceof IConnectionOverflowHandler) {
				IConnectionOverflowHandler coh = (IConnectionOverflowHandler)active;
				if (!coh.overflow(d, connection, messageProcessor)) {
					nextHandler();
					return overflow(d, connection, messageProcessor);
				} else {
					return true;
				}
			} else {
				return overflow(d);
			}
		} catch(NoSuchElementException e) {return false;}
	}
	
	/**
	 * Handles an overflow situation.
	 *
	 * @param d the IDatagram that is being sent.
	 * @return whether the caller should retry the output
	 * or not.
	 */
	public boolean overflow(IDatagram d)
	{
		try {
			if (!active.overflow(d)) {
				nextHandler();
				return overflow(d);
			} else {
				return true;
			}
		} catch(NoSuchElementException e) {return false;}
	}
	
	
}



Index: ExponentialBackoff.java
===================================================================
RCS file: /cvsroot/ubermq/jms/src/com/ubermq/kernel/overflow/ExponentialBackoff.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -d -r1.4 -r1.5
*** ExponentialBackoff.java	23 Aug 2002 14:06:53 -0000	1.4
--- ExponentialBackoff.java	27 Sep 2002 21:29:04 -0000	1.5
***************
*** 9,13 ****
   * implementation treats all overflow signals that
   * arrive within a configurable timeframe as part of the
!  * same overflow, and increment the backoff accordingly.
   *
   * The backoff is implemented as a Thread.sleep(). This will
--- 9,13 ----
   * implementation treats all overflow signals that
   * arrive within a configurable timeframe as part of the
!  * same overflow, and increment the backoff accordingly.<P>
   *
   * The backoff is implemented as a Thread.sleep(). This will

Index: KillReceiver.java
===================================================================
RCS file: /cvsroot/ubermq/jms/src/com/ubermq/kernel/overflow/KillReceiver.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** KillReceiver.java	22 Aug 2002 15:06:03 -0000	1.2
--- KillReceiver.java	27 Sep 2002 21:29:04 -0000	1.3
***************
*** 1,10 ****
  package com.ubermq.kernel.overflow;
  
- import com.ubermq.kernel.IDatagram;
  import com.ubermq.kernel.*;
! import java.nio.*;
  
  /**
!  * This overflow handler will kill any connection
   * that causes its write buffer to overflow. Somewhat
   * heavy handed, but works very well if overflowing
--- 1,10 ----
  package com.ubermq.kernel.overflow;
  
  import com.ubermq.kernel.*;
! 
! import com.ubermq.jms.server.proc.DatagramProc;
  
  /**
!  * An overflow handler that kills any connection
   * that causes its write buffer to overflow. Somewhat
   * heavy handed, but works very well if overflowing
***************
*** 13,36 ****
   */
  public class KillReceiver
!     extends AbstractOverflowHandler
  {
-     private final IConnectionInfo conn;
-     
      /**
!      * Specify the IConnectionInfo that can be closed
!      * abruptly.
       */
!     public KillReceiver(IConnectionInfo conn)
      {
-         this.conn = conn;
-     }
- 
-     public IOverflowHandler getRetryHandler() {return null;}
-     
-     public boolean doOverflow()
-     {
-         conn.close();
- 
-         return false;
      }
  }
--- 13,49 ----
   */
  public class KillReceiver
!     extends DropIncoming
! 	implements IConnectionOverflowHandler
  {
      /**
!      * Creates an overflow handler that
! 	 * closes a connection and deregisters it with the
! 	 * central control processor.
       */
!     public KillReceiver()
      {
      }
+ 	
+ 	/**
+ 	 * Handles an overflow by removing the connection from the
+ 	 * message processor and closing the connection's associated
+ 	 * channels. <P>
+ 	 *
+ 	 * The outgoing message will not be retried.
+ 	 *
+ 	 * @param d the datagram that was being sent when the overflow
+ 	 * occurred.
+ 	 * @param connection the connection that was the target of the
+ 	 * <code>output</code> call.
+ 	 * @param messageProcessor the message processor that is calling
+ 	 * this method.
+ 	 */
+ 	public boolean overflow(IDatagram d,
+ 							IConnectionInfo connection,
+ 							IMessageProcessor messageProcessor)
+ 	{
+ 		messageProcessor.remove(connection);
+ 		connection.close();
+ 		return false;
+ 	}
  }

--- HeuristicWaitAndSee.java DELETED ---