X-Git-Url: https://git.tokkee.org/?p=sysdb.git;a=blobdiff_plain;f=src%2Ffrontend%2Fquery.c;h=2a1954abc9a87ebc966dff97e1af47244f76645a;hp=79886105bd3d68ed0dd099114af5d7d8913983cf;hb=HEAD;hpb=6f4b7e7407964b05477416d1c1c4291421a5859a diff --git a/src/frontend/query.c b/src/frontend/query.c index 7988610..2a1954a 100644 --- a/src/frontend/query.c +++ b/src/frontend/query.c @@ -43,6 +43,52 @@ #include #include +/* + * metric fetcher: + * Implements the callbacks necessary to read a metric object. + */ + +typedef struct { + char *type; + char *id; + sdb_time_t last_update; +} metric_store_t; + +static int +metric_fetcher_host(sdb_store_host_t __attribute__((unused)) *host, + sdb_object_t __attribute__((unused)) *user_data) +{ + return 0; +} /* metric_fetcher_host */ + +static int +metric_fetcher_metric(sdb_store_metric_t *metric, sdb_object_t *user_data) +{ + metric_store_t *st = SDB_OBJ_WRAPPER(user_data)->data; + sdb_time_t last_update = 0; + size_t idx = 0, i; + + if (! metric->stores_num) + return -1; + + /* Find the most up to date data store. + * TODO: Consider merging multiple results? */ + for (i = 0; i < metric->stores_num; ++i) { + if (metric->stores[i].last_update > last_update) { + last_update = metric->stores[i].last_update; + idx = i; + } + } + st->type = strdup(metric->stores[idx].type); + st->id = strdup(metric->stores[idx].id); + st->last_update = metric->stores[idx].last_update; + return 0; +} /* metric_fetcher_metric */ + +static sdb_store_writer_t metric_fetcher = { + metric_fetcher_host, NULL, metric_fetcher_metric, NULL, +}; + /* * private helper functions */ @@ -59,6 +105,46 @@ sstrlen(const char *s) return s ? strlen(s) : 0; } /* sstrlen */ +static int +exec_query(sdb_ast_node_t *ast, sdb_strbuf_t *buf, sdb_strbuf_t *errbuf) +{ + sdb_store_json_formatter_t *f; + int type = 0, flags = 0; + uint32_t res_type = 0; + int status; + + switch (ast->type) { + case SDB_AST_TYPE_FETCH: + type = SDB_AST_FETCH(ast)->obj_type; + res_type = htonl(SDB_CONNECTION_FETCH); + break; + case SDB_AST_TYPE_LIST: + type = SDB_AST_LIST(ast)->obj_type; + flags = SDB_WANT_ARRAY; + res_type = htonl(SDB_CONNECTION_LIST); + break; + case SDB_AST_TYPE_LOOKUP: + type = SDB_AST_LOOKUP(ast)->obj_type; + flags = SDB_WANT_ARRAY; + res_type = htonl(SDB_CONNECTION_LOOKUP); + break; + default: + sdb_strbuf_sprintf(errbuf, "invalid command %s (%#x)", + SDB_AST_TYPE_TO_STRING(ast), ast->type); + return -1; + } + + f = sdb_store_json_formatter(buf, type, flags); + sdb_strbuf_memcpy(buf, &res_type, sizeof(res_type)); + status = sdb_plugin_query(ast, &sdb_store_json_writer, SDB_OBJ(f), + &(sdb_query_opts_t){ true }, errbuf); + if (status < 0) + sdb_strbuf_clear(buf); + sdb_store_json_finish(f); + sdb_object_deref(SDB_OBJ(f)); + return status; +} /* exec_query */ + static int exec_store(sdb_ast_store_t *st, sdb_strbuf_t *buf, sdb_strbuf_t *errbuf) { @@ -81,6 +167,7 @@ exec_store(sdb_ast_store_t *st, sdb_strbuf_t *buf, sdb_strbuf_t *errbuf) snprintf(name, sizeof(name), "%s.%s", st->hostname, st->name); metric_store.type = st->store_type; metric_store.id = st->store_id; + metric_store.last_update = st->store_last_update; status = sdb_plugin_store_metric(st->hostname, st->name, &metric_store, st->last_update); break; @@ -145,7 +232,62 @@ exec_store(sdb_ast_store_t *st, sdb_strbuf_t *buf, sdb_strbuf_t *errbuf) } /* exec_store */ static int -exec_query(sdb_conn_t *conn, sdb_ast_node_t *ast) +exec_timeseries(sdb_ast_timeseries_t *ts, sdb_strbuf_t *buf, sdb_strbuf_t *errbuf) +{ + metric_store_t st = { NULL, NULL, 0 }; + sdb_object_wrapper_t obj = SDB_OBJECT_WRAPPER_STATIC(&st); + sdb_ast_fetch_t fetch = SDB_AST_FETCH_INIT; + sdb_timeseries_opts_t opts = { 0, 0, NULL, 0 }; + sdb_timeseries_t *series = NULL; + int status; + + if ((! ts) || (! ts->hostname) || (! ts->metric)) + return -1; + + fetch.obj_type = SDB_METRIC; + fetch.hostname = strdup(ts->hostname); + fetch.name = strdup(ts->metric); + opts.data_names = (const char * const *)ts->data_names; + opts.data_names_len = ts->data_names_len; + opts.start = ts->start; + opts.end = ts->end; + + status = sdb_plugin_query(SDB_AST_NODE(&fetch), + &metric_fetcher, SDB_OBJ(&obj), + &(sdb_query_opts_t){ true }, errbuf); + if ((status < 0) || (! st.type) || (! st.id)) { + sdb_log(SDB_LOG_ERR, "frontend: Failed to fetch time-series '%s/%s' " + "- no data-store configured for the stored metric", + ts->hostname, ts->metric); + status = -1; + } + if (status >= 0) { + series = sdb_plugin_fetch_timeseries(st.type, st.id, &opts); + if (series) { + uint32_t res_type = htonl(SDB_CONNECTION_TIMESERIES); + sdb_strbuf_memcpy(buf, &res_type, sizeof(res_type)); + sdb_timeseries_tojson(series, buf); + sdb_timeseries_destroy(series); + } + else { + sdb_log(SDB_LOG_ERR, "frontend: Failed to fetch time-series '%s/%s' " + "- %s fetcher callback returned no data for '%s'", + ts->hostname, ts->metric, st.type, st.id); + status = -1; + } + } + + free(fetch.hostname); + free(fetch.name); + if (st.type) + free(st.type); + if (st.id) + free(st.id); + return status; +} /* exec_timeseries */ + +static int +exec_cmd(sdb_conn_t *conn, sdb_ast_node_t *ast) { sdb_strbuf_t *buf; int status; @@ -160,10 +302,14 @@ exec_query(sdb_conn_t *conn, sdb_ast_node_t *ast) sdb_strbuf_sprintf(conn->errbuf, "Out of memory"); return -1; } + if (ast->type == SDB_AST_TYPE_STORE) status = exec_store(SDB_AST_STORE(ast), buf, conn->errbuf); + else if (ast->type == SDB_AST_TYPE_TIMESERIES) + status = exec_timeseries(SDB_AST_TIMESERIES(ast), buf, conn->errbuf); else - status = sdb_plugin_query(ast, buf, conn->errbuf); + status = exec_query(ast, buf, conn->errbuf); + if (status < 0) { char query[conn->cmd_len + 1]; strncpy(query, sdb_strbuf_string(conn->buf), conn->cmd_len); @@ -176,7 +322,7 @@ exec_query(sdb_conn_t *conn, sdb_ast_node_t *ast) sdb_strbuf_destroy(buf); return status < 0 ? status : 0; -} /* exec_query */ +} /* exec_cmd */ /* * public API @@ -227,7 +373,7 @@ sdb_conn_query(sdb_conn_t *conn) } if (ast) { - status = exec_query(conn, ast); + status = exec_cmd(conn, ast); sdb_object_deref(SDB_OBJ(ast)); } sdb_llist_destroy(parsetree); @@ -264,9 +410,10 @@ sdb_conn_fetch(sdb_conn_t *conn) ast = sdb_ast_fetch_create((int)type, hostname[0] ? strdup(hostname) : NULL, + -1, NULL, name[0] ? strdup(name) : NULL, - /* filter = */ NULL); - status = exec_query(conn, ast); + /* full */ 1, /* filter = */ NULL); + status = exec_cmd(conn, ast); sdb_object_deref(SDB_OBJ(ast)); return status; } /* sdb_conn_fetch */ @@ -292,7 +439,7 @@ sdb_conn_list(sdb_conn_t *conn) } ast = sdb_ast_list_create((int)type, /* filter = */ NULL); - status = exec_query(conn, ast); + status = exec_cmd(conn, ast); sdb_object_deref(SDB_OBJ(ast)); return status; } /* sdb_conn_list */ @@ -321,30 +468,22 @@ sdb_conn_lookup(sdb_conn_t *conn) matcher = sdb_strbuf_string(conn->buf) + sizeof(uint32_t); matcher_len = conn->cmd_len - sizeof(uint32_t); - m = sdb_parser_parse_conditional(matcher, (int)matcher_len, conn->errbuf); + m = sdb_parser_parse_conditional((int)type, + matcher, (int)matcher_len, conn->errbuf); if (! m) { - char expr[matcher_len + 1]; - strncpy(expr, matcher, sizeof(expr)); - expr[sizeof(expr) - 1] = '\0'; - sdb_log(SDB_LOG_ERR, "frontend: Failed to parse lookup condition '%s': %s", - expr, sdb_strbuf_string(conn->errbuf)); - return -1; - } - - ast = sdb_ast_lookup_create((int)type, m, /* filter = */ NULL); - /* run analyzer using the full context */ - if (ast && sdb_parser_analyze(ast, conn->errbuf)) { char expr[matcher_len + 1]; char err[sdb_strbuf_len(conn->errbuf) + sizeof(expr) + 64]; strncpy(expr, matcher, sizeof(expr)); expr[sizeof(expr) - 1] = '\0'; snprintf(err, sizeof(err), "Failed to parse lookup condition '%s': %s", expr, sdb_strbuf_string(conn->errbuf)); + sdb_log(SDB_LOG_ERR, "frontend: %s", err); sdb_strbuf_sprintf(conn->errbuf, "%s", err); - status = -1; + return -1; } - else - status = exec_query(conn, ast); + + ast = sdb_ast_lookup_create((int)type, m, /* filter = */ NULL); + status = exec_cmd(conn, ast); if (! ast) sdb_object_deref(SDB_OBJ(m)); sdb_object_deref(SDB_OBJ(ast)); @@ -354,7 +493,7 @@ sdb_conn_lookup(sdb_conn_t *conn) int sdb_conn_store(sdb_conn_t *conn) { - sdb_ast_node_t *ast; + sdb_ast_node_t *ast = NULL; const char *buf = sdb_strbuf_string(conn->buf); size_t len = conn->cmd_len; uint32_t type; @@ -383,7 +522,7 @@ sdb_conn_store(sdb_conn_t *conn) } ast = sdb_ast_store_create(SDB_HOST, /* host */ NULL, /* parent */ 0, NULL, sstrdup(host.name), host.last_update, - /* metric store */ NULL, NULL, SDB_DATA_NULL); + /* metric store */ NULL, NULL, 0, SDB_DATA_NULL); } break; @@ -397,7 +536,7 @@ sdb_conn_store(sdb_conn_t *conn) } ast = sdb_ast_store_create(SDB_SERVICE, sstrdup(svc.hostname), /* parent */ 0, NULL, sstrdup(svc.name), svc.last_update, - /* metric store */ NULL, NULL, SDB_DATA_NULL); + /* metric store */ NULL, NULL, 0, SDB_DATA_NULL); } break; @@ -412,7 +551,7 @@ sdb_conn_store(sdb_conn_t *conn) ast = sdb_ast_store_create(SDB_METRIC, sstrdup(metric.hostname), /* parent */ 0, NULL, sstrdup(metric.name), metric.last_update, sstrdup(metric.store_type), sstrdup(metric.store_id), - SDB_DATA_NULL); + metric.store_last_update, SDB_DATA_NULL); } break; } @@ -438,7 +577,7 @@ sdb_conn_store(sdb_conn_t *conn) } ast = sdb_ast_store_create(SDB_ATTRIBUTE, sstrdup(hostname), parent_type, sstrdup(parent), sstrdup(attr.key), - attr.last_update, /* metric store */ NULL, NULL, + attr.last_update, /* metric store */ NULL, NULL, 0, attr.value); } @@ -451,7 +590,7 @@ sdb_conn_store(sdb_conn_t *conn) status = sdb_parser_analyze(ast, conn->errbuf); if (! status) - status = exec_query(conn, ast); + status = exec_cmd(conn, ast); sdb_object_deref(SDB_OBJ(ast)); return status; } /* sdb_conn_store */