src/frontend/grammar.y

   1 /*
   2  * SysDB - src/frontend/grammar.y
   3  * Copyright (C) 2013 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 %{
  29
  30 #include "frontend/connection-private.h"
  31 #include "frontend/parser.h"
  32 #include "frontend/grammar.h"
  33
  34 #include "core/store.h"
  35 #include "core/store-private.h"
  36 #include "core/time.h"
  37
  38 #include "utils/error.h"
  39 #include "utils/llist.h"
  40
  41 #include <stdio.h>
  42 #include <string.h>
  43
  44 int
  45 sdb_fe_yylex(YYSTYPE *yylval, YYLTYPE *yylloc, sdb_fe_yyscan_t yyscanner);
  46
  47 sdb_fe_yyextra_t *
  48 sdb_fe_yyget_extra(sdb_fe_yyscan_t scanner);
  49
  50 void
  51 sdb_fe_yyerror(YYLTYPE *lval, sdb_fe_yyscan_t scanner, const char *msg);
  52
  53 /* quick access to the current parse tree */
  54 #define pt sdb_fe_yyget_extra(scanner)->parsetree
  55
  56 /* quick access to the parser mode */
  57 #define parser_mode sdb_fe_yyget_extra(scanner)->mode
  58
  59 #define MODE_TO_STRING(m) \
  60         (((m) == SDB_PARSE_DEFAULT) ? "statement" \
  61                 : ((m) == SDB_PARSE_COND) ? "condition" \
  62                 : ((m) == SDB_PARSE_EXPR) ? "expression" \
  63                 : "UNKNOWN")
  64
  65 %}
  66
  67 %pure-parser
  68 %lex-param {sdb_fe_yyscan_t scanner}
  69 %parse-param {sdb_fe_yyscan_t scanner}
  70 %locations
  71 %error-verbose
  72 %expect 0
  73 %name-prefix "sdb_fe_yy"
  74
  75 %union {
  76         const char *sstr; /* static string */
  77         char *str;
  78
  79         sdb_data_t data;
  80         sdb_time_t datetime;
  81
  82         sdb_llist_t     *list;
  83         sdb_conn_node_t *node;
  84
  85         sdb_store_matcher_t *m;
  86         sdb_store_expr_t *expr;
  87 }
  88
  89 %start statements
  90
  91 %token SCANNER_ERROR
  92
  93 %token AND OR IS NOT MATCHING FILTER
  94 %token CMP_EQUAL CMP_NEQUAL CMP_REGEX CMP_NREGEX
  95 %token CMP_LT CMP_LE CMP_GE CMP_GT
  96 %token CONCAT
  97
  98 %token START END
  99
 100 /* NULL token */
 101 %token NULL_T
 102
 103 %token FETCH LIST LOOKUP TIMESERIES
 104
 105 %token <str> IDENTIFIER STRING
 106
 107 %token <data> INTEGER FLOAT
 108
 109 %token <datetime> DATE TIME
 110
 111 /* Precedence (lowest first): */
 112 %left OR
 113 %left AND
 114 %right NOT
 115 %left CMP_EQUAL CMP_NEQUAL
 116 %left CMP_LT CMP_LE CMP_GE CMP_GT
 117 %nonassoc CMP_REGEX CMP_NREGEX
 118 %left CONCAT
 119 %nonassoc IS
 120 %left '+' '-'
 121 %left '*' '/' '%'
 122 %left '[' ']'
 123 %left '(' ')'
 124 %left '.'
 125
 126 %type <list> statements
 127 %type <node> statement
 128         fetch_statement
 129         list_statement
 130         lookup_statement
 131         timeseries_statement
 132         matching_clause
 133         filter_clause
 134         condition
 135
 136 %type <m> matcher
 137         compare_matcher
 138
 139 %type <expr> expression
 140
 141 %type <sstr> cmp
 142
 143 %type <data> data
 144         interval interval_elem
 145
 146 %type <datetime> datetime
 147         start_clause end_clause
 148
 149 %destructor { free($$); } <str>
 150 %destructor { sdb_object_deref(SDB_OBJ($$)); } <node> <m> <expr>
 151
 152 %%
 153
 154 statements:
 155         statements ';' statement
 156                 {
 157                         /* only accepted in default parse mode */
 158                         if (parser_mode != SDB_PARSE_DEFAULT) {
 159                                 char errmsg[1024];
 160                                 snprintf(errmsg, sizeof(errmsg),
 161                                                 YY_("syntax error, unexpected statement, "
 162                                                         "expecting %s"), MODE_TO_STRING(parser_mode));
 163                                 sdb_fe_yyerror(&yylloc, scanner, errmsg);
 164                                 sdb_object_deref(SDB_OBJ($3));
 165                                 YYABORT;
 166                         }
 167
 168                         if ($3) {
 169                                 sdb_llist_append(pt, SDB_OBJ($3));
 170                                 sdb_object_deref(SDB_OBJ($3));
 171                         }
 172                 }
 173         |
 174         statement
 175                 {
 176                         /* only accepted in default parse mode */
 177                         if (parser_mode != SDB_PARSE_DEFAULT) {
 178                                 char errmsg[1024];
 179                                 snprintf(errmsg, sizeof(errmsg),
 180                                                 YY_("syntax error, unexpected statement, "
 181                                                         "expecting %s"), MODE_TO_STRING(parser_mode));
 182                                 sdb_fe_yyerror(&yylloc, scanner, errmsg);
 183                                 sdb_object_deref(SDB_OBJ($1));
 184                                 YYABORT;
 185                         }
 186
 187                         if ($1) {
 188                                 sdb_llist_append(pt, SDB_OBJ($1));
 189                                 sdb_object_deref(SDB_OBJ($1));
 190                         }
 191                 }
 192         |
 193         condition
 194                 {
 195                         /* only accepted in condition parse mode */
 196                         if (! (parser_mode & SDB_PARSE_COND)) {
 197                                 char errmsg[1024];
 198                                 snprintf(errmsg, sizeof(errmsg),
 199                                                 YY_("syntax error, unexpected condition, "
 200                                                         "expecting %s"), MODE_TO_STRING(parser_mode));
 201                                 sdb_fe_yyerror(&yylloc, scanner, errmsg);
 202                                 sdb_object_deref(SDB_OBJ($1));
 203                                 YYABORT;
 204                         }
 205
 206                         if ($1) {
 207                                 sdb_llist_append(pt, SDB_OBJ($1));
 208                                 sdb_object_deref(SDB_OBJ($1));
 209                         }
 210                 }
 211         |
 212         expression
 213                 {
 214                         /* only accepted in expression parse mode */
 215                         if (! (parser_mode & SDB_PARSE_EXPR)) {
 216                                 char errmsg[1024];
 217                                 snprintf(errmsg, sizeof(errmsg),
 218                                                 YY_("syntax error, unexpected expression, "
 219                                                         "expecting %s"), MODE_TO_STRING(parser_mode));
 220                                 sdb_fe_yyerror(&yylloc, scanner, errmsg);
 221                                 sdb_object_deref(SDB_OBJ($1));
 222                                 YYABORT;
 223                         }
 224
 225                         if ($1) {
 226                                 sdb_conn_node_t *n;
 227                                 n = SDB_CONN_NODE(sdb_object_create_dT(/* name = */ NULL,
 228                                                         conn_expr_t, conn_expr_destroy));
 229                                 n->cmd = CONNECTION_EXPR;
 230                                 CONN_EXPR($$)->expr = $1;
 231
 232                                 sdb_llist_append(pt, SDB_OBJ(n));
 233                                 sdb_object_deref(SDB_OBJ(n));
 234                         }
 235                 }
 236         ;
 237
 238 statement:
 239         fetch_statement
 240         |
 241         list_statement
 242         |
 243         lookup_statement
 244         |
 245         timeseries_statement
 246         |
 247         /* empty */
 248                 {
 249                         $$ = NULL;
 250                 }
 251         ;
 252
 253 /*
 254  * FETCH <type> <hostname> [FILTER <condition>];
 255  *
 256  * Retrieve detailed information about a single host.
 257  */
 258 fetch_statement:
 259         FETCH IDENTIFIER STRING filter_clause
 260                 {
 261                         /* TODO: support other types as well */
 262                         if (strcasecmp($2, "host")) {
 263                                 char errmsg[strlen($2) + 32];
 264                                 snprintf(errmsg, sizeof(errmsg),
 265                                                 YY_("unknown data-source %s"), $2);
 266                                 sdb_fe_yyerror(&yylloc, scanner, errmsg);
 267                                 free($2); $2 = NULL;
 268                                 free($3); $3 = NULL;
 269                                 sdb_object_deref(SDB_OBJ($4));
 270                                 YYABORT;
 271                         }
 272
 273                         $$ = SDB_CONN_NODE(sdb_object_create_dT(/* name = */ NULL,
 274                                                 conn_fetch_t, conn_fetch_destroy));
 275                         CONN_FETCH($$)->type = SDB_HOST;
 276                         CONN_FETCH($$)->name = $3;
 277                         CONN_FETCH($$)->filter = CONN_MATCHER($4);
 278                         $$->cmd = CONNECTION_FETCH;
 279                         free($2); $2 = NULL;
 280                 }
 281         ;
 282
 283 /*
 284  * LIST <type> [FILTER <condition>];
 285  *
 286  * Returns a list of all hosts in the store.
 287  */
 288 list_statement:
 289         LIST IDENTIFIER filter_clause
 290                 {
 291                         int type = sdb_store_parse_object_type_plural($2);
 292                         if (type < 0) {
 293                                 char errmsg[strlen($2) + 32];
 294                                 snprintf(errmsg, sizeof(errmsg),
 295                                                 YY_("unknown data-source %s"), $2);
 296                                 sdb_fe_yyerror(&yylloc, scanner, errmsg);
 297                                 free($2); $2 = NULL;
 298                                 sdb_object_deref(SDB_OBJ($3));
 299                                 YYABORT;
 300                         }
 301
 302                         $$ = SDB_CONN_NODE(sdb_object_create_dT(/* name = */ NULL,
 303                                                 conn_list_t, conn_list_destroy));
 304                         CONN_LIST($$)->type = type;
 305                         CONN_LIST($$)->filter = CONN_MATCHER($3);
 306                         $$->cmd = CONNECTION_LIST;
 307                         free($2); $2 = NULL;
 308                 }
 309         ;
 310
 311 /*
 312  * LOOKUP <type> MATCHING <condition> [FILTER <condition>];
 313  *
 314  * Returns detailed information about <type> matching condition.
 315  */
 316 lookup_statement:
 317         LOOKUP IDENTIFIER matching_clause filter_clause
 318                 {
 319                         /* TODO: support other types as well */
 320                         if (strcasecmp($2, "hosts")) {
 321                                 char errmsg[strlen($2) + 32];
 322                                 snprintf(errmsg, sizeof(errmsg),
 323                                                 YY_("unknown data-source %s"), $2);
 324                                 sdb_fe_yyerror(&yylloc, scanner, errmsg);
 325                                 free($2); $2 = NULL;
 326                                 sdb_object_deref(SDB_OBJ($3));
 327                                 sdb_object_deref(SDB_OBJ($4));
 328                                 YYABORT;
 329                         }
 330
 331                         $$ = SDB_CONN_NODE(sdb_object_create_dT(/* name = */ NULL,
 332                                                 conn_lookup_t, conn_lookup_destroy));
 333                         CONN_LOOKUP($$)->type = SDB_HOST;
 334                         CONN_LOOKUP($$)->matcher = CONN_MATCHER($3);
 335                         CONN_LOOKUP($$)->filter = CONN_MATCHER($4);
 336                         $$->cmd = CONNECTION_LOOKUP;
 337                         free($2); $2 = NULL;
 338                 }
 339         ;
 340
 341 matching_clause:
 342         MATCHING condition { $$ = $2; }
 343         |
 344         /* empty */ { $$ = NULL; }
 345
 346 filter_clause:
 347         FILTER condition { $$ = $2; }
 348         |
 349         /* empty */ { $$ = NULL; }
 350
 351 /*
 352  * TIMESERIES <host>.<metric> [START <datetime>] [END <datetime>];
 353  *
 354  * Returns a time-series for the specified host's metric.
 355  */
 356 timeseries_statement:
 357         TIMESERIES STRING '.' STRING start_clause end_clause
 358                 {
 359                         $$ = SDB_CONN_NODE(sdb_object_create_dT(/* name = */ NULL,
 360                                                 conn_ts_t, conn_ts_destroy));
 361                         CONN_TS($$)->hostname = $2;
 362                         CONN_TS($$)->metric = $4;
 363                         CONN_TS($$)->opts.start = $5;
 364                         CONN_TS($$)->opts.end = $6;
 365                         $$->cmd = CONNECTION_TIMESERIES;
 366                 }
 367         ;
 368
 369 start_clause:
 370         START datetime { $$ = $2; }
 371         |
 372         /* empty */ { $$ = sdb_gettime() - SDB_INTERVAL_HOUR; }
 373
 374 end_clause:
 375         END datetime { $$ = $2; }
 376         |
 377         /* empty */ { $$ = sdb_gettime(); }
 378
 379 /*
 380  * Basic expressions.
 381  */
 382
 383 condition:
 384         matcher
 385                 {
 386                         if (! $1) {
 387                                 /* TODO: improve error reporting */
 388                                 sdb_fe_yyerror(&yylloc, scanner,
 389                                                 YY_("syntax error, invalid condition"));
 390                                 YYABORT;
 391                         }
 392
 393                         $$ = SDB_CONN_NODE(sdb_object_create_dT(/* name = */ NULL,
 394                                                 conn_matcher_t, conn_matcher_destroy));
 395                         $$->cmd = CONNECTION_MATCHER;
 396                         CONN_MATCHER($$)->matcher = $1;
 397                 }
 398         ;
 399
 400 matcher:
 401         '(' matcher ')'
 402                 {
 403                         $$ = $2;
 404                 }
 405         |
 406         matcher AND matcher
 407                 {
 408                         $$ = sdb_store_con_matcher($1, $3);
 409                         sdb_object_deref(SDB_OBJ($1));
 410                         sdb_object_deref(SDB_OBJ($3));
 411                 }
 412         |
 413         matcher OR matcher
 414                 {
 415                         $$ = sdb_store_dis_matcher($1, $3);
 416                         sdb_object_deref(SDB_OBJ($1));
 417                         sdb_object_deref(SDB_OBJ($3));
 418                 }
 419         |
 420         NOT matcher
 421                 {
 422                         $$ = sdb_store_inv_matcher($2);
 423                         sdb_object_deref(SDB_OBJ($2));
 424                 }
 425         |
 426         compare_matcher
 427                 {
 428                         $$ = $1;
 429                 }
 430         ;
 431
 432 /*
 433  * <object_type>.<object_attr> <cmp> <value>
 434  *
 435  * Parse matchers comparing object attributes with a value.
 436  */
 437 compare_matcher:
 438         '.' IDENTIFIER cmp expression
 439                 {
 440                         $$ = sdb_store_matcher_parse_field_cmp($2, $3, $4);
 441                         free($2); $2 = NULL;
 442                         sdb_object_deref(SDB_OBJ($4));
 443                 }
 444         |
 445         IDENTIFIER cmp expression
 446                 {
 447                         $$ = sdb_store_matcher_parse_cmp($1, NULL, $2, $3);
 448                         free($1); $1 = NULL;
 449                         sdb_object_deref(SDB_OBJ($3));
 450                 }
 451         |
 452         IDENTIFIER '[' IDENTIFIER ']' cmp expression
 453                 {
 454                         $$ = sdb_store_matcher_parse_cmp($1, $3, $5, $6);
 455                         free($1); $1 = NULL;
 456                         free($3); $3 = NULL;
 457                         sdb_object_deref(SDB_OBJ($6));
 458                 }
 459         |
 460         IDENTIFIER '[' IDENTIFIER ']' IS NULL_T
 461                 {
 462                         $$ = sdb_store_matcher_parse_cmp($1, $3, "IS", NULL);
 463                         free($1); $1 = NULL;
 464                         free($3); $3 = NULL;
 465                 }
 466         |
 467         IDENTIFIER '[' IDENTIFIER ']' IS NOT NULL_T
 468                 {
 469                         sdb_store_matcher_t *m;
 470                         m = sdb_store_matcher_parse_cmp($1, $3, "IS", NULL);
 471                         free($1); $1 = NULL;
 472                         free($3); $3 = NULL;
 473
 474                         /* sdb_store_inv_matcher return NULL if m==NULL */
 475                         $$ = sdb_store_inv_matcher(m);
 476                         sdb_object_deref(SDB_OBJ(m));
 477                 }
 478         ;
 479
 480 expression:
 481         '(' expression ')'
 482                 {
 483                         $$ = $2;
 484                 }
 485         |
 486         expression '+' expression
 487                 {
 488                         $$ = sdb_store_expr_create(SDB_DATA_ADD, $1, $3);
 489                         sdb_object_deref(SDB_OBJ($1)); $1 = NULL;
 490                         sdb_object_deref(SDB_OBJ($3)); $3 = NULL;
 491                 }
 492         |
 493         expression '-' expression
 494                 {
 495                         $$ = sdb_store_expr_create(SDB_DATA_SUB, $1, $3);
 496                         sdb_object_deref(SDB_OBJ($1)); $1 = NULL;
 497                         sdb_object_deref(SDB_OBJ($3)); $3 = NULL;
 498                 }
 499         |
 500         expression '*' expression
 501                 {
 502                         $$ = sdb_store_expr_create(SDB_DATA_MUL, $1, $3);
 503                         sdb_object_deref(SDB_OBJ($1)); $1 = NULL;
 504                         sdb_object_deref(SDB_OBJ($3)); $3 = NULL;
 505                 }
 506         |
 507         expression '/' expression
 508                 {
 509                         $$ = sdb_store_expr_create(SDB_DATA_DIV, $1, $3);
 510                         sdb_object_deref(SDB_OBJ($1)); $1 = NULL;
 511                         sdb_object_deref(SDB_OBJ($3)); $3 = NULL;
 512                 }
 513         |
 514         expression '%' expression
 515                 {
 516                         $$ = sdb_store_expr_create(SDB_DATA_MOD, $1, $3);
 517                         sdb_object_deref(SDB_OBJ($1)); $1 = NULL;
 518                         sdb_object_deref(SDB_OBJ($3)); $3 = NULL;
 519                 }
 520         |
 521         expression CONCAT expression
 522                 {
 523                         $$ = sdb_store_expr_create(SDB_DATA_CONCAT, $1, $3);
 524                         sdb_object_deref(SDB_OBJ($1)); $1 = NULL;
 525                         sdb_object_deref(SDB_OBJ($3)); $3 = NULL;
 526                 }
 527         |
 528         '.' IDENTIFIER
 529                 {
 530                         int field = sdb_store_parse_field_name($2);
 531                         free($2); $2 = NULL;
 532                         $$ = sdb_store_expr_fieldvalue(field);
 533                 }
 534         |
 535         IDENTIFIER '[' IDENTIFIER ']'
 536                 {
 537                         $$ = sdb_store_expr_attrvalue($3);
 538                         free($1); $1 = NULL;
 539                         free($3); $3 = NULL;
 540                 }
 541         |
 542         data
 543                 {
 544                         $$ = sdb_store_expr_constvalue(&$1);
 545                         sdb_data_free_datum(&$1);
 546                 }
 547         ;
 548
 549 cmp:
 550         CMP_EQUAL { $$ = "="; }
 551         |
 552         CMP_NEQUAL { $$ = "!="; }
 553         |
 554         CMP_REGEX { $$ = "=~"; }
 555         |
 556         CMP_NREGEX { $$ = "!~"; }
 557         |
 558         CMP_LT { $$ = "<"; }
 559         |
 560         CMP_LE { $$ = "<="; }
 561         |
 562         CMP_GE { $$ = ">="; }
 563         |
 564         CMP_GT { $$ = ">"; }
 565         ;
 566
 567 data:
 568         STRING { $$.type = SDB_TYPE_STRING; $$.data.string = $1; }
 569         |
 570         INTEGER { $$ = $1; }
 571         |
 572         FLOAT { $$ = $1; }
 573         |
 574         datetime { $$.type = SDB_TYPE_DATETIME; $$.data.datetime = $1; }
 575         |
 576         interval { $$ = $1; }
 577         ;
 578
 579 datetime:
 580         DATE TIME { $$ = $1 + $2; }
 581         |
 582         DATE { $$ = $1; }
 583         |
 584         TIME { $$ = $1; }
 585         ;
 586
 587 interval:
 588         interval interval_elem
 589                 {
 590                         $$.data.datetime = $1.data.datetime + $2.data.datetime;
 591                 }
 592         |
 593         interval_elem { $$ = $1; }
 594         ;
 595
 596 interval_elem:
 597         INTEGER IDENTIFIER
 598                 {
 599                         sdb_time_t unit = 1;
 600
 601                         unit = sdb_strpunit($2);
 602                         if (! unit) {
 603                                 char errmsg[strlen($2) + 32];
 604                                 snprintf(errmsg, sizeof(errmsg),
 605                                                 YY_("invalid time unit %s"), $2);
 606                                 sdb_fe_yyerror(&yylloc, scanner, errmsg);
 607                                 free($2); $2 = NULL;
 608                                 YYABORT;
 609                         }
 610                         free($2); $2 = NULL;
 611
 612                         $$.type = SDB_TYPE_DATETIME;
 613                         $$.data.datetime = (sdb_time_t)$1.data.integer * unit;
 614
 615                         if ($1.data.integer < 0) {
 616                                 sdb_fe_yyerror(&yylloc, scanner,
 617                                                 YY_("syntax error, negative intervals not supported"));
 618                                 YYABORT;
 619                         }
 620                 }
 621         ;
 622
 623 %%
 624
 625 void
 626 sdb_fe_yyerror(YYLTYPE *lval, sdb_fe_yyscan_t scanner, const char *msg)
 627 {
 628         sdb_log(SDB_LOG_ERR, "frontend: parse error: %s", msg);
 629 } /* sdb_fe_yyerror */
 630
 631 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 632