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 = RIEMANN_CLIENT_INIT;
int i;
if (argc != 3) {
fprintf(stderr, "%s <IP> <PORT>\n", argv[0]);
exit(EXIT_FAILURE);
}
riemann_query_set_string(&qry, "true");
riemann_message_set_query(&msg, &qry);
riemann_client_connect(&cli, 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++)
puts(resp->events[i]->service);
riemann_message_free(resp); /* responses should be freed */
riemann_client_free(&cli);
return 0;
}
/**
* Function to send messages to riemann.
*
* Acquires the host lock, disconnects on errors.
*/
static int wrr_send_nolock(struct riemann_host *host,
riemann_message_t *msg) /* {{{ */
{
int status = 0;
status = wrr_connect(host);
if (status != 0) {
return status;
}
status = riemann_client_send_message(host->client, msg);
if (status != 0) {
wrr_disconnect(host);
return status;
}
/*
* For TCP we need to receive message acknowledgemenent.
*/
if (host->client_type != RIEMANN_CLIENT_UDP) {
riemann_message_t *response;
response = riemann_client_recv_message(host->client);
if (response == NULL) {
wrr_disconnect(host);
return errno;
}
riemann_message_free(response);
}
return 0;
} /* }}} int wrr_send */
END_TEST
START_TEST (test_riemann_simple_query)
{
riemann_client_t *client;
riemann_message_t *response;
ck_assert (riemann_query (NULL, "service = \"test-simple\"") == NULL);
ck_assert_errno (-errno, ENOTCONN);
client = riemann_client_create (RIEMANN_CLIENT_TCP, "127.0.0.1", 5555);
riemann_send (client,
RIEMANN_EVENT_FIELD_SERVICE, "test-simple",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE);
response = riemann_query (client, "service = \"test-simple\"");
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
riemann_message_free (response);
riemann_client_free (client);
}
int
riemann_client_send_message_oneshot (riemann_client_t *client,
riemann_message_t *message)
{
int ret = 0;
ret = riemann_client_send_message (client, message);
riemann_message_free (message);
return ret;
}
END_TEST
START_TEST (test_riemann_simple_communicate_event)
{
riemann_client_t *client;
riemann_message_t *response;
client = riemann_client_create (RIEMANN_CLIENT_TCP, "127.0.0.1", 5555);
response = riemann_communicate_event
(client,
RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate_event",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert_int_eq (response->n_events, 0);
riemann_message_free (response);
response = riemann_communicate_event
(client,
256,
RIEMANN_EVENT_FIELD_NONE);
ck_assert (response == NULL);
ck_assert_errno (-errno, EPROTO);
riemann_send
(client,
RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate_event",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE);
response = riemann_communicate_event (client, RIEMANN_EVENT_FIELD_NONE);
ck_assert (response != NULL);
ck_assert (response->has_ok == 1);
ck_assert (response->ok == 1);
riemann_message_free (response);
riemann_client_free (client);
}
static riemann_message_t *
wrr_value_list_to_message(struct riemann_host const *host, /* {{{ */
data_set_t const *ds, value_list_t const *vl,
int *statuses) {
riemann_message_t *msg;
size_t i;
gauge_t *rates = NULL;
/* Initialize the Msg structure. */
msg = riemann_message_new();
if (msg == NULL) {
ERROR("write_riemann plugin: riemann_message_new failed.");
return NULL;
}
if (host->store_rates) {
rates = uc_get_rate(ds, vl);
if (rates == NULL) {
ERROR("write_riemann plugin: uc_get_rate failed.");
riemann_message_free(msg);
return NULL;
}
}
for (i = 0; i < vl->values_len; i++) {
riemann_event_t *event;
event = wrr_value_to_event(host, ds, vl, (int)i, rates, statuses[i]);
if (event == NULL) {
riemann_message_free(msg);
sfree(rates);
return NULL;
}
riemann_message_append_events(msg, event, NULL);
}
sfree(rates);
return msg;
} /* }}} riemann_message_t *wrr_value_list_to_message */
/*
* Always call while holding host->lock !
*/
static int wrr_batch_flush_nolock(cdtime_t timeout, struct riemann_host *host) {
cdtime_t now;
int status = 0;
now = cdtime();
if (timeout > 0) {
if ((host->batch_init + timeout) > now) {
return status;
}
}
wrr_send_nolock(host, host->batch_msg);
riemann_message_free(host->batch_msg);
host->batch_init = now;
host->batch_msg = NULL;
return status;
}
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;
}
END_TEST
START_TEST (test_riemann_simple_communicate_query)
{
riemann_client_t *client;
riemann_message_t *response;
client = riemann_client_create (RIEMANN_CLIENT_TCP, "127.0.0.1", 5555);
response = riemann_communicate_query (client, "true");
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert (response->n_events > 0);
riemann_message_free (response);
riemann_client_disconnect (client);
client = riemann_client_create (RIEMANN_CLIENT_UDP, "127.0.0.1", 5555);
response = riemann_communicate_query (client, "true");
ck_assert (response == NULL);
ck_assert_errno (-errno, ENOTSUP);
riemann_client_disconnect (client);
riemann_client_free (client);
}
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;
}
END_TEST
START_TEST (test_riemann_simple_communicate)
{
riemann_client_t *client, *dummy_client;
riemann_message_t *message, *response;
client = riemann_client_create (RIEMANN_CLIENT_TCP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
ck_assert (riemann_communicate (NULL, NULL) == NULL);
ck_assert_errno (-errno, ENOTCONN);
ck_assert (riemann_communicate (client, NULL) == NULL);
ck_assert_errno (-errno, EINVAL);
ck_assert (riemann_communicate (NULL, message) == NULL);
ck_assert_errno (-errno, ENOTCONN);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
dummy_client = riemann_client_new ();
ck_assert (riemann_communicate (dummy_client, message) == NULL);
ck_assert_errno (-errno, ENOTCONN);
riemann_client_free (dummy_client);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
riemann_message_free (response);
response = riemann_communicate
(client,
riemann_message_create_with_query
(riemann_query_new ("true")));
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert (response->n_events > 0);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_connect (client, RIEMANN_CLIENT_UDP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_connect (client, RIEMANN_CLIENT_TCP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate #2",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
riemann_message_set_query (message,
riemann_query_new ("true"));
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert (response->n_events > 0);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_connect (client, RIEMANN_CLIENT_UDP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate #2",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
riemann_message_set_query (message,
riemann_query_new ("true"));
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert (response->n_events == 0);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_free (client);
}
int main(int argc, char** argv){
int r;
char* end;
sd_journal *j;
riemann_client_t *c;
riemann_message_t *req, *res;
riemann_event_t *event;
int after_wait = 0;
r = sd_journal_open(&j, 0);
assert(r == 0);
if(argc != 3 && argc != 6){
fprintf(stderr,"usage: journal2riemann <host> <port> [<ca-file> <cert-file> <key-file>]\n");
fprintf(stderr,"example: journal2riemann 127.0.0.1 5555\n");
exit(1);
}
long port = strtol(argv[2],&end,10);
if(argc >= 6){
c = riemann_client_create (
RIEMANN_CLIENT_TLS, argv[1], port,
RIEMANN_CLIENT_OPTION_TLS_CA_FILE, argv[3],
RIEMANN_CLIENT_OPTION_TLS_CERT_FILE, argv[4],
RIEMANN_CLIENT_OPTION_TLS_KEY_FILE, argv[5],
RIEMANN_CLIENT_OPTION_TLS_HANDSHAKE_TIMEOUT, 10000,
RIEMANN_CLIENT_OPTION_NONE);
}else{
c = riemann_client_create (RIEMANN_CLIENT_TCP, argv[1], port);
}
r = sd_journal_seek_tail(j);
assert(r == 0);
for (;;) {
const void *field; size_t len;
r = sd_journal_next(j); assert (r >= 0);
if (r == 0) { // if no more log available, wait for new ones
r = sd_journal_wait(j, (uint64_t) -1);
assert (r >= 0);
after_wait = 1;
continue;
}
else if (!after_wait){ // skip all logs before the first wait
continue;
}
event = riemann_event_create(RIEMANN_EVENT_FIELD_NONE);
strncpy(servicename,"journal",8);
SD_JOURNAL_FOREACH_DATA(j, field, len){
char* attr = ""; enum RiemannType type; void* val;
int matched = NOMATCH;
MATCH(F,RIEMANN_EVENT_FIELD_DESCRIPTION , STRING , "MESSAGE=")
MATCH(A,"message_id" , STRING , "MESSAGE_ID=")
MATCH(F,RIEMANN_EVENT_FIELD_STATE , STATE , "PRIORITY=")
MATCH(F,MATCHNOTHING , STRING , "CODE_FILE=")
MATCH(F,MATCHNOTHING , STRING , "CODE_LINE=")
MATCH(F,MATCHNOTHING , STRING , "CODE_FUNC=")
MATCH(F,MATCHNOTHING , STRING , "ERRNO=")
MATCH(F,MATCHNOTHING , STRING , "SYSLOG_FACILITY=")
MATCH(F,MATCHNOTHING , STRING , "SYSLOG_IDENTIFIER=")
MATCH(F,MATCHNOTHING , STRING , "SYSLOG_PID=")
MATCH(F,MATCHNOTHING , STRING , "_PID=")
MATCH(F,MATCHNOTHING , STRING , "_UID=")
MATCH(F,MATCHNOTHING , STRING , "_GID=")
MATCH(F,MATCHNOTHING , STRING , "_COMM=")
MATCH(F,MATCHNOTHING , STRING , "_EXE=")
MATCH(A,"command_line" , STRING , "_CMDLINE=")
MATCH(F,MATCHNOTHING , STRING , "_CAP_EFFECTIVE=")
MATCH(F,MATCHNOTHING , STRING , "_AUDIT_SESSION=")
MATCH(F,MATCHNOTHING , STRING , "_AUDIT_LOGINUID=")
MATCH(F,MATCHNOTHING , STRING , "_SYSTEMD_CGROUP=")
MATCH(F,MATCHNOTHING , STRING , "_SYSTEMD_SESSION=")
MATCH(F,SERVICEPART , STRING , "_SYSTEMD_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "_SYSTEMD_USER_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "_SYSTEMD_OWNER_UID=")
MATCH(F,MATCHNOTHING , STRING , "_SYSTEMD_SLICE=")
MATCH(F,MATCHNOTHING , STRING , "_SELINUX_CONTEXT=")
MATCH(F,RIEMANN_EVENT_FIELD_TIME , TIME , "_SOURCE_REALTIME_TIMESTAMP=")
MATCH(F,MATCHNOTHING , STRING , "_BOOT_ID=")
MATCH(F,MATCHNOTHING , STRING , "_MACHINE_ID=")
MATCH(F,RIEMANN_EVENT_FIELD_HOST , STRING , "_HOSTNAME=")
MATCH(F,MATCHNOTHING , STRING , "_TRANSPORT=")
MATCH(F,MATCHNOTHING , STRING , "_KERNEL_DEVICE=")
MATCH(F,MATCHNOTHING , STRING , "_KERNEL_SUBSYSTEM=")
MATCH(F,MATCHNOTHING , STRING , "_UDEV_SYSNAME=")
MATCH(F,MATCHNOTHING , STRING , "_UDEV_DEVNODE=")
MATCH(F,MATCHNOTHING , STRING , "_UDEV_DEVLINK=")
MATCH(F,MATCHNOTHING , STRING , "COREDUMP_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "COREDUMP_USER_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_UID=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_GID=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_COMM=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_EXE=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_CMDLINE=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_AUDIT_SESSION=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_AUDIT_LOGINUID=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_SYSTEMD_CGROUP=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_SYSTEMD_SESSION=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_SYSTEMD_OWNER_UID=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_SYSTEMD_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_SYSTEMD_USER_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "__CURSOR=")
MATCH(F,MATCHNOTHING , STRING , "__REALTIME_TIMESTAMP=")
MATCH(F,MATCHNOTHING , STRING , "__MONOTONIC_TIMESTAMP=")
if(matched != MATCHNOTHING && matched != NOMATCH){
memcpy(valuebuf,field,len); *(valuebuf+len) = 0;
switch(type){
case STATE:
val = (void*) states[atoi(valuebuf)];
break;
case TIME:
*(valuebuf+len-6) = 0;
long t = strtol(valuebuf,&end,10);
val = (int64_t) t;
break;
default:
val = (void*) valuebuf;
}
switch(matched){
case ATTRIBUTE:
riemann_event_string_attribute_add(event,attr,valuebuf); break;
case TAG:
riemann_event_tag_add(event,valuebuf); break;
case SERVICEPART:
if(len > 0){
strncat(servicename," ",2);
strncat(servicename,valuebuf,len+1);
}
break;
default:
riemann_event_set(event,matched,val,RIEMANN_EVENT_FIELD_NONE);
}
}
}
riemann_event_set(event,RIEMANN_EVENT_FIELD_SERVICE,servicename,RIEMANN_EVENT_FIELD_NONE);
req = riemann_message_create_with_events(event, NULL);
res = riemann_communicate(c, req);
if (!res)
{
fprintf (stderr, "Error communicating with Riemann: %s\n",
strerror (errno));
exit (1);
}
if (res->error)
{
fprintf (stderr, "Error communicating with Riemann: %s\n",
res->error);
exit (1);
}
if (res->has_ok && !res->ok)
{
fprintf (stderr, "Error communicating with Riemann: %s\n",
strerror (errno));
exit (1);
}
riemann_message_free(res);
}
