X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fcore%2Fstore_lookup.c;h=4e777d863f2dbed1a2433da46bf27bd8e62c55e9;hb=d4a8da24750a0547a6b6af29853f519869bb9a53;hp=476e0e717d9fb5c788651722d5e2a4948dcd696e;hpb=52e68c096ba26c0620f78718054b20dc6c0d5306;p=sysdb.git diff --git a/src/core/store_lookup.c b/src/core/store_lookup.c index 476e0e7..4e777d8 100644 --- a/src/core/store_lookup.c +++ b/src/core/store_lookup.c @@ -114,20 +114,64 @@ attr_cmp(sdb_store_obj_t *obj, sdb_store_cond_t *cond, if (obj->type != SDB_HOST) return INT_MAX; - if (sdb_store_expr_eval(ATTR_C(cond)->expr, &value)) + if (sdb_store_expr_eval(ATTR_C(cond)->expr, obj, &value, filter)) return INT_MAX; attr = attr_get(HOST(obj), ATTR_C(cond)->name, filter); if (! attr) status = INT_MAX; else if (attr->value.type != value.type) - status = INT_MAX; + status = sdb_data_strcmp(&attr->value, &value); else status = sdb_data_cmp(&attr->value, &value); sdb_data_free_datum(&value); return status; } /* attr_cmp */ +static int +obj_cmp(sdb_store_obj_t *obj, sdb_store_cond_t *cond, + sdb_store_matcher_t *filter) +{ + sdb_data_t obj_value = SDB_DATA_INIT; + sdb_data_t value = SDB_DATA_INIT; + int status; + + if (sdb_store_expr_eval(OBJ_C(cond)->expr, obj, &value, filter)) + return INT_MAX; + + if (OBJ_C(cond)->field == SDB_FIELD_BACKEND) { + /* this implementation is not actually a conditional but rather checks + * for equality (or rather, existence) only */ + size_t i; + + if (value.type != SDB_TYPE_STRING) + return INT_MAX; + + status = INT_MAX; + for (i = 0; i < obj->backends_num; ++i) { + if (! strcasecmp(obj->backends[i], value.data.string)) { + status = 0; + break; + } + } + sdb_data_free_datum(&value); + return status; + } + + if (sdb_store_get_field(obj, OBJ_C(cond)->field, &obj_value)) + return INT_MAX; + if (obj_value.type != value.type) { + sdb_data_free_datum(&obj_value); + sdb_data_free_datum(&value); + return INT_MAX; + } + + status = sdb_data_cmp(&obj_value, &value); + sdb_data_free_datum(&obj_value); + sdb_data_free_datum(&value); + return status; +} /* obj_cmp */ + /* * matcher implementations */ @@ -197,6 +241,9 @@ match_name(sdb_store_matcher_t *m, sdb_store_obj_t *obj, case SDB_SERVICE: iter = sdb_avltree_get_iter(HOST(obj)->services); break; + case SDB_METRIC: + iter = sdb_avltree_get_iter(HOST(obj)->metrics); + break; case SDB_ATTRIBUTE: iter = sdb_avltree_get_iter(HOST(obj)->attributes); break; @@ -289,6 +336,88 @@ match_gt(sdb_store_matcher_t *m, sdb_store_obj_t *obj, return (status != INT_MAX) && (status > 0); } /* match_gt */ +/* + * cmp_expr: + * Compare the values of two expressions when evaluating them using the + * specified stored object and filter. Returns a value less than, equal to, or + * greater than zero if the value of the first expression compares less than, + * equal to, or greater than the value of the second expression. Returns + * INT_MAX if any of the expressions could not be evaluated. + */ +static int +cmp_expr(sdb_store_expr_t *e1, sdb_store_expr_t *e2, + sdb_store_obj_t *obj, sdb_store_matcher_t *filter) +{ + sdb_data_t v1 = SDB_DATA_INIT, v2 = SDB_DATA_INIT; + int status; + + if (sdb_store_expr_eval(e1, obj, &v1, filter)) + return INT_MAX; + if (sdb_store_expr_eval(e2, obj, &v2, filter)) { + sdb_data_free_datum(&v1); + return INT_MAX; + } + + if (v1.type == v2.type) + status = sdb_data_cmp(&v1, &v2); + else + status = sdb_data_strcmp(&v1, &v2); + + sdb_data_free_datum(&v1); + sdb_data_free_datum(&v2); + return status; +} /* cmp_expr */ + +static int +match_cmp_lt(sdb_store_matcher_t *m, sdb_store_obj_t *obj, + sdb_store_matcher_t *filter) +{ + int status; + assert(m->type == MATCHER_CMP_LT); + status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter); + return (status != INT_MAX) && (status < 0); +} /* match_cmp_lt */ + +static int +match_cmp_le(sdb_store_matcher_t *m, sdb_store_obj_t *obj, + sdb_store_matcher_t *filter) +{ + int status; + assert(m->type == MATCHER_CMP_LE); + status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter); + return (status != INT_MAX) && (status <= 0); +} /* match_cmp_le */ + +static int +match_cmp_eq(sdb_store_matcher_t *m, sdb_store_obj_t *obj, + sdb_store_matcher_t *filter) +{ + int status; + assert(m->type == MATCHER_CMP_EQ); + status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter); + return (status != INT_MAX) && (! status); +} /* match_cmp_eq */ + +static int +match_cmp_ge(sdb_store_matcher_t *m, sdb_store_obj_t *obj, + sdb_store_matcher_t *filter) +{ + int status; + assert(m->type == MATCHER_CMP_GE); + status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter); + return (status != INT_MAX) && (status >= 0); +} /* match_cmp_ge */ + +static int +match_cmp_gt(sdb_store_matcher_t *m, sdb_store_obj_t *obj, + sdb_store_matcher_t *filter) +{ + int status; + assert(m->type == MATCHER_CMP_GT); + status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter); + return (status != INT_MAX) && (status > 0); +} /* match_cmp_gt */ + static int match_isnull(sdb_store_matcher_t *m, sdb_store_obj_t *obj, sdb_store_matcher_t *filter) @@ -316,6 +445,11 @@ matchers[] = { match_eq, match_ge, match_gt, + match_cmp_lt, + match_cmp_le, + match_cmp_eq, + match_cmp_ge, + match_cmp_gt, match_isnull, }; @@ -356,6 +490,32 @@ static sdb_type_t attr_cond_type = { /* destroy = */ attr_cond_destroy, }; +static int +obj_cond_init(sdb_object_t *obj, va_list ap) +{ + int field = va_arg(ap, int); + sdb_store_expr_t *expr = va_arg(ap, sdb_store_expr_t *); + + SDB_STORE_COND(obj)->cmp = obj_cmp; + + OBJ_C(obj)->field = field; + OBJ_C(obj)->expr = expr; + sdb_object_ref(SDB_OBJ(expr)); + return 0; +} /* obj_cond_init */ + +static void +obj_cond_destroy(sdb_object_t *obj) +{ + sdb_object_deref(SDB_OBJ(OBJ_C(obj)->expr)); +} /* obj_cond_destroy */ + +static sdb_type_t obj_cond_type = { + /* size = */ sizeof(obj_cond_t), + /* init = */ obj_cond_init, + /* destroy = */ obj_cond_destroy, +}; + /* * private matcher types */ @@ -495,21 +655,34 @@ cond_matcher_destroy(sdb_object_t *obj) static char * cond_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen) { + const char *type, *id; + sdb_data_t value = SDB_DATA_INIT; + char value_str[buflen]; + sdb_store_expr_t *expr; + if (COND_M(m)->cond->cmp == attr_cmp) { - sdb_data_t value = SDB_DATA_INIT; - char value_str[buflen]; - if (sdb_store_expr_eval(ATTR_C(COND_M(m)->cond)->expr, &value)) - snprintf(value_str, sizeof(value_str), "ERR"); - else if (sdb_data_format(&value, value_str, sizeof(value_str), - SDB_SINGLE_QUOTED) < 0) - snprintf(value_str, sizeof(value_str), "ERR"); - snprintf(buf, buflen, "ATTR[%s]{ %s %s }", - ATTR_C(COND_M(m)->cond)->name, MATCHER_SYM(m->type), - value_str); - sdb_data_free_datum(&value); + type = "ATTR"; + id = ATTR_C(COND_M(m)->cond)->name; + expr = ATTR_C(COND_M(m)->cond)->expr; } - else + else if (COND_M(m)->cond->cmp == obj_cmp) { + type = "OBJ"; + id = SDB_FIELD_TO_NAME(OBJ_C(COND_M(m)->cond)->field); + expr = OBJ_C(COND_M(m)->cond)->expr; + } + else { snprintf(buf, buflen, ""); + return buf; + } + + if (sdb_store_expr_eval(expr, /* obj */ NULL, &value, /* filter */ NULL)) + snprintf(value_str, sizeof(value_str), "ERR"); + else if (sdb_data_format(&value, value_str, sizeof(value_str), + SDB_SINGLE_QUOTED) < 0) + snprintf(value_str, sizeof(value_str), "ERR"); + snprintf(buf, buflen, "%s[%s]{ %s %s }", type, id, + MATCHER_SYM(m->type), value_str); + sdb_data_free_datum(&value); return buf; } /* cond_tostring */ @@ -558,6 +731,42 @@ op_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen) return buf; } /* op_tostring */ +static int +cmp_matcher_init(sdb_object_t *obj, va_list ap) +{ + M(obj)->type = va_arg(ap, int); + + CMP_M(obj)->left = va_arg(ap, sdb_store_expr_t *); + sdb_object_ref(SDB_OBJ(CMP_M(obj)->left)); + CMP_M(obj)->right = va_arg(ap, sdb_store_expr_t *); + sdb_object_ref(SDB_OBJ(CMP_M(obj)->right)); + + if ((! CMP_M(obj)->left) || (! CMP_M(obj)->right)) + return -1; + return 0; +} /* cmp_matcher_init */ + +static void +cmp_matcher_destroy(sdb_object_t *obj) +{ + sdb_object_deref(SDB_OBJ(CMP_M(obj)->left)); + sdb_object_deref(SDB_OBJ(CMP_M(obj)->right)); +} /* cmp_matcher_destroy */ + +static char * +cmp_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen) +{ + if (! m) { + /* this should not happen */ + snprintf(buf, buflen, "()"); + return buf; + } + + /* TODO */ + snprintf(buf, buflen, "CMP_MATCHER(%d)", m->type); + return buf; +} /* cmp_tostring */ + static int uop_matcher_init(sdb_object_t *obj, va_list ap) { @@ -660,6 +869,12 @@ static sdb_type_t uop_type = { /* destroy = */ uop_matcher_destroy, }; +static sdb_type_t cmp_type = { + /* size = */ sizeof(cmp_matcher_t), + /* init = */ cmp_matcher_init, + /* destroy = */ cmp_matcher_destroy, +}; + static sdb_type_t isnull_type = { /* size = */ sizeof(isnull_matcher_t), /* init = */ isnull_matcher_init, @@ -682,6 +897,11 @@ matchers_tostring[] = { cond_tostring, cond_tostring, cond_tostring, + cmp_tostring, + cmp_tostring, + cmp_tostring, + cmp_tostring, + cmp_tostring, isnull_tostring, }; @@ -696,6 +916,13 @@ sdb_store_attr_cond(const char *name, sdb_store_expr_t *expr) name, expr)); } /* sdb_store_attr_cond */ +sdb_store_cond_t * +sdb_store_obj_cond(int field, sdb_store_expr_t *expr) +{ + return SDB_STORE_COND(sdb_object_create("obj-cond", obj_cond_type, + field, expr)); +} /* sdb_store_obj_cond */ + sdb_store_matcher_t * sdb_store_name_matcher(int type, const char *name, _Bool re) { @@ -765,6 +992,46 @@ sdb_store_gt_matcher(sdb_store_cond_t *cond) MATCHER_GT, cond)); } /* sdb_store_gt_matcher */ +/* + * TODO: Rename sdb_store_cmp_* to sdb_store_* once the old code is unused and + * has been removed. + */ + +sdb_store_matcher_t * +sdb_store_cmp_lt(sdb_store_expr_t *left, sdb_store_expr_t *right) +{ + return M(sdb_object_create("lt-matcher", cmp_type, + MATCHER_CMP_LT, left, right)); +} /* sdb_store_cmp_lt */ + +sdb_store_matcher_t * +sdb_store_cmp_le(sdb_store_expr_t *left, sdb_store_expr_t *right) +{ + return M(sdb_object_create("le-matcher", cmp_type, + MATCHER_CMP_LE, left, right)); +} /* sdb_store_cmp_le */ + +sdb_store_matcher_t * +sdb_store_cmp_eq(sdb_store_expr_t *left, sdb_store_expr_t *right) +{ + return M(sdb_object_create("eq-matcher", cmp_type, + MATCHER_CMP_EQ, left, right)); +} /* sdb_store_cmp_eq */ + +sdb_store_matcher_t * +sdb_store_cmp_ge(sdb_store_expr_t *left, sdb_store_expr_t *right) +{ + return M(sdb_object_create("ge-matcher", cmp_type, + MATCHER_CMP_GE, left, right)); +} /* sdb_store_cmp_ge */ + +sdb_store_matcher_t * +sdb_store_cmp_gt(sdb_store_expr_t *left, sdb_store_expr_t *right) +{ + return M(sdb_object_create("gt-matcher", cmp_type, + MATCHER_CMP_GT, left, right)); +} /* sdb_store_cmp_gt */ + sdb_store_matcher_t * sdb_store_isnull_matcher(const char *attr_name) { @@ -772,6 +1039,72 @@ sdb_store_isnull_matcher(const char *attr_name) MATCHER_ISNULL, attr_name)); } /* sdb_store_isnull_matcher */ +int +sdb_store_parse_object_type_plural(const char *name) +{ + if (! strcasecmp(name, "hosts")) + return SDB_HOST; + else if (! strcasecmp(name, "services")) + return SDB_SERVICE; + else if (! strcasecmp(name, "metrics")) + return SDB_METRIC; + return -1; +} /* sdb_store_parse_object_type_plural */ + +int +sdb_store_parse_field_name(const char *name) +{ + if (! strcasecmp(name, "name")) + return SDB_FIELD_NAME; + else if (! strcasecmp(name, "last_update")) + return SDB_FIELD_LAST_UPDATE; + else if (! strcasecmp(name, "age")) + return SDB_FIELD_AGE; + else if (! strcasecmp(name, "interval")) + return SDB_FIELD_INTERVAL; + else if (! strcasecmp(name, "backend")) + return SDB_FIELD_BACKEND; + return -1; +} /* sdb_store_parse_field_name */ + +static sdb_store_matcher_t * +maybe_inv_matcher(sdb_store_matcher_t *m, _Bool inv) +{ + sdb_store_matcher_t *tmp; + + if ((! m) || (! inv)) + return m; + + tmp = sdb_store_inv_matcher(m); + /* pass ownership to the inverse matcher */ + sdb_object_deref(SDB_OBJ(m)); + return tmp; +} /* maybe_inv_matcher */ + +static int +parse_cond_op(const char *op, + sdb_store_matcher_t *(**matcher)(sdb_store_cond_t *), _Bool *inv) +{ + *inv = 0; + if (! strcasecmp(op, "<")) + *matcher = sdb_store_lt_matcher; + else if (! strcasecmp(op, "<=")) + *matcher = sdb_store_le_matcher; + else if (! strcasecmp(op, "=")) + *matcher = sdb_store_eq_matcher; + else if (! strcasecmp(op, ">=")) + *matcher = sdb_store_ge_matcher; + else if (! strcasecmp(op, ">")) + *matcher = sdb_store_gt_matcher; + else if (! strcasecmp(op, "!=")) { + *matcher = sdb_store_eq_matcher; + *inv = 1; + } + else + return -1; + return 0; +} /* parse_cond_op */ + static sdb_store_matcher_t * parse_attr_cmp(const char *attr, const char *op, sdb_store_expr_t *expr) { @@ -791,21 +1124,7 @@ parse_attr_cmp(const char *attr, const char *op, sdb_store_expr_t *expr) } else if (! expr) return NULL; - else if (! strcasecmp(op, "<")) - matcher = sdb_store_lt_matcher; - else if (! strcasecmp(op, "<=")) - matcher = sdb_store_le_matcher; - else if (! strcasecmp(op, "=")) - matcher = sdb_store_eq_matcher; - else if (! strcasecmp(op, ">=")) - matcher = sdb_store_ge_matcher; - else if (! strcasecmp(op, ">")) - matcher = sdb_store_gt_matcher; - else if (! strcasecmp(op, "!=")) { - matcher = sdb_store_eq_matcher; - inv = 1; - } - else + else if (parse_cond_op(op, &matcher, &inv)) return NULL; cond = sdb_store_attr_cond(attr, expr); @@ -815,17 +1134,7 @@ parse_attr_cmp(const char *attr, const char *op, sdb_store_expr_t *expr) m = matcher(cond); /* pass ownership to 'm' or destroy in case of an error */ sdb_object_deref(SDB_OBJ(cond)); - if (! m) - return NULL; - - if (inv) { - sdb_store_matcher_t *tmp; - tmp = sdb_store_inv_matcher(m); - /* pass ownership to the inverse matcher */ - sdb_object_deref(SDB_OBJ(m)); - m = tmp; - } - return m; + return maybe_inv_matcher(m, inv); } /* parse_attr_cmp */ sdb_store_matcher_t * @@ -843,6 +1152,8 @@ sdb_store_matcher_parse_cmp(const char *obj_type, const char *attr, type = SDB_HOST; else if (! strcasecmp(obj_type, "service")) type = SDB_SERVICE; + else if (! strcasecmp(obj_type, "metric")) + type = SDB_METRIC; else if (! strcasecmp(obj_type, "attribute")) type = SDB_ATTRIBUTE; else @@ -870,10 +1181,11 @@ sdb_store_matcher_parse_cmp(const char *obj_type, const char *attr, if (! expr) return NULL; - if (sdb_store_expr_eval(expr, &value)) - return NULL; - if (value.type != SDB_TYPE_STRING) { + if (sdb_store_expr_eval(expr, /* obj */ NULL, &value, /* filter */ NULL) + || (value.type != SDB_TYPE_STRING)) { sdb_data_free_datum(&value); + if (type != SDB_ATTRIBUTE) + return NULL; return parse_attr_cmp(attr, op, expr); } @@ -883,19 +1195,39 @@ sdb_store_matcher_parse_cmp(const char *obj_type, const char *attr, m = sdb_store_attr_matcher(attr, value.data.string, re); sdb_data_free_datum(&value); + return maybe_inv_matcher(m, inv); +} /* sdb_store_matcher_parse_cmp */ - if (! m) +sdb_store_matcher_t * +sdb_store_matcher_parse_field_cmp(const char *name, const char *op, + sdb_store_expr_t *expr) +{ + sdb_store_matcher_t *(*matcher)(sdb_store_cond_t *) = NULL; + sdb_store_matcher_t *m; + sdb_store_cond_t *cond; + _Bool inv = 0; + + int field; + + if (! expr) return NULL; - if (inv) { - sdb_store_matcher_t *tmp; - tmp = sdb_store_inv_matcher(m); - /* pass ownership to the inverse matcher */ - sdb_object_deref(SDB_OBJ(m)); - m = tmp; - } - return m; -} /* sdb_store_matcher_parse_cmp */ + field = sdb_store_parse_field_name(name); + if (field < 0) + return NULL; + + if (parse_cond_op(op, &matcher, &inv)) + return NULL; + cond = sdb_store_obj_cond(field, expr); + if (! cond) + return NULL; + + assert(matcher); + m = matcher(cond); + /* pass ownership to 'm' or destroy in case of an error */ + sdb_object_deref(SDB_OBJ(cond)); + return maybe_inv_matcher(m, inv); +} /* sdb_store_matcher_parse_field_cmp */ sdb_store_matcher_t * sdb_store_dis_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right)