// typical usage of Elektra
int main()
{
Key * error_key = keyNew(KEY_END);
KDB * kdb_handle = kdbOpen(error_key);
Key * top = keyNew(KEY_END);
keySetName(top, "user/sw/MyApp");
KeySet * ks = ksNew(0);
kdbGet(kdb_handle, ks, top);
Key * key = keyNew(KEY_END);
keySetName(key, "user/sw/MyApp/Tests/TestKey1"); // == 31
keySetString(key, "NULLTestValue"); // == 14
keySetMeta(key, "comment", "NULLTestComment"); // == 16
ksAppendKey(ks, key); // == 1
keyNeedSync(key);
kdbSet(kdb_handle, ks, top); // == -1
print_warnings(top);
keyDel(top);
ksDel(ks);
kdbClose(kdb_handle, error_key);
keyDel(error_key);
check_key();
return 0;
}
int main()
{
KeySet *myConfig = ksNew(0, KS_END);
Key *key = keyNew("system/test/myapp",KEY_END);
KDB *handle = kdbOpen(key);
kdbGet(handle, myConfig, key);
keySetName(key, "user/test/myapp");
kdbGet(handle, myConfig, key);
// check for errors in key
keyDel(key);
key = ksLookupByName(myConfig,"/test/myapp/key", 0);
// check if key is not 0 and work with it...
if (key)
{
printf("%s\n", keyString(key));
}
ksDel (myConfig); // delete the in-memory configuration
// maybe you want kdbSet() myConfig here
kdbClose(handle, 0); // no more affairs with the key database.
return 0;
}
int main()
{
KeySet *myConfig = ksNew(0, KS_END);
Key *key = keyNew("/sw/MyApp", KEY_CASCADING_NAME, KEY_END);
KDB *handle = kdbOpen(key);
kdbGet(handle, myConfig, key);
// to get an intention of proper error handling see kdbget_error.c
keyDel (key);
Key * result = ksLookupByName (myConfig,"/sw/MyApp/Tests/TestKey1", 0);
const char * key_name = keyName(result);
const char * key_value = keyString(result);
const char * key_comment = keyString(keyGetMeta(result, "comment"));
printf("key: %s value: %s comment: %s\n", key_name, key_value, key_comment);
ksDel (myConfig); // delete the in-memory configuration
// maybe you want kdbSet() myConfig here
kdbClose(handle, 0); // no more affairs with the key database.
}
static int basicUse (int argc, const char ** argv)
{
Key * parentKey = keyNew ("/sw/org/example/#0/current", KEY_END);
//! [basic use]
KDB * kdb = kdbOpen (parentKey);
KeySet * ks = ksNew (0, KS_END);
kdbGet (kdb, ks, parentKey);
int result = elektraGetOpts (ks, argc, argv, (const char **) environ, parentKey);
if (result == -1)
{
fprintf (stderr, "ERROR: %s\n", keyString (keyGetMeta (parentKey, "error/reason")));
keyDel (parentKey);
ksDel (ks);
return EXIT_FAILURE;
}
if (result == 1)
{
char * help = elektraGetOptsHelpMessage (parentKey, NULL, NULL);
fprintf (stderr, "%s\n", help);
elektraFree (help);
keyDel (parentKey);
ksDel (ks);
return EXIT_SUCCESS;
}
//! [basic use]
ksDel (ks);
kdbClose (kdb, parentKey);
keyDel (parentKey);
return EXIT_SUCCESS;
}
static void test_registerInt (void)
{
printf ("test elektraNotificationRegisterInt\n");
Key * key = keyNew ("system/elektra/version/constants", KEY_END);
Key * valueKey = keyNew ("system/elektra/version/constants/KDB_VERSION_MAJOR", KEY_END);
int startValue = -1;
int value = startValue;
KDB * kdb = kdbOpen (key);
succeed_if (elektraNotificationRegisterInt (kdb, valueKey, &value) == 0, "register should fail before open");
elektraNotificationOpen (kdb);
succeed_if (elektraNotificationRegisterInt (kdb, valueKey, &value), "register failed");
// call kdbGet; value gets automatically updated
KeySet * config = ksNew (0, KS_END);
succeed_if (kdbGet (kdb, config, key), "kdbGet failed");
succeed_if (value != startValue, "value was not changed");
// cleanup
ksDel (config);
elektraNotificationClose (kdb);
kdbClose (kdb, key);
keyDel (key);
keyDel (valueKey);
}
void thread2 ()
{
Key * parent = keyNew ("/app/part2", KEY_CASCADING_NAME, KEY_END);
KDB * h = kdbOpen (parent);
// fetch keys and work with them
kdbClose (h, parent);
}
int main ()
{
// clang-format off
//! [set]
KeySet * myConfig = ksNew (0, KS_END);
Key * parentKey = keyNew ("system/sw/MyApp", KEY_END);
KDB * handle = kdbOpen (parentKey);
kdbGet (handle, myConfig, parentKey); // kdbGet needs to be called first!
KeySet * base = ksDup (myConfig); // save a copy of original keyset
// change the keys within myConfig
KeySet * ours = ksDup (myConfig); // save a copy of our keyset
KeySet * theirs; // needed for 3-way merging
int ret = kdbSet (handle, myConfig, parentKey);
while (ret == -1) // as long as we have an error
{
// We got an error. Warn user.
Key * problemKey = ksCurrent (myConfig);
// parentKey has the errorInformation
// problemKey is the faulty key (may be null)
int userInput = showElektraErrorDialog (parentKey, problemKey);
switch (userInput)
{
case INPUT_USE_OURS:
kdbGet (handle, myConfig, parentKey); // refresh key database
ksDel (myConfig);
myConfig = ours;
break;
case INPUT_DO_MERGE:
theirs = ksDup (ours);
kdbGet (handle, theirs, parentKey); // refresh key database
KeySet * res = doElektraMerge (ours, theirs, base);
ksDel (theirs);
myConfig = res;
break;
case INPUT_USE_THEIRS:
// should always work, we just write what we got
// but to be sure always give the user another way
// to exit the loop
kdbGet (handle, myConfig, parentKey); // refresh key database
break;
// other cases ...
}
ret = kdbSet (handle, myConfig, parentKey);
}
ksDel (ours);
ksDel (base);
ksDel (myConfig); // delete the in-memory configuration
kdbClose (handle, parentKey); // no more affairs with the key database.
keyDel (parentKey);
//! [set]
}
int main(int argc, char**argv)
{
Key *parentKey = keyNew("", KEY_END);
KDB *kdb = kdbOpen(parentKey);
KeySet *conf = ksNew(0);
// get all config files
kdbGetByName(kdb, conf, parentKey, "/test/lift");
kdbGetByName(kdb, conf, parentKey, "/test/material_lift");
kdbGetByName(kdb, conf, parentKey, "/test/heavy_material_lift");
kdbGetByName(kdb, conf, parentKey, "/test/person_lift");
// get by params
int retval = ksGetOpt(argc, argv, conf);
if (retval & 1)
{
printf("%s Version 0.1\n",
argv[0]);
return 0;
}
else if (retval & 2)
{
printf("Usage: %s [OPTIONS]\n"
"%s\n"
"Example that demonstrates elektra gen parameters\n",
argv[0],
elektraGenHelpText());
return 0;
}
else if (retval != 0)
{
printf ("Error in parsing options %d\n", retval);
}
// write back to user/test/lift what we got by commandline
// that means overrides in *_lift are still active, but
// fallbacks will be overriden.
if (lift(conf))
{
printf("Write out config\n");
keySetName(parentKey, "user/test/lift");
kdbSet(kdb, conf, parentKey);
}
ksDel(conf);
kdbClose(kdb, parentKey);
keyDel(parentKey);
return retval;
}
int main ()
{
// clang-format off
//! [cut]
Key * parentKey = keyNew ("system/mountpoint/interest", KEY_END);
KDB * kdb = kdbOpen (parentKey);
KeySet * ks = ksNew (0, KS_END);
kdbGet (kdb, ks, parentKey);
KeySet * returned = ksCut (ks, parentKey);
kdbSet (kdb, ks, parentKey); // all keys below cutpoint are now removed
kdbClose (kdb, parentKey);
//! [cut]
outputKeySet (returned);
outputKeySet (ks);
}
int main(int argc, char **argv)
{
kdbOpen ( );
QApplication app(argc, argv);
new EditorController();
//app.setMainWidget(main);
int ret = app.exec();
kdbClose ( );
return ret;
}
/** After writing the key this function rereads the key and print it*/
void check_key()
{
Key * error_key = keyNew(KEY_END);
KDB * kdb_handle = kdbOpen(error_key);
Key * top = keyNew(KEY_END);
keySetName(top, "user/sw/MyApp"); // == 14
KeySet * ks = ksNew(0);
kdbGet(kdb_handle, ks, top);
Key * key = keyNew(KEY_END);
keySetName(key, "user/sw/MyApp/Tests/TestKey1"); // == 14
Key * result = ksLookup(ks, key, KDB_O_NONE);
const char * key_name = keyName(result);
const char * key_value = keyString(result);
const char * key_comment = keyString(keyGetMeta(result, "comment"));
printf("key: %s value: %s comment: %s", key_name, key_value, key_comment);
ksDel(ks);
keyDel(key);
keyDel(top);
kdbClose(kdb_handle, error_key);
keyDel(error_key);
}
static void test_openclose (void)
{
printf ("test open & close\n");
// TODO test with ASAN and with & without cascading key
Key * key = keyNew ("system/sw/tests/testlib_notification", KEY_END);
KDB * kdb = kdbOpen (key);
exit_if_fail (kdb, "opening kdb failed");
succeed_if (!elektraNotificationClose (kdb), "could close notification system without open");
succeed_if (elektraNotificationOpen (kdb), "could not open notification system");
succeed_if (!elektraNotificationOpen (kdb), "could open notification system twice");
succeed_if (elektraNotificationClose (kdb), "could not close notification system");
succeed_if (elektraNotificationOpen (kdb), "could not re-open notification system");
// cleanup
succeed_if (elektraNotificationClose (kdb), "could not close notification system");
succeed_if (kdbClose (kdb, key) == 0, "could not close kdb");
keyDel (key);
}
int main (void)
{
KeySet * myConfig = ksNew (0, KS_END);
Key * key = keyNew ("/sw/MyApp", KEY_CASCADING_NAME, KEY_END);
KDB * handle = kdbOpen (key);
if (!handle) printError (key);
printWarnings (key);
if (kdbGet (handle, myConfig, key) < 0) printError (key);
printWarnings (key);
keyDel (key);
// lookup
Key * result = ksLookupByName (myConfig, "/sw/MyApp/Tests/TestKey1", 0);
if (!result)
printf ("Key not found in KeySet\n");
else
{
// do something with the key
const char * key_name = keyName (result);
const char * key_value = keyString (result);
const char * key_comment = keyString (keyGetMeta (result, "comment"));
printf ("key: %s value: %s comment: %s\n", key_name, key_value, key_comment);
}
ksDel (myConfig); // delete the in-memory configuration
// maybe you want kdbSet() myConfig here
kdbClose (handle, 0); // no more affairs with the key database.
}
void benchmarkOpen ()
{
kdb = kdbOpen (key);
}
/**
* gelektra_kdb_gi_open:
* @kdb: A #GElektraKdb
* @error key which holds errors and warnings which were issued
*
* \note This is for GObject Introspection.
* \note Do NOT use! Use gelektra_kdb_open instead
*/
void gelektra_kdb_gi_open (GElektraKdb * kdb, GElektraKey * error)
{
kdb->handle = kdbOpen (error->key);
}
/**
* gelektra_kdb_open: (constructor)
* @error key which holds errors and warnings which were issued
*
* Returns: (transfer full): A new #GElektraKdb
* see kdbOpen
*/
GElektraKdb * gelektra_kdb_open (GElektraKey * error)
{
return gelektra_kdb_make (kdbOpen (error->key));
}
int main (void)
{
printf ("lightweight zeromq message hub\n");
// exit on SIGINT
signal (SIGINT, onSignal);
KeySet * config = ksNew (2, KS_END);
Key * parentKey = keyNew ("/sw/elektra/hub-zeromq/#0/current", KEY_END);
Key * configXSubEndpoint = keyDup (parentKey);
keyAddBaseName (configXSubEndpoint, "bind_xsub");
Key * configXPubEndpoint = keyDup (parentKey);
keyAddBaseName (configXPubEndpoint, "bind_xpub");
KDB * kdb = kdbOpen (parentKey);
if (kdb == NULL)
{
printf ("could not open KDB. aborting\n");
return -1;
}
const char * xSubEndpoint = "tcp://127.0.0.1:6000";
const char * xPubEndpoint = "tcp://127.0.0.1:6001";
kdbGet (kdb, config, parentKey);
Key * xSubEndpointKey = ksLookup (config, configXSubEndpoint, 0);
if (xSubEndpointKey)
{
xSubEndpoint = keyString (xSubEndpointKey);
}
Key * xPubEndpointKey = ksLookup (config, configXPubEndpoint, 0);
if (xPubEndpointKey)
{
xPubEndpoint = keyString (xPubEndpointKey);
}
keyDel (configXSubEndpoint);
keyDel (configXPubEndpoint);
kdbClose (kdb, parentKey);
keyDel (parentKey);
context = zmq_ctx_new ();
xSubSocket = zmq_socket (context, ZMQ_XSUB);
xPubSocket = zmq_socket (context, ZMQ_XPUB);
int result;
result = zmq_bind (xSubSocket, xSubEndpoint);
if (result != 0)
{
printf ("could not bind XSUB on %s socket: %s\n", xSubEndpoint, zmq_strerror (zmq_errno ()));
zmq_close (xSubSocket);
zmq_close (xPubSocket);
zmq_ctx_destroy (context);
return -1;
}
result = zmq_bind (xPubSocket, xPubEndpoint);
if (result != 0)
{
printf ("could not bind XPUB on %s socket: %s\n", xPubEndpoint, zmq_strerror (zmq_errno ()));
zmq_close (xSubSocket);
zmq_close (xPubSocket);
zmq_ctx_destroy (context);
return -1;
}
printf ("listening on %s (XSUB for zeromqsend)\n", xSubEndpoint);
printf ("listening on %s (XPUB for zeromqrecv)\n", xPubEndpoint);
ksDel (config);
// forward messages between sockets
// will return on zmq_ctx_destroy()
zmq_proxy (xPubSocket, xSubSocket, NULL);
return 0;
}
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/wait.h>
pthread_barrier_t *bar;
void * writer (void * pV_data ELEKTRA_UNUSED)
{
Key * parent = keyNew ("user/test/race", KEY_END);
KDB *h = kdbOpen(parent);
char buffer[4096];
unsigned long tid = (unsigned long) pthread_self();
int pid = getpid();
sprintf(buffer, "user/test/race/keys/%d/%lu", pid, tid);
KeySet * ks = ksNew(20,
KS_END);
int retg = kdbGet(h, ks, parent);
ksAppendKey(ks,
keyNew (buffer, KEY_VALUE, "a value", KEY_END));
pthread_barrier_wait(bar);
int rets = kdbSet (h, ks, parent);
if (rets != -1)
