/** The watcher-set command */ int cmd_watcher_set (int argc, const char *argv[]) { if (OPTIONS.tenant[0] == 0) { fprintf (stderr, "%% No tenantid provided\n"); return 1; } if (OPTIONS.meter[0] == 0) { fprintf (stderr, "%% No meter provided\n"); return 1; } if (OPTIONS.match[0] == 0) { fprintf (stderr, "%% No match provided\n"); return 1; } if (OPTIONS.value[0] == 0) { fprintf (stderr, "%% No value provided\n"); return 1; } var *mdef = api_get ("/%s/meter", OPTIONS.tenant); if (! mdef) return 1; var *mdef_m = var_get_dict_forkey (mdef, "meter"); var *mde_meter = var_get_dict_forkey (mdef_m, OPTIONS.meter); const char *inftype = var_get_str_forkey (mde_meter, "type"); var *req = var_alloc(); var *req_watcher = var_get_dict_forkey (req, "watcher"); var *reql = var_get_dict_forkey (req_watcher, OPTIONS.level); if (OPTIONS.host[0] == 0) { var_set_str_forkey (reql, "cmp", OPTIONS.match); } if (strcmp (inftype, "integer") == 0) { var_set_int_forkey (reql, "val", strtoull (OPTIONS.value, NULL, 10)); } else if (strcmp (inftype, "frac") == 0) { var_set_double_forkey (reql, "val", atof (OPTIONS.value)); } else { var_set_str_forkey (reql, "val", OPTIONS.value); } var_set_double_forkey (reql, "weight", atof (OPTIONS.weight)); var *apires; if (OPTIONS.host[0]) { apires = api_call ("POST", req, "/%s/host/%s/watcher/%s", OPTIONS.tenant, OPTIONS.host, OPTIONS.meter); } else { apires = api_call ("POST", req, "/%s/watcher/%s", OPTIONS.tenant, OPTIONS.meter); } var_free (mdef); var_free (req); var_free (apires); return 0; }
void host_to_overview (host *h, var *ovdict) { char mid[16]; char uuidstr[40]; uuid2str (h->uuid, uuidstr); var *res = var_get_dict_forkey (ovdict, uuidstr); meter *m = h->first; while (m) { if (m->count >= SZ_EMPTY_VAL) { m = m->next; continue; } id2str (m->id, mid); if ((strncmp (mid, "top/", 4) == 0) || (strncmp (mid, "df/", 3) == 0) || (strncmp (mid, "proc/", 5) == 0) || (strncmp (mid, "os/", 3) == 0) || (strncmp (mid, "who/", 4) == 0)) { m = m->next; continue; } switch (m->id & MMASK_TYPE) { case MTYPE_INT: var_set_int_forkey (res, mid, meter_get_uint (m, 0)); break; case MTYPE_FRAC: var_set_double_forkey (res, mid, meter_get_frac (m, 0)); break; case MTYPE_STR: var_set_str_forkey (res, mid, m->d.str[0].str); break; default: break; } m = m->next; } }
int main (int argc, const char *argv[]) { const char *tstr = NULL; var *env = var_alloc(); var *env_collector = var_get_dict_forkey (env, "collector"); var *env_colors = var_get_array_forkey (env, "colors"); var_set_int_forkey (env_collector, "listenport", 3333); var_set_str_forkey (env_collector, "address", "127.0.0.1"); var_set_str_forkey (env_collector, "key", "secret"); var_clear_array (env_colors); var_add_str (env_colors, "red"); var_add_str (env_colors, "green"); var_add_str (env_colors, "blue"); assert (var_get_int_forkey (env_collector, "listenport") == 3333); assert (tstr = var_get_str_forkey (env_collector, "address")); assert (strcmp (tstr, "127.0.0.1") == 0); assert (tstr = var_get_str_forkey (env_collector, "key")); assert (strcmp (tstr, "secret") == 0); assert (var_get_count (env_collector) == 3); assert (tstr = var_get_str_atindex (env_colors, 0)); assert (strcmp (tstr, "red") == 0); assert (tstr = var_get_str_atindex (env_colors, 1)); assert (strcmp (tstr, "green") == 0); assert (tstr = var_get_str_atindex (env_colors, 2)); assert (strcmp (tstr, "blue") == 0); time_t tnow = time (NULL); var_set_time_forkey (env, "nowtime", tnow); assert (var_get_time_forkey (env, "nowtime") == tnow); var_set_unixtime_forkey (env, "unixtime", tnow); assert (var_get_time_forkey (env, "unixtime") == tnow); uuid uuid_in = uuidgen(); var_set_uuid_forkey (env, "myuuid", uuid_in); uuid uuid_out = var_get_uuid_forkey (env, "myuuid"); assert (uuidcmp (uuid_in, uuid_out)); var_new_generation (env); var_set_int_forkey (env_collector, "listenport", 3333); var_set_str_forkey (env_collector, "address", "192.168.1.1"); var_clear_array (env_colors); var_add_str (env_colors, "red"); var_add_str (env_colors, "green"); var_add_str (env_colors, "blue"); var *lport, *addr, *key; lport = var_find_key (env_collector, "listenport"); addr = var_find_key (env_collector, "address"); key = var_find_key (env_collector, "key"); assert (lport); assert (addr); assert (key); /* collector.listenport should be unchanged from first generation */ assert (lport->generation == env->generation); assert (lport->lastmodified < env->generation); assert (lport->firstseen == lport->lastmodified); /* collector.addr should be changed this generation */ assert (addr->generation == env->generation); assert (addr->lastmodified == env->generation); assert (addr->firstseen == env->firstseen); /* colors should be changed this generation */ assert (env_colors->generation == env->generation); assert (env_colors->lastmodified == env->generation); assert (env_colors->firstseen == env->firstseen); /* collector.key should be stale */ assert (key->generation < env->generation); var_clean_generation (env); /* collector.key should now be deleted */ key = var_find_key (env_collector, "key"); assert (key == NULL); return 0; }
/** Internal state machine for parsing a JSON-like configuration * text. Recurses on itself for new levels of hierarchy. * \param v The var at this cursor level. * \param buf The cursor (inout) * \param st The state to start out with. */ static int var_parse_json_level (var *v, const char **buf, parse_state st, int depth) { if (depth > default_max_json_depth) { sprintf (LAST_PARSE_ERROR, "Nested to deep"); return 0; } const char *c = *buf; var *vv = NULL; char keybuf[4096]; int keybuf_pos = 0; char valuebuf[4096]; int valuebuf_pos = 0; int value_nondigits = 0; int value_dots = 0; parse_state stnext; while (*c) { switch (st) { case PSTATE_BEGINNING: if (*c == '{') { st = PSTATE_DICT_WAITKEY; break; } /* intentional fall-through */ case PSTATE_DICT_WAITKEY: if (*c == '#') { stnext = st; st = PSTATE_COMMENT; break; } if (isspace (*c)) break; if (*c == ',') break; if (*c == '}') { *buf = c; return 1; } if (*c == '\"') st = PSTATE_DICT_KEY_QUOTED; else { if (! strchr (VALIDUNQUOTED, *c)) { sprintf (LAST_PARSE_ERROR, "Invalid char for " "key: '%c'", *c); return 0; } --c; st = PSTATE_DICT_KEY; } keybuf_pos = 0; keybuf[0] = 0; valuebuf_pos = 0; valuebuf[0] = 0; break; case PSTATE_DICT_KEY: if (*c == '#') { stnext = PSTATE_DICT_WAITVALUE; st = PSTATE_COMMENT; break; } if (isspace (*c)) { st = PSTATE_DICT_WAITVALUE; break; } if (*c == '{') { *buf = c+1; vv = var_get_dict_forkey (v, keybuf); if (! vv) { sprintf (LAST_PARSE_ERROR, "Couldn't get dict " "for key '%s'", keybuf); return 0; } if (!var_parse_json_level (vv, buf, PSTATE_DICT_WAITKEY, depth+1)) { return 0; } c = *buf; st = PSTATE_DICT_WAITKEY; break; } if (*c == '[') { *buf = c+1; vv = var_get_array_forkey (v, keybuf); if (! vv) { sprintf (LAST_PARSE_ERROR, "Couldn't get array " "for key '%s'", keybuf); return 0; } var_clear_array (vv); if (!var_parse_json_level (vv, buf, PSTATE_ARRAY_WAITVALUE, depth+1)) { return 0; } c = *buf; st = PSTATE_DICT_WAITKEY; break; } if (*c == ':') { st = PSTATE_DICT_WAITVALUE; break; } if (! strchr (VALIDUNQUOTED, *c)) { sprintf (LAST_PARSE_ERROR, "Invalid character in " "value '%c'", *c); return 0; } if (keybuf_pos >= 4095) return 0; keybuf[keybuf_pos++] = *c; keybuf[keybuf_pos] = 0; break; case PSTATE_DICT_KEY_QUOTED: if (*c == '\"') { st = PSTATE_DICT_WAITVALUE; break; } if (*c == '\\') ++c; if (keybuf_pos >= 4095) return 0; keybuf[keybuf_pos++] = *c; keybuf[keybuf_pos] = 0; break; case PSTATE_DICT_WAITVALUE: if (*c == '#') { stnext = st; st = PSTATE_COMMENT; break; } if (isspace (*c)) break; if (*c == ':') break; if (*c == '=') break; if (*c == '{') { *buf = c+1; vv = var_get_dict_forkey (v, keybuf); if (! vv) { sprintf (LAST_PARSE_ERROR, "Couldn't get dict for " "key '%s'", keybuf); return 0; } if (!var_parse_json_level (vv, buf, PSTATE_DICT_WAITKEY, depth+1)) { return 0; } c = *buf; st = PSTATE_DICT_WAITKEY; break; } if (*c == '[') { *buf = c+1; vv = var_get_array_forkey (v, keybuf); if (! vv) { sprintf (LAST_PARSE_ERROR, "Couldn't get array " "for key '%s'", keybuf); return 0; } var_clear_array (vv); if (!var_parse_json_level (vv, buf, PSTATE_ARRAY_WAITVALUE, depth+1)) { return 0; } c = *buf; st = PSTATE_DICT_WAITKEY; break; } if (*c == '\"') { st = PSTATE_DICT_VALUE_QUOTED; } else { if (! strchr (VALIDUNQUOTEDV, *c)) { sprintf (LAST_PARSE_ERROR, "Invalid character for " "value: '%c'", *c); return 0; } --c; value_nondigits = 0; value_dots = 0; st = PSTATE_DICT_VALUE; } valuebuf_pos = 0; valuebuf[0] = 0; break; case PSTATE_DICT_VALUE: if (isspace (*c) || (*c == ',') || (*c == '}') || (*c == '#')) { if ((! value_nondigits) && (value_dots < 2)) { if (value_dots == 0) { var_set_int_forkey (v, keybuf, strtoull(valuebuf, NULL, 10)); } else { var_set_double_forkey (v, keybuf, atof(valuebuf)); } } else var_set_str_forkey (v, keybuf, valuebuf); if (*c == '#') { stnext = PSTATE_DICT_WAITKEY; st = PSTATE_COMMENT; break; } if (*c == '}') { *buf = c; return 1; } st = PSTATE_DICT_WAITKEY; break; } if (! strchr (VALIDUNQUOTEDV, *c)) { sprintf (LAST_PARSE_ERROR, "Invalid character in " "value for '%s': '%c'", keybuf, *c); return 0; } if (*c == '.') value_dots++; else if ((!value_nondigits) && (*c<'0' || *c>'9')) { value_nondigits = 1; } if (valuebuf_pos >= 4095) return 0; valuebuf[valuebuf_pos++] = *c; valuebuf[valuebuf_pos] = 0; break; case PSTATE_DICT_VALUE_QUOTED: if (*c == '\"') { var_set_str_forkey (v, keybuf, valuebuf); st = PSTATE_DICT_WAITKEY; break; } if (*c == '\\') ++c; if (valuebuf_pos >= 4095) return 0; valuebuf[valuebuf_pos++] = *c; valuebuf[valuebuf_pos] = 0; break; case PSTATE_ARRAY_WAITVALUE: if (*c == '#') { stnext = st; st = PSTATE_COMMENT; break; } if (isspace (*c)) break; if (*c == ',') break; if (*c == ']') { *buf = c; return 1; } if (*c == '{') { *buf = c+1; vv = var_add_dict (v); if (! vv) { sprintf (LAST_PARSE_ERROR, "Couldn't add dict"); return 0; } if (!var_parse_json_level (vv, buf, PSTATE_DICT_WAITKEY, depth+1)) { return 0; } c = *buf; st = PSTATE_ARRAY_WAITVALUE; break; } if (*c == '[') { *buf = c+1; vv = var_add_array (v); if (! vv) { sprintf (LAST_PARSE_ERROR, "Couldn't add array"); return 0; } var_clear_array (vv); if (!var_parse_json_level (vv, buf, PSTATE_ARRAY_WAITVALUE, depth+1)) { return 0; } c = *buf; st = PSTATE_ARRAY_WAITVALUE; break; } if (*c == '\"') { st = PSTATE_ARRAY_VALUE_QUOTED; } else { if (! strchr (VALIDUNQUOTED, *c)) return 0; --c; value_nondigits = 0; value_dots = 0; st = PSTATE_ARRAY_VALUE; } valuebuf_pos = 0; valuebuf[0] = 0; break; case PSTATE_ARRAY_VALUE: if (isspace (*c) || (*c == ']') || (*c == ',') || (*c == '#')) { if ((! value_nondigits) && (value_dots<2)) { if (value_dots == 0) { var_add_int (v, strtoull (valuebuf, NULL, 10)); } else { var_add_double (v, atof (valuebuf)); } } else var_add_str (v, valuebuf); if (*c == '#') { stnext = PSTATE_ARRAY_WAITVALUE; st = PSTATE_COMMENT; break; } if (*c == ']') { *buf = c; return 1; } st = PSTATE_ARRAY_WAITVALUE; break; } if (! strchr (VALIDUNQUOTEDV, *c)) return 0; if (*c == '.') value_dots++; else if ((!value_nondigits) && (*c<'0' || *c>'9')) { value_nondigits = 1; } if (valuebuf_pos >= 4095) return 0; valuebuf[valuebuf_pos++] = *c; valuebuf[valuebuf_pos] = 0; break; case PSTATE_ARRAY_VALUE_QUOTED: if (*c == '\"') { var_add_str (v, valuebuf); st = PSTATE_ARRAY_WAITVALUE; break; } if (*c == '\\') ++c; if (valuebuf_pos >= 4095) return 0; valuebuf[valuebuf_pos++] = *c; valuebuf[valuebuf_pos] = 0; break; case PSTATE_COMMENT: if (*c == '\n') { st = stnext; } break; } ++c; *buf = c; } return 1; }