/**@return a backend which gives plugin configuration of the module * which is currently point to. * * @param modules the modules to work with * @param errorKey the key to issue warnings and errors to */ Backend* elektraBackendOpenModules(KeySet *modules, Key *errorKey) { Backend *backend = elektraBackendAllocate(); cursor_t save = ksGetCursor (modules); KeySet *defaultConfig = ksNew(5, keyNew("system/module", KEY_VALUE, "1", KEY_END), keyNew("user/module", KEY_VALUE, "1", KEY_END), KS_END); Key *cur = ksCurrent(modules); Plugin *plugin = elektraPluginOpen(keyBaseName(cur), modules, defaultConfig, errorKey); if (!plugin) { /* Error already set in plugin */ elektraFree(backend); return 0; } Key *mp = keyNew ("system/elektra/modules", KEY_VALUE, "modules", KEY_END); keyAddBaseName (mp, keyBaseName(cur)); backend->getplugins[0] = plugin; plugin->refcounter = 1; backend->mountpoint = mp; keyIncRef(backend->mountpoint); ksSetCursor (modules, save); return backend; }
static void test_addNewBaseToParentKey() { Key *parentKey = keyNew ("user/tests/rename", KEY_END); KeySet *conf = ksNew (20, keyNew ("system/cut", KEY_VALUE, "new/base", KEY_END), KS_END); PLUGIN_OPEN("rename"); KeySet *ks = ksNew(0, KS_END); keyIncRef(parentKey); ksAppendKey (ks, parentKey); succeed_if(plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful"); succeed_if(output_error (parentKey), "error in kdbSet"); succeed_if(output_warnings (parentKey), "warnings in kdbSet"); Key *key = ksLookupByName (ks, "user/tests/rename/new/base", 0); succeed_if (key, "new base was not correctly appended to parent key"); ksDel(ks); keyDecRef(parentKey); keyDel(parentKey); PLUGIN_CLOSE (); }
/** * @brief sets mountpoint * * @param backend where the mountpoint should be set * @param elektraConfig the config where the mountpoint can be found * @param [out] errorKey the name also has the mountpoint set * * @pre ksCurrent() is root key * @post ksCurrent() is root key * * @retval -1 if no mountpoint is found or memory allocation problem * @retval 0 on success */ int elektraBackendSetMountpoint(Backend *backend, KeySet *elektraConfig, Key *errorKey) { Key * root = ksCurrent(elektraConfig); Key * searchMountpoint = keyDup(root); keyAddBaseName(searchMountpoint, "mountpoint"); Key * foundMountpoint = ksLookup(elektraConfig, searchMountpoint, 0); keyDel (searchMountpoint); ksLookup(elektraConfig, root, 0); // reset ksCurrent() if (!foundMountpoint) { ELEKTRA_ADD_WARNINGF(14, errorKey, "Could not find mountpoint within root %s", keyName(root)); return -1; } backend->mountpoint = keyNew("", KEY_VALUE, keyBaseName(root), KEY_END); elektraKeySetName(backend->mountpoint, keyString(foundMountpoint), KEY_CASCADING_NAME | KEY_EMPTY_NAME); keySetName(errorKey, keyName(backend->mountpoint)); if (!backend->mountpoint) { ELEKTRA_ADD_WARNINGF(14, errorKey, "Could not create mountpoint with name %s and value %s", keyString(foundMountpoint), keyBaseName(root)); return -1; } keyIncRef(backend->mountpoint); return 0; }
Trie *test_insert (Trie *trie, char *name, char* value) { Backend *backend = elektraCalloc (sizeof (Backend)); backend->mountpoint = keyNew (name, KEY_VALUE, value, KEY_END); backend->refcounter = 1; keyIncRef (backend->mountpoint); return elektraTrieInsert(trie, name, backend); }
Backend *b_new(const char *name, const char *value) { Backend *backend = elektraCalloc (sizeof (Backend)); backend->refcounter = 1; backend->mountpoint = keyNew (name, KEY_VALUE, value, KEY_END); keyIncRef (backend->mountpoint); return backend; }
/** * Opens a default backend using the plugin named KDB_DEFAULT_RESOLVER * and KDB_DEFAULT_STORAGE. * * @param modules the modules to work with * @param errorKey the key to issue warnings and errors to * @return the fresh allocated default backend or 0 if it failed */ Backend* elektraBackendOpenDefault(KeySet *modules, Key *errorKey) { Backend *backend = elektraBackendAllocate(); KeySet *resolverConfig = ksNew(5, keyNew("system/path", KEY_VALUE, KDB_DB_FILE, KEY_END), KS_END); Plugin *resolver = elektraPluginOpen(KDB_DEFAULT_RESOLVER, modules, resolverConfig, errorKey); if (!resolver) { elektraFree(backend); /* error already set in elektraPluginOpen */ return 0; } backend->getplugins[RESOLVER_PLUGIN] = resolver; backend->setplugins[RESOLVER_PLUGIN] = resolver; backend->setplugins[COMMIT_PLUGIN] = resolver; backend->errorplugins[STORAGE_PLUGIN] = resolver; resolver->refcounter = 4; KeySet *storageConfig = ksNew(5, KS_END); Plugin *storage = elektraPluginOpen(KDB_DEFAULT_STORAGE, modules, storageConfig, errorKey); if (!storage) { elektraPluginClose(resolver, errorKey); elektraFree(backend); /* error already set in elektraPluginOpen */ return 0; } backend->getplugins[STORAGE_PLUGIN] = storage; backend->setplugins[STORAGE_PLUGIN] = storage; storage->refcounter = 2; Key *mp = keyNew ("", KEY_VALUE, "default", KEY_END); backend->mountpoint = mp; keyIncRef(backend->mountpoint); return backend; }
/** * Opens the internal backend that indicates that a backend * is missing at that place. * * @return the fresh allocated backend or 0 if no memory */ Backend* elektraBackendOpenMissing(Key *mp) { Backend *backend = elektraBackendAllocate(); Plugin *plugin = elektraPluginMissing(); if (!plugin) { /* Could not allocate plugin */ elektraFree(backend); return 0; } backend->getplugins[0] = plugin; backend->setplugins[0] = plugin; plugin->refcounter = 2; keySetString (mp, "missing"); backend->mountpoint = mp; keyIncRef(backend->mountpoint); return backend; }
static void shortExamples() { { //! [Simple] Key *k = keyNew(0); // work with it keyDel (k); //! [Simple] }{ //! [Alternative] Key *k =keyNew("", KEY_END); // Has the same effect as above // work with it keyDel (k); //! [Alternative] }{ //! [With Name] // Create and initialize a key with a name and nothing else Key *k=keyNew("user/some/example", KEY_END); // work with it keyDel (k); //! [With Name] }{ //! [With Value] // Create and initialize a key with a name and nothing else Key *k=keyNew("user/tmp/ex0", KEY_VALUE, "some data", // set a string value KEY_END); // end of args //! [With Value] keyDel(k); }{ //! [With Size] // Create and initialize a key with a name and nothing else Key *k=keyNew("user/tmp/ex1", KEY_SIZE, 4, // has no effect on strings KEY_VALUE, "some data", // set a string value KEY_END); // end of args //! [With Size] printf ("%s\n", keyString(k)); keyDel(k); }{ //! [With Binary] // Create and initialize a key with a name and nothing else Key *k=keyNew("user/tmp/ex2", KEY_BINARY, KEY_SIZE, 4, // now the size is important KEY_VALUE, "some data", // sets the binary value ("some") KEY_END); // end of args //! [With Binary] printf ("%.4s\n", (char*)keyValue(k)); keyDel(k); }{ //! [With Mode] Key *k=keyNew("user/tmp/ex3", KEY_VALUE, "some data", // with a simple value KEY_MODE, 0777, // permissions KEY_END); // end of args //! [With Mode] keyDel(k); }{ //! [With Meta] Key *k=keyNew("user/tmp/ex3", KEY_META, "comment", "a comment", // with a comment KEY_META, "owner", "root", // and an owner KEY_META, "special", "yes", // and any other meta data KEY_END); // end of args //! [With Meta] keyDel(k); }{ //! [With Flags] Key *k=keyNew("user/tmp/ex3", KEY_FLAGS, KEY_BINARY | KEY_CASCADING_NAME, // flags KEY_SIZE, 7, // assume binary length 7 KEY_VALUE, "some data", // value that will be truncated in 7 bytes KEY_END); // end of args //! [With Flags] printf ("%.7s\n", (char*)keyValue(k)); keyDel(k); }{ //! [With Everything] Key *k=keyNew("user/tmp/ex4", KEY_BINARY, // key type KEY_SIZE, 7, // assume binary length 7 KEY_VALUE, "some data", // value that will be truncated in 7 bytes KEY_COMMENT, "value is truncated", KEY_OWNER, "root", // owner (not uid) is root KEY_UID, 0, // root uid KEY_END); // end of args //! [With Everything] printf ("%.7s\n", (char*)keyValue(k)); keyDel(k); }{ //! [Ref in KeySet] Key *k = keyNew("user/proper_name", KEY_END); // ref counter = 0 KeySet *ks = ksNew (1, k, KS_END); keyDel(k); // key will not be deleted, because its in the keyset ksDel(ks); // now the key will be deleted //! [Ref in KeySet] }{ //! [Ref in multiple KeySets] Key *k = keyNew("user/proper_name", KEY_END); // ref counter 0 KeySet *ks1 = ksNew(1, k, KS_END); // ref counter of k 1 KeySet *ks2 = ksNew(1, k, KS_END); // ref counter of k 2 ksDel(ks1); // ref counter of k 1 ksDel(ks2); // k is now deleted //! [Ref in multiple KeySets] }{ //! [Ref] Key *k = keyNew(0); // ref counter = 0 keyIncRef(k); // ref counter = 1 keyDel(k); // key will not be deleted keyDecRef(k); keyDel(k); //! [Ref] }{ //! [Multi Ref] Key *k = keyNew(0); // ref counter 0 keyIncRef(k); // ref counter of key 1 keyDel (k); // has no effect keyIncRef(k); // ref counter of key 2 keyDel (k); // has no effect keyDecRef(k); // ref counter of key 1 keyDel (k); // has no effect keyDecRef(k); // ref counter is now 0 keyDel (k); // k is now deleted //! [Multi Ref] } }
/**Builds a backend out of the configuration supplied * from: * @verbatim system/elektra/mountpoints/<name> @endverbatim * * The root key must be like the above example. You do * not need to rewind the keyset. But every key must be * below the root key. * * The internal consistency will be checked in this * function. If necessary parts are missing, like * no plugins, they cant be loaded or similar 0 * will be returned. * * ksCut() is perfectly suitable for cutting out the * configuration like needed. * * @note The given KeySet will be deleted within the function, * don't use it afterwards. * * @param elektraConfig the configuration to work with. * It is used to build up this backend. * @param modules used to load new modules or get references * to existing one * @return a pointer to a freshly allocated backend * this could be the requested backend or a so called * "missing backend". * @retval 0 if out of memory * @ingroup backend */ Backend* elektraBackendOpen(KeySet *elektraConfig, KeySet *modules, Key *errorKey) { Key * cur; Key * root; KeySet *referencePlugins = 0; KeySet *systemConfig = 0; int failure = 0; referencePlugins = ksNew(0, KS_END); ksRewind(elektraConfig); root = ksNext (elektraConfig); Backend *backend = elektraBackendAllocate(); while ((cur = ksNext(elektraConfig)) != 0) { if (keyRel (root, cur) == 1) { // direct below root key KeySet *cut = ksCut (elektraConfig, cur); if (!strcmp(keyBaseName(cur), "config")) { systemConfig = elektraRenameKeys(cut, "system"); ksDel (cut); } else if (!strcmp(keyBaseName(cur), "getplugins")) { if (elektraProcessPlugins(backend->getplugins, modules, referencePlugins, cut, systemConfig, errorKey) == -1) { if (!failure) ELEKTRA_ADD_WARNING(13, errorKey, "elektraProcessPlugins for get failed"); failure = 1; } } else if (!strcmp(keyBaseName(cur), "mountpoint")) { backend->mountpoint = keyNew("", KEY_VALUE, keyBaseName(root), KEY_END); elektraKeySetName(backend->mountpoint, keyString(cur), KEY_CASCADING_NAME | KEY_EMPTY_NAME); if (!backend->mountpoint) { if (!failure) ELEKTRA_ADD_WARNINGF(14, errorKey, "Could not create mountpoint with name %s and value %s", keyString(cur), keyBaseName(root)); failure = 1; } keyIncRef(backend->mountpoint); ksDel (cut); } else if (!strcmp(keyBaseName(cur), "setplugins")) { if (elektraProcessPlugins(backend->setplugins, modules, referencePlugins, cut, systemConfig, errorKey) == -1) { if (!failure) ELEKTRA_ADD_WARNING(15, errorKey, "elektraProcessPlugins for set failed"); failure = 1; } } else if (!strcmp(keyBaseName(cur), "errorplugins")) { if (elektraProcessPlugins(backend->errorplugins, modules, referencePlugins, cut, systemConfig, errorKey) == -1) { if (!failure) ELEKTRA_ADD_WARNING(15, errorKey, "elektraProcessPlugins for error failed"); failure = 1; } } else { // no one cares about that config if (!failure) ELEKTRA_ADD_WARNING(16, errorKey, keyBaseName(cur)); ksDel (cut); } } } if (failure) { Backend *tmpBackend = elektraBackendOpenMissing(backend->mountpoint); elektraBackendClose(backend, errorKey); backend = tmpBackend; } ksDel (systemConfig); ksDel (elektraConfig); ksDel (referencePlugins); return backend; }
static void gelektra_key_init (GElektraKey * self) { /* initialize the object */ self->key = keyNew (NULL); keyIncRef (self->key); }
/** * Opens a default backend using the plugin named KDB_DEFAULT_RESOLVER * and KDB_DEFAULT_STORAGE. * * @param modules the modules to work with * @param errorKey the key to issue warnings and errors to * @return the fresh allocated default backend or 0 if it failed */ Backend* elektraBackendOpenDefault(KeySet *modules, const char * file, Key *errorKey) { Backend *backend = elektraBackendAllocate(); KeySet *resolverConfig = ksNew(5, keyNew("system/path", KEY_VALUE, file, KEY_END), KS_END); elektraKeySetName(errorKey, "", KEY_CASCADING_NAME | KEY_EMPTY_NAME); Plugin *resolver = elektraPluginOpen(KDB_DEFAULT_RESOLVER, modules, resolverConfig, errorKey); if (!resolver) { elektraFree(backend); /* error already set in elektraPluginOpen */ return 0; } #if DEBUG && VERBOSE KeySet *tracerConfig = ksNew(5, // does not matter because it is mounted differently in system/elektra/modules: // keyNew("system/logmodule", KEY_VALUE, "1", KEY_END), KS_END); Plugin *tracer = elektraPluginOpen("tracer", modules, tracerConfig, errorKey); if (tracer) { backend->getplugins[RESOLVER_PLUGIN+1] = tracer; backend->setplugins[RESOLVER_PLUGIN+1] = tracer; backend->errorplugins[RESOLVER_PLUGIN+1] = tracer; tracer->refcounter = 3; } #endif backend->getplugins[RESOLVER_PLUGIN] = resolver; backend->setplugins[RESOLVER_PLUGIN] = resolver; backend->setplugins[COMMIT_PLUGIN] = resolver; backend->errorplugins[STORAGE_PLUGIN] = resolver; resolver->refcounter = 4; KeySet *storageConfig = ksNew(5, KS_END); Plugin *storage = elektraPluginOpen(KDB_DEFAULT_STORAGE, modules, storageConfig, errorKey); if (!storage) { elektraPluginClose(resolver, errorKey); elektraFree(backend); /* error already set in elektraPluginOpen */ return 0; } backend->getplugins[STORAGE_PLUGIN] = storage; backend->setplugins[STORAGE_PLUGIN] = storage; storage->refcounter = 2; Key *mp = keyNew ("", KEY_VALUE, "default", KEY_END); backend->mountpoint = mp; keyIncRef(backend->mountpoint); return backend; }