src/org/lwes/emitter/MulticastEventEmitter.java

   1 package org.lwes.emitter;
   2
   3 import org.lwes.Event;
   4 import org.lwes.EventSystemException;
   5 import org.lwes.util.Log;
   6
   7 import java.io.IOException;
   8 import java.io.InputStream;
   9 import java.net.DatagramPacket;
  10 import java.net.InetAddress;
  11 import java.net.MulticastSocket;
  12
  13 /**
  14  * MulticastEventEmitter emits events to multicast groups on the network.  This is the most common
  15  * class used by users of the Light Weight Event System.
  16  * <p/>
  17  * Example code:
  18  * <pre>
  19  * MulticastEventEmitter emitter = new MulticastEventEmitter();
  20  * emitter.setESFFilePath("/path/to/esf/file");
  21  * emitter.setMulticastAddress(InetAddress.getByName("224.0.0.69"));
  22  * emitter.setMulticastPort(9191);
  23  * emitter.initialize();
  24  * <p/>
  25  * Event e = emitter.createEvent("MyEvent", false);
  26  * e.setString("key","value");
  27  * emitter.emit(e);
  28  * </pre>
  29  *
  30  * @author Michael P. Lum
  31  * @author Anthony Molinaro
  32  * @since 0.0.1
  33  */
  34 public class MulticastEventEmitter extends AbstractEventEmitter {
  35
  36     /* the actual multicast socket being used */
  37     private MulticastSocket socket = null;
  38
  39     /* the multicast address */
  40     private InetAddress address = null;
  41
  42     /* the multicast port */
  43     private int port = 9191;
  44
  45     /* the multicast interface */
  46     private InetAddress iface = null;
  47
  48     /* the multicast time-to-live */
  49     private int ttl = 31;
  50
  51     /* a lock variable to synchronize events */
  52     private final Object lock = new Object();
  53
  54     /**
  55      * Default constructor.
  56      */
  57     public MulticastEventEmitter() {
  58     }
  59
  60     /**
  61      * Sets the multicast address for this emitter.
  62      *
  63      * @param address the multicast address
  64      */
  65     public void setMulticastAddress(InetAddress address) {
  66         this.address = address;
  67     }
  68
  69     /**
  70      * Gets the multicast address for this emitter.
  71      *
  72      * @return the address
  73      */
  74     public InetAddress getMulticastAddress() {
  75         return this.address;
  76     }
  77
  78     /**
  79      * Sets the multicast port for this emitter.
  80      *
  81      * @param port the multicast port
  82      */
  83     public void setMulticastPort(int port) {
  84         this.port = port;
  85     }
  86
  87     /**
  88      * Gets the multicast port for this emitter.
  89      *
  90      * @return the multicast port
  91      */
  92     public int getMulticastPort() {
  93         return this.port;
  94     }
  95
  96     /**
  97      * Sets the network interface for this emitter.
  98      *
  99      * @param iface the network interface
 100      */
 101     public void setInterface(InetAddress iface) {
 102         this.iface = iface;
 103     }
 104
 105     /**
 106      * Gets the network interface for this emitter.
 107      *
 108      * @return the interface address
 109      */
 110     public InetAddress getInterface() {
 111         return this.iface;
 112     }
 113
 114     /**
 115      * Sets the multicast time-to-live for this emitter.
 116      *
 117      * @param ttl the time to live
 118      */
 119     public void setTimeToLive(int ttl) {
 120         this.ttl = ttl;
 121     }
 122
 123     /**
 124      * Gets the multicast time-to-live for this emitter.
 125      *
 126      * @return the time to live
 127      */
 128     public int getTimeToLive() {
 129         return this.ttl;
 130     }
 131
 132     /**
 133      * Sets the ESF file used for event validation.
 134      *
 135      * @param esfFilePath the path of the ESF file
 136      */
 137     public void setESFFilePath(String esfFilePath) {
 138         if (getFactory() != null) {
 139             getFactory().setESFFilePath(esfFilePath);
 140         }
 141     }
 142
 143     /**
 144      * Gets the ESF file used for event validation
 145      *
 146      * @return the ESF file path
 147      */
 148     public String getESFFilePath() {
 149         if (getFactory() != null) {
 150             return getFactory().getESFFilePath();
 151         }
 152         else {
 153             return null;
 154         }
 155     }
 156
 157     /**
 158      * Sets an InputStream to be used for event validation.
 159      *
 160      * @param esfInputStream an InputStream used for event validation
 161      */
 162     public void setESFInputStream(InputStream esfInputStream) {
 163         if (getFactory() != null) {
 164             getFactory().setESFInputStream(esfInputStream);
 165         }
 166     }
 167
 168     /**
 169      * Gets the InputStream being used for event validation.
 170      *
 171      * @return the InputStream of the ESF validator
 172      */
 173     public InputStream getESFInputStream() {
 174         if (getFactory() != null) {
 175             return getFactory().getESFInputStream();
 176         }
 177         else {
 178             return null;
 179         }
 180     }
 181
 182     /**
 183      * Initializes the emitter.
 184      */
 185     public void initialize() throws IOException {
 186         super.initialize();
 187         socket = new MulticastSocket();
 188
 189         if (iface != null) {
 190             socket.setInterface(iface);
 191         }
 192
 193         socket.setTimeToLive(ttl);
 194     }
 195
 196     /**
 197      * Shuts down the emitter.
 198      */
 199     public void shutdown() throws IOException {
 200         socket.close();
 201         super.shutdown();
 202     }
 203
 204     /**
 205      * Creates a new event named <tt>eventName</tt>.
 206      *
 207      * @param eventName the name of the event to be created
 208      * @return a new Event
 209      * @throws EventSystemException if there is a problem creating the event
 210      */
 211     public Event createEvent(String eventName) throws EventSystemException {
 212         return createEvent(eventName, true);
 213     }
 214
 215     /**
 216      * Creates a new event named <tt>eventName</tt>.
 217      *
 218      * @param eventName the name of the event to be created
 219      * @param validate  whether or not to validate the event against the EventTemplateDB
 220      * @return a new Event
 221      * @throws EventSystemException if there is a problem creating the event
 222      */
 223     public Event createEvent(String eventName, boolean validate) throws EventSystemException {
 224         if (getFactory() != null) {
 225             return getFactory().createEvent(eventName, validate);
 226         }
 227         else {
 228             throw new EventSystemException("EventFactory not initialized");
 229         }
 230     }
 231
 232     /**
 233      * Emits the event to the network.
 234      *
 235      * @param event the event to emit
 236      * @throws IOException throws an IOException is there is a network error.
 237      */
 238     public void emit(Event event) throws IOException {
 239         byte[] msg = event.serialize();
 240
 241         synchronized (lock) {
 242             emit(msg);
 243             try {
 244                 collectStatistics();
 245             }
 246             catch (EventSystemException e) {
 247                 Log.error(e.getMessage(), e);
 248             }
 249         }
 250     }
 251
 252     /**
 253      * Emits a byte array to the network.
 254      *
 255      * @param bytes the byte array to emit
 256      * @throws IOException throws an IOException if there is a network error.
 257      */
 258     protected void emit(byte[] bytes) throws IOException {
 259         /* don't bother with empty arrays */
 260         if (bytes == null) {
 261             return;
 262         }
 263
 264         /* construct a datagram */
 265         DatagramPacket dp = new DatagramPacket(bytes, bytes.length, address, port);
 266         socket.send(dp);
 267     }
 268 }