From: Daniel Salzman Date: Sat, 27 Jun 2020 20:33:53 +0000 (+0200) Subject: catalog: unify API names X-Git-Tag: v3.0.0~82^2~7 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=9285d480c1fd5fb754f7d88c7ff2b20ba50dcaef;p=thirdparty%2Fknot-dns.git catalog: unify API names --- diff --git a/src/knot/conf/base.h b/src/knot/conf/base.h index 475da16255..464f03c091 100644 --- a/src/knot/conf/base.h +++ b/src/knot/conf/base.h @@ -134,7 +134,7 @@ typedef struct { /*! Default query modules plan. */ struct query_plan *query_plan; /*! Zone catalog database. */ - struct knot_catalog *catalog; + struct catalog *catalog; } conf_t; /*! diff --git a/src/knot/conf/conf.c b/src/knot/conf/conf.c index 1ee35bae63..4e26928208 100644 --- a/src/knot/conf/conf.c +++ b/src/knot/conf/conf.c @@ -205,7 +205,7 @@ conf_val_t conf_zone_get_txn( // Check if this is a catalog member zone. if (conf->catalog != NULL) { knot_dname_t *catalog = NULL; - int ret = knot_cat_get_catzone_thrsafe(conf->catalog, dname, &catalog); + int ret = catalog_get_zone_threadsafe(conf->catalog, dname, &catalog); if (ret == KNOT_EOK) { conf_db_get(conf, txn, C_ZONE, C_CATALOG_TPL, catalog, knot_dname_size(catalog), &val); diff --git a/src/knot/server/server.c b/src/knot/server/server.c index 9131b3f3f7..1d37898d97 100644 --- a/src/knot/server/server.c +++ b/src/knot/server/server.c @@ -520,7 +520,7 @@ int server_init(server_t *server, int bg_workers) return KNOT_ENOMEM; } - int ret = knot_cat_update_init(&server->catalog_upd); + int ret = catalog_update_init(&server->catalog_upd); if (ret != KNOT_EOK) { worker_pool_destroy(server->workers); evsched_deinit(&server->sched); @@ -529,7 +529,7 @@ int server_init(server_t *server, int bg_workers) char *catalog_dir = conf_db(conf(), C_CATALOG_DB); conf_val_t catalog_size = conf_db_param(conf(), C_CATALOG_DB_MAX_SIZE, NULL); - knot_catalog_init(&server->catalog, catalog_dir, conf_int(&catalog_size)); + catalog_init(&server->catalog, catalog_dir, conf_int(&catalog_size)); free(catalog_dir); conf()->catalog = &server->catalog; @@ -566,8 +566,8 @@ void server_deinit(server_t *server) } /* Free catalog zone context. */ - knot_cat_update_deinit(&server->catalog_upd); - knot_catalog_deinit(&server->catalog); + catalog_update_deinit(&server->catalog_upd); + catalog_deinit(&server->catalog); /* Free remaining interfaces. */ server_deinit_iface_list(server->ifaces, server->n_ifaces); diff --git a/src/knot/server/server.h b/src/knot/server/server.h index bc7dc634d9..f73b620435 100644 --- a/src/knot/server/server.h +++ b/src/knot/server/server.h @@ -83,7 +83,7 @@ typedef struct server { knot_lmdb_db_t timerdb; knot_lmdb_db_t journaldb; knot_lmdb_db_t kaspdb; - knot_catalog_t catalog; + catalog_t catalog; /*! \brief I/O handlers. */ struct { @@ -102,7 +102,7 @@ typedef struct server { size_t n_ifaces; /*! \brief Pending changes to catalog member zones. */ - knot_cat_update_t catalog_upd; + catalog_update_t catalog_upd; } server_t; /*! diff --git a/src/knot/updates/zone-update.c b/src/knot/updates/zone-update.c index 558f3cc79d..1fb3484b3a 100644 --- a/src/knot/updates/zone-update.c +++ b/src/knot/updates/zone-update.c @@ -717,17 +717,22 @@ static int update_catalog(conf_t *conf, zone_update_t *update) int ret = KNOT_EOK; if ((update->flags & UPDATE_INCREMENTAL)) { - ret = knot_cat_update_from_zone(update->zone->catalog_upd, update->change.remove, - true, false, update->zone->catalog); + ret = catalog_update_from_zone(update->zone->catalog_upd, + update->change.remove, + true, false, update->zone->catalog); if (ret == KNOT_EOK) { - ret = knot_cat_update_from_zone(update->zone->catalog_upd, - update->change.add, false, false, NULL); + ret = catalog_update_from_zone(update->zone->catalog_upd, + update->change.add, + false, false, NULL); } } else { - ret = knot_cat_update_del_all(update->zone->catalog_upd, update->zone->catalog, update->zone->name); + ret = catalog_update_del_all(update->zone->catalog_upd, + update->zone->catalog, + update->zone->name); if (ret == KNOT_EOK) { - ret = knot_cat_update_from_zone(update->zone->catalog_upd, - update->zone->contents, false, true, NULL); + ret = catalog_update_from_zone(update->zone->catalog_upd, + update->zone->contents, + false, true, NULL); } } diff --git a/src/knot/zone/catalog.c b/src/knot/zone/catalog.c index 41265d9541..a298b120cd 100644 --- a/src/knot/zone/catalog.c +++ b/src/knot/zone/catalog.c @@ -28,7 +28,7 @@ #define CATALOG_VERSION "1.0" #define CATALOG_ZONE_VERSION "2" // must be just one char long -const MDB_val knot_catalog_iter_prefix = { 1, "" }; +const MDB_val catalog_iter_prefix = { 1, "" }; static bool check_zone_version(const zone_contents_t *zone) { @@ -53,12 +53,12 @@ static bool check_zone_version(const zone_contents_t *zone) return false; } -void knot_catalog_init(knot_catalog_t *cat, const char *path, size_t mapsize) +void catalog_init(catalog_t *cat, const char *path, size_t mapsize) { knot_lmdb_init(&cat->db, path, mapsize, 0, NULL); } -int knot_catalog_open(knot_catalog_t *cat) +int catalog_open(catalog_t *cat) { if (!knot_lmdb_is_open(&cat->db)) { int ret = knot_lmdb_open(&cat->db); @@ -84,7 +84,7 @@ int knot_catalog_open(knot_catalog_t *cat) return cat->txn.ret; } -int knot_catalog_deinit(knot_catalog_t *cat) +int catalog_deinit(catalog_t *cat) { if (cat->txn.opened) { knot_lmdb_commit(&cat->txn); @@ -105,10 +105,10 @@ static int bailiwick_shift(const knot_dname_t *subname, const knot_dname_t *name return res - subname; } -int knot_catalog_add(knot_catalog_t *cat, const knot_dname_t *member, - const knot_dname_t *owner, const knot_dname_t *catzone) +int catalog_add(catalog_t *cat, const knot_dname_t *member, + const knot_dname_t *owner, const knot_dname_t *catzone) { - int ret = knot_catalog_open(cat); + int ret = catalog_open(cat); if (ret != KNOT_EOK) { return ret; } @@ -126,7 +126,7 @@ int knot_catalog_add(knot_catalog_t *cat, const knot_dname_t *member, return cat->txn.ret; } -int knot_catalog_del(knot_catalog_t *cat, const knot_dname_t *member) +int catalog_del(catalog_t *cat, const knot_dname_t *member) { MDB_val key = knot_lmdb_make_key("BN", 0, member); knot_lmdb_del_prefix(&cat->txn, &key); // deletes one record @@ -134,8 +134,8 @@ int knot_catalog_del(knot_catalog_t *cat, const knot_dname_t *member) return cat->txn.ret; } -void knot_catalog_curval(knot_catalog_t *cat, const knot_dname_t **member, - const knot_dname_t **owner, const knot_dname_t **catzone) +void catalog_curval(catalog_t *cat, const knot_dname_t **member, + const knot_dname_t **owner, const knot_dname_t **catzone) { uint8_t zero, shift; if (member != NULL) { @@ -152,8 +152,8 @@ void knot_catalog_curval(knot_catalog_t *cat, const knot_dname_t **member, } } -int knot_catalog_get_catzone(knot_catalog_t *cat, const knot_dname_t *member, - const knot_dname_t **catzone) +int catalog_get_zone(catalog_t *cat, const knot_dname_t *member, + const knot_dname_t **catzone) { if (!knot_lmdb_is_open(&cat->db)) { return KNOT_ENOENT; @@ -161,7 +161,7 @@ int knot_catalog_get_catzone(knot_catalog_t *cat, const knot_dname_t *member, MDB_val key = knot_lmdb_make_key("BN", 0, member); if (knot_lmdb_find(&cat->txn, &key, KNOT_LMDB_EXACT)) { - knot_catalog_curval(cat, NULL, NULL, catzone); + catalog_curval(cat, NULL, NULL, catzone); free(key.mv_data); return KNOT_EOK; } @@ -169,8 +169,8 @@ int knot_catalog_get_catzone(knot_catalog_t *cat, const knot_dname_t *member, return MIN(cat->txn.ret, KNOT_ENOENT); } -int knot_cat_get_catzone_thrsafe(knot_catalog_t *cat, const knot_dname_t *member, - knot_dname_t **catzone) +int catalog_get_zone_threadsafe(catalog_t *cat, const knot_dname_t *member, + knot_dname_t **catzone) { if (!knot_lmdb_is_open(&cat->db)) { return KNOT_ENOENT; @@ -192,14 +192,14 @@ int knot_cat_get_catzone_thrsafe(knot_catalog_t *cat, const knot_dname_t *member return ret; } -knot_cat_find_res_t knot_catalog_find(knot_catalog_t *cat, const knot_dname_t *member, - const knot_dname_t *owner, const knot_dname_t *catzone) +catalog_find_res_t catalog_find(catalog_t *cat, const knot_dname_t *member, + const knot_dname_t *owner, const knot_dname_t *catzone) { MDB_val key = knot_lmdb_make_key("BN", 0, member); int ret = MEMBER_NONE; if (knot_lmdb_find(&cat->txn, &key, KNOT_LMDB_EXACT)) { const knot_dname_t *ow, *cz; - knot_catalog_curval(cat, NULL, &ow, &cz); + catalog_curval(cat, NULL, &ow, &cz); if (!knot_dname_is_equal(cz, catzone)) { ret = MEMBER_ZONE; } else if (!knot_dname_is_equal(ow, owner)) { @@ -215,7 +215,7 @@ knot_cat_find_res_t knot_catalog_find(knot_catalog_t *cat, const knot_dname_t *m return ret; } -int knot_cat_update_init(knot_cat_update_t *u) +int catalog_update_init(catalog_update_t *u) { u->add = trie_create(NULL); if (u->add == NULL) { @@ -237,7 +237,7 @@ static int freecb(trie_val_t *tval, void *unused) return 0; } -void knot_cat_update_clear(knot_cat_update_t *u) +void catalog_update_clear(catalog_update_t *u) { trie_apply(u->add, freecb, NULL); trie_clear(u->add); @@ -245,16 +245,16 @@ void knot_cat_update_clear(knot_cat_update_t *u) trie_clear(u->rem); } -void knot_cat_update_deinit(knot_cat_update_t *u) +void catalog_update_deinit(catalog_update_t *u) { pthread_mutex_destroy(&u->mutex); trie_free(u->add); trie_free(u->rem); } -int knot_cat_update_add(knot_cat_update_t *u, const knot_dname_t *member, - const knot_dname_t *owner, const knot_dname_t *catzone, - bool remove) +int catalog_update_add(catalog_update_t *u, const knot_dname_t *member, + const knot_dname_t *owner, const knot_dname_t *catzone, + bool remove) { int bail = bailiwick_shift(owner, catzone); if (bail < 0) { @@ -272,7 +272,7 @@ int knot_cat_update_add(knot_cat_update_t *u, const knot_dname_t *member, trie_val_t *found = trie_get_try(check, lf + 1, lf[0]); if (found != NULL) { - knot_cat_upd_val_t *counter = *found; + catalog_upd_val_t *counter = *found; assert(knot_dname_is_equal(counter->member, member)); if (knot_dname_is_equal(counter->owner, owner)) { assert(knot_dname_is_equal(counter->catzone, catzone)); @@ -288,7 +288,7 @@ int knot_cat_update_add(knot_cat_update_t *u, const knot_dname_t *member, size_t member_size = knot_dname_size(member); size_t owner_size = knot_dname_size(owner); - knot_cat_upd_val_t *val = malloc(sizeof(*val) + member_size + owner_size); + catalog_upd_val_t *val = malloc(sizeof(*val) + member_size + owner_size); if (val == NULL) { return KNOT_ENOMEM; } @@ -310,20 +310,20 @@ int knot_cat_update_add(knot_cat_update_t *u, const knot_dname_t *member, return KNOT_EOK; } -knot_cat_upd_val_t *knot_cat_update_get(knot_cat_update_t *u, const knot_dname_t *member, bool remove) +catalog_upd_val_t *catalog_update_get(catalog_update_t *u, const knot_dname_t *member, bool remove) { knot_dname_storage_t lf_storage; uint8_t *lf = knot_dname_lf(member, lf_storage); trie_val_t *found = trie_get_try(remove ? u->rem : u->add, lf + 1, lf[0]); - return found == NULL ? NULL : *(knot_cat_upd_val_t **)found; + return found == NULL ? NULL : *(catalog_upd_val_t **)found; } typedef struct { - knot_cat_update_t *u; + catalog_update_t *u; const knot_dname_t *apex; bool remove; - knot_catalog_t *check; + catalog_t *check; } cat_upd_ctx_t; static int cat_update_add_node(zone_node_t *node, void *data) @@ -338,18 +338,18 @@ static int cat_update_add_node(zone_node_t *node, void *data) for (int i = 0; ret == KNOT_EOK && i < ptr->count; i++) { const knot_dname_t *member = knot_ptr_name(rdata); if (ctx->check != NULL && ctx->remove && - knot_catalog_find(ctx->check, member, node->owner, ctx->apex) != MEMBER_EXACT) { + catalog_find(ctx->check, member, node->owner, ctx->apex) != MEMBER_EXACT) { rdata = knot_rdataset_next(rdata); continue; } - ret = knot_cat_update_add(ctx->u, member, node->owner, ctx->apex, ctx->remove); + ret = catalog_update_add(ctx->u, member, node->owner, ctx->apex, ctx->remove); rdata = knot_rdataset_next(rdata); } return ret; } -int knot_cat_update_from_zone(knot_cat_update_t *u, struct zone_contents *zone, - bool remove, bool check_ver, knot_catalog_t *check) +int catalog_update_from_zone(catalog_update_t *u, struct zone_contents *zone, + bool remove, bool check_ver, catalog_t *check) { if (check_ver && !check_zone_version(zone)) { return KNOT_EZONEINVAL; @@ -371,19 +371,19 @@ int knot_cat_update_from_zone(knot_cat_update_t *u, struct zone_contents *zone, return ret; } -int knot_cat_update_del_all(knot_cat_update_t *u, knot_catalog_t *cat, const knot_dname_t *zone) +int catalog_update_del_all(catalog_update_t *u, catalog_t *cat, const knot_dname_t *zone) { - int ret = knot_catalog_open(cat); + int ret = catalog_open(cat); if (ret != KNOT_EOK) { return ret; } pthread_mutex_lock(&u->mutex); - knot_catalog_foreach(cat) { // TODO possible speedup by indexing which member zones belong to a catalog zone + catalog_foreach(cat) { // TODO possible speedup by indexing which member zones belong to a catalog zone const knot_dname_t *mem, *ow, *cz; - knot_catalog_curval(cat, &mem, &ow, &cz); + catalog_curval(cat, &mem, &ow, &cz); if (knot_dname_is_equal(cz, zone)) { - ret = knot_cat_update_add(u, mem, ow, cz, true); + ret = catalog_update_add(u, mem, ow, cz, true); if (ret != KNOT_EOK) { pthread_mutex_unlock(&u->mutex); return ret; @@ -410,44 +410,44 @@ static void print_dname3(const char *pre, const knot_dname_t *a, const knot_dnam printf("%s\n", suff); } -void knot_cat_update_print(const char *intro, knot_catalog_t *cat, knot_cat_update_t *u) +void catalog_update_print(const char *intro, catalog_t *cat, catalog_update_t *u) { ssize_t cattot = 0, uplus = 0, uminus = 0; printf("Catalog (%s)\n", intro); if (cat != NULL) { - int ret = knot_catalog_open(cat); + int ret = catalog_open(cat); if (ret != KNOT_EOK) { printf("Catalog print failed (%s)\n", knot_strerror(ret)); return; } - knot_catalog_foreach(cat) { + catalog_foreach(cat) { const knot_dname_t *mem, *ow, *cz; - knot_catalog_curval(cat, &mem, &ow, &cz); + catalog_curval(cat, &mem, &ow, &cz); print_dname3("*", mem, ow, cz, ""); cattot++; } } if (u != NULL) { - knot_cat_it_t *it = knot_cat_it_begin(u, true); - while (!knot_cat_it_finised(it)) { - knot_cat_upd_val_t *val = knot_cat_it_val(it); + catalog_it_t *it = catalog_it_begin(u, true); + while (!catalog_it_finished(it)) { + catalog_upd_val_t *val = catalog_it_val(it); print_dname3("-", val->member, val->owner, val->catzone, ""); uminus++; - knot_cat_it_next(it); + catalog_it_next(it); } - knot_cat_it_free(it); + catalog_it_free(it); - it = knot_cat_it_begin(u, false); - while (!knot_cat_it_finised(it)) { - knot_cat_upd_val_t *val = knot_cat_it_val(it); + it = catalog_it_begin(u, false); + while (!catalog_it_finished(it)) { + catalog_upd_val_t *val = catalog_it_val(it); print_dname3("+", val->member, val->owner, val->catzone, val->just_reconf ? "JR" : ""); uplus++; - knot_cat_it_next(it); + catalog_it_next(it); } - knot_cat_it_free(it); + catalog_it_free(it); } printf("Catalog: *%zd -%zd +%zd\n", cattot, uminus, uplus); } diff --git a/src/knot/zone/catalog.h b/src/knot/zone/catalog.h index 2e2c8967f1..c4d7d58522 100644 --- a/src/knot/zone/catalog.h +++ b/src/knot/zone/catalog.h @@ -22,10 +22,10 @@ #include "contrib/qp-trie/trie.h" #include "knot/journal/knot_lmdb.h" -typedef struct knot_catalog { +typedef struct catalog { knot_lmdb_db_t db; knot_lmdb_txn_t txn; // RW transaction open all the time -} knot_catalog_t; +} catalog_t; typedef enum { MEMBER_NONE, // this member zone is not in any catalog @@ -33,96 +33,96 @@ typedef enum { MEMBER_ZONE, // this member zone is in different catalog MEMBER_OWNER, // this member zone is in same catalog with diferent owner MEMBER_ERROR, // find error code in cat->txn.ret -} knot_cat_find_res_t; +} catalog_find_res_t; typedef struct { trie_t *rem; trie_t *add; pthread_mutex_t mutex; -} knot_cat_update_t; +} catalog_update_t; typedef struct { knot_dname_t *member; knot_dname_t *owner; knot_dname_t *catzone; bool just_reconf; -} knot_cat_upd_val_t; +} catalog_upd_val_t; -extern const MDB_val knot_catalog_iter_prefix; +extern const MDB_val catalog_iter_prefix; -void knot_catalog_init(knot_catalog_t *cat, const char *path, size_t mapsize); +void catalog_init(catalog_t *cat, const char *path, size_t mapsize); -int knot_catalog_open(knot_catalog_t *cat); +int catalog_open(catalog_t *cat); -int knot_catalog_deinit(knot_catalog_t *cat); +int catalog_deinit(catalog_t *cat); -int knot_catalog_add(knot_catalog_t *cat, const knot_dname_t *member, - const knot_dname_t *owner, const knot_dname_t *catzone); +int catalog_add(catalog_t *cat, const knot_dname_t *member, + const knot_dname_t *owner, const knot_dname_t *catzone); -inline static int knot_catalog_add2(knot_catalog_t *cat, const knot_cat_upd_val_t *val) +inline static int catalog_add2(catalog_t *cat, const catalog_upd_val_t *val) { - return knot_catalog_add(cat, val->member, val->owner, val->catzone); + return catalog_add(cat, val->member, val->owner, val->catzone); } -int knot_catalog_del(knot_catalog_t *cat, const knot_dname_t *member); +int catalog_del(catalog_t *cat, const knot_dname_t *member); -inline static int knot_catalog_del2(knot_catalog_t *cat, const knot_cat_upd_val_t *val) +inline static int catalog_del2(catalog_t *cat, const catalog_upd_val_t *val) { assert(!val->just_reconf); // just re-add in this case - return knot_catalog_del(cat, val->member); + return catalog_del(cat, val->member); } -#define knot_catalog_foreach(cat) knot_lmdb_foreach(&(cat)->txn, (MDB_val *)&knot_catalog_iter_prefix) +#define catalog_foreach(cat) knot_lmdb_foreach(&(cat)->txn, (MDB_val *)&catalog_iter_prefix) -void knot_catalog_curval(knot_catalog_t *cat, const knot_dname_t **member, - const knot_dname_t **owner, const knot_dname_t **catzone); +void catalog_curval(catalog_t *cat, const knot_dname_t **member, + const knot_dname_t **owner, const knot_dname_t **catzone); -int knot_catalog_get_catzone(knot_catalog_t *cat, const knot_dname_t *member, - const knot_dname_t **catzone); +int catalog_get_zone(catalog_t *cat, const knot_dname_t *member, + const knot_dname_t **catzone); -int knot_cat_get_catzone_thrsafe(knot_catalog_t *cat, const knot_dname_t *member, - knot_dname_t **catzone); +int catalog_get_zone_threadsafe(catalog_t *cat, const knot_dname_t *member, + knot_dname_t **catzone); -knot_cat_find_res_t knot_catalog_find(knot_catalog_t *cat, const knot_dname_t *member, - const knot_dname_t *owner, const knot_dname_t *catzone); +catalog_find_res_t catalog_find(catalog_t *cat, const knot_dname_t *member, + const knot_dname_t *owner, const knot_dname_t *catzone); -int knot_cat_update_init(knot_cat_update_t *u); +int catalog_update_init(catalog_update_t *u); -void knot_cat_update_clear(knot_cat_update_t *u); +void catalog_update_clear(catalog_update_t *u); -void knot_cat_update_deinit(knot_cat_update_t *u); +void catalog_update_deinit(catalog_update_t *u); -int knot_cat_update_add(knot_cat_update_t *u, const knot_dname_t *member, - const knot_dname_t *owner, const knot_dname_t *catzone, - bool remove); +int catalog_update_add(catalog_update_t *u, const knot_dname_t *member, + const knot_dname_t *owner, const knot_dname_t *catzone, + bool remove); -knot_cat_upd_val_t *knot_cat_update_get(knot_cat_update_t *u, const knot_dname_t *member, bool remove); +catalog_upd_val_t *catalog_update_get(catalog_update_t *u, const knot_dname_t *member, bool remove); struct zone_contents; -int knot_cat_update_from_zone(knot_cat_update_t *u, struct zone_contents *zone, - bool remove, bool check_ver, knot_catalog_t *check); +int catalog_update_from_zone(catalog_update_t *u, struct zone_contents *zone, + bool remove, bool check_ver, catalog_t *check); -int knot_cat_update_del_all(knot_cat_update_t *u, knot_catalog_t *cat, const knot_dname_t *zone); +int catalog_update_del_all(catalog_update_t *u, catalog_t *cat, const knot_dname_t *zone); -typedef trie_it_t knot_cat_it_t; +typedef trie_it_t catalog_it_t; -inline static knot_cat_it_t *knot_cat_it_begin(knot_cat_update_t *u, bool remove) +inline static catalog_it_t *catalog_it_begin(catalog_update_t *u, bool remove) { return trie_it_begin(remove ? u->rem : u->add); } -inline static knot_cat_upd_val_t *knot_cat_it_val(knot_cat_it_t *it) +inline static catalog_upd_val_t *catalog_it_val(catalog_it_t *it) { - return *(knot_cat_upd_val_t **)trie_it_val(it); + return *(catalog_upd_val_t **)trie_it_val(it); } -inline static bool knot_cat_it_finised(knot_cat_it_t *it) +inline static bool catalog_it_finished(catalog_it_t *it) { return it == NULL || trie_it_finished(it); } -#define knot_cat_it_next trie_it_next -#define knot_cat_it_free trie_it_free +#define catalog_it_next trie_it_next +#define catalog_it_free trie_it_free -void knot_cat_update_print(const char *intro, knot_catalog_t *cat, knot_cat_update_t *u); +void catalog_update_print(const char *intro, catalog_t *cat, catalog_update_t *u); diff --git a/src/knot/zone/zone.h b/src/knot/zone/zone.h index 3af58fa38b..267517c52c 100644 --- a/src/knot/zone/zone.h +++ b/src/knot/zone/zone.h @@ -86,8 +86,8 @@ typedef struct zone knot_lmdb_db_t *kaspdb; /*! \brief Ptr to catalog and ist changeset changes (in struct server) */ - knot_catalog_t *catalog; - knot_cat_update_t *catalog_upd; + catalog_t *catalog; + catalog_update_t *catalog_upd; /*! \brief Preferred master lock. */ pthread_mutex_t preferred_lock; diff --git a/src/knot/zone/zonedb-load.c b/src/knot/zone/zonedb-load.c index 9ffb147a69..9bd18e023f 100644 --- a/src/knot/zone/zonedb-load.c +++ b/src/knot/zone/zonedb-load.c @@ -245,9 +245,10 @@ static zone_contents_t *zone_expire(zone_t *zone) return zone_switch_contents(zone, NULL); } -static bool check_open_catalog(knot_catalog_t *cat) { +static bool check_open_catalog(catalog_t *cat) +{ if (knot_lmdb_exists(&cat->db)) { - int ret = knot_catalog_open(cat); + int ret = catalog_open(cat); if (ret != KNOT_EOK) { log_error("failed to open existing zone catalog"); } else { @@ -264,7 +265,7 @@ static zone_t *reuse_member_zone(zone_t *zone, server_t *server, conf_t *conf, return NULL; } - knot_cat_upd_val_t *upd = knot_cat_update_get(&server->catalog_upd, zone->name, true); + catalog_upd_val_t *upd = catalog_update_get(&server->catalog_upd, zone->name, true); if (upd != NULL) { if (upd->just_reconf) { zone_purge(conf, zone, server); @@ -290,7 +291,7 @@ static zone_t *reuse_member_zone(zone_t *zone, server_t *server, conf_t *conf, // cold start of knot: add unchanged member zone to zonedb static zone_t *reuse_cold_zone(const knot_dname_t *zname, server_t *server, conf_t *conf) { - knot_cat_upd_val_t *upd = knot_cat_update_get(&server->catalog_upd, zname, true); + catalog_upd_val_t *upd = catalog_update_get(&server->catalog_upd, zname, true); if (upd != NULL && !upd->just_reconf) { return NULL; // zone will be removed immediately } @@ -306,7 +307,8 @@ static zone_t *reuse_cold_zone(const knot_dname_t *zname, server_t *server, conf return zone; } -static zone_t *add_member_zone(knot_cat_upd_val_t *val, knot_zonedb_t *check, server_t *server, conf_t *conf) +static zone_t *add_member_zone(catalog_upd_val_t *val, knot_zonedb_t *check, + server_t *server, conf_t *conf) { if (val->just_reconf) { return NULL; @@ -317,7 +319,7 @@ static zone_t *add_member_zone(knot_cat_upd_val_t *val, knot_zonedb_t *check, se return NULL; } - int ret = knot_catalog_add2(&server->catalog, val); + int ret = catalog_add2(&server->catalog, val); if (ret != KNOT_EOK) { log_zone_error(val->member, "failed adding member zone to catalog (%s)", knot_strerror(ret)); @@ -327,7 +329,7 @@ static zone_t *add_member_zone(knot_cat_upd_val_t *val, knot_zonedb_t *check, se zone_t *zone = create_zone(conf, val->member, server, NULL); if (zone == NULL) { log_zone_error(val->member, "zone cannot be created"); - knot_catalog_del2(conf->catalog, val); + catalog_del2(conf->catalog, val); } else { zone->flags |= ZONE_IS_CAT_MEMBER; conf_activate_modules(conf, server, zone->name, &zone->query_modules, @@ -406,9 +408,9 @@ static knot_zonedb_t *create_zonedb(conf_t *conf, server_t *server, list_t *expi } knot_zonedb_iter_free(it); } else if (check_open_catalog(&server->catalog)) { - knot_catalog_foreach(&server->catalog) { + catalog_foreach(&server->catalog) { const knot_dname_t *member = NULL; - knot_catalog_curval(&server->catalog, &member, NULL, NULL); + catalog_curval(&server->catalog, &member, NULL, NULL); zone_t *zone = reuse_cold_zone(member, server, conf); if (zone != NULL) { knot_zonedb_insert(db_new, zone); @@ -416,15 +418,15 @@ static knot_zonedb_t *create_zonedb(conf_t *conf, server_t *server, list_t *expi } } - knot_cat_it_t *it = knot_cat_it_begin(&server->catalog_upd, false); - while (!knot_cat_it_finised(it)) { - zone_t *zone = add_member_zone(knot_cat_it_val(it), db_new, server, conf); + catalog_it_t *it = catalog_it_begin(&server->catalog_upd, false); + while (!catalog_it_finished(it)) { + zone_t *zone = add_member_zone(catalog_it_val(it), db_new, server, conf); if (zone != NULL) { knot_zonedb_insert(db_new, zone); } - knot_cat_it_next(it); + catalog_it_next(it); } - knot_cat_it_free(it); + catalog_it_free(it); return db_new; } @@ -471,30 +473,29 @@ static void remove_old_zonedb(conf_t *conf, knot_zonedb_t *db_old, } /* Completely reused zone. */ } - knot_zonedb_iter_next(it); } - knot_zonedb_iter_free(it); catalog_only: ; /* Remove deleted cataloged zones from conf. */ - knot_cat_it_t *tit = knot_cat_it_begin(&server->catalog_upd, true); - while (!knot_cat_it_finised(tit)) { - knot_cat_upd_val_t *val = knot_cat_it_val(tit); - if (!val->just_reconf) { - knot_catalog_del(&server->catalog, val->member); - zone_t *zone = knot_zonedb_find(db_old, val->member); + catalog_it_t *cat_it = catalog_it_begin(&server->catalog_upd, true); + while (!catalog_it_finished(cat_it)) { + catalog_upd_val_t *upd = catalog_it_val(cat_it); + if (!upd->just_reconf) { + catalog_del(&server->catalog, upd->member); + zone_t *zone = knot_zonedb_find(db_old, upd->member); if (zone != NULL) { zone_purge(conf, zone, server); } } - knot_cat_it_next(tit); + catalog_it_next(cat_it); } - knot_cat_it_free(tit); + catalog_it_free(cat_it); - /* Clear catalog changes. No need to use mutex as this is done from main thread while all zone events are paused. */ - knot_cat_update_clear(&server->catalog_upd); + /* Clear catalog changes. No need to use mutex as this is done from main + * thread while all zone events are paused. */ + catalog_update_clear(&server->catalog_upd); if (full) { knot_zonedb_deep_free(&db_old, false); diff --git a/src/knot/zone/zonedb.c b/src/knot/zone/zonedb.c index af8050510d..c66549c2f6 100644 --- a/src/knot/zone/zonedb.c +++ b/src/knot/zone/zonedb.c @@ -30,7 +30,7 @@ static void discard_zone(zone_t *zone, bool abort_txn) // Don't flush if removed zone (no previous configuration available). if (conf_rawid_exists(conf(), C_ZONE, zone->name, knot_dname_size(zone->name)) || - knot_catalog_get_catzone(conf()->catalog, zone->name, &unused) == KNOT_EOK) { + catalog_get_zone(conf()->catalog, zone->name, &unused) == KNOT_EOK) { uint32_t journal_serial, zone_serial = zone_contents_serial(zone->contents); bool exists; diff --git a/src/utils/kcatalogprint/main.c b/src/utils/kcatalogprint/main.c index 1147d33cf0..0271c9b386 100644 --- a/src/utils/kcatalogprint/main.c +++ b/src/utils/kcatalogprint/main.c @@ -60,9 +60,9 @@ int main(int argc, char *argv[]) print_help(); return EXIT_FAILURE; } - knot_catalog_t c; + catalog_t c; memset(&c, 0, sizeof(c)); - knot_catalog_init(&c, argv[1], 0); // mapsize grows automatically - knot_cat_update_print("Catalog:", &c, NULL); - return knot_catalog_deinit(&c) == KNOT_EOK ? 0 : 1; + catalog_init(&c, argv[1], 0); // mapsize grows automatically + catalog_update_print("Catalog:", &c, NULL); + return catalog_deinit(&c) == KNOT_EOK ? 0 : 1; }