Coverage Report - org.mule.providers.udp.UdpMessageReceiver
 
Classes in this File Line Coverage Branch Coverage Complexity
UdpMessageReceiver
68%
43/63
65%
13/20
2.529
UdpMessageReceiver$UdpWorker
53%
19/36
29%
4/14
2.529
 
 1  
 /*
 2  
  * $Id: UdpMessageReceiver.java 9949 2007-11-29 21:56:42Z aperepel $
 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.providers.udp;
 12  
 
 13  
 import org.mule.config.MuleProperties;
 14  
 import org.mule.config.i18n.CoreMessages;
 15  
 import org.mule.impl.MuleMessage;
 16  
 import org.mule.providers.AbstractMessageReceiver;
 17  
 import org.mule.providers.udp.i18n.UdpMessages;
 18  
 import org.mule.umo.UMOComponent;
 19  
 import org.mule.umo.UMOException;
 20  
 import org.mule.umo.UMOMessage;
 21  
 import org.mule.umo.endpoint.UMOEndpoint;
 22  
 import org.mule.umo.lifecycle.Disposable;
 23  
 import org.mule.umo.lifecycle.InitialisationException;
 24  
 import org.mule.umo.provider.UMOConnector;
 25  
 import org.mule.umo.provider.UMOMessageAdapter;
 26  
 import org.mule.umo.transformer.UMOTransformer;
 27  
 
 28  
 import java.io.IOException;
 29  
 import java.net.DatagramPacket;
 30  
 import java.net.DatagramSocket;
 31  
 import java.net.InetAddress;
 32  
 import java.net.SocketAddress;
 33  
 import java.net.SocketTimeoutException;
 34  
 import java.net.URI;
 35  
 import java.net.UnknownHostException;
 36  
 
 37  
 import javax.resource.spi.work.Work;
 38  
 import javax.resource.spi.work.WorkException;
 39  
 import javax.resource.spi.work.WorkManager;
 40  
 
 41  
 /**
 42  
  * <code>UdpMessageReceiver</code> receives UDP message packets.
 43  
  */
 44  4004
 public class UdpMessageReceiver extends AbstractMessageReceiver implements Work
 45  
 {
 46  10
     protected DatagramSocket socket = null;
 47  
     protected InetAddress inetAddress;
 48  
     protected int bufferSize;
 49  
     private URI uri;
 50  10
     protected UMOTransformer responseTransformer = null;
 51  
 
 52  
     public UdpMessageReceiver(UMOConnector connector, UMOComponent component, UMOEndpoint endpoint)
 53  
         throws InitialisationException
 54  
     {
 55  10
         super(connector, component, endpoint);
 56  10
         bufferSize = ((UdpConnector)connector).getReceiveBufferSize();
 57  
 
 58  10
         uri = endpoint.getEndpointURI().getUri();
 59  
 
 60  
         try
 61  
         {
 62  10
             if(!"null".equalsIgnoreCase(uri.getHost()))
 63  
             {
 64  8
                 inetAddress = InetAddress.getByName(uri.getHost());
 65  
             }
 66  
         }
 67  0
         catch (UnknownHostException e)
 68  
         {
 69  0
             throw new InitialisationException(UdpMessages.failedToLocateHost(uri), e, this);
 70  10
         }
 71  
 
 72  10
         responseTransformer = getResponseTransformer();
 73  10
     }
 74  
 
 75  
     protected void doConnect() throws Exception
 76  
     {
 77  
         try
 78  
         {
 79  4
             socket = ((UdpConnector)connector).getSocket(endpoint);
 80  
         }
 81  0
         catch (Exception e)
 82  
         {
 83  0
             throw new InitialisationException(UdpMessages.failedToBind(uri), e, this);
 84  4
         }
 85  
 
 86  
         try
 87  
         {
 88  4
             getWorkManager().scheduleWork(this, WorkManager.INDEFINITE, null, connector);
 89  
         }
 90  0
         catch (WorkException e)
 91  
         {
 92  0
             throw new InitialisationException(CoreMessages.failedToScheduleWork(), e, this);
 93  4
         }
 94  4
     }
 95  
 
 96  
     protected void doDisconnect() throws Exception
 97  
     {
 98  
         // this will cause the server thread to quit
 99  4
         disposing.set(true);
 100  4
         if (socket != null)
 101  
         {
 102  4
             socket.close();
 103  
         }
 104  
 
 105  4
     }
 106  
 
 107  
     protected void doStart() throws UMOException
 108  
     {
 109  
         // nothing to do
 110  4
     }
 111  
 
 112  
     protected void doStop() throws UMOException
 113  
     {
 114  
         // nothing to do
 115  4
     }
 116  
 
 117  
     protected UMOTransformer getResponseTransformer() throws InitialisationException
 118  
     {
 119  10
         UMOTransformer transformer = component.getDescriptor().getResponseTransformer();
 120  10
         if (transformer == null)
 121  
         {
 122  10
             return connector.getDefaultResponseTransformer();
 123  
         }
 124  0
         return transformer;
 125  
     }
 126  
 
 127  
     protected DatagramSocket createSocket(URI uri, InetAddress inetAddress) throws IOException
 128  
     {
 129  0
         return new DatagramSocket(uri.getPort(), inetAddress);
 130  
     }
 131  
 
 132  
     /**
 133  
      * Obtain the serverSocket
 134  
      */
 135  
     public DatagramSocket getSocket()
 136  
     {
 137  0
         return socket;
 138  
     }
 139  
 
 140  
     protected DatagramPacket createPacket()
 141  
     {
 142  2006
         DatagramPacket packet = new DatagramPacket(new byte[bufferSize], bufferSize);
 143  
 //        if (uri.getPort() > 0)
 144  
 //        {
 145  
 //            packet.setPort(uri.getPort());
 146  
 //        }
 147  
 //        packet.setAddress(inetAddress);
 148  2006
         return packet;
 149  
     }
 150  
 
 151  
     public void run()
 152  
     {
 153  2010
         while (!disposing.get())
 154  
         {
 155  2006
             if (connector.isStarted())
 156  
             {
 157  
 
 158  
                 try
 159  
                 {
 160  2006
                     DatagramPacket packet = createPacket();
 161  
                     try
 162  
                     {
 163  2006
                         socket.receive(packet);
 164  
 
 165  2002
                         if (logger.isTraceEnabled())
 166  
                         {
 167  0
                             logger.trace("Received packet on: " + uri);
 168  
                         }
 169  
 
 170  2002
                         Work work = createWork(packet);
 171  
                         try
 172  
                         {
 173  2002
                             getWorkManager().scheduleWork(work, WorkManager.INDEFINITE, null, connector);
 174  
                         }
 175  0
                         catch (WorkException e)
 176  
                         {
 177  0
                             logger.error("Udp receiver interrupted: " + e.getMessage(), e);
 178  2002
                         }
 179  
                     }
 180  0
                     catch (SocketTimeoutException e)
 181  
                     {
 182  
                         // ignore
 183  2002
                     }
 184  
 
 185  
                 }
 186  4
                 catch (Exception e)
 187  
                 {
 188  4
                     if (!connector.isDisposed() && !disposing.get())
 189  
                     {
 190  0
                         logger.debug("Accept failed on socket: " + e, e);
 191  0
                         handleException(e);
 192  
                     }
 193  2006
                 }
 194  
             }
 195  
         }
 196  4
     }
 197  
 
 198  
     public void release()
 199  
     {
 200  0
         dispose();
 201  0
     }
 202  
 
 203  
     protected void doDispose()
 204  
     {
 205  10
         if (socket != null && !socket.isClosed())
 206  
         {
 207  0
             logger.debug("Closing Udp connection: " + uri);
 208  0
             socket.close();
 209  0
             logger.info("Closed Udp connection: " + uri);
 210  
         }
 211  10
     }
 212  
 
 213  
     protected Work createWork(DatagramPacket packet) throws IOException
 214  
     {
 215  2002
         return new UdpWorker(new DatagramSocket(0), packet);
 216  
     }
 217  
 
 218  
     protected class UdpWorker implements Work, Disposable
 219  
     {
 220  2002
         private DatagramSocket socket = null;
 221  
         private DatagramPacket packet;
 222  
 
 223  
         public UdpWorker(DatagramSocket socket, DatagramPacket packet)
 224  2002
         {
 225  2002
             this.socket = socket;
 226  2002
             this.packet = packet;
 227  2002
         }
 228  
 
 229  
         public void release()
 230  
         {
 231  0
             dispose();
 232  0
         }
 233  
 
 234  
         public void dispose()
 235  
         {
 236  2002
             if (socket != null && !socket.isClosed())
 237  
             {
 238  
                 try
 239  
                 {
 240  2002
                     socket.close();
 241  
                 }
 242  0
                 catch (Exception e)
 243  
                 {
 244  0
                     logger.error("Socket close failed", e);
 245  2002
                 }
 246  
             }
 247  2002
             socket = null;
 248  2002
         }
 249  
 
 250  
         /**
 251  
          * Accept requests from a given Udp address
 252  
          */
 253  
         public void run()
 254  
         {
 255  2002
             UMOMessage returnMessage = null;
 256  
             try
 257  
             {
 258  2002
                 UMOMessageAdapter adapter = connector.getMessageAdapter(packet);
 259  2002
                 final SocketAddress clientAddress = socket.getRemoteSocketAddress();
 260  2002
                 if (clientAddress != null)
 261  
                 {
 262  0
                     adapter.setProperty(MuleProperties.MULE_REMOTE_CLIENT_ADDRESS, clientAddress);
 263  
                 }
 264  2002
                 returnMessage = routeMessage(new MuleMessage(adapter), endpoint.isSynchronous());
 265  
 
 266  2002
                 if (returnMessage != null)
 267  
                 {
 268  
                     byte[] data;
 269  0
                     if (responseTransformer != null)
 270  
                     {
 271  0
                         Object response = responseTransformer.transform(returnMessage.getPayload());
 272  0
                         if (response instanceof byte[])
 273  
                         {
 274  0
                             data = (byte[])response;
 275  
                         }
 276  
                         else
 277  
                         {
 278  0
                             data = response.toString().getBytes();
 279  
                         }
 280  0
                     }
 281  
                     else
 282  
                     {
 283  0
                         data = returnMessage.getPayloadAsBytes();
 284  
                     }
 285  0
                     DatagramPacket result = new DatagramPacket(data, data.length, packet.getAddress(),
 286  
                         packet.getPort());
 287  0
                     socket.send(result);
 288  
                 }
 289  
             }
 290  0
             catch (Exception e)
 291  
             {
 292  0
                 if (!disposing.get())
 293  
                 {
 294  0
                     handleException(e);
 295  
                 }
 296  
             }
 297  
             finally
 298  
             {
 299  2002
                 dispose();
 300  2002
             }
 301  2002
         }
 302  
     }
 303  
 }