void
noit_filters_from_conf() {
noit_conf_section_t *sets;
int i, cnt;
sets = noit_conf_get_sections(NULL, "/noit/filtersets//filterset", &cnt);
for(i=0; i<cnt; i++) {
noit_filter_compile_add(sets[i]);
}
free(sets);
}
void
noit_filters_from_conf() {
mtev_conf_section_t *sets;
int i, cnt;
sets = mtev_conf_get_sections(NULL, "/noit/filtersets//filterset", &cnt);
for(i=0; i<cnt; i++) {
mtev_watchdog_child_heartbeat();
noit_filter_compile_add(sets[i]);
}
free(sets);
}
static int
noit_console_rule_configure(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state,
void *closure) {
xmlNodePtr fsnode = NULL;
noit_conf_t_userdata_t *info;
char xpath[1024];
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
snprintf(xpath, sizeof(xpath), "/%s",
info->path);
fsnode = noit_conf_get_section(NULL, xpath);
if(!fsnode) {
nc_printf(ncct, "internal error");
return -1;
}
if(closure) {
int rulenum;
xmlNodePtr byebye;
/* removing a rule */
if(argc != 1) {
nc_printf(ncct, "requires one argument\n");
return -1;
}
rulenum = atoi(argv[0]);
snprintf(xpath, sizeof(xpath), "rule[%d]", rulenum);
byebye = noit_conf_get_section(fsnode, xpath);
if(!byebye) {
nc_printf(ncct, "cannot find rule\n");
return -1;
}
xmlUnlinkNode(byebye);
xmlFreeNode(byebye);
nc_printf(ncct, "removed\n");
}
else {
xmlNodePtr (*add_func)(xmlNodePtr, xmlNodePtr);
xmlNodePtr add_arg, new_rule;
int i, needs_type = 1;
if(argc < 1 || argc % 2) {
nc_printf(ncct, "even number of arguments required\n");
return -1;
}
if(!strcmp(argv[0], "before") || !strcmp(argv[0], "after")) {
int rulenum = atoi(argv[1]);
snprintf(xpath, sizeof(xpath), "rule[%d]", rulenum);
add_arg = noit_conf_get_section(fsnode, xpath);
if(!add_arg) {
nc_printf(ncct, "%s rule not found\n", xpath);
return -1;
}
if(*argv[0] == 'b') add_func = xmlAddPrevSibling;
else add_func = xmlAddNextSibling;
argc -= 2;
argv += 2;
}
else {
add_func = xmlAddChild;
add_arg = fsnode;
}
for(i=0;i<argc;i+=2) {
if(!strcmp(argv[i], "type")) needs_type = 0;
else if(strcmp(argv[i], "target") && strcmp(argv[i], "module") &&
strcmp(argv[i], "name") && strcmp(argv[i], "metric")) {
nc_printf(ncct, "unknown attribute '%s'\n", argv[i]);
return -1;
}
}
if(needs_type) {
nc_printf(ncct, "type <allow|deny> is required\n");
return -1;
}
new_rule = xmlNewNode(NULL, (xmlChar *)"rule");
for(i=0;i<argc;i+=2)
xmlSetProp(new_rule, (xmlChar *)argv[i], (xmlChar *)argv[i+1]);
add_func(add_arg, new_rule);
noit_filter_compile_add((noit_conf_section_t *)fsnode);
}
return 0;
}
static int
rest_set_filter(noit_http_rest_closure_t *restc,
int npats, char **pats) {
noit_http_session_ctx *ctx = restc->http_ctx;
xmlDocPtr doc = NULL, indoc = NULL;
xmlNodePtr node, parent, root, newfilter;
char xpath[1024];
int error_code = 500, complete = 0, mask = 0;
const char *error = "internal error";
if(npats != 2) goto error;
indoc = rest_get_xml_upload(restc, &mask, &complete);
if(!complete) return mask;
if(indoc == NULL) FAIL("xml parse error");
snprintf(xpath, sizeof(xpath), "//filtersets%sfilterset[@name=\"%s\"]",
pats[0], pats[1]);
node = noit_conf_get_section(NULL, xpath);
if(!node && noit_filter_exists(pats[1])) {
/* It's someone else's */
error_code = 403;
goto error;
}
if((newfilter = validate_filter_post(indoc)) == NULL) goto error;
xmlSetProp(newfilter, (xmlChar *)"name", (xmlChar *)pats[1]);
parent = make_conf_path(pats[0]);
if(!parent) FAIL("invalid path");
if(node) {
xmlUnlinkNode(node);
xmlFreeNode(node);
}
xmlUnlinkNode(newfilter);
xmlAddChild(parent, newfilter);
CONF_DIRTY(newfilter);
noit_conf_mark_changed();
if(noit_conf_write_file(NULL) != 0)
noitL(noit_error, "local config write failed\n");
noit_filter_compile_add(newfilter);
if(restc->call_closure_free) restc->call_closure_free(restc->call_closure);
restc->call_closure_free = NULL;
restc->call_closure = NULL;
restc->fastpath = rest_show_filter;
return restc->fastpath(restc, restc->nparams, restc->params);
error:
noit_http_response_standard(ctx, error_code, "ERROR", "text/html");
doc = xmlNewDoc((xmlChar *)"1.0");
root = xmlNewDocNode(doc, NULL, (xmlChar *)"error", NULL);
xmlDocSetRootElement(doc, root);
xmlNodeAddContent(root, (xmlChar *)error);
noit_http_response_xml(ctx, doc);
noit_http_response_end(ctx);
goto cleanup;
cleanup:
if(doc) xmlFreeDoc(doc);
return 0;
}
int
noit_filtersets_cull_unused() {
mtev_hash_table active = MTEV_HASH_EMPTY;
char *buffer = NULL;
mtev_conf_section_t *declares;
int i, n_uses = 0, n_declares = 0, removed = 0;
const char *declare_xpath = "//filterset[@name and not (@cull='false')]";
declares = mtev_conf_get_sections(NULL, declare_xpath, &n_declares);
if(declares) {
/* store all unit filtersets used */
for(i=0;i<n_declares;i++) {
if(!buffer) buffer = malloc(128);
if(mtev_conf_get_stringbuf(declares[i], "@name", buffer, 128)) {
if(mtev_hash_store(&active, buffer, strlen(buffer), declares[i])) {
buffer = NULL;
}
else {
void *vnode = NULL;
/* We've just hit a duplicate.... check to see if there's an existing
* entry and if there is, load the latest one and delete the old
* one. */
mtev_hash_retrieve(&active, buffer, strlen(buffer), &vnode);
if (vnode) {
noit_filter_compile_add(declares[i]);
CONF_REMOVE(vnode);
xmlUnlinkNode(vnode);
xmlFreeNode(vnode);
removed++;
if(mtev_hash_replace(&active, buffer, strlen(buffer), declares[i], free, NULL)) {
buffer = NULL;
}
}
}
}
}
if(buffer) free(buffer);
free(declares);
}
n_uses = noit_poller_do(filterset_accum, &active);
if(n_uses > 0 && mtev_hash_size(&active) > 0) {
mtev_hash_iter iter = MTEV_HASH_ITER_ZERO;
const char *filter_name;
int filter_name_len;
void *vnode;
while(mtev_hash_next(&active, &iter, &filter_name, &filter_name_len,
&vnode)) {
if(noit_filter_remove(vnode)) {
CONF_REMOVE(vnode);
xmlUnlinkNode(vnode);
xmlFreeNode(vnode);
removed++;
}
}
}
mtev_hash_destroy(&active, free, NULL);
return removed;
}
