Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2012 International Business Machines Corp.
   * 
   * See the NOTICE file distributed with this work for additional information
   * regarding copyright ownership. Licensed under the Apache License, 
   * Version 2.0 (the "License"); you may not use this file except in compliance
   * with the License. You may obtain a copy of the License at
   * 
   *   http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.ibm.jbatch.container.impl;
 
 import java.util.List;
 import java.util.Set;
 
 
 
 public class RetryHandler {

Logic for handling retryable records. A RetryHandler object is attached to every BDS that inherits from AbstractBatchDataStream.
 
 
 	private static final String className = RetryHandler.class.getName();
 	private static Logger logger = Logger.getLogger(RetryHandler.class.getPackage().getName());
 
 	public static final String RETRY_COUNT      = "retry-limit";
 	public static final String RETRY_INCLUDE_EX = "include class";
 	public static final String RETRY_EXCLUDE_EX = "exclude class";
 
 	private static final int RETRY_NONE = 0;
 	private static final int RETRY_READ = 1;
 	private static final int RETRY_PROCESS = 2;
 	private static final int RETRY_WRITE = 3;
 
 	private int retryType = ;
 
 	/*private RetryProcessListenerProxy _retryProcessListener = null;
 	  private RetryReadListenerProxy _retryReadListener = null;
 	  private RetryWriteListenerProxy _retryWriteListener = null;*/
 
 
 	private long _jobId = 0;
 	private String _stepId = null;
 	private Set<String_retryNoRBIncludeExceptions = null;
 	private Set<String_retryNoRBExcludeExceptions = null;
 	private Set<String_retryIncludeExceptions = null;
 	private Set<String_retryExcludeExceptions = null;
 	private int _retryLimit = 0;
 	private long _retryCount = 0;
 	private Exception _retryException = null;
 
 	public RetryHandler(Chunk chunklong lString stepId)
 	{
 		 = l;
 		 = stepId;
 
 		initialize(chunk);
 	}


Add the user-defined RetryProcessListener.
 
 	public void addRetryProcessListener(List<RetryProcessListenerProxyretryProcessListeners)
 	{
 		 =  retryProcessListeners;
 	}

Add the user-defined RetryReadListener.
 
 	public void addRetryReadListener(List<RetryReadListenerProxyretryReadListeners)
 	{
		 = retryReadListeners;
	}

Add the user-defined RetryWriteListener.
	public void addRetryWriteListener(List<RetryWriteListenerProxyretryWriteListeners)
	{
		 = retryWriteListeners;
	}


Read the retry exception lists from the BDS props.
	private void initialize(Chunk chunk)
	{
		final String mName = "initialize";
		try
		{
			if (chunk.getRetryLimit() != null){
				 = Integer.parseInt(chunk.getRetryLimit());
			}
		}
		{
			throw new RuntimeException("NumberFormatException reading " + nfe);
		}
		if ( > 0)
		{
			// Read the include/exclude exceptions.
			String includeEx = null;
			String excludeEx = null;
			String includeExNoRB = null;
			String excludeExNoRB = null;
			if (chunk.getRetryableExceptionClasses() != null) {
				if (chunk.getRetryableExceptionClasses().getIncludeList() != null) {
					for (ExceptionClassFilter.Include include : includes){
						.finer("RETRYHANDLE: include: " + include.getClazz().trim());
					}
						.finer("RETRYHANDLE: include element not present");
					}
				}
				if (chunk.getRetryableExceptionClasses().getExcludeList() != null) {
					for (ExceptionClassFilter.Exclude exclude : excludes){
						.finer("SKIPHANDLE: exclude: " + exclude.getClazz().trim());
					}
						.finer("SKIPHANDLE: exclude element not present");
					}
				}
			}
			if (chunk.getNoRollbackExceptionClasses() != null) {
				if (chunk.getNoRollbackExceptionClasses().getIncludeList() != null) {
					for (ExceptionClassFilter.Include include : includes){
						.finer("RETRYHANDLE: include: " + include.getClazz().trim());
					}
						.finer("RETRYHANDLE: include element not present");
					}
				}
				if (chunk.getNoRollbackExceptionClasses().getExcludeList() != null) {
					for (ExceptionClassFilter.Exclude exclude : excludes){
						.finer("SKIPHANDLE: exclude: " + exclude.getClazz().trim());
					}
						.finer("SKIPHANDLE: exclude element not present");
					}
				}
			}
						"added include exception " + includeEx
"; added exclude exception " + excludeEx);
						"added include no rollback exception " + includeExNoRB
"; added exclude no rollback exception " + excludeExNoRB);
			}
		}
	        
	    if(.isLoggable(.)) {
	      .exiting(mNamethis.toString());
	    }
	  }
	  
	  public boolean isRollbackException(Exception e)
	  {
		  return !isNoRollbackException(e);
	  }
  
