int main(int argc, char **argv) { riemann_message_t msg = RIEMANN_MSG_INIT; riemann_message_t *resp; riemann_query_t qry = RIEMANN_QUERY_INIT; riemann_client_t cli; int i; int error; if (argc != 4) { fprintf(stderr, "%s <IP> <PORT> <FMT>\n", argv[0]); exit(EXIT_FAILURE); } riemann_query_set_string(&qry, "true"); riemann_message_set_query(&msg, &qry); riemann_client_init(&cli); riemann_client_connect(&cli, RIEMANN_TCP, argv[1], atoi(argv[2])); riemann_client_send_message(&cli, &msg, 0, NULL); resp = riemann_client_recv_message(&cli, 0, NULL); if (!resp->ok) { fprintf(stderr, "Message error %s\n", resp->error); exit(EXIT_FAILURE); } else { puts("Sucess"); } for (i = 0; i < resp->n_events; i++) { error = riemann_event_strfevent(buffer, BUFSIZ, argv[3], resp->events[i]); if (error) { fprintf(stderr, "riemann_event_strfevent() error\n"); exit(EXIT_FAILURE); } puts(buffer); } riemann_message_free(resp); /* responses should be freed */ riemann_client_free(&cli); return 0; }
int main(int argc, char ** argv) { int ret; struct MHD_Daemon *daemon; int opt; riemann_client_t riemann_client; struct sockaddr_in localhost_addr; init_from_env(); while ((opt = getopt(argc, argv, "l:r:p:s:h:m:")) != -1) { switch (opt) { case 'l': listen_port = atoi(optarg); break; case 'r': riemann_host = strdup(optarg); break; case 'p': riemann_port = atoi(optarg); break; case 's': riemann_field_service = strdup(optarg); break; case 'h': riemann_field_host = strdup(optarg); break; case 'm': maintainance_page = strdup(optarg); break; default: print_help(); exit(EXIT_FAILURE); } } if (!listen_port || !riemann_host || !riemann_field_host) { if (!listen_port) { fprintf(stderr, "port to listen on is not specified (LISTEN_PORT or -l)\n"); } if (!riemann_host) { fprintf(stderr, "riemann host is not specified (RIEMANN_HOST or -r)\n"); } if (!riemann_field_host) { fprintf(stderr, "host field for riemann payload is not specified (RIEMANN_FIELD_HOST or -h)\n"); } print_help(); exit(EXIT_FAILURE); } if (maintainance_page) { int ret; int fd; struct stat stat; fd = open(maintainance_page, O_RDONLY); if (fd == -1) { fprintf(stderr, "Cannot open maintainance page '%s': strerror(%s)\n", maintainance_page, strerror(errno)); exit(EXIT_FAILURE); } ret = fstat(fd, &stat); if (ret != 0) { fprintf(stderr, "Cannot get size of maintainance page '%s': strerror(%s)\n", maintainance_page, strerror(errno)); close(fd); exit(EXIT_FAILURE); } body_len = stat.st_size; body = calloc(body_len, sizeof(char)); if (body == NULL) { fprintf(stderr, "Cannot allocate enough memory for content of maintainance page '%s'\n", maintainance_page); close(fd); exit(EXIT_FAILURE); } ret = read(fd, body, body_len); if (ret != body_len) { fprintf(stderr, "Error while reading maintainance page content '%s': strerror(%s)\n", maintainance_page, strerror(errno)); close(fd); exit(EXIT_FAILURE); } } ret = riemann_client_init(&riemann_client); if (ret) { fprintf(stderr, "Cannot initialize riemann_client: strerror(%s)\n", strerror(errno)); exit(EXIT_FAILURE); } ret = riemann_client_connect(&riemann_client, RIEMANN_TCP, riemann_host, riemann_port); if (ret) { fprintf(stderr, "Cannot connect: strerror(%s) gai_strerrror(%s)\n", strerror(errno), gai_strerror(ret)); exit(EXIT_FAILURE); } memset(&localhost_addr, 0, sizeof(struct sockaddr_in)); localhost_addr.sin_family = AF_INET; localhost_addr.sin_port = htons(listen_port); ret = inet_pton(AF_INET, "127.0.0.1", &localhost_addr.sin_addr); if (ret != 1) { fprintf(stderr, "Cannot construct address structure: strerror(%s)\n", strerror(errno)); exit(EXIT_FAILURE); } daemon = MHD_start_daemon(MHD_USE_THREAD_PER_CONNECTION | MHD_USE_POLL, listen_port, NULL, NULL, &write_to_riemann, &riemann_client, MHD_OPTION_SOCK_ADDR, &localhost_addr, MHD_OPTION_END); if (daemon == NULL) { fprintf(stderr, "Cannot start HTTP daemon\n"); exit(EXIT_FAILURE); } wait(); MHD_stop_daemon(daemon); riemann_client_free(&riemann_client); return 0; }
int main(int argc, char **argv) { riemann_message_t msg = RIEMANN_MSG_INIT; riemann_message_t *resp = NULL; size_t n_events = STATIC_ARRAY_SIZE(cpus); riemann_event_t *events[n_events]; /* using stack space */ size_t n_attrs = STATIC_ARRAY_SIZE(attrs); int i; int error; riemann_client_t cli; if (argc != 3) { fprintf(stderr, "%s <IP> <PORT>\n", argv[0]); exit(EXIT_FAILURE); } for (i = 0; i < n_events; i++) { events[i] = alloca(sizeof (riemann_event_t)); riemann_event_init(events[i]); riemann_event_set_host(events[i], "gentoo-x86"); riemann_event_set_service(events[i], cpus[i]); riemann_event_set_metric_f(events[i], 100); /* 100% idle */ riemann_event_set_state(events[i], "ok"); riemann_event_set_tags(events[i], tags, STATIC_ARRAY_SIZE(tags)); riemann_event_set_attributes(events[i], attrs, STATIC_ARRAY_SIZE(attrs)); } riemann_message_set_events(&msg, events, n_events); error = riemann_client_init(&cli); if (error) { fprintf(stderr, "Can't initialize client: strerror(%s)\n", strerror(errno)); exit(EXIT_FAILURE); } error = riemann_client_connect(&cli, TCP, argv[1], atoi(argv[2])); /* functions that returns ints returns 0 on success */ if (error) { fprintf(stderr, "Can't connectd: strerror(%s) gai_strerrror(%s)\n", strerror(errno), gai_strerror(error)); exit(EXIT_FAILURE); } error = riemann_client_send_message(&cli, &msg, 0, NULL); if (error) { fprintf(stderr, "Can't send message: %s\n", strerror(errno)); exit(EXIT_FAILURE); } resp = riemann_client_recv_message(&cli, 0, NULL); /* functions that returns pointers rertuns NULL on failure */ assert(resp); if (!resp->ok) { fprintf(stderr, "Message error %s\n", resp->error); exit(EXIT_FAILURE); } else { puts("Sucess"); } for (i = 0; i < n_events; i++) /* freeing events fields */ riemann_event_free(events[i]); /* Since events are on * stack the may not be * freed. */ riemann_message_free(resp); /* responses should be freed */ riemann_client_free(&cli); return 0; }