Coverage Report - org.mule.routing.outbound.MessageChunkingRouter
 
Classes in this File Line Coverage Branch Coverage Complexity
MessageChunkingRouter
0%
0/44
0%
0/16
0
 
 1  
 /*
 2  
  * $Id: MessageChunkingRouter.java 19599 2010-09-10 23:11:54Z tcarlson $
 3  
  * --------------------------------------------------------------------------------------
 4  
  * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.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.outbound;
 12  
 
 13  
 import org.mule.DefaultMuleEvent;
 14  
 import org.mule.DefaultMuleMessage;
 15  
 import org.mule.api.MuleEvent;
 16  
 import org.mule.api.MuleMessage;
 17  
 import org.mule.api.MuleSession;
 18  
 import org.mule.api.routing.RoutingException;
 19  
 import org.mule.config.i18n.CoreMessages;
 20  
 
 21  
 /**
 22  
  * A router that breaks up the current message onto smaller parts and sends them to the
 23  
  * same destination. The Destination service needs to have a MessageChunkingAggregator
 24  
  * inbound router in order to rebuild the message at the other end.
 25  
  */
 26  0
 public class MessageChunkingRouter extends FilteringOutboundRouter
 27  
 {
 28  0
     private int messageSize = 0;
 29  0
     private int numberOfMessages = 1;
 30  
 
 31  
     public int getMessageSize()
 32  
     {
 33  0
         return messageSize;
 34  
     }
 35  
 
 36  
     public void setMessageSize(int messageSize)
 37  
     {
 38  0
         this.messageSize = messageSize;
 39  0
     }
 40  
 
 41  
     public int getNumberOfMessages()
 42  
     {
 43  0
         return numberOfMessages;
 44  
     }
 45  
 
 46  
     public void setNumberOfMessages(int numberOfMessages)
 47  
     {
 48  0
         this.numberOfMessages = numberOfMessages;
 49  0
     }
 50  
 
 51  
     @Override
 52  
     public MuleEvent route(MuleEvent event) throws RoutingException
 53  
     {
 54  0
         MuleMessage message = event.getMessage();
 55  0
         MuleSession session = event.getSession();
 56  0
         if (messageSize == 0 && numberOfMessages < 2)
 57  
         {
 58  0
             return super.route(event);
 59  
         }
 60  0
         else if (messageSize > 0)
 61  
         {
 62  
             byte[] data;
 63  
             try
 64  
             {
 65  0
                 data = message.getPayloadAsBytes();
 66  
             }
 67  0
             catch (Exception e)
 68  
             {
 69  0
                 throw new RoutingException(CoreMessages.failedToReadPayload(), event, getRoute(0, event), e);
 70  0
             }
 71  
 
 72  0
             int parts = data.length / messageSize;
 73  0
             if ((parts * messageSize) < data.length)
 74  
             {
 75  0
                 parts++;
 76  
             }
 77  0
             int len = messageSize;
 78  
             MuleMessage part;
 79  0
             int count = 0;
 80  0
             int pos = 0;
 81  
             byte[] buffer;
 82  
             try
 83  
             {
 84  0
                 for (; count < parts; count++)
 85  
                 {
 86  0
                     if ((pos + len) > data.length)
 87  
                     {
 88  0
                         len = data.length - pos;
 89  
                     }
 90  0
                     buffer = new byte[len];
 91  0
                     System.arraycopy(data, pos, buffer, 0, buffer.length);
 92  0
                     pos += len;
 93  0
                     part = new DefaultMuleMessage(buffer, message, muleContext);
 94  0
                     part.setCorrelationId(message.getUniqueId());
 95  0
                     part.setCorrelationGroupSize(parts);
 96  0
                     part.setCorrelationSequence(count);
 97  
 
 98  0
                     if (logger.isInfoEnabled())
 99  
                     {
 100  0
                         logger.info(String.format("sending part %d of %d (seq # %d)", count + 1, parts, count));
 101  
                     }
 102  0
                     super.route(new DefaultMuleEvent(part, event.getEndpoint(), session));
 103  0
                     if (logger.isInfoEnabled())
 104  
                     {
 105  0
                         logger.info("sent");
 106  
                     }
 107  
                 }
 108  
             }
 109  0
             catch (RoutingException e)
 110  
             {
 111  
                 // we'll want to send the whole message to the Exception handler
 112  0
                 e = new RoutingException(e.getI18nMessage(), e.getEvent(), e.getRoute(), e.getCause());
 113  
                 // e.addInfo("chunking", "true");
 114  
                 // buffer = new byte[data.length - len];
 115  
                 // System.arraycopy(data, len, buffer, 0, buffer.length);
 116  
                 // e.addInfo("remaining data", buffer);
 117  0
                 throw e;
 118  0
             }
 119  
         }
 120  0
         return event;
 121  
     }
 122  
 }