src/frontend/query.c

   1 /*
   2  * SysDB - src/frontend/query.c
   3  * Copyright (C) 2013-2014 Sebastian 'tokkee' Harl <sh@tokkee.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #       include "config.h"
  30 #endif
  31
  32 #include "sysdb.h"
  33
  34 #include "core/plugin.h"
  35 #include "frontend/connection-private.h"
  36 #include "parser/ast.h"
  37 #include "parser/parser.h"
  38 #include "utils/error.h"
  39 #include "utils/proto.h"
  40 #include "utils/strbuf.h"
  41
  42 #include <errno.h>
  43 #include <string.h>
  44
  45 /*
  46  * private helper functions
  47  */
  48
  49 static char *
  50 sstrdup(const char *s)
  51 {
  52         return s ? strdup(s) : NULL;
  53 } /* sstrdup */
  54
  55 static int
  56 query_exec(sdb_conn_t *conn, sdb_ast_node_t *ast)
  57 {
  58         sdb_strbuf_t *buf;
  59         int status;
  60
  61         if (! ast) {
  62                 sdb_strbuf_sprintf(conn->errbuf, "out of memory");
  63                 return -1;
  64         }
  65
  66         buf = sdb_strbuf_create(1024);
  67         if (! buf) {
  68                 sdb_strbuf_sprintf(conn->errbuf, "Out of memory");
  69                 return -1;
  70         }
  71         status = sdb_plugin_query(ast, buf, conn->errbuf);
  72         if (status < 0) {
  73                 char query[conn->cmd_len + 1];
  74                 strncpy(query, sdb_strbuf_string(conn->buf), conn->cmd_len);
  75                 query[sizeof(query) - 1] = '\0';
  76                 sdb_log(SDB_LOG_ERR, "frontend: failed to execute query '%s'", query);
  77         }
  78         else
  79                 sdb_connection_send(conn, status,
  80                                 (uint32_t)sdb_strbuf_len(buf), sdb_strbuf_string(buf));
  81
  82         sdb_strbuf_destroy(buf);
  83         return status < 0 ? status : 0;
  84 } /* query_exec */
  85
  86 /*
  87  * public API
  88  */
  89
  90 int
  91 sdb_fe_query(sdb_conn_t *conn)
  92 {
  93         sdb_llist_t *parsetree;
  94         sdb_ast_node_t *ast = NULL;
  95         int status = 0;
  96
  97         if ((! conn) || (conn->cmd != SDB_CONNECTION_QUERY))
  98                 return -1;
  99
 100         parsetree = sdb_parser_parse(sdb_strbuf_string(conn->buf),
 101                         (int)conn->cmd_len, conn->errbuf);
 102         if (! parsetree) {
 103                 char query[conn->cmd_len + 1];
 104                 strncpy(query, sdb_strbuf_string(conn->buf), conn->cmd_len);
 105                 query[sizeof(query) - 1] = '\0';
 106                 sdb_log(SDB_LOG_ERR, "frontend: Failed to parse query '%s': %s",
 107                                 query, sdb_strbuf_string(conn->errbuf));
 108                 return -1;
 109         }
 110
 111         switch (sdb_llist_len(parsetree)) {
 112                 case 0:
 113                         /* skipping empty command; send back an empty reply */
 114                         sdb_connection_send(conn, SDB_CONNECTION_DATA, 0, NULL);
 115                         break;
 116                 case 1:
 117                         ast = SDB_AST_NODE(sdb_llist_get(parsetree, 0));
 118                         break;
 119
 120                 default:
 121                         {
 122                                 char query[conn->cmd_len + 1];
 123                                 strncpy(query, sdb_strbuf_string(conn->buf), conn->cmd_len);
 124                                 query[sizeof(query) - 1] = '\0';
 125                                 sdb_log(SDB_LOG_WARNING, "frontend: Ignoring %zu command%s "
 126                                                 "in multi-statement query '%s'",
 127                                                 sdb_llist_len(parsetree) - 1,
 128                                                 sdb_llist_len(parsetree) == 2 ? "" : "s",
 129                                                 query);
 130                                 ast = SDB_AST_NODE(sdb_llist_get(parsetree, 0));
 131                         }
 132         }
 133
 134         if (ast) {
 135                 status = query_exec(conn, ast);
 136                 sdb_object_deref(SDB_OBJ(ast));
 137         }
 138         sdb_llist_destroy(parsetree);
 139         return status;
 140 } /* sdb_fe_query */
 141
 142 int
 143 sdb_fe_fetch(sdb_conn_t *conn)
 144 {
 145         sdb_ast_node_t *ast;
 146         char hostname[conn->cmd_len + 1];
 147         char name[conn->cmd_len + 1];
 148         uint32_t type;
 149         int status;
 150
 151         if ((! conn) || (conn->cmd != SDB_CONNECTION_FETCH))
 152                 return -1;
 153
 154         if (conn->cmd_len < sizeof(uint32_t)) {
 155                 sdb_log(SDB_LOG_ERR, "frontend: Invalid command length %d for "
 156                                 "FETCH command", conn->cmd_len);
 157                 sdb_strbuf_sprintf(conn->errbuf, "FETCH: Invalid command length %d",
 158                                 conn->cmd_len);
 159                 return -1;
 160         }
 161
 162         /* TODO: support other types besides hosts */
 163         hostname[0] = '\0';
 164
 165         sdb_proto_unmarshal_int32(SDB_STRBUF_STR(conn->buf), &type);
 166         strncpy(name, sdb_strbuf_string(conn->buf) + sizeof(uint32_t),
 167                         conn->cmd_len - sizeof(uint32_t));
 168         name[sizeof(name) - 1] = '\0';
 169
 170         ast = sdb_ast_fetch_create((int)type,
 171                         hostname[0] ? strdup(hostname) : NULL,
 172                         name[0] ? strdup(name) : NULL,
 173                         /* filter = */ NULL);
 174         status = query_exec(conn, ast);
 175         sdb_object_deref(SDB_OBJ(ast));
 176         return status;
 177 } /* sdb_fe_fetch */
 178
 179 int
 180 sdb_fe_list(sdb_conn_t *conn)
 181 {
 182         sdb_ast_node_t *ast;
 183         uint32_t type = SDB_HOST;
 184         int status;
 185
 186         if ((! conn) || (conn->cmd != SDB_CONNECTION_LIST))
 187                 return -1;
 188
 189         if (conn->cmd_len == sizeof(uint32_t))
 190                 sdb_proto_unmarshal_int32(SDB_STRBUF_STR(conn->buf), &type);
 191         else if (conn->cmd_len) {
 192                 sdb_log(SDB_LOG_ERR, "frontend: Invalid command length %d for "
 193                                 "LIST command", conn->cmd_len);
 194                 sdb_strbuf_sprintf(conn->errbuf, "LIST: Invalid command length %d",
 195                                 conn->cmd_len);
 196                 return -1;
 197         }
 198
 199         ast = sdb_ast_list_create((int)type, /* filter = */ NULL);
 200         status = query_exec(conn, ast);
 201         sdb_object_deref(SDB_OBJ(ast));
 202         return status;
 203 } /* sdb_fe_list */
 204
 205 int
 206 sdb_fe_lookup(sdb_conn_t *conn)
 207 {
 208         sdb_ast_node_t *ast, *m;
 209         const char *matcher;
 210         size_t matcher_len;
 211
 212         uint32_t type;
 213         int status;
 214
 215         if ((! conn) || (conn->cmd != SDB_CONNECTION_LOOKUP))
 216                 return -1;
 217
 218         if (conn->cmd_len < sizeof(uint32_t)) {
 219                 sdb_log(SDB_LOG_ERR, "frontend: Invalid command length %d for "
 220                                 "LOOKUP command", conn->cmd_len);
 221                 sdb_strbuf_sprintf(conn->errbuf, "LOOKUP: Invalid command length %d",
 222                                 conn->cmd_len);
 223                 return -1;
 224         }
 225         sdb_proto_unmarshal_int32(SDB_STRBUF_STR(conn->buf), &type);
 226
 227         matcher = sdb_strbuf_string(conn->buf) + sizeof(uint32_t);
 228         matcher_len = conn->cmd_len - sizeof(uint32_t);
 229         m = sdb_parser_parse_conditional(matcher, (int)matcher_len, conn->errbuf);
 230         if (! m) {
 231                 char expr[matcher_len + 1];
 232                 strncpy(expr, matcher, sizeof(expr));
 233                 expr[sizeof(expr) - 1] = '\0';
 234                 sdb_log(SDB_LOG_ERR, "frontend: Failed to parse lookup condition '%s': %s",
 235                                 expr, sdb_strbuf_string(conn->errbuf));
 236                 return -1;
 237         }
 238
 239         ast = sdb_ast_lookup_create((int)type, m, /* filter = */ NULL);
 240         /* run analyzer using the full context */
 241         if (ast && sdb_parser_analyze(ast, conn->errbuf)) {
 242                 char expr[matcher_len + 1];
 243                 char err[sdb_strbuf_len(conn->errbuf) + sizeof(expr) + 64];
 244                 strncpy(expr, matcher, sizeof(expr));
 245                 expr[sizeof(expr) - 1] = '\0';
 246                 snprintf(err, sizeof(err), "Failed to parse lookup condition '%s': %s",
 247                                 expr, sdb_strbuf_string(conn->errbuf));
 248                 sdb_strbuf_sprintf(conn->errbuf, "%s", err);
 249                 status = -1;
 250         }
 251         else
 252                 status = query_exec(conn, ast);
 253         if (! ast)
 254                 sdb_object_deref(SDB_OBJ(m));
 255         sdb_object_deref(SDB_OBJ(ast));
 256         return status;
 257 } /* sdb_fe_lookup */
 258
 259 int
 260 sdb_fe_store(sdb_conn_t *conn)
 261 {
 262         sdb_ast_node_t *ast;
 263         const char *buf = sdb_strbuf_string(conn->buf);
 264         size_t len = conn->cmd_len;
 265         uint32_t type;
 266         ssize_t n;
 267         int status;
 268
 269         if ((! conn) || (conn->cmd != SDB_CONNECTION_STORE))
 270                 return -1;
 271
 272         if ((n = sdb_proto_unmarshal_int32(buf, len, &type)) < 0) {
 273                 sdb_log(SDB_LOG_ERR, "frontend: Invalid command length %zu for "
 274                                 "STORE command", len);
 275                 sdb_strbuf_sprintf(conn->errbuf,
 276                                 "STORE: Invalid command length %zu", len);
 277                 return -1;
 278         }
 279
 280         switch (type) {
 281                 case SDB_HOST:
 282                 {
 283                         sdb_proto_host_t host;
 284                         if (sdb_proto_unmarshal_host(buf, len, &host) < 0) {
 285                                 sdb_strbuf_sprintf(conn->errbuf,
 286                                                 "STORE: Failed to unmarshal host object");
 287                                 return -1;
 288                         }
 289                         ast = sdb_ast_store_create(SDB_HOST, /* host */ NULL,
 290                                         /* parent */ 0, NULL, sstrdup(host.name), host.last_update,
 291                                         /* metric store */ NULL, NULL, SDB_DATA_NULL);
 292                 }
 293                 break;
 294
 295                 case SDB_SERVICE:
 296                 {
 297                         sdb_proto_service_t svc;
 298                         if (sdb_proto_unmarshal_service(buf, len, &svc) < 0) {
 299                                 sdb_strbuf_sprintf(conn->errbuf,
 300                                                 "STORE: Failed to unmarshal service object");
 301                                 return -1;
 302                         }
 303                         ast = sdb_ast_store_create(SDB_SERVICE, sstrdup(svc.hostname),
 304                                         /* parent */ 0, NULL, sstrdup(svc.name), svc.last_update,
 305                                         /* metric store */ NULL, NULL, SDB_DATA_NULL);
 306                 }
 307                 break;
 308
 309                 case SDB_METRIC:
 310                 {
 311                         sdb_proto_metric_t metric;
 312                         if (sdb_proto_unmarshal_metric(buf, len, &metric) < 0) {
 313                                 sdb_strbuf_sprintf(conn->errbuf,
 314                                                 "STORE: Failed to unmarshal metric object");
 315                                 return -1;
 316                         }
 317                         ast = sdb_ast_store_create(SDB_METRIC, sstrdup(metric.hostname),
 318                                         /* parent */ 0, NULL, sstrdup(metric.name), metric.last_update,
 319                                         sstrdup(metric.store_type), sstrdup(metric.store_id),
 320                                         SDB_DATA_NULL);
 321                 }
 322                 break;
 323         }
 324
 325         if (type & SDB_ATTRIBUTE) {
 326                 sdb_proto_attribute_t attr;
 327                 const char *hostname, *parent;
 328                 int parent_type;
 329                 if (sdb_proto_unmarshal_attribute(buf, len, &attr) < 0) {
 330                         sdb_strbuf_sprintf(conn->errbuf,
 331                                         "STORE: Failed to unmarshal attribute object");
 332                         return -1;
 333                 }
 334                 if (attr.parent_type == SDB_HOST) {
 335                         hostname = attr.parent;
 336                         parent_type = 0;
 337                         parent = NULL;
 338                 }
 339                 else {
 340                         hostname = attr.hostname;
 341                         parent_type = attr.parent_type;
 342                         parent = attr.parent;
 343                 }
 344                 ast = sdb_ast_store_create(SDB_ATTRIBUTE, sstrdup(hostname),
 345                                 parent_type, sstrdup(parent), sstrdup(attr.key),
 346                                 attr.last_update, /* metric store */ NULL, NULL,
 347                                 attr.value);
 348         }
 349
 350         if (! ast) {
 351                 sdb_log(SDB_LOG_ERR, "frontend: Invalid object type %d for "
 352                                 "STORE COMMAND", type);
 353                 sdb_strbuf_sprintf(conn->errbuf, "STORE: Invalid object type %d", type);
 354                 return -1;
 355         }
 356
 357         status = sdb_parser_analyze(ast, conn->errbuf);
 358         if (! status)
 359                 status = query_exec(conn, ast);
 360         sdb_object_deref(SDB_OBJ(ast));
 361         return status;
 362 } /* sdb_fe_store */
 363
 364 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 365