X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Ffrontend%2Fquery.c;h=585222d25a56fbe971b57c6655df9a7f5e5b9565;hb=d48884911904c87e0143b70a1a102d4cf25d638b;hp=9e3b66a3a5c2b55579dccb5fdc4741631930e95d;hpb=c2b7616c8a80c5de6356b675d55a4ee36415fd7b;p=sysdb.git diff --git a/src/frontend/query.c b/src/frontend/query.c index 9e3b66a..585222d 100644 --- a/src/frontend/query.c +++ b/src/frontend/query.c @@ -27,19 +27,209 @@ #include "sysdb.h" -#include "core/error.h" #include "core/store.h" #include "frontend/connection-private.h" +#include "frontend/parser.h" +#include "utils/error.h" #include "utils/strbuf.h" #include +#include + +/* + * private helper functions + */ + +typedef struct { + sdb_strbuf_t *buf; + sdb_store_matcher_t *filter; + + size_t last_len; +} tojson_data_t; + +static int +lookup_tojson(sdb_store_obj_t *obj, void *user_data) +{ + tojson_data_t *data = user_data; + int status; + + if (data->filter && (! sdb_store_matcher_matches(data->filter, obj, NULL))) + return 0; + + if (sdb_strbuf_len(data->buf) > data->last_len) + sdb_strbuf_append(data->buf, ","); + data->last_len = sdb_strbuf_len(data->buf); + status = sdb_store_host_tojson(obj, data->buf, + data->filter, /* flags = */ 0); + return status; +} /* lookup_tojson */ /* * public API */ +int +sdb_fe_query(sdb_conn_t *conn) +{ + sdb_llist_t *parsetree; + sdb_conn_node_t *node = NULL; + int status = 0; + + parsetree = sdb_fe_parse(sdb_strbuf_string(conn->buf), + (int)conn->cmd_len); + if (! parsetree) { + char query[conn->cmd_len + 1]; + strncpy(query, sdb_strbuf_string(conn->buf), conn->cmd_len); + query[sizeof(query) - 1] = '\0'; + sdb_log(SDB_LOG_ERR, "frontend: Failed to parse query '%s'", + query); + return -1; + } + + switch (sdb_llist_len(parsetree)) { + case 0: + /* skipping empty command */ + break; + case 1: + node = SDB_CONN_NODE(sdb_llist_get(parsetree, 0)); + break; + + default: + { + char query[conn->cmd_len + 1]; + strncpy(query, sdb_strbuf_string(conn->buf), conn->cmd_len); + query[sizeof(query) - 1] = '\0'; + sdb_log(SDB_LOG_WARNING, "frontend: Ignoring %d command%s " + "in multi-statement query '%s'", + sdb_llist_len(parsetree) - 1, + sdb_llist_len(parsetree) == 2 ? "" : "s", + query); + node = SDB_CONN_NODE(sdb_llist_get(parsetree, 0)); + } + } + + if (node) { + status = sdb_fe_exec(conn, node); + sdb_object_deref(SDB_OBJ(node)); + } + + sdb_llist_destroy(parsetree); + return status; +} /* sdb_fe_query */ + +int +sdb_fe_fetch(sdb_conn_t *conn) +{ + char hostname[conn->cmd_len + 1]; + strncpy(hostname, sdb_strbuf_string(conn->buf), conn->cmd_len); + hostname[sizeof(hostname) - 1] = '\0'; + return sdb_fe_exec_fetch(conn, hostname, /* filter = */ NULL); +} /* sdb_fe_fetch */ + int sdb_fe_list(sdb_conn_t *conn) +{ + return sdb_fe_exec_list(conn, /* filter = */ NULL); +} /* sdb_fe_list */ + +int +sdb_fe_lookup(sdb_conn_t *conn) +{ + sdb_store_matcher_t *m; + int status; + + m = sdb_fe_parse_matcher(sdb_strbuf_string(conn->buf), + (int)conn->cmd_len); + if (! m) { + char expr[conn->cmd_len + 1]; + strncpy(expr, sdb_strbuf_string(conn->buf), conn->cmd_len); + expr[sizeof(expr) - 1] = '\0'; + sdb_log(SDB_LOG_ERR, "frontend: Failed to parse " + "lookup condition '%s'", expr); + return -1; + } + + status = sdb_fe_exec_lookup(conn, m, /* filter = */ NULL); + sdb_object_deref(SDB_OBJ(m)); + return status; +} /* sdb_fe_lookup */ + +int +sdb_fe_exec(sdb_conn_t *conn, sdb_conn_node_t *node) +{ + if (! node) + return -1; + + switch (node->cmd) { + case CONNECTION_FETCH: + return sdb_fe_exec_fetch(conn, CONN_FETCH(node)->name, + /* filter = */ NULL); + case CONNECTION_LIST: + return sdb_fe_exec_list(conn, /* filter = */ NULL); + case CONNECTION_LOOKUP: + { + sdb_store_matcher_t *m = NULL, *filter = NULL; + if (CONN_LOOKUP(node)->matcher) + m = CONN_LOOKUP(node)->matcher->matcher; + if (CONN_LOOKUP(node)->filter) + filter = CONN_LOOKUP(node)->filter->matcher; + return sdb_fe_exec_lookup(conn, m, filter); + } + + default: + sdb_log(SDB_LOG_ERR, "frontend: Unknown command %i", node->cmd); + return -1; + } + return -1; +} /* sdb_fe_exec */ + +int +sdb_fe_exec_fetch(sdb_conn_t *conn, const char *name, + sdb_store_matcher_t *filter) +{ + sdb_strbuf_t *buf; + sdb_store_obj_t *host; + + host = sdb_store_get_host(name); + if (! host) { + sdb_log(SDB_LOG_DEBUG, "frontend: Failed to fetch host '%s': " + "not found", name); + + sdb_strbuf_sprintf(conn->errbuf, "Host %s not found", name); + return -1; + } + + buf = sdb_strbuf_create(1024); + if (! buf) { + char errbuf[1024]; + sdb_log(SDB_LOG_ERR, "frontend: Failed to create " + "buffer to handle FETCH command: %s", + sdb_strerror(errno, errbuf, sizeof(errbuf))); + + sdb_strbuf_sprintf(conn->errbuf, "Out of memory"); + sdb_strbuf_destroy(buf); + sdb_object_deref(SDB_OBJ(host)); + return -1; + } + + if (sdb_store_host_tojson(host, buf, filter, /* flags = */ 0)) { + sdb_log(SDB_LOG_ERR, "frontend: Failed to serialize " + "host '%s' to JSON", name); + sdb_strbuf_sprintf(conn->errbuf, "Out of memory"); + sdb_strbuf_destroy(buf); + sdb_object_deref(SDB_OBJ(host)); + return -1; + } + + sdb_connection_send(conn, CONNECTION_OK, + (uint32_t)sdb_strbuf_len(buf), sdb_strbuf_string(buf)); + sdb_strbuf_destroy(buf); + sdb_object_deref(SDB_OBJ(host)); + return 0; +} /* sdb_fe_exec_fetch */ + +int +sdb_fe_exec_list(sdb_conn_t *conn, sdb_store_matcher_t *filter) { sdb_strbuf_t *buf; @@ -50,16 +240,15 @@ sdb_fe_list(sdb_conn_t *conn) "buffer to handle LIST command: %s", sdb_strerror(errno, errbuf, sizeof(errbuf))); - /* XXX: send error message */ - sdb_connection_send(conn, CONNECTION_ERROR, 0, NULL); + sdb_strbuf_sprintf(conn->errbuf, "Out of memory"); sdb_strbuf_destroy(buf); return -1; } - if (sdb_store_tojson(buf)) { + if (sdb_store_tojson(buf, filter, /* flags = */ SDB_SKIP_ALL)) { sdb_log(SDB_LOG_ERR, "frontend: Failed to serialize " "store to JSON"); - sdb_connection_send(conn, CONNECTION_ERROR, 0, NULL); + sdb_strbuf_sprintf(conn->errbuf, "Out of memory"); sdb_strbuf_destroy(buf); return -1; } @@ -68,7 +257,46 @@ sdb_fe_list(sdb_conn_t *conn) (uint32_t)sdb_strbuf_len(buf), sdb_strbuf_string(buf)); sdb_strbuf_destroy(buf); return 0; -} /* session_start */ +} /* sdb_fe_exec_list */ + +int +sdb_fe_exec_lookup(sdb_conn_t *conn, sdb_store_matcher_t *m, + sdb_store_matcher_t *filter) +{ + tojson_data_t data = { NULL, filter, 0 }; + + data.buf = sdb_strbuf_create(1024); + if (! data.buf) { + char errbuf[1024]; + sdb_log(SDB_LOG_ERR, "frontend: Failed to create " + "buffer to handle LOOKUP command: %s", + sdb_strerror(errno, errbuf, sizeof(errbuf))); + + sdb_strbuf_sprintf(conn->errbuf, "Out of memory"); + sdb_strbuf_destroy(data.buf); + return -1; + } + + sdb_strbuf_append(data.buf, "["); + + /* Let the JSON serializer handle the filter instead of the scanner. Else, + * we'd have to filter twice -- once in the scanner and then again in the + * serializer. */ + data.last_len = sdb_strbuf_len(data.buf); + if (sdb_store_scan(m, /* filter */ NULL, lookup_tojson, &data)) { + sdb_log(SDB_LOG_ERR, "frontend: Failed to lookup hosts"); + sdb_strbuf_sprintf(conn->errbuf, "Failed to lookup hosts"); + sdb_strbuf_destroy(data.buf); + return -1; + } + + sdb_strbuf_append(data.buf, "]"); + + sdb_connection_send(conn, CONNECTION_OK, + (uint32_t)sdb_strbuf_len(data.buf), sdb_strbuf_string(data.buf)); + sdb_strbuf_destroy(data.buf); + return 0; +} /* sdb_fe_exec_lookup */ /* vim: set tw=78 sw=4 ts=4 noexpandtab : */