catalog: unify API names

diff --git a/src/knot/conf/base.h b/src/knot/conf/base.h
index 475da16255eaf681e4deb61c881ccb1f471996ce..464f03c09156a958c05326c29af388dd7d2b08e4 100644 (file)
--- 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 1ee35bae635be5ce8fe8dcc270ef1f18b86e3e7f..4e26928208288e9e9f64c3cd9cb0aedae006727f 100644 (file)
--- 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 9131b3f3f7a3e0994fe9353897ad438e7258a5e9..1d37898d978842a71727eeb477b7c97f85fdfb94 100644 (file)
--- 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 bc7dc634d94c0910738eb842a66e6af479754bc2..f73b62043534796a0efa1dd64eb59519eab2e15a 100644 (file)
--- 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 558f3cc79dd3b996ff5d286499675fecdc3417d5..1fb3484b3a7640463b6ab35e5f6a637b623f8d7c 100644 (file)
--- 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 41265d954196e9e53a0377eeffdcbc9ab7551f09..a298b120cdbc567d3813f00500d571a84dad002c 100644 (file)
--- 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 2e2c8967f101617c8181ee89a28765d9d76d9aa0..c4d7d585225aa99bb013e665bf4e0b43fcb57196 100644 (file)
--- 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 3af58fa38b1c0485e9c1a75b0c36a2ebf09761ca..267517c52c10574eebb288bce8aab9d104984c54 100644 (file)
--- 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 9ffb147a699dc16f4577f9b4a6202b561cb58fdd..9bd18e023f9188f60aaf3472ba60af49893e1ddc 100644 (file)
--- 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 af8050510d03ba99ad87b202d625667b514c937a..c66549c2f617aa877a31a3b77b134513eb0265b8 100644 (file)
--- 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 1147d33cf048e57febc68ad8d244db3b3b0fe118..0271c9b3862aaee53a0bfc4c82679886622bb539 100644 (file)
--- 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;
 }