Handle exception from a read failure.
	  public void handleExceptionRead(Exception e)
	  {
	    final String mName = "handleExceptionRead";
	    
	    .finer("RETRYHANDLE: in retryhandler handle exception on a read:" + e.toString());
	      .logp(.mNamee.getClass().getName() + "; " + this.toString());
	    
	    if (!isRetryLimitReached() && isRetryable(e))
	    {
	        = ;
	        = e;
	      // Retry it.  Log it.  Call the RetryListener.
	      ++;
	      logRetry(e);
	      if ( != null) {
	    	  for (RetryReadListenerProxy retryReadListenerProxy : ) {
	    		  retryReadListenerProxy.onRetryReadException(e);
				}
	      }
	    }
	    else
	    {
	      // No retry.  Throw it back.
	      if(.isLoggable(.)) 
	        .logp(.mName"No retry.  Rethrow"e);
	      	throw new BatchContainerRuntimeException(e);
	    }
	      .exiting(mNamee);
	  }

  
Handle exception from a process failure.
	  public void handleExceptionProcess(Exception eObject w)
	  {
	    final String mName = "handleExceptionProcess";
	    
	      .logp(.mNamee.getClass().getName() + "; " + this.toString());
	    
	    if (!isRetryLimitReached() && isRetryable(e))
	    {
	       = ;
	       = e;
	      // Retry it.  Log it.  Call the RetryListener.
	      ++;
	      logRetry(e);
	      if ( != null) {
	    	  for (RetryProcessListenerProxy retryProcessListenerProxy : ) {
	    		  retryProcessListenerProxy.onRetryProcessException(we);
				}
	      }
	    }
	    else
	    {
	      // No retry.  Throw it back.
	      if(.isLoggable(.)) 
	        .logp(.mName"No retry.  Rethrow "e);
	      throw new BatchContainerRuntimeException(e);
	    }
	  }
  
  
Handle exception from a write failure.
	  public void handleExceptionWrite(Exception eList<Objectw)
	  {
	    final String mName = "handleExceptionWrite";
	    
	      .logp(.mNamee.getClass().getName() + "; " + this.toString());
	    if (!isRetryLimitReached() && isRetryable(e))
	    {
	      // Retry it.  Log it.  Call the RetryListener.
	       = ;
	       = e;
	      ++;
	      logRetry(e);
	      if ( != null) {
	    	  for (RetryWriteListenerProxy retryWriteListenerProxy : ) {
	    		  retryWriteListenerProxy.onRetryWriteException(we);
				}
	      }
	    }
	    else
	    {
	      // No retry.  Throw it back.
	      if(.isLoggable(.)) 
	        .logp(.mName"No retry.  Rethrow "e);
	      throw new BatchContainerRuntimeException(e);
	    }
	  }


  
Check the retryable exception lists to determine whether the given Exception is retryable.
	  private boolean isRetryable(Exception e)
	  {
	    final String mName = "isRetryable";
	    String exClassName = e.getClass().getName();
	    
	    
	    if(.isLoggable(.)) 
	      .logp(.mNamemName + ": " + retVal + ": " + exClassName);
	    return retVal;
	  }
	  private boolean isNoRollbackException(Exception e)
	  {
		  final String mName = "isNoRollbackException";
		  String exClassName = e.getClass().getName();
		  
			  
		    .logp(.mNamemName + ": " + retVal + ": " + exClassName);
		  return retVal;
	  }
  
  
Check whether given exception is in the specified exception list
	  private boolean containsException(Set<StringretryListException e)
	  {
	    final String mName = "containsException";
	    boolean retVal = false;
	    for ( Iterator it = retryList.iterator(); it.hasNext(); ) {
	        String exClassName = (Stringit.next();
	       
	        try {
	        	if (retVal = Thread.currentThread().getContextClassLoader().loadClass(exClassName).isInstance(e))
	        		break;
	        } catch (ClassNotFoundException cnf) {
	        	.logp(.mNamecnf.getLocalizedMessage());
	        }
	    }
	    if(.isLoggable(.)) 
	      .logp(.mNamemName + ": " + retVal );
	    return retVal;
	  }

  
Check if the retry limit has been reached. Note: if retry handling isn't enabled (i.e. not configured in xJCL), then this method will always return TRUE.
	  private boolean isRetryLimitReached()
	  {
	    return ( >= );
	  }
	  
	  private void logRetry(Exception e)
	  {
	    String key = "record.retried.norollback.by.batch.container";
	    Object[] details = { e.getClass().getName() + ": " + e.getMessage() };
	    //String message = LoggerUtil.getFormattedMessage(key, details, true);
	    //logger.info(message);	
		}
	  public Exception getException()
	  {
		  return ;
	  }
	  
	  public long getRetryCount()
	  {
	    return ;
	  }
	  public void setRetryCount(long retryCount)
	  {
	    final String mName = "setRetryCount";
	     = retryCount;
	    if(.isLoggable(.)) 
	      .logp(.mName"setRetryCount: " + );
	  }
	  public String toString()
	  {
	    return "RetryHandler{" + super.toString() + "}count:limit=" +  + ":" + ;
	  }
New to GrepCode? Check out our FAQ X