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