int main(int argc, char **argv)
{
gzFile file;
const char *filename;
char header[22];
unsigned char buf[65535];
const char *args = "n:o:r:tdh";
int number = 0; /* (n) total number to emit */
struct lwes_emitter *emitter = NULL; /* (o) where to send the events */
int rate = 0; /* (r) number per second for emission */
bool use_timings = false; /* (t) using timings from file */
bool repeat = false; /* (d) rerun journals over and over */
int ret = 0;
LWES_INT_64 start = 0LL;
LWES_INT_64 stop = 0LL;
/* turn off error messages, I'll handle them */
opterr = 0;
while (1)
{
char c = getopt (argc, argv, args);
if (c == -1)
{
break;
}
switch (c)
{
case 'n':
number = atoi(optarg);
break;
case 'r':
rate = atoi(optarg);
break;
case 'o':
emitter = handle_transport_arg (optarg);
if (emitter == NULL)
{
fprintf (stderr, "ERROR: problem with emitter\n");
ret = 1;
goto cleanup;
}
break;
case 't':
use_timings = true;
break;
case 'd':
repeat = true;
break;
case 'h':
fprintf (stderr, "%s", help);
ret = 1;
goto cleanup;
default:
fprintf (stderr,
"WARNING: unrecognized command line option -%c\n",
optopt);
}
}
if (optind >= argc)
{
fprintf (stderr, "ERROR: journal file is required\n");
ret = 1;
goto cleanup;
}
/* setup sigint/sigkill/sigpipe handler */
setup_sig_handler();
start = currentTimeMillisLongLong ();
int start_index = optind;
int num_files = argc - optind;
int offset = 0;
int total_count = 0;
int this_second_count = 0;
unsigned long long delay_micros = rate > 0 ? 1000000 / rate : 0;
bool done = false;
while (! done)
{
/* deal with multiple files and repeating */
filename = argv[start_index + offset];
if (! repeat && offset == (num_files - 1))
{
done = true; /* last file and we are not repeating,
so done after it's processed */
}
offset = (offset + 1) % num_files; /* skip to next file if available */
file = gzopen (filename, "rb");
struct timeval start_emit_time;
micro_now (&start_emit_time);
struct timeval current_emit_time = { 0, 0 };
struct timeval previous_emit_time = { 0, 0 };
unsigned long long time_between_emit_events = 0ULL;
unsigned long long start_file_timestamp = 0ULL;
unsigned long long end_file_timestamp = 0ULL;
int file_count = 0;
unsigned long long time_to_sleep = 0ULL;
/* read a header from the file */
while (gzread (file, header, 22) == 22)
{
unsigned short size = header_payload_length (header);
unsigned long long cur_file_timestamp =
(unsigned long long)(header_receipt_time (header));
if (start_file_timestamp == 0ULL)
{
start_file_timestamp = cur_file_timestamp;
}
end_file_timestamp = cur_file_timestamp;
/* read an event from the file */
if (gzread (file, buf, size) != size)
{
fprintf (stderr, "ERROR: failure reading journal\n");
done = true;
ret=1;
break;
}
/* keep track of the current emit time */
micro_now (¤t_emit_time);
/* if we are using timings determine how long to sleep before
* emitting the next event */
if (use_timings)
{
unsigned long long time_between_file_events = 0ULL;
time_between_file_events =
(cur_file_timestamp - start_file_timestamp) * 1000ULL;
time_between_emit_events =
micro_timediff (&start_emit_time, ¤t_emit_time);
time_to_sleep =
time_between_file_events > time_between_emit_events
? time_between_file_events - time_between_emit_events
: 0ULL;
/* sleep some number of microseconds */
if (time_to_sleep > 0)
{
usleep (time_to_sleep);
}
}
/* if we are trying to meet a rate, determine how long to sleep
* before next call
*/
if (rate > 0)
{
if (previous_emit_time.tv_sec != 0)
{
/* the difference in micros alway includes the time slept,
* so to figure out how much time we should sleep we subtract
* the previous slept time from how much time it's actually
* been since the last emit. In other words sleep time plus
* processing time should equal delay_ms
*/
unsigned long long diff =
micro_timediff (&previous_emit_time, ¤t_emit_time)
- time_to_sleep;
time_to_sleep =
delay_micros > diff
? delay_micros - diff
: 0ULL;
if (time_to_sleep > 0)
{
usleep (time_to_sleep);
}
}
}
/* then emit the event */
if (lwes_emitter_emit_bytes (emitter, buf, size) != size)
{
fprintf (stderr, "ERROR: failure emitting\n");
done = true;
ret=1;
break;
}
/* keep track of some counts */
file_count++;
total_count++;
this_second_count++;
previous_emit_time = current_emit_time;
/* if we are emitting a limited number we will be done if we hit
* that number
*/
if (number > 0 && number == total_count)
{
done = true;
ret=2;
break;
}
if (gbl_sig)
{
done = true;
ret=3;
break;
}
}
gzclose (file);
fprintf (stderr,
"emitted %d events from %s representing %lld file time "
"in %llu milliseconds\n",
file_count, filename,
(end_file_timestamp - start_file_timestamp),
micro_timediff (&start_emit_time, ¤t_emit_time) / 1000ULL);
}
/* if we hit the count limit (2) it is not an error */
if (ret == 2)
{
ret = 0;
}
stop = currentTimeMillisLongLong ();
fprintf (stderr, "emitted %d events in %lld milliseconds\n",
total_count, (stop - start));
cleanup:
if (emitter != NULL)
{
lwes_emitter_destroy (emitter);
}
exit (ret);
}
int main (int argc,
char *argv[])
{
const char *mcast_ip = "224.1.1.11";
const char *mcast_iface = NULL;
int mcast_port = 12345;
int number = 1;
int pad = 0;
int seconds = 1;
int pause = 0;
int even = 0;
struct lwes_emitter * emitter;
struct lwes_event *event;
char *pad_string;
/* turn off error messages, I'll handle them */
opterr = 0;
while (1)
{
char c = getopt (argc, argv, "m:p:i:n:s:x:b:eh");
if (c == -1)
{
break;
}
switch (c)
{
case 'b':
pause = atoi(optarg);
break;
case 'm':
mcast_ip = optarg;
break;
case 'p':
mcast_port = atoi(optarg);
break;
case 'n':
number = atoi(optarg);
break;
case 's':
seconds = atoi(optarg);
break;
case 'e':
even = 1;
break;
case 'h':
fprintf (stderr, "%s", help);
return 1;
case 'i':
mcast_iface = optarg;
break;
case 'x':
pad = atoi(optarg);
break;
default:
fprintf (stderr,
"error: unrecognized command line option -%c\n",
optopt);
return 1;
}
}
pad_string = NULL;
if (pad > 0)
{
pad_string = malloc(pad+1);
if (pad_string == NULL)
{
fprintf (stderr,
"Unable to allocate %d bytes for pad string\n",
pad);
exit(1);
}
else
{
memset(pad_string, 'X', pad);
pad_string[pad] = '\0';
}
}
emitter = lwes_emitter_create ( (LWES_SHORT_STRING) mcast_ip,
(LWES_SHORT_STRING) mcast_iface,
(LWES_U_INT_32) mcast_port,
0,
10 );
assert (emitter != NULL);
{
int i,s,n;
LWES_INT_64 start = 0LL;
LWES_INT_64 stop = 0LL;
for (s = 0, n = 0; s < seconds; ++s)
{
start = currentTimeMillisLongLong ();
stop = start;
for (i = 0; i < number; ++i, ++n)
{
event = lwes_event_create (NULL, "MyEvent");
assert (event != NULL);
assert
(lwes_event_set_STRING (event, "field", "hello world") == 1 );
assert
(lwes_event_set_INT_32 (event, "count", i) == 2);
assert
(lwes_event_set_INT_32 (event, "run", s) == 3);
assert
(lwes_event_set_STRING (event, "prog_id","12345") == 4);
assert
(lwes_event_set_INT_16 (event,"num", 2) == 5);
assert
(lwes_event_set_STRING (event,"k0", "a-key.count") == 6);
assert
(lwes_event_set_INT_16 (event,"v0", 1) == 7);
assert
(lwes_event_set_STRING (event,"k1", "b-key.count") == 8);
assert
(lwes_event_set_INT_16 (event,"v1", 2) == 9);
assert
(lwes_event_set_U_INT_64(event, "global_count", n) == 10);
assert
(lwes_event_set_INT_64 (event,"SentTime", stop) == 11);
if (pad>0) {
assert(lwes_event_set_STRING (event,"pad",pad_string) == 12);
}
assert (lwes_emitter_emit (emitter, event) == 0);
lwes_event_destroy(event);
stop = currentTimeMillisLongLong ();
/* if we are going over our total time, bail out */
if ((stop - start) >= 1000)
{
printf ("Was only able to emit %7d in 1 sec\n",i);
break;
}
/* if we are attempting to send events evenly throughout
the second, consider pausing briefly to get back on
schedule */
if (even)
{
const int delay_ms = (i*1000/number) - (stop-start);
if (delay_ms > 0)
{
usleep (delay_ms*1000);
}
}
}
{
const int delay_ms = (1000 - (stop - start))*1000;
if (delay_ms > 0) usleep (delay_ms);
}
{
char timebuff[20];
/* HH/MM/SS DD/MM/YYYY */
/* 12345678901234567890 */
time_t start_time = time (NULL);
strftime (timebuff, 20, "%H:%M:%S %d/%m/%Y", localtime (&start_time));
printf ("%s : %7d\n", timebuff, i);
}
sleep (pause);
}
lwes_emitter_destroy(emitter);
if (pad_string!=NULL) free(pad_string);
}
return 0;
}
