src/lwes-event-testing-emitter.c

   1 /*======================================================================*
   2  * Copyright (C) 2008 Light Weight Event System                         *
   3  * All rights reserved.                                                 *
   4  *                                                                      *
   5  * This program is free software; you can redistribute it and/or modify *
   6  * it under the terms of the GNU General Public License as published by *
   7  * the Free Software Foundation; either version 2 of the License, or    *
   8  * (at your option) any later version.                                  *
   9  *                                                                      *
  10  * This program is distributed in the hope that it will be useful,      *
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
  13  * GNU General Public License for more details.                         *
  14  *                                                                      *
  15  * You should have received a copy of the GNU General Public License    *
  16  * along with this program; if not, write to the Free Software          *
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                   *
  18  * Boston, MA 02110-1301 USA.                                           *
  19  *======================================================================*/
  20 #include <assert.h>
  21 #include <signal.h>
  22 #include <sys/types.h>
  23 #include <unistd.h>
  24
  25 #include "lwes_emitter.h"
  26 #include "lwes_time_functions.h"
  27
  28 static const char help[] =
  29   "lwes-event-testing-emitter [options]"                               "\n"
  30   ""                                                                   "\n"
  31   "  where options are:"                                               "\n"
  32   ""                                                                   "\n"
  33   "    -m [one argument]"                                              "\n"
  34   "       The multicast ip address to listen on."                      "\n"
  35   "       (default: 224.1.1.11)"                                       "\n"
  36   ""                                                                   "\n"
  37   "    -p [one argument]"                                              "\n"
  38   "       The ip port to listen on."                                   "\n"
  39   "       (default: 12345)"                                            "\n"
  40   ""                                                                   "\n"
  41   "    -i [one argument]"                                              "\n"
  42   "       The interface to listen on."                                 "\n"
  43   "       (default: 0.0.0.0)"                                          "\n"
  44   ""                                                                   "\n"
  45   "    -n [one argument]"                                              "\n"
  46   "       The number of events per second to emit."                    "\n"
  47   "       (default: 1)"                                                "\n"
  48   ""                                                                   "\n"
  49   "    -s [one argument]"                                              "\n"
  50   "       The number of seconds to emit for."                          "\n"
  51   "       (default: 1)"                                                "\n"
  52   ""                                                                   "\n"
  53   "    -x [one argument]"                                              "\n"
  54   "       The number of extra pad bytes to add to each event."         "\n"
  55   "       (default: 0)"                                                "\n"
  56   ""                                                                   "\n"
  57   "    -b [one argument]"                                              "\n"
  58   "       The amount of seconds to break for between event bursts."    "\n"
  59   "       (default: 0)"                                                "\n"
  60   ""                                                                   "\n"
  61   "    -e"                                                             "\n"
  62   "       Attempt to emit events evenly throughout each second."       "\n"
  63   ""                                                                   "\n"
  64   "    -h"                                                             "\n"
  65   "       show this message"                                           "\n"
  66   ""                                                                   "\n"
  67   "  arguments are specified as -option value or -optionvalue"         "\n"
  68   ""                                                                   "\n";
  69
  70 int main (int   argc,
  71           char *argv[])
  72 {
  73   const char *mcast_ip    = "224.1.1.11";
  74   const char *mcast_iface = NULL;
  75   int         mcast_port  = 12345;
  76   int         number      = 1;
  77   int         pad         = 0;
  78   int         seconds     = 1;
  79   int         pause       = 0;
  80   int         even        = 0;
  81
  82   struct lwes_emitter * emitter;
  83   struct lwes_event *event;
  84   char *pad_string;
  85
  86   /* turn off error messages, I'll handle them */
  87   opterr = 0;
  88   while (1)
  89     {
  90       char c = getopt (argc, argv, "m:p:i:n:s:x:b:eh");
  91
  92       if (c == -1)
  93         {
  94           break;
  95         }
  96
  97       switch (c)
  98         {
  99           case 'b':
 100             pause = atoi(optarg);
 101
 102             break;
 103
 104           case 'm':
 105             mcast_ip = optarg;
 106
 107             break;
 108
 109           case 'p':
 110             mcast_port = atoi(optarg);
 111
 112             break;
 113
 114           case 'n':
 115             number = atoi(optarg);
 116
 117             break;
 118
 119           case 's':
 120             seconds = atoi(optarg);
 121             break;
 122
 123           case 'e':
 124             even = 1;
 125             break;
 126
 127           case 'h':
 128             fprintf (stderr, "%s", help);
 129
 130             return 1;
 131
 132           case 'i':
 133             mcast_iface = optarg;
 134
 135             break;
 136
 137           case 'x':
 138             pad = atoi(optarg);
 139             break;
 140
 141           default:
 142             fprintf (stderr,
 143                      "error: unrecognized command line option -%c\n",
 144                      optopt);
 145
 146             return 1;
 147         }
 148     }
 149
 150   pad_string = NULL;
 151   if (pad > 0)
 152     {
 153       pad_string = malloc(pad+1);
 154       if (pad_string == NULL)
 155         {
 156           fprintf (stderr,
 157                    "Unable to allocate %d bytes for pad string\n",
 158                    pad);
 159           exit(1);
 160         }
 161       else
 162         {
 163           memset(pad_string, 'X', pad);
 164           pad_string[pad] = '\0';
 165         }
 166     }
 167
 168   emitter = lwes_emitter_create ( (LWES_SHORT_STRING) mcast_ip,
 169                                   (LWES_SHORT_STRING) mcast_iface,
 170                                   (LWES_U_INT_32)     mcast_port,
 171                                   0,
 172                                   10 );
 173
 174   assert (emitter != NULL);
 175
 176   {
 177     int i,s,n;
 178     LWES_INT_64 start  = 0LL;
 179     LWES_INT_64 stop   = 0LL;
 180
 181     for (s = 0, n = 0; s < seconds; ++s)
 182       {
 183         start = currentTimeMillisLongLong ();
 184         stop  = start;
 185         for (i = 0; i < number; ++i, ++n)
 186           {
 187             event  = lwes_event_create (NULL, "MyEvent");
 188             assert (event != NULL);
 189
 190             assert
 191               (lwes_event_set_STRING   (event, "field", "hello world") == 1 );
 192             assert
 193               (lwes_event_set_INT_32   (event, "count", i) == 2);
 194             assert
 195               (lwes_event_set_INT_32   (event, "run", s) == 3);
 196             assert
 197               (lwes_event_set_STRING (event, "prog_id","12345") == 4);
 198             assert
 199               (lwes_event_set_INT_16 (event,"num", 2) == 5);
 200             assert
 201               (lwes_event_set_STRING (event,"k0", "a-key.count") == 6);
 202             assert
 203               (lwes_event_set_INT_16 (event,"v0", 1) == 7);
 204             assert
 205               (lwes_event_set_STRING (event,"k1", "b-key.count") == 8);
 206             assert
 207               (lwes_event_set_INT_16 (event,"v1", 2) == 9);
 208             assert
 209               (lwes_event_set_U_INT_64(event, "global_count", n) == 10);
 210             assert
 211               (lwes_event_set_INT_64 (event,"SentTime", stop) == 11);
 212             if (pad>0) {
 213               assert(lwes_event_set_STRING (event,"pad",pad_string) == 12);
 214             }
 215
 216             assert (lwes_emitter_emit (emitter, event) == 0);
 217
 218             lwes_event_destroy(event);
 219             stop = currentTimeMillisLongLong ();
 220
 221             /* if we are going over our total time, bail out */
 222             if ((stop - start) >= 1000)
 223               {
 224                 printf ("Was only able to emit %7d in 1 sec\n",i);
 225                 break;
 226               }
 227
 228             /* if we are attempting to send events evenly throughout
 229             the second, consider pausing briefly to get back on
 230             schedule */
 231             if (even)
 232               {
 233                 const int delay_ms = (i*1000/number) - (stop-start);
 234                 if (delay_ms > 0)
 235                   {
 236                     usleep (delay_ms*1000);
 237                   }
 238               }
 239           }
 240         {
 241           const int delay_ms = (1000 - (stop - start))*1000;
 242           if (delay_ms > 0) usleep (delay_ms);
 243         }
 244         {
 245           char timebuff[20];
 246           /* HH/MM/SS DD/MM/YYYY  */
 247           /* 12345678901234567890 */
 248           time_t start_time = time (NULL);
 249
 250           strftime (timebuff, 20, "%H:%M:%S %d/%m/%Y", localtime (&start_time));
 251
 252           printf ("%s : %7d\n", timebuff, i);
 253         }
 254
 255         sleep (pause);
 256       }
 257     lwes_emitter_destroy(emitter);
 258     if (pad_string!=NULL) free(pad_string);
 259   }
 260
 261   return 0;
 262 }