0.9.5 Release

• guid: 8a56a045-3d2e-427d-84bb-8256635159d2
• author: Mihael Pranjic
• pubDate: Mon, 12 Apr 2021 08:43:05 +0200
• shortDesc: Java Binding Improvements, Breaking Change to kdbOpen

We are proud to release Elektra 0.9.5.

What is Elektra?

Elektra serves as a universal and secure framework to access
configuration settings in a global, hierarchical key database.
For more information, visit https://libelektra.org.

You can also read the news on our website

You can try out the latest Elektra release using our docker image elektra/elektra.
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run
docker run -it elektra/elektra.

Highlights

• Breaking change to kdbOpen. see below
• Ongoing improvements of Java bindings and publishing of bindings to maven central for easy dependency integrations in Java projects

kdbOpen Contracts

The signature of kdbOpen has been changed from

KDB *  kdbOpen (Key * errorKey);

to

KDB * kdbOpen(const KeySet * contract, Key *parentKey);

You can use kdbOpen (NULL, errorKey) to get the same behaviour as before.

The new parameter contract is similar to what could be done via kdbEnsure (which has been removed).
Currently, the contract allows you to mount global plugins and add data into the global KeySet (passed to all plugins)
during kdbOpen. This alone is already quite powerful, but we might more functionality in future releases.

For now, there are three use cases for the contract parameter. All of them are covered by helper functions:

int elektraGOptsContract (KeySet * contract, int argc, const char * const * argv, const char * const * envp, const Key * parentKey, KeySet * goptsConfig);
int elektraIoContract (KeySet * contract, ElektraIoInterface * ioBinding);
int elektraNotificationContract (KeySet * contract);

With elektraGOptsContract you can mount and set up the gopts plugin used for command-line argument parsing.
The other two functions are the new way to configure Elektra's notification feature.

For more information take a look at doc/dev/kdb-contracts.md

Plugins

The following section lists news about the plugins we updated in this release.

Cache

• The cache plugin now only caches the parts of the global keyset that are below system:/elektra/cache or below
  system:/elektra/cached. The part below system:/elektra/cache is meant for internal data of the cache, so you
  should put data below system:/elektra/cached, if you want it to be cached. (Klemens Böswirth)

internalnotification

