1 /**
2 * collectd-tg - src/collectd-tg.c
3 * Copyright (C) 2010-2012 Florian octo Forster
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 *
23 * Authors:
24 * Florian Forster <octo at collectd.org>
25 **/
27 #if HAVE_CONFIG_H
28 #include "config.h"
29 #endif
31 #if !__GNUC__
32 #define __attribute__(x) /**/
33 #endif
35 #include <errno.h>
36 #include <math.h>
37 #include <signal.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <sys/time.h>
42 #include <time.h>
43 #include <unistd.h>
45 #include "utils_heap.h"
47 #include "collectd/client.h"
48 #include "collectd/network.h"
50 #define DEF_NUM_HOSTS 1000
51 #define DEF_NUM_PLUGINS 20
52 #define DEF_NUM_VALUES 100000
53 #define DEF_INTERVAL 10.0
55 static int conf_num_hosts = DEF_NUM_HOSTS;
56 static int conf_num_plugins = DEF_NUM_PLUGINS;
57 static int conf_num_values = DEF_NUM_VALUES;
58 static double conf_interval = DEF_INTERVAL;
59 static const char *conf_destination = NET_DEFAULT_V6_ADDR;
60 static const char *conf_service = NET_DEFAULT_PORT;
62 static lcc_network_t *net;
64 static c_heap_t *values_heap = NULL;
66 static struct sigaction sigint_action;
67 static struct sigaction sigterm_action;
69 static _Bool loop = 1;
71 __attribute__((noreturn)) static void exit_usage(int exit_status) /* {{{ */
72 {
73 fprintf(
74 (exit_status == EXIT_FAILURE) ? stderr : stdout,
75 "collectd-tg -- collectd traffic generator\n"
76 "\n"
77 " Usage: collectd-ng [OPTION]\n"
78 "\n"
79 " Valid options:\n"
80 " -n <number> Number of value lists. (Default: %i)\n"
81 " -H <number> Number of hosts to emulate. (Default: %i)\n"
82 " -p <number> Number of plugins to emulate. (Default: %i)\n"
83 " -i <seconds> Interval of each value in seconds. (Default: %.3f)\n"
84 " -d <dest> Destination address of the network packets.\n"
85 " (Default: %s)\n"
86 " -D <port> Destination port of the network packets.\n"
87 " (Default: %s)\n"
88 " -h Print usage information (this output).\n"
89 "\n"
90 "Copyright (C) 2010-2012 Florian Forster\n"
91 "Licensed under the MIT license.\n",
92 DEF_NUM_VALUES, DEF_NUM_HOSTS, DEF_NUM_PLUGINS, DEF_INTERVAL,
93 NET_DEFAULT_V6_ADDR, NET_DEFAULT_PORT);
94 exit(exit_status);
95 } /* }}} void exit_usage */
97 static void signal_handler(int signal) /* {{{ */
98 {
99 loop = 0;
100 } /* }}} void signal_handler */
102 #if HAVE_CLOCK_GETTIME
103 static double dtime(void) /* {{{ */
104 {
105 struct timespec ts = {0};
107 if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0)
108 perror("clock_gettime");
110 return (double)ts.tv_sec + (double)ts.tv_nsec / 1e9;
111 } /* }}} double dtime */
112 #else
113 /* Work around for Mac OS X which doesn't have clock_gettime(2). *sigh* */
114 static double dtime(void) /* {{{ */
115 {
116 struct timeval tv = {0};
118 if (gettimeofday(&tv, /* timezone = */ NULL) != 0)
119 perror("gettimeofday");
121 return (double)tv.tv_sec + ((double)tv.tv_usec) / 1e6;
122 } /* }}} double dtime */
123 #endif
125 static int compare_time(const void *v0, const void *v1) /* {{{ */
126 {
127 const lcc_value_list_t *vl0 = v0;
128 const lcc_value_list_t *vl1 = v1;
130 if (vl0->time < vl1->time)
131 return -1;
132 else if (vl0->time > vl1->time)
133 return 1;
134 else
135 return 0;
136 } /* }}} int compare_time */
138 static int get_boundet_random(int min, int max) /* {{{ */
139 {
140 int range;
142 if (min >= max)
143 return -1;
144 if (min == (max - 1))
145 return min;
147 range = max - min;
149 return min + ((int)(((double)range) * ((double)random()) / (((double)RAND_MAX) + 1.0)));
150 } /* }}} int get_boundet_random */
152 static lcc_value_list_t *create_value_list(void) /* {{{ */
153 {
154 lcc_value_list_t *vl;
155 int host_num;
157 vl = calloc(1, sizeof(*vl));
158 if (vl == NULL) {
159 fprintf(stderr, "calloc failed.\n");
160 return NULL;
161 }
163 vl->values = calloc(/* nmemb = */ 1, sizeof(*vl->values));
164 if (vl->values == NULL) {
165 fprintf(stderr, "calloc failed.\n");
166 free(vl);
167 return NULL;
168 }
170 vl->values_types = calloc(/* nmemb = */ 1, sizeof(*vl->values_types));
171 if (vl->values_types == NULL) {
172 fprintf(stderr, "calloc failed.\n");
173 free(vl->values);
174 free(vl);
175 return NULL;
176 }
178 vl->values_len = 1;
180 host_num = get_boundet_random(0, conf_num_hosts);
182 vl->interval = conf_interval;
183 vl->time = 1.0 + dtime() + (host_num % (1 + (int)vl->interval));
185 if (get_boundet_random(0, 2) == 0)
186 vl->values_types[0] = LCC_TYPE_GAUGE;
187 else
188 vl->values_types[0] = LCC_TYPE_DERIVE;
190 snprintf(vl->identifier.host, sizeof(vl->identifier.host), "host%04i",
191 host_num);
192 snprintf(vl->identifier.plugin, sizeof(vl->identifier.plugin), "plugin%03i",
193 get_boundet_random(0, conf_num_plugins));
194 strncpy(vl->identifier.type,
195 (vl->values_types[0] == LCC_TYPE_GAUGE) ? "gauge" : "derive",
196 sizeof(vl->identifier.type));
197 vl->identifier.type[sizeof(vl->identifier.type) - 1] = 0;
198 snprintf(vl->identifier.type_instance, sizeof(vl->identifier.type_instance),
199 "ti%li", random());
201 return vl;
202 } /* }}} int create_value_list */
204 static void destroy_value_list(lcc_value_list_t *vl) /* {{{ */
205 {
206 if (vl == NULL)
207 return;
209 free(vl->values);
210 free(vl->values_types);
211 free(vl);
212 } /* }}} void destroy_value_list */
214 static int send_value(lcc_value_list_t *vl) /* {{{ */
215 {
216 int status;
218 if (vl->values_types[0] == LCC_TYPE_GAUGE)
219 vl->values[0].gauge =
220 100.0 * ((gauge_t)random()) / (((gauge_t)RAND_MAX) + 1.0);
221 else
222 vl->values[0].derive += (derive_t)get_boundet_random(0, 100);
224 status = lcc_network_values_send(net, vl);
225 if (status != 0)
226 fprintf(stderr, "lcc_network_values_send failed with status %i.\n", status);
228 vl->time += vl->interval;
230 return 0;
231 } /* }}} int send_value */
233 static int get_integer_opt(const char *str, int *ret_value) /* {{{ */
234 {
235 char *endptr;
236 int tmp;
238 errno = 0;
239 endptr = NULL;
240 tmp = (int)strtol(str, &endptr, /* base = */ 0);
241 if (errno != 0) {
242 fprintf(stderr, "Unable to parse option as a number: \"%s\": %s\n", str,
243 strerror(errno));
244 exit(EXIT_FAILURE);
245 } else if (endptr == str) {
246 fprintf(stderr, "Unable to parse option as a number: \"%s\"\n", str);
247 exit(EXIT_FAILURE);
248 } else if (*endptr != 0) {
249 fprintf(stderr, "Garbage after end of value: \"%s\"\n", str);
250 exit(EXIT_FAILURE);
251 }
253 *ret_value = tmp;
254 return 0;
255 } /* }}} int get_integer_opt */
257 static int get_double_opt(const char *str, double *ret_value) /* {{{ */
258 {
259 char *endptr;
260 double tmp;
262 errno = 0;
263 endptr = NULL;
264 tmp = strtod(str, &endptr);
265 if (errno != 0) {
266 fprintf(stderr, "Unable to parse option as a number: \"%s\": %s\n", str,
267 strerror(errno));
268 exit(EXIT_FAILURE);
269 } else if (endptr == str) {
270 fprintf(stderr, "Unable to parse option as a number: \"%s\"\n", str);
271 exit(EXIT_FAILURE);
272 } else if (*endptr != 0) {
273 fprintf(stderr, "Garbage after end of value: \"%s\"\n", str);
274 exit(EXIT_FAILURE);
275 }
277 *ret_value = tmp;
278 return 0;
279 } /* }}} int get_double_opt */
281 static int read_options(int argc, char **argv) /* {{{ */
282 {
283 int opt;
285 while ((opt = getopt(argc, argv, "n:H:p:i:d:D:h")) != -1) {
286 switch (opt) {
287 case 'n':
288 get_integer_opt(optarg, &conf_num_values);
289 break;
291 case 'H':
292 get_integer_opt(optarg, &conf_num_hosts);
293 break;
295 case 'p':
296 get_integer_opt(optarg, &conf_num_plugins);
297 break;
299 case 'i':
300 get_double_opt(optarg, &conf_interval);
301 break;
303 case 'd':
304 conf_destination = optarg;
305 break;
307 case 'D':
308 conf_service = optarg;
309 break;
311 case 'h':
312 exit_usage(EXIT_SUCCESS);
314 default:
315 exit_usage(EXIT_FAILURE);
316 } /* switch (opt) */
317 } /* while (getopt) */
319 return 0;
320 } /* }}} int read_options */
322 int main(int argc, char **argv) /* {{{ */
323 {
324 double last_time;
325 int values_sent = 0;
327 read_options(argc, argv);
329 sigint_action.sa_handler = signal_handler;
330 sigaction(SIGINT, &sigint_action, /* old = */ NULL);
332 sigterm_action.sa_handler = signal_handler;
333 sigaction(SIGTERM, &sigterm_action, /* old = */ NULL);
335 values_heap = c_heap_create(compare_time);
336 if (values_heap == NULL) {
337 fprintf(stderr, "c_heap_create failed.\n");
338 exit(EXIT_FAILURE);
339 }
341 net = lcc_network_create();
342 if (net == NULL) {
343 fprintf(stderr, "lcc_network_create failed.\n");
344 exit(EXIT_FAILURE);
345 } else {
346 lcc_server_t *srv;
348 srv = lcc_server_create(net, conf_destination, conf_service);
349 if (srv == NULL) {
350 fprintf(stderr, "lcc_server_create failed.\n");
351 exit(EXIT_FAILURE);
352 }
354 lcc_server_set_ttl(srv, 42);
355 #if 0
356 lcc_server_set_security_level (srv, ENCRYPT,
357 "admin", "password1");
358 #endif
359 }
361 fprintf(stdout, "Creating %i values ... ", conf_num_values);
362 fflush(stdout);
363 for (int i = 0; i < conf_num_values; i++) {
364 lcc_value_list_t *vl;
366 vl = create_value_list();
367 if (vl == NULL) {
368 fprintf(stderr, "create_value_list failed.\n");
369 exit(EXIT_FAILURE);
370 }
372 c_heap_insert(values_heap, vl);
373 }
374 fprintf(stdout, "done\n");
376 last_time = 0;
377 while (loop) {
378 lcc_value_list_t *vl = c_heap_get_root(values_heap);
380 if (vl == NULL)
381 break;
383 if (vl->time != last_time) {
384 printf("%i values have been sent.\n", values_sent);
386 /* Check if we need to sleep */
387 double now = dtime();
389 while (now < vl->time) {
390 double diff = vl->time - now;
391 struct timespec ts = {
392 .tv_sec = (time_t)diff,
393 };
394 ts.tv_nsec = (long)((diff - ((double)ts.tv_sec)) * 1e9);
396 nanosleep(&ts, /* remaining = */ NULL);
397 now = dtime();
399 if (!loop)
400 break;
401 }
402 last_time = vl->time;
403 }
405 send_value(vl);
406 values_sent++;
408 c_heap_insert(values_heap, vl);
409 }
411 fprintf(stdout, "Shutting down.\n");
412 fflush(stdout);
414 while (42) {
415 lcc_value_list_t *vl = c_heap_get_root(values_heap);
416 if (vl == NULL)
417 break;
418 destroy_value_list(vl);
419 }
420 c_heap_destroy(values_heap);
422 lcc_network_destroy(net);
423 exit(EXIT_SUCCESS);
424 } /* }}} int main */