lwes-perl-event-listener

   1 #!/usr/bin/env perl
   2
   3 use strict;
   4 use warnings;
   5 use Getopt::Long;
   6 use Pod::Usage;
   7 use LWES::EventParser;
   8 use LWES::Listener;
   9 use IO::Socket::INET;
  10 use IO::Socket::Multicast;
  11 use Time::HiRes qw( gettimeofday );
  12 use POSIX;
  13
  14 # don't buffer stdout
  15 $| = 1;
  16
  17 my $port             = $ENV{'LWES_PORT'}    || 9191;
  18 my $addr             = $ENV{'LWES_ADDRESS'} || '224.0.0.69';
  19 my $pidfile          = undef;
  20 my $rootdir          = undef;
  21 my $help_opt         = 0;
  22 my $man_opt          = 0;
  23 my $verbose_opt      = 0;
  24
  25 GetOptions
  26   (
  27     'help'           => \$help_opt,
  28     'man'            => \$man_opt,
  29     'verbose'        => \$verbose_opt,
  30     'm|addr=s'       => \$addr,
  31     'p|port=s'       => \$port,
  32     'r|root=s'       => \$rootdir,
  33     'pidfile=s'      => \$pidfile,
  34   ) or pod2usage (2);
  35
  36 pod2usage (-exitval => -1, -verbose => 0) if $help_opt;
  37 pod2usage (-exitval => -2, -verbose => 2) if $man_opt;
  38
  39 my $listener = shift @ARGV;
  40
  41 # default listener to one which just prints
  42 unless (defined($listener))
  43   {
  44     $listener = "LWES::Listeners::EventPrintingListener";
  45   }
  46
  47 # determine the callback which will process each event
  48 my $processEventFunc = getProcessEventFunc ($listener, @ARGV);
  49
  50 unless (defined $rootdir)
  51   {
  52     # default rootdir to current working directory
  53     $rootdir = getcwd ();
  54   }
  55
  56 # pidfile means to daemonize
  57 if (defined ($pidfile))
  58   {
  59     # place pidfile in cwd as well
  60     unless ($pidfile =~ m#^/#)
  61       {
  62         $pidfile = "$rootdir/$pidfile";
  63       }
  64
  65     chdir '/'                  or die "Can't chdir to /: $!";
  66     open STDIN, '/dev/null'    or die "Can't read /dev/null: $!";
  67     open STDOUT, '>>/dev/null' or die "Can't write to /dev/null: $!";
  68     open STDERR, '>>/dev/null' or die "Can't write to /dev/null: $!";
  69     defined (my $pid = fork)   or die "Can't fork: $!";
  70     if ($pid != 0)
  71       {
  72         # parent writes pidfile
  73         open PID, ">$pidfile";
  74         print PID "$pid";
  75         close PID;
  76         exit;
  77       }
  78     else
  79       {
  80         # child continues daemonizing
  81         POSIX::setsid()        or die "Can't start a new session: $!";
  82         umask 0;
  83         open STDOUT, "> $rootdir/listener.out";
  84         open STDERR, "> $rootdir/listener.err";
  85       }
  86   }
  87
  88 # set up socket either UDP or Multicast
  89 my $sock = undef;
  90 if ($addr eq "0.0.0.0")
  91   {
  92     $sock = IO::Socket::INET->new(LocalPort=>$port, Proto=>'udp', Reuse=>1);
  93   }
  94 else
  95   {
  96     $sock = IO::Socket::Multicast->new(LocalPort=>$port, Reuse=>1)
  97       or die "Can't create socket: $!";
  98     # add multicast address
  99     $sock->mcast_add($addr) or die "mcast_add: $!";
 100   }
 101
 102 $sock->sockopt(SO_RCVBUF,(16*1024*1024));
 103
 104 while (1)
 105   {
 106     my ($message, $peer);
 107     die "recv error: $!" unless $peer = recv ($sock, $message, 65535, 0);
 108     my ($port, $peeraddr) = sockaddr_in($peer);
 109
 110     my $event = bytesToEvent($message);
 111
 112     # set up a header similiar to the lwes header
 113     my ($seconds, $microseconds) = gettimeofday;
 114     my $millis = int($microseconds/1000);
 115
 116     $event->{'ReceiptTime'}       = $seconds*1000+$millis;
 117     $event->{'ReceiptTimeSecs'}   = $seconds;
 118     $event->{'ReceiptTimeMillis'} = $millis;
 119     $event->{'SenderIP'}          = inet_ntoa($peeraddr);
 120     $event->{'SenderPort'}        = $port;
 121
 122     # let the listener process the event
 123     $processEventFunc->($event);
 124   }
 125
 126 0;
 127
 128 __END__
 129
 130 =head1 NAME
 131
 132 lwes-perl-event-listener - listens for events on the network
 133
 134 =head1 SYNOPSIS
 135
 136 lwes-perl-event-listener [options] [<listener> [<args>] | <code>]
 137
 138 Options:
 139   -m|--addr <ip>              Address to listen on
 140                                 (default: 224.0.0.69)
 141   -p|--port <port>            Port numer to listen on
 142                                 (default: 9191)
 143   -r|--root <dir>             Directory to write logs/pid files
 144                                 (default: cwd)
 145   --pidfile <filepath>        If a pidfile is specified this
 146                               will daemonize itself.
 147   -help                       Brief help message
 148   -man                        Full Documentation
 149
 150 <listener> is the name of a perl module which extends the base
 151 listener LWES::Listener and provides an initialize and processEvent
 152 method.  The <args> are passed directly to the listener constructor.
 153
 154 code is perl code which is embedded in a function which takes one
 155 argument, a reference to a perl hash which contains the contents
 156 of the event called $event
 157
 158 =head1 OPTIONS
 159
 160 =over 8
 161
 162 =item B<-m|--addr>
 163
 164 The address to listen on, if you are using UDP this should be 0.0.0.0,
 165 otherwise it should be a valid multicast address.
 166
 167 =item B<-p|--port>
 168
 169 The port to listen on.
 170
 171 =item B<-r|--root>
 172
 173 The directory to write log and pidfiles when daemonizing
 174
 175 =item B<--pidfile>
 176
 177 The path to a pidfile, it will default to being in the B<root> directory,
 178 specifying this option causes the listener to daemonize itself.
 179
 180 =item B<-help>
 181
 182 Print help information
 183
 184 =item B<-man>
 185
 186 Print more verbose help information
 187
 188 =back
 189
 190 =head1 DESCRIPTION
 191
 192 The lwes-perl-event-listener is a tool for inspecting LWES events that are
 193 flowing to a particular machine.  It can listen for either multicast or
 194 udp events on an ip and port, then process the events as it receives them.
 195 It processes events as they appear, so on a heavy LWES stream may not be
 196 able to clear the system network buffer before it overflows.
 197
 198 There are several ways to use the tool.  To just print out events as they
 199 are seen it can be invoked as
 200
 201 % lwes-perl-event-listener -m <ip> -p <port>
 202
 203 If you wish to create a module for handling events a skeleton is as
 204 follows (saved as Foo.pm)
 205
 206   package Foo;
 207
 208   use strict;
 209
 210   @Foo::ISA = qw(LWES::Listener);
 211
 212   sub initialize
 213   {
 214     my $self = shift;
 215
 216     print "Bar : initialize with @_\n";
 217   }
 218
 219   sub processEvent
 220   {
 221     my $self  = shift;
 222     my $event = shift;
 223
 224     print "Foo : Got event!\n";
 225   }
 226
 227   1;
 228
 229 Which can then be invoked as
 230
 231 % lwes-perl-event-listener -m <ip> -p <port> Foo foo_arg
 232
 233 This assumes the Foo.pm file is in the directory you invoke the listener
 234 from.
 235
 236 Alternatively, you can install a listener into the LWES/Listeners/ directory
 237 in the perl LWES distribution (you'll have to find it).  In that case the
 238 file should look like
 239
 240   package LWES::Listeners::Bar;
 241
 242   use strict;
 243
 244   @LWES::Listeners::Bar::ISA = qw(LWES::Listener);
 245
 246   sub initialize
 247   {
 248     my $self = shift;
 249
 250     print "Bar : initialize with @_\n";
 251   }
 252
 253   sub processEvent
 254   {
 255     my $self  = shift;
 256     my $event = shift;
 257
 258     print "Bar : Got event!\n";
 259   }
 260
 261   1;
 262
 263 And be saved as Bar.pm in the system LWES/Listeners directory.  It can then
 264 be invoked as
 265
 266 % lwes-perl-event-listener -m <ip> -p <port> Bar bar_arg
 267
 268 Finally, the listener can be passed code which will be wrapped in a function
 269 called for each event.  An example of this is
 270
 271 % lwes-perl-event-listener -m <ip> -p <port> \
 272     'print $event->{"EventType"}."\n";'
 273
 274 Internally this is wrapped by a function like
 275
 276   sub processEvent {
 277     my $event = shift;
 278     <code from command line>
 279   }
 280
 281 The $event is a reference to a perl hash.  64-bit values are Math::BigInt
 282 objects.
 283
 284 =cut
 285