Coverage Report - org.mule.transport.udp.UdpMessageDispatcher
 
Classes in this File Line Coverage Branch Coverage Complexity
UdpMessageDispatcher
0%
0/52
0%
0/18
0
 
 1  
 /*
 2  
  * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
 3  
  * The software in this package is published under the terms of the CPAL v1.0
 4  
  * license, a copy of which has been included with this distribution in the
 5  
  * LICENSE.txt file.
 6  
  */
 7  
 package org.mule.transport.udp;
 8  
 
 9  
 import org.mule.DefaultMuleMessage;
 10  
 import org.mule.api.MuleEvent;
 11  
 import org.mule.api.MuleMessage;
 12  
 import org.mule.api.endpoint.ImmutableEndpoint;
 13  
 import org.mule.api.endpoint.OutboundEndpoint;
 14  
 import org.mule.api.retry.RetryContext;
 15  
 import org.mule.api.transformer.DataType;
 16  
 import org.mule.transport.AbstractMessageDispatcher;
 17  
 import org.mule.transport.NullPayload;
 18  
 
 19  
 import java.io.IOException;
 20  
 import java.net.DatagramPacket;
 21  
 import java.net.DatagramSocket;
 22  
 import java.net.InetAddress;
 23  
 
 24  
 /**
 25  
  * <code>UdpMessageDispatcher</code> is responsible for dispatching MuleEvents as
 26  
  * UDP packets on the network
 27  
  */
 28  
 
 29  
 public class UdpMessageDispatcher extends AbstractMessageDispatcher
 30  
 {
 31  
     protected final UdpConnector connector;
 32  
 
 33  
     public UdpMessageDispatcher(OutboundEndpoint endpoint)
 34  
     {
 35  0
         super(endpoint);
 36  0
         this.connector = (UdpConnector)endpoint.getConnector();
 37  0
     }
 38  
 
 39  
     @Override
 40  
     public RetryContext validateConnection(RetryContext retryContext)
 41  
     {
 42  0
         DatagramSocket socket = null;
 43  
         try
 44  
         {
 45  0
             socket = connector.getSocket(endpoint);
 46  
 
 47  0
             retryContext.setOk();
 48  
         }
 49  0
         catch (Exception ex)
 50  
         {
 51  0
             retryContext.setFailed(ex);
 52  
         }
 53  
         finally
 54  
         {
 55  0
             if (socket != null)
 56  
             {
 57  
                 try
 58  
                 {
 59  0
                     connector.releaseSocket(socket, endpoint);
 60  
                 }
 61  0
                 catch (Exception e)
 62  
                 {
 63  0
                     if (logger.isDebugEnabled())
 64  
                     {
 65  0
                         logger.debug("Failed to release a socket " + socket, e);
 66  
                     }
 67  0
                 }
 68  
             }
 69  
         }
 70  
 
 71  0
         return retryContext;
 72  
 
 73  
     }
 74  
 
 75  
     @Override
 76  
     protected void doConnect() throws Exception
 77  
     {
 78  
         // nothing, there is an optional validation in validateConnection()
 79  
         
 80  0
     }
 81  
 
 82  
     @Override
 83  
     protected void doDisconnect() throws Exception
 84  
     {
 85  
         // nothing to do
 86  0
     }
 87  
 
 88  
 
 89  
     @Override
 90  
     protected synchronized void doDispatch(MuleEvent event) throws Exception
 91  
     {
 92  0
         ImmutableEndpoint ep = event.getEndpoint();
 93  
 
 94  0
         DatagramSocket socket = connector.getSocket(ep);
 95  
         try
 96  
         {
 97  0
             byte[] payload = event.transformMessage(DataType.BYTE_ARRAY_DATA_TYPE);
 98  
 
 99  0
             int port = ep.getEndpointURI().getPort();
 100  0
             InetAddress inetAddress = null;
 101  
             //TODO, check how expensive this operation is
 102  0
             if("null".equalsIgnoreCase(ep.getEndpointURI().getHost()))
 103  
             {
 104  0
                 inetAddress = InetAddress.getLocalHost();
 105  
             }
 106  
             else
 107  
             {
 108  0
                 inetAddress = InetAddress.getByName(ep.getEndpointURI().getHost());
 109  
             }
 110  
 
 111  0
             write(socket, payload, port, inetAddress);
 112  
         }
 113  
         finally
 114  
         {
 115  0
             connector.releaseSocket(socket, ep);
 116  0
         }
 117  0
     }
 118  
 
 119  
     protected void write(DatagramSocket socket, byte[] data, int port, InetAddress inetAddress) throws IOException
 120  
     {
 121  0
         DatagramPacket packet = new DatagramPacket(data, data.length);
 122  0
         if (port >= 0)
 123  
         {
 124  0
             packet.setPort(port);
 125  
         }
 126  0
         packet.setAddress(inetAddress);
 127  0
         socket.send(packet);
 128  0
     }
 129  
 
 130  
     @Override
 131  
     protected synchronized MuleMessage doSend(MuleEvent event) throws Exception
 132  
     {
 133  0
         doDispatch(event);
 134  
         // If we're doing sync receive try and read return info from socket
 135  0
         if (event.getEndpoint().getExchangePattern().hasResponse())
 136  
         {
 137  0
             DatagramSocket socket = connector.getSocket(event.getEndpoint());
 138  0
             DatagramPacket result = receive(socket, event.getTimeout());
 139  0
             if (result == null)
 140  
             {
 141  0
                 return createNullMuleMessage();
 142  
             }
 143  0
             return createMuleMessage(result, event.getMessage(), endpoint.getEncoding());
 144  
         }
 145  
         else
 146  
         {
 147  0
             return new DefaultMuleMessage(NullPayload.getInstance(), connector.getMuleContext());
 148  
         }
 149  
     }
 150  
 
 151  
     private DatagramPacket receive(DatagramSocket socket, int timeout) throws IOException
 152  
     {
 153  0
         int origTimeout = socket.getSoTimeout();
 154  
         try
 155  
         {
 156  0
             DatagramPacket packet = new DatagramPacket(new byte[connector.getReceiveBufferSize()],
 157  
                 connector.getReceiveBufferSize());
 158  
 
 159  0
             if(timeout > 0 && timeout != socket.getSoTimeout())
 160  
             {
 161  0
                 socket.setSoTimeout(timeout);
 162  
             }
 163  0
             socket.receive(packet);
 164  0
             return packet;
 165  
         }
 166  
         finally
 167  
         {
 168  0
             if(socket.getSoTimeout()!= origTimeout)
 169  
             {
 170  0
                 socket.setSoTimeout(origTimeout);
 171  
             }
 172  
         }
 173  
     }
 174  
 
 175  
     @Override
 176  
     protected void doDispose()
 177  
     {
 178  
         // template method
 179  0
     }
 180  
 }