2 * collectd-tg - src/collectd-tg.c
3 * Copyright (C) 2010-2012 Florian octo Forster
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:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
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.
24 * Florian Forster <octo at collectd.org>
32 #define __attribute__(x) /**/
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) /* {{{ */
74 (exit_status == EXIT_FAILURE) ? stderr : stdout,
75 "collectd-tg -- collectd traffic generator\n"
77 " Usage: collectd-ng [OPTION]\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"
86 " -D <port> Destination port of the network packets.\n"
88 " -h Print usage information (this output).\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);
95 } /* }}} void exit_usage */
97 static void signal_handler(int signal) /* {{{ */
100 } /* }}} void signal_handler */
102 #if HAVE_CLOCK_GETTIME
103 static double dtime(void) /* {{{ */
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 */
113 /* Work around for Mac OS X which doesn't have clock_gettime(2). *sigh* */
114 static double dtime(void) /* {{{ */
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 */
125 static int compare_time(const void *v0, const void *v1) /* {{{ */
127 const lcc_value_list_t *vl0 = v0;
128 const lcc_value_list_t *vl1 = v1;
130 if (vl0->time < vl1->time)
132 else if (vl0->time > vl1->time)
136 } /* }}} int compare_time */
138 static int get_boundet_random(int min, int max) /* {{{ */
144 if (min == (max - 1))
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) /* {{{ */
154 lcc_value_list_t *vl;
157 vl = calloc(1, sizeof(*vl));
159 fprintf(stderr, "calloc failed.\n");
163 vl->values = calloc(/* nmemb = */ 1, sizeof(*vl->values));
164 if (vl->values == NULL) {
165 fprintf(stderr, "calloc failed.\n");
170 vl->values_types = calloc(/* nmemb = */ 1, sizeof(*vl->values_types));
171 if (vl->values_types == NULL) {
172 fprintf(stderr, "calloc failed.\n");
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;
188 vl->values_types[0] = LCC_TYPE_DERIVE;
190 snprintf(vl->identifier.host, sizeof(vl->identifier.host), "host%04i",
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),
202 } /* }}} int create_value_list */
204 static void destroy_value_list(lcc_value_list_t *vl) /* {{{ */
210 free(vl->values_types);
212 } /* }}} void destroy_value_list */
214 static int send_value(lcc_value_list_t *vl) /* {{{ */
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);
222 vl->values[0].derive += (derive_t)get_boundet_random(0, 100);
224 status = lcc_network_values_send(net, vl);
226 fprintf(stderr, "lcc_network_values_send failed with status %i.\n", status);
228 vl->time += vl->interval;
231 } /* }}} int send_value */
233 static int get_integer_opt(const char *str, int *ret_value) /* {{{ */
240 tmp = (int)strtol(str, &endptr, /* base = */ 0);
242 fprintf(stderr, "Unable to parse option as a number: \"%s\": %s\n", str,
245 } else if (endptr == str) {
246 fprintf(stderr, "Unable to parse option as a number: \"%s\"\n", str);
248 } else if (*endptr != 0) {
249 fprintf(stderr, "Garbage after end of value: \"%s\"\n", str);
255 } /* }}} int get_integer_opt */
257 static int get_double_opt(const char *str, double *ret_value) /* {{{ */
264 tmp = strtod(str, &endptr);
266 fprintf(stderr, "Unable to parse option as a number: \"%s\": %s\n", str,
269 } else if (endptr == str) {
270 fprintf(stderr, "Unable to parse option as a number: \"%s\"\n", str);
272 } else if (*endptr != 0) {
273 fprintf(stderr, "Garbage after end of value: \"%s\"\n", str);
279 } /* }}} int get_double_opt */
281 static int read_options(int argc, char **argv) /* {{{ */
285 while ((opt = getopt(argc, argv, "n:H:p:i:d:D:h")) != -1) {
288 get_integer_opt(optarg, &conf_num_values);
292 get_integer_opt(optarg, &conf_num_hosts);
296 get_integer_opt(optarg, &conf_num_plugins);
300 get_double_opt(optarg, &conf_interval);
304 conf_destination = optarg;
308 conf_service = optarg;
312 exit_usage(EXIT_SUCCESS);
315 exit_usage(EXIT_FAILURE);
317 } /* while (getopt) */
320 } /* }}} int read_options */
322 int main(int argc, char **argv) /* {{{ */
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");
341 net = lcc_network_create();
343 fprintf(stderr, "lcc_network_create failed.\n");
348 srv = lcc_server_create(net, conf_destination, conf_service);
350 fprintf(stderr, "lcc_server_create failed.\n");
354 lcc_server_set_ttl(srv, 42);
356 lcc_server_set_security_level (srv, ENCRYPT,
357 "admin", "password1");
361 fprintf(stdout, "Creating %i values ... ", conf_num_values);
363 for (int i = 0; i < conf_num_values; i++) {
364 lcc_value_list_t *vl;
366 vl = create_value_list();
368 fprintf(stderr, "create_value_list failed.\n");
372 c_heap_insert(values_heap, vl);
374 fprintf(stdout, "done\n");
378 lcc_value_list_t *vl = c_heap_get_root(values_heap);
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,
394 ts.tv_nsec = (long)((diff - ((double)ts.tv_sec)) * 1e9);
396 nanosleep(&ts, /* remaining = */ NULL);
402 last_time = vl->time;
408 c_heap_insert(values_heap, vl);
411 fprintf(stdout, "Shutting down.\n");
415 lcc_value_list_t *vl = c_heap_get_root(values_heap);
418 destroy_value_list(vl);
420 c_heap_destroy(values_heap);
422 lcc_network_destroy(net);