Coverage Report - org.mule.routing.inbound.SelectiveConsumer
 
Classes in this File Line Coverage Branch Coverage Complexity
SelectiveConsumer
74%
23/31
58%
7/12
2.125
 
 1  
 /*
 2  
  * $Id: SelectiveConsumer.java 11531 2008-04-08 15:34:34Z rossmason $
 3  
  * --------------------------------------------------------------------------------------
 4  
  * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.com
 5  
  *
 6  
  * The software in this package is published under the terms of the CPAL v1.0
 7  
  * license, a copy of which has been included with this distribution in the
 8  
  * LICENSE.txt file.
 9  
  */
 10  
 
 11  
 package org.mule.routing.inbound;
 12  
 
 13  
 import org.mule.DefaultMuleMessage;
 14  
 import org.mule.api.MessagingException;
 15  
 import org.mule.api.MuleEvent;
 16  
 import org.mule.api.MuleMessage;
 17  
 import org.mule.api.routing.InboundRouter;
 18  
 import org.mule.api.routing.RoutingException;
 19  
 import org.mule.api.routing.MessageInfoMapping;
 20  
 import org.mule.api.routing.filter.Filter;
 21  
 import org.mule.api.transformer.TransformerException;
 22  
 import org.mule.config.i18n.CoreMessages;
 23  
 import org.mule.routing.AbstractRouter;
 24  
 import org.mule.routing.MuleMessageInfoMapping;
 25  
 
 26  
 import org.apache.commons.logging.Log;
 27  
 import org.apache.commons.logging.LogFactory;
 28  
 
 29  
 /**
 30  
  * <code>SelectiveConsumer</code> is an inbound router used to filter out unwanted
 31  
  * events. The filtering is performed by a <code>Filter</code> that can be set
 32  
  * on the router.
 33  
  * 
 34  
  * @see InboundRouter
 35  
  * @see org.mule.api.routing.InboundRouterCollection
 36  
  * @see org.mule.api.routing.RouterCollection
 37  
  */
 38  
 
 39  10
 public class SelectiveConsumer extends AbstractRouter implements InboundRouter
 40  
 {
 41  10
     protected final Log logger = LogFactory.getLog(getClass());
 42  
 
 43  
     private volatile Filter filter;
 44  10
     private volatile boolean transformFirst = true;
 45  
 
 46  10
     private MessageInfoMapping messageInfoMapping = new MuleMessageInfoMapping();
 47  
 
 48  
     public boolean isMatch(MuleEvent event) throws MessagingException
 49  
     {
 50  62
         if (logger.isDebugEnabled())
 51  
         {
 52  0
             logger.debug("Attempting to route event: " + event.getId());
 53  
         }
 54  
 
 55  62
         if (filter == null)
 56  
         {
 57  34
             return true;
 58  
         }
 59  
 
 60  28
         MuleMessage message = event.getMessage();
 61  
 
 62  28
         if (transformFirst)
 63  
         {
 64  
             try
 65  
             {
 66  24
                 Object payload = event.transformMessage();
 67  24
                 message = new DefaultMuleMessage(payload, message);
 68  
             }
 69  0
             catch (TransformerException e)
 70  
             {
 71  0
                 throw new RoutingException(
 72  
                     CoreMessages.transformFailedBeforeFilter(), event.getMessage(), 
 73  
                     event.getEndpoint(), e);
 74  24
             }
 75  
         }
 76  
 
 77  28
         boolean result = filter.accept(message);
 78  
 
 79  28
         if (logger.isDebugEnabled())
 80  
         {
 81  0
             logger.debug("MuleEvent " + event.getId() + (result ? " passed filter " : " did not pass filter ")
 82  
                             + filter.getClass().getName());
 83  
         }
 84  
 
 85  28
         return result;
 86  
     }
 87  
 
 88  
     public MuleEvent[] process(MuleEvent event) throws MessagingException
 89  
     {
 90  8
         if (this.isMatch(event))
 91  
         {
 92  8
             return new MuleEvent[]{event};
 93  
         }
 94  
         else
 95  
         {
 96  0
             return null;
 97  
         }
 98  
     }
 99  
 
 100  
     public Filter getFilter()
 101  
     {
 102  4
         return filter;
 103  
     }
 104  
 
 105  
     public void setFilter(Filter filter)
 106  
     {
 107  4
         this.filter = filter;
 108  4
     }
 109  
 
 110  
     public boolean isTransformFirst()
 111  
     {
 112  0
         return transformFirst;
 113  
     }
 114  
 
 115  
     public void setTransformFirst(boolean transformFirst)
 116  
     {
 117  2
         this.transformFirst = transformFirst;
 118  2
     }
 119  
 
 120  
     public MessageInfoMapping getMessageInfoMapping()
 121  
     {
 122  2
         return messageInfoMapping;
 123  
     }
 124  
 
 125  
     public void setMessageInfoMapping(MessageInfoMapping messageInfoMapping)
 126  
     {
 127  0
         this.messageInfoMapping = messageInfoMapping;
 128  0
     }
 129  
 }