Coverage report

  %line %branch
org.apache.jcs.auxiliary.lateral.socket.tcp.discovery.UDPDiscoverySender
57% 
86% 

 1  
 package org.apache.jcs.auxiliary.lateral.socket.tcp.discovery;
 2  
 
 3  
 /*
 4  
  * Licensed to the Apache Software Foundation (ASF) under one
 5  
  * or more contributor license agreements.  See the NOTICE file
 6  
  * distributed with this work for additional information
 7  
  * regarding copyright ownership.  The ASF licenses this file
 8  
  * to you under the Apache License, Version 2.0 (the
 9  
  * "License"); you may not use this file except in compliance
 10  
  * with the License.  You may obtain a copy of the License at
 11  
  *
 12  
  *   http://www.apache.org/licenses/LICENSE-2.0
 13  
  *
 14  
  * Unless required by applicable law or agreed to in writing,
 15  
  * software distributed under the License is distributed on an
 16  
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 17  
  * KIND, either express or implied.  See the License for the
 18  
  * specific language governing permissions and limitations
 19  
  * under the License.
 20  
  */
 21  
 
 22  
 import java.io.ByteArrayOutputStream;
 23  
 import java.io.IOException;
 24  
 import java.io.ObjectOutputStream;
 25  
 import java.net.DatagramPacket;
 26  
 import java.net.InetAddress;
 27  
 import java.net.MulticastSocket;
 28  
 import java.util.ArrayList;
 29  
 
 30  
 import org.apache.commons.logging.Log;
 31  
 import org.apache.commons.logging.LogFactory;
 32  
 import org.apache.jcs.auxiliary.lateral.LateralCacheInfo;
 33  
 
 34  
 /**
 35  
  * This is a generic sender for the UDPDiscovery process.
 36  
  *
 37  
  * @author Aaron Smuts
 38  
  *
 39  
  */
 40  
 public class UDPDiscoverySender
 41  
 {
 42  26
     private final static Log log = LogFactory.getLog( UDPDiscoverySender.class );
 43  
 
 44  
     private MulticastSocket m_localSocket;
 45  
 
 46  
     private InetAddress m_multicastAddress;
 47  
 
 48  
     private int m_multicastPort;
 49  
 
 50  
     /**
 51  
      * Constructor for the UDPDiscoverySender object
 52  
      * <p>
 53  
      * This sender can be used to send multiple messages.
 54  
      * <p>
 55  
      * When you are done sending, you should destroy the socket sender.
 56  
      *
 57  
      * @param host
 58  
      * @param port
 59  
      *
 60  
      * @exception IOException
 61  
      */
 62  
     public UDPDiscoverySender( String host, int port )
 63  
         throws IOException
 64  13
     {
 65  
         try
 66  
         {
 67  13
             m_localSocket = new MulticastSocket();
 68  
 
 69  
             // Remote address.
 70  13
             m_multicastAddress = InetAddress.getByName( host );
 71  
         }
 72  0
         catch ( IOException e )
 73  
         {
 74  0
             log.error( "Could not bind to multicast address [" + host + "]", e );
 75  
 
 76  0
             throw e;
 77  13
         }
 78  
 
 79  13
         m_multicastPort = port;
 80  13
     }
 81  
 
 82  
     /**
 83  
      * Closes the socket connection.
 84  
      *
 85  
      */
 86  
     public void destroy()
 87  
     {
 88  
         try
 89  
         {
 90  
             // TODO when we move to jdk 1.4 reinstate the isClosed check
 91  26
             if ( this.m_localSocket != null )
 92  
             // && !this.m_localSocket.isClosed() )
 93  
             {
 94  26
                 this.m_localSocket.close();
 95  
             }
 96  
         }
 97  0
         catch ( Exception e )
 98  
         {
 99  0
             log.error( "Problem destrying sender", e );
 100  26
         }
 101  26
     }
 102  
 
 103  
     /**
 104  
      * Just being careful about closing the socket.
 105  
      *
 106  
      * @throws Throwable
 107  
      */
 108  
     public void finalize()
 109  
         throws Throwable
 110  
     {
 111  13
         super.finalize();
 112  13
         destroy();
 113  13
     }
 114  
 
 115  
     /**
 116  
      * Send messages.
 117  
      *
 118  
      * @param message
 119  
      * @throws IOException
 120  
      */
 121  
     public void send( UDPDiscoveryMessage message )
 122  
         throws IOException
 123  
     {
 124  13
         if ( this.m_localSocket == null )
 125  
         {
 126  0
             throw new IOException( "Socket is null, cannot send message." );
 127  
         }
 128  
 
 129  
         // TODO when we move to jdk 1.4 reinstate the isClosed check
 130  
         // if (this.m_localSocket.isClosed() )
 131  
         // {
 132  
         // throw new IOException( "Socket is closed, cannot send message." );
 133  
         // }
 134  
 
 135  13
         if ( log.isDebugEnabled() )
 136  
         {
 137  0
             log.debug( "sending UDPDiscoveryMessage, message = " + message );
 138  
         }
 139  
 
 140  
         try
 141  
         {
 142  
             // write the object to a byte array.
 143  13
             final MyByteArrayOutputStream byteStream = new MyByteArrayOutputStream();
 144  13
             final ObjectOutputStream objectStream = new ObjectOutputStream( byteStream );
 145  13
             objectStream.writeObject( message );
 146  13
             objectStream.flush();
 147  13
             final byte[] bytes = byteStream.getBytes();
 148  
 
 149  
             // put the byte array in a packet
 150  13
             final DatagramPacket packet = new DatagramPacket( bytes, bytes.length, m_multicastAddress, m_multicastPort );
 151  
 
 152  13
             m_localSocket.send( packet );
 153  
         }
 154  0
         catch ( IOException e )
 155  
         {
 156  0
             log.error( "Error sending message", e );
 157  0
             throw e;
 158  13
         }
 159  13
     }
 160  
 
 161  
     /**
 162  
      * Ask other to broadcast their info the the multicast address. If a lateral
 163  
      * is non receiving it can use this. This is also called on startup so we
 164  
      * can get info.
 165  
      *
 166  
      * @throws IOException
 167  
      */
 168  
     public void requestBroadcast()
 169  
         throws IOException
 170  
     {
 171  13
         if ( log.isDebugEnabled() )
 172  
         {
 173  0
             log.debug( "sending requestBroadcast " );
 174  
         }
 175  
 
 176  13
         UDPDiscoveryMessage message = new UDPDiscoveryMessage();
 177  13
         message.setRequesterId( LateralCacheInfo.listenerId );
 178  13
         message.setMessageType( UDPDiscoveryMessage.REQUEST_BROADCAST );
 179  13
         send( message );
 180  13
     }
 181  
 
 182  
     /**
 183  
      * This sends a message braodcasting our that the host and port is available
 184  
      * for connections.
 185  
      * <p>
 186  
      * It uses the vmid as the requesterDI
 187  
      *
 188  
      * @param host
 189  
      * @param port
 190  
      * @param cacheNames
 191  
      * @throws IOException
 192  
      */
 193  
     public void passiveBroadcast( String host, int port, ArrayList cacheNames )
 194  
         throws IOException
 195  
     {
 196  0
         passiveBroadcast( host, port, cacheNames, LateralCacheInfo.listenerId );
 197  0
     }
 198  
 
 199  
     /**
 200  
      * This allows you to set the sender id. This is mainly for testing.
 201  
      *
 202  
      * @param host
 203  
      * @param port
 204  
      * @param cacheNames
 205  
      * @param listenerId
 206  
      * @throws IOException
 207  
      */
 208  
     protected void passiveBroadcast( String host, int port, ArrayList cacheNames, long listenerId )
 209  
         throws IOException
 210  
     {
 211  0
         if ( log.isDebugEnabled() )
 212  
         {
 213  0
             log.debug( "sending passiveBroadcast " );
 214  
         }
 215  
 
 216  0
         UDPDiscoveryMessage message = new UDPDiscoveryMessage();
 217  0
         message.setHost( host );
 218  0
         message.setPort( port );
 219  0
         message.setCacheNames( cacheNames );
 220  0
         message.setRequesterId( listenerId );
 221  0
         message.setMessageType( UDPDiscoveryMessage.PASSIVE_BROADCAST );
 222  0
         send( message );
 223  0
     }
 224  
 }
 225  
 
 226  
 /**
 227  
  * This allows us to get the byte array from an output stream.
 228  
  *
 229  
  * @author asmuts
 230  
  * @created January 15, 2002
 231  
  */
 232  
 
 233  
 class MyByteArrayOutputStream
 234  
     extends ByteArrayOutputStream
 235  
 {
 236  
     /**
 237  
      * Gets the bytes attribute of the MyByteArrayOutputStream object
 238  
      *
 239  
      * @return The bytes value
 240  
      */
 241  
     public byte[] getBytes()
 242  
     {
 243  
         return buf;
 244  
     }
 245  
 }
 246  
 // end class

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.