int registry_uid_assign(struct registry_instance *instance, char* uid) { registry_lock(); struct registry_param *p; for (p = instance->params; p && strcmp(p->name, "uid"); p = p->next); if (!p) { pomlog(POMLOG_ERR "Could not find the uid parameter"); registry_unlock(); return POM_ERR; } uint32_t old_uid = *PTYPE_UINT32_GETVAL(p->value); if (ptype_parse_val(p->value, uid) != POM_OK) { pomlog(POMLOG_ERR "Could not parse the new uid"); registry_unlock(); return POM_ERR; } uint32_t new_uid = *PTYPE_UINT32_GETVAL(p->value); size_t i; for (i = 0; registry_uid_table[i] != old_uid && i < registry_uid_table_size; i++); if (i < registry_uid_table_size) { registry_uid_table[i] = new_uid; } registry_unlock(); return POM_OK; }
int registry_set_param(struct registry_instance *i, char *param, char* value) { registry_lock(); struct registry_param *p; for (p = i->params; p && strcmp(p->name, param); p = p->next); if (!p) { registry_unlock(); pomlog(POMLOG_ERR "Parameter %s doesn't exists for registry instance %s", param, i->name); return POM_ERR; } if (p->flags & REGISTRY_PARAM_FLAG_IMMUTABLE) { registry_unlock(); pomlog(POMLOG_ERR "Cannot change parameter %s for instance %s as it's marked immutable", param, i->name); return POM_ERR; } if (registry_set_param_value(p, value) != POM_OK) { registry_unlock(); return POM_ERR; } i->serial++; i->parent->serial++; registry_classes_serial_inc(); registry_unlock(); return POM_OK; }
// the main method for searching the URLs of a netdata int registry_request_search_json(RRDHOST *host, struct web_client *w, char *person_guid, char *machine_guid, char *url, char *request_machine, time_t when) { if(!registry.enabled) return registry_json_disabled(host, w, "search"); registry_lock(); REGISTRY_MACHINE *m = registry_request_machine(person_guid, machine_guid, url, request_machine, when); if(!m) { registry_json_header(host, w, "search", REGISTRY_STATUS_FAILED); registry_json_footer(w); registry_unlock(); return 404; } registry_json_header(host, w, "search", REGISTRY_STATUS_OK); buffer_strcat(w->response.data, ",\n\t\"urls\": ["); struct registry_json_walk_person_urls_callback c = { NULL, m, w, 0 }; dictionary_get_all(m->machine_urls, registry_json_machine_url_callback, &c); buffer_strcat(w->response.data, "\n\t]\n"); registry_json_footer(w); registry_unlock(); return 200; }
int registry_remove_instance_type(struct registry_class *c, char *name) { struct registry_instance_type *type; registry_lock(); for (type = c->types; type && strcmp(type->name, name); type = type->next); if (!type) { registry_unlock(); pomlog(POMLOG_ERR "Registry instance type %s not found in class %s", name, c->name); return POM_ERR; } if (type->next) type->next->prev = type->prev; if (type->prev) type->prev->next = type->next; else c->types = type->next; registry_unlock(); free(type->name); free(type); return POM_OK; }
int registry_add_instance_type(struct registry_class *c, char *name) { struct registry_instance_type *type = malloc(sizeof(struct registry_instance_type)); if (!type) { pom_oom(sizeof(struct registry_instance_type)); return POM_ERR; } memset(type, 0, sizeof(struct registry_instance_type)); type->name = strdup(name); if (!type->name) { free(type); pom_oom(strlen(name) + 1); return POM_ERR; } registry_lock(); type->next = c->types; if (type->next) type->next->prev = type; c->types = type; registry_unlock(); return POM_OK; }
// the main method for registering an access int registry_request_access_json(RRDHOST *host, struct web_client *w, char *person_guid, char *machine_guid, char *url, char *name, time_t when) { if(unlikely(!registry.enabled)) return registry_json_disabled(host, w, "access"); // ------------------------------------------------------------------------ // verify the browser supports cookies if(registry.verify_cookies_redirects > 0 && !person_guid[0]) { buffer_flush(w->response.data); registry_set_cookie(w, REGISTRY_VERIFY_COOKIES_GUID); w->response.data->contenttype = CT_APPLICATION_JSON; buffer_sprintf(w->response.data, "{ \"status\": \"redirect\", \"registry\": \"%s\" }", registry.registry_to_announce); return 200; } if(unlikely(person_guid[0] && !strcmp(person_guid, REGISTRY_VERIFY_COOKIES_GUID))) person_guid[0] = '\0'; // ------------------------------------------------------------------------ registry_lock(); REGISTRY_PERSON *p = registry_request_access(person_guid, machine_guid, url, name, when); if(!p) { registry_json_header(host, w, "access", REGISTRY_STATUS_FAILED); registry_json_footer(w); registry_unlock(); return 412; } // set the cookie registry_set_person_cookie(w, p); // generate the response registry_json_header(host, w, "access", REGISTRY_STATUS_OK); buffer_sprintf(w->response.data, ",\n\t\"person_guid\": \"%s\",\n\t\"urls\": [", p->guid); struct registry_json_walk_person_urls_callback c = { p, NULL, w, 0 }; avl_traverse(&p->person_urls, registry_json_person_url_callback, &c); buffer_strcat(w->response.data, "\n\t]\n"); registry_json_footer(w); registry_unlock(); return 200; }
// the main method for deleting a URL from a person int registry_request_delete_json(RRDHOST *host, struct web_client *w, char *person_guid, char *machine_guid, char *url, char *delete_url, time_t when) { if(!registry.enabled) return registry_json_disabled(host, w, "delete"); registry_lock(); REGISTRY_PERSON *p = registry_request_delete(person_guid, machine_guid, url, delete_url, when); if(!p) { registry_json_header(host, w, "delete", REGISTRY_STATUS_FAILED); registry_json_footer(w); registry_unlock(); return 412; } // generate the response registry_json_header(host, w, "delete", REGISTRY_STATUS_OK); registry_json_footer(w); registry_unlock(); return 200; }
struct registry_class* registry_add_class(char *name) { if (!name) return NULL; registry_lock(); struct registry_class *c = registry_head; for (;c && strcmp(c->name, name); c = c->next); if (c) { pomlog(POMLOG_WARN "Cannot add class %s as it already exists", name); registry_unlock(); return NULL; } c = malloc(sizeof(struct registry_class)); if (!c) { pom_oom(sizeof(struct registry_class)); registry_unlock(); return NULL; } memset(c, 0, sizeof(struct registry_class)); c->name = strdup(name); if (!c->name) { registry_unlock(); free(c); pom_oom(strlen(name)); return NULL; } c->next = registry_head; if (c->next) registry_head->prev = c; registry_head = c; registry_unlock(); return c; }
struct registry_perf *registry_instance_add_perf(struct registry_instance *i, const char *name, enum registry_perf_type type, const char *description, const char *unit) { struct registry_perf *p = registry_perf_alloc(name, type, description, unit); if (!p) return NULL; registry_lock(); p->next = i->perfs; i->perfs = p; registry_unlock(); return p; }
int registry_uid_create(struct registry_instance *instance) { registry_lock(); // Find a good uid uint32_t new_uid; do { new_uid = rand_r(®istry_uid_seedp); } while (registry_uid_check(new_uid)); if (registry_uid_add(instance, new_uid) != POM_OK) { registry_unlock(); return POM_ERR; } registry_unlock(); return POM_OK; }
int registry_instance_add_function(struct registry_instance *i, char *name, int (*handler) (struct registry_instance *), char *description) { if (!i || !name || !handler || !description) return POM_ERR; struct registry_function *f = malloc(sizeof(struct registry_function)); if (!f) { pom_oom(sizeof(struct registry_function)); return POM_ERR; } memset(f, 0, sizeof(struct registry_function)); f->name = strdup(name); if (!f->name) { pom_oom(strlen(name)); goto err; } f->description = strdup(description); if (!f->description) { pom_oom(strlen(description)); goto err; } f->handler = handler; registry_lock(); f->next = i->funcs; i->funcs = f; registry_unlock(); return POM_OK; err: if (f->name) free(name); if (f->description) free(f->description); free(f); return POM_ERR; }
int input_stop_all() { registry_lock(); int res = POM_OK; struct input *tmp; for (tmp = input_head; tmp ; tmp = tmp->next) { if (tmp->running == INPUT_RUN_RUNNING) { res += input_stop(tmp); } } registry_unlock(); return (res == POM_OK ? POM_OK : POM_ERR); }
struct registry_instance *registry_add_instance(struct registry_class *c, char *name) { if (!name || !c) return NULL; struct registry_instance *i = malloc(sizeof(struct registry_instance)); if (!i) { pom_oom(sizeof(struct registry_instance)); return NULL; } memset(i, 0, sizeof(struct registry_instance)); i->name = strdup(name); if (!i->name) { free(i); pom_oom(strlen(name)); return NULL; } i->parent = c; registry_lock(); i->next = c->instances; if (i->next) i->next->prev = i; c->instances = i; i->parent->serial++; registry_classes_serial_inc(); registry_unlock(); return i; }
xmlrpc_value *xmlrpccmd_core_serial_poll(xmlrpc_env * const envP, xmlrpc_value * const paramArrayP, void * const userData) { uint32_t last_serial = 0; xmlrpc_decompose_value(envP, paramArrayP, "(i)", &last_serial); if (envP->fault_occurred) return NULL; pom_mutex_lock(&xmlrpccmd_serial_lock); if (last_serial == xmlrpccmd_serial) { // Wait for update if (pthread_cond_wait(&xmlrpccmd_serial_cond, &xmlrpccmd_serial_lock)) { xmlrpc_faultf(envP, "Error while waiting for serial condition : %s", pom_strerror(errno)); abort(); return NULL; } } last_serial = xmlrpccmd_serial; pom_mutex_unlock(&xmlrpccmd_serial_lock); registry_lock(); pomlog_rlock(); struct pomlog_entry *last_log = pomlog_get_tail(); xmlrpc_value *res = xmlrpc_build_value(envP, "{s:i,s:i,s:i}", "main", last_serial, "registry", registry_serial_get(), "log", last_log->id); pomlog_unlock(); registry_unlock(); return res; }
void registry_perf_reset_all() { registry_lock(); struct registry_class *ctmp; for (ctmp = registry_head; ctmp; ctmp = ctmp->next) { struct registry_perf *p; for (p = ctmp->perfs; p; p = p->next) { if (p->type == registry_perf_type_counter) registry_perf_reset(p); } struct registry_instance *inst; for (inst = ctmp->instances; inst; inst = inst->next) { for (p = inst->perfs; p; p = p->next) { if (p->type == registry_perf_type_counter) registry_perf_reset(p); } } } registry_unlock(); }
int registry_instance_add_param(struct registry_instance *i, struct registry_param *p) { if (!i || !p) return POM_ERR; registry_lock(); if (i->params) { // Add at the end struct registry_param *tmp = i->params; while (tmp->next) tmp = tmp->next; tmp->next = p; p->prev = tmp; } else { i->params = p; p->prev = NULL; } p->next = NULL; registry_unlock(); return POM_OK; }
int registry_class_add_param(struct registry_class *c, struct registry_param *p) { if (!c || !p) return POM_ERR; registry_lock(); if (c->global_params) { // Add at the end struct registry_param *tmp = c->global_params; while (tmp->next) tmp = tmp->next; tmp->next = p; p->prev = tmp; } else { c->global_params = p; p->prev = NULL; } p->next = NULL; registry_unlock(); return POM_OK; }
int registry_config_save(char *config_name) { if (strlen(config_name) >= REGISTRY_CONFIG_NAME_MAX) { pomlog(POMLOG_ERR "Configuration name too long, max %u characters.", REGISTRY_CONFIG_NAME_MAX); return POM_ERR; } struct dataset_query *dsq_config_list = NULL, *dsq_config = NULL; struct datastore *sys_dstore = system_datastore(); if (!sys_dstore) return POM_ERR; struct datastore_connection *dc = datastore_connection_new(sys_dstore); if (!dc) return POM_ERR; dsq_config_list = datastore_dataset_query_open(sys_dstore, REGISTRY_CONFIG_LIST, registry_config_list_dataset_template, dc); if (!dsq_config_list) goto err; if (datastore_dataset_query_set_string_condition(dsq_config_list, 0, PTYPE_OP_EQ, config_name) != POM_OK) goto err; dsq_config = datastore_dataset_query_open(sys_dstore, REGISTRY_CONFIG, registry_config_dataset_template, dc); if (!dsq_config) goto err; if (datastore_transaction_begin(dc) != POM_OK) goto err; // Find out if we already have a config by that name int res = datastore_dataset_read_single(dsq_config_list); if (res == DATASET_QUERY_MORE) { // Delete existing stuff about this config if (datastore_dataset_query_set_uint64_condition(dsq_config, 0, PTYPE_OP_EQ, dsq_config_list->data_id) != POM_OK) goto err; if (datastore_dataset_delete(dsq_config_list) != DATASET_QUERY_OK) goto err; if (datastore_dataset_delete(dsq_config) != DATASET_QUERY_OK) goto err; } if (res < 0) goto err; // Add the config to the config list PTYPE_STRING_SETVAL(dsq_config_list->values[0].value, config_name); PTYPE_TIMESTAMP_SETVAL(dsq_config_list->values[1].value, pom_gettimeofday()); if (datastore_dataset_write(dsq_config_list) != DATASET_QUERY_OK) goto err; PTYPE_UINT64_SETVAL(dsq_config->values[0].value, dsq_config_list->data_id); registry_lock(); struct registry_class *cls; // Browse each class for (cls = registry_head; cls; cls = cls->next) { // Browse each instance of the class struct registry_instance *inst; for (inst = cls->instances; inst; inst = inst->next) { // Don't add the instance if it's not added by the user if (cls->instance_add) { // The system datastore will always exist if (inst == sys_dstore->reg_instance) continue; char *buff = malloc(strlen(cls->name) + 1 + strlen(inst->name) + 1); if (!buff) { pom_oom(strlen(cls->name) + 1 + strlen(inst->name) + 1); goto err_locked; } strcpy(buff, cls->name); strcat(buff, "."); strcat(buff, inst->name); PTYPE_STRING_SETVAL_P(dsq_config->values[1].value, buff); struct registry_param *p; for (p = inst->params; p && strcmp(p->name, "type"); p = p->next); if (p) { dsq_config->values[2].is_null = 0; char *type = PTYPE_STRING_GETVAL(p->value); PTYPE_STRING_SETVAL(dsq_config->values[2].value, type); } else { dsq_config->values[2].is_null = 1; } PTYPE_UINT8_SETVAL(dsq_config->values[3].value, registry_config_instance); if (datastore_dataset_write(dsq_config) != DATASET_QUERY_OK) goto err_locked; } // Browse the parametrers and add the non default ones struct registry_param *param; for (param = inst->params; param; param = param->next) { // Check if the parameter value is not the default one anymore if (param->default_value) { struct ptype *defval = ptype_alloc_from(param->value); if (!defval) goto err_locked; if (ptype_parse_val(defval, param->default_value) != POM_OK) { pomlog(POMLOG_ERR "Unable to parse default value !"); ptype_cleanup(defval); goto err_locked; } if (ptype_compare_val(PTYPE_OP_EQ, param->value, defval)) { // Param still has the default value, do nothing ptype_cleanup(defval); continue; } ptype_cleanup(defval); } char *buff = malloc(strlen(cls->name) + 1 + strlen(inst->name) + 1 + strlen(param->name) + 1); if (!buff) { pom_oom(strlen(cls->name) + 1 + strlen(inst->name) + 1 + strlen(param->name) + 1); goto err_locked; } strcpy(buff, cls->name); strcat(buff, "."); strcat(buff, inst->name); strcat(buff, "."); strcat(buff, param->name); PTYPE_STRING_SETVAL_P(dsq_config->values[1].value, buff); char *value = ptype_print_val_alloc(param->value, NULL); if (!value) goto err_locked; dsq_config->values[2].is_null = 0; PTYPE_STRING_SETVAL_P(dsq_config->values[2].value, value); PTYPE_UINT8_SETVAL(dsq_config->values[3].value, registry_config_instance_param); if (datastore_dataset_write(dsq_config) != DATASET_QUERY_OK) goto err_locked; } } } registry_config_serial++; registry_serial++; xmlrcpcmd_serial_inc(); registry_unlock(); if (datastore_transaction_commit(dc) != POM_OK) goto err; datastore_dataset_query_cleanup(dsq_config_list); datastore_dataset_query_cleanup(dsq_config); datastore_connection_release(dc); pomlog("Registry configuration saved as \"%s\"", config_name); return POM_OK; err_locked: registry_unlock(); err: if (dsq_config_list) datastore_dataset_query_cleanup(dsq_config_list); if (dsq_config) datastore_dataset_query_cleanup(dsq_config); if (dc) { datastore_transaction_rollback(dc); datastore_connection_release(dc); } return POM_ERR; }
// the main method for switching user identity int registry_request_switch_json(RRDHOST *host, struct web_client *w, char *person_guid, char *machine_guid, char *url, char *new_person_guid, time_t when) { if(!registry.enabled) return registry_json_disabled(host, w, "switch"); (void)url; (void)when; registry_lock(); REGISTRY_PERSON *op = registry_person_find(person_guid); if(!op) { registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED); registry_json_footer(w); registry_unlock(); return 430; } REGISTRY_PERSON *np = registry_person_find(new_person_guid); if(!np) { registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED); registry_json_footer(w); registry_unlock(); return 431; } REGISTRY_MACHINE *m = registry_machine_find(machine_guid); if(!m) { registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED); registry_json_footer(w); registry_unlock(); return 432; } struct registry_person_url_callback_verify_machine_exists_data data = { m, 0 }; // verify the old person has access to this machine avl_traverse(&op->person_urls, registry_person_url_callback_verify_machine_exists, &data); if(!data.count) { registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED); registry_json_footer(w); registry_unlock(); return 433; } // verify the new person has access to this machine data.count = 0; avl_traverse(&np->person_urls, registry_person_url_callback_verify_machine_exists, &data); if(!data.count) { registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED); registry_json_footer(w); registry_unlock(); return 434; } // set the cookie of the new person // the user just switched identity registry_set_person_cookie(w, np); // generate the response registry_json_header(host, w, "switch", REGISTRY_STATUS_OK); buffer_sprintf(w->response.data, ",\n\t\"person_guid\": \"%s\"", np->guid); registry_json_footer(w); registry_unlock(); return 200; }
int registry_config_reset() { registry_lock(); // Reset the UID table size_t old_uid_table_size = registry_uid_table_size; registry_uid_table_size = 0; struct datastore *sys_dstore = system_datastore(); int restore_sys_dstore = 0; struct registry_class *cls; for (cls = registry_head; cls; cls = cls->next) { /* TODO : registry parameters */ if (cls->instance_remove) { // If we can, remove the instances while (cls->instances) { // Do not remove the system datastore ! if (cls->instances == sys_dstore->reg_instance) { cls->instances = cls->instances->next; if (cls->instances) cls->instances->prev = NULL; restore_sys_dstore = 1; continue; } if (registry_remove_instance(cls->instances) != POM_OK) { // cls->instances might be invalid at this point so don't reference it pomlog(POMLOG_ERR "Unable to remove an instance from class %s", cls->name); if (restore_sys_dstore) { cls->instances = sys_dstore->reg_instance; cls->instances->prev = NULL; cls->instances->next = NULL; restore_sys_dstore = 0; } goto err; } } if (restore_sys_dstore) { cls->instances = sys_dstore->reg_instance; cls->instances->prev = NULL; cls->instances->next = NULL; restore_sys_dstore = 0; } } else { // Else reset all the parameters of each instance struct registry_instance *inst; for (inst = cls->instances; inst; inst = inst->next) { struct registry_param *param; for (param = inst->params; param; param = param->next) { if (registry_set_param_value(param, param->default_value) != POM_OK) { pomlog(POMLOG_ERR "Unable to reset the default value of parameter %s.%s.%s", cls->name, inst->name, param->name); goto err; } } } } } registry_classes_serial_inc(); registry_unlock(); return POM_OK; err: registry_uid_table_size = old_uid_table_size; return POM_ERR; }
int registry_remove_instance(struct registry_instance *i) { if (!i) return POM_ERR; registry_lock(); struct registry_class *c = i->parent; if (c->instance_remove && c->instance_remove(i) != POM_OK) { pomlog(POMLOG_ERR "Error while removing the instance %s from class %s", i->name, c->name); registry_unlock(); return POM_ERR; } free(i->name); while (i->params) { struct registry_param *p = i->params; i->params = p->next; free(p->name); if (p->default_value) free(p->default_value); free(p->description); if (p->flags & REGISTRY_PARAM_FLAG_CLEANUP_VAL) ptype_cleanup(p->value); free(p); } while (i->funcs) { struct registry_function *f = i->funcs; i->funcs = f->next; free(f->name); free(f->description); free(f); } while (i->perfs) { struct registry_perf *p = i->perfs; i->perfs = p->next; if (p->update_hook) { int res = pthread_mutex_destroy(&p->hook_lock); if (res) { pomlog(POMLOG_ERR "Error while destroying perf hook lock : %s", pom_strerror(errno)); abort(); } } free(p->name); free(p->description); free(p->unit); free(p); } if (i->prev) i->prev->next = i->next; else c->instances = i->next; if (i->next) i->next->prev = i->prev; c->serial++; registry_classes_serial_inc(); registry_unlock(); free(i); return POM_OK; }
int registry_config_load(char *config_name) { struct dataset_query *dsq_config_list = NULL, *dsq_config = NULL; struct datastore *sys_dstore = system_datastore(); if (!sys_dstore) { pomlog(POMLOG_ERR "No system datastore declared"); return POM_ERR; } // Find what is the id corresponding to the name given if any dsq_config_list = datastore_dataset_query_open(sys_dstore, REGISTRY_CONFIG_LIST, registry_config_list_dataset_template, NULL); if (!dsq_config_list) goto err; if (datastore_dataset_query_set_string_condition(dsq_config_list, 0, PTYPE_OP_EQ, config_name) != POM_OK) goto err; int res = datastore_dataset_read_single(dsq_config_list); if (res < 0) goto err; if (res == DATASET_QUERY_OK) { pomlog(POMLOG_ERR "Configuration \"%s\" not found in the database", config_name); goto err; } uint64_t config_id = dsq_config_list->data_id; datastore_dataset_query_cleanup(dsq_config_list); dsq_config_list = NULL; // Fetch the config dsq_config = datastore_dataset_query_open(sys_dstore, REGISTRY_CONFIG, registry_config_dataset_template, NULL); if (!dsq_config) goto err; if (datastore_dataset_query_set_uint64_condition(dsq_config, 0, PTYPE_OP_EQ, config_id) != POM_OK) goto err; // Fetch the config in a convenient way if (datastore_dataset_query_set_order(dsq_config, 3, DATASET_READ_ORDER_ASC) != POM_OK) goto err; registry_lock(); // Reset the registry if (registry_config_reset() != POM_OK) goto err_locked; while ((res = datastore_dataset_read(dsq_config)) != DATASET_QUERY_OK) { if (res < 0) goto err_locked; if (dsq_config->values[1].is_null || dsq_config->values[3].is_null) { pomlog(POMLOG_ERR "Got NULL values while they were not supposed to be !"); goto err_locked; } enum registry_config_entry_types type = *PTYPE_UINT8_GETVAL(dsq_config->values[3].value); char *entry = PTYPE_STRING_GETVAL(dsq_config->values[1].value); char *value = NULL; if (!dsq_config->values[2].is_null) value = PTYPE_STRING_GETVAL(dsq_config->values[2].value); // Parse the entry char *name1 = strdup(entry); if (!name1) { pom_oom(strlen(entry) + 1); goto err_locked; } char *name2 = strchr(name1, '.'); if (!name2) { pomlog(POMLOG_ERR "Unparseable entry name \"%s\"", entry); free(name1); goto err_locked; } *name2 = 0; name2++; char *name3 = strchr(name2, '.'); if (name3) { *name3 = 0; name3++; } switch (type) { case registry_config_instance: { if (!value) { pomlog(POMLOG_WARN "Instance type not provided for entry %s, skipping", entry); break; } struct registry_class *cls = registry_find_class(name1); if (!cls) { pomlog(POMLOG_WARN "Cannot add instance %s to class %s as this class doesn't exists. skipping", name2, name1); break; } struct registry_instance *inst; for (inst = cls->instances; inst && strcmp(inst->name, name2); inst = inst->next); if (inst) { pomlog(POMLOG_WARN "Cannot add instance %s as it's already in the registry, skipping", entry); break; } if (!cls->instance_add) { pomlog(POMLOG_WARN "Cannot add instances to class %s as it doesn't support it. skipping", name1); break; } if (cls->instance_add(value, name2) != POM_OK) { pomlog(POMLOG_WARN "Unable to add instance %s of type %s, skipping", entry, value); break; } break; } case registry_config_instance_param: { if (!value) { pomlog(POMLOG_WARN "Parameter value not provided for entry %s, skipping", entry); break; } if (!name3) { pomlog(POMLOG_WARN "Parameter name not provided for entry %s, skipping", entry); break; } struct registry_instance *inst = registry_find_instance(name1, name2); if (!inst) { pomlog(POMLOG_WARN "Cannot find instance %s.%s to set parameter, skipping", name1, name2); break; } if (!strcmp(name3, "uid")) { // Special handling for uids if (registry_uid_assign(inst, value) != POM_OK) { pomlog(POMLOG_WARN "Error while setting the uid, skipping"); break; } } else if (!strcmp(name3, "running")) { // For now don't do anything for running } else { registry_set_param(inst, name3, value); } break; } default: pomlog(POMLOG_WARN "Unhandled configuration entry type %u for item %s", entry); } free(name1); } registry_classes_serial_inc(); registry_unlock(); datastore_dataset_query_cleanup(dsq_config); pomlog("Registry configuration \"%s\" loaded", config_name); return POM_OK; err_locked: registry_unlock(); err: if (dsq_config_list) datastore_dataset_query_cleanup(dsq_config_list); if (dsq_config) datastore_dataset_query_cleanup(dsq_config); return POM_ERR; }
int registry_remove_class(struct registry_class *c) { if (!c) return POM_OK; registry_lock(); if (c->prev) c->prev->next = c->next; else registry_head = c->next; if (c->next) c->next->prev = c->prev; while (c->types) { struct registry_instance_type *t = c->types; c->types = c->types->next; free(t->name); free(t); } while (c->instances) { if (registry_remove_instance(c->instances) != POM_OK) { pomlog(POMLOG_WARN "Some error occured while removing an instance"); break; } } registry_unlock(); while (c->global_params) { struct registry_param *p = c->global_params; c->global_params = p->next; free(p->name); if (p->default_value) free(p->default_value); free(p->description); if (p->flags & REGISTRY_PARAM_FLAG_CLEANUP_VAL) ptype_cleanup(p->value); free(p); } while (c->perfs) { struct registry_perf *p = c->perfs; c->perfs = p->next; if (p->update_hook) { int res = pthread_mutex_destroy(&p->hook_lock); if (res) { pomlog(POMLOG_ERR "Error while destroying perf hook lock : %s", pom_strerror(errno)); abort(); } } free(p->name); free(p->description); free(p->unit); free(p); } free(c->name); free(c); return POM_OK; }
int registry_config_delete(char *config_name) { struct dataset_query *dsq_config_list = NULL, *dsq_config = NULL; struct datastore *sys_dstore = system_datastore(); if (!sys_dstore) { pomlog(POMLOG_ERR "No system datastore declared"); return POM_ERR; } registry_lock(); // Find what is the id corresponding to the name given if any dsq_config_list = datastore_dataset_query_open(sys_dstore, REGISTRY_CONFIG_LIST, registry_config_list_dataset_template, NULL); if (!dsq_config_list) goto err; if (datastore_dataset_query_set_string_condition(dsq_config_list, 0, PTYPE_OP_EQ, config_name) != POM_OK) goto err; int res = datastore_dataset_read_single(dsq_config_list); if (res < 0) goto err; if (res == DATASET_QUERY_OK) { pomlog(POMLOG_ERR "Configuration \"%s\" not found in the database", config_name); goto err; } // Get the id of the list uint64_t config_id = dsq_config_list->data_id; // Fetch the config dsq_config = datastore_dataset_query_open(sys_dstore, REGISTRY_CONFIG, registry_config_dataset_template, NULL); if (!dsq_config) goto err; if (datastore_dataset_query_set_uint64_condition(dsq_config, 0, PTYPE_OP_EQ, config_id) != POM_OK) goto err; // Delete the config if (datastore_dataset_delete(dsq_config) != POM_OK) goto err; datastore_dataset_query_cleanup(dsq_config); // Delete the config in the list datastore_dataset_delete(dsq_config_list); datastore_dataset_query_cleanup(dsq_config_list); registry_config_serial++; registry_serial++; xmlrcpcmd_serial_inc(); registry_unlock(); return POM_OK; err: registry_unlock(); if (dsq_config_list) datastore_dataset_query_cleanup(dsq_config_list); if (dsq_config) datastore_dataset_query_cleanup(dsq_config); return POM_ERR; }