 |
Elektra 0.11.0
|
|
Elektra 0.11.0
|
For the base system you only need cmake3, Git, a C99 compiler and essential build tools (make and some standard Unix tools; alternatively ninja and clang are also supported but not described here). Those can be installed as follows:
Run the following commands to compile Elektra with non-experimental parts where your system happens to fulfill the dependencies (continue reading the rest of the document for details about these steps):
The last line only runs tests without writing onto your system. See TESTING for how to run more tests. Afterwards you can use sudo make install && sudo ldconfig to install Elektra. See INSTALL for more information about installation of self-compiled Elektra (such as how to uninstall it).
Note: You do not need to install the dependencies listed here. If they are not available, some of the functionality gets disabled automatically. The core of Elektra never depends on other libraries.
To build the documentation you need doxygen (we recommend 1.8.8+), graphviz and ronn-ng. These can be installed as follows:
To build PDF documentation you need pdflatex. You can install it as follows:
For dependencies of plugins, please refer to the README.md of the respective plugin.
A small subset of build dependencies to get you started:
Elektra uses CMake3. Tested are CMake version 3.0.2 and 3.7.2 among others.
To configure Elektra graphically (with curses) run (.. belongs to command):
and press c to configure the cache (might be necessary multiple times, and once on the first time in case you don‘t see any settings). After applying the desired settings, press g to generate the make file.
All options described here, can also be used with cmake rather than ccmake (.. does also here belong to the command):
For information what you can use as OPTION1 and OPTION2, see above. Note: You have to enclose a value with quotes "" if it contains a semicolon (;). E.g.:
Some scripts in the folder of the same name may help you running CMake.
You should be able to compile Elektra with any C99 compiler. For a list of compilers we test with have a look at:
Here is an additional list of compilers used by developers (for build servers, see links above):
| Compiler | Version | Target |
|---|---|---|
| gcc | gcc (Debian 8.3.0-6) 8.3.0 | x86_64-linux-gnu |
| gcc | gcc (Debian 10.2.1-6) 10.2.1 20210110 | x86_64-linux-gnu |
| gcc | gcc (GCC) 11.2.1 20220127 (Red Hat 11.2.1-9) | x86_64-redhat-linux |
| gcc | gcc (GCC) 12.2.1 20220819 (Red Hat 12.2.1-2) | x86_64-redhat-linux |
| gcc | gcc-12 (Homebrew GCC 12.2.0) 12.2.0 | x86_64-apple-darwin21 |
| gcc | Homebrew clang version 15.0.1 | x86_64-apple-darwin21.6.0 |
| clang | clang version 14.0.5 (Fedora 14.0.5-1.fc36) | x86_64-redhat-linux-gnu |
| clang | Apple clang version 14.0.0 (clang-1400.0.29.102) | x86_64-apple-darwin21.6.0 |
(¹) OpenBSD ships an old version of GCC per default, which can not compile Elektra. A manual installation of egcc/eg++ is required. Note that not every OpenBSD mirror provides the eg++ package. Elektra builds are confirmed with egcc/eg++ 4.9.4 in OpenBSD 6.3. The packages are called gcc and g++. Compile with
CC=/usr/local/bin/egcc CXX=/usr/local/bin/eg++.
To change the compiler, use CMake settings CMAKE_C_COMPILER and CMAKE_CXX_COMPILER.
To use gcc-4.3 for example
To change the compiler with ccmake, you may need to toggle advanced options (key t).
Some options, i.e. PLUGINS, BINDINGS and TOOLS are either:
;) (note that shells typically need ; to be escaped)ALL to include all elements (except elements with unfulfilled dependencies)NODEP to include all elements without dependencies-) to exclude an elementExamples for this are especially in the subsection PLUGINS below, but they work in the same fashion for BINDINGS and TOOLS.
Read about available plugins here.
Because the core of Elektra is minimal, plugins are needed to actually read and write to configuration files (storage plugins), commit the changes (resolver plugins, also takes care about how the configuration files are named) and also do many other tasks related to configuration.
The minimal set of plugins you should add:
KDB_DEFAULT_STORAGE to it.KDB_DEFAULT_RESOLVER to it.ENABLE_TESTING, except on mingw.)/sw/elektra/kdb/#0/current/plugins to a value not containing sync (e.g. an empty value). See kdb-mount(1).By default CMake adds nearly all plugins if the dependencies are present. Only experimental plugins will be omitted by default:
To add also experimental plugins, you can use:
Note that plugins are only built if their dependencies are satisfied. So make sure to install all dependencies you need before you run
cmake. For example, to include the pluginyajl, make surelibyajl-devis installed.
To add all plugins except some plugins you can use:
For example, if you want all plugins except the jni plugin you would use:
To add all plugins not having additional dependencies (they need only POSIX), you can use
Note, that every infos/provides and infos/status field written uppercase can be used to select plugins that way (see README of individual plugins). You also can combine any of these fields and add/remove other plugins to/from it, e.g. to include all plugins without deps, that provide storage (except yajl) and are maintained, but not include all plugins that are experimental, you would use:
The inclusion is determined by following preferences:
-pluginplugin-CATEGORYCATEGORYNote, that changing PLUGINS will not modify the defaults used after Elektra was installed. For this endeavour you need to change:
and
The default resolver and storage will write to KDB_DB_FILE and KDB_DB_INIT (for bootstrapping).
Obviously, you can pass the exact list of plugins you want, e.g.:
Some plugins are compile-time configurable. Then you can choose which features are compiled in or out. This is especially important in the bootstrapping phase, because then only the compiled in configuration applies. To compile-time-configure a plugin, you just pass a underscore (_) and flags after the name of the plugin.
The resolver for example distinguish between 3 different kind of flags:
The following base flags are available:
c for debugging conflictsf for enabling file lockingm for enabling mutex lockingThe user flags are (the order matters!):
p use passwd/ldap to lookup home directory using getpwuid_rh use the environment variable HOMEu use the environment variable USERb use the built-in default CMake variable KDB_DB_HOMEThe system flags are (the order matters!):
x use the environment variable XDG_CONFIG_DIRS (: are interpreted as part of filename, no searching is done!) This option is not recommended (unless for testing), because it allows users to fake system configuration.b use the built-in default CMake variable KDB_DB_SYSTEM/) is chosen, the system flags are irrelevant and the path is taken as-is.For example, one may use:
To add resolver_l_h_b you need to specify
You can add resolver with any combination of the flags, even if they are not available in ALL.
Tools are used to add extra functionality to Elektra. The flag used to specify which tools are compiled is -DTOOLS, thus flag works similarly to the -DPLUGINS flag, but is more limited in its functionality (which does not matter, because there are not so many tools).
To add all non-experimental tools, you can use::
Note that the behavior is different to PLUGINS which includes all PLUGINS if ALL is used.
To add all tools except of race, you can use:
To specify specific tools you can use, e.g.:
Bindings are used in a like as PLUGINS. For example, to build all maintained bindings and exclude experimental bindings you can use:
The SWIG executable may be specified with:
If this option is not used, CMake will find the first occurrence of swig in your environment's path.
Some bindings provide different APIs (and not a different language), e.g:
gsettingsINTERCEPT with intercept_fs and intercept_envIO with io_uvTo not add such APIs, but only swig bindings and cpp, you can use:
For a list of available bindings see binding's README.md.
Debug, Release or RelWithDebInfo See help bar at bottom of ccmake for that option or: https://www.cmake.org/Wiki/CMake_Useful_Variables
BUILD_SHARED is the typical build you want to have on systems that support dlopen. It can be used for desktop builds, but also embedded systems as long as they support dlopen, for example, BUILD_SHARED is used on OpenWRT with musl. Using BUILD_SHARED every plugin is its own shared object.
BUILD_FULL links together all parts of Elektra as a single shared .so library. This is ideal if shared libraries are available, but you want to avoid dlopen. Some tests only work with BUILD_FULL, so you might turn it on to get full coverage.
BUILD_STATIC also links together all parts but as static .a library. It is only useful for systems without dlopen or if the overhead of dlopen needs to be avoided.
All three forms of builds can be intermixed freely.
For example, to enable shared and full build, but disable static build, one would use:
Build documentation with doxygen (API) and ronn-ng (man pages).
If ronn-ng is not found, already compiled man pages will be used instead.
Note: Turning off building the documentation, also turns off installing the documentation, see https://issues.libelektra.org/2522 Then no man pages are available.
Build documentation with LaTeX.
See Documentation dependencies for the required dependencies.
As developer you should enable ENABLE_DEBUG and ENABLE_LOGGER:
ENABLE_DEBUG:ENABLE_LOGGER: enables logging By default no logging will take place, see CODING for how to get log messages.Continue reading testing for more information about testing.
CMAKE_INSTALL_PREFIX defaults to /usr/local. So by default most files will be installed below /usr/local. Exceptions to this are files handled by INSTALL_SYSTEM_FILES.
Edit that cache entry to change that behavior. Also called system prefix within the documentation.
If you want to create a package afterwards it is ok to use paths that you can write to (e.g. -DCMAKE_INSTALL_PREFIX=/home/username/)
Lets you install libraries into architecture specific folder. E.g. for 32/64 bit systems you might install libraries under lib64. Set LIB_SUFFIX to 64 to achieve exactly that. So the system library folder will be CMAKE_INSTALL_PREFIX/lib64 then.
By default include folders will be installed below CMAKE_INSTALL_PREFIX/include/elektra. This entry let you change the elektra. If the entry is empty, the include files will be installed directly to CMAKE_INSTALL_PREFIX/include.
Similar to above, but with the plugins. Default is: CMAKE_INSTALL_PREFIX/lib${LIB_SUFFIX}/elektra It can be also left empty to install plugins next to other libraries.
This value specifies the root directory of a local copy of the Google Test framework.
""), then the build system will download a copy of Google Test into the build directory.CMakeLists.txt in the top level directory of GTEST_ROOT. If this file exists, then the build system will use the sources files at GTEST_ROOT to translate tests that use Google Test.It can be provided as CMake or environment variable. If both options are provided the value passed via CMake takes precedence.
It is recommended that you browse through all the options using ccmake. Afterwards press c again (maybe multiple times until all variables are resolved) and then g to generate. Finally press e to exit.
Specifies that the build tools, i.e. elektra-export-symbols and elektra-export-symbols are installed (by default off). Is needed for cross-compilation.
Some of Elektra’s targets require to be installed into specific folders in the file system hierarchy to work properly.
This variable is disabled by default, since it requires the install target to have the rights to write into the corresponding folders. Set -DINSTALL_SYSTEM_FILES=ON, if you also want to install the files listed below.
If you do not have root rights you can also copy the files manually to your user folder.
Currently the installed system files are as following:
| Module | Description | Install Path |
|---|---|---|
| bash-completion | bash tab auto completion file | completionsdir from pkg-config (¹) |
| zsh-completion | zsh tab auto completion file | /usr/share/zsh/vendor-completions |
| GIR | introspection file for bindings | INTROSPECTION_GIRDIR from pkg-config |
| GSettings | GSettings backend module | GIO_MODULE_DIR from pkg-config |
(¹) Or
/usr/share/bash-completion/completionsas fallback.
In order to keep the binaries as small as possible this flag allows trading memory for speed.
To build the source use:
You can pass:
-j for parallel buildsVERBOSE=1 to see the invocations of the compilerContinue by reading INSTALL.
You can build Elektra using Code::Blocks under Gentoo:
Precondition: Make sure you have a compiler, xml2 (for kdb tool) and xsl (see later) installed. cmake configure will help you with that, it will make sure you don't forget something essential.
For Most Linux system all you have to do is open up a console and
Note 1: You can use other editor if you like just type cmake at the console to get a list of option you can pass to cmake as long as well as a list of what code editor project cmake can create.
Note 2: For Unix if you have nCurses install you can run ccmake to set important option after running cmake like to enable debug symbol.
Note 3: For Gentoo it's recommended to emerge sys-apps/lsb-release to name the package right even thou not required.
On multiarch (multiple architectures installed in one system), you need to set LIB_SUFFIX. For example, if you want to have the binaries in lib64 and lib32, you would use for the libraries to be installed in ${CMAKE_INSTALL_PREFIX}/lib64:
If there is a directory for different architectures, simply prepend an /. For example, for Debian:
By default Elektra uses RPATH to hide its plugins. This makes it obvious that external applications should not link against plugins. Instead every application should use the elektraModulesLoad() API to load Elektra’s modules.
The folder where the plugins are located is a subdirectory of where the libraries are installed. The name of the subdirectory can be specified using TARGET_PLUGIN_FOLDER and is elektra by default. You might want to encode Elektra’s SOVERSION into the folders name, if you want different major versions of Elektra be co-installable.
Elektra’s use case for RPATH is considered acceptable, so we recommend using it because:
ld.so.cacheLIB_SUFFIX is also honored for plugins)RPATH supports exactly that because it even overrides LD_LIBRARY_PATH.Unfortunately, there are also drawbacks:
RPATH is decided at compile-time, so you cannot simply move Elektra’s installations within the file system (e.g. from /usr/local to /usr)ld.so implementations that honor RPATH from libraries. This is the case for most libc implementations including Linux and macOS, but not for, e.g., musl.If you want Elektra to not use RPATH, you can add:
Then all plugins are directly installed to the library directory and loaded like other libraries (in any of ld.so paths).
Alternatively, which gives you the advantage not to clutter the main library path, is to add the plugin folder in /etc/ld.so.conf.d/elektra. Note that it still allows applications to link against plugins.
Please enable EPEL https://fedoraproject.org/wiki/EPEL
For Bindings swig3 is recommended. swig2 only works on some distributions. E.g., for Debian Jessie the bindings will crash.
At time of writing, no swig 3 was available, not even in EPEL. Thus you need to install swig3 manually:
Also, no ronn-ng was available, thus you need to do:
In Elektra cross compiling needs two steps. If you get errors like elektra-export-errors_EXE_LOC not found, go on reading.
In the first step, you need to compile Elektra for the host architecture and install the build tools:
Where must be a directory to be found in the later build process. In particular, /bin must be in a directory found by a later find_program.
Then you need to compile Elektra again, but for the target architecture. Now, the build tools such as elektra-export-errors should be found in the /bin where they were installed before.
For reference, you can look into the OpenWRT Elektra Makefile and the CMake in OpenWRT.
1.9.1