• Fix use of kdb_long_double_t on armel platforms (#3450). (Mihael Pranjić)

Dbus & Dbusrecv

• Internal changes to ensure compatibility with the new elektraNotificationContract. (Klemens Böswirth)

YAML Smith & Yan LR

• Removed plugins yamlsmith and yanlr. (René Schwaiger)

Zeromqsend & Zeromqrecv

• Internal changes to ensure compatibility with the new elektraNotificationContract. (Klemens Böswirth)

Libraries

The text below summarizes updates to the C (and C++)-based libraries of Elektra.

Compatibility

• keyCopy and keyDup now take an additional flag. See below.
• kdbEnsure was removed and integrated into kdbOpen, which now takes an additional KeySet * contract parameter. See above

Core

• The keyCopy and keyDup functions have been changed. They now take a flags argument which specifies which parts
  of the Key should be copied.
  The API also changed slightly. Most importantly NULL values are handled differently. For example, keyDup (NULL, KEY_CP_ALL)
  returns a key similar to what keyNew ("/", KEY_END) produces, whereas previously keyDup (NULL) returned NULl.
  (Klemens Böswirth)
• We added keyReplacePrefix, a function that allows you to easily move a key from one parent to another. (Klemens Böswirth)
• kdbEnsure was removed and replaced by similar functionality added to kdbOpen. see above (Klemens Böswirth)
• KEY_END is now defined as (void *) 0 instead of 0. This allows us to mark keyNew with the GCC attribute
  __attribute__ ((sentinel)), which causes a compiler warning, if keyNew calls don't use KEY_END as their last argument.
  (Klemens Böswirth)

Io

• elektraSetIoBinding has been removed. Use elektraIoContract instead. (Klemens Böswirth)

Notification

• elektraNotificationOpen has been removed. Use elektraNotificationContract instead.
  elektraNotificationClose has also been removed. There is no replacement, cleanup now happens automatially during
  kdbClose. (Klemens Böswirth)
• The contract for transport plugins has been changed. The exported functions "openNotification", "closeNotification" and"setIoBinding"are no longer used. Instead, plugins should retrieve the I/O binding from the keysystem:/elektra/io/bindingin the global keyset. The notification callback and context that were passed to"openNotification", can now be read from the global keyset as well. The keys aresystem:/elektra/notification/callbackandsystem:/elektra/notification/context` respectively.
  (Klemens Böswirth)

Bindings

Bindings allow you to utilize Elektra using various programming languages. This section keeps
you up to date with the multi-language support provided by Elektra.

JNA

• Since internal iterator support for KeySet is due to being dropped, the following methods have been removed:

  • Elektra::ksNext
  • Elektra::ksCurrent
  • Elektra::ksGetCursor
  • Elektra::ksSetCursor
  • KeySet::next
  • KeySet::current
  • KeySet::rewind
  • KeySet::getCursor
  • KeySet::setCursor

  Until internal KeySet iterator support has been dropped form native library, Elektra::ksRewind is being retained while also being annotated as 'deprecated for removal'. The reason is, that we still need to rewind a KeySet before passing it to a native plugin via NativePlugin::set, NativePlugin::get or NativePlugin::error. (Michael Tucek)

  Furthermore Elektra::ksPop and KeySet::pop have been removed and KeySet::remove has been introduced as replacment.
  Until internal KeySet iterator support has been dropped form native library, Elektra::ksRewind is being retained while also being annotated as 'depricated for removal'. The reason is, that we still need to rewind a KeySet before passing it to a native plugin via NativePlugin::set, NativePlugin::get or NativePlugin::error. (Michael Tucek)

  Further more Elektra::ksPop and KeySet::pop have been removed and KeySet::remove has been introduced as replacment. (Michael Tucek)

• Renamed KeyException specializations: KeyInvalidNameException, KeyTypeConversionException, KeyTypeMismatchException

• Migration from Maven to Gradle (Michael Tucek)

• Updated documentation for usage of published artifacts (Michael Tucek)

• Integration of Maven Central publishing on Elektra release (Robert Sowula)

Outlook

Ongoing work on bringing the JNA binding up to scratch and improving developer experience. Both for JNA binding API consumers, as well as future JNA binding contrubutors. (Michael Tucek)

Python & Lua

Add support for keyset.remove(key). (Manuel Mausz)

Tools

• webd: update ini, y18n and elliptic dependencies. (Mihael Pranjić)
• Make search for providers not skip rest of plugins on exceptions. (Markus Raab)

Examples

• Fix enums in examples/spec. (Markus Raab)

Documentation

• Document names of different components. (Markus Raab)
• Update buildserver documentation (Robert Sowula)
• Reworked METADATA.ini (Markus Raab)
• Minor rewording in INSTALL.md (@a-kraschitzer)
• Write notes that \\ are due to shell recorder, and are not to be copied (Markus Raab)
• Add link to Go bindings (Markus Raab)
• Fix order of tutorials (Markus Raab)
• Added API-Reviews for multiple functions in the public API (Stefan Hanreich)
• Minor rewording in java-kdb.md (@aaronabebe)
• Added a short Visual Studio 2019 tutorial (/doc/tutorials/contributing-windows.md) (Dominic Jäger)
• Added hint regarding WSL filesystem configuration (/doc/tutorials/contributing-windows.md) (@tucek)
• Fixed broken link in yanlr-plugin readme (@lawli3t)
• Minor readability improvement in highlevel.md (Tobias Schubert @qwepoizt)
• Fix examples of spec plugin. (Robert Sowula)

Tests

• Added small test for jna Return plugin (Return.java), KeyNameIterator.java (@aaronabebe)

Packaging

• Change shlibs version compatibility policy of Debian packages to ">=". (Robert Sowula)
• Automate publishing of the release Elektra Docker images. (Robert Sowula)

Build

CMake

• Fix issue where the library runpaths of the jni plugin could not be resolved. (Robert Sowula)

Docker

• Update Alpine Linux images to version 3.13.1 and update Elektra release image. (Mihael Pranjić)

Infrastructure

Cirrus

• Update FreeBSD images from version 12.1 to 12.2 (Robert Sowula)
• Update brew before installing packages and print brew config. (Mihael Pranjić)
• Restart dbus service before running tests and find `DBUS_LAUNCHD_SESSION_...

0.9.4 Release

• guid: a3f66c2f-ae6a-412b-bdbd-f8950adb2334
• author: Mihael Pranjic
• pubDate: Mon, 01 Feb 2021 22:54:30 +0100
• shortDesc: Key Name Improvements, Debian and Fedora Packaging

We are proud to release Elektra 0.9.4.

What is Elektra?

Elektra serves as a universal and secure framework to access
configuration settings in a global, hierarchical key database.
For more information, visit https://libelektra.org.

You can also read the news on our website

Highlights

• Important Breaking Changes to key names et al. see below
• Debian and Fedora Packaging with CPack see below

Important Breaking Changes

• The structure of key names has been changed. see below (Klemens Böswirth)
  
  This change breaks mountpoint configurations.
  Please follow the upgrade procedure shown below.
• The backend fallback procedure introduced in Elektra 0.8.15 has been removed and the structure of the warnings metadata array has been changed. see below (Klemens Böswirth)
• We removed the ini plugin (superseded by the TOML plugin), the null plugin (superseded by the base64 plugin) and the tcl plugin (Markus Raab, Philipp Gackstatter)

Important Changes to Key Names

There have been significant changes to Elektra's key names:

• The most important change is that you now need a : after the namespace.
  So instead of system/elektra/version you have to use system:/elektra/version.

• The second big change is to array elements.
  From now on keyNew ("/array/#10", KEY_END) will create a Key with name /array/#_10, to make arrays more user-friendly by preserving numerical ordering.

• The whole implementation for keySetName, keyAddName, etc. has been completely rewritten.
  If you rely on specific behaviour of Elektra's key names and have already taken the two changes above into account, please refer to the newly created key name documentation and Python reference implementation.

• Metakeys now use the namespace meta:/.
  The accessor functions keyGetMeta and keySetMeta automatically add this namespace to preserve compatibility.
  However, if you use the recently introduced keyMeta or otherwise directly access the key name of a metakey, you will have to update your code.

• default:/ is a new namespace used for keys that exist purely to represent a default value (e.g. generated by the spec plugin).

  Looking up cascading keys with ksLookup now looks at namespaces in the following order:

  • proc:/
  • dir:/
  • user:/
  • system:/
  • default:/
  • / (cascading key itself)

  The final lookup of the cascading key itself, will be removed in a future release.
  Please update your code to generate default:/ keys, if you rely on this feature.

  Note: The spec plugin already generates default:/ keys.

• The function keyInactive has been removed.
  The concept of inactive keys no longer exists, use comment/# instead.

• ElektraNamespace is the new C++ enum class for the Elektra's namespaces.
  You should prefer it to using KEY_NS_SYSTEM et al. directly, if you use C++.

• keyGetFullName et al. have been removed. The concept of a "full name (with owner)" no longer exists.

A huge thanks to (Klemens Böswirth) for doing these important changes and clean-ups.

Mountpoint upgrade

The change to key names breaks existing mountpoint configurations.

It is not hard to fix the mountpoint configs even after the updating to the new version.

There are two places that will still contain the old syntax after the update:

1. Every key below (and including) system:/elektra/mountpoints/<MOUNTPOINT> uses an old key names as <MOUNTPOINT>, if the mountpoint was created with kdb mount.
2. The value of all keys matching system:/elektra/mountpoints/*/mountpoint must be valid key names.

Fixing the first instance is optional.
There the key name is just used to create a unique name for the mountpoint.

The second instance, however, must be fixed or Elektra will be unusable.

Disclaimer: We cannot guarantee that the commands below work for all cases.
We also make no guarantees that the command will not break things.

Please report any problems.

You have been warned. Manually backup important data first.

For the migration you can use the following commands:

#! /usr/bin/env sh
kdb export system:/elektra/mountpoints ni > mountpoints.ini
sed -E 's~((^\[?|/mountpoint = )(user|system))((\\\\)?/)~\1:\4~g' mountpoints.ini > mountpoints_corrected.ini
kdb mv -r system:/elektra/mountpoints system:/elektra/mountpoints-backup
kdb import system:/elektra/mountpoints ni < mountpoints_corrected.ini

Note: The original system:/elektra/mountpoints data will be moved to system:/elektra/mountpoints-backup

Debian and Fedora Packaging with CPack

We are now using CPack to generate modular Debian, Ubuntu (DEB) and Fedora (RPM) packages. This simplifies the packaging process and solves problems where a PR, which introduces changes to installed files, fails. We can now also set distribution specific dependencies with CPack, which is needed for some packages. (Robert Sowula)

We now provide DEB and RPM packages for releases and for every commit on master in our own repositories using CPack for:

• DEB packages for Debian Buster
• DEB packages for Ubuntu Bionic
• DEB packages for Ubuntu Focal
• RPM packages for Fedora 33

A big thanks to (Robert Sowula) for introducing CPack and creating the repositories.

Short Installation Guide

DEB packages

1. First, you need to obtain the repository key:

sudo apt-key adv --keyserver keys.gnupg.net --recv-keys F26BBE02F3C315A19BF1F791A9A25CC1CC83E839

2. Add deb https://debs.libelektra.org/<DISTRIBUTION> <DISTRIBUTION> main into /etc/apt/sources.list
   where <DISTRIBUTION> is the codename of your distributions e.g. focal, bionic or buster.

apt-get install libelektra5-all

RPM packages

Download our .repo configuration file and add it to yum/dnf.

To get all packaged plugins, bindings and tools install:

dnf install libelektra5-all

For more available packages, further instructions on how to add our repositories or instructions on how to use our master built packages, please refer to our install documentation.

Version Bump

The 0.9.* series of Elektra is for development of Elektra 1.0.
Elektra 1.0 will be incompatible to 0.8 and as such, we need a SO version bump.
We used this release to bump the SO version from 4 to 5 due to the breaking changes that are not visible in the API.

Note: that within 0.9.* we likely introduce further breaking changes but we will not bump the SO version again.

The package names which consist of the SO Version also changed from libelektra4* to libelektra5*.
If you used our previous repository with master built packages, please make sure to migrate to our new package repositories described above or in our install documentation.

The version of the Java bindings was also bumped from 4 to 5, although the API is also work in progress.

A big thanks to (Robert Sowula) for doing the necessary renamings.

Plugins

The following section lists news about the plugins we updated in this release.

jni

• Fix rare memleak when the jni plugin is closed. (Mihael Pranjić)

mINI

• We changed the provides clause in the plugin contract. Now mINI offers support for the properties format (storage/properties) instead of the INI file format (storage/ini). This makes sense, since the plugin never supported the section syntax of INI files. (René Schwaiger)

Quickdump

• Support for the old quickdump v1 and v2 formats has been removed. (Klemens Böswirth)

Simple INI

• The plugin contract now correctly states that the plugin offers support for the properties format. Before it would state that the plugin offered support for the INI file format. This is not true, since the plugin does not support the section syntax of the INI file format.

YAML CPP

• We fixed an use after free bug in the plugin. (René Schwaiger)

Yan LR

• The plugin now works (with and) requires ANTLR 4.9. (René Schwaiger)

Libraries

The text below summarizes updates to the C (and C++)-based libraries of Elektra.

Compatibility

• We removed the fallback procedure introduced in Elektra 0.8.15 (using KDB_DB_FILE (default.ecf) for system:/elektra, if the bootstrap backend KDB_DB_INIT (elektra.ecf) isn't found).
  If you still rely on this feature, either use kdb upgrade-bootstrap before upgrading, or manually extract system:/elektra into elektra.ecf.
• There was an update to how warnings are generated.
  For users this means that the warnings metadata now forms a proper array.
  Specifically, the first 100 warnings are stored below to the meta keys warnings/#0, warnings/#1, ..., warnings/#9, warnings/#_10, ..., warnings/#_99.
  After that, warnings will wrap around, so the 101st warning...

0.9.3 Release

• guid: 9b9e8889-0c77-45ce-8441-8bdf26a110ac
• author: Mihael Pranjic
• pubDate: Fri, 30 Oct 2020 23:03:43 +0100
• shortDesc: TOML Storage Plugin

We are proud to release Elektra 0.9.3.
This release again brings us a big step towards Elektra 1.0.
It introduces the new soon-to-be-default storage plugin: TOML.

What is Elektra?

Elektra serves as a universal and secure framework to access
configuration settings in a global, hierarchical key database.
For more information, visit https://libelektra.org.

You can also read the news on our website

You can try out the latest Elektra release using our docker image elektra/elektra.
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run
docker run -it elektra/elektra.

TOML

The highlight of this release is the TOML plugin.
The TOML plugin has a similar huge feature set as the INI plugin,
but is written in a much cleaner and more maintainable way using flex and bison.
Furthermore, it follows the popular TOML spec.

It has nearly no run-time dependency, it only needs base64 if binary values are needed.

A huge thanks to Jakob Fischer for this amazing work!

Warning: In one of the following 0.9.* releases, INI will be removed and TOML will become the
default plugin. If you are using INI, please migrate to TOML now.

Plugins

The following section lists news about the plugins we updated in this release.

xmltool

• Values of KDBStream changed to fit with elektraKeyFlags: recompilation of application is needed. (Markus Raab)

TOML

• Added the TOML plugin, which can read and write TOML files using flex and bison. (Jakob Fischer)
• Removed the null plugin dependency of the plugin. (Jakob Fischer)
• The type metakey is now set for numbers on reading. (Jakob Fischer)

dump

• The dump plugin got a major update. The new version can read old files, but only write new files.
  The new files cannot be read by the old version of the plugin and will result in a "version error" message. (Klemens Böswirth)
• The new version stores keynames relative to the mountpoint, so exported dump files can now be imported into a different mountpoint. (Klemens Böswirth)
• dump no longer writes unnecessary zero-bytes into files. This means that as long as all key-values are human-readable, so is the dump output.
  This makes dump usable for tests and demo purposes, as it is a very simple format closely modelled after a KeySet's structure.
  This also makes it much easier to manually fix broken dump files.
  You only need a text editor most of the time. (Klemens Böswirth)

Compatibility

Elektra 0.9.* does not make any compatibility promises, as we want a clean 1.0.0 release.
In this release, we did the following changes:

• keyswitch_t renamed to elektraKeyFlags. (Markus Raab)
• option_t renamed to elektraLockFlags and elektraLookupFlags. (Markus Raab)
• cursor_t renamed to elektraCursor. (Markus Raab)

Note: We made this release before merging larger changes.
Please expect more fundamental changes in the next releases.

Errors

• Improved error messages. (Markus Raab)

Bindings

Bindings allow you to utilize Elektra using various programming languages. This section keeps
you up to date with the multi-language support provided by Elektra.

JNA

• Made examples work again. (Markus Raab)

Scripts

• Fix googletest framework path in debian configure script. (Mihael Pranjić)

• The fish completion script does not fail any more, if you try to complete a simple
  command that expects a namespace. For example, completing

  kdb ls ‸

  with the tab key (⇥) (‸ represents the current cursor position) should work correctly again. (René Schwaiger)

• The formatting scripts using prettier now use npx, which is included in npm
  v5.2.0 or newer. This allows us to specify an exact version of prettier to use. (Klemens Böswirth)

• The reformat-shell script now accepts the alias shfmt2, in case shfmt v3 is needed for another project. (Klemens Böswirth)

• The config for restyled.io now specifies the image to use for each formatter. This clearly reflects the version used for
  formatting. (Klemens Böswirth)

• Add a release script to automate the release process. (Robert Sowula)

Documentation

• Updated GOALS.md. (Markus Raab)
• Describe hierarchy and limitations of hosts plugin. (Markus Raab)
• The Doxygen PDF documentation now also requires the packages
  • stix (part of texlive-fonts-extra) and
  • stmaryrd (part of texlive-science or texlive-math-extra). (René Schwaiger)
• Write down some fundamental decisions,
  mostly about key names and key set structure. (Markus Raab in discussions with Klemens Böswirth)

Tests

• Fixed the is_not_rw_storage function. (Lukas Kilian)
• We now ensure that the check_import and check_export tests run for at least one plugin. (Lukas Kilian)

Build

CMake

• make uninstall also uninstalls symlinks. (Markus Raab)
• external-links.txt and extra_install_manifest.txt are cleaned up at cmake runs. (Markus Raab)
• Increased CTest timeout for testscr_check_kdb_internal_suite due to timouts reached on slow test machines. (Mihael Pranjić)

Docker

• Added Alpine Linux docker image with latest Elektra installed. This image is published on docker hub as elektra/elektra.
  We will update the image for each Elektra release such that novices can easily test Elektra without compiling or installing. (Mihael Pranjić)
• Remove unused libgtest-dev from docker images. (Mihael Pranjić)
• Add Ubuntu Focal (20.04) docker image. (Robert Sowula)
• Update Alpine Linux docker image to 3.12.1. (Mihael Pranjić)

Infrastructure

Cirrus

• Update FreeBSD images from version 11.3 to 11.4. (Mihael Pranjić)
• Increase CPU count for containers to 4. (Mihael Pranjić)
• Use Ruby 2.7 on macOS. (Mihael Pranjić)
• Export Python 3.8 path for macOS builds. (Mihael Pranjić)

Jenkins

• Temporarily resolve cyclic dependency between go-elektra and libelektra builds. (Mihael Pranjić)
• Add a new Jenkinsfile for release automation. (Robert Sowula)
• Our release pipeline now also builds deb packages for Ubuntu Focal (20.04). (Robert Sowula)

Travis

• Update macOS builds to use GCC 10, Ruby 2.7.1 and Xcode 12.2. (Mihael Pranjić)
• Increase wait time on builds to fix build timeout errors ("No output has been received in the last 10m0s"). (Mihael Pranjić)
• Export Python 3.9 path for macOS builds. (Mihael Pranjić)

Website

The website is generated from the repository, so all information about
plugins, bindings and tools are always up to date. Furthermore, we changed:

• Renamed the source folder of the website and removed the backend. (Markus Raab)
• Use strict dependency injection for website modules. (Marvin Mall)
• Added package-lock.json to ensure repeatable builds. (Marvin Mall)

Decisions

We are intensively working on Elektra 1.0.
The last details of the semantics of Elektra 1.0 are in discussion.
The decisions are documented, but some of them
are not finalized.

If you are interested in the discussions, please
subscribe.

Outlook

We are currently working on following topics:

• Elektrify KDE (Dardan Haxhimustafa), (Felix Resch) and (Mihael Pranjić)
• Elektrify GNOME (Mihael Pranjić)
• Default TOML plugin (Jakob Fischer)
• Improve Plugin Framework (Vid Leskovar)
• Keyname Overhaul (Klemens Böswirth)
• Continious Releases (Robert Sowula)
• FUSE Integration (Alexander Firbas)
• 1.0 API (Philipp Gackstatter)
• Improve 3-way merge (Dominic Jäger)
• Shell completion (Ulrike Schäfer)
• Improve Elektra developer experience (Hani Torabi)
• Ansible bindings (Thomas Waser)

Statistics

We closed 15 issues for this release.

About 17 authors changed 533 files with 26133 insertions(+) and 15834 deletions(-) in 545 commits.

Thanks to all authors for making this release possible!

Join the Initiative!

We welcome new contributors!
Read here about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our issue tracker.

Get the Release!

You can download the release from here
or GitHub

The hashsums are:

• author: mpranj
• name: elektra-0.9.3.tar.gz
• size: 7540609
• md5sum: 649fe13100266ab0e9a4cd19b99e2049
• sha1: 02900ef5c8b24cf067930068c62f2ff09b44354d
• sha256: 5022a6ebf004d892ded03fcf6eb3d223942a7fadd2d68f14d847d1f7f243e1d7

The release tarball is also available signed by Mihael Pranjić using GnuPG from
[here](https://www.libelektra.org/ftp/el...

0.9.2 Release

• guid: ea79f59e-f471-4658-a11b-1371802814c2
• author: Mihael Pranjic
• pubDate: Tue, 26 May 2020 19:33:30 +0200
• shortDesc: KDE and GNOME Integration, elektrad in Go

We are proud to release Elektra 0.9.2.

With the 0.9.x series of releases we shift our focus to bugfixes and stability improvements as needed for the KDE and GNOME integration.
We do not guarantee any compatibility in this series.

What is Elektra?

Elektra serves as a universal and secure framework to access
configuration settings in a global, hierarchical key database.
For more information, visit https://libelektra.org.

You can also read the news on our website

Highlights

• KDE integration
• GNOME Integration
• elektrad rewritten in Go

KDE Integration

We created a fork of KDE's KConfig configuration system and patched it to use libelektra. We have done some initial testing and replaced the KConfig library for Kate and KDevelop successfully.

Additionally, we added a new Elektra plugin called kconfig, which can read and write kconfig's INI files.
The plugin enables smooth migration of existing KDE configurations. (Dardan Haxhimustafa) and (Felix Resch)

GNOME Integration

We continued work on Elektra's bindings for GNOME GSettings. Our implementation should be able to replace the widely used dconf backend. Elektra's gsettings bindings are not yet ready for production use, but they are already able to replace dconf for a complete GNOME session without problems. We are still lacking proper dbus integration for change notifications. (Mihael Pranjić)

elektrad rewritten in Go

elektrad provides an HTTP API to access Elektra remotely. elektrad is now completely rewritten in Go, which drastically improves the performance by leveraging the new go-elektra bindings instead of calling the kdb command-line tool on every request. The new elektrad creates a session per user to reuse the same KDB handle for correct conflict handling and better performance. (Raphael Gruber)

Try out Elektra

You can try out the latest Elektra release using our docker image elektra/elektra. This is the quickest way to get started with Elektra without compiling and other obstacles.

Get started with Elektra by running docker run -it elektra/elektra.

Plugins

We removed the maintained status of the following plugins:

• blockresolver
• csvstorage
• gitresolver
• list
• multifile
• spec

New maintainers are very much welcomed!

Augeas

• Improved error message for Augeas to show lensPath. (Michael Zronek)

CCode

• The Markdown Shell Recorder test of the plugin does not require Bash any more. (René Schwaiger)

Crypto

• The crypto plugin no longer supports Botan and OpenSSL as provider of cryptographic functions. The support has been removed to improve the maintainability of the code. (Peter Nirschl)
• The unit test of the crypto plugin attempts to kill the gpg-agent if a regular shutdown via connect-gpg-agent failed. (Peter Nirschl)

Directory Value

• The plugin now only interprets a KeySet as array if the parent contains the meta key array. (René Schwaiger)

Fcrypt

• Improve handling of temporary files after encryption and decryption by trying to perform a manual copy if the call of rename fails. This problem might occur if another file system is mounted at /tmp. (Peter Nirschl)

KConfig

• Write support for the KConfig INI format was added. (Dardan Haxhimustafa)

SWIG

• Configure line (-DBINDINGS="..") for SWIG based bindings have been changed from swig_foo to foo. (Manuel Mausz)
• Exclude SWIG bindings if SWIG Version is 4.0.1 and Python is >= 3.8 or Ruby is >= 2.7 due to incompatibility (#3378, #3379). (Mihael Pranjić)

SWIG/python

• Added bindings for libelektratools. (Manuel Mausz)
• Add test for kdbEnsure. (Mihael Pranjić)

SWIG/python2

• Removed python2 binding, as python2 support ended. (Manuel Mausz)

Tcl

• The Markdown Shell Recorder test of the plugin now correctly requires the xmltool plugin. (René Schwaiger)

YAMBi

• We removed the plugin in favor of Yan LR. (René Schwaiger)

YAML CPP

• The plugin now always prints a newline at the end of the YAML output. (René Schwaiger)

• The plugin does not interpret a key set such as

  user/example
  user/example/#0
  user/example/#1
  user/example/#2
  

  as array unless the parent key user/example contains the meta key array. (René Schwaiger)

• YAML CPP now always sets and requires the metakey type with the value boolean for boolean data. (René Schwaiger)

• We limited the scope of a logging function of the module. This makes it possible to build Elektra again, if

  • you enabled the logger (ENABLE_LOGGER=ON),
  • build the “full” (BUILD_FULL=ON) version of Elektra, and
  • include both the Directory Value and YAML CPP plugin in your build configuration. (René Schwaiger)

Yan LR

• The CMake code of the plugin does not print error messages produced by the tool ldd any more. (René Schwaiger)
• The plugin now also supports ANTLR 4.8. (René Schwaiger)
• We limited the scope of the logging code of the module. For more information, please take a look at the last news entry of the YAML CPP plugin. (René Schwaiger)

GOpts

• The plugin now supports an offset into argv given by the /offset config key. If /offset is set, gopts will
  ignore a number of arguments at the start of argv. This can be used in e.g. python scripts to ignore the interpreter
  arguments. (Klemens Böswirth)
• gopts now also writes help message into the key proc/elektra/gopts/help/message in addition to setting
  proc/elektra/gopts/help = 1. This is especially useful in non-C/C++ environments. (Klemens Böswirth)
• gopts is also affected by the changes and improvements to the opts library outlined below.

Cache

• Respect XDG_CACHE_HOME when resolving the mmap cache directory. (Mihael Pranjić)

Libraries

The text below summarizes updates to the C (and C++)-based libraries of Elektra.

Compatibility

• We clarified compatibility requirements for Elektra and its plugins and bindings.
  Furthermore, we renamed system/elektra/version/constants/KDB_VERSION_MICRO
  to system/elektra/version/constants/KDB_VERSION_PATCH to be compatible
  with Semantic Versioning 2.0.0. (Markus Raab)

Opts

• The library function elektraGetOpts now supports sub-commands.
  Sub-commands are best explained by looking at an application that uses them, like git.
  For example add is a sub-command in git add, and interprets -p differently from git:
  git -p add is git --paginate add, but git add -p is git add --patch.
  elektraGetOpts now implements this notion of sub-commands.
  For more information take a look at the tutorial for command-line-options.
  By extension this functionality is also available via the gopts plugin. (Klemens Böswirth)
• The generated help message was improved. It now also gives details about parameter arguments, sub-commands and
  environment variables in addition to the existing support for option arguments. This also means that it is no longer
  possible to have multiple keys with the args=remaining metadata (because their opt/help may not be the same).
  (Klemens Böswirth)

Bindings

Bindings allow you to utilize Elektra using various programming languages. This section keeps
you up to date with the multi-language support provided by Elektra.

python2

• Removed python2 plugin, as python2 support ended. (Manuel Mausz)

Rust

• Published elektra and elektra-sys to crates.io. (Philipp Gackstatter)

Tools

• Update kdb cache tool synopsis to reflect man page. (Mihael Pranjić)
• Pull elektrad, webui and webd out of shared web folder to allow fine grained selection of tools. (Raphael Gruber)
• webd has updated dependencies. (Mihael Pranjić)

Scripts

• The fish completion script now recognizes the new names of subcommands (e.g. meta-set instead of setmeta ) introduced with Elektra 0.9.1. (René Schwaiger)

• The script reformat-cmake now reformats the code with cmake-format 0.6.3. (René Schwaiger)

• The scripts

  • reformat-c, and
  • reformat-java

  now uses clang-format 9 to reformat the code base. (René Schwaiger)

• The script reformat-shell now makes sure that you do not use shfmt 3, which formats parts of the code base slightly differently. (René Schwaiger)

Documentation

• Improved formatting of the validation tutorial _(A...

0.9.1 Release

• guid: 8c64fe8a-87a5-4b72-b772-d98c8a4a5efd
• author: Mihael Pranjić
• pubDate: Tue, 26 Nov 2019 14:55:19 +0100
• shortDesc: KDE Integration, Rust&Go Bindings, Code Generation

We are proud to release Elektra 0.9.1.

What is Elektra?

Elektra serves as a universal and secure framework to access
configuration settings in a global, hierarchical key database.
For more information, visit https://libelektra.org.

You can also read the news on our website

Highlights

• We are working on integrating Elektra into KDE. A new Elektra plugin called kconfig was added which can read KDE's kconfig ini files. Additionally we are working on a fork of KDE's KConfig configuration system and patching it to use libelektra. (Dardan Haxhimustafa) and (Felix Resch)
• The elektra and elektra-sys crates have been published to crates.io for easier usage of our Rust binding. (Philipp Gackstatter)
• We improved our Go bindings. (Raphael Gruber)
• Code Generation is ready for productive use. (Klemens Böswirth)

Code Generation

While the new kdb gen was already included in the last release, it is now fully functional and ready for productive use. To get started take a look
at the new man-page for kdb-gen(1).

If you specifically want to use it with the High-Level API take a look at this tutorial.

We also created a new CMake function that will be available, if you include Elektra via CMake's
find_package. The function is called elektra_kdb_gen and can be used to tell CMake about files
that are generated via kdb gen. (Klemens Böswirth)

Further Highlights

• We migrated our build server and website to up-to-date hardware. (Markus Raab and Djordje Bulatovic)
• Elektra now has a technical preview of a new merge library. It is written in C99 and can currently be used with kdb cmerge. (Dominic Jäger)
• We make it easier for new developers to join Elektra, e.g., see new get started. (Hani Torabi)
• We made many cleanups, to get Elektra ready for 1.0!

Plugins

The following section lists news about the plugins we updated in this release.

General

• We removed 12 obsolete or unfinished plugins:
  • boolean,
  • cachefilter,
  • cpptype,
  • dini,
  • enum,
  • regexstore,
  • required,
  • haskell,
  • simplespeclang,
  • regexdispatcher,
  • typechecker,
  • struct. (Markus Raab, René Schwaiger)
• We unified the name of the config check function of the plugins to nameOfPluginCheckConf. Before this update some plugins used the name nameOfPluginCheckConfig instead. (René Schwaiger)
• We improved the error messages in crypto, fcrypt, and gpgme plugins. (Peter Nirschl)
• We now correctly handle return codes (error codes) of execv in the GPG module. (Peter Nirschl)
• We improved the documentation of ksAppendKey regarding ownership of keys. (Raphael Gruber)
• We removed the experimental status of the following plugins:
  • gopts
  • specload. (Klemens Böswirth)
• We added the following experimental plugins:
  • kconfig. (Dardan Haxhimustafa)

Camel

We removed the experimental plugin. For a plugin that is able to parse similar syntax, please take a look at the

• YAJL , and
• YAML CPP

plugins. (René Schwaiger)

GOpts

• The error message, if non of the gopts variants can be compiled, was improved. (Klemens Böswirth)
• A better error, if the plugin fails to load argv from the system, was added. (Klemens Böswirth)
• A function to detect help mode, without invoking elektraGetOpts was added. It simply checks, whether --help is one
  of the string in argv. (Klemens Böswirth)
• Increase test timeout from 120s to 240s. (Mihael Pranjić)

KConfig

• We added a plugin which can be used to parse kconfig INI files. (Dardan Haxhimustafa)

Mmapstorage

• We now store the OPMPHM inside of the mmap format. (Mihael Pranjić)
• The storage format was changed and many sanity checks were improved or added. (Mihael Pranjić)
• Enforce consistency by writing the magic file footer last. (Mihael Pranjić)
• Filter empty meta KeySets to save space. (Mihael Pranjić)

Noresolver

• The plugin now correctly sets the path in the parentKey. It therefore now supports set calls. (Klemens Böswirth)

Path

• The Markdown Shell Recorder test of the plugin now also works, if you execute it as root user. (René Schwaiger)

Spec

• There is now the config key missing/log that allows logging of all missing required keys. (Klemens Böswirth)
• spec now internally handles errors differently. There should be no external impact apart from better performance. (Klemens Böswirth)

Specload

• We now treat relative paths as relative to KDB_DB_SPEC instead of the current working directory. (Klemens Böswirth)
• Changes to default or type metadata are no longer supported, since they are not safe in every case. (Klemens Böswirth)
• The plugin no longer has the experimental status. (Klemens Böswirth)

Tcl

• We made sure that building the plugin works, if you use the latest version of CMake (3.15.3) and Boost (1.71). (René Schwaiger)

Type

• We added an option to disable the restoring of boolean values. This useful for storage formats like YAML that have
  native boolean types. (Klemens Böswirth)

Yajl

• Yajl now correctly supports Elektras boolean types using the type plugin. For example, setting on, enable or true all map to JSONs native true value. See the type plugin for more details about boolean types. (Philipp Gackstatter)

YAwn

• We removed the plugin in favor of Yan LR. (René Schwaiger)

YAy PEG

• We removed the plugin in favor of Yan LR. (René Schwaiger)

Libraries

The text below summarizes updates to the C (and C++)-based libraries of Elektra.

Compatibility

We introduced several incompatible changes:

• The library libelektra, which is a collection of different elektra libraries, is now removed.
  Users of CMake or pkg-config should not be affected. Otherwise change -lelektra to -lelektra-core -lelektra-kdb
  or whatever parts of Elektra your application uses. (Markus Raab)
• The conversion functions elektraKeyTo* and elektra*ToString are now part of the elektra-ease library instead of
  the elektra-highlevel library. This should not cause any breaking changes since elektra-highlevel already depends
  on elektra-ease. In addition the header elektra/conversion.h is kept for compatibility. (Klemens Böswirth)
• Fixes in documentation that might disallow some code operating in grey areas before. (Markus Raab)
• We removed keyRel and keyRel2 since it can be easily replaced by other existing functions. (Philipp Gackstatter)

We changed the following symbols:

• ELEKTRA_PLUGIN_COMMIT
• elektraKeyToString
• elektraKeyToBoolean
• elektraKeyToChar
• elektraKeyToOctet
• elektraKeyToShort
• elektraKeyToUnsignedShort
• elektraKeyToLong
• elektraKeyToUnsignedLong
• elektraKeyToLongLong
• elektraKeyToUnsignedLongLong
• elektraKeyToFloat
• elektraKeyToDouble
• elektraKeyToLongDouble
• elektraBooleanToString
• elektraCharToString
• elektraOctetToString
• elektraShortToString
• elektraUnsignedShortToString
• elektraLongToString
• elektraUnsignedLongToString
• elektraLongLongToString
• elektraUnsignedLongLongToString
• elektraFloatToString
• elektraDoubleToString
• elektraLongDoubleToString
• kdb_octet_t
• kdb_boolean_t
• kdb_short_t
• kdb_long_t
• kdb_long_long_t
• kdb_unsigned_short_t
• kdb_unsigned_long_t
• kdb_unsigned_long_long_t
• kdb_char_t
• kdb_float_t
• kdb_double_t
• kdb_long_double_t

Core

• A new plugin function, kdbCommit, was implemented. The function is carried out in the commit phase of kdbSet and separates the commit functionality from the kdbSet() function. (Vid Leskovar)
• kdbconfig.h is no longer included in the installed headers. This is because it could cause conflicts with other
  config.h-type headers from applications. (Klemens Böswirth)
• ksAppendKey: state that it only fail on memory problems. (Markus Raab)
• Fix memory leak in kdbGet. (Markus Raab)
• Implemented kdberrors.h directly without generation of the specification file because of drastically reduced error code count (Michael Zronek)
• keyIsDirectBelow was renamed to keyIsDirectlyBelow. (Philipp Gackstatter)
• keyMeta was added to provide access to a key's underlying KeySet that holds its metadata keys. (Philipp Gackstatter)
• Removed the obsolete ksLookupByString and ksLookupByBinary, as well as deprecated KDB_O_* options. (Philipp Gackstatter)
• Added keyLock and keyIsLocked. (Manuel Mausz)
• Removed keyVInit. (Manuel Mausz)

Opts

• The option -h is no longer used to indicate help mode. Only --help, will invoke help mode. (Klemens Böswirth)

Proposal

• Removed or moved several functi...

0.9.0 Release

• guid: e8c753c0-74af-410b-9f66-77c3ce194717
• author: Markus Raab
• pubDate: Tue, 06 Aug 2019 12:09:02 +0200
• shortDesc: Cache, Command-line Options, Error Codes

What is Elektra?

Elektra serves as a universal and secure framework to access
configuration settings in a global, hierarchical key database.

You can also read this document on our website.

We wrote a new article describing our vision from
configuration management perspective.

For more information, visit https://libelektra.org.

0.9.*

We are proud to present our largest release so far.
It is the first release of the 0.9.* version series,
which goal is it:

• To prepare Elektra for version 1.0.0,
  which includes incompatible changes like new error codes
  (which are already part of this release, hence 0.9.0).
  When 0.9.* is mature enough, we will call it 1.0.0.
• To make Elektra future-proof so that during 1.*.
  most of Elektra's functionality can be kept stable
• To cleanup Elektra, including removal of compatibility layers
  and research prototypes.

Business Plans

To get away from a purely research-oriented approach
to a mature foundation, we also need paid employees
to fix problems.

We plan to introduce following ways of income:

1. donations
2. paid support/feature requests
3. consultancy

If you are interested in any of these, please
contact us via [email protected]

The 0.8.* version series will be maintained on paid requests.
If you have maintenance requests and want 0.8.27 to be released,
please contact us via [email protected]

Please note, that Elektra will definitely stay
100% free software (BSD licensed).
We do not plan to make any part proprietary. We only introduce a way
for paid customers to get desired features or help more quickly.

Highlights

• Cache
• Command-line Options
• Error Codes

Cache

Cache is a new global caching plugin.
It uses mmapstorage
as its storage backend and lazily stores the whole configuration from previous
configuration accesses.

With large or many configuration files, the cache brings amazing performance improvements:
Let us say, you have 649 INI configuration files mounted with
the multifile resolver, completely
specified (which means that the specification must be copied to all the configuration settings).
Before the cache, retrieving the whole configuration would take 6 or even 13 seconds.
With the cache, the whole operation now takes less than 0.5 seconds after the first
access.

This is an important step towards the goal of Elektra to integrate all configuration
files present on a system.

Limitations:

• Mountpoints that are not connected with files, currently cannot be cached.
• The cache currently does not work together with other global plugins.

By default, the cache will automatically enable itself once the cache plugin is installed.
The cache can be found in ~/.cache/elektra.

We also added tools for enabling, disabling and clearing the cache (kdb cache {enable,disable,default,clear}).

A big thanks to (Mihael Pranjić) for the excellent work.

Command-line Options

Gopts is a new plugin that integrates support for command-line options to applications:

• The gopts plugin retrieves the values of argc, argv and envp needed for
  elektraGetOpts and then makes the call. It is intended to be used as a
  global plugin, so that command-line options are automatically parsed when kdbGet is called. (Klemens Böswirth)
• The plugin works under WIN32 (via GetCommandLineW and GetEnvironmentString), MAC_OSX (_NSGetArgc, _NSGetArgv) and any system that
  either has a sysctl(3) function that accepts KERN_PROC_ARGS (e.g. FreeBSD) or when procfs is mounted and either /proc/self or
  /proc/curproc refers to the current process. If you need support for any other systems, feel free to add an implementation.

This means, that using the plugin, you do not need to call elektraGetOpts yourself anymore.

kdbEnsure is a new function in elektra-kdb. It can be used to ensure that a KDB instance meets certain clauses specified in a
contract. In principle this a very powerful tool that may be used for a lot of things.
All changes made by kdbEnsure are purely within the KDB handle passed to the function.

For example, kdbEnsure can be used, to ensure the availability of command-line options for your application.

Limitations:

• kdbEnsure only works, if the list plugin is mounted in all appropriate global positions.
• kdbEnsure does not take care of dependencies between plugins.
• Mounting of non-global plugins is not supported.

A big thanks to (Klemens Böswirth) for the excellent work.

Error Codes

With this release, we changed our messy error code system into a more structured and clean way.
Similar to SQLStates
we changed to structure of our error codes and migrated them. Have a look into
the new codes. This allows us to easily extend the specification without breaking existing
codes and to avoid risking duplicated errors as we had before. (Michael Zronek)

We were able to reduce the former 214 to now only 9 error codes.

For background information read:

• about error codes
• about error message format

A big thanks to (Michael Zronek) for the excellent work.

Plugins

The following section lists news about the plugins we updated in this release.
In total, we added 9 plugins and removed 2 plugins.

Type (New Version)

The type plugin was completely rewritten in C. The old version is now called cpptype. (Klemens Böswirth)

The new type plugin also provides the functionality of the enum and the boolean plugin. These plugins are now considered obsolete and
you should use type instead.

A few notes on compatibility:

• the new type does not support the full feature set of enum and boolean, but it supports the features we consider useful.
• the new type doesn't support FSType and empty. These have been deprecated for a long time and there are good alternatives available.
• the new type supports enum, wchar and wstring as types, whereas the old cpptype would throw an error for these. In most cases
  this won't be a problem, but you should be aware of this breaking change.
• the new type does not support check/type/min and check/type/max, please use the range plugin instead.

To switch from enum to the new type, you have to add either check/type=enum or type=enum. Without a check/type or type metakey,
the type plugin will ignore the key. We now also support converting enum values to and from integer values (see
README).

To switch from boolean to the new type, you don't have to do anything, if you used the default config. If you used a custom configuration
please take a look at the README.

Base64

• We fixed some warnings about implicit type conversions reported by UBSan in the base64 plugin. (René Schwaiger)

Crypto and Fcrypt

• Empty GPG key IDs in the plugin configuration are being ignored by the crypto plugin and the fcrypt plugin. Adding empty GPG key IDs would lead to an error when gpg is being invoked. (Peter Nirschl)
• Apply Base64 encoding to the master password, which is stored within the plugin configuration. This fixes a problem that occurs if ini is used as default storage (see 2591). (Peter Nirschl)
• Fix compilation without deprecated OpenSSL APIs. Initialization and deinitialization is not needed anymore. (Rosen Penev)

CSVStorage

• Support DOS newlines for the csvstorage plugin. (Vlad - Ioan Balan)

Filecheck

• We fixed some warnings about implicit type conversions reported by UBSan. (René Schwaiger)

INI

• Fixed INI plugin when only the root key needs to be written. (Mihael Pranjić)
• Plugin writes to INI files without spaces around '=' anymore. Reading is still possible with and without spaces.
  (Oleksandr Shabelnyk)

Macaddr

• Added a plugin to handle MAC addresses. kdbGet converts a MAC address into a decimal 64-bit integer (with the most significant 16 bits always set to 0), if the format is supported. kdbSet restores the converted values back to there original form. (Thomas Bretterbauer)

mINI

• We fixed compiler warnings reported by GCC 9 in the unit test code of the plugin. (René Schwaiger)

Mmapstorage

• mmapstorage is now able to persist the Global KeySet, which is used by the cache plugin. (Mihael Pranjić)
• Fixed support for `k...

0.8.26 Release

• guid: 55950e64-fa4e-4eb9-9a3a-2c73d9cd6478
• author: Markus Raab
• pubDate: Tue, 26 Feb 2019 15:31:09 +0100
• shortDesc: high-level API

We are proud to release Elektra 0.8.26 with the new high-level API.

What is Elektra?

Elektra serves as a universal and secure framework to access
configuration settings in a global, hierarchical key database.
For more information, visit https://libelektra.org.

You can also read the news on our website

High-Level API

The new high-level API provides an easier way for applications to get started with Elektra.

To use Elektra in an application (including proper error handling) you now only need a few self-explanatory lines of code:

ElektraError * error = NULL;
Elektra * elektra = elektraOpen ("/sw/org/myapp/#0/current", NULL, &error);
if (elektra == NULL)
{
	printf ("An error occurred: %s", elektraErrorDescription (error));
	elektraErrorReset (&error);
	return -1;
}

// Once you have an instance of `Elektra` you simply call one of the typed `elektraGet*` functions to read a value:

kdb_long_t mylong = elektraGetLong (elektra, "mylong");
printf ("got long " ELEKTRA_LONG_F "\n", mylong);
const char * mystring = elektraGetString (elektra, "mystring");
printf ("got string %s\n", mystring);

elektraClose (elektra);

To run the application, the configuration should be specified, e.g., for mylong:

sudo kdb setmeta /sw/org/myapp/#0/current/mylong type long
sudo kdb setmeta /sw/org/myapp/#0/current/mylong default 5

In the getters/setters there is no need to convert types or to specify the base path
/sw/org/myapp/#0/current, as the high-level API does that for you.
The API supports the CORBA types already used by the plugins.
The high-level API should also be used in combination with a specification (spec-mount).
When used this way, the API is designed to be error and crash free while reading values.
Writing values, can of course still produce errors.

Another advantage of the new API is, that it will be much easier to write bindings for other languages now, because only a few simple
types and functions have to be mapped to provide the full functionality.

Take a look at the README for more information.

Because of the high-level API, we now have the new header files elektra.h and a folder elektra in Elektra's include directory.
Furthermore, we install the library libelektra-highlevel.so and the pkgconfig file elektra-highlevel.pc for easier detection.

For an example on how to build an application using this API take a look at this.

A big thanks to Klemens Böswirth for making this possible.
Also big thanks to Dominik Hofer, who did all the foundation work for this API.

Plugins

The following section lists news about the plugins we updated in this release.

Augeas

• We changed the default Augeas directory prefix for the lenses directory on macOS to the one used by
  Homebrew: /usr/local. (René Schwaiger)

Network

• The network plugin also supports port declarations to check if a port number is valid
  or if the port is available to use. (Michael Zronek)
• We added a [Markdown Shell Recorder][] test to the ReadMe of the plugin. (René Schwaiger)

YAMBi

• The build system does not print a warning about a deprecated directive any more, if you build the plugin with Bison 3.3 or later.
  (René Schwaiger)
• YAMBi now handles comments at the end of input properly. (René Schwaiger)

YanLR

• We improved the error reporting capabilities of the plugin. It now stores all of the error message reported by ANTLR and also specifies
  the line and column number of syntax errors. We also visualize these error messages in a similar way as modern compilers like Clang or
  GCC. For example, for the following erroneous input:

  key: - element 1
  - element 2 # Incorrect Indentation!

  the plugin currently prints an error message that looks like this:

  config.yaml:2:1: mismatched input '- ' expecting end of map
                   - element 2 # Incorrect Indentation!
                   ^^
  config.yaml:2:37: extraneous input 'end of map' expecting end of document
                    - element 2 # Incorrect Indentation!
                                                        ^
  

  . The inspiration for this feature was taken from the book
  “The Definitive ANTLR 4 Reference” by Terence Parr.
  (René Schwaiger)

• Yan LR’s lexer now

  • handles comment at the end of a YAML document correctly,
  • stores a more human readable description in tokens (e.g. end of map instead of MAP END)

  . (René Schwaiger)

Path

Enhanced the plugin to also check for concrete file or directory permissions such as rwx.
For example, you can specify that a user can write to a certain directory or file which prevents applications of runtime failures
once they try to access the given path (such as a log directory or file).
Simply add check/path/user <user> and check/path/mode <modes> as specification (metadata)
and be assured that you can safely set a path value to the key. A more detailed explanation can be found
here (Michael Zronek)

YAwn

• The plugin now handles comments at the end of a file properly. (René Schwaiger)
• We improved the syntax error messages of the plugin. (René Schwaiger)
• We fixed a memory leak that occurred, if a YAML file contained syntax errors. (René Schwaiger)

YAy PEG

• The new plugin YAy PEG parses a subset of YAML using a parser based on
  PEGTL. (René Schwaiger)

Ruby

• Added some basic unit tests (Bernhard Denner)

Misc

• We fixed some compiler warnings for the plugins

  • camel,
  • line,
  • mini and
  • resolver

  reported on FreeBSD. (René Schwaiger)

• The resolver plugin and its tests now better support KDB_DB_SYSTEM and KDB_DB_SPEC paths
  using ~ to refer to a home directory. (Klemens Böswirth)

• If KDB_DB_SYSTEM is set to a relative path, it is now treated as relative to CMAKE_INSTALL_PREFIX. This ensures that
  KDB_DB_SYSTEM actually points to the same location no matter the current working directory. (Klemens Böswirth)

Libraries

The text below summarizes updates to the C (and C++)-based libraries of Elektra.

Compatibility

As always, the ABI and API of kdb.h is fully compatible, i.e. programs
compiled against an older 0.8 version of Elektra will continue to work
(ABI) and you will be able to recompile programs without errors (API).

We have two minor incompatible changes:

• we now support larger array numbers (i.e. the larger numbers are not an error anymore)
• elektraArrayValidateBaseNameString returns the offset to the first digit of the array index instead of 1

For details of the changes see below Core and Libease.

Core

• All plugins in the KDB now get a handle to a global keyset via elektraPluginGetGlobalKeySet(), for communication between plugins.
  See Global KeySet Handle for details. (Mihael Pranjić)
• elektraWriteArrayNumber now uses kdb_long_long_t for array indices to be compatible with the high level API.
  Similarly the value of ELEKTRA_MAX_ARRAY_SIZE was changed to match this. (Klemens Böswirth)

Libease

• The function elektraArrayValidateBaseNameString now returns the offset to the first digit of the array index, if the given string
  represents an array element containing an index. This update enhances the behavior of the function. Now it not only tells you if a name
  represents a valid array element, but also the start position of the array index.

  elektraArrayValidateBaseNameString ("#_10");
  //                                     ~~^ Returns `2` (instead of `1`)
  
  elektraArrayValidateBaseNameString ("#___1337");
  //                                   ~~~~^ Returns `4` (instead of `1`)

  If your program already used elektraArrayValidateBaseNameString and you check for a valid array element using the equality operator
  (== 1), then please use (>= 1) instead. For example, if you code that looks like this:

  if (elektraArrayValidateBaseNameString(baseName) == 1) …;

  , please update your code to check for a valid array element name like this:

  if (elektraArrayValidateBaseNameString(baseName) >= 1) …;

  . (René Schwaiger)

Libopts

• This is a new library containing only the function elektraGetOpts. This function can be used to parse command line arguments and
  environment variables and add their values to keys in the proc namespace.

  You can use opt, opt/long and env to specify a short, a long option and an environment variable. For more information take
  a look at the tutorial and the code documentation of elektraGetOpts. (Klemens Böswirth)

Tools

• kdb spec-mount correctly includes type plugin to validate type. (Markus Raab)
• kdb setmeta ...

0.8.25 Release

We are proud to present Elektra 0.8.25.

What is Elektra?

Elektra serves as a universal and secure framework to access
configuration settings in a global, hierarchical key database.
For more information, visit https://libelektra.org.

For a small demo see here:

You can also read the news on our website

Metadata

• guid: 472392e0-cc4f-4826-a0a9-2764d90c5f89
• author: Markus Raab
• pubDate: Sun, 18 Nov 2018 21:24:34 +0100
• shortDesc: faster storage and lookup

Highlight

This release is dedicated to drastically improve the speed of Elektra.
Two non-trivial features facilitate most of the improvement:

• mmap storage for very fast retrieval of configuration
• Hybrid Search Algorithm for ksLookup (...) for very fast access of configuration

mmap storage

We added a new, binary and fast storage plugin called mmapstorage.
It leverages the mmap() syscall and supports full Elektra semantics.
We provide two compile variants: mmapstorage and mmapstorage_crc.
The mmapstorage_crc variant enables CRC32 checksums for critical data,
while the mmapstorage variant omits the checksum for maximum performance.

We ran a synthetic benchmark with 257 iterations using 40k keys in a keyset,
and compared the performance to the dump storage plugin.

Median write time in microseconds:

Plugin	Time
dump	71079
mmapstorage	2964
mmapstorage_crc	7644

Median read time in microseconds:

Plugin	Time
dump	82737
mmapstorage	1145
mmapstorage_crc	5744

In our benchmark, the mmapstorage plugin writes more than 23x faster,
and reads more than 72x faster than the dump storage plugin.

For this release the plugin is marked as experimental,
even though it is already used as default storage plugin in a build job on our build server.

Thanks to Mihael Pranjić for this improvement.

Hybrid Search Algorithm for ksLookup (...)

The hybrid search algorithm is now implemented, this concludes the extension of the ksLookup (...) search with the
order preserving minimal perfect hash map (OPMPHM).
The hybrid search combines the best properties of the binary search and the OPMPHM.
The hybrid search decides dynamically which search algorithm to use.

Because of the automatic decision, usually nothing needs to be done by API users to take advantage of this improvement.
Advanced API user, however, can overrule the hybrid search by passing KDB_O_OPMPHM or KDB_O_BINSEARCH to ksLookup (...).
The constants are defined in kdbproposal.h.
For low-memory systems the building of the hash map can be disabled altogether at build-time by disabling the CMake variable ENABLE_OPTIMIZATIONS (by default enabled now).

The implemented randomized OPMPHM
algorithm is in 99.5% of the measured random cases optimal. However the randomization property of the algorithm leaves an uncertainty.

The results made with random cases had shown that the hybrid search is, except for small keyset sizes, almost always faster
compared to the standalone binary search. The performance increase strongly depended on the measured hardware. In the random cases
where the hybrid search is faster, on average ~8.53% to ~20.92% of time was saved.
The implemented hybrid search works only above a keyset size of 599 to exclude the small keyset sizes.

Thanks to Kurt Micheli for this improvement.

Plugins

The following section lists news about the plugins we updated in this release.

Directory Value

We improved the performance of the directoryvalue plugin. (René Schwaiger)
This plugin is used for configuration file formats that do not support that directories contain values, like it is the case in JSON.
A program manipulating a 13 MB JSON file which first did not succeed within 10 hours is now finished in 44 seconds.

Process

There is a new, experimental plugin called process.
This plugin utilizes the pluginprocess library in order to execute arbitrary other
plugins in an own process, acting as a proxy itself. Therefore it is not required
to explicitly change a plugin's implementation if it shall be executed in an own
process. This plugin is not completely finished yet, as currently there is no way
for it to mimic the proxied plugin's contract in Elektra. It can be used with simple
plugins like dump however, check the limitations in the readme for more details. (Armin Wurzinger)

FSTab

The detection of the mntent functions now also works correctly, if you use the compiler switch -Werror. (René Schwaiger)

passwd

We fixed an issue with the passwd plugin not properly setting compile flags.
This resolves a problem with undefined functions when building with musl. (Lukas Winkler)

gpgme

The experimental gpgme plugin was brought into existence to provide cryptographic functions using GnuGP via the libgpgme library. (Peter Nirschl)

network

The network plugin now also allows for non-numerical hosts (i.e. "localhost") to be set and tries to resolve it via DNS. (Michael Zronek)

YAMBi

This new plugin parses a subset of YAML using a parser generated by Bison. (René Schwaiger)

YAML CPP

The build system now disables the plugin automatically, if you use a GCC compiler (6.x or earlier) and enable the option ENABLE_ASAN.
We updated the behavior, since otherwise the plugin will report memory leaks at runtime. (René Schwaiger)

Yan LR

A new plugin parsing YAML files using Yan LR.

• The plugin does not modify the (original) parent key. As a consequence, setting values at the root of a mountpoint:

  sudo kdb mount config.yaml user/tests/yambi yambi
  kdb set user/tests/yanlr 'Mount Point Value'
  kdb get user/tests/yanlr
  #> Mount Point Value

  now works correctly. (René Schwaiger)

• We now use C++ code to test the plugin. (René Schwaiger)

• The CMake code of the plugin now also recognizes antlr as ANTLR executable, if antlr4 is not available. (René Schwaiger)

• The build system now disables the unit test for the plugin, if you use GCC (6.x or earlier) to translate Elektra. We introduced this
  behavior, since the code generated by ANTLR (YAML.h) seems to contain a double free that causes a segmentation fault on systems that
  use the GNU C library. (René Schwaiger)

• The build system now disables the plugin automatically, if you use a GCC compiler (6.x or earlier) and enable the option ENABLE_ASAN.
  (René Schwaiger)

YAwn

This new plugin parses a subset of YAML using the Earley Parser library YAEP. (René Schwaiger)

Reference

This new plugin can be used to validate that the value of a key is a reference to another key. (Klemens Böswirth)

Libraries

The text below summarizes updates to the C (and C++)-based libraries of Elektra.

Compatibility

As always, the ABI and API of kdb.h is fully compatible, i.e. programs
compiled against an older 0.8 version of Elektra will continue to work
(ABI) and you will be able to recompile programs without errors (API).

This is the last release for which we have built Jessie packages:

    deb     [trusted=yes] https://debian-stable.libelektra.org/elektra-stable/ jessie main
    deb-src [trusted=yes] https://debian-stable.libelektra.org/elektra-stable/ jessie main

Obviously, we will continue to update the stretch package:

    deb     [trusted=yes] https://debian-stretch-repo.libelektra.org/ stretch main
    deb-src [trusted=yes] https://debian-stretch-repo.libelektra.org/ stretch main

Infos for Package Maintainers

Following plugins got added:

• libelektra-gpgme.so
• libelektra-mmapstorage_crc.so
• libelektra-mmapstorage.so
• libelektra-process.so
• libelektra-reference.so
• libelektra-yambi.so

A new library got added (should be packaged privately for now):

• libelektra-globbing.so

Core

Optimize elektraKsFilter to not duplicate keys (Markus Raab)

Globbing

A new library which can be used to match keys against globbing patterns was introduced. (Klemens Böswirth)

The API is still experimental, so it should not be used externally for now.

Ease

libease provides the function elektraArrayValidateBaseNameString, which can be used to validate that a
given string is an Elektra array name. (Klemens Böswirth)

Bindings

Bindings allow you to utilize Elektra using various programming languages. This section keeps
you up to date with the multi-language support provided by Elektra.

Ruby

Do not use private Elektra headers for Ruby bindings as preparation for a Ruby libelektra gem. (Bernhard Denner)

Tools

• Added benchmarks for storage plugins. The currently benchmarked plugins are dump and mmapstorage. *(Mihael Pranjić...

0.8.24 release

0.8.24 Release

We are proud to release Elektra 0.8.24.

• guid: 889b700d-9eac-4eff-9a3d-f6fb15c3d9da
• author: Markus Raab
• pubDate: Sat, 18 Aug 2018 18:13:40 +0200
• shortDesc: Elektra Web, Notifications, Type System

What is Elektra?

Elektra serves as a universal and secure framework to access
configuration settings in a global, hierarchical key database.
For more information, visit https://libelektra.org.

For a small demo see here:

You can also read the news on our website

Highlights

• Elektra Web
• Notifications
• KDE Workshop
• Type System Prototype
• Chef Cookbook

Elektra Web 1.6

The new release of Elektra Web features many UX improvements from the usability test!

Try it out now on: http://webdemo.libelektra.org/

1.5 changelog:

• search completely reworked - it does not act as a filter on already opened keys anymore, and instead searches the whole key database - feedback from the search was also greatly improved (pulsating while searching, glowing blue when done)
• added "abort" buttons to dialogs to revert actions
• added "create array" button to easily create arrays
• removed confirmation dialog before deletion (undo can be used instead)
• created a docker image: elektra/web
• implemented auto-deployment of webdemo.libelektra.org
• small fixes:
  • updated visibility levels
  • removed "done" button in main view
  • fixed issues with the opener click area
  • remove metakeys when they are set to the default value or empty/0
  • improved keyboard support
  • fixed many small issues (#2037)

1.6 changelog:

• fixed bugs related to arrays (#2103)
• improved performance of search for many results
• added 404 page for invalid instance ids
• implement drag & copy by holding the Ctrl or Alt key
• add button to show error details
• allow deleting all keys in a namespace

Thanks to Daniel Bugl.

Notifications

Elektra's notification feature which allows applications to keep persistent
configuration settings in sync with the key database and other applications was
greatly improved with this release:

• The notification API
  now supports more types and has improved support for callbacks.
• With the addition of the zeromqsend
  and zeromqrecv plugins
  together with the hub-zeromq
  tool we have an alternative to the D-Bus transport plugins
  (dbus and
  dbusrecv).
• The new asynchronous I/O binding for ev
  is the third I/O binding - so notifications can be used in applications using
  glib, uv
  or ev.
  If your application uses a different library please check out the
  "How to create your own I/O binding" section in the notification tutorial.
• Notifications can be used to reload KDB after Elektra's configuration (e.g.
  mountpoints or globally mounted plugins) has changed.
  We added a how-to to the notification tutorial
  that explains the required steps and the "notificationReload" example with the complete code.

More details can be found in this news.
Check out the updated notification tutorial
and notification examples (polling,
async and
reload.

KDE Workshop

At Akademy 2018 we had a successful
Config Workshop.

We generally agreed that misconfiguration is important and the situation
in FLOSS needs to improve.
We discussed how Elektra can be used in KDE and came up with the idea that
KConfig could be moved to a Elektra plugin.
Then KConfig could be patched to use Elektra instead.
This would lead to the situation that KDE users would have the same user
experience with the advantages of Elektra, like:

• Elektra Web and qt-gui to safely modify all settings
• modification of settings via configuration management tools
• switch to other configuration file formats (e.g., XML or YAML for plasma)
• provide notification with main-loop integration
• plugin system for LDAP support and similar features

For more information see the Slides

Type System Prototype

Elektra supports specifying the semantics of keys via metakeys in the spec
namespace. An example is the metakey check/range which can be used to specify
that a key only holds numbers in a given range. Another metakey is check/enum
which only allows specific keywords to be the content of a key. Up to now these
semantics are only being checked at runtime. Therefore a type system was developed to
be able to check configuration specifications statically. As an example, it
would detect when one accidentally adds both a range and an enum check if their
possible contents are not compatible with each other.

The type system is available as a plugin that gets mounted along with a
configuration specification into the spec namespace. Furthermore we include a
set of type definitions for commonly used metakeys such as check/range,
check/enum, check/validation, fallback or override.

For more details see the
typechecker readme

Thanks to Armin Wurzinger.

Chef Cookbook

Next to the Puppet Resource Type
we now also prepared a Chef Cookbook
which allows us to use Elektra from within Chef.

For example, to set mount a configuration file, you can use:

kdbmount 'system/hosts' do
	file '/etc/hosts'
	plugins 'hosts'
	action :create
end

And to add an hosts entry, you can use:

kdbset '/hosts/ipv4/showthatitworks' do
	namespace 'system'
	value '127.0.0.33'
	action :create
end

Note that currently kdb is invoked
and Elektra needs to be installed for
managed systems.

Thanks to Michael Zronek and Vanessa Kos.

Plugins

CCode

• We fixed various warnings in the source code reported by OCLint. (René Schwaiger)
• The plugin now also encodes and decodes key names in addition to key values. (René Schwaiger)

CPP Template

• We added a new template for C++ based plugins. To create a plugin based on this
  template, please use the command

  scripts/copy-template -p pluginname

  , where pluginname specifies the name of your new plugin. (René Schwaiger)

Crypto

• The crypto plugin now uses Elektra's libinvoke and the base64 plugin in order to encode and decode Base64 strings. This improvement reduces code duplication between the two plugins. (Peter Nirschl)

CSVStorage

• Changed behaviour of export to validate the structure of exported keys only. (Thomas Waser)

Directory Value

• We rewrote the plugin using C++. (René Schwaiger)
• Directory Value now also supports nested arrays. (René Schwaiger)
• The plugin now also adds leafs for a key, if its value is null or the empty string. (René Schwaiger)

fcrypt

• The fcrypt plugin will consider the environment variable TMPDIR in order to detect its temporary directory. See [#1973] (Peter Nirschl)

fstab

• The fstab plugin now passes tests on musl builds. (Lukas Winkler)

Haskell

• An issue when building Haskell plugins with a cached sandbox is fixed in case
  a Haskell library bundled with Elektra gets changed. (Armin Wurzinger)
• The script that generates the list of haskell dependencies now also works on
  ghc8.0.1 and older cabal versions. Furthermore one can specify the build directory as
  a parameter if it is not located within the source directory. (Armin Wurzinger)

Interpreter Plugins

• The plugins Ruby, Python and Jni can now also be mounted as global plugin.
• Fix crashes in global Python plugin by using pluginprocess.
  Python plugin can now shutdown properly again. (Markus Raab and Armin Wurzinger)

JNI

• We now disable the plugin for the BUILD_STATIC or BUILD_FULL build variants, since otherwise the plugin breaks the kdb tool.
  (René Schwaiger)
• We disabled the internal check (testscr_check_kdb_internal_check) for the plugin, since it always fails. (René Schwaiger)

HexNumber

• The plugin hexnumber has ...

0.8.23 release

• guid: 9a9ab08b-9ca0-4242-b617-5a8b21ea42a0
• author: Markus Raab
• pubDate: Sun, 13 May 2018 08:57:15 +0200
• shortDesc: Notification, Web UI, Build System

We are proud to release Elektra 0.8.23.

In 717 commits 11 authors changed 835 files with 31144 insertions(+), 21773 deletions(-).

What is Elektra?

Elektra serves as a universal and secure framework to access
configuration settings in a specified, global, hierarchical key database.
For more information, visit https://libelektra.org.

For a small demo see here:

You can also read the news on our website

Highlights

• Notification: New transport plugin
• Web UI greatly improved
• Overhaul of Build System and Daily Stretch Repository

Notification: New transport plugin

To keep persistent configuration settings in sync with the configuration settings of applications, notifications are needed.
For notifications it is important that they do not block the execution of the applications.
In Elektra we achieve this using transport plugins.

Elektra's notification feature has received its first transport plugin pair:
D-Bus.
Transport plugins provide a link between applications using Elektra.
These plugins send and receive notifications when a key is modified within the
key database.
The existing dbus plugin has been modified to use an asynchronous I/O binding
for sending messages, if available.
The new dbusrecv plugin is responsible for receiving messages sent from the
dbus plugin and other sources with the same
message format.

For more details see the
notification tutorial
or the
example applications.

Thanks to Thomas Wahringer.

Web UI greatly improved

The goal of the Web UI is to provide safe and unified access to all configuration settings of a system.
Different to other UIs, it generates its interface according specifications as found in Elektra.

For example, if a configuration setting only has a number of choices, you get exactly these choices
within the user interface.

To get outstanding usability, Web UI now provides:

• undo functionality
• visibility functionality to hide irrelevant configuration settings
• built-in validation for many types of configuration settings
• support for arrays
• descriptions of configuration settings embedded in the user interface

Furthermore:

• The Web-UI now is able to install itself via cmake.
• The API was updated for elektrad
  and webd (former clusterd).

Read here to get started.

Note that new version of the Web UI requires Elektra 0.8.23 or later.

Thanks to Daniel Bugl.

Overhaul of Build System and Daily Stretch Repository

We started to overhaul our build system to improve build times and responsiveness.
It focuses heavily on containerisation to improve hardware utilization.

If you are interested in #devops have a look at our
Jenkinsfile.

Daily builds Debian packages for Stretch are available again in our
stretch repository.
Add it to your sources.list:

deb     [trusted=yes] https://debian-stretch-repo.libelektra.org/ stretch main
deb-src [trusted=yes] https://debian-stretch-repo.libelektra.org/ stretch main

Thanks to Lukas Winkler.

Other New Features

We added even more functionality, which could not make it to the highlights:

• A new experimental I/O binding for glib
  has been added.
  It can be used to integrate the notification feature with applications based
  on glib.
• The Order Preserving Minimal Perfect Hash Map (OPMPHM), used to speed up the lookups, got optimized
  and a benchmark was added,
  thanks to Kurt Micheli
• We added a script that calculates the complexity of configuration settings based on their specification,
  thanks to Anton Hößl
• kdb ls now has -0 option to allow key names with newlines (needed for Web UI)
• The csvstorage now can treat selected columns
  to be part of the key. Error messages were improved.
  thanks to Thomas Waser

Other News

• We added a tutorial about securing the integrity and confidentiality of configuration values,
  thanks to Peter Nirschl
• Peter Nirschl finished his thesis
  (signature).
  It includes a benchmark of different cryptographic providers.
• Markus Raab gave a talk at Linuxwochen Wien (in German).
  For similar talks in English, please refer to the FOSDEM talks.
• We replaced the word "project" to "initiative" in the Code of Conduct (project has per definition an end date).

Documentation

We improved the documentation in the following ways:

• FAQ was extended by Why do I need Elektra if I already use configuration management tools?
• Documentation about the recommended environment for test runs were added
• uniformly add . at end of short help
• Logo for Doc Set was added and logo for favicon was updated,
  thanks to René Schwaiger
• template of design decisions was updated to use the words
  problem (instead of issue) and rationale (instead of argument).
• METADATA.ini:
  • added visibility (as used in Web UI)
  • added type (only check/type existed)
  • plenty of metadata is now used by Web UI
• update docu for type plugin that check/type/min and check/type/max are deprecated
• Fixed various spelling mistakes,
  thanks to René Schwaiger
• Document limitations of resolver (kdbOpen fails if no home directory found)
  and json/yaml plugins (intermixing of array and objects not detected, which is possible
  in Elektra but impossible in JSON)
• Required environment to run tests is documented.
• A decision about deferred plugin calls has been made and implemented,
  thanks to Thomas Wahringer.

Compatibility

As always, the ABI and API of kdb.h is fully compatible, i.e. programs
compiled against an older 0.8 version of Elektra will continue to work
(ABI) and you will be able to recompile programs without errors (API).

We removed:

• the not used error code 12 from kdb mv from docu

We changed:

• kdb get, kdb mv and kdb cp now use error code 11 if keys are not found
• cascading keys as arguments to kdb cp and kdb mv now fail instead
  of doing something unexpected, thanks to René Schwaiger for reporting

Shell scripts:

• cp and mv no longer accept cascading keys.

Notes for Maintainer

These notes are of interest for people maintaining packages of Elektra:

• Docu is updated that cmake3 is required.
  thanks to Lukas Winkler for reporting.
• To run all tests successfully, the spec and list plugin is required.
  So if ENABLE_TESTING is checked, cmake checks the presence of a storage,
  a resolver, the list and the spec plugin,
  thanks to René Schwaiger
• Tests no longer clear environment or reset locales.
  This fixes lua and dbus problems but might cause problems if TMPDIR is set,
  thanks to Lukas Winkler
• This will be the last release supporting Debian Wheezy
  (LTS support will stop in May).
  Directly after the release, Jessie (oldstable) with gcc 4.8.4 will
  be the oldest supported platform.

We added:

• the private headerfiles kdbnotificationinternal.h, kdbioplugin.h.
• the headerfiles kdbio_glib.h and kdbio_uv.h
• the plugin libelektra-dbusrecv.so
• the scripts build-web, run-elektrad, and run-web
• the test case testmod_dbusrecv
• the constant ENABLE_ASAN in the constants plugin
• several man pages such as: kdb-run-elektrad.1 and kdb-run-web.1

We removed:

• Base64.pdf is not installed anymore
• doxygen-generated man pages such as: doc_docker_jenkinsnode_README_md.3elektra,
  doc_docker_README_md.3elektra, and doc_vagrant_README_md.3elektra

Website

The website is generated from the repository, so all information about
plugins, bindings and tools are always up to date. Furthermore, we changed:

• Error page that is shown if no JavaScript is enabled now more clearly
  says that the Website only renders content from the repo and
  only contains free JavaScript.
• The FAQ is now
  more visible (added to "getting started").
• The Code of Conduct
  was added.

Notes for Elektra's Developers

These notes are of interest for people developing Elektra:

• . run_dev_env is a script to be sourced from the build directory.
  It sets environment variables, so that Elektra from the build
  direct...