




# 0.8.6 Release

- author: Markus Raab
- pubDate: Sat, 21 Jun 2014 12:00:00 +0100
- shortDesc: adds technical previews & other improvements

## Introduction

The Elektra Initiative moved to GitHub for following reasons:

- We were seriously missing a bug tracker
- It may make collaboration easier
- Build Server Integration:
  - Build on MergeRequests waits for the first merge request to be built!
  - And the build status is now published for this job

The main entrance point and URL for any advertisement and linking stays

https://www.libelektra.org

(which points to GitHub at the moment).

Additionally (not related to GitHub), we now have a
[LCOV code coverage report](https://doc.libelektra.org/coverage/master/debian-buster-full)!

## Improvements

The hosts plugin got documentation and several bug fixes.
Multiline comments now remove the comment start sequences within
the metadata comment.
Additionally the kdb tool has an improved error message on invalid
filenames. (thanks to Manuel Mausz)

Fix an issue that the resolver plugin did not delete tmpfile in some
error situations and add test cases with error plugin.

Fix KS_END in C++ that did not specify the namespace.

"kdb run_all" will now run all tests using Elektra from your system.
Because not all testdata will be installed, some test cases fail unless
you copy the data manually. Those are:

    testmod_yajl testmod_augeas testmod_fstab testmod_hosts test_xml

Virtually all clang compiler warnings were fixed
(thanks to Felix Berlakovich).

kdb mv now is atomic. (API was used wrongly in the tool)

Clang, icc and gcc are now all supported and tested.

## Technical Previews

A plugin that logs write operations and errors via the native
journald interface was added (thanks to Felix Berlakovich).

A preview of the augeas plugin was added. In CMake add "augeas" to PLUGINS
and then run "kdb info augeas" for further instructions. Additionally,
see Outlook below (thanks to Felix Berlakovich).

A preview of python3 and lua bindings were added. In CMake enable the
options `BUILD_SWIG BUILD_SWIG_LUA BUILD_SWIG_PYTHON` so that they are
compiled (thanks to Manuel Mausz).

The code generator was extended to support contextual values, more
information about that topic later.

The libtools library is back to life again! It has the same idea as its
predecessor, but it is much more powerful. Because of the plugin system
libtools is able to export and import any configuration format
Elektra supports. Additionally it adds support for mounting backends.
While most of its functionality is mature, the API is not final, though.

## API Changes

The API and ABI is as always backwards-compatible within the 0.8 series.

This time it is, however, not forward-compatible (that means programs
linked against 0.8.6 might not work with 0.8.5), because ksAtCursor()
was added.

ksAtCursor() provides the means for an external iterator. This
was immediately exploited by an implementation of the C++
iterators. These new C++(11) (reverse)iterators allow multi-pass
algorithm over the same KeySet.

ksSort was in the kdb.h header file, even though it never was
needed nor available in 0.8. Automatic compatibility checkers may
wrongly tell that the API is not compatible, but this is not the case
(thanks to Manuel Mausz).

The C++ API changed, including:

- does not wrongly convert garbage to default types using `get<T>`
- getMeta now internally uses `get<T>` and both throw the
  KeyTypeConversion Exception
- KeySet::at directly allows one to use ksAtCursor()
- KeyTypeConversion (or former KeyBadMeta) is not thrown anymore if key
  is not available
- Key::hasMeta allows one to directly check if metadata is available

CMake: ENABLE_CXX11 is now default OFF (because gcc 4.6 and older won't
work with it). It disables some tests, though.
`unique_ptr` will automatically be used instead of `auto_ptr` in this mode.

Note for maintainers: libelektratools now needs to be installed so that
the kdb tool will work.

## Outlook

One drawback of Elektra is the small number of available storage
plugins. While writing storage plugins isn't too hard, it still requires
knowledge of Elektra’s plugin architecture. In addition it is always
necessary to keep both translation directions in mind (from file to
Elektra and back). In order to mitigate this issue Felix Berlakovich
is working on an Elektra storage plugin which uses Augeas [1] to read
and manipulate configuration files. Augeas uses a concept called lenses
to translate between files and abstract trees (i.e. trees that hide
unimportant details like whitespaces). In brief, what makes lenses special
is the fact that they automatically disallow translations that cannot be
reversed. This means that one of the translation directions comes for free
as it is implicitly described by the other one. Therefore writing lenses
is much simpler than programming both directions explicitly as done in
traditional Elektra storage plugins. Furthermore many lenses for common
applications like Apache, MySQL, DHCPd and many more [2] already exist.
Besides these benefits, Augeas lacks many features of Elektra. Although
this is mostly intended because Augeas aims to concentrate just on
configuration file manipulation some of these features would be valuable
for administrators and developers. Some of these mentioned Elektra
features include but are not limited to: logging of all configuration
changes done, transformation of character encoding as needed, import and
export of configuration data in any format, e.g. XML or JSON (Augeas has
a similar feature for XML), file conflict detection and several different
validations for configuration options (see [3] for a full list of
features). With the Augeas storage plugin these features cannot be used
with only the applications already integrated into Elektra, but with all
applications for which lenses exist. This storage plugin targets system
administrators as well as developers, that wish to take advantage of
Elektra’s features, but were unable to do so because of missing plugins. If
no lens exists already, writing a new one requires neither programming
skills nor knowledge of Elektra’s plugin architecture. Furthermore,
implementing a new configuration file format is just a matter of writing a
lens instead of writing a full-fledged parser.
[1] http://augeas.net/
[2] http://augeas.net/stock_lenses.html
[3] https://www.libelektra.org

Since Elektra is written in C, integration is limited to projects
written in C and languages compatible with C like C++. In order to
change this situation Manuel Mausz is working on the implementation of
language bindings using two different techniques. The first technique
uses SWIG as a generic generator for various languages. In a nutshell,
SWIG is a compiler that takes C/C++ declarations and creates the wrappers
needed to access those declarations from other languages. The second
technique is called GObject Introspection. In contrast to SWIG, GObject
Introspection generates a language independent metadata file. For dynamic
languages the GObject Introspection support in the target language will
load this metadata file to generate bindings at run-time. In order to
provide bindings for static languages a compiler on the metadate file
will be used. This is comparable to using SWIG. Manuel will focus on
implementing language bindings for Python and Lua though both techniques
will support various other languages. As language bindings only allow
to call into Elektra’s API Manuel will also embed the interpreters of
both Python and Lua into two generic plugins. Using these plugins in
combination with the languages bindings it will be fully possible to
write plugins for Elektra in languages other than C/C++.

While Elektra offers sophisticated methods to store and manipulate
configuration, currently there is only a command line tool (kdb)
available to interact with the database. This requires the user to study
and learn the possible commands and does not allow free exploration of the
options of the application. To enable new ways to interact with Elektra,
Raffael Pancheri is designing and implementing a Graphical User Interface
(GUI). To increase the probability to create a GUI that is indeed usable
and beneficial, Pancheri is following the design principles proposed by
Ben Shneiderman and Jakob Nielson.

Finally, as you already noticed, Ian Donnelly is working on a semantic
3-way merge to make distribution and package upgrades smoother.
This is done as GSOC project. The progress is documented here:
http://community.libelektra.org/wp/

## Get It!

You can download the release at:
http://www.markus-raab.org/ftp/elektra/releases/elektra-0.8.6.tar.gz

- size: 1188337
- md5sum: 4a59824e70a29295e9ef9ae7605d9299
- sha1: 2570710b0057470223611ca00d61a0196e54e7b2
- sha256: e815cf69b070c339784472841aa0ee0b169fab7c78f41cbbd7044f53fa9ed216

Documentation can be found here:
https://doc.libelektra.org/api/0.8.6/html/

You can install the debian packages for debian (wheezy, amd64 only,
some packages will be added later) by adding following lines to your
/etc/apt/sources.list:
deb http://markus-raab.org/ftp/wheezy wheezy main

and install or upgrade the packages with:

```sh
sudo apt-get update
sudo apt-get install libelektra-core4 libelektra-full4 libelektra-bin libelektra-dev libelektra-test libelektra-xmltool4 libelektra-json4 libelektra-dbus4 libelektra-doc
```

Best regards,
Markus





# 0.8.7 release

- author: Markus Raab
- pubDate: Mon, 28 Jul 2014 12:00:00 +0100
- shortDesc: adds python2 bindings, 3-way merge & improvements

Again, we managed to have a great feature release with dozens of
corrections!

## New Features

Thanks to Manuel Mausz for further improving lua, python3 bindings
and the new python2 bindings.

The GSoC efforts have their first large contribution to Elektra, the 3
way merge finally arrives with this release. It is still a long way to
go, however, because augeas plugins can only be mounted with a
workaround and the package integration of the 3-way merge is still in
its infancy.

A special thanks to Felix Berlakovich for his contributions to the
3-way merge, including meta merging, conflict resolving strategies and
extensive testing.

Additionally, he added the plugins keytometa, ini and greatly improved
the glob plugin. These plugins are technical previews and will receive
some improvements in the next release, too.

Now a script for tab completion is available
[here](/scripts/completion/kdb-bash-completion), again thanks to Felix
Berlakovich.

The contextual values now got a [tutorial](https://master.libelektra.org/src/tools/pythongen)
and small fixes.

## Corrections

Thanks to Pino Toscano for fixing a lot of spelling errors, simplify
RPATH setting, respect `$HOME` and `$TMPDIR`, improvements of test cases,
and his debian-packaging efforts.

In the kdb tool not allowed subfolders are now checked properly
and the output of warnings comes before output of the error.
This fixes the problem that in the case of a longer list of
warnings one did not see the error anymore.

Fix compilation warnings on clang and gcc 4.9.
Also improve test coverage on kdb tool and some plugins.

Fix kdb import/export for some plugins (Should now work with any storage
plugin again).

kdb run_all should run flawlessly with this release. Remaining problems
with not installed test data were fixed. kdb run_all also checks if the
test cases do not modify any existing key and keeps a backup if this
happened.

Some remaining mem leaks in rare circumstances were fixed. Valgrind
should now never report any leaks, if it does, please report the issue.

## API Changes

Added delMeta() for C++, because setMeta() with NULL will set the
number 0 and not remove the meta.

Arguments of isBelow, isDirectBelow, isBelowOrSame are swapped for
better readability. k.isBelow(root) now means the obvious thing.
The change only effects the C++ binding, keyIsBelow is unaffected by
the change.

## Documentation

[Specification of metadata](/doc/METADATA.ini) and
[contracts](/doc/CONTRACT.ini) written/greatly improved.

[Decisions](/doc/decisions) are introduced again.

Most often the KeySet is ideal, e.g. when doing full iteration or when
performing set operations. In some cases, however, a hierarchical data
structure fits better. This is especially true for GUIs. Luckily, Keys
can be in multiple data structures because of their reference counting.

## Other Stuff

We now fully embrace github:

- We use its issue tracker (all issues from local text files were moved
  there)
- We have rewritten many READMEs to use GitHubs Markdown
- On pull requests the build server checks if the merge would break
  the build.
- All previous gitorious users are now at github. (Most had an account
  anyway)

Raffael Pancheri also made progress with its qt-gui. It now features a
model that implements great parts of Elektra’s features. Unfortunately
the model cannot be serialized and thus changes cannot made persistent.
Also undo and other important use-cases are still not there. The GUI
looks very clean and was evaluated in a SUS study on 23.07.2014.
The current implementation can be found [here](https://github.com/0003088/qt-gui).

Many distributions already have Elektra packages

- Gentoo
- [Arch Linux](https://aur.archlinux.org/packages/libelektra/)

In some distributions Elektra packages are available, but are not
up-to-date. Pino Toscano is working on get them (actually
Debian, but others are derived from it) up-to-date.

- [Ubuntu](https://launchpad.net/ubuntu/+source/elektra)
- Debian
- [Linux Mint](http://community.linuxmint.com/software/view/elektra)

A special thanks to Kai-Uwe Behrmann for providing packages for
[CentOS, Fedora, OpenSUSE, RHEL and
SLE](http://software.opensuse.org/download.html?project=home%3Abekun&package=elektra).

## Get It!

You can download the release from:

http://www.markus-raab.org/ftp/elektra/releases/elektra-0.8.7.tar.gz
size: 1566800
md5sum: 4996df62942791373b192c793d912b4c
sha1: 00887cc8edb3dea1bc110f69ea64f6b700c29402
sha256: 698ebd41d540eb0c6427c17c13a6a0f03eef94655fbd40655c9b42d612ea1c9b

already build API documentation can be found here:

https://doc.libelektra.org/api/0.8.7/html/

Best regards,
Markus





# 0.8.8 Release

- guid: eca69e19-5ddb-438c-ac06-57c20b1a9160
- author: Markus Raab
- pubDate: Tue, 02 Sep 2014 17:31:42 +0200
- shortDesc: adds 3-way merging, reworked documentation & improved kdb tool

In this release we changed 578 files in 473 commits
(68596 insertions(+), 59260 deletions(-) compared to Elektra 0.8.7).
We assume thats the largest changeset for any of Elektra’s releases
up to now. It happened only within a bit more than a month up
(0.8.7 was released 28.07.2014).

## New features

GSoC finished successfully (thanks Ian and Felix)
See http://community.libelektra.org/wp for the latest results.
So Elektra now has a 3-way merging framework that is superior
to text-based merging in many scenarios (e.g. moving configuration
options within a file or with in-line comments) iff a storage plugin
creates key names that are not only line numbers.
We love to get Feedback!

Writing plugins is now even more comfortable.
A plugin writer tutorial was written (thanks Ian):
https://github.com/ElektraInitiative/libelektra/blob/master/doc/tutorials/plugins.md
The documentation was completely reworked:
https://doc.libelektra.org/api/0.8.7/html/group__plugin.html
And two new macros allow printf formatting for warnings and errors
(`ELEKTRA_ADD_WARNINGF` and `ELEKTRA_SET_ERRORF`).

The ini plugin was greatly improved (tested with samba configurations
and added to ALL plugins) and the hosts plugin was rewritten to support
ipv6 properly (thanks to Felix).

The constants plugin was added and allows introspection of Elektra’s
CMake variables. Because such non-file-based plugins (e.g. also uname)
do not need resolving, the plugin noresolver was added. It supersedes
the success plugin.

Elektra now allows one to correctly fsync its configuration files
(sync plugin) and the folders where files are stored (resolver plugin).
Just make sure to add the "sync" plugin using kdb mount.
The resolver plugin now reads from passwd and no longer needs
environment variables. Additionally, the resolver plugin was prepared
to support other variants by so-called compilation variants.

The error plugin now allows, next to list all possible errors, to
provoke errors when opening plugins. We fixed some issues related
to plugins having errors when they initialize themselves.

So following plugins were added: sync noresolver line ini constants
Nearly all plugins now have a README.md for further information
(thanks to Ian). An overview of all plugin is on with links to them:
https://github.com/ElektraInitiative/libelektra/blob/master/src/plugins/

The kdb tools were greatly improved (thanks to Felix):

- added remount tool
- umount now also accepts mountpath
- mount allows one to specify different resolvers
- import now can use merge strategies
- check without arguments checks key database
- mount is now more verbose when validation fails

New/improved scripts/make targets (note that scripts can be executed by
kdb scriptname):

- mounting, unmounting scripts were added
- generate template for a new plugin was improved
- configure-debian was added
- added targets `run_all` and `run_memcheck`
- bash completion file now installed
- ucf integration
- merging scripts were added for the usage with ucf
- scripts doing internal checks on source of plugins

## Compatibility

This time we had to break compatibility. We did not change the ABI (your
application still will be able to use Elektra 0.8.8) and we did not
change the API (your application still will compile against Elektra). We
changed the third part of our interface: the semantic interface.

The problems were following:
keyAddBaseName/keySetBaseName did something obvious when no special
characters were in the baseName. But once there were, there are two
different interpretations what it should do:

1. add/set a basename, so escape characters that are not canonical
   in the basename
2. add all parts of the name given (with slashes)

The methods were used in both ways, so it was obvious that something is
very wrong. We decided that it should do what the name says, that is
add/set a basename (variant 1).

The variant 2, to add any name was added and is called keyAddName() and
added as proposal.

(Thank Felix for implementations and Manuel for investigations)

When keys are renamed after adding to a keyset is a bad thing because it
destroys the order of the keyset. This is now avoided by keyLock.
Use keyDup() to get rid of such locks.

Another, even larger, change is also about ordering of keys in keysets.
Elektra now internally has an null-terminated unescaped key name.
Ordering of keysets will always happen on this name. The `keyCmp()` tool
can be used to check this order. It works very efficiently with
`memcmp()` and never gets confused by ASCII ordering of / (because / is
0 in the unescaped key name).

The syntax, semantics and conventions of key names is now documented in
detail:
https://doc.libelektra.org/api/0.8.8/html/group__keyname.html

ksNew() does now return a keyset with a properly set cursor (ksRewind).

Because its always possible that software relies on bugs the
better way to deal with such a situation (as the keySetBaseName()
situation described above) is to provide the same function twice.
Manuel said he will create a prototype to introduce symbol versioning
in Elektra. With that, old customers would still receive the old
behavior, but people compiling against a new version would get the new
behavior. So in one of the next releases we will also avoid semantic
interface changes when there is a valid use case for it (there is none
if the program e.g. crashes).

Symbol versioning also allows one to compile against old versions on
purpose if you do not want the new behavior.

We have prepared an ABI-test suite, that also checks behavior,
for that purpose, but we also improved testing in other parts:

- (New Test strategy)[/doc/TESTING.md]
- New resolver tests for conflicts (needs tty)

If you try to execute test_ks from 0.8.7 with libelektra 0.8.8 it will
crash, but not because of any incompatibility, but because of `strcmp` in
the test itself gets a null pointer. The pointer is now null, because
ksNew correctly rewinds its internal cursor (see above). Amusingly,
it says on that line 94 in test_ks.c:
// TODO: why is the cursor here?

## API Proposals

see above for more information:

- `keyAddName` .. add key name without escaping, like keySetName
- `keyUnescapedName` .. get access to null-separated unescaped name
- `keyLock` .. to allow one to secure keys against modifications

some new ideas:

- `keySetStringF` .. printf format-style changing of the key string
- `elektraKeySetName` .. to allow one to set meta + cascading keys

`elektraArrayIncName()` now works correctly with empty arrays embedded in
other arrays (yajl+line plugin)

`elektraArrayValidateName()` was also added, thanks to Felix.

These methods are declared in the file `kdbproposal.h`
but do not guarantee any forms of compatibility (they might
even be removed).

## Issues

Many issues were resolved as you can see in github:
https://github.com/ElektraInitiative/libelektra/issues
Alone for the milestone 0.8.8 we closed 17 issues, including
those mentioned in "Compatibility". Other issues (not all were
tracked on GitHub):

- fix undefined errors in `kdbOpen()` or `kdbClose()`
- Now Python 2+3 work in parallel
- python2 interpreter is found correctly (also on Arch)
- Sentinel now makes sure that you cannot forget `KS_END` to end `ksNew`
- Fixes for architecture-specific problems by Pino
- fix .pc file
- fix compilation problem with `KDB_MAX_PATH_LENGTH`
- tmpnam to mkstemp (security)
- make test data naming consistent (thanks Pino)
- use `LIB_SUFFIX for TARGET_TOOL_EXEC_FOLDER` thanks to Kai Uwe
- Fix search for boost (thank Pino)

## Other Stuff

Thanks to Pino Toscano Elektra 0.8.7-4 is now available in Debian
Testing: https://packages.debian.org/search?keywords=elektra
So it is only a matter of time that other (debian-based) distributions
will follow and replace the dusty Elektra 0.7.

Debian Continuous Integration http://ci.debian.net/packages/e/elektra
(thanks Pino)
greatly complement our tests running on https://build.libelektra.org/

Elektra’s buildserver also was improved:

- now also compiles with icc
- runs `make run_memcheck`
- checks if plugins are added correctly in-source
- runs ABI + behavioral tests

Raffael Pancheri now made a merge request for qt-gui
https://github.com/ElektraInitiative/libelektra/pull/103/files
in which copy, paste and delete of keys already works.
It is, however, still work in progress.

Manuel Mausz made great progress in script-based Elektra plugins. He is
also working on glib+gobject-introspection based bindings.
He investigated some issues, e.g. a crash of the python binding which
was only triggered if python3 is build with a specific flag/module
combination, see:
https://github.com/ElektraInitiative/libelektra/issues/25

## Get It!

You can download the release from:

http://www.markus-raab.org/ftp/elektra/releases/elektra-0.8.8.tar.gz

- size: 1644441
- md5sum: fe11c6704b0032bdde2d0c8fa5e1c7e3
- sha1: 16e43c63cd6d62b9fce82cb0a33288c390e39d12
- sha256: ae75873966f4b5b5300ef5e5de5816542af50f35809f602847136a8cb21104e2

already built API documentation can be found here:

https://doc.libelektra.org/api/0.8.8/html/

Best regards,
Markus





# Augeas and Config::Model

- author: Markus Raab
- guid: eca69e19-5ddb-438c-ac06-57c20b1a9160
- pubDate: Mon, 22 Oct 2014 17:31:42 +0200

A common question is: now we have Augeas for editing config files,
why do we need Elektra, Config::Model or something else?

First, it is clear that Augeas is a huge step forward and improved
configuration of Linux systems, especially when used with centralized
configuration management tools.

Augeas, in short, introduces a special-purpose programming language that
allows to transform configuration files into configuration trees and
back. This transformation is it strength (so it is easy to add support
for a particular legacy configuration files), but also it weakness (the
mapping is implementation-defined by a language that is limited to a bit
more than regular expressions). Augeas is not able nor is it intended
to provide more abstraction over the configuration files. Instead Augeas
mirrors the structure of the configuration as closely as possible.

Elektra’s goal, instead, is not only to provide access to legacy
configuration files, but to provide access to the configuration
exactly as the programs itself uses it. So with Elektra, the developers of
applications are part of Elektra’s ecosystem by providing specifications
how their configuration should look like and by writing plugins that
define how the configuration is accessed and checked. Ideally, after
some time of legacy issues and migration, developers will also not
have to care about writing plugins anymore, but just use any available
ones (and users of their application can choose any other compatible
plugin). What is about to stay is a specification that defines the
application's configuration, e.g. in INI (could be any syntax):

```ini
[/yourapp/file_dialog/show_hidden_files]
type=Boolean
default=true
```

allows other applications to reuse your setting show_hidden_files by
referring to above specification. So Elektra not only abstracts from
cross-platform-related issues with an consistent API, but also allows
us to be aware of other applications' configurations, leveraging easy
application integration.

Config::Model shares most of Elektra’s goals, especially those regarding
validation (you saw the type=Boolean above) and having a unified
interface for all programs (this feature is unavoidable with any such
approach). The projects mainly differs that Elektra is supposed to be used
by the programs themselves (and not only by GUIs and validation tools)
and that Elektra uses self-describing data: the specification itself
is also in Elektra’s key database, stored in metadata and e.g. below
system/elektra/mountpoints. In Elektra validators can be
written in any language (because the specification is just data)
and can enforce constraints on any access (because plugins define
the behavior of the key database).





# 0.8.9 Release

- guid: 38640673-3e07-4cff-9647-f6bdd89b1b08
- author: Markus Raab
- pubDate: Tue, 04 Nov 2014 10:48:14 +0100
- shortDesc: adds qt-gui, several optimizations & fixes

Again we managed to do an amazing feature release in just two month.
In 416 commits we modified 393 files with 23462 insertions(+) and
9046 deletions(-).

## Most awaited

The most awaited feature in this release is certainly the _qt-gui_
developed by Raffael Pancheri. It includes a rich feature set including
searching, unmounting, importing and exporting. A lot of functionality
is quite stable now, even though its version is 0.0.1 alpha. If you find
any bugs or want to give general feedback, feel free to use the issue
tracker of the Elektra Initiative. A screenshot can be found
[here](https://github.com/ElektraInitiative/libelektra/blob/master/doc/images/screenshot-qt-gui.png)
To compile it (together with Elektra), see the README
[here](https://github.com/ElektraInitiative/libelektra/tree/master/src/tools/qt-gui)

Manuel Mausz also has been very active and developed glib+gi bindings.
These bindings make Elektra more friendly to the glib/gtk/gnome world.
Using the gobject introspection python3 and lua bindings were developed.
Additionally he got rid of all clang warnings.

Felix Berlakovich also made progress: [the ini
plugin](https://github.com/ElektraInitiative/libelektra/tree/master/src/plugins/ini)
now supports multiline and
which can be dynamically turned on and off, i.e. during mounting
(thanks to Felix)

Last, but not least, Kai-Uwe ported Elektra to Windows7. MinGW is now
one more supported compiler (tested on build-server, see later).
Astonishingly, it was only little effort necessary:
Basically we only needed a new implementation of the resolver, which
is now called _wresolver_. Different from the _resolver_ it lacks the
sophisticated multi-process and multi-thread atomicity properties. On
the plus side we now have a resolver that is very easy to study and
understand and still works as file resolver (_noresolver_ does not).

## Interfaces

ABI/API of the C-API is still completely stable even though under the
hood a lot was changed. All test cases compiled against the previous
version still run against Elektra 0.8.9.

This is, however, not the case for libtools. For MinGW porting it was
necessary to rename an enum related to merging because it conflicted
with an already defined MACRO.

For maintainers also some changes are necessary. For MinGW and to
actually use the flexibility of the new resolver variants two new CMake
Variables are introduced: KDB_DEFAULT_RESOLVER and KDB_DEFAULT_STORAGE.

More importantly for maintainers the CMake variables regarding SWIG
bindings are now abandoned in favor to the new variable BINDINGS that
works like PLUGINS and TOOLS. Just start with

```sh
-DBINDINGS=ALL
```

and CMake should remove the bindings that have missing dependencies
on your system. Remember that glib and gi (i.e. _gi_python3_ and
_gi_lua_) bindings were introduced, too. Additionally, the _cpp_
binding can now be deactivated if not added to BINDINGS.

Finally, the _gen_ tool added a Python package called `support`.

## Other Bits

A proof of concept storage plugin `regexstore` was added. It allows one to
capture individual configuration options within an otherwise not
understood configuration file (e.g. for vimrc or emacs where
the configuration file may contain programming constructs).

Most tests now also work with the BUILD_SHARED variant (from our
knowledge all would work now, but some are still excluded if
BUILD_FULL and BUILD_STATIC is disabled. Please report issues
if you want to use uncommon CMake combinations).

A small but very important step towards specifying configuration files
is the new proposed API method ksLookupBySpec (and ksLookup implementing
cascading search). It introduces a `logical view` of
configuration that in difference to the `physical view` of
configuration does not have namespaces, but everything is below the root
"/". Additionally, contextual values now allow one to be compile-time
configured using C++-Policies. These are small puzzle pieces that will
fit into a greater picture at a later time.

A (data) race detection tool was implemented. Using it a configurable
number of processes and threads it tries to kdbSet() a different
configuration at (nearly) the same time.

With this tool the resolver could be greatly be improved (again). It now
uses stat with nanosecond precision that will be updated for every
successful kdbSet(). Even if the configuration file was modified
manually (not using Elektra) the next kdbSet() then is much more likely
to fail. Additionally a recursive mutex now protects the file locking
mechanism.

The build server now additionally has following build jobs:

- i386 build:
  We had an i386 regression, because none of the developers
  seems to use i386 anymore.
- Configure Debian Script:
  Calls the scripts/configure-debian(-wheezy).
- Local Installation:
  We had an regression that local installation was not possible because
  of a bash completion file installed to /etc. This build tests if it is
  possible to install Elektra in your home directory (and calls kdb
  run_all afterwards)
- Test bindings:
  Compiles and tests ALL bindings.
- Mingw:
  Compiles Elektra using mingw.

Many more examples were written and are used within doxygen. Most
snippets now can also be found in compilable files:

- [keyNew examples](https://github.com/ElektraInitiative/libelektra/tree/master/examples/keyNew.c)
- [keyCopy examples](https://github.com/ElektraInitiative/libelektra/tree/master/examples/keyCopy.c)
- [C++ deep dup](https://github.com/ElektraInitiative/libelektra/tree/master/src/bindings/cpp/examples/cpp_example_dup.cpp)
- [How to put Key in different data structures](https://github.com/ElektraInitiative/libelektra/tree/master/src/bindings/cpp/examples/cpp_example_ordering.cpp)
- [Mount some config files using augeas](https://github.com/ElektraInitiative/libelektra/tree/master/scripts/kdb/mount-augeas)
- [Mount system information](https://github.com/ElektraInitiative/libelektra/tree/master/scripts/kdb/mount-info)

Most plugins now internally use the same CMake function `add_plugin`
which makes plugin handling more consistent.

Felix converted the METADATA spec to ini files and added a proposal
how comments can be improved.

### Refactoring:

- reuse of utilities in gen code generator
- the gen support library is now in its own package (`support`)
- refactor array handling
- internal comparision functions (keyCompareByName)

### Optimization:

- lookupByName does not need to allocate two keys
- lookups in generated code
- prefer to use allocation on stack

### Fixes:

- disable cast that segfaults on i386 (only testing code was affected)
- fix keyAddBaseName in xmltool and testing code
- support non-system installation (e.g. in home directory)
- rewrote test cases to use succeed_if_same to avoid crashes on
  null pointers
- allow one to use python 2.6 for kdb gen
- improve exception messages
- use memcasecmp (fix lookup ignoring case)
- fix memory leaks (ini)
- text messages for some warnings/errors
- fix many issues regarding CMake, more variants of setting CMake
  options are now allowed.
- CMake policies fixes allow us to use CMake version > 3

## Get It!

You can download the release from
[here](http://www.markus-raab.org/ftp/elektra/releases/elektra-0.8.9.tar.gz)

- size: 1936524
- md5sum: 001c4ec67229046509a0cb9eda223dc6
- sha1: 79ea9b83c08ed4c347ed0100b5e0e2d3309b9d04
- sha256: e0895bba28a27fb37f36f59ef77c95235f3a9c54fb71aa6f648566774d276568

already built API documentation can be found
[here](https://doc.libelektra.org/api/0.8.9/html/)

For more information, see https://www.libelektra.org

Best regards,
Markus





# 0.8.10 Release

- guid: 6ce57ecf-420a-4a31-821e-1c5fe5532eb4
- author: Markus Raab
- pubDate: Tue, 02 Dec 2014 18:37:51 +0100
- shortDesc: adds XDG/OpenICC compatibility & java binding

Hello,

we are delighted to announce our latest feature release providing
major updates in:

- compatibility with standards,
- tooling,
- plugins (hosts, rename),
- Qt-Gui and
- a new Java binding

## XDG Compatibility

Elektra now is fully XDG 0.8
compliant. Following changes were necessary:

- newly created configuration files for user/ now have the permissions
  0600
- newly created configuration directories for user/ now have the
  permissions 0700
- existing configuration files will retain their permissions.
- The default path to store user configuration is now ~/.config
- A new resolver variant x (for user and system) is introduced
  - implements handling of XDG environment variables
  - ignores empty dirs and absolute paths in envvar
- add new shell based test suite for (xdg)-resolver

For example, we could use `resolver_fm_xhp_x`:

    kdb mount --resolver=resolver_fm_xhp_x file.dump /example dump
    kdb file user/example
    kdb file system/example

Will show you that for both user+system the resolver respects
XDG environment variables, e.g. above lines will print:

    /home/m/.config/file.dump
    /etc/xdg/file.dump

Of course, any attempts to get and set keys below user/example and
system/example will also be in these files.

The letters after `_` describe the variant of the resolver:

- `f` .. file-based locking
- `m` .. mutex based locking (for multiple KDB per process)
- for user configuration (after next `_`)
  - `x` .. first check `XDG_CONFIG_HOME` environment
  - `h` .. then check `HOME` environment
  - `p` .. then fall back to passwd
- for system configuration (after next `_`)
  - `x` .. check all paths in `XDG_CONFIG_DIRS` and falls back to `/etc/xdg`

A lot of such resolver variants are added when `-DPLUGINS=ALL` is used.
Of course you can create new variants with different behavior by adding
them to PLUGINS.

To make your application (that uses Elektra) XDG aware, you have nothing
to do: you get it to free. Make sure to always use cascading lookup.
Additionally, an XDG conforming application should not write system/
keys.

## OpenICC Compatibility

Based on that, Elektra now also implements the draft for
[the OpenICC specification](https://www.openicc.info/index.php%3Ftitle=OpenICC_Configuration_0.1.html).

The mount command looks like quite complicated, but it consists of
simple parts:

```sh
kdb mount --resolver=resolver_fm_xhp_x \
  color/settings/openicc-devices.json /org/freedesktop/openicc \
  yajl rename cut=org/freedesktop/openicc
```

We already know the first two lines: we use the XDG resolver already
introduced above. Only the file name and the path where it should be
mounted differs.

The plugin yajl is a storage plugin that reads/writes json. The plugin
rename was the missing link to support OpenICC (thanks to Felix
Berlakovich for closing this gap). It is needed, because every OpenICC
file starts like this:

```
{ "org": { "freedesktop": { "openicc": {
```

Because the backend is mounted at /org/freedesktop/openicc, it would
lead to keys below /org/freedesktop/openicc/org/freedesktop/openicc
which we obviously do not want. So we simply get rid of the common
prefix by cutting it out using the rename plugin.

Of course this renaming functionality can be used in every situation and
is not limited to OpenICC.

## Tools

A large number of old and new tools were added, mostly for convenience
e.g.:

```sh
kdb mount-openicc
```

saves you from writing the long mount command we had in the previous
section.

To get a list of all tools that are installed, now the command (which is
also an external tool and as such currently not displayed in kdb --help):

```sh
kdb list-tools
```

is available. Do not be surprised: on typical installations this will
be a large list. You can run each of these tools by using kdb <command>.
Most of the tools, however, are part of the test suite,
which you can run using:

```sh
kdb run_all
```

Other tools are "old friends", e.g. convert-fstab written in 2006 by Avi
Alkalay still works:

```sh
kdb convert-fstab | kdb import system/filesystems xmltool
```

It will parse your /etc/fstab and generate a XML. This XML then can be
imported. Other convert tools directly produce kdb commands, though.

kdb now uses KDB itself for many commands:

- /sw/kdb/current/resolver .. You always want a different default
  resolver than that was compiled in as default when mounting
  backends?
- /sw/kdb/current/format .. If you are annoyed by the default format
  dump format for import/export.
- /sw/kdb/current/plugins .. If you always forget to add some plugins
  when mounting something.

By default the plugin "sync" is added automatically (it makes sure that
fsync is executed on config files, the directory is already done by the
resolver), you should not remove it from /sw/kdb/current/plugins
otherwise the next mount command will not add it. To preserve it use a
space separated list, e.g.:

```sh
kdb set user/sw/kdb/current/plugins "sync syslog"
```

Last, but not least, kdb get now supports cascading get:

```sh
kdb get /sw/kdb/current/plugins
```

This feature allows you to see the configuration exactly as seen by the
application.

Other options:

- -123 options for hiding nth column in `kdb mount`
- hide warnings during script usage of `kdb mount`
- -0 option accepted in some tools (null termination)
- Mount got a new -c option for backend configuration. For example
  -c cut=org/freedesktop/openicc would be the parameter cut for all
  plugins. Have a look at #146 if you want to use it.

## Compatibility

The core API (kdb.h), as always, stayed API/ABI compatible. The only
changes in kdb.h is the addition of `KEY_CASCADING_NAME` and
`KEY_META_NAME`. So applications compiled against 0.8.10 and using these
constants, will not work with Elektra 0.8.9.

The constants allow us to create following kinds of keys:

- empty names: this was always possible, because invalid names
  (including empty names) did not cause keyNew to abort
- metanames: this is a new feature that allows us to compare key names
  with metakeys
- cascading names: names starting with / have the special meaning that
  they do not specify which namespace they have. When such names are
  used for
  - kdbGet() and kdbSet() keys are retrieved from all namespaces
  - ksLookup() keys are searched in all namespaces
  - ksLookupByName() is now just a wrapper for ksLookup().
    The method does not do much except creating a key and passing
    them to ksLookup().

Usage in C is:

```c
Key *c = keyNew("/org/freedesktop", KEY_CASCADING_NAME, KEY_END);
Key *m = keyNew("comment/#0", KEY_META_NAME, KEY_END);
```

The same functionality exists, of course, in available in all bindings,
too.

Changes in non-core API are:

- xmltool now does not output default (unchanged) uid,gid and mode
- ksLookupBySpec from kdbproposal.h was removed, is now integrated into
  ksLookup
- extension keyNameGetNamespace was removed
- the hosts comment format has changed
- the default resolver has changed (uses passwd)
- kdb::tools::Backend::Backend constructor, tryPlugin and addPlugin
  have changed:
- mountname is now automatically calculated
- addPlugin allows us to add a KeySet to validate plugins with different
  contracts correctly
- C++ binding now throws std::bad_alloc on allocation problems (and not
  InvalidName)

## CMake

It is now possible to remove a plugin/binding/tools by prefixing a name
with "-". The new "-element" syntax is accepted by TOOLS, BINDINGS and
PLUGINS. It is very handy in combination with ALL, e.g.:

```sh
-DPLUGINS="ALL;-xmltool"
```

will include all plugins except xmltool.

## Improved comments

Comment preserving was improved a lot. Especially, the hosts plugin was
rewritten completely. Now multiple different comment styles can be
intermixed without losing information. E.g. some INI formats support
both ; and # for comments. With the new comments it is possible to
preserve that information and even better: applications can iterate
over that information (metadata).

To mount the new hosts plugin use (if you already have mounted it, you
have nothing to do):

```sh
kdb mount /etc/hosts system/hosts hosts
```

The hosts plugin now separates from ipv4 and ipv6 which makes the host
names canonical again, e.g.:

```sh
kdb get system/hosts/ipv4/localhost
kdb get system/hosts/ipv6/localhost
```

To access the inline-comment, use:

```sh
kdb getmeta system/hosts/ipv4/localhost "comment/#0"
```

For other meta information, see:

```sh
kdb lsmeta system/hosts/ipv4/localhost
```

Additionally, a small API for specific metadata operations emerges.
These operations will be moved to a separate library and will not stay
in Elektra’s core library.

## Proposal

- lookup options:
  - `KDB_O_SPEC` uses the lookup key as specification
  - `KDB_O_CREATE` creates a key if it could not be found
- `elektraKeyGetMetaKeySet` creates a KeySet from metadata
- `elektraKsFilter` allows us to filter a KeySet arbitrarily (not only
  `keyIsBelow` in case of `ksCut`). It reintroduces more functional
  programming.
- `keyGetNamespace` was reintroduced. In one of the next versions of
  Elektra we will introduce new namespaces. `keyGetNamespace` allows the
  compiler to output a warning when some namespaces are not handled in
  your C/C++ code.

## Java binding

Elektra now fully supports applications written in Java and also Plugins
written in the same language.

The
[new binding was developed using jna.](https://github.com/ElektraInitiative/libelektra/tree/master/src/bindings/jna)
For the
[plugin interface JNI](https://github.com/ElektraInitiative/libelektra/tree/master/src/plugins/jni)
was used.
We developed already
[some plugins](https://master.libelektra.org/src/bindings/jna/libelektra5j/src/main/java/org/libelektra/plugin).

## Qt-Gui

Raffael Pancheri released the version 0.0.2 of the Qt-Gui:

- added Backend Wizard for mounting
- user can hover over TreeView items and quickly see key name, key value
  and metakeys
- it is now easily possible to create and edit arrays
- added header to MetaArea for better clarity
- many small layout and view update fixes

## Further stuff and small fixes

- Two new error/warnings information: mountpoint and configfile.
  It is added automatically and all tools will print it.
- C++ I/O for key(s) now allows null terminator next to new-line
  terminator
- fix error plugin: now use `on_open`/`trigger_warnings` to be consistent
- fix metaset: now correctly append new key
- arrays are also available when compiled with mingw
  (but tests still have to be excluded for successful compilation)
- fix #136
- fix long help text in `kdb check`
- signed release tags are now used

## Get It!

You can download the release from
[here](http://www.markus-raab.org/ftp/elektra/releases/elektra-0.8.10.tar.gz)

- size: 1915277
- md5sum: 2b16a4b555bc187562a0b38919d822a1
- sha1: 08b1d0139fc5eb0d03c52408478e68b91b1825dc
- sha256: 526e2ed61e87d89966eb36ddad78d8139b976e01ce18aab340d8a1df47132355

already built API documentation can be found
[here](https://doc.libelektra.org/api/0.8.10/html/)

## Stay tuned!

Subscribe to the
[new RSS feed](https://doc.libelektra.org/news/feed.rss)
to always get the release notifications.

[Permalink to this NEWS entry](https://doc.libelektra.org/news/6ce57ecf-420a-4a31-821e-1c5fe5532eb4.html)

For more information, see https://www.libelektra.org

Best regards,
Markus





# 0.8.11 Release

- guid: 7d4647d4-4131-411e-9c2a-2aca39446e18
- author: Markus Raab
- pubDate: Fri, 03 Apr 2015 02:39:37 +0200
- shortDesc: adds specification namespace & numerous improvements

From the beginning of the Elektra Initiative, Elektra aimed at avoiding
hard coded information in the application and to make the application's
configuration more transparent. While avoiding any paths to files was
reality from the first released Elektra version, now also hard coding
default values, fallback mechanisms and even Elektra’s paths to keys
can be avoided.

## How does that work?

Elektra 0.8.11 introduces a so-called specification for the
application's configuration. It is located below its own namespace
`spec` (next to user and system).

Once the base path is known, the user can find out all Elektra
paths used by an application, using:

```sh
kdb ls spec/basepath
```

Keys in `spec` allow us to specify which keys are read by the application,
which fallback it might have and which is the default value using
metadata. The implementation of these features happened in `ksLookup`.
When cascading keys (those starting with `/`) are used following features
are now available (in the metadata of respective `spec`-keys):

- `override/#`: use these keys _in favor_ of the key itself (note that
  `#` is the syntax for arrays, e.g. `#0` for the first element,
  `#_10` for the 11th and so on)
- `namespace/#`: instead of using all namespaces in the predefined order,
  one can specify which namespaces should be searched in which order
- `fallback/#`: when no key was found in any of the (specified) namespaces
  the `fallback`-keys will be searched
- `default`: this value will be used if nothing else was found

This technique does not only give you the obvious advantages, but
also provides complete transparency how a program will fetch a configuration
value. In practice that means that:

```sh
kdb get "/sw/app/#0/promise"
```

will give you the _exact same value_ as the application uses when it
lookups the key `promise`. Many `if`s and hard coded values are avoided,
we simply fetch and lookup the configuration by following code:

```c
Key *parentKey = keyNew("/sw/app/#0", KEY_CASCADING_NAME, KEY_END);
kdbGet(kdb, ks, parentKey);

ksLookupByName(ks, "/sw/app/#0/promise", 0);
```

We see in that example that only Elektra paths are hard coded in
the application. But those can be found out easily, completely without
looking in the source code. The technique is simple: append a
logger plugin and the KDB base path is printed to:

- stdout in the case of the plugin tracer
- syslog in the case of the plugin syslog
- journald in the case of the plugin journald

What we do not see in the program above are the default values and
fallbacks. They are only present in the so specification (namespace `spec`).
Luckily, the specification are key-value pairs, too. So we do not have
to learn something new, e.g. using the ni plugin we can specify:

```ini
[promise]
default=20
fallback/#0=/somewhere/else
namespace/#0=user
```

1. When this file is mounted to `spec/sw/app/#0` we specify, that
   for the key `/sw/app/#0/promise` only the namespace `user` should be
   used.
2. If this key was not found, but `/somewhere/else` is present, we will use
   this key instead. The `fallback` technique is very powerful: it allows
   us to have (recursive) links between applications. In the example above,
   the application is tricked in receiving e.g. the key `user/somewhere/else`
   when `promise` was not available.
3. The value `20` will be used as default, even if no configuration file
   is found.

Note that the fallback, override and cascading works on _key level_,
and not like most other systems have implemented, on
configuration _file level_.

## Namespaces

The specification gives the namespaces clearer semantics and
purpose. Key names starting with a namespace are connected to a
configuration source. E.g. keys starting with:

- `user` are keys from the home directory of the current user
- `system` are keys from the `/etc` directory of the current system
- `spec` are keys from the specification directory (configurable
  with `KDB_DB_SPEC`, typically `/usr/share/elektra/specification`)

When a key name starts with an `/` it means that it is looked up by
specification. Such a cascading key is not really present in the keyset
(except when a default value was found). They are neither received
nor stored by `kdbGet` and `kdbSet`.

Applications shall only lookup using cascading keys (starting with `/`).
If no specification is present, cascading of all namespaces is used as before.

Elektra will (always) continue to work for applications that do not have a
specification. We strongly encourage you, however, to write such a
specification, because:

- it helps the administrator to know which keys exist
- it documents the keys (including lookup behavior and default value)
- and many more advantages to come in future releases..

For a tutorial how to actually elektrify an application and for more
background to Elektra,
[read this document](https://github.com/ElektraInitiative/libelektra/blob/master/doc/tutorials/application-integration.md).

For a full list of proposed and implemented metadata,
[read this document](https://github.com/ElektraInitiative/libelektra/blob/master/doc/help/elektra-namespaces.md).

## Simplification in the merging framework

As it turned out the concept of very granular merge strategies was hard to understand
for users of the three-way merging framework that emerged in the last year's
GSoC. While this granularity is desirable for flexibility, we
additionally wanted something easy to use. For that reason merge
configurations were introduced. These are simply preconfigured configurations for a merger
that arrange required strategies for the most common merging scenarios. Especially
they make sure that meta merging is handled correctly.

Have a look at the changes in the example
[/src/libs/tools/examples/merging.cpp](https://github.com/ElektraInitiative/libelektra/blob/master/src/libs/tools/examples/merging.cpp)
for an glimpse of the simplifications.

A big thanks to Felix Berlakovich!

The header files will be installed to /usr/include/elektra/merging, but they are
subject to be changed in the future (e.g. as they did in this release).

From the merging improvements some minor incompatibility happened in
`kdb import`. Not all merging strategies that worked in 0.8.10 work
anymore. Luckily, now its much simpler to choose the strategies.

## API

The main API kdb.h has two added lines. First a new method was added:

```c
ssize_t keyAddName(Key *key, const char *addName);
```

This method is already used heavily in many parts. Contrary to `keySetBaseName` and
`keyAddBaseName` it allows us to extend the path with more than one Element at once,
i.e. `/` are not escaped.

The other new line is the new enum value `KEY_FLAGS`.
This feature allows bindings to use any flags in keyNew without actually
building up variable argument lists. (Thanks to Manuel Mausz)

As always, API+ABI is stable and compatible.

## Proposed

Many new functions are proposed and can be found in
[the doxygen documentation](https://doc.libelektra.org/api/0.8.11/html) and in
[kdbproposal.h](https://github.com/ElektraInitiative/libelektra/blob/master/src/include/kdbproposal.h).

Noteworthy is the method `keyGetNamespace` which allows us to query all
namespaces. Since this release we changed every occurrence of namespaces
(except documentation) with switch-statements around `keyGetNamespace`.
This allows us to add new more namespaces more easily. (Although its
currently not planned to add further namespaces.)

Finally, a bunch of new lookup options were added, which might not be
useful for the public API (they allow us to disable the
specification-aware features mentioned in the beginning).

## Obsolete and removed concepts

### umount

The concept that backends have a name (other than their mountpoint)
is now gone. Backends will simply be named with their escaped mountpath
below system/elektra/mountpoints without any confusing additional name.

Unmounting still works with the mountpath.

Removing this concept makes Elektra easier to understand and it also
removes some bugs. E.g. having mountpoints which do not differ except
having a `_` instead of a `/` would have caused problems with the
automatic name generation of Elektra 0.8.10.

Old mountpoints need to be removed with their 0.8.10 name
(`_` instead of `/`).

### directory keys

Additionally, the so-called directory keys were also removed.
Elektra was and still is completely key-value based. The `/` separator
is only used for mountpoints.

### fstab

The plugin fstab is also improved: Slashes in mountpoints are
escaped properly with the internal escaping engine of keyAddBaseName()
(i.e. without any problematic `/` replacements).

### dirname

getDirName() was removed from C++, gi-lua, gi-python2, gi-python3,
swig-lua, swig-python2 and swig-python3. It was never present in C and
did not fit well with keyBaseName() (which returns an unescaped name,
which is not possible for the dirname). (Thanks to Manuel Mausz)

### invalid parent names

While empty (=invalid) names are still accepted as parentName to `kdbGet`
and `kdbSet` for compatibility reasons, but the parentKey

```c
Key *parentKey = keyNew("/", KEY_END);
```

should be used instead (if you want to get or store everything).
They have identical behavior, except that
invalid names (that cannot be distinguished from empty names) will
produce a warning. In the next major version invalid parentNames
will produce an error.

## KDB Behavior

It is now enforced that before a kdbSet() on a specific path a kdbGet()
on that path needs to be done. This was always documented that way and
is the only way to correctly detect conflicts, updates and missing
configuration files. Error #107 will be reported on violations.

Additionally, the handling with missing files was improved. Empty
keysets for a mountpoint now will remove a file. Such an empty file
is always up-to-date. Removing files has the same atomicity guarantees
as other operations.

The concurrency behavior is at a very high level: as expected many processes
with many threads can each concurrently write to the key database,
without any inconsistent states: This is noted here because Elektra
works on standard configuration files without any guarding processes.

Filesystem problems, e.g. permission, now always lead to the same errors
(#9, #75, #109, #110), regardless of the storage plugin.

## Qt-Gui 0.0.6

Raffael Pancheri was very busy and did a lot of stabilizing work:

- Added Markdown converter functionality for plugin documentation
- Integrated help (Whats this?)
- Added credits to other authors
- do not show storage/resolver plugins if a plugin of that kind has been selected
- added menu to newkey toolbar button to allow new array entries
- added option to include a configuration keyset when adding a plugin
- show included keys when creating the plugin configuration
- Added all storageplugins to namefilters
- Reimplement ErrorDialog
- Added undo/redo of all commands and correctly update the view
- modified ToolTip size
- Color animation on search results
- Refactored Buttons to accept shortcuts
- Updated Translations
- Colors are now customizeable
- Many small fixes

The gui is already used and the remaining small bugs (see github)
are going to be fixed soon. One of the highlights is undo for
nearly every action, so nothing prevents you from trying it out!

A huge thanks to Raffael Pancheri for his contributions. His thesis can
be found at [here](https://www.libelektra.org/ftp/elektra/publications/pancheri2015gui.pdf).

## Bug fixing

- fix issues with escaped backslashes in front of slashes
- atomic commits across namespaces work again
- memleak on ReadFile error in ni plugin
- `kdb getmeta` reports errorcode if key, but no meta was found
- `ksLookup` now will also work if a key of the keyset is used as
  search-key (aliasing problem fixed by dup() on namelock)
- resolver regex does not match to wrongly written plugins
- jna plugin is now named libelektra-0.8.11.jar, with proper symbolic link to current version, for every CMake version
- fix bashism (`$RANDOM`)
- new keys are correctly renamed, fixes OpenICC (thanks to Felix Berlakovich)
- comments in host keys are correctly restored (thanks to Felix Berlakovich)
- output stream in type checking is no longer locale dependent (thanks to Manuel Mausz)
- CMake uninstall works again
- simplify `CMAKE_DL_LIBS` (thanks to Manuel Mausz)

## Further gems

- Examples were improved, added (e.g. cascading, namespace) and included in
  [Doxygen documentation](https://doc.libelektra.org/api/0.8.11/html).
- [METADATA specification](https://github.com/ElektraInitiative/libelektra/blob/master/doc/METADATA.ini)
  was nearly completely rewritten (thanks to Felix Berlakovich)
- benchmarks were greatly enhanced (run-time+heap profiling),
  and some important performance improvements were done
- All plugins now use the CMake function `add_plugin`
  (thanks to Ian Donnelly for most of the work)
- data directory (keysets as C-files) is now shared between different
  kinds of test suites.
- many more tests were added, e.g. distribution tests, KDB API tests;
  and allocation tests were readded
- now all kdb commands accept cascading keys.
- More compiler warning-flags are added and many warnings are fixed
- cleanup of old unused `keyName` methods
- The key `system/elektra/mountpoints` itself was always created and a
  left-over on a freshly installed system after the unit tests run the
  first time. The physical presence of the key is now irrelevant and
  it won't be created automatically.
- Bash completion was greatly improved (thanks to Manuel Mausz)
- Configure scripts were refactored and are now much shorter (thanks to Manuel Mausz)
- New Debian build agents were added that are magnitutes faster than the old ones (a big thanks to Manuel Mausz)
- Many KDB tests, written in C, lua and python were added (thanks to Manuel Mausz)
- SWIG3 is preferred when available
- add the plugin counter that counts how often the methods of a plugin are called
- `kdb list-tools` is now advertised in `kdb --help`
- macOS support was greatly improved, thanks to Peter Nirschl
  and Kai-Uwe Behrmann. The feature rich resolver, now also works
  for macOS. wresolver is now only needed for mingw.
- Elektra still compiles with gcc (also mingw variants), icc and clang.

## Further Notes

With 471 files changed, 27978 insertions(+), 11512 deletions(-) this
release is huge. With 773 commits over four month much more changes
happened which did not find their place in these release notes, even
though the notes are much less detailed than usual.

Thanks for all contributions that are not enlisted here!

For any questions and comments, please contact the
[Mailing List](https://lists.sourceforge.net/lists/listinfo/registry-list)
or elektra@markus-raab.org.

## Get It!

You can download the release from
[here](http://www.markus-raab.org/ftp/elektra/releases/elektra-0.8.11.tar.gz)

- name: elektra-0.8.11.tar.gz
- size: 2022129
- md5sum: c53a8151aab760851842d745e904a4f8
- sha1: d7929d17d1a6529089d156f1910d87f678b84998
- sha256: c20fefcfba62cc906228f9b55d1f411ef8f884ff9d75774a0dd4f8eb8f5b48f6

This release tarball now is also available
[signed by me using gpg](http://www.markus-raab.org/ftp/elektra/releases/elektra-0.8.11.tar.gz.gpg)

already built API documentation can be found [here](https://doc.libelektra.org/api/0.8.11/html/)

## Stay tuned!

Subscribe to the
[new RSS feed](https://doc.libelektra.org/news/feed.rss)
to always get the release notifications.

[Permalink to this NEWS entry](https://doc.libelektra.org/news/7d4647d4-4131-411e-9c2a-2aca39446e18.html)

For more information, see https://www.libelektra.org

Best regards,
Markus





# 0.8.12 Release

- guid: 98770541-32a1-486a-98a1-d02f26afc81a
- author: Markus Raab
- pubDate: Sun, 12 Jul 2015 20:14:09 +0200
- shortDesc: adds directory namespace & other improvements and fixes

Again we managed to release with new features, many build system
fixes and also other improvements.

## dir namespace

This namespace adds per-project or per-directory (hence the name) configurations.
E.g. think how Git works: not only /etc and ~ are relevant sources
for configuration but also the nearest .git directory.

This technique is, however, much more widely useful than just for git
repositories! Nearly every application can benefit from such a per-dir
configuration. Its almost certain that you have already run into the
problem that different projects have different guidelines
(e.g. coding conventions, languages, whitespace requirements, line breaks, ..).
Obviously, thats not a per-user configuration and
its also not a per-file issue (thats how its usually solved today).
So in fact you want, e.g., your editor to have an additional per-project layer
to choose between such settings.

The technique is useful for nearly every other tool:

- different color palettes in gimp, inkscape,..
- different languages for LibreOffice
- different security settings for media players, interpreters (e.g. when in Download folder)
- per-folder .htaccess in apache or other web servers
- any other per-dir configuration you can imagine..

It is simple to use, also for the administrative side. First, change to the folder to your
folder (e.g. where a project is):

```sh
cd ~/projects/abc
```

Then add some user (or system or spec) configuration to have some default.

```sh
kdb set user/sw/editor/textwidth 72
```

Then verify that we get this value back when we do a cascading lookup:

```sh
kdb get /sw/editor/textwidth
```

The default configuration file for the dir-namespace is `pwd`/KDB_DB_DIR/filename:

```sh
kdb file dir/sw/editor/textwidth
```

- KDB_DB_DIR can be modified at compile-time and is `.dir` per default
- filename can be modified by mounting, see below, and is `default.ecf` by default

We assume, that the project abc has the policy to use textwidth 120, so
we change the dir-configuration:

```sh
kdb set dir/sw/editor/textwidth 120
```

Now we will get the value 120 in the folder ~/projects/abc and its
subdirectories (!), but everywhere else we still get 72:

```sh
kdb get /sw/editor/textwidth
```

Obviously, that does not only work with kdb, but with every elektrified tool.

### mount files in dir namespaces

For cascading mountpoints, the dir name is also automatically mounted, e.g.:

```sh
kdb mount editor.ini /sw/editor ini
```

But its also possible to only mount for the namespace dir if no cascading mountpoint is
present already:

```sh
kdb mount app.ini dir/sw/app tcl
```

In both cases keys below dir/sw/editor would be in the INI file
`.dir/editor.ini` and not in the file `.dir/default.ecf`.

### dir together with spec namespace

In the project P we had the following issue: We needed on a specific computer the
configuration in /etc to be used in favor of the dir config.

We could easily solve the problem using the specification:

```sh
kdb setmeta spec/sw/P/current/org/base override/#0 /sw/P/override/org/base
```

Hence, we could create system/sw/P/override/org/base which would be in favor of dir/sw/P/current/org/base.
So we get system/sw/P/override/org/base when we do:

```sh
kdb get /sw/P/current/org/base
```

Alternatively, one could also use the specification:

```sh
kdb setmeta spec/sw/P/current/org/base namespace/#0 user
kdb setmeta spec/sw/P/current/org/base namespace/#1 system
kdb setmeta spec/sw/P/current/org/base namespace/#2 dir
```

Which makes dir the namespace with the least priority and system would be preferred.
This was less suitable for our purpose, because we needed the override
only on one computer. For all other computers we wanted dir
to be preferred with only one specification.

### Conclusion

The great thing is, that every elektrified application, automatically gets all the mentioned features.
Not even a recompilation of the application is necessary.

Especially the specification provides flexibility not present in other configuration systems.

## Qt-Gui 0.0.7

Raffael Pancheri again did a lot of stabilizing work:

- show errormessage on exception when starting gui
- Correctly update keyAreaView property when selecting item in TreeView
- Fix crash when creating key in MountingWizard
- Remove information on successful export
- Show error dialog on failed import
- Remove namefilters (every syntax can have any file extension)
- other namespaces (including dir) are included

The GUI can be handy for many purposes, e.g. we use it already as xml and json editor.
Note that there are still [some bugs](https://git.libelektra.org/issues).

## Other fixes

- constants now additionally gives information about SPEC and DIR.
- Doku about CMake variables `ELEKTRA_DEBUG_BUILD` and `ELEKTRA_VERBOSE_BUILD` fixed, thanks to Kurt Micheli
- Fixed compilation of `ELEKTRA_DEBUG_BUILD` and `ELEKTRA_VERBOSE_BUILD`, thanks to Manuel Mausz
- Example with error handling added, thanks to Kurt Micheli
- Add design decision about global plugins
- Split dependencies document to individual README.md, thanks to Ian Donnelly
- Fix nearly all compilation warnings of SWIG, thanks to Manuel Mausz
- CMake: Fix gtest to be build if `BUILD_TESTING` activated, but not `ENABLE_TESTING`
- CMake: Allow compilation without BUILD_STATIC
- Explain compilation options more, thanks to Kai-Uwe Behrmann for asking the question
- CMake: always build examples, allow one to only build documentation
- add common header file for C++ plugins (used by plugins struct and type)
- fix compilation of race tool under oS-11.4 thanks to Kai-Uwe Behrmann
- CMake: find python3 correctly
- CMake: fix BUILD_SHARED_LIBS
- Doxygen: remove `HTML_TIMESTAMP` to make build reproduceable
- Doxygen: rewrite of main page+add info about all five namespaces
- CMake: allow one to use qt-gui with qt built with -reduce-relocations
- fix kdb ls, get to list warnings during open
- during kdbOpen() use Configfile: to state phase
- add -f option to kdb check+improve docu
- improve readability of warning output
- run_all always uses dump for backups
- line plugin round-trips correctly
- untypical resolvers have their non-existant filename handled correctly + sync ignored them correctly
- cmake-3.0 fixes
- cascading merging, a big thanks to Felix Berlakovich for the last minute fix

## Compatibility

As always, the API and API is fully compatible. Because nothing was added, its even
possible to link against an older version of Elektra (if compiled against 0.8.12).

In plugins some small changes may effect compatibility:

- in rename the handling of parent key is different (see #206)
- resolving of spec absolute and relative paths are no more handled identical.
  Instead absolute paths will be searched absolutely, while relatives are below KDB_DB_SPEC (as before).
  This behavior is consistent to the behavior of the other namespaces.

These two points are also the only unit tests that fail when Elektra 0.8.12 is used with 0.8.11 unit tests.

## Build Server

- special GitHub command to build bindings "jenkins build bindings please", thanks to Manuel Mausz
- open build service update
  For [OpenSUSE, CentOS, Fedora, RHEL and SLE](https://build.opensuse.org/package/show/home:bekun:devel/elektra)
  Kai-Uwe Behrmann kindly provides packages [for download](http://software.opensuse.org/download.html?project=home%3Abekun%3Adevel&package=libelektra4).

## Get It!

You can download the release from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.12.tar.gz)
and now also [here on GitHub](https://github.com/ElektraInitiative/ftp/tree/master/releases/elektra-0.8.12.tar.gz)

- name: elektra-0.8.12.tar.gz
- size: 2102450
- md5sum: a40a33ae6661ebfa096378f0986ede6c
- sha1: 3594ef58b6e3b0ffa9589d787679b6e739fbb0dd
- sha256: 562432bea9455a61ff6e6b3263078ea9b26bef2ed177a04b5f9b181d605bc021

This release tarball now is also available
[signed by me using gpg](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.12.tar.gz.gpg)

already built API documentation can be found [here](https://doc.libelektra.org/api/0.8.12/html/)

## Stay tuned!

Subscribe to the
[RSS feed](https://doc.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
[Mailing List](https://lists.sourceforge.net/lists/listinfo/registry-list)
the issue tracker [on GitHub](https://git.libelektra.org/issues)
or by mail elektra@markus-raab.org.

[Permalink to this NEWS entry](https://doc.libelektra.org/news/98770541-32a1-486a-98a1-d02f26afc81a.html)

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

Best regards,
Markus





# 0.8.13 Release

- guid: 3c00a5f1-c017-4555-92b5-a2cf6e0803e3
- author: Markus Raab
- pubDate: Thu, 17 Sep 2015 17:32:16 +0200
- shortDesc: adds elektrify-getenv & other improvements

Again we managed to release with many new features, many fixes
and also other improvements.

## Elektrify-getenv

getenv(3) is one of the most popular ways to retrieve configuration,
even though it has many known problems:

- no standard way to modify it
- relogin (or restart of shell) necessary
- names are flat (no hierarchical structure)
- cannot be set for individual applications
- different in at, cron and similar scripts

With elektrify-getenv we wrote a solution which solves most of the
problems. We use the `LD_PRELOAD` technique to _additionally_ retrieve
values from Elektra, and not only the environment.

You simply can do:

```bash
kdb set user/env/override/HTTP_PROXY "http://my.proxy:8080"
```

This will set the `HTTP_PROXY` environment variable to `http://my.proxy:8080`.
Configuration can be retrieved with `kdb get`:

```bash
kdb get user/env/override/HTTP_PROXY
lynx   # or start another www-browser with the newly set HTTP_PROXY
```

Or using the man pages:

```sh
kdb elektrify-getenv man man --elektra:MANWIDTH=40
```

Will use MANWIDTH 40 for this invocation of man man.
This feature is handy, if an option is only available
by environment, but not by command-line arguments,
because sometimes environment variables are not trivial
to set (e.g. in Makefiles).

Some more examples:

```sh
kdb set user/env/override/MANOPT -- "--regex -LC"
kdb elektrify-getenv getenv MANOPT   # to check if it is set as expected
kdb getenv MANOPT   # if /etc/ld.so.preload is active
```

So is this the final solution for configuration and manual elektrification
of applications is not needed anymore?

The answer is: no and yes.

It is quite satisfactory for configuration that is inherently sharable
(not different from one application to another) _and_ needs the environment
semantics, i.e. some subprocesses should have different configuration
than others, e.g. in a specific terminal.

But it might not be a good solution for your own application, because
libgetenv(3) implies many architectural decision, that other elektrified
applications would decide differently, e.g.:

- it uses global variables (getenv(3) has no handle)
- it uses mutex for multi-threading safety
- the API getenv(3) only returns `char*` and has no support for other data types

For more information see [src/libgetenv/README.md](https://git.libelektra.org/blob/master/src/bindings/intercept/env/README.md)

## Compatibility

As always, the API and API is fully forward-compatible, i.e. programs compiled against an
older 0.8 versions of Elektra will continue to work.

Because `keyUnescapedName` and `keyGetUnescapedNameSize` is added in this release, it is not backward-compatible,
i.e. programs compiled against 0.8.13, might _not_ work with older 0.8 libraries.

The function `keyUnescapedName` provides access to an unescaped name, i.e. one where `/` and `\\` are
literal symbols and do not have any special meaning. `NULL` characters are used as path separators.
This function makes it trivial and efficient to iterate over all path names, as already exploited
in all bindings:

- [jna (java)](https://git.libelektra.org/blob/master/src/bindings/jna/HelloElektra.java)
- [lua](https://git.libelektra.org/blob/master/src/bindings/swig/lua/tests/test_key.lua)
- python2
- [python3](https://git.libelektra.org/blob/master/src/bindings/swig/python/tests/test_key.py)

Other small changes/additions in bindings:

- fix key constructor, thanks to Manuel Mausz
- add copy and deepcopy in python (+examples,+test cases), thanks to Manuel Mausz
- dup() in python3 returned wrong type (SWIG wrapper), thanks to Toscano Pino for reporting, thanks to Manuel Mausz for fixing it

Doxygen 1.8.8 is preferred and the configfile was updated to this version.

The symbols of nickel (for the ni plugin) do not longer leak from the Elektra library.
As such, old versions of testmod_ni won't work with Elektra 0.8.13.
A version-script is now in use to only export following symbols:

- `kdb*`
- `key*`
- `ks*`
- `libelektra*` for module loading system
- `elektra*` for proposed and other functions (no ABI/API compatibility here!)

In this release, ENABLE_CXX11 was changed to `ON` by default.

Note that in the next release 0.8.14 there will be two changes:

- According to [issue #262](https://git.libelektra.org/issues/262), we plan to remove the option ENABLE_CXX11
  and require the compiler to be C++11 compatible.
  If you have any system you are not able to build Elektra with -DENABLE_CXX11=ON (which is
  the default for 0.8.13) please report that immediately.
- the python3 bindings will be renamed to python

By not having to care for pre-C++11 compilers, we hope to attract more developers.
The core part is still in C99 so that Elektra can be used on systems where libc++ is not available.
Many new plugins are still written in C99, also with the purpose of not depending on C++.

## Python Plugins

A technical preview of [python3](https://git.libelektra.org/blob/master/src/plugins/python)
and python2 plugins has been added.

With them its possible to write any plugin with python scripts.

Note, they are a technical preview. They might have severe bugs
and the API might change in the future.
Nevertheless, it is already possible to, e.g. develop storage plugins
with it.

They are not included in `ALL` plugins. To use it, you have to specify it:

```sh
-PLUGINS="ALL;python;python2"
```

Thanks to Manuel Mausz for to this work on the plugins and the patience in all
the last minute fixes!

## Qt-gui 0.0.8

The GUI was improved and the most annoying bugs are fixed:

- only reload and write config files if something has changed
- use merging in a way that only a conflict free merge will be written, thanks to Felix Berlakovich
- made sure keys can only be renamed if the new name/value/metadata is different from the existing ones
- fixed 1) and 2) of #233
- fixed #235
- fixed qml warning when deleting key
- fixed qml typerror when accepting an edit

A big thanks to Raffael Pancheri!

## KDB Tool

The commandline tool `kdb` also got some improvements.
Most noteworthy is that `kdb get -v` now gives a complete trace for
every key that was tried. This is very handy if you have a complex
specification with many fallback and override links.

It also shows default values and warnings in the case of context-oriented
features.

Furthermore:

- Add `-v` for setmeta
- Copy will warn when it won't overwrite another key (behavior did not change)
- improve help text, thanks to Ian Donnelly

## Documentation Initiative

As Michael Haberler from [machinekit](http://www.machinekit.io/) pointed out it was certainly not easy for someone
to get started with Elektra. With the documentation initiative we are going to change that.

- The discussion in [GitHub issues](https://git.libelektra.org/issues) should clarify many things
- We start writing man pages in ronn-format(7), thanks to Ian Donnelly for current work
- Kurt Micheli is woring on improved doxygen documentation + pdf generation
- Daniel Bugl already restructed the main page
- Daniel Bugl also improved formatting
- doc: use @retval more, thanks to Pino Toscano
- doxygen: fix template to use `@` and not `\\`.
- SVG logo is preferred, thanks to Daniel Bugl
- doc: use @retval more, thanks to Pino Toscano
- many typo fixes, thanks to Pino Toscano
- fix broken links, thanks to Manuel Mausz, Daniel Bugl and Michael Haberler

Any further help is very welcome! This call is especially addressed to beginners in Elektra because
they obviously know best which documentation is lacking and what they would need.

## Portability

`kdb-full` and `kdb-static` work fine now for Windows 64bit, thanks to Manuel Mausz.
The wresolver is now more relaxed with unset environment.

All issues for macOS were resolved. With the exception of elektrify-getenv
everything should work now, thanks to Mihael Pranjic:

- fix mktemp
- testscripts
- recursive mutex simplification
- clearenv ifdef

and thanks to Daniel Bugl:

- RPATH fixed, so that `kdb` works

furthermore:

- fix `__FUNCTION__` to `__func__` (C99), thanks to Pino Toscano
- avoid compilation error when JNI_VERSION_1_8 is missing
- fix (twice, because of an accidental revert) the TARGET_CMAKE_FOLDER, thanks to Pino Toscano

Thanks to Manuel Mausz for to testing and improving portability!

## Packaging and Build System

- [0.8.12 packaged+migrated to testing](https://packages.qa.debian.org/e/elektra/news/20150726T155000Z.html), thanks to Pino Toscano
- fix build with external gtest, thanks to Pino Toscano
- switch from FindElektra.cmake to ElektraConfig.cmake, thanks to Pino Toscano
- use `cmake_parse_arguments` instead of `parse_arguments`, thanks to Manuel Mausz

## Further Fixes

- Key::release() will also work when Key holds a null-pointer
- Key::getName() avoids std::string exception
- support for copy module was introduced, thanks to Manuel Mausz
- be more POSIX compatible in shell scripts (`type` to `command -v` and avoid `echo -e`) thanks to Pino Toscano
- fix vararg type for KEY_FLAGS, thanks to Pino Toscano
- fix crash of example, thanks to Pino Toscano
- add proper licence file for Modules (COPYING-CMAKE-SCRIPTS), thanks to Pino Toscano
- fix XDG resolver issue when no given path in XDG_CONFIG_DIRS is valid
- make dbus example work again
- fix compiler warnings for gcc and clang
- fix Valgrind suppressions
- Installation of GI binding is fixed, thanks to Dāvis
- make uninstall is fixed and documentation improved

## Notes

There are some misconceptions about Elektra and semi structured data (like XML, JSON).
Elektra is a key-value storage, that internally represents everything with key and values.
Even though, Elektra can use XML and JSON files elegantly, there are limitations what
XML and JSON can represent. XML, e.g., cannot have holes within its structure, while this
is obviously easily possible with key-value. And JSON, e.g., cannot have non-array entries
within an array. This is a more general issue of that configuration files in general
are constrained in what they are able to express. The solution to this problem is
validation, i.e. keys that does not fit in the underlying format are rejected.
Note there is no issue the other way round: special characteristics of configuration
files can always be captured in Elektra’s metadata.

## Get It!

You can download the release from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.13.tar.gz)
and now also [here on GitHub](https://github.com/ElektraInitiative/ftp/tree/master/releases/elektra-0.8.13.tar.gz)

- name: elektra-0.8.13.tar.gz
- size: 2141758
- md5sum: 6e7640338f440e67aba91bd64b64f613
- sha1: ca58524d78e5d39a540a4db83ad527354524db5e
- sha256: f5c672ef9f7826023a577ca8643d0dcf20c3ad85720f36e39f98fe61ffe74637

This release tarball now is also available
[signed by me using gpg](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.13.tar.gz.gpg)

already built API documentation can be found [here](https://doc.libelektra.org/api/0.8.13/html/)

## Stay tuned!

Subscribe to the
[RSS feed](https://doc.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
[Mailing List](https://lists.sourceforge.net/lists/listinfo/registry-list)
the issue tracker [on GitHub](https://git.libelektra.org/issues)
or by mail elektra@markus-raab.org.

[Permalink to this NEWS entry](https://doc.libelektra.org/news/3c00a5f1-c017-4555-92b5-a2cf6e0803e3.html)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
Markus





# 0.8.14 Release

- guid: 519cbfac-6db5-4594-8a38-dec4c84b134f
- author: Markus Raab
- pubDate: Thu, 19 Nov 2015 17:48:14 +0100
- shortDesc: adds massive documentation improvements & new or overhauled plugins

Again we managed to release with many new features and plugins (lua, enum,
list, crypto, csvstorage, conditionals, mathcheck, filecheck, logchange)
many fixes, and especially with a vastly improved polished documentation.

## Documentation Initiative

The Documentation Initiative is a huge success and now the documentation
of Elektra is in a state where someone (preferable a linux guru),
never heard of Elektra, still can use Elektra only by reading man pages.

There are now many ways to show a man page:

- [on GitHub](https://master.libelektra.org/doc/help/kdb.md)
- [in the API documentation](https://doc.libelektra.org/api/master/html/doc_help_kdb_md.html)
- by using `kdb --help` or `kdb help <command>`
- by using `man kdb`

### Help system

Ian Donnelly wrote man pages for all the tools delivered with Elektra.
Additionally, nearly all README.md are now also converted to man pages
and also to Doxygen.

### Doxygen Filter

Kurt Micheli did an amazing work with a new doxygen filter.
The filter allows all Elektra Markdown pages to be also included
in the doxygen documentation. Thus all technical concepts are now
explained in Markdown pages, this filter is essential.

But even more, the filter also includes all man pages written
for the tools, giving a nice html view for them. (In addition to
the Markdown rendering on GitHub).

Enjoy the [result](https://doc.libelektra.org/api/0.8.14/html/).

A big thanks to Kurt Micheli!

### Further Documentation fixes

- getenv debugging documentation was improved
- typo fix: Specify, thanks to Pino Toscano
- [Design decisions](https://master.libelektra.org/doc/decisions)
  Definition of Bool, capabilities and
  Publish Subscribe (thanks to Daniel Bugl)
- Improve iconv docu
- usage examples for many plugins
- improve README for line plugin (thanks to Ian Donnelly)
- add documentation about dependencies for some plugins (thanks to Ian Donnelly)
- create many new links within the documentation

## Simplicity

We shifted our [goals](https://git.libelektra.org/blob/master/doc/GOALS.md)
a bit: We want to prefer simplicity to flexibility. Not because we
do no like flexibility, but because we think we achieved enough of it.
Currently (and in future) you can use Elektra:

- obviously as primitive key-value storage
- with specifications and dozens of plugins driven by it
- with code generation
- ...

But we cut flexibility regarding:

- namespaces are only useful for configuration (not for arbitrary key-value)
- the semantics of [metadata](https://git.libelektra.org/blob/master/doc/METADATA.ini)
- mounting functionality
- error code meanings are fixed, if a resolver detects a conflict, our defined
  error must be used
- of course ABI, API

## Qt-gui 0.0.9

Raffael Pancheri again updated his qt-gui to version 0.0.9 (beta)
with important of fixes and improvements:

- Fixes for Qt 5.5
- Handling of merge-conflicts improved
- Avoid rewriting on merge-conflicts
- Allow QML to destroy C++ owned model
- Dialog at startup
- Reduce memory footprint
- add man page

A bit thanks to Raffael Pancheri!

## Compatibility

As always, the API and API is fully forward-compatible, i.e. programs
compiled against an older 0.8 versions of Elektra will continue to work.

The behavior of some plugins, however, changed:

- the INI plugin, the section handling was improved.
- in the NI plugin, the symbol Ni_GetVersion vanished
- in the resolver plugin files of other namespaces which are not
  mounted are not resolved anymore

### Build System

ENABLE_CXX11 does not exist anymore, it is always on.
We do not care about 199711L compilers anymore, which
makes development easier, without losing any actually
used platform.

Some programs that are only used in-source are not installed
anymore. (by Pino Toscano)

Python and Lua plugins are enabled now in `-DPLUGINS=ALL`.

Python3 plugin was renamed to python.

## Lua Plugin

Manuel Mausz add a lightweight alternative to the python plugin:
[the lua plugin](https://master.libelektra.org/src/plugins/lua/).
In a similar way, someone can write scripts, which are executed on every
access to the
[key database](https://master.libelektra.org/doc/help/elektra-glossary.md).

To mount a lua based filter, you can use:

```sh
kdb mount file.ini /lua ini lua script=/path/to/lua/lua_filter.lua
```

Even though it works well, it is classified as technical preview.

Thanks to Manuel Mausz for this plugin!

## Cryptography Plugin

In this technical preview, Peter Nirschl
[demonstrates how a plugin](https://master.libelektra.org/src/plugins/crypto/)
can encrypt Elektra’s values. In test cases it is already able to do so,
but for the end user an easy way for key derivation is missing.

A big thanks to Peter Nirschl!

## INI Plugin

The INI plugin got a near rewrite. Now it handles many situations better,
has many more options and features, including:

- preserving the order
- using keys as metadata
- many new test cases
- fix escaping

Thanks to Thomas Waser for this work!

## Mathcheck plugin

This plugin allows you to check and even calculate keys from
other keys using an polish prefix notation.
It supports the typical operations `+ - / *` and
`<, <=, ==, !=, =>, >, :=`. To mount, check and
calculate values, one would use:

```sh
kdb mount mathcheck.dump /example/mathcheck dump mathcheck
kdb setmeta user/example/mathcheck/k check/math "== + a b"
kdb setmeta user/example/mathcheck/k check/math ":= + a b"
```

For details [see the documentation](https://master.libelektra.org/src/plugins/mathcheck/).

Thanks to Thomas Waser for this important plugin!

## List Plugin

Currently, Elektra has some limitations on how many plugins can be
added to certain
[placement](https://master.libelektra.org/doc/dev/plugins-ordering.md).
Because of the rapidly growing number of plugins, some combinations
are not possible anymore.

This plugin tackles the issue, by delegating the work to an arbitrary
number of subplugins. As a bonus, it works lazily and thus might avoid
the loading of some plugins all together.

Thanks to Thomas Waser for this plugin!

## Conditionals

Brings `if` inside Elektra. It lets you check if some keys have
the values they should have.

```sh
kdb mount conditionals.dump /tmount/conditionals conditionals dump
kdb set user/tmount/conditionals/fkey 3.0
kdb set user/tmount/conditionals/hkey hello
kdb setmeta user/tmount/conditionals/key check/condition "(hkey == 'hello') ? (fkey == '3.0')" # success
kdb setmeta user/tmount/conditionals/key check/condition "(hkey == 'hello') ? (fkey == '5.0')" # fail
```

For details [see the documentation](https://master.libelektra.org/src/plugins/conditionals/).

Again, thanks to Thomas Waser for this plugin!

## Csvstorage Plugin

You can now mount csv-files. To mount `test.csv` simply use:

```sh
kdb mount test.csv /csv csvstorage
```

There are many options, e.g. changing the delimiter, use header
for the key names or predefine how the columns should be named.
For details [see the documentation](https://master.libelektra.org/src/plugins/csvstorage/).

Thanks to Thomas Waser!

## Filecheck plugin

This plugin lets you validate lineendings, encodings, null, bom and
unprintable characters.

The also new plugin lineendings is already superseded by the filecheck
plugin.

Thanks to Thomas Waser!

## Enum plugin

The Enum plugin checks string values of Keys by comparing it against a
list of valid values.

Thanks to Thomas Waser!

## Elektrify Machinekit.io

We are proud that [Machinekit](http://www.machinekit.io/) starts using
Elektra.

Alexander Rössler is digging into all details, and already enhanced
the DBUS Plugin for their needs. DBus now can emit a message for every
changed key.

A big thanks to Alexander Rössler!

## Bugfixes

- libgetenv did not reinitalized its mutexes on forks
- add needSync also in C++ binding
- handle removed current working directories (fallback to /)
- avoid segfault on missing version keys (when doing `kdb rm system/elektra/version`)
- fix glob plugin + kdb mount with
  [config/needs usage](https://master.libelektra.org/doc/help/elektra-contracts.md)
- fix different handling of strerror_r in macOS (thanks to Daniel Bugl)
- do not change the users parentKey in early-error scenarios
- do not try to interpret some binary keys as function keys

## Other Gems

- getenv example: do not link to elektra/elektratools,
  thanks to Pino Toscano
- fixes in other examples
- avoid useless UTF-8 chars and fix typos, thanks to Kurt Micheli
- fix kdb check return code (open fail)
- pdf now also allows UTF-8 characters if added to
  elektraSpecialCharacters.sty, thanks to Kurt Micheli
- libgetenv: lookup also used for layers
- handle wrong arguments of metals better, thanks to Ian Donnelly
- Improvement of error messages in the augeas plugin
- `kdb set` avoids fetching unnecessary namespaces
- verbose unmount
- logchange: small demonstration plugin to show how to log added,
  removed and changed keys
- setmeta will use spec as default
- libtools: avoid useless getName, add verbosity flag for findBackend
- Improve iconv error messages
- That mount needs permissions to /etc should now really be obvious
  with new error message
- many fixes in the template for new plugins

## Get It!

You can download the release from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.14.tar.gz)
and now also [here on GitHub](https://github.com/ElektraInitiative/ftp/tree/master/releases/elektra-0.8.14.tar.gz)

- name: elektra-0.8.14.tar.gz
- size: 2252008
- md5sum: a87cd3845e590bf413959dfd555e3704
- sha1: 2360603c347ae3f3a28e827eb9260ff0b9881e46
- sha256: af681a38c9c2921b8d249f98ab851c3d51371735471d8a1f833a224c4446fe2e

This release tarball now is also available
[signed by me using gpg](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.14.tar.gz.gpg)

already built API documentation can be found [here](https://doc.libelektra.org/api/0.8.14/html/)

## Stay tuned!

Subscribe to the
[RSS feed](https://doc.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
[Mailing List](https://lists.sourceforge.net/lists/listinfo/registry-list)
the issue tracker [on GitHub](https://git.libelektra.org/issues)
or by mail elektra@markus-raab.org.

[Permalink to this NEWS entry](https://doc.libelektra.org/news/519cbfac-6db5-4594-8a38-dec4c84b134f.html)

For more information, see [https://libelektra.org](https://libelektra.org)

Btw. the whole release happened with
[elektrify-getenv](https://master.libelektra.org/src/bindings/intercept/env/README.md)
enabled.

Best regards,
Markus





# 0.8.15 Release

- guid: 1ab4a560-c286-46d2-a058-1a8e7e208fe8
- author: Markus Raab
- pubDate: Tue, 16 Feb 2016 17:47:00 +0100
- shortDesc: adds improved mounting, split of library & configuration validation

In case you do not yet know about it, here is an abstract about Elektra:

Elektra serves as a universal and secure framework to access configuration
parameters in a global, hierarchical key database.
Elektra provides a mature, consistent and easily comprehensible API.
Its modularity effectively avoids code duplication across applications
and tools regarding configuration tasks. Elektra abstracts from
cross-platform-related issues and allows applications to be aware of other
applications' configurations, leveraging easy application integration.

See [https://libelektra.org](https://libelektra.org)

## Overview

This is one of the largest release up to now. It includes many
user-visible improvements. Some highlights:

- Mounting is vastly improved:
  think about Debian's "dpkg" to "apt"-like functionality
- In previous releases you could already specify the structure
  of the configuration. Now you can also automatically enforce
  this property.
- We split the shared library `libelektra` into smaller parts.
  Now users can link against the parts of the library they need.
- As always, the ABI and API is fully forward-compatible.
- The release contains improvements in the
  [bootstrapping process](https://github.com/ElektraInitiative/libelektra/blob/master/doc/decisions/bootstrap.md).
- We improved the `ini`, `rename` and `crypto` plugins.
- The tool `kdb` now supports bookmarks and profiles.
- The new tool `kdb editor` allows you to edit KDB configuration in
  your favorite text editor.
- We are glad of the new packages for Debian, Arch Linux and OpenWRT.

The same text as follows is also available
[here as html](https://doc.libelektra.org/news/1ab4a560-c286-46d2-a058-1a8e7e208fe8.html)
and
[here on GitHub](https://github.com/ElektraInitiative/libelektra/blob/master/doc/news/2016-02-16_0.8.15.md)

## Global Mount

Sometimes you simply want some functionality for the whole key database.
For example, you want to enable logging or notification of configuration
changes. In previous versions, you had to change every mountpoint
individually. Even more problematic, every mountpoint created its
individual logs and notifications, without any way for someone to know
if an application has issued its last log/notification.

These problems are now solved by global plugins. The same plugins are
reused for this purpose. Also the mounting works nearly in the same way,
you only have to omit the configuration file and the mountpoint:

```sh
kdb global-mount syslog journald dbus
```

Voilà, from now on every configuration change gets logged to syslog
and journald. Additionally, every application gets notified via dbus.

If you want it more verbose for debugging, you can easily do so by:

```sh
kdb global-mount logchange counter
```

Which gives you detailed information to standard output which keys
were changed/edited/deleted. Additionally, Elektra counts how often
the `counter` plugin is invoked.

The underlying work for the global plugins, i.e. hooks in the core
libraries and the `list` plugin that allows us to use many plugins
without bloating the core was done by Thomas Waser.

It was already possible in earlier versions of Elektra to specify the
configuration of your program. Until now, this specification could be
mainly used to to generate code as described
[here](https://master.libelektra.org/src/tools/pythongen).
This release adds two more interesting options:

1. the spec plugin, and
2. the spec mount.

## Spec Plugin

The most important global plugin that is now newly introduced with this
release (thanks to Thomas Waser) is the `spec` plugin. By default it
will be added for every global-mount. So for a new installation make
sure you executed at least once:

```sh
kdb global-mount
```

The spec plugin is a global plugin that copies metadata from the
`spec`-namespace to other namespaces. That means, it reads the
specification, and makes sure that the configuration conforms to it. The
actual validation is done by the many validation plugins already present.

Lets start by saying a key is a long and must have at least the
value 10:

```sh
kdb setmeta spec/example/longkey check/type long
```

Then we can create a key in a different namespace and see if the `spec`
plugin applies the metadata correctly:

```sh
kdb set /example/longkey 25
kdb lsmeta /example/longkey
```

Should now at least print `check/type`.
By itself, this is useful for documentation of keys.
For example, the application developer says:

```sh
kdb setmeta spec/example/longkey description "Do not change"
kdb setmeta spec/example/longkey example 30
```

The user can retrieve this documentation by:

```sh
kdb getmeta /example/longkey description
```

But we want `check/type` to be not only a documentation, but also
enforced.

## Spec Mount

Using `kdb setmeta` extensively and always looking out that all plugins
are mounted correctly is error-prone. So instead, one can directly mount
the plugins as specified. For the example above one simply needs:

```sh
kdb setmeta spec/example mountpoint example.ecf
kdb spec-mount /example
```

Now, when we try to modify `/example/longkey` it will be validated:

```sh
kdb set /example/longkey a
#> Error (#52) [...] long [not] matched [...] a
```

Based on the present metadata, the correct plugins (in this case `type`
because of the metadata `check/type`) will be loaded.

We can also create a whole specification file, first mount the
specification and then the mountpoint according the specification, e.g
when we have `battery.ini` in the folder `$(dirname $(kdb file spec))`
with following content:

```ini
[]
mountpoint = battery.ini
infos/plugins = ini

[level]
check/enum = 'critical', 'low', 'high', 'full'
```

Then we can use:

```sh
# mount the file itself:
kdb mount battery.ini spec/example/battery ni
# make sure all plugins are present (e.g. enum for check/enum):
kdb spec-mount /example/battery
```

Now lets verify if it worked:

```sh
kdb lsmeta /example/battery/level
# we see it has a check/enum
kdb getmeta /example/battery/level check/enum
# now we know allowed values
kdb set /example/battery/level low
# success, low is ok!
kdb set /example/battery/level wrong
# fails, not one of the allowed values!
```

The main idea of the spec-mount is: search a plugin for every
specification (metadata) found in the spec-namespace.

## General Mount Improvements

In earlier versions `kdb mount` failed when plugin dependencies were
not satisfied. Now dependencies will automatically be fulfilled, e.g.

```sh
kdb mount /etc/modules system/modules line
```

In earlier versions you would have got an error because of the missing
`null` plugin. Now it simply adds the needed plugins.

The plugins given in the command-line used to be real plugins. Now also
so-called providers are accepted.

To make providers useful we need to actually know which plugin is the
best candidate. To get the information we added a `infos/status` clause
in the contract. In this clause the plugin developer adds many details
how well the plugin is tested, reviewed, documented, maintained and so
on. Based on this information, the best suited plugin will be chosen.
For example, you now can use:

```sh
kdb mount /etc/security/limits.conf system/limits augeas \
	lens=Limits.lns logging
```

And the best suitable logger will automatically be chosen.

The configuration variable `/sw/kdb/current/plugins` now allows
us to pass plugin configuration with the same syntax as the plugin
specification passed on the commandline. A subtle difference is that
thus the shell-splitting of arguments is missing, it is not possible to
include whitespaces in the plugin configuration that way.

Now it is also possible to include the same plugin multiple times and
also give them individual names. This feature is essential for
script-based plugins, e.g. you now might add:

```sh
kdb mount file.x /example/mountpoint \
	lua#resolver script=resolver.lua \
	lua#storage script=storage.lua
```

Furthermore, `kdb mount` now supports recommendations, which can be
enabled with `--with-recommends`. E.g. supplied to the mount command
using augeas above, comments will automatically transformed to metadata
to avoid cluttering of the real configuration.

## Library Split

Up to now, Elektra consisted only of a single shared library,
`libelektra.so`. Not all symbols in it were relevant to end users, for
example, some were only needed by plugins. Others were only proposed and
not yet part of the stable API. And finally, other symbols were not needed
in some situations, e.g. the plugins do not need the `kdb` interface.

Thus, we split `libelektra.so`, so that only coherent parts are in the
same library:

- `libelektra-core.so` only contains the `KeySet` data structure and
  module loading. Every binary using Elektra should link against it.
- `libelektra-kdb.so` contains the missing `KDB` symbols. Together with
  the `core` they contain everything declared in `kdb.h`.
  Michael Zehender plans to have multiple variants of `libelektra-kdb.so`
  that use different kinds of concurrency.
  Headerfile: `<kdb.h>`
- `libelektra-ease.so` adds functionality missing in `core` to make the
  life for C programmers easier.
  New headerfile: `kdbease.h`
- `libelektra-proposal.so` adds functionality proposed for `core`. It
  directly uses internal structures of `core`, thus they always need to
  have exactly the same version.
  Headerfile: `kdbproposal.h`

The source code is now better organized by the introduction of a `libs`
folder. The explanation of every library can be found in
[/src/libs/](https://github.com/ElektraInitiative/libelektra/tree/master/src/libs).

The rationale of the library split is documented
[here](https://github.com/ElektraInitiative/libelektra/blob/0.8.15/doc/decisions/library_split.md).
Shortly put, it was needed for further evolution and allowing us to grow
and enhance without getting a fat core.

Thanks to Manuel Mausz for fixing many bugs related to the library split
and also adapting all the bindings for it.

### Benchmark

To show that the split does not make Elektra slower, Mihael Pranjić made
a small benchmark. The real time of
[benchmarks/large](https://github.com/ElektraInitiative/libelektra/blob/master/benchmarks/large.c)
and revision 634ad924109d3cf5d9f83c33aacfdd341b8de17a

1. kdb-static: Median :0.8800
2. kdb-full: Median :0.8700
3. kdb: Median :0.8700

So it seems that the split does not influence the time of running
elektrified processes.

_Times were measured with time(1) and the median is calculated for 21
runs of benchmarks/large. This was done using
[scripts/benchmark_libsplit.sh](https://github.com/ElektraInitiative/libelektra/blob/524397669f800cb76b742514fd3aaae7a58a07da/scripts/benchmark_libsplit.sh)_

## Compatibility

As always, the ABI and API is fully forward-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 every program without errors
(API).

We added `keyGetNamespace` which allows us to handle all namespaces
in a switch and to iterate all namespaces. This is essential, when
a new namespace is added, thus then the compiler can warn you about
every part where the new namespace is not yet considered. We currently
do not plan to add a new namespace, but better be safe than sorry.

The internal function `keyCompare` now also detects any metadata
change.

libtools was nearly rewritten. Even though it is mostly API compatible
(you should not use the low-level `Backend` anymore but instead use the
`BackendBuilder`), it is certainly not ABI compatible. If you have an
undefined symbol: `_ZN3kdb5tools7Backend9addPluginESsNS_6KeySetE` you need
to recompile your tool. Even the merging part has ABI incompatibility
(different size of `_ZTVN3kdb5tools7merging14NewKeyStrategyE`).
Unfortunately, we still cannot guarantee compatibility in `libtools`,
further changes are planned (e.g. implementing mounting of lazy plugins).

The python(2) and lua interfaces changed, an additional argument (the
plugin configuration) is passed to `open`.

The INI plugin was rewritten, so many options changed in incompatible ways.

The default format plugin (e.g. for import/export) is no longer hard coded
to be `dump`. Instead KDB_DEFAULT_STORAGE will be used.
To get KDB_DEFAULT_STORAGE you can use the constants plugin:

```sh
kdb mount-info
kdb get system/info/elektra/constants/cmake/KDB_DEFAULT_STORAGE
```

Thanks to Manuel Mausz plugins do no longer export any method other than
`elektraPluginSymbol`. It now will fail if you directly linked against
plugins and did not correctly use their public interface. Please
use the module loading and access functions via the contract.

The CMake and Pkgconfig Files now only link against `elektra-core` and
`elektra-kdb`. If you used some symbols not present in `kdb.h`, your
application might not work anymore.

`libelektra.so` is still present for compatibility reasons. It should
not be used for new applications. Some unimportant parts, however,
moved to the "sugar" libraries. E.g. the symbol `elektraKeyCutNamePart`
is no longer part of `libelektra.so`.

### Bootstrapping

When you use `kdbOpen` in Elektra as first step it reads mountpoint
configuration from `/elektra`. This step is the only hard coded one,
and all other places of the KDB's tree can be customized as desired
via mounting.

The bootstrapping now changed, so that `/elektra` is not part of the
default configuration `default.ecf` (or as configured with `KDB_DB_FILE`),
but instead we use `elektra.ecf` (or as configured with `KDB_DB_INIT`).
This behavior solves the problem that `default.ecf` was read twice
(and even differently, once for `/elektra` and once for `/`).

To be fully compatible with previous mountpoints, Elektra will still read
mountpoints from `default.ecf` as long as `elektra.ecf` is not present.

To migrate the mountpoints to the new method, simply use:

```sh
kdb upgrade-bootstrap
```

which basically exports `system/elektra/mountpoints`, then does `kdb rm -r system/elektra/mountpoints` so that `default.ecf` will be without an
mountpoint and thus the compatibility mode does not apply anymore. As
last step it will import again what it exported before.

[Details are here](https://github.com/ElektraInitiative/libelektra/blob/master/doc/decisions/bootstrap.md)

## Plugins

We already highlighted the new `spec` plugin, but also other plugins
were improved at many places. Small other changes are:

- Conditionals now also support `assign/condition` syntax,
  thanks to Thomas Waser
- Lua and Python are not tagged experimental anymore.
  They now correctly add their configuration to the open-call.
- The plugin `yajl` (the json parser and generator) now also accepts the
  type `string` and yields better warnings on wrong types.
- Improved error message in the `type` plugin.

Larger changes were done in the following plugins:

### INI

The INI plugin was rewritten and a huge effort was taken so that it
fully-round-trips and additionally preserves all comments and ordering.
Currently, it is brand new. It is planned that it will replace `dump`
in the future.

Currently is has some minor problems when used as KDB_DEFAULT_STORAGE.
You can avoid most problems by mounting a different file into root:

```sh
kdb mount root.ini /
```

Read [here about the details](https://github.com/ElektraInitiative/libelektra/tree/master/src/plugins/ini).

A huge thanks to Thomas Waser.

### Rename

Thanks to Thomas Waser `rename` is now fixed for cascading keys.
Additionally, it does not change the `sync` status of the keys so
that notification plugins work properly afterwards.

### Crypto

The crypto plugin is a facility for securing sensitive Keys by symmetric
encryption of the value. It acts as a filter plugin and it will only
operate on Keys, which have the metakey „crypto/encrypt“ set.

The key derivation is still work-in-progress, so the plugin does not
work with kdb yet. A planned method for key derivation is to utilize
the gpg-agent.

For now the plugin requires the following Keys within the plugin
configuration in order to work properly:

1. /crypto/key - the cryptographic key (binary 256 bit long)
2. /crypto/iv - the initialization vector (binary 128 bit long)

Please note that this method of key input is for testing purposes only
and should never be used in a productive environment!

Thanks to Peter Nirschl, especially the patience for also supporting
different platforms where dependencies need to be handled differently.

## KDB

A technical preview of a new tool was added: `kdb editor` allows you
to edit any part of Elektra’s configuration with any editor and any
syntax. It uses 3-way merging and other stable technology, but it
currently does not provides a way to abort editing. So you only should
use it with care.

The tool `kdb list` now searches in the rpath for libraries and thus
will also find plugins not present at compile-time (using `glob`).
Additionally, it sorts the plugins by `infos/status` score, which can
also be printed with `-v`. The last plugins printed are the ones ranked
highest.

When running as root, `kdb` will now use the `system` namespace when
writing configuration to cascading key names.

Long paths are cumbersome to enter in the CLI. Thus one can define
bookmarks now. Bookmarks are key names that start with `+`. They are
only recognized by the `kdb` tool or tools that explicitly have support
for it. Applications should not depend on the presence of a bookmark. For
example, if you set the bookmark kdb:

```sh
kdb set user/sw/elektra/kdb/#0/current/bookmarks
kdb set user/sw/elektra/kdb/#0/current/bookmarks/kdb user/sw/elektra/kdb/#0/current
```

You are able to use:

```sh
kdb ls +kdb/bookmarks
kdb set +kdb/format ini
```

The kdb tool got much more robust when the initial configuration is broken,
no man page viewer is present or Elektra was installed wrongly.

The `--help` usage is unified and improved.

The new key naming conventions are now used for
configuration of the `kdb`-tool itself: `/sw/elektra/kdb/#0/%/`
and `/sw/elektra/kdb/#0/current/` are additionally read. The option
`-p`/`--profile` is now supported for every command, it allows to fetch
configuration from `/sw/elektra/kdb/#0/<profile>/` instead of `current`.
KDB is more robust when it cannot fetch its own configuration due to
KDB errors.

## Coding Guidelines

Thanks to Kurt Micheli the code guidelines are
[now properly documented](https://github.com/ElektraInitiative/libelektra/blob/master/doc/CODING.md).
Thanks to René Schwaiger we also provide a style file for clang-format.

Furthermore we unified and fixed the source:

- only use @ for doxygen commands
- always use `elektra*` functions for allocation
- added a file header for every file

## C++11 migration

Since we now only use C++11, we applied `clang-modernize` which simplified
many loops and replaced many `0` to `nullptr`. Additionally, we added
`override` and `default` at many places.

We removed all places where we had `ifdefs` to use `auto_ptr` if no
modern smart pointer is available.

Because of these changes there is no easy way to compile Elektra without
C++11 support, except by avoiding the C++ parts all together.

The C++ `KeySet` now also supports a `get` to retrieve whole containers
at once. By specializing `KeySetTypeWrapper` you can support your own
containers. Currently only `map<string, T>` is supported (T is any type
supported by `Key::get`).

If you haven't removed it from your flags already, there is no use
anymore to set `ENABLE_CXX11`.

## Documentation

The documentation was improved vastly. Most thanks to Kurt Micheli who
did a lot of editing and fixed many places throughout the documentation
Also thanks to Michael Zehender who added two paragraphs in the main
README.md.

Key names of applications should be called `/sw/org/app/#0/current`,
where `current` is the default profile (non given). `org` and
`app` is supposed to not contain `/` and be completely lowercase.
Key names are documented [here](/doc/help/elektra-key-names.md).
[See also here](/doc/tutorials/application-integration.md). The main
reason for long paths is the provided flexibility in the future
(e.g. to use profiles and have a compatible path for new major versions
of configuration). By using bookmarks, users should not be confronted
by it too often.

- many man pages were improved
- many typos were fixed, thanks to Pino Toscano!
- Fix documentation for kdb list, thanks to Christian Berrer
- Compilation variants are explained better,
  thanks to Peter Nirschl for pointing out what was missing
- document ronn as dependency, thanks to Michael Zehender
- fix broken links, thanks to Daniel Bugl

Thanks to Kurt Micheli, developers are now warned during compilation on
broken links in Markdown. The output format is the same as for gcc.
Additionally, the Markdown documentation of plugins now get a proper
title in the pdf and html output of doxygen.

## Qt-Gui 0.0.10

Raffael Pancheri again updated qt-gui with many nice improvements:

- update existing nodes in case the config was changed outside the gui
- safely update tree
- add update signal to metadata
- fix crash when closing the GUI
- move Actions in separate file to make main.qml less clustered
- plugins do not output messages at startup
- `BackendBuilder` is now used, which automatically takes cares of the correct ordering of plugins
- Qt 5.4 compatibility is still ensured
- C++11 is now used in Qt-Gui, too

## Packaging and Build System

Elektra 0.8.14 now in Debian with qt-gui, man pages,
thanks to Pino Toscano
[read more here](https://packages.qa.debian.org/e/elektra/news/20151215T000031Z.html)

Thanks to Gustavo Alvarez for updating and splitting the packages on
Arch Linux!

Thanks to [Harald Geyer](http://friends.ccbib.org/harald/supporting/),
Elektra is now packaged for OpenWRT. We fixed a number of
cross-compilation issues and now officially support building against musl
libc, with one minor limitation: RPATH works differently on musl so you
need to install all plugins directly in /usr/lib/ or set LD_LIBRARY_PATH.
Report any bugs in
[Harald's OpenWRT packaging issue tracker](https://github.com/haraldg/packages).

- export errors/symbols are now called `elektra-export-symbols` and
  `elektra-export-symbols` and can be installed using `INSTALL_BUILD_TOOLS`
  (by default off). This is needed for cross-compilation.
  Thanks to Harald Geyer for reporting.
- some header files are renamed because they endlessly included themselves
  if the header files were found in wrong order.
  Thanks to Harald Geyer for reporting.
- fixed compilation when built on more than 20 cores with >= -j15,
  thanks to Gustavo Alvarez for reporting and Manuel Mausz for analyzing
- lua 5.1 now works too (except for iterators),
  thanks to Harald Geyer for reporting.
  thanks to Manuel Mausz for adding a new FindLua.cmake
- pdf builds do not fail due to half written files,
  reported by René Schwaiger and fixed by Kurt Micheli

Read about [other packages here](https://github.com/ElektraInitiative/libelektra#packages).

## Fixes and Improvements

- 3 way merge now properly deals with binary data,
  thanks to Felix Berlakovich
- getenv: fix wrapping on powerpc, thanks to Pino Toscano
- markdownlinkconverter: fix char/int mismatch, thanks to Pino Toscano
- wresolver: use KDB_MAX_PATH_LENGTH instead of PATH_MAX,
  thanks to Pino Toscano
- Cleaning up #ifdefs that break statements, thanks to Romero Malaquias
- Daniel Bugl tested the INI plugin
- cmake list_filter was broken because of different behavior in
  cmake_parse_arguments, thanks to Christian Berrer for reporting
- g++5.3 is now supported
- gtest does not link against pthread if not needed
- test cases that are built with BUILD_SHARED also successfully work
- kdb list works when libs are in same path as plugins,
  thanks to Harald Geyer for reporting
- fix macOS issues,
  thanks to Peter Nirschl, René Schwaiger and Mihael Pranjic
- fix resolver-baseflag documentation, thanks to Harald Geyer for reporting
- do not create wrong directories called `(` and `)` in source,
  thanks to René Schwaiger
- fix CMake for systems where iconv is not part of libc,
  thanks to Michael Zehender and Peter Kümmel (for FindIconv.cmake)
- fix segfault in libgetenv if root keys are present
- lua: fix Key:tostring(), thanks to Manuel Mausz
- add list of [supported bindings](https://github.com/ElektraInitiative/libelektra/tree/master/src/bindings),
  thanks to Manuel Mausz

## Get It!

You can download the release from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.15.tar.gz)
and now also [here on GitHub](https://github.com/ElektraInitiative/ftp/tree/master/releases/elektra-0.8.15.tar.gz)

- name: elektra-0.8.15.tar.gz
- size: 2338297
- md5sum: 33ec1e5982fb7fbd8893bf7b579b80f0
- sha1: 6b1fdd5aa5aaad6ba377b4bb5ef437e0c85319ff
- sha256: 6a406986cecb8d4a44485ced118ee803bc039b0824b72298e123b4dd47eb0b22
- sha512: 86a408dd546b33e3b437f92f415de7aee6a235189f9eab0762b3f44ab4c453ee369a53de10a9f5b0df1b446460b12c57c6b8b77c282648ec2a49f2328d9af13d

This release tarball now is also available
[signed by me using gpg](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.15.tar.gz.gpg)

already built API documentation can be found [here](https://doc.libelektra.org/api/0.8.15/html/)

## Stay tuned!

Subscribe to the
[RSS feed](https://doc.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
[Mailing List](https://lists.sourceforge.net/lists/listinfo/registry-list)
the issue tracker [on GitHub](https://git.libelektra.org/issues)
or by mail elektra@markus-raab.org.

[Permalink to this NEWS entry](https://doc.libelektra.org/news/1ab4a560-c286-46d2-a058-1a8e7e208fe8.html)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
Markus





# 0.8.16 Release

- guid: 9c9247ee-ee9c-4f4a-a68e-76959def9b82
- author: Markus Raab
- pubDate: Fri, 29 Apr 2016 12:45:39 +0200
- shortDesc: adds stability improvements, configuration profiles & new plugins

In case you do not yet know about it, here is an abstract about Elektra:

Elektra serves as a universal and secure framework to access configuration
parameters in a global, hierarchical key database.
Elektra provides a mature, consistent and easily comprehensible API.
Its modularity effectively avoids code duplication across applications
and tools regarding configuration tasks. Elektra abstracts from
cross-platform-related issues and allows applications to be aware of other
applications' configurations, leveraging easy application integration.

Elektra consists of three parts:

1. _LibElektra_ is a modular configuration access toolkit to
   construct and integrate applications into a global,
   hierarchical key database. The building blocks are:
   - language bindings (inclusive high-level interfaces)
   - GenElektra, the code generator for type-safe bindings
   - plugins for configuration access behavior and validation
2. _SpecElektra_ is a configuration specification language
   that is easy to use and self-contained in the same key database (i.e.
   written in any of the configuration file formats Elektra supports).
3. Tools on top of LibElektra for administrators, such as CLI tools and GUIs.

See [https://libelektra.org](https://libelektra.org)

The same text as follows is also available
[here as html](https://doc.libelektra.org/news/9c9247ee-ee9c-4f4a-a68e-76959def9b82.html)
and
[here on GitHub](https://github.com/ElektraInitiative/libelektra/blob/master/doc/news/2016-04-29_0.8.16.md)

## Highlights

- Elektra now allows applications to support multiple
  profiles with a plugin, thus _without code modifications_ in
  Elektra applications.
  That means a user can select multiple configuration files to use,
  even if the application has no explicit support for it.
  It completes the cascading feature (level `$HOME` before /etc), to allows
  us also to select different configuration for the same level.
- Resolver can now better handle conflicts that happen
  when files are removed and others that happen
  within a single time tick (resolution of your clock)
  and also better handles NFS and older file systems
- Default storage and resolver can be changed by symlink.
  So no need to recompile Elektra to change the default storage
  from INI to dump.
  INI now works quite reliable as default plugin and already
  used by default by its author Thomas Waser.

## Other important features

- shell plugin allows you to execute shell commands on every KDB access
  and curlget plugin allows you to download configuration files
  from a URL during KDB access.
- Improvements in sync/merge of qt-gui with important fix
  (Usage of 0.8.15 qt-gui is discouraged)
- Add plugin for dpkg database (read-only)
- Assignment for conditionals using `assign/condition`.
- Support for multiple and nested statements
- Support for `condition/validsuffix` which allows you to suffix
  numbers with signs such as `%` or `$`.
  It does not check if the suffixes are identical.
- kdb mount now uses topological sorting to always
  find a dependency solution if there is one,
  many effort was put in that ordering is as requested, thanks to
  Thomas Waser for the topological sorting implementation
- Frontend generated by GenElektra now also can reload its
  values with taking the correct context into account.
- Source is now automatically formatted and formatting is checked on build server
- More flexible CMake syntax for PLUGINS

## Plugins

Many new or vastly improved plugins are waiting to be explored.

### curlget

The plugin curlget fetches a configuration file from a remote host before
the configuration is being accessed:

```sh
kdb mount -R noresolver /tmp/curltest.ini system/curltest ini curlget url="https://raw.githubusercontent.com/ElektraInitiative/libelektra/master/src/plugins/ini/ini/plainini"
kdb ls system/curltest  # every get access will redownload the file
```

Thanks to Thomas Waser!

### INI

The INI plugin is still under heavy development and
was again nearly rewritten:

- fixed key is below hacks
- fixed ordering
- custom delimiter
- use meta array for comments
- rewritten ordering
- best effort order
- fixed array support

Thanks to Thomas Waser!

### shell

This plugin allows you to executes shell commandos after kdbGet, kdbSet and kdbError (failing kdbSet):

```sh
kdb mount /tmp/test.ini system/shelltest ini array= shell 'execute/set=echo set >> /tmp/log,execute/get=echo get >> /tmp/log'
kdb set system/shelltest
cat /tmp/log
```

Thanks to Thomas Waser!

### validation

The validation plugin is not new, but got many new features.
It allows you to match values by a regex and set your own
error messages in case a validation did not match.

Up to now, the regex was given as is to regcomp, which means
that if the regex is contained _anywhere_ in the value, the
value is accepted.

Often this is not what we want, thus Thomas Waser added special
support for icase, word and line validation.
Additionally, flags allow you now to ignore the case or invert
the match. This can be changed for every individual value
or for the whole mountpoint.

Additionally, `kdb vset` validation was updated to use the new
metadata and correctly match against the whole value.

Thanks to Thomas Waser!

### hosts

Only minor improvements were necessary for the host plugin but
it is quite matured already. The contract was changed so that
ipv6 addresses for ipv4 addresses will be rejected:

```sh
# kdb mount --with-recommends /etc/hosts system/hosts hosts
# kdb set system/hosts/ipv4/localhost ::1
The command set failed...
Reason: localhost value: ::1 message: Address family not supported
# kdb set system/hosts/ipv6/localhost ::1
```

You can also comfortably and safely edit the hosts file
with: `kdb editor system/hosts hosts`, then you have the
functionality `visudo` for the hosts file.

### rename

Again not a new plugin, but the plugin was greatly improved
and many test cases were added.

Now you can set upper/lowercase individually for both sides:

1. What applications see.
2. What the configuration file contains.

For example, if you always want the keys in the configuration file upper case,
but for your application lower case you would use:

```sh
kdb mount caseconversion.ini /rename ini rename get/case=tolower,set/case=toupper
kdb set user/rename/section/key valu
cat ~/.config/caseconversion.ini
#> [SECTION]
#> KEY = value
```

Thanks to Thomas Waser!

### Resolver

Resolving by ~ as home directory now also for system and spec namespaces,
thanks to Thomas Waser.

Files keep their previous owner, useful when root edits configuration
files of others, thanks to Thomas Waser.

The resolver has many improvements to better detect conflicts.

The lock is now extended longer after the commit and already requested
in the temporary file.

The warnings were improved when `getcwd` fails.

Resolver now can correctly handle conflicts with empty files. It can also
better cope with frequent commits of the same binary. Elektra already
reached some limits filesystems have.

## Bindings

### Java

Marvin Mall improved the Java binding, fixed the appending
of keysets, added lots of documentation, and many unit tests.

### C++

Some kind of misusage of vaargs is now detected at compile-time instead
of crashing at runtime.

### Generated C++

Value now supports convenience activations.
Values can be used to activate context, no more layers are needed.
Topological sorting makes sure that values are activated in the
correct order, loops are not allowed anymore.

The `bool operator<` is now correctly inline (allows to use it in more than
one translation unit)

## Documentation

René Schwaiger<sanssecours> reworked most of the documentation and
fixed countless spelling mistakes and other problems.

- Peter Nirschl updated the status of the crypto-plugin
  and fixed a typo
- Daniel Bugl wrote a cascading tutorial
- Daniel Bugl fixed all broken links
- René Schwaiger also drew a new logo with SVG.
  It is already used on GitHub as avatar for the organization.
- make all é use the same code point 233.

## Testing

- Tests work if the build path contains spaces
- Tests: Fix problems locating memory checker
- remove obsolete TestScript.cmake

Thanks to René Schwaiger

## Maintainer

By default now ALL plugins except EXPERIMENTAL are included.
Plugins will be automatically excluded if dependencies are missing.

The PLUGINS syntax was vastly improved. Now many categories can be
intermixed freely and also categories can be used for exclusion.

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:

```sh
-DPLUGINS="NODEP;STORAGE;-yajl;MAINTAINED;-EXPERIMENTAL"
```

Details see [/doc/COMPILE.md](https://github.com/ElektraInitiative/libelektra/tree/master/doc/COMPILE.md).

### Renamed files:

/usr/include/elektra/merging/kdbmerge.hpp ->
/usr/include/elektra/merging/mergingkdb.hpp

/etc/profile.d/kdb -> /etc/profile.d/kdb.sh

(So that it works on arch linux, thanks to Gabriel Rauter)

### removed files:

- /usr/lib/elektra/libelektra-crypto.so

was only necessary because of limitations of the build system and is
now removed. It never had actual functionality, but was only a stub
without a crypto provider selected.

### new files:

- `/usr/include/kdbease.h`
- `/usr/lib/elektra4/libelektra-curlget.so*`
- `/usr/lib/elektra4/libelektra-dpkg.so*`
- `/usr/lib/elektra4/libelektra-profile.so*`
- `/usr/lib/elektra4/libelektra-resolver_fm_hpu_b.so`
- `/usr/lib/elektra4/libelektra-shell.so*`

more new files with ALL or EXPERIMENTAL:

- /usr/lib/elektra/libelektra-semlock.so

new tests all in folder /usr/lib/elektra/tool_exec:
testcpp_contextual_update testkdb_conflict test_keyname testmod_curlget
testmod_dpkg testmod_jni testmod_profile testmod_semlock testmod_shell
testtool_mergingkdb

Following Plugins are excluded on specific platforms:

- mathcheck on Intel compiler (reason: failing test cases)
- simpleini on non-glibc systems (reason: not portable printf extension)

### new symlinks:

- /usr/lib/elektra4/libelektra-storage.so
- /usr/lib/elektra4/libelektra-resolver.so

### new releases

The first release of the libraries libelektratools-full, libelektratools
and libelektragetenv. They now have SOVERSION 0.

## Development

You do not need to format the source manually anymore.
Make sure that you run scripts/reformat-source before
creating a PR.

`clang-tidy` helps you to add blocks to have better
maintainable code.

Felix Berlakovich improved the performance of the augeas plugin and
also contributed a script to benchmark different host plugin.
His thesis can be downloaded from [here](https://www.libelektra.org/ftp/elektra/publications/berlakovich2016universal.pdf).
It contains benchmarks and discussions about augeas.

The CMake function `add_plugin` was completely rewritten.
Now you do not have to register your plugin at multiple points
but instead information of README.md is parsed to correctly
register the plugin to categories as stated by `infos/status`
and `infos/provides`.

The code generator for errors also yields macros. This
avoids usage of the IDs, which can be problematic if
multiple pullrequests are prepared at once.

## Compatibility

This might be the last release supporting wheezy, because
it gets more and more time-intensive to find workarounds
for the old compiler. The C++11 regex do not work at all.

### Binary Compatibility Test

When you execute the test cases of 0.8.15 against Elektra 0.8.16
following test cases fail. None of them effect the API.

- test_splitget test_splitset .. Internal restructuring
- testmod_crypto .. not included by default now
- testmod_ini .. section handling changed, line 178:
  `nosectionkey contained no comment`
- testmod_rename .. internal API elektraKeyCreateNewName changed
- testmod_resolver .. internal data structure now contains more
  members to remember uid and gid
- testmod_template .. not present by default
- testtool_backend testtool_backendbuilder testtool_backendparser
- testtool_specreader .. changes in KDB tool before release
- check_kdb_internal_check .. experimental plugins are now excluded

### Added API

in libease René Schwaiger added:

```c
extern char const * elektraKeyGetRelativeName(Key const * cur, Key const * parentKey);
```

in libmeta Thomas Waser added (partly based on ideas/code from Felix Berlakovich):

```c
extern void elektraMetaArrayAdd(Key *, char const *, char const *);
extern KeySet * elektraMetaArrayToKS(Key *, char const *);
extern char * elektraMetaArrayToString(Key *, char const *, char const *);
extern int elektraSortTopology(KeySet *, Key * *);
```

## Tools

### Qt-gui

Raffael Pancheri fixed an important issue which broke the synchronization
because an key related to Elektra’s internal version information was missing.

Felix Berlakovich updated the qt-gui so that it uses a newly written sync-method
added in libtools.

Gabriel Rauter added a desktop file that uses the new svg logo from
René Schwaiger.

## Portability

- Peter Nirschl fixed code in the resolver that uses EBADMSG which was not
  available in BSD.
- Peter Nirschl improved detection of librt
- Felix Berlakovich fixed searching of FindSystemd
- MinGW64 resolver now handles conflicts correctly and does not ignore them
  anymore and now also is able to create empty files (but still not directories)

### macOS

A lot of effort was invested to all test cases also run on macOS:

- .template syntax
- linking errors
- fix regex in conditionals plugins

Thanks to René Schwaiger

## Bugs

- print null-environment correctly with `kdb getenv`
- keyIs(Direct)Below didn't work with cascading keys
- fix elektraKeyGetRelativeName (needed by ni) for cascading
  keys and move it to libease, thanks to René Schwaiger
- make nickel tests show correct test name, thanks to René Schwaiger
- glib: replace cursor_t with gssize so that GElektra-4.0.gir
  builds with gobject-introspection later than 1.47, thanks to Manuel Mausz
- fixed out-of-bounds bug in timeofday plugin
- elektraMetaArrayToKS correctly adds parent key, thanks to Thomas Waser
- kdb-shell: Do not abort ksOutput on binary data.
- some rework for global hooks, still not stable

## Get It!

You can download the release from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.16.tar.gz)
and now also [here on GitHub](https://github.com/ElektraInitiative/ftp/tree/master/releases/elektra-0.8.16.tar.gz)

- name: elektra-0.8.16.tar.gz
- size: 2405443
- md5sum: ef0c138b4a4fda017aa8bb6f812671ce
- sha1: c6a6f9c26addd5fcc274cea635de02ef680cfb1a
- sha256: 3cf0624eb027e533192ca9d612618df3d38ec3674c9cd20474f04ff269fad77e
- sha512: b225e61379907365a423ea75ec7138e5257bb78c526bb05a1ec21f66a52eb4bad9e6f1eb23209d700670b21b86166497b47c3bc46bc9d45f6d366cd544afc326

This release tarball now is also available
[signed by me using gpg](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.16.tar.gz.gpg)

already built API documentation can be found [here](https://doc.libelektra.org/api/0.8.16/html/)

## Stay tuned!

Subscribe to the
[RSS feed](https://doc.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
[Mailing List](https://lists.sourceforge.net/lists/listinfo/registry-list)
the issue tracker [on GitHub](https://git.libelektra.org/issues)
or by mail elektra@markus-raab.org.

[Permalink to this NEWS entry](https://doc.libelektra.org/news/9c9247ee-ee9c-4f4a-a68e-76959def9b82.html)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
Markus





# 0.8.17 Release

- guid: e6153a39-c4bd-41c3-bc86-785d451eb6c5
- author: Markus Raab
- pubDate: Tue, 14 Jun 2016 08:32:44 +0200
- shortDesc: adds several improvements & survey about configuration

## Survey

First off: We created a survey questionnaire to gather more knowledge
about the relevance of configuration systems. If you are involved in
the development of free and open source software (FLOSS) you are the
person we are looking for.

It would be a great help if you take this survey. It will be available till 18.07.2016 (anywhere on earth).

For every thoroughly and not anonymously finished survey € 40 cent
will be donated to one of the following organizations of your choice:

- LimeSurvey (LimeService, kindly hosts this survey)
- SPI (General Donation: 0 A.D., LibreOffice, Debian, ArchLinux, …)
- FSFE
- GNOME
- KDE
- Mozilla (Firefox)
- Wikimedia Foundation (Wikipedia)

## Why should I use Elektra?

The three main points relevant for most people are:

1. Even though Elektra provides a global keydatabase
   configuration files stay human read- and writable
   which allows us to integrate unmodified software.
2. Flexible adoption on how the configuration is accessed
   via plugins: you can run arbitrary code, e.g. do a
   `git commit` or log/notify when configuration files
   are changed.
3. Elektra allows you to specify configuration values:
   - use the value of other configuration values (symbolic links)
   - calculate the values based on other configuration values
   - validation configuration files
   - [generate code based on it](https://master.libelektra.org/src/tools/pythongen)
   - [and much more](https://github.com/elektrainitiative/libelektra/tree/master/src/plugins/README.md)

Read more about [Why using Elektra](https://github.com/elektrainitiative/libelektra/tree/master/doc/WHY.md),
which also contains since this release unique features,
further reasons and limitations.

For a small demo see here

[![asciicast](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r.png)](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r)

## Highlights

- Qt-Gui reworked mounting and native icons
- Full macOS Support, Build Server improvements
  and new beginner friendly tasks
- allows us to mount csv, json and xml (and other common provider names)
  without needing to know plugin names
- colored output for kdb tools
- Experimental GSettings support

## Beginner friendly tasks

In this release starting developing Elektra gets easier:

- `ELEKTRA_DEBUG` adds run-time checks and makes stack traces
  as if Elektra would not use plugins
- `CMakeLists.txt` for plugins got simplified, in most cases it
  should be not more than calling a single function,
  even if unit tests and test data are present
- We prepared [beginner friendly tasks](https://github.com/ElektraInitiative/libelektra/issues?q=is%3Aissue+is%3Aopen+label%3A%22beginner+friendly%22)
  for you.

For details about `ELEKTRA_DEBUG` and CMake, see individual points below.

## Find-Tools

There is now a fine collection of external scripts which can
executed by `kdb + <script>`. The new script `kdb find-tools`
provides full text search over the metadata as provided by
the scripts.

- `kdb find-tools -b BRIEF` to search for a short text.
- `kdb find-tools -a AUTHOR` to search for an author.
- `kdb find-tools -d DATE` to search for a creation date.
- `kdb find-tools -e EXECUTE` to search for a type.

Developers should now [add MetaData for their scripts.](https://github.com/elektrainitiative/libelektra/tree/master/scripts/README.md).

Thanks to Kurt Micheli!

## macOS Support

Because of its POSIX support one might think it would be trivial to
support macOS. Unfortunately there were many small issues, especially
in the regular expression handling and the filesystem.

Nevertheless we finally fully support macOS and the newly added
travis build server makes sure it will stay this way.

A huge thanks to Manuel Mausz and Mihael Pranjić for fixing the
issues and setting up travis:

- jni plugin now can load Elektra (avoids using `.so`)
  thanks to Mihael Pranjić
- initial creation of travis.yml
  thanks to Manuel Mausz
- Add all 3 different Xcode setups and some macOS fixes
  thanks to Mihael Pranjić

## jenkins

Now (nearly) every build job can be triggered from Pull Requests.
For example:

- jenkins build [libelektra](https://build.libelektra.org/job/libelektra/) please

For a full list see [here](https://github.com/elektrainitiative/libelektra/tree/master/doc/Git.md).

Thanks to Mihael Pranjić for the setup!

## Fixes

- fix inconsistency with one excluded compilation variant,
  thanks to Harald Geyer for reporting #698
- fix dynamic searching of installed plugins,
  needed so that kdb list-tools works correctly
  thanks to Harald Geyer for reporting
- kdbtimer, `include <vector>` as needed by some compilers,
  a big thanks to Andreas Bombe for the non-maintainer
  upload in Debian to fix it for upcoming Debian release
- also find yajl header files if installed in non-standard
  include directories,
  thanks to Mihael Pranjić
- glib: make sure we use all definitions returned by pkg-config #719,
  fixes build on FreeBSD
  now glib bindings need CMake 2.8.12
  thanks to Mihael Pranjić for reporting/testing
  and Manuel Mausz for fixing
- fix INI for macOS (did require some non-portable sorting
  properties of `qsort`.)
- INI makes INI-specific metadata private by prefixing `ini`.
- `kdb export` also works under MinGW,
  thanks to Gabriel Rauter

## Rework Add Plugin

- prefer to link shared
- add plugin tests when using link shared
- make ADD_TEST simpler (without calling add_plugintest)
- make installation of test data simpler + honor INSTALL_TESTING option
- fix installation of test_data (do not install whole dir)
- introduce cache so that it is enough to pass parameters
  to `add_plugin*` once
- avoid PLUGIN_DIRECTORY_NAME and change CMAKE_CURRENT_SOURCE_DIR
  and CMAKE_CURRENT_BINARY_DIR instead
- add_plugin: remove unused option SHARED_SOURCES
- implement a 3rd phase to add test cases:
  correctly handles dependencies of test cases to bindings
- fix testmod_jni

## CMake

for maintainers:

- The CMake variables KDB_DB_SYSTEM and KDB_DB_HOME are now STRING and not PATH.
- BUILD_FULL and BUILD_STATIC are now OFF by default
- building with BUILD_SHARED is now preferred (for all examples, test cases,...)
- ELEKTRA_DEBUG_BUILD and ELEKTRA_VERBOSE_BUILD is not used anymore.
- ENABLE_DEBUG was added: it does not add debug symbols but run-time assertions.
- More CMake variables are marked as advanced.

for developers:

- BUILD_STATIC and BUILD_FULL is now OFF by default
  (nearly) all unit tests now also work with BUILD_SHARED
- to support shared unit tests, a third phase was added when
  adding plugins
  inconsistent adding (across phases) of plugins and unit tests is reported
- in `add_plugin` remove SHARED_SOURCES, and add `ADD_TEST` and `INSTALL_TEST_DATA`.

and fixes:

- adding plugin tests is now much simpler, simply use `ADD_TEST`
  in `add_plugin`.
- KDB_DB_SYSTEM and KDB_DB_HOME are now STRING and not PATH because
  of incorrect resolving of `~`.
- lua bindings tests: make sure lua executable matches with the lua libraries version
  thanks to Mihael Pranjić
- lua bindings: do not use hard coded `lua` executable.
- Fix CMake configure when BUILD_DOCUMENTATION is set to OFF
  thanks to Kurt Micheli

See more about changes to plugin adding in CMake in the
[plugin decision](https://github.com/elektrainitiative/libelektra/tree/master/doc/decisions/cmake_plugins.md).

## Experimental GSettings support

As part of the ongoing work of the bachelor thesis
`Integration of Elektra into the GNOME desktop environment`
we now have experimental support for Elektra as a GSettings backend on Linux
(We will look into getting macOS support on a later date).
When installed, applications using GSettings default backend will write to Elektra
below the `/sw` key. The GSettings bindings are intended as a preview version so
please do not use them in a production system.

To build the GSettings backend you have to explicitly add the binding even if `ALL` is given.
e.g. `-DBINDINGS=gsettings` `-DBINDINGS="ALL;gsettings"`

All needed core functionality of a GSettings backend is already implemented.
This includes notification support if you have your `/sw` mounted with the dbus plugin.

Please report any bugs you encounter.

For further information regarding the status of the implementations
please refer to the corresponding [README](https://github.com/elektrainitiative/libelektra/tree/master/src/bindings/gsettings)
and [ticket](https://github.com/ElektraInitiative/libelektra/issues/775).

## Common Provider Names

Mounting now supports to mount commonly known names even if the name is not a plugin.
If more than one plugin is available automatically the best one is selected.
The selection process works by annotating different qualities of the plugins,
see `infos/status` in the README.md of individual plugins.

E.g. to mount a file using a json plugin (called yajl because of the library's name
it build upon)

```sh
kdb mount file.json json
```

## New Cachefilter Plugin

stores filtered keys internally so that they
do not get accidentally lost and can be written to the storage again without
the user having to remember including them in the writeout

The longer term goal is to add such global plugins per default, so that
the usage of the API is easier.

For now you can simply add it using:

```sh
kdb global-mount cachefilter
```

Thanks to Marvin Mall.

## Qt GUI 0.0.12

The Qt GUI receives new features and a better gnome integration.
Its version number was updated to 0.0.12 (beta).
Major features:

- use native icons (Qt GUI xdg icon theme support rework)
  thanks to Gabriel Rauter
- update desktop entry org.libelektra.elektra-qt-editor.desktop
  with new symbolic icon of Elektra’s logo
  so that qt-gui can nicely started from within Gnome
  thanks to Gabriel Rauter
- Add new layout elements to backend wizard
  and integrate new BackendBuilder functionality (See Common Provider Names) to qt-gui
  thanks to Raffael Pancheri

Bug fixes:

- Reset to defaults now reverts back to built-in defaults.
- Make clicks on search icon focus on search textfield.
- save settings when settings dialog is closed.
- fix crash of qt-gui when crypto plugin was enabled
  (and added /shutdown option to enable previous behavior)
  thanks to Peter Nirschl
- fix qt-gui fails to synchronize because of readonly plugins
  thanks to Raffael Pancheri
- Rename desktop file: correct reverse url from org.elektra to org.libelektra.
- Rename elektra-qt to elektra-qt-editor.
- Rename ChooseColorWindow: The ChooseColorWindows will be replaced by a
  AppearanceSettingsWindow, all references to ChooseColor, choose color have been
  replaced by AppearanceSettings or choose appearance.

Other improvements:

- Install `elektra-qt-editor` binary so both the desktop files TryExec works
  and people not starting the gui trough `kdb qt-gui` have a speaking name
  in their process list.
- Replace occurrences of `Elektra Editor` with `Elektra Qt Editor` so that
  we use the same name in all places apart from the tools binary.
- Introduce Appearance Settings Window: Appearance Settings Window
  contains both color settings as well as a switch to disable or enable
  the system icon theme. For this to work we had to introduce the setting
  in `guisettings`. We also added a private function in `guisettings` to
  get and set settings with a boolean value.
- Tree reload on Settings close: We now synch and refresh the tree view on
  closing of the settings window if any settings have been changed, so
  changes can be seen imediatly in the tree.
- Add qt5 svg module as dependency: the qt5 svg module is needed so we can
  display icon themes that provide svg as icon format.
- Add and install symbolic icon with the installation of the Elektra
  Qt Editor.

Thanks to Gabriel Rauter and Raffael Pancheri for the engagement in
improving qt-gui.

## Colored kdb tool

A big thanks to Gabriel Rauter for improving the user experience with the kdb tool.
On errors and in `kdb info` it was often quite hard to find the relevant text.

Now important parts are highlighted by bold or colorful text.
This helps to spot the important information immediately without sacrificing
information that would be important for a detailed analysis.

Every tool now has the option `--color` and `-C` which is set to `auto` per default.
By writing to:

```sh
kdb set user/sw/elektra/kdb/#0/color off
```

one can go back to previous behavior.

## Documentation

- improve documentation about how to pop a key
- document how to avoid running test cases as root in
  [TESTING.md](https://github.com/elektrainitiative/libelektra/tree/master/doc/TESTING.md).
- document guarantees of `elektraPluginGetData`,
  thanks to Marvin Mall
- doc mentions that -1 should be returned
  _always_ when an error is set
- many more spelling mistakes were fixed and useless whitespace was removed,
  thanks to René Schwaiger
- describe preferences when plugins are included/excluded
- improvements in `ksCopy`, `ksPop`, `kdbGet` and `kdbSet`
  [API description](https://doc.libelektra.org/api/0.8.17/html/)
- added [WHY document](https://github.com/elektrainitiative/libelektra/tree/master/doc/WHY.md)
- updated [plugin decision](https://github.com/elektrainitiative/libelektra/tree/master/doc/decisions/cmake_plugins.md) to include 3rd phase

## ELEKTRA_DEBUG build

ENABLE_DEBUG now enables a debug build for Elektra.
It has nothing to do with debug symbols, but:

- it enables assertions
- it enables [undefinied behavior sanitizer](http://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html)
  for clang
- plugins will not be closed so that stack traces are more useful
  (using `RTLD_NODELETE`)

`ENABLE_DEBUG` is recommended for every developer, even if you are not
modifying Elektra itself. The assertions will give you hints on API misusage.

For example, `keyNew` was known to be error-prone. `ENABLE_DEBUG` now will report
wrong parameters by an assertion.

The old options `ELEKTRA_DEBUG` and `ELEKTRA_VERBOSE` are not available anymore.

Thanks to:

- Thomas Waser for pointing to `RTLD_NODELETE`
- Gabriel Rauter for fixing qt-gui with `-DENABLE_DEBUG=ON`

The constants plugin was updated to provide `cmake/ENABLE_LOGGER` `cmake/ENABLE_DEBUG`
and will no longer provide `cmake/ELEKTRA_DEBUG_BUILD` `cmake/ELEKTRA_VERBOSE_BUILD`

## Other

- Gabriel Rauter is now listed in
  [AUTHORS.md](https://github.com/elektrainitiative/libelektra/tree/master/doc/AUTHORS.md)
- constants plugin: configure_file now uses current binary directory, not cluttering
  the main build directory.
- fix ssize_t for VS2015,
  thanks to Gabriel Rauter
- gtest: fix linking when using arch systemd-nspawn,
  thanks to Marvin Mall
- `LD_LIBRARY_PATH` is added to lua and python bindings needed for macOS,
  thanks to Mihael Pranjić
- Fix external unit test for Ubuntu 15.04 by putting files before
  the flags,
  thanks to Marvin Mall
- symbols in `Ni_` namespace are now in `elektraNi_`
- add more ipv4 and ipv6 test cases for IP adress validation
  checker
- crypto-plugin avoid usage of hard coded error numbers,
  thanks to Peter Nirschl
- do not use number for resolver position
- to fix a compiler warning in macOS, we made the printf
  format specifier of time_t more portable,
  thanks to René Schwaiger
- many preparations for global plugins and mmap
- in the constants plugin `cmake/BUILTIN_PLUGIN_FOLDER`, `BUILTIN_DATA_FOLDER`
  and `BUILTIN_EXEC_FOLDER` were added.
- doxygen is only run once during build,
  thanks to René Schwaiger
- add script configure-home to build Elektra
  that it will resolve all pathes to home-directories
- add script metaini-to-c that converts METADATA.ini
  to C code, thanks to Thomas Waser
- add note that default values must be present for
  code generation, thanks to Martin Schleiss
- avoid `seq` as it is not available in some `*BSD`,
  thanks to Mihael Pranjić
- make jni testmod check consistent to others

## Compatibility

As always, the ABI and API is fully forward- and backward-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 every program without errors
(API). This time you can even compile programs against 0.8.17 and run with 0.8.16.

For the qt-gui the svg module is added as dependency.

New and missing files in the installation:

- `elektra-qt-editor` is installed in the path (needed for TryExec in Desktop file)
- `libelektrasettings.so` will be installed if `gsettings` binding is enabled
- `libelektra-cachefilter.so` is the new cachefilter plugin
- `tool_exec/testmod_cachefilter` is its unit test
- `tool_exec/find-tools` is a new python script to find other tools
- `appdata/org.libelektra.elektra-qt-editor.appdata.xml`
- `icons/hicolor/scalable/apps/elektra-symbolic.svg`
- `share/man/man1/kdb-find-tools.1`

Renamed files:

- `applications/org.elektra.elektra-qt.desktop` got renamed to
  `applications/org.libelektra.elektra-qt-editor.desktop`.

Removed files:

- Some of the installed "test data" actually was source code from
  Elektra. Test data from the following plugins is affected:
  `hosts`, `ini`, `lineendings`,

Temporarily removed files:

- `testmod_lua`, `testmod_python` and `testmod_python2` do not work in a shared build
  and are temporarily disabled if `BUILD_SHARED` is enabled.
  Also their test data is affected.

## Get It!

You can download the release from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.17.tar.gz)
and also [here on GitHub](https://github.com/ElektraInitiative/ftp/tree/master/releases/elektra-0.8.17.tar.gz)

- name: elektra-0.8.17.tar.gz
- size: 2459542
- md5sum: e53efdb9a5e0852c58b21280b1e6c07d
- sha1: a1abcd4ac5aabfc60c34da98a02c4636e4634b5c
- sha256: a6a41afb0160feef84f7d1e0d199da26022ff8cb52ed455a0d306b589838d8f5

This release tarball now is also available
[signed by me using gpg](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.17.tar.gz.gpg)

already built API documentation can be found [here](https://doc.libelektra.org/api/0.8.17/html/)

## Stay tuned!

Subscribe to the
[RSS feed](https://doc.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
[Mailing List](https://lists.sourceforge.net/lists/listinfo/registry-list)
the issue tracker [on GitHub](https://git.libelektra.org/issues)
or by email elektra@markus-raab.org.

[Permalink to this NEWS entry](https://doc.libelektra.org/news/e6153a39-c4bd-41c3-bc86-785d451eb6c5.html)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
Markus





# 0.8.18 Release

- guid: 190576e0-9fef-486e-b8da-c4e75be08329
- author: Markus Raab
- pubDate: Fri, 16 Sep 2016 23:31:27 +0200
- shortDesc: adds intercept open, crypto plugins & improved git-resolver

## What is Elektra?

Elektra serves as a universal and secure framework to access configuration
parameters in a global, hierarchical key database.
For a small demo see here:

[![asciicast](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r.png)](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r)

## Highlights

- Intercept open syscalls which allows Elektra to dynamically
  generate config files from Elektra’s database
- Experimental version of cryptographic plugins
- A new zsh completion file (next to the bash completion file)
- Gitresolver allows to directly read and write config files
  from Git instead of files present in the file system.
- Survey completed successfully (and debts paid), we are now
  preparing raw data.

### Crypto Plugin

Gpg is now used to decrypt a master password, which is used
by the individual crypto backends. So all necessary parts
for encryption of decryption of individual keys is present.

Furthermore, a new [botan](https://botan.randombit.net) backend
was implemented.

[See here](https://master.libelektra.org/src/plugins/crypto)

Thanks to Peter Nirschl.

### Open Interception

When Elektra directly modifies config files which are on the disc,
and applications read the config files without Elektra, Elektra has
no control over the access, e.g. we cannot dynamically calculate
values. To avoid this, we wrote a library that
intercepts the `open`-call.

Together with the `mozprefs` plugin, we got control over the configuration
of Firefox and can dynamically change config values with all possibilities
Elektra provides.

For easy setup, we implemented the script `configure-firefox`.

[See here](https://master.libelektra.org/src/bindings/intercept)

Thanks to Thomas Waser.

### Resolver

Resolvers in Elektra are the code that are responsible to determine where
content should be read from and stored to. They are independent of the
actual configuration file syntax.

The [gitresolver](https://master.libelektra.org/src/plugins/gitresolver)
allows you to get/store config data in git.

The [blockresolver](https://master.libelektra.org/src/plugins/blockresolver)
allows Elektra to take control of parts of the configuration
file. This is useful for config files such as vim or zsh, which contain
program code. The plugin allows you to split config files with special markers
into parts containing code and others controlled by Elektra.

### zsh completion

Added zsh completion file, and a script (`kdb install-sh-completion`)
that installs bash+zsh completion when the default installation places
do not work (e.g. for macOS).

Thanks to Sebastian Bachmann.

## Documentation

- fix `kdb-import` man page, thanks to Kurt Micheli
- mark `keyIsSystem`/`keyIsUser` as internal
- fix doxygen reference to example
- better document that `global-mount` or `gmount` will overwrite
  previously mounted global plugins
- fix spelling mistake, thanks to René Schwaiger
- Wrote tutorial how to use Elektra-python bindings,
  thanks to Ulrike Schäfer

## Quality

- shell recorder test cases now run during `make test`, thanks to Kurt
  Micheli and René Schwaiger (Warning: might remove present keys
  when it conflicts with their mountpoints)
- find-tools now is pep and pyflakes happy, thanks to Kurt Micheli
- fix bashism, thanks to Thomas Waser and Kurt Micheli
- better error message for conditionals plugin, thanks to Thomas Waser
- better error message for augeas plugin, thanks to Felix Berlakovich
- Many compilation warnings fixed, thanks to Gabriel Rauter, Thomas Waser
- GSettings: fix double free, thanks to Gabriel Rauter
- Fix external links and implement an external link checker,
  thanks to Kurt Micheli
- Fix openwrt/musl warnings with wrong printf format, thanks to
  Thomas Waser
- Fix NODEP metadata, allows you to build all plugins that do not
  have dependencies.

## 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).

### Libtools

Libtools got a new major version (SOVERSION 0 -> 1):

- backend/plugin configs are now validated by plugins (needed
  by gpg plugin, which checks if wrong key IDs are supplied during mount)
- resolveRecommends was never implemented and was now removed

### Plugins

The plugins conditionals and mathcheck are incompatible in some cases
because of changes in syntax.

### Proposal

New API: `keyRel2` which differs from `keyRel` by allowing you to
specify which relation should be checked.

## Development

- GitHub descriptions+workflow (displayed by github when creating
  PRs and issues)
- new trigger phases for GitHub, see
  [doc/Git](https://master.libelektra.org/doc/Git.md)
  thanks to Mihael Pranjić
- valgrind suppressions are great again, thanks to Peter Nirschl
- Plugins get a new namespace `internal` which can be used for metadata
  that is not relevant for other plugins.
- kdberrors.h is only generated once, which allows us to use other build
  systems, thanks to René Schwaiger
- `INCLUDE_SYSTEM_DIRECTORIES` in add_plugin allows you to add an include
  path where warnings are suppressed (useful for boost).
- `infos/provides` now allows multiple entries

## Packaging

- Plugin-provider `CRYPTO` can be used to enable/disable all crypto
  plugin variants (not enabled by default because its experimental).
- Config option `ENABLE_OPTIMIZATIONS`, enable by default: trade more
  memory for speed (can be turned off on embedded systems)
- `INSTALL_SYSTEM_FILES` is now off by default on macOS.
- bash-completion is installed to where pkg-config tells us,
  thanks to Gabriel Rauter
  (fallback is now `/usr/share/bash-completion/completions/kdb`)
  was `/etc/bash_completion.d/kdb` (removed)
- zsh is now installed to `/usr/share/zsh/vendor-completions/_kdb`
  (except for Darwin, where `/usr/local/share/zsh/site-functions` is used)
- removed `/etc/profile.d/kdb.sh`: the script `elektraenv.sh` was
  removed (and is no longer installed), superseded by `elektrify-getenv`
- added scripts install-sh-completion configure-firefox elektrify-open
- added plugins libelektra-blockresolver.so libelektra-boolean.so
  libelektra-crypto_botan.so libelektra-crypto_openssl.so
  libelektra-desktop.so libelektra-mozprefs.so libelektra-passwd.so
- added tests testmod_blockresolver testmod_boolean
  testmod_crypto_botan testmod_crypto
  gcrypt testmod_crypto_openssl testmod_mozprefs testmod_passwd
  test_opmphm_vheap test_opmphm_vstack
- added test data blockresolver mozprefs passwd

## Other

- Conditionals and mathcheck plugins got support to specify relative
  keys, thanks to Thomas Waser
- `kdb` command-list: commands are written in bold
- GSettings backend can be build standalone, thanks to Gabriel Rauter
- first data structures for order preserving minimal perfect hash map,
  thanks to Kurt Micheli
- added a new passwd plugin, thanks to Thomas Waser
- boolean
  plugin to normalize boolean values, thanks to Thomas Waser
- [desktop](https://master.libelektra.org/src/plugins/desktop)
  plugin to detect which desktop currently is running (supports kde,
  gnome, tde, unity or any other XDG conformant desktop)
- `doc/paper` contains some info for [joss](https://github.com/openjournals/joss)

## Get It!

You can download the release from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.18.tar.gz)
and also [here on GitHub](https://github.com/ElektraInitiative/ftp/tree/master/releases/elektra-0.8.18.tar.gz)

- name: elektra-0.8.18.tar.gz
- size: 2582183
- md5sum: 62fe0fbf9ee57ffaa58a982f602f596a
- sha1: 743484e16b102a00cd58956a49f0c558939d56a8
- sha256: 9ee65895ba5cba6736c13c264637664c1410b25f4aaaeac8f1f83712ff93d53b

This release tarball now is also available
[signed by me using gpg](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.18.tar.gz.gpg)

already built API documentation can be found [here](https://doc.libelektra.org/api/0.8.18/html/)

## Stay tuned!

Subscribe to the
[RSS feed](https://doc.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
[Mailing List](https://lists.sourceforge.net/lists/listinfo/registry-list)
the issue tracker [on GitHub](https://git.libelektra.org/issues)
or by email elektra@markus-raab.org.

[Permalink to this NEWS entry](https://doc.libelektra.org/news/190576e0-9fef-486e-b8da-c4e75be08329.html)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
Markus





# 0.8.19 Release

- guid: 8e05231a-4f3d-488b-8dc2-5f0d5c474c39
- author: Markus Raab
- pubDate: Tue, 22 Nov 2016 22:04:59 +0100
- shortDesc: adds more tutorials, ruby bindings & cleanup of core

## What is Elektra?

Elektra solves a non-trivial issue: how to abstract configuration
in a way that software can be integrated and reconfiguration can
be automated. Elektra solves this problem in a holistic way.
Read [why Elektra](https://master.libelektra.org/doc/WHY.md)
for an explanation of why such a solution is necessary. It can be seen as a
[virtual file system](https://master.libelektra.org/doc/BIGPICTURE.md)
for configuration files.

## Highlights

- more tutorials and getting started guides
- new Ruby bindings
- cleanup of core (only 124K for main library on Debian/amd64)

### More Tutorials

Elektra already has an open and welcoming environment, with many
interesting discussions. It is our interest that we keep it
that way. To make this a bit more formal we added a [code of
conduct](https://master.libelektra.org/CODE_OF_CONDUCT.md).

But without good introductions, it is easy to get lost in such
a large initiative like Elektra. Thus we focused on writing
great tutorials for this release!

- We wrote an [overview readme](https://master.libelektra.org/doc/tutorials/README.md)
- We wrote new tutorials about [mounting](https://master.libelektra.org/doc/tutorials/mount.md)
  and [validation](https://master.libelektra.org/doc/tutorials/validation.md)
  (thanks to Christoph Weber)
- We wrote a readme to shell recorder transpiler
  which allows us to execute tutorials and verify that the examples in
  them work. (thanks to Thomas Waser)
- [Lua](https://master.libelektra.org/src/plugins/lua) and
  [Python](https://master.libelektra.org/src/plugins/python)
  plugins got tutorials and better explanations!
  (Thanks to Marvin Mall)
- The [doxygen](https://doc.libelektra.org/api/0.8.19/html/) documentation now also
  uses links to directories, thanks to Kurt Micheli!

Thanks to Armin Wurzinger for pointing to areas of improvement.
A big thanks to Marvin Mall, Kurt Micheli, Christoph Weber and Thomas Waser!

If you like the tutorials, we would love to read from you.
Please feel free to [start a discussion or ask a
question](https://git.libelektra.org/issues/new).
We also added a
[FAQ](https://master.libelektra.org/doc/help/elektra-faq.md)
and updated
[CONTRIBUTING](https://master.libelektra.org/.github/CONTRIBUTING.md)

### Ruby Bindings

We now provide Ruby bindings for Elektra. The bindings are based on the
C++ bindings and are generated by SWIG. A strong focus was put on a good
integration with standard Ruby features and conventions, such as naming
conventions, predicates, key and metadata iteration...

A [short introduction](https://master.libelektra.org/src/bindings/swig/ruby/README.md)
shows some basic usage scenarios. More detailed examples can be found in the
[examples directory](https://master.libelektra.org/src/bindings/swig/ruby/examples).

A big thanks to Bernhard Denner!

### Cleanup of Core

Following methods were hidden (`static`) or removed:

- `mount*` methods
- `trie*` methods
- `backend*`
- `split*`
- `keyGetParentNameSize`
- `keyGetParentName`

These are dozens of methods and it was required to adapt
the unit tests to work with the hidden methods.

A big thanks to Kurt Micheli!

## Usability

- Improved many error messages
  - spelling
  - be more friendly to the user
  - capitalization
  - mention `sudo !!`
- `kdb set`: do not print what was not done
- `kdb editor` handles non-modified files (will not do anything)
- Be more chatty about what `kdb` does, can be disabled with `-q` or
  `/sw/elektra/kdb/#0/current/quiet`.
- Furthermore, `-v` now tells even more details (e.g. `kdb-import` outputs
  the key about to import)

## Plugins

### New

- [c plugin](https://master.libelektra.org/src/plugins/c) generates C code that represents
  configuration. This is useful for unit tests or if you need to have hard coded
  fallback configuration in your C application.
- [base64 plugin](https://master.libelektra.org/src/plugins/base64) allows you to encode
  binary data. This is especially handy in combination with the
  [crypto plugin](https://master.libelektra.org/src/plugins/crypto)
  to avoid problems with non-printable characters in configuration files.
  (Thanks to Peter Nirschl)
- [fcrypt plugin](https://master.libelektra.org/src/plugins/fcrypt) allows you to
  fully encrypt configuration files. They are only decrypted when applications
  access them. (Thanks to Peter Nirschl)
- required plugin rejects
  every key that is not required by an application.
- simple spec lang allows you
  to define metadata for enum
  and required in a more compact way.

### Major Enhancements

- [simpleini](https://master.libelektra.org/src/plugins/simpleini) got a configurable
  format in which it will read and write configuration files. For example, one
  can use `format=% -> %` to have `key -> value`.
- enum got support for multi-enums,
  i.e., multiple separated values within one value. The error reporting was improved,
  too. (Thanks to Thomas Waser)
- [glob](https://master.libelektra.org/src/plugins/glob) accepts a list of named flags
  instead of an integer value and aborts matching after first hit.
  (Thanks to Felix Berlakovich)
- [hosts](https://master.libelektra.org/src/plugins/hosts) now only accepts `ipv4` and
  `ipv6` keys.
  (Thanks to Felix Berlakovich)

## Development

In the perpetual effort to improve software quality, we made several improvements:
(This information is mainly intended for Elektra’s developers.)

- A new logger encourages developers to write more comments (`ELEKTRA_LOG`)
- `ELEKTRA_ASSERT` prints better messages on failure and does not need `&&` trick.
- get rid of previous `VERBOSE` macro at many places.
- Many assertions were added in the low-level helpers (memory management)
- Using the assertions we fixed some undefined behavior.
  (Thanks to Thomas Waser)
- added new `configure-debian-debug` and `configure-debian-log` helper scripts
- The build server now checks if builds with active logger and debugging
  work correctly.
- Improved Coding Style in crypto_botan (thanks to Peter Nirschl)
- add `external-links.txt` to `outputs`
  (The file is generated in the build directory and contains
  all external-links. To validate them, use `./scripts/link-checker`)
  (Thanks to Kurt Micheli)
- `markdownlinkconverter` handles directories correctly (using `stat`).
  (Thanks to Kurt Micheli)
- Fixed compiler warning caused by libxml2 (different behavior since 2.9.4),
  thanks to René Schwaiger
- added often used links in [main README](https://master.libelektra.org/README.md)
- Improve documentation about failing test cases and what to do about it.
- added [decisions](https://master.libelektra.org/doc/decisions/) about `plugin_variants`
  and `array`.
  (Thanks to Marvin Mall)
- Rename to metadata, metakey, mountpoint
  (Thanks to Peter Nirschl)
- std::ios_base::showbase can be used to output metadata when streaming keys (C++)
- New `infos/status`: `readonly`, `writeonly`, `limited`
  (Thanks to Marvin Mall)
- The tool `update-infos-status` orders `infos/status` and allows devs to easily add/rem
  entries. (Thanks to Kurt Micheli)
- Automatic setting of `infos/status`: `nodoc`, `nodep`, `unittest`, `memleak`, `configurable`
  (Thanks to Kurt Micheli)
- Improve `create_lib_symlink`, add `PLUGIN` argument
  and make it useful also for other library symlinks.
- New Markdown style applied to most Markdown files.
  (Thanks to Marvin Mall)
- Tracer is now disabled, even for `ENABLE_DEBUG`.
  (Thanks to Marvin Mall)
- Updated [SECURITY document](https://master.libelektra.org/doc/SECURITY.md)
- Macro naming convention `ELEKTRA_`, added `kdbmacros.h`
- `ENABLE_DEBUG` also works with `clang` and `ENABLE_ASAN` now allows devs
  to additionally enable sanitizers.
  Thanks to Gabriel Rauter.

## 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).

It is now possible to enquiry which plugins provide a specific format.
This needed changes in libtools, which got a new major revision.
Changes in the plugin's contract are fully compatible:
You can now use `storage/ini` instead of `storage ini` in `infos/provides`
which gives you the information that `ini` is a storage format (and not
anything else the plugin might provide). For compatibility reasons,
the build system still adds `storage ini` even if only `storage/ini`
is specified.

That means that `kdb mount file.json /examples/json json` still will find
`json` plugins even if they are not called `json` but
[yajl](https://master.libelektra.org/src/plugins/yajl).

Another breaking change in `libtools` is that `appendNamespace` was renamed
to `prependNamespace`.

Error messages changed a bit, so if you tried to parse them, make sure
to make the `e` of error case-insensitive (`[eE]`).

In the C++ binding, `rewindMeta` is now `const` and some methods
to check if a key is in a namespace were added.

The intercept libraries were moved to a [common
folder](https://master.libelektra.org/src/bindings/intercept).
They can now be included or excluded like other `BINDINGS`.
For consistency reasons the libraries were also renamed
(`libelektraintercept-fs.so` and `libelektraintercept-env.so.0`),
but symlinks allow you to link against their old names
(`lib/libelektraintercept.so` and `lib/libelektragetenv.so.0`).

## Package Maintainers

This information is intended for package maintainers.

- GI Bindings were removed from `BINDINGS=ALL`.
  It is recommended to use `SWIG` bindings instead, which
  will be added with `ALL`.
- Intercept libraries are part of `BINDINGS`.
  They will be added on glibc systems where `BINDINGS=ALL` is used.
- Documentation in textfiles is now installed,
  `TARGET_DOCUMENTATION_TEXT_FOLDER` was added for that purpose.
  The files are:
  - `BIGPICTURE.md`, `GOALS.md`, `LICENSE.md`, `METADATA.ini`, `SECURITY.md`, `AUTHORS`, `CONTRACT.ini`, `NEWS.md`, and `WHY.md`

Other new files are:

- Plugins: `libelektra-base64.so`, `libelektra-c.so`, `libelektra-fcrypt.so`
  `libelektra-required.so`, `libelektra-simplespeclang.so`
  (only in `EXPERIMENTAL`, not added by default, but with `ALL`)
- `site_ruby/_kdb.so` (ruby binding, only in `ALL`)
- `testcpp_keyio`, `testkdb_error`, `testmod_base64`,
  `testmod_fcrypt` (test binaries in `TARGET_TOOL_EXEC_FOLDER`)

Changed files are:

- `libelektraintercept-env.so` (renamed from `libelektragetenv.so.`, but still available as symlink)
- `libelektraintercept-fs.so` (renamed from `libelektraintercept.so`, but still available as symlink)
- version upgrade: `libelektratools.so.2`

## Portability

Elektra should work on every system that has CMake and a C/C++ compiler.

For this release we increased portability to better work with macOS,
CentOS 7, and OpenSuse 42.

- macOS:
  - Travis build server now also build qt-gui
  - Support for xcode8 added (xcode6 still supported)
- fix lua != 5.2 issues (wrong output), update docu
- remove hard dependency to `pkg-config`
- remove hard dependency to version 3 of `cmake`
  (most parts still work with version 2)
- make search for swig 2 visible
- fix plugin names and mounting on OpenSuse 42.1

A big thanks to Kai-Uwe Behrmann, Mihael Pranjić and
Sebastian Bachmann.

## Fixed Issues

- simpleini: use correct error number when open file fails
- yajl: improve error message on non-utf8 text.
  (Thanks to Christoph Weber)
- drop multiple `/` from `~` paths
  (Thanks to Thomas Waser)
- fix failing test cases with `ENABLE_DEBUG` #988
  (Thanks to Thomas Waser)
- csvstorage: files in source are rewritten #987
  (Thanks to Thomas Waser)
- fix RTLD_NODELETE for OpenBSD
  (Thanks to Thomas Waser)
- better handle adding/deleting of read-only (info) plugins.
- fix behavior of multiple plugins setting errors (first error wins,
  later errors are transformed to warnings)
  (Thanks to Thomas Waser)
- fix resolver logic for missing files
- regex string in conditionals
  (Thanks to Thomas Waser)
- use `KDB` environment variable in shell tests and fix counting of tests
  for `kdb run_all`.
- output to `stderr` for `elektrify-*` scripts
- make [desktop plugin](https://master.libelektra.org/src/plugins/desktop)
  mountable
- avoid CMake warnings in `make uninstall` (avoid `@`)
- fix quoting in ini plugin
  (Thanks to Thomas Waser)
- fix plugin names and mounting with plugin pre/postfixes
  (Thanks to Kai-Uwe Behrmann)
- mount-openicc: rename to openicc.json
  (Thanks to Kai-Uwe Behrmann)

## Get It!

You can download the release from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.19.tar.gz)
and also [here on GitHub](https://github.com/ElektraInitiative/ftp/tree/master/releases/elektra-0.8.19.tar.gz)

- name: elektra-0.8.19.tar.gz
- size: 2681639
- md5sum: 6669e765c834e259fb7570f126b85d7e
- sha1: 82cefe4cea58d6e6b0a99ddbda24d1b57e98d93a
- sha256: cc14f09539aa95623e884f28e8be7bd67c37550d25e08288108a54fd294fd2a8

This release tarball now is also available
[signed by me using gpg](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.19.tar.gz.gpg)

already built API documentation can be found [here](https://doc.libelektra.org/api/0.8.19/html/)

## Stay tuned!

Subscribe to the
[RSS feed](https://doc.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
[Mailing List](https://lists.sourceforge.net/lists/listinfo/registry-list)
the issue tracker [on GitHub](https://git.libelektra.org/issues)
or by email elektra@markus-raab.org.

[Permalink to this NEWS entry](https://doc.libelektra.org/news/8e05231a-4f3d-488b-8dc2-5f0d5c474c39.html)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
Markus





# Website Release

- guid: 102b84a3-c41e-485c-8fe2-f12a24b3fbfd
- author: Marvin Mall
- pubDate: Thu, 22 Dec 2016 17:46:19 +0100
- shortDesc: introduces new Elektra website with snippet sharing

## Highlight

1. Release of new Elektra website with an integrated service for
   sharing of configuration snippets.
2. The website also supports conversion between different
   configuration formats.
3. Website structures documentation and news sections in a new way.

## Introduction

With Elektra developing into a more and more reliable as well as
popular system to manage system configurations, the demand for a
better public appearance increases as well. For this reason, we
are happy to be able to announce the release of our new
[website](https://www.libelektra.org)!

The new website does not only give us a chance to better present
ourselves to the open world, it also enables us to structure our
project documentation better. We hope that this will make it easier
for our users to get started with Elektra and all of its awesome
features!

Besides the documentation, the website does also include a database
that can be used to share, search, download and convert configuration
snippets in various formats. We hope that this tool helps developers
and administrators, but also anyone else to simplify their
configuration processes when they have to look for a specific
configuration snippet. Btw. with snippet we mean that you can
also share parts of configuration files that you find particular
useful!

But sharing of snippets does not only help other users, it can help
yourself as well because you can search for them easier. You also
have access to the snippets in various formats at any time, allowing
you to use them across multiple system by mounting them with the
[curlget](https://master.libelektra.org/src/plugins/curlget) resolver!

## The Website

The website was written by Marvin Mall in the course of his
[bachelor thesis](https://www.libelektra.org/ftp/elektra/publications/mall2016rest.pdf)
as part of the frontend he developed for his snippet sharing service.
His main goals were to create a proper appearance for Elektra, but
also to create a platform that promotes his service. We think that
this worked out quite well by connecting the website with the service
the way it was done.

### Documentation

An important aspect of the new website was to make existing documentation
more transparent and structured. A lot of documentation files have been
changed to achieve this goal and an equal amount of effort was put into
writing a system that decouples the documentation structure on the
website from the structure used within the Elektra repository.

The tutorials section was partially reworked to make the first steps
together with Elektra easier for our users. Clearly the effort put into
the tutorials is worth it. Thanks to Erik Schnetter for the valuable
feedback where improvements are needed and Christoph Weber for (re)writing
the tutorials!

We should note -- as always in software -- that the structure on the website
is not final yet and will definitely develop over time, especially the
bindings and libraries sections will get some more attention.

If you are interested in the techniques we use to structure our files,
you can have a look at the
[website readme](/src/tools/website/README.md).
The website is already the fourth view of our Markdown pages!
The others are man pages, doxygen, and github.

### Homepage & News

Besides the documentation we also wanted a place to properly present
ourselves and our news around Elektra. For this reason we created a new
home page which shall give an overview of what Elektra is and can do.
Additionally to that, we also added a news section to keep you better
up-to-date!

We hope that you enjoy our new appearance as much as we do!

### Snippet Sharing

Another important part of the website and also without doubt the part
that took most effort to create, is the service that allows for sharing
of configuration snippets. It is run by a REST service fully built with
the help of [CppCMS](http://cppcms.com/) on basis of Elektra as
data store. All data concerning snippets and user accounts is stored
in Elektra’s key database (of course with password being properly hashed).

The service allows you to paste configuration snippets in various (supported)
formats and to tag, describe and name them. This in return allows you to
search snippets by keywords and to download them -- even in other formats than
the format used for uploading.

Clearly the service is meant to be driven by its users. Therefore we ask
you to share your own configuration snippets, maybe they can be of help, e.g.,
be a time saver for someone else!

Snippets shared with the service are
[BSD licensed](https://www.libelektra.org/devgettingstarted/license).
The snippets can also be downloaded directly as bundle from a separate
[GitHub repository](https://github.com/ElektraInitiative/snippets).
As soon as a snippet is added, changed or deleted on the website, a job
that updates the repository is triggered. So you can expect the repository
to be always up-to-date.

### NoScript

The website is fully written with the help of AngularJS and is therefore
heavily based on JavaScript. This should be no issue though as the
website does only use resources that can be found in the official Elektra
repository:

1. So in case you cannot or do not want to use JavaScript, you
   can find all resources also [here](https://git.libelektra.org).
2. If you are only worried about executed untrusted JavaScript,
   you can study and improve the
   [Web Frontend](/src/tools/website/README.md),
   which builds the website.
   Based on this, we hope you disable `NoScript` for our page
   so that you are able to share snippets!

## Domains

All Elektra Domains directly hosted by us are now only served by `https`.
The former `http` sites are only redirects to `https`. This might cause
trouble with some software, e.g., update `/etc/apt/sources.list`:

```
deb     [trusted=yes] https://build.libelektra.org/debian/ wheezy main
deb-src [trusted=yes] https://build.libelektra.org/debian/ wheezy main
```

The build Server is no longer reachable at port 8080, but now only directly at
[https://build.libelektra.org/](https://build.libelektra.org/).

While most `libelektra.org` now point to the new website, you can still
directly go to [GitHub](https://git.libelektra.org) and also to the
[bug tracker](https://bugs.libelektra.org).

The old Wordpress installation was shut down because of security concerns.

## Feedback

At this point there is not much more to say about the new website except for:
Feel free to explore it!

We greatly appreciate all feedback, be it for the website, the snippet sharing
service or other parts of the Elektra Initiative. We always have an open ear
for suggestions and we also like to help with technical issues, simply
[leave us a note on GitHub](https://bugs.libelektra.org)!

## Stay tuned!

Subscribe to the reimplemented
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
[mailing list](https://lists.sourceforge.net/lists/listinfo/registry-list),
use the issue tracker [on GitHub](https://bugs.libelektra.org)
or write an email to elektra@markus-raab.org.
For issues or feedback concerning the website, you can also
contact us at website@libelektra.org.

[Permalink to this NEWS entry](https://www.libelektra.org/news/website-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
Marvin & Markus





# Elektrify LCDproc

- guid: d52657b5-60da-4a21-9679-f8aacf6d6b72
- author: Markus Raab
- pubDate: Sat, 18 Mar 2017 20:43:03 +0100
- shortDesc: Elektrify LCDproc

> LCDproc is a piece of open source software that displays real-time
> system information from your `Linux`/`*BSD` box on a LCD.

LCDproc's [website](http://lcdproc.omnipotent.net/) is a bit outdated
but LCDproc itself is now well-maintained on
[GitHub](https://github.com/lcdproc/lcdproc) and had a
[release recently](https://github.com/lcdproc/lcdproc/releases).

Like in many projects, it invented its own configuration access and
INI parser which did not evolve with the needs of the project. As a
consequence inconsistencies and code duplication spread over the source.
For example, the LCDproc configuration access does not support values
that represent display's size (such as `20x4`). Thus every LCDproc's
module has its own parsing code for such values.

Some days ago (16.03.2017), we met with Harald Geyer and discussed the
current situation. We decided that we will elektrify LCDproc and remove
all the configuration access and parsing code within LCDproc.
To **elektrify** an application means to change the application so
that it uses LibElektra afterwards.

## Goals

We formulated three goals:

1. We (Elektra Initiative, mainly Thomas Waser) remove as much code
   as possible from LCDproc's code base.
2. Users of LCDproc should be able to use `LCDd.conf` as they use it now.
3. We avoid the current duplications of configuration specifications.
   (Currently in `LCDd.conf`, the docbook, in code checking the limits,
   and the default parameter in the code.)

Nice-to-have is:

- Safe updates: `make install` should not break the current `LCDd.conf`.
  (As it is already done in Debian.)
- The robustness of LCDproc on misconfiguration should be improved
  (Thomas Waser writes the specification).
- Automatic reloading of the daemon when using Elektra to update configuration.
  (Manual `SIGHUP`-signals will work in any case.)
- Have physical units with metric prefix like `500ms` for `0.5s` (seconds).

Possible limitations are:

- We break support for systems that only have very old compilers.
- The `-c` option to specify a different configuration file is
  against the abstraction Elektra should deliver. We might create a
  [wrapper script](https://github.com/ElektraInitiative/libelektra/issues/1416)
  that emulates `-c` via mountpoints.
- LCDproc will depend on the yet-to-be-released
  [0.8.20](https://github.com/ElektraInitiative/libelektra/milestone/11).
  We will delay the 0.8.20 release until all parts for LCDproc are tested and ready.

In any case, the [advertised benefits of Elektra](https://www.libelektra.org)
will automatically apply (incomplete list):

- Global key database: you can connect other configuration files with the
  LCDproc's configuration and validation.
- Allows users to easily modify the specifications, for example to have different
  command-line options, or support for environment variables.
- [Profile support](https://www.libelektra.org/plugins/profile): Having multiple
  complete configuration settings you can easily choose from. (thanks to Thomas Waser)
- Introspectibility: you can check with `kdb`-tool which configuration
  settings LCDproc will receive.
- Other configuration file formats can be used instead, e.g. JSON or XML.
  (Only if wanted as personal preference, by default INI will be used to
  remain compatibility with `LCDd.conf`.)
- Easy migration paths to use other configuration file formats such as YAML
  as default in future. (thanks to René Schwaiger)
- Elektra's tool can be used to configure LCDconf, including:
  - `kdb set` to modify individual settings within scripts and validation.
  - `kdb editor`, which spawns your favorite editor but validates
    the configuration file before writing it out.
  - `kdb qt-gui`, the Qt GUI (thanks to Raffael Pancheri).
  - The web UI of Elektra (thanks to Daniel Bugl).
- Elektra's website can be used to share LCDproc's configuration files,
  and you can use the [curlget plugin](https://www.libelektra.org/plugins/curlget)
  to mount files from the website. (thanks to Marvin Mall)
- You can use Shell, Python, or Lua to write small scripts that are executed on
  configuration access.
- Elektra allows you to directly read and write from git
  using the [Git plugin](https://www.libelektra.org/plugins/gitresolver).
  (Even if `LCDd.conf` is not checked out, thanks to Thomas Waser)
- We extensively [test](https://www.libelektra.org/devgettingstarted/testing)
  Elektra with modern techniques such as fuzzing.

## Validation

Instead of `if`s within the code, we will use SpecElektra for validation.
[SpecElektra](https://www.libelektra.org/man-pages/elektra-glossary)
is a configuration specification language that allows us to describe
which configuration is valid.

This specification will be installed as part of LCDproc to
`/usr/share/elektra/specifications`.
It uses the [metadata](https://www.libelektra.org/docgettingstarted/metadata)
as defined by the plugins to validate configuration changed via
Elektra.

For broken installations or when executing LCDproc from the source
repository, there is also a built-in specification. The specification
will only be used if the installed one cannot be found.

Thus the configuration validation specification is a normal configuration
file also integrated in Elektra, also the specification can be introspected:
useful for system administrators who want to know about valid entries, but
also for tools like our newly developed web-UI by Daniel Bugl.

The web-UI automatically restricts the interface so that only valid
entries can be entered. For example, if you should enter a boolean,
only a check box is presented to you.

- For more information about validation, see the [tutorial](https://www.libelektra.org/tutorials/validate-configuration)

## Code Generation

We (mainly Dominik Hofer) are currently developing
[a high-level API](https://www.libelektra.org/decisions/high-level-api),
whose first user will be LCDproc. In this API, we will make sure during
compilation, that configuration access is done correctly.

This is especially useful when configuration settings get renamed.
Then all places where out-dated configuration settings are used will fail to compile.

In particular using code generation developers do not need to use strings
to refer to configuration settings and they get easy-to-use enums consistent
with the configuration specification.

Furthermore, code generation will make sure that a specification (and default configuration settings)
will be found even if no `/etc` or no `/usr` is found.

We also found that we cannot use code generation everywhere.
In generic access code, code generation obviously is limited.

- For more information about code generation, see the [tutorial](https://www.libelektra.org/tools/pythongen)

## Risks

Understandably, users might be concerned that such a change will not work or create
problems in the future. Here we will discuss some of the concerns.

> Elektra might be discontinued.

From history perspective, Elektra received steady development since 2004.
Elektra is a FLOSS project and welcomes everyone to join. In the last
years several people did, with an increasing number per year.
Currently following people are working on substantial new features in Elektra
(sorted by first name):

- Armin Wurzinger: Quality Improvements
- Bernhard Denner: [Puppet Module](https://github.com/ElektraInitiative/puppet-libelektra)
- Daniel Bugl: [WebUI](https://www.libelektra.org/tools/web)
- Dominik Hofer: [the high-level API](https://www.libelektra.org/decisions/high-level-api)
- Kurt Micheli: Order Preserving Minimal Hash Map
- Markus Raab: Maintainer
- Michael Zehender: Quality Improvements
- Mihael Pranjić: mmap plugin
- Peter Nirschl: [crypto plugin](https://www.libelektra.org/plugins/crypto)
- René Schwaiger: YAML plugin
- Sebastian Bachmann: Shell Completion
- Thomas Waht: Notification
- Thomas Waser: Validation and Transformations of Configuration
- Vanessa Kos: Misconfiguration Bug Database

Obviously, there are many more casual contributors.

Elektra has a large set of [automated tests](https://build.libelektra.org)
and only a small amount of technical dept. Elektra has no required external
dependencies except libc. So without internal changes, only minimal maintenance
cost is required.

> Elektra is unfinished.

Technically this is true: we did not reach
[1.0](https://git.libelektra.org/milestone/12).
We are, however, on track to reach this goal within this summer.
Now is the best time to join because we can provide more support
and are more flexible for changes and wishes.

Some [time ago](https://www.libelektra.org/news/2016-06-14_0.8.17.md) we asked in a survey in
which direction Elektra should develop. Most open issues are (in)direct
responses from this wanted direction.

Some plugins are experimental or proof-of-concept, but they are clearly
marked as such.

> It seems a bit to me like [xkcd: Standards](https://xkcd.com/927/).

Elektra does not invent a new configuration file format nor new standards
where to store configuration files but abstracts over these issues.

> Elektra not being available in my distribution.

For the following Linux Distributions Elektra 0.8 packages are available:

- Gentoo
- [Arch Linux](https://aur.archlinux.org/packages/libelektra/)
- [Debian](https://packages.debian.org/de/jessie/libelektra4)
- [Ubuntu](https://launchpad.net/ubuntu/+source/elektra)
- [OpenSuse](https://software.opensuse.org/package/elektra)
- PLDLinux
- [Linux Mint](https://community.linuxmint.com/software/view/elektra-bin)
- [OpenWRT](https://openwrt.org/packages/pkgdata/libelektra-core?s[]=elektra)

See [INSTALL](https://www.libelektra.org/docgettingstarted/installation)
for the complete and up-to-date list.

> If Elektra does not take off and achieve world dominance,
> will we be worse off than before?

Making sure that projects will not be worse off is what we did the last
years: Not only offer an API and wait for world dominance but to offer
an implementation that can compete with any configuration library out
there. We are not completely there yet (there are some details where
specific other libraries are better than Elektra in specific points)
but these are not points that the current configuration system of
LCDproc supports (not even close). And the libraries that can compete
with Elektra have a completely different level on which dependencies
they have: Elektra is the only one only requiring libc.

> Do we retain the old way of configuring things,
> i.e. manually editing an ini file in /etc?

Absolutely, you can think of libelektra as a small library in C that
reads a configuration file and returns a data structure if you do not
use any of its advanced features.

> Do we retain the old way reloading/restarting the system service?

Elektra does not interfere with restarting. It is a passive library.
It provides some techniques for reloading but they are optional (but we
recommend that you keep the in-memory and persistent configuration in
sync via notification).

For more information, see the [FAQ](https://www.libelektra.org/man-pages/elektra-faq).

## Win-Win

We can both profit from it:

1. For LCDproc it will be a simplification of code while getting many more tools.
2. For Elektra it will improve its adoption and packaging.

For oyranos it already worked well on both sides, see our discussions in the issue tracker, for example [#1134](https://issues.libelektra.org/1134).

If you also maintain an free or open source (FLOSS) project with an out-dated configuration system, please contact us.

Obviously, we cannot fully port every FLOSS project ourselves, instead we will handle requests on a first come, first serve basis.
Earlier projects will also have an higher impact on the feature set of Elektra, thus you will less likely need to implement your own plugin.

## See Also

- Progress can be viewed [here](https://git.libelektra.org/projects/7)
- We discussed about alternatives to Elektra [here](https://issues.libelektra.org/1266).

Best regards,
Markus





# 0.8.20 Release

- guid: 547d48e2-c044-4a8e-9d32-ca6b6fb914d9
- author: Markus Raab
- pubDate: Thu, 31 Oct 2017 23:08:07 +0200
- shortDesc: New Website, puppet-libelektra, New Plugins

## 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](https://libelektra.org).

## Highlights

This is by far the largest release in Elektra's history.
In 2813 commits, 19 authors changed 1714 files with 92462
insertions(+) and 21532 deletions(-). The highlights are:

- libelektra.org: new website and puppet-libelektra
- plugin+bindings for Haskell and Ruby
- improved shell completion
- new plugins: yamlcpp, camel, mini, date, file, range,
  multifile, xerces, ipaddr

### libelektra.org

Unfortunately this release was delayed. The reason for the delay is that our
community server ([build server](https://build.libelektra.org), web site,...)
was compromised and we needed to reinstall everything from scratch.

We took advantage of the situation, and reinstalled everything properly
managed by [puppet-libelektra](https://github.com/ElektraInitiative/puppet-libelektra).
With puppet-libelektra, you can directly set keys, specifications (validations),
and even mount new configuration files from within Puppet.

Our community server is now completely managed by libelektra.

Thanks to Bernhard Denner, for rescuing us from the difficult situation, especially
for the sprint shortly before the release.

As already already announced in [December 2016](https://master.libelektra.org/doc/news/2016-12-17_website_release.md)
we completely reimplemented our website. Now all our websites are available via https.
This release is the first one that includes the source code of the website and its
snippet sharing functionality.

The backend for this snippet sharing website uses Elektra itself: both for its
configuration and for the configuration snippets.

Thanks again to Marvin Mall for the awesome website.

#### Haskell and Ruby

The Ruby binding, created by Bernhard Denner, was greatly improved and now
includes libtools bindings. It is the first binding that goes beyond Elektra's
main API. Bernhard Denner also added many
[examples](https://master.libelektra.org/src/bindings/swig/ruby/examples) that
demonstrate how you can take advantage of the Ruby bindings.

Armin Wurzinger created a new binding
for the functional language Haskell. He also added support for
Haskell plugins.
Due to generic CMake and C Code, plugins can be written
exclusively in Haskell, without any glue code. Several Haskell
examples already exist. The Haskell support is currently experimental.

### Shell Completion

René Schwaiger added completion support for [Fish](http://fishshell.com)
in this release. We also extended our support for other shells: The new
tool `kdb complete` suggests how to complete an Elektra path. It considers
mountpoints and also takes bookmarks into account. Thanks to Armin
Wurzinger for creating this useful utility. Our Zsh and fish completions
already take advantage of `kdb complete`. Thanks to Sebastian Bachmann
for taking the time to update the `zsh` completions.

### New Plugins

See [plugin overview](https://www.libelektra.org/plugins/)
to get an overview of the ever-growing number of plugins.

The [yamlcpp plugin](https://www.libelektra.org/plugins/yamlcpp)
and camel plugin
add first support for YAML.

The [mini plugin](https://www.libelektra.org/plugins/mini)
is yet another minimal INI plugin.

Thanks to René Schwaiger.

The [date plugin](https://www.libelektra.org/plugins/date)
supports validation of dates according to three standards:

- `RFC2822`
- `ISO8601`
- `POSIX`

The [multifile plugin](https://www.libelektra.org/plugins/multifile)
allows us to integrate many configuration files via globbing with
a single mount command. It supports `.d` configuration directories
as often used today.

The [file plugin](https://www.libelektra.org/plugins/file)
interprets the content of a file as configuration value.

The [ipaddr plugin](https://www.libelektra.org/plugins/ipaddr)
adds support for IP address validation on systems that do not
support `getaddrinfo`.

Thanks to Thomas Waser for creating these useful plugins.

The [xerces plugin](https://www.libelektra.org/plugins/xerces)
supplants the [xmltool plugin](https://www.libelektra.org/plugins/xmltool)
and allows us to use XML files not following a specific schemata.
Attributes are mapped to Elektra's metadata, multiple keys with the
same names are mapped to arrays.

Thanks to Armin Wurzinger.

## Documentation

The documentation was greatly improved within this release.

- Added "Hello, Elektra" and logging tutorial,
  thanks to René Schwaiger
- extended [FAQ](https://master.libelektra.org/doc/help/elektra-faq.md)
- Christoph Weber (@krit0n) improved some tutorials
- options are passed to PDFLaTeX compiler,
  thanks to René Schwaiger
- small fixes, thanks to Dominik Hofer
- fix many spelling mistakes, use American english, fix formatting,
  fix+add links, unify title style, fix code blocks, add titles
  and fix the PDF manual
  a big thanks to René Schwaiger

## Features

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

- DBUS support for qt-gui (listening to configuration changes):
  qt-gui gets a viewer-mode where configuration settings are immediately updated
  via DBus notifications, thanks to Raffael Pancheri
  With the new qt-gui and newer qt releases (~5.7) the qtquick experience is much smoother,
  for example, the tree view does not collapse on syncs anymore.
- Armin Wurzinger greatly improved the [JNA binding](https://www.libelektra.org/bindings/jna).
  The build system now uses Maven to build them. Armin also added Doxygen documentation
  and a [script](http://master.libelektra.org/scripts/randoop/randoop.in)
  to test the JNA binding using [Randoop](https://randoop.github.io/randoop).
- The improved [curlget plugin](https://www.libelektra.org/plugins/curlget),
  is now able to upload configuration files,
  thanks to Thomas Waser and Peter Nirschl (CMake fixes).
- New command `kdb rmmeta`, thanks to Bernhard Denner
- [crypto plugin](https://www.libelektra.org/plugins/crypto) and [fcrypt plugin](https://www.libelektra.org/plugins/fcrypt)
  - The configuration option `gpg/key` was renamed to `encrypt/key`
  - The plugins now make sure that you configured them properly by
    validating key IDs
  - thanks to Peter Nirschl
- [fcrypt plugin](https://www.libelektra.org/plugins/fcrypt):
  - The plugin now list available GPG keys when config is missing
  - You can now specify signatures via the configuration option `sign/key`
  - New text mode, enabled by default (disable by setting `fcrypt/textmode` to `0`)
  - New option `fcrypt/tmpdir` allows you to specify the output directory of `gpg`
  - If you want to learn how to use the plugin please check out our new [ASCII cast](https://asciinema.org/a/153014)
  - thanks to Peter Nirschl
- Thomas Waser added useful scripts:
  - [mount-list-all-files](https://master.libelektra.org/doc/help/kdb-mount-list-all-files.md)
    to list all mounted files.
  - [mountpoint-info](https://master.libelektra.org/doc/help/kdb-mountpoint-info.md)
    to provide more info about mountpoints.
  - [stash](https://master.libelektra.org/doc/help/kdb-stash.md)
    to stash away Elektra's configuration, to be restored using `restore`.
  - [backup](https://master.libelektra.org/doc/help/kdb-backup.md)
    to backup Elektra's configuration.
  - [restore](https://master.libelektra.org/doc/help/kdb-restore.md)
    to restore a backup or stash.
  - [check-env-dep](https://master.libelektra.org/doc/help/kdb-check-env-dep.md)
    allows users to check if environment has influence on configuration settings.
  - [change-resolver-symlink](https://master.libelektra.org/doc/help/kdb-change-resolver-symlink.md)
    allows users to change the default resolver.
  - [change-storage-symlink](https://master.libelektra.org/doc/help/kdb-change-storage-symlink.md)
    allows users to change the default storage.
- limit min/max depth for `kdb ls` (`-mM`), thanks to Armin Wurzinger.
- conditionals: allow multiple assigns and conditions
- base64 also works as filter for binary data (not just encrypted data),
  thanks to René Schwaiger
- [csvstorage plugin](https://www.libelektra.org/plugins/csvstorage):
  compatibility with RFC 4180, thanks to Thomas Waser
- [gitresolver plugin](https://www.libelektra.org/plugins/gitresolver):
  improvements and update of libgit version, thanks to Thomas Waser
- [curlget plugin](https://www.libelektra.org/plugins/curlget):
  also allow uploading of configuration files, thanks to Thomas Waser

## 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 added `explicit` to some C++ constructors in libtools and internally moved
some typedefs. ModulesPluginDatabase now has protected members (instead
of private). This might break code in special cases, but should not affect binary
compatibility. As always we tested for binary compatibility.
This time we had to revert some changes to keep libelektra-tools
ABI compatible.

Furthermore:

- scripts now work on macOS (readlink and sed),
  thanks to Armin Wurzinger and René Schwaiger
- generalized error #60, "invalid line encountered"
- added new errors #164 - #187
- added private headerfiles `kdbglobal.h`, `kdbinvoke.h`

## Notes for Package Maintainer

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

- LICENSE.md now contains only the BSD 3-Clause License
  (without any additional non-license text)
- AUTHORS renamed to AUTHORS.md
- NEWS.md is now a generated file containing all news concatenated
- CMake 2.8.8 is no longer supported, CMake 3.0 is now needed
- fix macOS `RPATH`, remove old policies, thanks to René Schwaiger
- new option `BUILD_DOCSET` to build DocSet, thanks to René Schwaiger
- new option `ENABLE_OPTIMIZATIONS` for `OPMPHM` preparation work,
  thanks to Kurt Micheli
  For this release, please keep `ENABLE_OPTIMIZATIONS` turned off.
  Currently the flag increases memory usage, without being faster.
- add `TARGET_TOOL_DATA_FOLDER` for installation of tool data

The following files are new:

- Libs: `libelektra-utility.so` ,`libelektra4j-0.8.20.pom.xml`,
  `libelektra-invoke` (needed by plugins: curlget, gitresolver, dini, blockresolver, multifile)
- Plugins: `libelektra-camel.so`, `libelektra-date.so`,
  `libelektra-file.so`, `libelektra-ipaddr.so`, `libelektra-mini.so`,
  `libelektra-multifile.so`, `libelektra-range.so`, `libelektra-xerces.so`,
  `libelektra-yamlcpp.so`
- Tools: `backup`, `mount-list-all-files`, `mountpoint-info`, `restore`,
  `stash`, `update-snippet-repository`
- Tests: `change-resolver-symlink`, `change-storage-symlink`,
  `check-env-dep`, `check_bashisms`, `check_doc`, `check_meta`,
  `testmod_camel`, `testmod_crypto_openssl`, `testmod_date`,
  `testmod_file`, `testmod_ipaddr`, `testmod_jni`, `testmod_mini`,
  `testmod_range`, `testmod_simpleini`, `testmod_xerces`, `testmod_yamlcpp`,
  `testtool_plugindatabase`, `test_utility`

The following files were removed: `testmod_curlget`, `testmod_dpkg`,
`testmod_profile`, `testmod_shell`, `testmod_spec`, `test_opmphm_vheap`,
`test_opmphm_vstack`

The following files were renamed:
`libelektra-1.jar` → `libelektra4j-0.8.19.jar`

In the Debian branch of the [git repo](https://git.libelektra.org/tree/debian),
we now build upon the work of Pino Toscano. The branch allows building
Debian packages of the release for Debian Stretch and Jessie.

Thanks to Pino Toscano for the high-quality packages.

## Notes for Elektra's Developers

These notes are of interest for people developing Elektra:

- Added macros, thanks to René Schwaiger:
  - `ELEKTRA_NOT_NULL` is an assertion against null pointers
  - `ELEKTRA_MALLOC_ERROR` sets an error when allocation failed
  - `ELEKTRA_STRINGIFY` to quote a macro value
  - `ELEKTRA_PLUGIN_STATUS_ERROR`, `ELEKTRA_PLUGIN_STATUS_SUCCESS`,
    `ELEKTRA_PLUGIN_STATUS_NO_UPDATE` for return values of plugins.
- `ELEKTRA_STRINGIFY` used throughout, thanks to René Schwaiger
- use `(void)` instead of `()` (added `-Wstrict-prototypes`)
- new positions for global plugins,
  thanks to Mihael Pranjic
- Kurt Micheli added `generateKeySet` to randomly generate large key sets
- add vagrant and docker support, thanks to Christoph Weber (@krit0n)
- improve support for CLion, NetBeans and `oclint`
- portability improvements for logger, thanks to René Schwaiger
- metadata consistency check within source repo, thanks to Thomas Waser
- `ELEKTRA_PLUGIN_EXPORT` accepts macro as argument
- fallthroughs in switch statements are now marked with `FALLTHROUGH`
- introduce `print_result` to unify test output, thanks to René Schwaiger
- export `validateKey` as preparation for type plugin

## Other

Various other changes happened in the code repository:

- kdb: errors are more colorful, add infos to report issues,
  catch signals for `kdb` tools to print errors on crashes,
  use `$EDITOR` if `sensible-editor` and `editor` is not found.
  René Schwaiger fixed preposition and format of the messages.
- added Spanish translation for qt-gui
  thanks to AdanGQ (@pixelead0)
- augeas plugin: error messages improved, export genconf (for WebUI to list all lenses)
- improvements for CentOS and Debian Packages,
  thanks to Sebastian Bachmann
- Travis improvements, fixes, and many build variants added,
  thanks to Mihael Pranjic and René Schwaiger
- `ronn` now always uses UTF-8 as encoded and is no longer required
  as essential dependency to get man pages, thanks to René Schwaiger
- GitHub now recognizes that we have a BSD licence,
  thanks to René Schwaiger
- uninstallation Script also uninstalls directories and Python files,
  thanks to René Schwaiger
- Kurt Micheli created a benchmark tool to generate large KeySets
- added/reformatted use cases, thanks to Daniel Bugl
- Thomas Wahringer prepared for a new theme on the website
- Arfon Smith updated metadata for Elektra's journal entry

## Quality

In this release we had a focus on quality improvements:

- fixed all remaining ASAN problems,
  thanks to René Schwaiger and Armin Wurzinger
  (some tests are excluded when compiled with ASAN)
- fix many compilation warnings,
  thanks to René Schwaiger and Armin Wurzinger
- fixed many potential out-of-bound errors,
  thanks to René Schwaiger
- fixed warnings of Clang's static analyzers,
  thanks to René Schwaiger
- fixed cppcheck warnings, thanks to Armin Wurzinger
- fixed strict prototypes, thanks to Armin Wurzinger
- fixed and use scan-build (clang)
- fixed potential memory leaks on errors
- added assertions
- generate Java API tests with randoop which
  revealed bugs in jna bindings that were fixed,
  thanks to Armin Wurzinger
- Numerous fixes in the shell recorder,
  which does regression tests on Elektra's tutorials
  and READMEs, thanks to René Schwaiger and Thomas Waser

## Fixes

Many problems were resolved with the following fixes:

- `kdb file`: never print errors, thanks to René Schwaiger
- plugin mathcheck: fixed regex #1094, thanks to Thomas Waser
- dbus: properly do unref and document how to integrate DBus,
  thanks to Kai-Uwe Behrmann
- dbus accepts announce=once which is used for `kdb mount-openicc`
  It protects against message floods in large configuration files,
  thanks to Kai-Uwe Behrmann for reporting
- plugin desktop: fix crash if `DESKTOP_SESSION` is missing
- shell-recorder: many fixes and improvements,
  thanks to Thomas Waser and René Schwaiger
- fix getopt positional parameters, thanks to Armin Wurzinger
- resolver: avoid silent errors of fchown/fchmod
- plugin fcrypt: fixes in file name handling to make leaks less likely
  (still needs tmpfs to be secure!), thanks to Peter Nirschl
- plugin jni: fix segfaults on errors, plugin is nevertheless tagged
  as experimental due to other problems
- plugin type: reject integers if garbage follows
- `kdb`: fix memleak when listing plugins
- many spelling fixes and fix typo in source of qt-gui:
  thanks to klemens (ka7)
- dpkg, fix file leakage, thanks to Armin Wurzinger
- plugin line: only skip parentKey if present
- plugin resolver: avoid failure after commit for files that
  cannot be removed
- plugin simpleini: handle more errors, make format parameter more robust
  thanks to Bernhard Denner
- plugin crypto: fix compilation errors for openssl versions on
  Debian 9, thanks to Peter Nirschl
- `kdb mv`: fail without keys also in recurse mode
- fix bashism, thanks to Armin Wurzinger
- qtgui: fix crash on unhandled exception on binary values,
  thanks to Raffael Pancheri

## Outlook

We are currently working on following topics:

- Migration of LCDproc, OpenIcc, machinekit, ... to Elektra.
- A reimplementation of Elektra's core API in Rust
  (next to implementation in C).
- A user interface which generates restricted input fields
  based on the specification.
- YAML as configuration file format (next to INI, XML, JSON, TCL, ...).
- An mmap persistent cache.
- Improvements for the specification language.
- New APIs to be directly used by applications.
- An order-preserving minimal hash for O(1) lookup and iteration.
- Mainloop migration for notifications (currently only DBus,
  to be extended to Redis, ZeroMq).
- Improvements on the Website and snippet sharing to also
  handle misconfiguration.

## Get It!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.20.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.20.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.20.tar.gz.hashsum?raw=true)

- name: elektra-0.8.20.tar.gz
- size: 4740032
- md5sum: 0e906f1a1677a8bfb31d144e1eaeb3cf
- sha1: 5e33c49ae6e3b890c9267288fb9f321289910eb5
- sha256: e9cbc796e175685ccb6221f1dd5ea5c43832f545c40557c32b764ff5d567b312

The release tarball is also available signed by me using gpg from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.20.tar.gz.gpg) or
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases//elektra-0.8.20.tar.gz.gpg?raw=true)

Already built API documentation can be found [online](https://doc.libelektra.org/api/0.8.20/html/)
or [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.8.20).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
issue tracker [on GitHub](http://issues.libelektra.org)
or me by email using elektra@markus-raab.org.

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.8.20-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
Markus





# 0.8.21 Release

We are proud to release Elektra 0.8.21.

- guid: 7f5de1b1-6086-47a6-9922-cac08c898ae7
- author: Markus Raab
- pubDate: Fri, 22 Dec 2017 09:24:02 +0100
- shortDesc: FOSDEM, New Book, Maturing of Plugins

## 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](https://libelektra.org).

The news can be read rendered at [our web server](https://www.libelektra.org/news/0.8.21-release).

## Highlights

In this release 8 authors created 307 commits and changed 217 files (5227 insertions, 1914 deletions).
The highlights of this release are:

- Fosdem Talk about Elektra was accepted
- CC-licensed book about Elektra published
- Maturing of plugins
- Elektra with encryption
- Preparation for switch to INI as default storage

### Fosdem Talk about Elektra in Main Track

We are happy to announce that there will be a talk about
Elektra in one of the [main tracks of Fosdem 2018](https://fosdem.org/2018/schedule/event/elektra/):

- Title: Configuration Revolution
- Subtitle: Why it Needed 13 Years and How it Will be Done
- Day: Saturday 2018-02-03
- Start time: 15:00
- Duration: 50 min
- Room: K.1.105 (La Fontaine)

And a second talk in the [Config Management DevRoom](https://fosdem.org/2018/schedule/event/puppet_key_value/):

- Title: Breaking with conventional Configuration File Editing
- Subtitle: Puppet with a Key/Value API in a User Study
- Day: Sunday 2018-02-04
- Start time: 12:30
- Duration: 25 min
- Room: UA2.114 (Baudoux)

See you in Brussels at 3 and 4 February 2018!

I will also be present in the [Config Management Camp](http://cfgmgmtcamp.eu/) directly after Fosdem in Gent.

### CC-licenced Book About Vision of Elektra Published

I am proud to release a book with the title "Context-aware Configuration" describing:

- the last 13 years of Elektra (focus on last 4 years with the questionnaire survey and code analysis),
- the current state of Elektra, and
- the long-term goals of Elektra (context-aware configuration).

The Fosdem talk will cover some highlights from the book.

A huge thanks to everyone involved in the questionnaire survey,
without you we would not have been able to collect all the
information that led to the requirements for Elektra.

The LaTeX sources are available [here](https://book.libelektra.org)
and the compiled book can be downloaded from [here](https://www.libelektra.org/ftp/elektra/publications/raab2017context.pdf).

### Maturing of Plugins

- The new [Directory Value plugin](https://www.libelektra.org/plugins/directoryvalue) supports storage plugins such as [YAJL](https://www.libelektra.org/plugins/yajl) and [YAML CPP ](https://www.libelektra.org/plugins/yamlcpp). It adds extra leaf values for directories (keys with children) that store the data of their parents. This way plugins that normally are only able to store values in leaf keys are able to support arbitrary key sets.
- The [YAML CPP plugin](https://www.libelektra.org/plugins/yamlcpp) reads and writes [YAML](http://yaml.org) data using [yaml-cpp](https://github.com/jbeder/yaml-cpp). The plugin supports arrays, binary data and metadata.
- The Camel plugin stores data as simplified YAML flow lists containing double quoted keys and values. For proper YAML support please use the [YAML CPP](https://www.libelektra.org/plugins/yamlcpp) instead.
- The [mINI plugin](https://www.libelektra.org/plugins/mini) reads and writes simple property list, separated by equal (`=`) signs.
- The [xerces plugin](https://www.libelektra.org/plugins/xerces) allows Elektra to read and write XML data. The plugin uses [Xerces-C++](http://xerces.apache.org/xerces-c) for this task. It supports both arrays and metadata.
- The [boolean plugin](https://www.libelektra.org/plugins/boolean) normalizes boolean values such as `0`, `1`, `true` and `false`.
- The [crypto plugin](https://www.libelektra.org/plugins/crypto) and [fcrypt plugin](https://www.libelektra.org/plugins/fcrypt) are described below.

### Elektra With Encryption

The plugins `fcrypt` and `crypto` are now considered stable. They are no longer tagged as `experimental`.
While `crypto` encrypts individual values within configuration files, `fcrypt` encrypts and/or signs the whole configuration file.

For this release Peter Nirschl prepared a demo showing Elektra's cryptographic abilities:

[![asciicast](https://asciinema.org/a/153014.png)](https://asciinema.org/a/153014)

Thanks to Peter Nirschl for this great work!

### Switch to INI

We plan to switch to INI as default storage instead of Elektra's infamous internal dump format.

As preparation work we implemented the `dini` plugin which transparently
converts all `dump` files to `ini` files on any write attempt.
Furthermore, we fixed most of the INI bugs which blocked INI to be the
default storage.

Due to this progress we will likely switch to INI as default starting
with the next release. If you want to, you can switch now by compiling
Elektra with:<br>
`-DKDB_DEFAULT_STORAGE=dini`

Or simply switch for your installation with:<br>
`sudo kdb change-default-storage dini`

If you are already using `ini` as default, changing to `dini` will:

- add some overhead because `dini` always checks if a file uses the `dump`
  format, unless the `dump` plugin is not installed.
- add support for binary values using the `binary` plugin

> NOTE: INI (dini) was not completely ready for 0.8.21 thus we kept `dump` as default.
> `dini` is currently an experimental plugin.

## Other New Features

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

- `kdb rm` now supports `-f` to ignore non-existing keys
- use `%` as profile name to disable reading from any profile
- The new function `elektraArrayDecName`:

  ```c
  int elektraArrayDecName (Key * key);
  ```

  decreases the index of an array element by one. It can be used to reverse the effect of `elektraArrayIncName`,
  thanks to René Schwaiger

## Documentation

We improved the documentation in the following ways:

- We renamed our beginner friendly issues to "good first issue" as recommended by GitHub.
- In many parts of the documentation we already switched to American spelling
  thanks to René Schwaiger
- Added more [automatic spelling corrections](https://master.libelektra.org/scripts/spelling.sed)
  thanks to René Schwaiger
- Fixed many spelling mistakes
  thanks to René Schwaiger
- We extended the ReadMe of the `jni` plugin. The ReadMe now also contains information about the Java prerequisites of the `jni` plugin on Debian Stretch.
- Improved notes about testing
  thanks to Thomas Wahringer
- qt-gui: give hints which package to install
- The build phrases `jenkins build all please` and `jenkins build doc please` were [documented](https://master.libelektra.org/doc/Git.md)
  thanks to René Schwaiger
- Documentation for libelektra-invoke was added

## 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).

All unit tests of 0.8.20 run successfully with Elektra 0.8.21.
There are, however, some additions and changes in rarely used interfaces:

- added `elektraArrayDecName` and `elektraArrayValidateName` in libease
- fixed `kdbinvoke.h` interface: make structure private and complete API
- fixed `xmlns` and `xsi:schemaLocation` to be `https://www.libelektra.org`
- the private header file `kdbopmphm.h` got nearly rewritten

## Notes for Maintainer

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

- We added the following files in this release:
  - `libelektra-dini.so`
  - `libelektra-directoryvalue.so`
  - `testmod_directoryvalue`
- The following plugins are not marked as experimental anymore:
  - `camel`
  - `crypto`
  - `mini`
  - `xerces`
  - `yamlcpp`
- The binding `intercept-fs` is now marked more clearly as experimental
- The `jni` plugin is again experimental because it does not work with some Java systems.
  For the `lua` plugin there are also problems with some Lua systems.

## Notes for Elektra's Developers

These notes are of interest for people developing Elektra:

- From now on release notes are written as part of PRs
- Elektra Initiative is spelled as two words
- At some more places we switched to use the logger, thanks to René Schwaiger
- Shell Recorder got many improvements, see below in Testing.
  Please use it.
- The plugin's template now adds all placements within backends by default
  (must be removed accordingly).
- We now warn if plugins do not have any placement.
- Please prefer -log and -debug builds
- The build server now understands the build phrase `jenkins build all please`
  thanks to René Schwaiger.
  Please use it carefully, since it puts our [build server](https://build.libelektra.org/) under heavy load.
- Markdown Shell Recorder Syntax recommended when reporting bugs.
- Elektra's [Dockerfile](https://master.libelektra.org/scripts/docker/legacy/Dockerfile) was improved and simplified, thanks to Thomas Wahringer.
- Add more Explanations how to do Fuzz Testing
- Started documenting disabled tests in [doc/todo/TESTING](https://master.libelektra.org/doc/todo/TESTING)
- You now can use `tests/icheck.suppression` to disable already checked API changes.
- The (hopefully) last Sourceforge references were removed and a redirection page was added,
  thanks to @the-Arioch for reporting.

## Testing

- AFL unveiled some crashes in INI code
- fix OCLint problems, thanks to René Schwaiger
- fix ASAN problems, thanks to René Schwaiger
- disabled non-working tests
- Shell recorder
- Benchmark optionally also works with OpenMP, thanks to Kurt Micheli
- The Shell Recorder now uses `kdb-static` or `kdb-full` if `kdb` is not available (`BUILD_SHARED=OFF`)

## Fixes

Many problems were resolved with the following fixes:

- fix use of `dbus_connection_unref(NULL)` API
  thanks to Kai-Uwe Behrmann
- Properly include headers for `std::bind`
  thanks to Nick Sarnie
- qt-gui: assure active focus on appearance selection window
  thanks to Raffael Pancheri
- René Schwaiger repaired the `boolean` plugin:
  - wrong metadata was used
  - plugin configuration was missing
  - documentation was missing
  - logging code was added
- René Schwaiger repaired many problems different build agents had
- `kdb info -l` does not open `KDB` anymore.
- `change-resolver-symlink` and `change-storage-symlink` now correctly use
  `@TARGET_PLUGIN_FOLDER@`
- date plugin will be removed on attempts to compile it with gcc 4.7, thanks to René Schwaiger
- C plugin: storage/c metadata added
- fix disabling documentation in CMake, thanks to Kurt Micheli
- Simplify `elektraArrayValidateName`, thanks to René Schwaiger

## Outlook

The Order Preserving Minimal Perfect Hash Map (OPMPHM) is ready to extend `ksLookup`. The implementation of the randomized Las Vegas hash map
algorithm is in a final stage and the heuristic functions that ensure time and space optimality are backed up by benchmarks.
Thanks to Kurt Micheli, the next release will include the OPMPHM!

## Get It!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.21.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.21.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.21.tar.gz.hashsum?raw=true)

- name: elektra-0.8.21.tar.gz
- size: 4712043
- md5sum: d627a01a0249fde46e80042c848d4521
- sha1: a7659a7bb1b2388d03cdf0084160de612e5c4511
- sha256: 51892570f18d1667d0da4d0908a091e41b41c20db9835765677109a3d150cd26

The release tarball is also available signed by me using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.21.tar.gz.gpg) or
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases//elektra-0.8.21.tar.gz.gpg?raw=true)

Already built API documentation can be found [online](https://doc.libelektra.org/api/0.8.21/html/)
or [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.8.21).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
issue tracker [on GitHub](http://issues.libelektra.org)
or me by email using elektra@markus-raab.org.

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.8.21-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
Markus Raab for the [Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.8.22 Release

- guid: 4884a54f-996a-4564-a138-38a70166fed7
- author: Markus Raab
- pubDate: Tue, 27 Feb 2018 19:35:58 +0100
- shortDesc: Logo, INI, Lookup

We are proud to release Elektra 0.8.22!
In 429 commits, 8 authors changed 548 files with 60369 insertions(+), 6783 deletions(-).

## 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](https://libelektra.org).

For a small demo see here:

[![asciicast](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r.png)](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r)

You can also read the news [on our website](https://www.libelektra.org/news/0.8.22-release)

You can read the [FOSDEM interview](https://fosdem.org/2018/interviews/markus-raab/) and watch the
[FOSDEM main talk](https://fosdem.org/2018/schedule/event/elektra/) given recently.

Elektra is now an official part of [Homebrew](http://formulae.brew.sh/formula/elektra).

## Highlights

- New Logo and Website Theme
- INI plugin greatly improved
- Notifications API and Bindings for Asynchronous I/O
- Plugin Processes
- Lookup with the Order Preserving Minimal Perfect Hash Map

### New Logo and Website Theme

We are proud to present our new logo.
It has a new shape and cooler colors.

<img src="https://cdn.rawgit.com/ElektraInitiative/libelektra/master/doc/images/logo/logo_color.svg" alt="Elektra" width="150" />

Thanks to Philipp Frei!

We also gave the website a new look. It has the colors from the logo and new
fonts ([Lato](https://fonts.google.com/specimen/Lato) and
[Libre Franklin](https://fonts.google.com/specimen/Libre+Franklin)) that improve
readability and add to a unique look. The restructured start page contributes to
the new look as well.

We also updated asciinema-player to 2.6.0.

Thanks to Thomas Wahringer.

We also fixed security issues in the Website due to an old version of jquery,
thanks to Marvin Mall.

Thanks to Bernhard Denner for keeping our infrastructure running.

### INI plugin greatly improved

- `dini` is no longer experimental anymore and adds the binary plugin.
- We added a crash test for the INI plugin that feeds the plugin with problematic input data we determined using [AFL](http://lcamtuf.coredump.cx/afl)
- We fixed various small bugs that could potentially cause the INI plugin to crash and fixes the problems as reported by AFL
- The INI plugin now [converts a section to a normal key-value pair](https://github.com/ElektraInitiative/libelektra/issues/1793) if you store a value inside it. This has the advantage that you will not [lose data unexpectedly anymore](https://github.com/ElektraInitiative/libelektra/issues/1697).
- The [INI plugin](https://www.libelektra.org/plugins/ini) should now read most key-value pairs containing delimiter characters (`=`) properly.

Thanks to René Schwaiger!

Nevertheless, we did not switch to INI as default format.
This has some reasons:

- In many workflows, `dump` is the better choice: e.g. with `kdb editor` you can edit any parts of Elektra with any format (e.g. INI) more safely.
  (With the INI plugin in some of these situations metadata is wrongly shown.)
- The code base of INI is not fully tested and partly not well understood.
- We plan to switch to a newly written parser (most likely YAML) and want to avoid that users have two migrations.
  The migration from `dump` is easier (especially compared with INI) because the `dump` format is recognisable without ambiguity.
  (Thus the INI file parses nearly any file, it is hard to detect that a file is not INI)

But for those who want to switch, the migration will be smooth:
The `dini` plugin makes sure that old dump files are still being read.
Only when writing out configuration files, configuration files are converted to INI.
To change to INI during compilation, simply use:

`-DKDB_DEFAULT_STORAGE=dini`

Or simply switch for your installation with:<br>
`sudo kdb change-default-storage dini`

You can also mount INI (or dini) as root:<br>
`sudo kdb mount default.ini / dini`

### Notification API and Bindings for Asynchronous I/O

This release contains an experimental implementation of Elektra's notification feature.
This feature enables applications to get updates when configuration is changed at run-time.
For more details see the preview tutorial at
[doc/tutorials/notifications.md](https://github.com/ElektraInitiative/libelektra/tree/master/doc/tutorials/notifications.md)

The
[Notification API](https://doc.libelektra.org/api/latest/html/kdbnotification_8h.html)
is implemented by a new library called `elektra-notification`.
To use the library you need the new internalnotification plugin.
Since the plugin is experimental it needs to be enabled when building Elektra
from source (e.g. by passing
`-DPLUGINS="ALL;-EXPERIMENTAL;internalnotification"` to `cmake`).

New bindings for asynchronous I/O called "I/O bindings" also have been added.
These bindings allow Elektra's plugins and other parts to perform _asynchronous_ operations.
I/O bindings are opt-in for application developers.
New features of Elektra that take advantage of I/O bindings will have fallbacks where viable.
These fallbacks will use synchronous I/O thus keeping the status quo.

This release includes an experimental I/O binding for [uv](http://libuv.org/).
The interface for I/O bindings is currently experimental and might change in the future.

Elektra's notification feature is not complete yet.
So-called "transport plugins" will be responsible for sending and receiving
notifications using different protocols or libraries (like ZeroMQ or D-Bus).
These plugins will make use of the new I/O bindings.
We plan to introduce the first transport plugins with the next release of Elektra.

### Plugin Processes

A new library called [pluginprocess](https://github.com/ElektraInitiative/libelektra/tree/master/src/libs/pluginprocess)
has been added. This library contains functions that aid in executing plugins in
a separate process. This child process is forked from Elektra's main process
each time such plugin is used and gets closed again afterwards. It uses a simple
communication protocol based on a KeySet that gets serialized through a pipe via
the `dump` plugin to orchestrate the processes.

Such a behavior is useful for plugins which cause memory leaks to be
isolated in an own process. Furthermore this is useful for runtimes or libraries
that cannot be reinitialized in the same process after they have been used.

### Lookup with the Order Preserving Minimal Perfect Hash Map

The `ksLookup (...)` has a new search algorithm, that acts as an alternative to the
binary search. The Order Preserving Minimal Perfect Hash Map (OPMPHM) is a non-dynamic,
randomized hash map and is very effective for mostly static configurations.
The OPMPHM can be enabled for a search by passing the in [kdbproposal.h](https://github.com/ElektraInitiative/libelektra/blob/master/src/include/kdbproposal.h)
defined option `KDB_O_OPMPHM` to the lookup.
Be aware that if the KeySet changes often using the OPMPHM might not be a good
idea, read more about the [OPMPHM](https://github.com/ElektraInitiative/libelektra/blob/master/doc/dev/data-structures.md#order-preserving-minimal-perfect-hash-map-aka-opmphm).

When you are not sure if the OPMPHM will speed up you searches, wait for the next release,
that one will include a hybrid search algorithm that combines the best properties of
both search algorithms.

To disable OPMPHM (e.g. on systems with tight memory constraints), you can pass
`-DENABLE_OPTIMIZATIONS=OFF`

## Other New Features

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

- The Web UI was greatly improved, thanks to Daniel Bugl
  The version of clusterd was increased from 1.0.0 to 1.1.0.
- Elektra is now part of the official [Homebrew repository](http://formulae.brew.sh/formula/elektra). We still provide a
  [tap](http://github.com/ElektraInitiative/homebrew-elektra), if you want to install Elektra together with plugins or bindings that require
  additional libraries.
- The building and linking of the Haskell bindings and Haskell plugins has been
  [greatly improved](https://github.com/ElektraInitiative/libelektra/pull/1698).
- The invoke library can now [report errors](https://github.com/ElektraInitiative/libelektra/pull/1801) upon opening/closing a plugin,
  thanks to Armin Wurzinger.
- The [YAML CPP plugin](https://www.libelektra.org/plugins/yamlcpp) does not require [Boost](http://www.boost.org) anymore, if you
  installed [yaml-cpp 0.6](https://github.com/jbeder/yaml-cpp/releases/tag/yaml-cpp-0.6.0).
- Improved colored output in `kdb` tool.
- We added two build jobs: docker and haskell.
  Thanks to Bernhard Denner and Armin Wurzinger.
- [YAML CPP](https://www.libelektra.org/plugins/yamlcpp) does not write binary data to a config file, if you forget to load the [Base64 plugin](https://www.libelektra.org/plugins/base64).
- [YAML CPP](https://www.libelektra.org/plugins/yamlcpp) now encodes empty binary keys as NULL values (`~`), and also adds the metakey `binary` for such values automatically.

## Documentation

We improved the documentation in the following ways:

- We have [documented how you can setup a build node for Jenkins using a Docker container](https://github.com/ElektraInitiative/libelektra/tree/master/scripts/docker/jenkinsnode/README.md)
  We also provide an example Dockerfile based on Debian Stretch for that purpose,
  thanks to Armin Wurzinger.
- Document how `rlwrap` might be used for `kdb shell`.
- Fixed documentation in `hosts` plugin.
- Greatly improved the [license documentation](https://git.libelektra.org/blob/debian/debian/copyright)
  in `debian/copyright` in the `debian` branch, thanks to Thomas Wahringer.
- Various fixes in doc/METADATA.ini

## 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 executed old test cases against the latest Elektra version and all
tests passed.

In `kdbinvoke.h` we changed the API so that `elektraInvokeOpen`
and `elektraInvokeClose` can yield error messages.

We added:

- the public headerfiles `kdbnotification.h`, `kdbio.h`, `kdbiotest.h`.
- the private headerfiles `kdbnotificationplugin.h`, `kdbioprivate.h`.

## Portability

- Fix bash shebang of bash scripts, thanks to Jakub Jirutka
- Remove unportable unneeded asm, thanks to Timo Teräs and Jakub Jirutka
- Fixed syntax in shell recorder, thanks to René Schwaiger
- Used `mktemp` in `check_distribution.sh` to allow parallel run of test cases,
  thanks to Armin Wurzinger.

## Notes for Maintainer

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

- `dini` is no longer experimental.
- CMake: `BINDINGS` now behaves like `PLUGINS`
  By default now all MAINTAINED bindings except EXPERIMENTAL and DEPRECATED are included.
  For more details see
  [/doc/COMPILE.md](https://github.com/ElektraInitiative/libelektra/tree/master/doc/COMPILE.md).
  To include both intercept bindings, you now need to write `INTERCEPT`, to only include getenv
  interception `intercept_env`. `intercept` in lower-case does not work anymore.

The following files are new:

- Libs: `libelektra-notification.so`, `libelektra-io.so`, `libelektra-io-uv.so`, `libelektra-pluginprocess.so`
- Headers: `kdbgetenv.h`, `kdbio.h`, `kdbpluginprocess.h`
- Plugins: `base64/Base64.pdf`
- Binaries: `getenv`, `test_context`, `test_fork`, `test_getenv`, `test_ks_opmphm`, `test_opmphm`
- Other: `elektra-io.pc`

The following files were removed:

- Tests: `testmod_semlock`

## Notes for Elektra's Developers

These notes are of interest for people developing Elektra:

- We now use `clang-reformat-5.0` for formatting.
  Please upgrade your clang.
- Build Agent `ryzen v2` was added to speed up `jenkins build all please`,
  thanks to Armin Wurzinger.
- Travis maintenance (Qt 5 and other problems),
  thanks to René Schwaiger.
- `BINDINGS` was greatly improved and the CMake functions were simplified.
  Bindings now also have a `README.md` with metadata.
  A big thanks to Thomas Wahringer.
- Decision: Logging with `ELEKTRA_LOG` is only for C/C++.
- Including `kdberrors.h` in a C++ files now also works, if you do not add the statement

  ```cpp
  using namespace ckdb;
  ```

  before you import `kdberrors.h`.

- The CMake code for Elektra’s [Qt-GUI](https://www.libelektra.org/tools/qt-gui) now detects the location of Qt 5 automatically if you
  installed Qt via Homebrew.
- All Shell Recorder tests should not now correctly restore your old configuration after you execute them,
  thanks to René Schwaiger.
- The [Base64 plugin](https://www.libelektra.org/plugins/base64) does not encode empty binary values in meta mode anymore. This update allows plugins such as YAML CPP to handle empty keys properly.

## Fixes

Many problems were resolved with the following fixes:

- `kdb global-umount` also removed other mountpoints
- We fixed [internal inconsistency](https://github.com/ElektraInitiative/libelektra/pull/1761) in the CMake code of the [Augeas plugin](https://www.libelektra.org/plugins/augeas)
- We fixed the [haskell bindings and plugins on Debian Stretch](https://github.com/ElektraInitiative/libelektra/pull/1787)
  and added a new build server job to test that in the future.
- Cleanup in list plugin, thanks to Thomas Wahringer
- The Shell Recorder now exports and imports the root of a mountpoint instead of the mountpoint itself. This change makes sure that Shell
  Recorder test do not change the configuration directly below the specified mountpoint.

## Get It!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.22.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.22.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.22.tar.gz.hashsum?raw=true)

- name: elektra-0.8.22.tar.gz
- size: 5885118
- md5sum: 5cbd9e33daf51f6f33791ff3f99342a6
- sha1: 4954ff16cfe7dc69e45e6a748556262b8fb1a9fa
- sha256: 962598315619d5dff3a575d742720f076dc4ba3702bd01609bfb7a6ddb5d759f

The release tarball is also available signed by me using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.22.tar.gz.gpg) or
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases//elektra-0.8.22.tar.gz.gpg?raw=true)

Already built API documentation can be found [online](https://doc.libelektra.org/api/0.8.22/html/)
or [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.8.22).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
issue tracker [on GitHub](http://issues.libelektra.org)
or me by email using elektra@markus-raab.org.

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.8.22-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 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](https://libelektra.org).

For a small demo see here:

[![asciicast](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r.png)](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r)

You can also read the news [on our website](https://www.libelektra.org/news/0.8.23-release)

## 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](https://www.libelektra.org/plugins/dbus#notification-format).

For more details see the
[notification tutorial](https://github.com/ElektraInitiative/libelektra/tree/master/doc/tutorials/notifications.md)
or the
[example applications](https://master.libelektra.org/examples).

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](https://master.libelektra.org/doc/api_blueprints/elektrad.apib)
  and [webd](https://master.libelektra.org/doc/api_blueprints/webd.apib) (former clusterd).

[Read here to get started](https://www.libelektra.org/tools/web).

> 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](https://github.com/ElektraInitiative/libelektra/blob/master/scripts/jenkins/Jenkinsfile).

Daily builds Debian packages for Stretch are available again in our
[stretch repository](https://debian-stretch-repo.libelektra.org).
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](https://www.libelektra.org/bindings/io_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](https://www.libelektra.org/plugins/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](https://www.libelektra.org/ftp/elektra/publications/nirschl2018cryptographic.pdf)
  ([signature](https://www.libelektra.org/ftp/elektra/publications/nirschl2018cryptographic.pdf.sig)).
  It includes a benchmark of different cryptographic providers.
- Markus Raab gave a [talk](https://cfp.linuxwochen.at/de/LWW18/public/events/798) at Linuxwochen Wien (in German).
  For similar talks in English, please refer to the [FOSDEM talks](https://fosdem.org/2018/schedule/speaker/markus_raab/).
- We replaced the word "project" to "initiative" in the [Code of Conduct](https://www.libelektra.org/devgettingstarted/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?](https://www.libelektra.org/docgettingstarted/faq)
- Documentation about the recommended [environment](https://www.libelektra.org/devgettingstarted/testing) 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](https://www.libelektra.org/docgettingstarted/meta-specification):
  - added visibility (as used in Web UI)
  - added type (only check/type existed)
  - plenty of metadata is now used by Web UI
- update documentation 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](https://master.libelektra.org/doc/decisions/deferred_plugin_calls.md) 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:

- Documentation is updated that [CMake3](https://cmake.org/cmake/help/v3.0/) 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](https://www.libelektra.org/docgettingstarted/faq) is now
  more visible (added to "getting started").
- The [Code of Conduct](https://www.libelektra.org/devgettingstarted/code-of-conduct)
  was added.

## Notes for Elektra's Developers

These notes are of interest for people developing Elektra:

- `. run_env` is a script to be sourced from the build directory.
  It sets environment variables, so that Elektra from the build
  directory is used (instead of the installed one).
- All current versions of Clang-Format (6.0+) and the outdated Clang-Format 5 will now produce exactly the same output for the whole codebase,
  thanks to René Schwaiger.
- To make enums nicely formatting, make sure at least one member
  is documented.
- You can now add a [Markdown Shell Recorder][] test for a plugin
  via the CMake function `add_plugin` by adding `TEST_README`.
  Furthermore `TEST_REQUIRED_PLUGINS` allows us to specify which
  additional plugins are required,
  thanks to René Schwaiger
- `const` was added to exceptions in catch blocks
  thanks to René Schwaiger
- We now mention to read [doc/DESIGN.md](https://master.libelektra.org/doc/DESIGN.md)
  in the contributing guidelines.
- The CMake functions

  - `add_plugin`
  - `add_msr_test`
  - `add_msr_test_plugin`, and the new
  - `add_shell_recorder_test`

  now allow you to specify a list of required plugins for [Shell Recorder][] and
  Markdown Shell Recorder tests.

- The [Markdown Shell Recorder][] now compares the whole output of `stderr` with the text following the directive `STDERR:`,
  thanks to René Schwaiger
- You can now leave the text following the directive `STDERR:` in a [Markdown Shell Recorder][] test empty:

  ```sh
  true # Print nothing to `stderr`
  # STDERR:
  ```

  . The Markdown Shell Recorder will then check if the command printed nothing to the standard error output.

- The [Shell Recorder][] now also prints the content of the protocol file if a test was unsuccessful or you used the command switch `-p`,
  and always cleans up the protocol,
  thanks to René Schwaiger
- We added an [Markdown Shell Recorder][] test for the [Constants](http://libelektra.org/plugins/constants) plugin.
- The [Markdown Shell Recorder][] now prints the path of the test file.
  thanks to René Schwaiger
- The Haskell binding now explicitly requires GHC installed with a minimum version of 8.0.0 during cmake
  thanks to René Schwaiger and Lukas Winkler
- If any of the tests in `make run_memcheck` fail valgrind will now set an exit-code which will get picked up by make,
  thanks to Lukas Winkler
- We introduced Git reference repositories to save I/O on our build system,
  thanks to Lukas Winkler
- Set `LD_LIBRARY_PATH` in all tests removing the need to specify it for running ctest,
  thanks to Lukas Winkler
- Provide the `RUN_SERIAL` property to all tests that can not be run in parallel,
  thanks to Lukas Winkler
- Speeding up your test runs via `ctest -j` is now possible,
  thanks to Lukas Winkler
- We now disable the [Xerces plugin](http://libelektra.org/plugins/xerces) if you use GCC with enabled ASAN to build Elektra. This update
  makes sure that you do not build the plugin with compilation settings that are known to
  [cause problems](https://github.com/ElektraInitiative/libelektra/issues/1895).
- Documentation and debugging capabilities of [Markdown Shell Recorder][] were improved.
- We added style guidelines for CMake code to
  [`doc/CODING.md`](https://github.com/ElektraInitiative/libelektra/blob/master/doc/CODING.md#cmake-guidelines).

[markdown shell recorder]: https://master.libelektra.org/tests/shell/shell_recorder/tutorial_wrapper
[shell recorder]: https://master.libelektra.org/tests/shell/shell_recorder

## Fixes

Many problems were resolved with the following fixes:

- [YAML CPP](http://libelektra.org/plugins/yamlcpp) now also saves key values directly below a mountpoint correctly,
  thanks to René Schwaiger
- If you use a minimal configuration ([`dump`](http://libelektra.org/plugins/dump), [`resolver`](https://www.libelektra.org/plugins/resolver), list, and spec), all test of the test suite now finish successfully again,
  thanks to René Schwaiger
- small refactoring in `kdb-test`
- The Haskell plugin failed to build if the Haskell bindings were not included explicitly by name.
- Fix invalid handling of keynames in the [spec](http://libelektra.org/plugins/spec) plugin.
- The [Shell Recorder][] counts the number of executed tests properly again.
- CMake now fails if the required plugins [list](http://libelektra.org/plugins/list) or [spec](http://libelektra.org/plugins/spec) (on
  non-[MinGW](http://mingw.org) platforms) are missing from the current build configuration.
- The [Lua](http://libelektra.org/plugins/lua), [Python 2](http://libelektra.org/plugins/python2),
  [Python](http://libelektra.org/plugins/python), and [Ruby](http://libelektra.org/plugins/ruby) plugins now require SWIG bindings for
  the corresponding programming language,
  thanks to René Schwaiger
- The [type checker](https://www.libelektra.org/plugins/type) now also honors `type` next to `check/type`
- Fix various compiler warnings
- The detection of Botan, Libgcrypt, LibGit2 and OpenSSL now also works properly, if we treat warnings as errors (compiler switch `-Werror`),
  thanks to René Schwaiger
- The [multifile plugin](http://libelektra.org/plugins/multifile) now passes the child config
  to the storage plugins too and also handles symlinks correctly,
  thanks to Thomas Waser

## Workshop

[Elektra Initiative](https://www.libelektra.org/developers/authors) are the people behind Elektra.
Our goal is to build up expertise with configuration settings and improve the situation in the FLOSS landscape.
To learn more about the needs of configuration-wise non-trivial FLOSS applications, we have workshops.
After a successful workshop with the LCDproc's maintainer, the next Workshop will be with people from KDE.

We will use the opportunity of [Akademy](https://akademy.kde.org/2018) being in Vienna.
We already got positive feedback from kconfig maintainers (David Faure and Aleix Pol).

If you are interested, you can sign up.
We are looking forward to an informative, interactive and interesting workshop!

## Outlook

We are currently working on following topics:

- Klemens Böswirth: [elektrifying LCDproc](https://www.libelektra.org/news/elektrify-lcdproc)
  After some setbacks (the two original developers who wanted to work on LCDproc resigned because of job duties)
  LCDproc development restarted now successfully.
  The new plan is to have more intermediate stages.
  In particular the first integration will be a minimal invasive integration without high-level API.
- Armin Wurzinger: type system for Elektra's specification language
- Anton Hössl: Puppet
- Daniel Bugl: Web UI
- Hani Torabi Makhsos: reduce community entry barriers
- Kurt Micheli: order preserving minimal perfect hash map
- Lukas Winkler: continous integration
- Mihael Pranjić: mmap plugin (i.e. avoiding reparsing of configuration files)
- Peter Nirschl: integrity and confidentiality
- René Schwaiger: parsing techniques
- Thomas Wahringer: notification techniques
- Thomas Waser: Linux distribution based on Elektra
- Ulrike Schaefer: generate shell completion files from Elektra's specification
- Vanessa Kos: misconfiguration bug database
- We created a proof of concept for a Chef resource and an Ansible module successfully setting Elektra's keys.
  They are not yet published. If you are interested on this preliminary work, please contact us.

## Get It!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.23.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.23.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.23.tar.gz.hashsum?raw=true)

- name: elektra-0.8.23.tar.gz
- size: 5870069
- md5sum: 0a065ed381a59b6213bd46fd3c82ba83
- sha1: 0727b420ff721e654b0ba6ab1d0c78e5e2341d26
- sha256: f1d3cd4888ba3ef47c1327cbddf21dff7be289f94217f12e5e93105273ca6c48

The release tarball is also available signed by Markus Raab using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.23.tar.gz.gpg) or
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases//elektra-0.8.23.tar.gz.gpg?raw=true)

Already built API documentation can be found [online](https://doc.libelektra.org/api/0.8.23/html/)
or [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.8.23).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
issue tracker [on GitHub](http://issues.libelektra.org)
or Markus Raab by email using elektra@markus-raab.org.

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.8.23-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 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](https://libelektra.org).

For a small demo see here:

[![asciicast](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r.png)](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r)

You can also read the news [on our website](https://www.libelektra.org/news/0.8.24-release)

## 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!

[![Elektra Web 1.6 video](https://img.youtube.com/vi/lLg9sk6Hx-E/0.jpg)](https://www.youtube.com/watch?v=lLg9sk6Hx-E)

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](https://issues.libelektra.org/2037))

#### 1.6 changelog:

- fixed bugs related to arrays ([#2103](https://issues.libelektra.org/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](https://doc.libelektra.org/api/latest/html/group__kdbnotification.html)
  now supports more types and has improved support for callbacks.
- With the addition of the [zeromqsend](https://www.libelektra.org/plugins/zeromqsend)
  and [zeromqrecv](https://www.libelektra.org/plugins/zeromqrecv) plugins
  together with the [hub-zeromq](https://www.libelektra.org/tools/hub-zeromq)
  tool we have an alternative to the D-Bus transport plugins
  ([dbus](https://www.libelektra.org/plugins/dbus) and
  [dbusrecv](https://www.libelektra.org/plugins/dbusrecv)).
- The new asynchronous I/O binding for [ev](https://www.libelektra.org/bindings/io_ev)
  is the third I/O binding - so notifications can be used in applications using
  [glib](https://www.libelektra.org/bindings/io_glib), [uv](https://www.libelektra.org/bindings/io_uv)
  or [ev](https://www.libelektra.org/bindings/io_ev).
  If your application uses a different library please check out the
  ["How to create your own I/O binding" section](https://www.libelektra.org/tutorials/notifications#how-to-create-your-own-i-o-binding) in the [notification tutorial](https://www.libelektra.org/tutorials/notifications).
- 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](https://www.libelektra.org/tutorials/notifications#howto-reload-kdb-when-elektras-configuration-has-changed)
  that explains the required steps and the ["notificationReload"](https://www.libelektra.org/examples/notificationreload) example with the complete code.

More details can be [found](#zeromq-transport-plugins) [in](#misc) [this](#bindings) [news](#notifications).
Check out the updated [notification tutorial](https://www.libelektra.org/tutorials/notifications)
and notification examples ([polling](https://www.libelektra.org/examples/notificationpolling),
[async](https://www.libelektra.org/examples/notificationasync) and
[reload](https://www.libelektra.org/examples/notificationreload).

### KDE Workshop

At [Akademy 2018](https://akademy.kde.org/2018) we had a successful
[Config Workshop](https://community.kde.org/Akademy/2018/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](http://www.complang.tuwien.ac.at/raab/akademy.pdf)

### 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](https://www.libelektra.org/plugins/typechecker)

Thanks to Armin Wurzinger.

### Chef Cookbook

Next to the [Puppet Resource Type](http://puppet.libelektra.org/)
we now also prepared a [Chef Cookbook](https://supermarket.chef.io/cookbooks/kdb)
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](http://oclint.org). _(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](https://www.libelektra.org/plugins/cpptemplate). To create a plugin based on this
  template, please use the command

  ```sh
  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 behavior of export to validate the structure of exported keys only. _(Thomas Waser)_

### Directory Value

- We rewrote the plugin using C++. _(René Schwaiger)_
- [Directory Value](https://www.libelektra.org/plugins/directoryvalue) 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](https://www.libelektra.org/plugins/hexnumber) has been added. It can be used
  to convert hexadecimal values into decimal when read, and back to hexadecimal when written. _(Klemens Böswirth)_

### List

- The [`list` plugin](http://libelektra.org/plugins/list) now allows us to pass
  common configuration for all plugins by using keys below the "config/" setting.
  The updated plugin documentation contains more information and an example. _(Thomas Wahringer)_
- The [`list` plugin](http://libelektra.org/plugins/list) which is responsible
  for global mounting had a bug which prevented globally mounted plugins from
  being configurable. _(Thomas Wahringer)_

### mINI

- We fixed a memory leak in the [mINI plugin](https://libelektra.org/plugins/mini) by requiring the plugin
  [`ccode`](https://libelektra.org/plugins/ccode) instead of the “provider” `code`. _(René Schwaiger)_
- Removed unused header files. _(René Schwaiger)_

### network

- Fixed an error in network plugin that prevented it from working on non-glibc
  platforms. _(Lukas Winkler)_

### Type

- We extended the [Markdown Shell Recorder][] example inside the [README of the plugin](https://www.libelektra.org/plugins/type).
  _(René Schwaiger)_

### Regex Dispatcher

- The plugin [regexdispatcher](https://www.libelektra.org/plugins/regexdispatcher) has been added.
  It calculates regex representations for commonly used specification keywords to be used with the
  [typechecker](https://www.libelektra.org/plugins/typechecker). Currently the keywords `check/range`,
  `check/enum` and `default` are supported. _(Armin Wurzinger)_

### Typechecker

- The plugin [typechecker](https://www.libelektra.org/plugins/typechecker), used to validate
  configuration specifications for Elektra statically, has been improved under the hood. It now
  supports a more concise and efficient type checking process including a greatly
  improved type inference scheme that should make generated specification files and thus
  generated errors to be easier to understand. An example of such error message is shown in the
  [README](https://www.libelektra.org/plugins/typechecker). _(Armin Wurzinger)_

### Tcl

- The [`tcl`](http://libelektra.org/plugins/tcl) plugin does not fail anymore, if its configuration file does not exist and you try to
  retrieve the plugin contract. _(René Schwaiger)_
- The plugin now uses relative key names. This update addresses issue [#51](https://issues.libelektra.org/51). _(René Schwaiger)_

### YAJL

- The [YAJL Plugin](http://libelektra.org/plugins/yajl) now uses the internal logger functionality instead of `printf` statements.
  _(René Schwaiger)_
- We fixed a problem with negative values reported by the
  [UndefinedBehaviorSanitizer](https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html). _(René Schwaiger)_

### YAML CPP

- The plugin does not save empty intermediate keys anymore. The example below shows the old and the new behavior of the plugin:

  ```sh
  # Mount plugin
  kdb mount config.yaml /tests/yamlcpp yamlcpp
  # Store single key-value pair
  kdb set /tests/yamlcpp/level1/level2/level3 value

  # Old behavior
  kdb ls /tests/yamlcpp
  #> user/tests/yamlcpp/level1
  #> user/tests/yamlcpp/level1/level2
  #> user/tests/yamlcpp/level1/level2/level3

  # New behavior
  kdb ls /tests/yamlcpp
  #> user/tests/yamlcpp/level1/level2/level3
  ```

  . _(René Schwaiger)_

- [YAML CPP](http://libelektra.org/plugins/yamlcpp) now requires at least `yaml-cpp 0.6`, since the current
  [MSR test for the plugin](https://master.libelektra.org/src/plugins/yamlcpp/README.md) triggers two bugs:

  - https://github.com/jbeder/yaml-cpp/issues/247
  - https://github.com/jbeder/yaml-cpp/issues/289

  in earlier versions of the [yaml-cpp library](https://github.com/jbeder/yaml-cpp). _(René Schwaiger)_

- The plugin does now support [arrays](https://www.libelektra.org/tutorials/arrays) containing empty fields. _(René Schwaiger)_
- YAML CPP now also adds `array` metadata for arrays containing arrays. _(René Schwaiger)_
- The plugin now also supports empty arrays:

  ```sh
  kdb mount test.yaml user/tests/yamlcpp yamlcpp
  kdb setmeta user/tests/yamlcpp/array array ''
  kdb export user/tests/yamlcpp/array yamlcpp
  #> []
  ```

  .

- YAML CPP now handles null values containing metadata properly:

  ```sh
  kdb mount test.yaml user/tests/yamlcpp yamlcpp
  kdb set user/tests/yamlcpp/null
  kdb setmeta user/tests/yamlcpp/null comment 'Null Key'
  kdb export user/tests/yamlcpp/null yamlcpp
  #> !<!elektra/meta>
  #> - ~
  #> - comment: Null Key
  ```

  .

### YAML Smith

- [YAML Smith](http://libelektra.org/plugins/yamlsmith) is a plugin that converts Elektra’s `KeySet` data structure to a textual
  representation in the [YAML][] serialization format. The plugin is currently in a **very early stage of development**. Please be advised,
  that it is quite likely that the plugin will produce incorrect or even invalid YAML data, especially if your `KeySet` contains special
  characters.

### Yan LR

- The experimental [Yan LR plugin](http://libelektra.org/plugins/yanlr) uses a parser, generated by [ANTLR](http://www.antlr.org) to read
  basic [YAML][] data. The plugin only converts YAML data to Elektra’s `KeySet` data structure. If you want to write data in the YAML
  format please take a look at the [YAML Smith plugin](http://libelektra.org/plugins/yamlsmith). _(René Schwaiger)_

### ZeroMQ transport plugins

- New notification transport plugins for [ZeroMQ](http://zeromq.org/) were added.
  The new ["zeromqsend"](https://www.libelektra.org/plugins/zeromqsend) and ["zeromqrecv"](https://www.libelektra.org/plugins/zeromqrecv) plugins use
  `ZMQ_PUB` and `ZMQ_SUB` sockets to send and receive notifications.
  The plugins can be used instead or along with the
  ["dbus"](https://www.libelektra.org/plugins/dbus) and
  ["dbusrecv"](https://www.libelektra.org/plugins/dbusrecv) transport plugins.
  Check out the
  [plugin documentation](https://www.libelektra.org/plugins/zeromqrecv) for more
  information. _(Thomas Wahringer)_

### Misc

- The logging plugins ["syslog"](https://www.libelektra.org/plugins/syslog),
  ["journald"](https://www.libelektra.org/plugins/journald) and
  ["logchange"](https://www.libelektra.org/plugins/logchange) now have a new
  option called "get" which can be enabled to log which configuration settings
  are loaded by applications.
  The new option can be used for logging application behavior when using
  [notifications](https://www.libelektra.org/tutorials/notifications). _(Thomas Wahringer)_
- Do not exclude `simpleini` silently on non-glibc systems but output a message
  like for other plugins _(Markus Raab)_
- We updated the `infos/status` clause of the following plugins:

  - [`boolean`](http://libelektra.org/plugins/boolean),
  - [`constants`](http://libelektra.org/plugins/constants),
  - [`csvstorage`](http://libelektra.org/plugins/csvstorage),
  - [`hexnumber`](http://libelektra.org/plugins/hexnumber),
  - [`internalnotification`](http://libelektra.org/plugins/internalnotification),
  - [`ruby`](http://libelektra.org/plugins/ruby),
  - [`simpleini`](http://libelektra.org/plugins/simpleini),
  - [`uname`](http://libelektra.org/plugins/uname), and
  - [`xerces`](http://libelektra.org/plugins/xerces)

  . _(René Schwaiger)_

[yaml]: http://yaml.org

## Libraries

### General

- Replaced `strdup` with `elektraStrDup` (for C99 compatibility). _(Markus Raab)_
- You can now remove the basename of a key via the C++ API by calling `key.delBaseName()`. _(René Schwaiger)_
- The function `elektraArrayGetNextKey` now uses `NULL` instead of the empty string as init value for the returned key. _(René Schwaiger)_

### pluginprocess

- The library [`pluginprocess`](http://master.libelektra.org/src/libs/pluginprocess) that is used to
  execute plugins run inside own processes has been improved. This is useful as some plugins like
  Haskell-based plugins or [`python`](http://libelektra.org/plugins/python) can only be started once
  inside a single process, while libelektra may call a plugin several times. The library now uses an
  improved communication protocol that separates between pluginprocess-related data and keysets
  passed to plugins. This avoids any possible name clashes between keys used by a plugin and keys
  used by pluginprocess.
  The documentation of the plugin has been improved as well, some mistakes were corrected and it
  should be more clear how to store plugin data besides pluginprocess's data structure.
  Tests have been added to the library to ensure its correct functionality. _(Armin Wurzinger)_
- Anonymous pipes are now used instead of named pipes for the communication as anonymous pipes get
  terminated by the OS in case a child process dies before writing back data to the parent.
  Currently the parent process will freeze otherwise attempting to read from the child. _(Armin Wurzinger)_

## Bindings

- A new I/O binding for [ev](https://www.libelektra.org/bindings/io_ev) has been
  added.
  It can be used to integrate the notification feature with applications based
  on [ev](http://libev.schmorp.de) main loops. _(Thomas Wahringer)_

## Notifications

- The
  [notification API](https://doc.libelektra.org/api/latest/html/group__kdbnotification.html)
  was extended.
  The API now supports more types: `int`, `unsigned int`,
  `long`, `unsigned long`, `long long`, `unsinged long long`, `float` and `double`.
  It also supports all of Elektra's `kdb_*_t` types defined in `kdbtypes.h`.
  Also contexts for callbacks were added and
  `elektraNotificationRegisterCallbackSameOrBelow()` allows for notifications
  for the registered key or below. _(Thomas Wahringer)_

## Tools

- The new tool `kdb find` lists keys of the database matching a certain regular expression. _(Markus Raab)_
- You can now build the [Qt-GUI](https://www.libelektra.org/tools/qt-gui) using Qt `5.11`. _(René Schwaiger)_

## Scripts

- The script [`check_formatting.sh`](https://master.libelektra.org/tests/shell/check_formatting.sh) now also checks the formatting of CMake
  code if you installed [`sponge`](https://joeyh.name/code/moreutils) and [`cmake-format`][]. _(René Schwaiger)_
- The script [`check_formatting.sh`](https://master.libelektra.org/tests/shell/check_formatting.sh) now no longer writes to stdout if clang-format5.0
  can not be found. _(Lukas Winkler)_
- The script [`check_bashisms.sh`](https://master.libelektra.org/tests/shell/check_bashisms.sh) should now work correctly again, if the
  system uses the GNU version `find`. _(René Schwaiger)_
- The script [`reformat-cmake`](https://master.libelektra.org/scripts/dev/reformat-cmake) now checks if `cmake-format` works before it reformats CMake files. Thank you to Klemens Böswirth for the [detailed description of the problem](https://github.com/ElektraInitiative/libelektra/pull/1903#discussion_r189332987). _(René Schwaiger)_
- `scripts/build/run_icheck` now no longer leaves the base directory of the project
  when checking if the ABI changed. _(Lukas Winkler)_
- The completion for [fish](http://fishshell.com) now also suggest the `info/` meta attributes of the
  [file plugin](https://www.libelektra.org/plugins/file). _(René Schwaiger)_

### Copy Template

- The script [`copy-template`](https://master.libelektra.org/scripts/dev/copy-template) is now location independent. It will always create a
  new plugin in `src/plugins`. _(René Schwaiger)_
- The command now also supports the new [template for C++ based plugins](https://www.libelektra.org/plugins/cpptemplate). Please use the
  command line switch `-p` to create a new plugin based on `cpptemplate`.

[`cmake-format`]: https://github.com/cheshirekow/cmake_format

## Documentation

- We improved the formatting of our [compilation guide](/doc/COMPILE.md). _(René Schwaiger)_
- We fixed various minor spelling mistakes in the documentation. _(René Schwaiger)_
- The man pages for [`kdb change-resolver-symlink`](https://www.libelektra.org/man-pages/kdb-change-resolver-symlink) and
  [`kdb change-storage-symlink`](https://www.libelektra.org/man-pages/kdb-change-storage-symlink) referenced the wrong command.
  _(Lukas Winkler, René Schwaiger)_
- We added documentation for our build system in
  [BUILDSERVER.md](https://master.libelektra.org/doc/BUILDSERVER.md).
  _(Lukas Winkler)_
- The documentation for `kdb` and `kdb set` now mentions the `--` argument that stops processing of command line switches. This is useful
  for setting negative values among other things. _(Klemens Böswirth)_
- We added a new tutorial about the jna binding. The tutorial shows how to use the java library to interact with kdb _(Michael Zronek)_
- GitHub now detects the license of the repository correctly again. _(René Schwaiger)_
- We added a tutorial describing Elektra’s [array data type](https://www.libelektra.org/tutorials/arrays). _(René Schwaiger)_

## Tests

### (Markdown) Shell Recorder

- We added new [Markdown Shell Recorder][] tests for the
  - [`ccode`](https://www.libelektra.org/plugins/ccode),
  - [`file`](https://www.libelektra.org/plugins/file),
  - [`iconv`](https://www.libelektra.org/plugins/iconv),
  - [`ni`](https://www.libelektra.org/plugins/ni),
  - [`rename`](https://www.libelektra.org/plugins/rename), and
  - [`uname`](https://www.libelektra.org/plugins/uname)
    plugin. _(René Schwaiger)_
- (Markdown) Shell Recorder tests now save test data below `/tests` (see issue [#1887][]). _(René Schwaiger)_
- The Markdown Shell Recorder checks `kdb set` commands to ensure we only add tests that store data below `/tests`. _(René Schwaiger)_
- The Markdown Shell Recorder now supports indented code blocks. _(René Schwaiger)_
- The Markdown Shell Recorder now also tests if a command prints nothing to `stdout` if you add the check `#>`. _(René Schwaiger)_
- We fixed some problems in the [Markdown Shell Recorder](https://master.libelektra.org/tests/shell/shell_recorder/tutorial_wrapper) test
  of [`kdb ls`](https://master.libelektra.org/doc/help/kdb-ls.md). _(René Schwaiger)_
- The [Shell Recorder][] now does not interpret `-` in checks as option character any more. _(René Schwaiger)_
- The `add_plugin` helper now respects `ENABLE_KDB_TESTING` when adding
  Markdown Shell Recorder tests. _(Lukas Winkler)_
- The Markdown Shell Recorder test for [`kdb find`](https://master.libelektra.org/doc/help/kdb-find.md) now removes the configuration file
  at the end of the test. _(René Schwaiger)_
- The [Shell Recorder][] now properly unmounts any additional mountpoints created
  during a test. _(René Schwaiger)_
- We removed the broken auto unmounting feature from the [Markdown Shell Recorder][]. _(René Schwaiger)_
- The [Markdown Shell Recorder][] does not require a `bash` compatible shell anymore. _(René Schwaiger)_

[#1887]: https://github.com/ElektraInitiative/libelektra/issues/1887
[markdown shell recorder]: https://master.libelektra.org/tests/shell/shell_recorder/tutorial_wrapper
[shell recorder]: (https://master.libelektra.org/tests/shell/shell_recorder)

### General

- Plugins added with the flag `SHARED_ONLY` no longer get tested in the script `check_kdb_internal_check.sh` if executed with kdb-full or kdb-static. _(Armin Wurzinger)_
- Add `compare_regex_to_line_files` which allows to compare a file made of
  regex patterns to be compared with a text file line by line.
  _(Lukas Winkler)_
- The OPMPHM has a new test case _(Kurt Micheli)_
- Do not execute `fcrypt` and `crypto` unit tests if the `gpg` binary is not available. _(Peter Nirschl)_
- Resolved an issue where tests did not cleanup properly after they ran.
  This was especially noticeable for `gpg` tests as the `gpg-agents` that were
  spawned did not get cleaned up afterwards. _(Lukas Winkler)_
- We disabled the general plugin test (`testkdb_allplugins`) for the [`semlock` plugin](https://libelektra.org/plugins/mini), since the
  test reported [memory leaks](https://issues.libelektra.org/2113) on the latest version of Debian Unstable. _(René Schwaiger)_
- The [CFramework](https://master.libelektra.org/tests/cframework) macro `compare_keyset` now supports the comparison of two empty key sets. _(René Schwaiger)_
- The C++ version of the macro `exit_if_fail` now really exits the test progamm if the test fails. _(René Schwaiger)_
- The C++ testing framework now supports the macro `compare_keyset` that checks if two key sets are equal. _(René Schwaiger)_

## Build

As written in the previous release notes:

- Debian Wheezy is not supported anymore.
- Jessie (oldstable) with gcc 4.8.4 is now the oldest supported platform.

Another important change is:

- We now import the current version of [Google Test][] as external project at configuration time using
  [DownloadProject](https://github.com/Crascit/DownloadProject). If you want to use a local installation of
  [Google Test][] instead, please set the value of `GTEST_ROOT` to the path of you local copy of the
  [Google Test][] framework. _(René Schwaiger)_
- The CMake variable `GTEST_ROOT` now respects the environment variable
  `GTEST_ROOT` if it is set. _(Lukas Winkler)_

### CMake

- The build system no longer installs Haskell dependencies from hackage by itself, instead
  this has to be done beforehand like it is the case with all other dependencies. The main
  reason is that the build servers shouldn't compile the dependencies over and over again,
  only if something changes. _(Armin Wurzinger)_
- Plugins can be specified to be only built for `BUILD_SHARED` builds, but to be excluded
  from any `BUILD_FULL` or `BUILD_STATIC` builds using the new optional argument `ONLY_SHARED`
  for our CMake macro `add_plugin`. This way `BUILD_SHARED` can be combined with the other
  options without excluding such plugins. The CMake messages about plugin inclusion have
  been updated to indicate this behavior. This behavior has been applied for the Haskell
  plugins- and bindings and JNI plugin as they currently don't support full or static builds.
  _(Armin Wurzinger)_
- The build system does not install [Google Test][] anymore if you install Elektra. _(René Schwaiger)_
- We disabled the test `testlib_notification` on ASAN enabled builds, since Clang reports that the test leaks memory. _(René Schwaiger)_
- Disable Markdown Shell Recorder test `validation.md` for ASAN builds.
  It leaks memory and thus fails the test during spec mount. _(Lukas Winkler)_
- Haskell plugins and bindings are now correctly excluded when using `BUILD_FULL` or `BUILD_STATIC`
  as this is currently unsupported. Another issue when building Haskell plugins with a cached sandbox
  is fixed as well. _(Armin Wurzinger)_
- Fix compilation with `BUILD_TESTING=OFF` when `spec` or `list` plugins are not selected.
- Set coverage prefix to `PROJECT_SOURCE_DIR`, resulting in easier readable
  coverage reports. _(Lukas Winkler)_
- The functions `add_plugintest` and `add_plugin` now also support adding a C++ test instead of a C test. _(René Schwaiger)_
- The function `add_plugintest` now also supports setting environment variables for C/C++ based tests. _(René Schwaiger)_
- The build system now automatically detects Homebrew’s OpenSSL version on macOS. _(René Schwaiger)_
- We improved the automatic detection of Libgcrypt and OpenSSL. _(René Schwaiger)_
- Resolved an issue where CMake did not properly set test feature macros to detect and use libc functionality. _(Lukas Winkler)_
- Improve the detection of `ftw.h`, if the current build use the compiler switch `-Werror`. _(René Schwaiger)_
- We now ignore warnings about

  - zero size arrays (Clang),
  - variadic macros (Clang, GCC),
  - conversions to non-pointer type (GCC), and
  - attribute warnings (GCC),

  caused by code generated via [SWIG](http://www.swig.org) in the Ruby binding and plugin. _(René Schwaiger)_

[google test]: https://github.com/google/googletest

### Docker

- `clang-5.0` is now used for clang tests by the build system _(Lukas Winkler)_
- An additional build job on Ubuntu:xenial has been added _(Lukas Winkler)_
- `withDockerEnv` Jenkinsfile helper now no longer provides stages automatically. _(Lukas Winkler)_
- [Google Test][] is installed in Docker images used by the build system. _(Lukas Winkler)_

## Infrastructure

### Jenkins

- A build job checks if PRs modify the release notes. _(Markus Raab)_
- Several improvements to the build system have been implemented _(Lukas Winkler)_:
  - Better Docker image handling.
  - Abort of previously queued but unfinished runs on new commits.
  - Document how to locally replicate the Docker environment used for tests.
- The Jenkins build server now also compiles and tests Elektra with enabled address sanitizer. _(Lukas Winkler)_
- Add `STATIC` and `FULL` linked builds. _(Lukas Winkler)_
- Ported GCC ASAN build job to new build system _(René Schwaiger + Lukas Winkler)_
- Docker artifacts are now cleaned up in our daily build job. _(Lukas Winkler)_
- `clang` tests have been ported to the new build system _(Lukas Winkler et al)_
- `icheck` build server job has been ported to our new build system. _(Lukas Winkler)_
- Port `elektra-gcc-configure-debian-optimizations` to new build system. _(Lukas Winkler)_
- Port `elektra-gcc-configure-mingw-w64` to new build system. _(Lukas Winkler)_
- Port `debian-multiconfig-gcc-stable` to new build system. _(Lukas Winkler)_
- Port `elektra-ini-mergerequests` to new build system. _(Lukas Winkler)_
- Port `elektra-gcc-configure-debian-nokdbtest` to new build system. _(Lukas Winkler)_
- Port `elektra-gcc-configure-xdg`to new build system. _(Lukas Winkler)_
- Port `elektra-gcc-i386` to new build system. _(Lukas Winkler)_
- Port `elektra-gcc-configure-debian-musl` to new build system. _(Lukas Winkler)_
- Docker Registry is cleaned up by our daily buildserver task. _(Lukas Winkler)_
- Remove `elektra-gcc-configure-debian-nokdbtest` test. Instead we are now
  removing write permissions of Elektra's paths to detect if we write to the
  filesystem even though tests are not tagged as such. _(Lukas Winkler)_
- Remove `elektra-gcc-configure-debian-withspace` test. We now test for
  compatibility of spaced build paths during normal tests. _(Lukas Winkler)_
- Check for source formatting during early test stages. _(Lukas Winkler)_
- Remove the amount of spawned tests via not running a full multiconfig setup for
  the `PLUGINS=NODEP` config. They did not provide any additional coverage.
  Instead we added a new test checking if `PLUGINS=NODEP` builds in an minimal
  Docker image. _(Lukas Winkler)_
- Speed up coverage data upload. _(Lukas Winkler)_
- Fix an issue where file archiving did not happen because of suppressed shell
  expansion _(Lukas Winkler)_
- Setup mailing for jenkins _(Lukas Winkler)_
  - send mail to build@libelektra.org when `master` fails _(Lukas Winkler)_
  - parse change list into mail _(Lukas Winkler)_
  - do not send mails if pipeline run was aborted _(Lukas Winkler)_

### Travis

- Travis now uses the latest version of GCC and Clang to translate Elektra on Linux. _(René Schwaiger)_
- Our Travis build job now
  - builds all (applicable) bindings by default again, and
  - checks the formatting of CMake code via [`cmake-format`][]
    . _(René Schwaiger)_
- Some cache issues on the Travis build job for cached Haskell sandboxes have been resolved. _(Armin Wurzinger)_
- Travis caches downloaded Homebrew packages to improve the reliability of macOS build jobs. _(René Schwaiger)_
- Travis is now using Xcode 9.4.1 on macOS 10.13 for most macOS build jobs. _(Mihael Pranjić)_
- We added a unique name to each build job, so you can see quickly which configuration caused problems. _(René Schwaiger)_
- We now specify custom binding, plugin and tool configuration for jobs via the environment variables:

  - `BINDINGS`,
  - `PLUGINS`, and
  - `TOOLS`

  . We also added environment variables for the build configuration options `BUILD_FULL`, `COMMON_FLAGS`, `ENABLE_ASAN` and the command
  used to test the build (`TEST_COMMAND`). _(René Schwaiger)_

- The ASAN build jobs `🍏 Clang ASAN` and `🐧 GCC ASAN` now only build the `kdb` tool and the `cpp` binding. This update ensures, that we
  do not hit the [job timeout for public repositories](https://docs.travis-ci.com/user/customizing-the-build/#build-timeouts) that often.
  _(René Schwaiger)_
- We now use the latest version of Ruby (`2.5.1`) to build and test the Ruby binding/plugin. _(René Schwaiger)_

## 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).

Following changes were made:

- The C++ API was extended with `delBaseName()`.
  This does not affect ABI compatibility, also C++ programs compiled against 0.8.24 and using `delBaseName()` will work with Elektra 0.8.23 or older.
- `kdbtypes.h` now comes with support for C99 types.
- We added the private headerfiles `kdbnotificationinternal.h`, `kdbioplugin.h`. _(Thomas Wahringer)_
- The I/O binding header files have been moved a new directory called `kdbio`.
  For example, instead of including `elektra/kdbio_ev.h` users of the binding now include `elektra/kdbio/ev.h`. _(Thomas Wahringer)_
- The plugin directoryvalue has changed its behavior, see above.
- The plugin list changed its configuration, see above.
- The plugin yamlcpp now gets excluded with too old versions of yamlcpp (Debian Stretch is affected).

The new plugins are:

- hexnumber
- yamlsmith
- zeromqrecv
- zeromqsend

The new tool is: kdb-find

## Website

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

## Outlook

We are currently working on following topics:

- The hybrid search algorithm for the Key search `ksLookup (...)` is now in preparation.
  The preparation includes a new KeySet flag `KS_FLAG_NAME_CHANGE`, this flag will be used by the hybrid search.
  The hybrid search combines the best properties of the binary search and the [OPMPHM](https://master.libelektra.org/doc/dev/data-structures.md#order-preserving-minimal-perfect-hash-map-aka-opmphm).
  The hybrid search uses a modified branch predictor to predicts KeySet changes and decides if binary search or OPMPHM would be faster. _(Kurt Micheli)_

## Statistics

Following persons made in total 1734 commits:

| Commits | Author                                             |
| ------- | -------------------------------------------------- |
| 1       | Mihael Pranjic <mpranj@limun.org>                  |
| 2       | Thomas Waser <thomas.waser@libelektra.org>         |
| 7       | Michael Zronek <michael.zronek@gmail.com>          |
| 12      | Kurt Micheli <e1026558@student.tuwien.ac.at>       |
| 17      | Peter Nirschl <peter.nirschl@gmail.com>            |
| 21      | Klemens Böswirth <k.boeswirth+git@gmail.com>       |
| 197     | Markus Raab <elektra@markus-raab.org>              |
| 102     | Thomas Wahringer <thomas.wahringer@libelektra.org> |
| 117     | Daniel Bugl <me@omnidan.net>                       |
| 265     | Lukas Winkler <derwinlu+git@gmail.com>             |
| 249     | Armin Wurzinger <e1528532@student.tuwien.ac.at>    |
| 744     | René Schwaiger <sanssecours@me.com>                |

In total there were 792 files changed with 27677 insertions(+) and 39176 deletions(-).

## Get It!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.24.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.24.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.24.tar.gz.hashsum?raw=true)

- name: elektra-0.8.24.tar.gz
- size: 6130464
- md5sum: 2e3def7b905f94e1f9f7fa0fe4743189
- sha1: ff2a9b2d3a5e20a456e272a47fe9fd79ad410428
- sha256: 454763dd00e95e774a907b26eb59b139cfc59e733692b3cfe37735486d6c4d1d

The release tarball is also available signed by Markus Raab using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.24.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases//elektra-0.8.24.tar.gz.gpg?raw=true)

Already built API documentation can be found [online](https://doc.libelektra.org/api/0.8.24/html/)
or [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.8.24).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

For any questions and comments, please contact the
issue tracker [on GitHub](http://issues.libelektra.org)
or Markus Raab by email using elektra@markus-raab.org.

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.8.24-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 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](https://libelektra.org).

For a small demo see here:

[![asciicast](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r.png)](https://asciinema.org/a/cantr04assr4jkv8v34uz9b8r)

You can also read the news [on our website](https://www.libelektra.org/news/0.8.25-release)

## 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`](https://libelektra.org/plugins/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](https://build.libelektra.org).

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)](https://master.libelektra.org/doc/dev/data-structures.md#order-preserving-minimal-perfect-hash-map-aka-opmphm).
The hybrid search combines the best properties of the binary search and the [OPMPHM](https://master.libelektra.org/doc/dev/data-structures.md#order-preserving-minimal-perfect-hash-map-aka-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](https://master.libelektra.org/src/include/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](https://master.libelektra.org/doc/dev/data-structures.md#order-preserving-minimal-perfect-hash-map-aka-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](https://www.libelektra.org/plugins/readme) we updated in this release.

### Directory Value

We improved the performance of the [directoryvalue plugin](https://libelektra.org/plugins/directoryvalue). _(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](https://libelektra.org/plugins/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](https://libelektra.org/plugins/gpgme) 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](https://www.gnu.org/software/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

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

  ```sh
  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](https://www.libelektra.org/libraries/readme) 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](https://www.libelektra.org/bindings/readme). 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ć)_
- Avoid raw pointers in KDB tools. _(Markus Raab)_
- Improved error text of KDB tool `cp`. _(Markus Raab)_
- Document hidden feature of KDB tool `mount`. _(Markus Raab)_
- Add more tags to the KDB tools to be used with `kdb find-tools`. _(Markus Raab)_

## Scripts

- We now require [`clang-format`](https://clang.llvm.org/docs/ClangFormat.html) 6.0 for formatting C and C++ code. _(René Schwaiger)_
- The command `reformat-source` now displays information about the installed
  version of `clang-format`, if it is unable to locate a supported version of the tool. _(René Schwaiger)_
- We now also check the POSIX compatibility of our scripts with [`shfmt`][]. _(René Schwaiger)_
- The new command `reformat-shfmt` reformats Shell scripts using the tool [`shfmt`](https://github.com/mvdan/sh). _(René Schwaiger)_

[`shfmt`]: https://github.com/mvdan/sh

## Documentation

- We fixed some minor spelling mistakes in the documentation. _(René Schwaiger)_
- Improved the plugins documentation. _(Michael Zronek)_
- The ReadMe now includes two badges that show the latest released version of Elektra and the status of the Travis build. _(René Schwaiger)_
- Fixed documenation error on Ruby plugin Readme. _(Bernhard Denner)_
- Go into more detail in
  [BUILDSERVER.md](https://master.libelektra.org/doc/BUILDSERVER.md).
  _(Lukas Winkler)_

## Tests

- Fix potential parallel execution of maven tests, which write to KDB. _(Markus Raab)_
- The unit test for the [`dbus` plugin](https://www.libelektra.org/plugins/dbus) does not leak memory anymore, if it fails on macOS.
  _(Thomas Wahringer)_
- The tests `testkdb_allplugins` and `testscr_check_kdb_internal_check` do not test a plugin on an ASAN enabled build anymore, if you
  specify the status tag `memleak` in the plugin contract. _(René Schwaiger)_
- The [CFramework](https://master.libelektra.org/doc/TESTING.md) macro `compare_key` now also checks if the meta values of keys are equal.
  _(René Schwaiger)_
- The test `testscr_check_bashisms` does not print warnings about skipped files anymore. _(René Schwaiger)_
- We added a [Markdown Shell Recorder][] test for the [`shell` plugin ](https://www.libelektra.org/plugins/shell). _(René Schwaiger)_
- Added many storage plugin tests. Most tests use the keyset, key name and value APIs.
  Currently, the tests are only active for `dump` and `mmapstorage`. _(Mihael Pranjić)_
- The test `testcpp_contextual_basic` now compiles without warnings, if we use Clang 7 as compiler. _(René Schwaiger)_
- crypto, fcrypt and gpgme properly shut down the gpg-agent after the unit test is done. See #1973 . _(Peter Nirschl)_
- minor refactoring of the unit tests for crypto, fcrypt, gpgme: moved shared code to separate module in order to avoid code duplication. _(Peter Nirschl)_
- The CMake targets for plugin tests (`testmod_[plugin]`) now depend on the respective CMake targets for the plugins themselves
  (`elektra-[plugin]`). _(Klemens Böswirth)_
- Fixed bug in CMake plugin tests, if only `BUILD_FULL` but not `BUILD_SHARED` is used. _(Klemens Böswirth)_
- The test [`testscr_check_formatting`](https://master.libelektra.org/tests/shell/check_formatting.sh) now also checks the formatting of
  Shell code. _(René Schwaiger)_
- We pumped version numbers in XML-test files. _(Markus Raab)_
- We fixed a crash in the unit test of the [JNA](https://www.libelektra.org/bindings/jna) binding. _(René Schwaiger)_
- The command [`kdb run_all`](https://master.libelektra.org/tests/README.md) now only prints the output of tests that failed. To print the
  full output of all test, please use the option `-v`. _(René Schwaiger)_
- The [Shell Recorder][] does not use the non-POSIX grep option `--text` any more. _(René Schwaiger)_
- The test suite now uses [Google Test](https://github.com/google/googletest) `1.8.1`. _(René Schwaiger)_

[markdown shell recorder]: https://master.libelektra.org/tests/shell/shell_recorder/tutorial_wrapper
[shell recorder]: https://master.libelektra.org/tests/shell/shell_recorder

## Build

### CMake

- We improved the detection of Python 2 and Python 3 in the CMake code of the Python bindings/plugins. _(René Schwaiger)_
- We restructured the code of the CMake module we use to detect Haskell tools . _(René Schwaiger)_
- Building the Haskell binding should now work again. _(René Schwaiger)_
- The CMake configuration step now displays less debug messages about found libraries. _(René Schwaiger)_
- Provide a wrapper around `check_symbol_exists` that handles issues with
  `-Werror -Wpedantic`. _(Lukas Winkler)_
- The argument `INCLUDE_SYSTEM_DIRECTORIES` of the function `add_plugin` now supports multiple include directories. _(René Schwaiger)_
- We reformatted all CMake source files with cmake-format 0.4.3. _(René Schwaiger)_
- Generating coverage data (`ENABLE_COVERAGE=ON`) should now also work on macOS. _(René Schwaiger)_
- You can use the new target `run_checkshell` to run all shell checks (`testscr_check.*`). _(René Schwaiger)_
- The new target `run_nocheckshell` runs all tests except for shell checks. _(René Schwaiger)_
- The target `run_all` now runs tests that do not modify the key database in parallel. _(René Schwaiger)_
- Fix CMake inclusion logic for GLib/Gi _(Markus Raab)_

### Docker

- The Docker image for Debian stretch now contains all (optional) dependencies for Elektra. _(René Schwaiger)_
- The docker images used by our build system are now available to download from
  our systems without authentication.
  Try it out and list available images via `docker run --rm anoxis/registry-cli -r https://hub-public.libelektra.org`.
  You can search for images using `--images-like`, for example: `docker run --rm anoxis/registry-cli -r https://hub-public.libelektra.org --images-like alpine`.
  Afterwards pull your desired image as you would do from any public registry, for example: `docker pull hub-public.libelektra.org/build-elektra-alpine:201811-37597a34fed4988639cdaf4d6a2c54754d09918586f53389e4fde5fd3b3a7180`.
  _(Lukas Winkler)_

### Vagrant

- Added Vagrantfile for Ubuntu artful 32-bit. _(Mihael Pranjić)_

## Infrastructure

### Jenkins

- We enabled tests that write to the hard disk on the build job `alpine`. _(René Schwaiger)_
- The build jobs now print less non-relevant output. _(René Schwaiger)_
- Enable `-Werror` in `debian-stable-full`. _(Lukas Winkler)_
- We added the compiler switch `-Werror` to the build jobs:
  - `alpine`,
  - `debian-stable-full-i386`,
  - `debian-stable-full-mmap-asan`,
  - `debian-stable-full-mmap`,
  - `debian-stable-full-optimizations-off`,
  - `debian-stable-full-xdg`,
  - `debian-stable-minimal`,
  - `debian-stable-multiconf`,
  - `debian-unstable-clang-asan`,
  - `debian-unstable-full-clang`,
  - `debian-unstable-full`,
  - `ubuntu-xenial`, and
  - `debian-stable-asan`. _(René Schwaiger)_
- Build Artifacts for all PR's to detect issues before merging _(Lukas Winkler)_
- Stricter removal of temporary docker images on docker nodes _(Lukas Winkler)_
- Added jenkins build jobs `debian-stable-full-mmap` and `debian-stable-full-mmap-asan`
  with `mmapstorage` as the default storage. _(Mihael Pranjić)_
- We added basic support for coverage analysis via [Coveralls](http://coveralls.io). _(René Schwaiger)_

### Travis

- Travis now also checks the code for memory leaks in the build job `🍏 Clang ASAN`. _(René Schwaiger)_
- The Travis build jobs `🍏 Clang ASAN` and `🐧 GCC ASAN` now only translates a minimal set of plugins, since we had various timeout
  problems with these jobs before. We explicitly excluded plugins, to make sure that the build jobs still test newly added plugins.
  _(René Schwaiger)_
- Added travis build job `🍏 mmap` on macOS with `mmapstorage` as the default storage. _(Mihael Pranjić)_
- Travis now prints the CMake configuration for each build job. _(René Schwaiger)_
- We now test Elektra using the latest version of Xcode (`10.0`). _(René Schwaiger)_
- We added the build job `🍏 Check Shell`, which only runs shell checks such as `testscr_check_oclint`. This update allows us to
  remove the shell checks from the jobs `🍏 MMap` and `🍏 Clang`, which sometimes hit the
  [timeout limit for public repositories](https://docs.travis-ci.com/user/customizing-the-build#build-timeouts) before. _(René Schwaiger)_
- All Travis build jobs now use the compiler switch `-Werror`. _(René Schwaiger)_
- The new job `🍏 FULL` and the build job `🐧 FULL` build Elektra using the CMake options `BUILD_FULL=ON` and `BUILD_SHARED=OFF`.
  _(René Schwaiger)_
- The `script` stage of the build jobs print less non-relevant output. Usually the commands in this stage should now only print verbose
  output if a test fails. _(René Schwaiger)_

## Website

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

## Outlook

We are currently working on following topics:

- Global mmap cache: This feature will enable Elektra to return configuration without parsing configuration files or executing other plugins as long as the configuration files are not changed. _(Mihael Pranjić)_
- Finish high-level API. _(Klemens Böswirth)_
- Validation improvements. _(Michael Zronek)_
- Improve YAML plugins. _(René Schwaiger)_

## Statistics

Following authors made this release possible:

| Commits | Author                                             |
| ------- | -------------------------------------------------- |
| 1       | Thomas Wahringer <thomas.wahringer@libelektra.org> |
| 2       | Bernhard Denner <bernhard.denner@gmail.com>        |
| 7       | Kurt Micheli <e1026558@student.tuwien.ac.at>       |
| 12      | Michael Zronek <michael.zronek@gmail.com>          |
| 33      | Lukas Winkler <derwinlu+git@gmail.com>             |
| 28      | Klemens Böswirth <k.boeswirth+git@gmail.com>       |
| 30      | Armin Wurzinger <e1528532@student.tuwien.ac.at>    |
| 38      | Peter Nirschl <peter.nirschl@gmail.com>            |
| 100     | Markus Raab <markus@libelektra.org>                |
| 180     | Mihael Pranjic <mpranj@limun.org>                  |
| 418     | René Schwaiger <sanssecours@me.com>                |

849 commits, 581 files changed, 18503 insertions(+), 3192 deletions(-)

We welcome new contributors!

## Finished Thesis

- [Daniel Bugl](https://www.libelektra.org/ftp/elektra/publications/bugl2018web.pdf), see also [the web demo](https://webdemo.libelektra.org/).
- [Thomas Wahringer](https://www.libelektra.org/ftp/elektra/publications/wahringer2018notification.pdf).
- [Kurt Micheli](https://www.libelektra.org/ftp/elektra/publications/micheli2018hybrid.pdf)
- [Armin Wurzinger](http://repositum.tuwien.ac.at/urn:nbn:at:at-ubtuw:1-115452)

## Get It!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.25.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.25.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.25.tar.gz.hashsum?raw=true)

- name: elektra-0.8.25.tar.gz
- size: 6233918
- md5sum: d5614b2049fb8431a80842a4909b140e
- sha1: c7dfb5fa87284d8f5ba4d4753e0e47a0e362c733
- sha256: 37829256e102e967fe3d58613a036d9fb9b8f9658e20c23fa787eac0bfbb8a79

The release tarball is also available signed by Markus Raab using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.25.tar.gz.gpg) or
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases//elektra-0.8.25.tar.gz.gpg?raw=true)

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.8.25/html/)
or [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.8.25).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via the issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.8.25-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.8.26-release)

## 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:

```c
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](https://www.libelektra.org/plugins/type).
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](/src/libs/highlevel/README.md) 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](/examples/highlevel).

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](https://www.libelektra.org/plugins/readme) we updated in this release.

### Augeas

- We changed the default [Augeas](http://augeas.net) directory prefix for the lenses directory on macOS to the one used by
  [Homebrew](https://brew.sh): `/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](https://www.libelektra.org/plugins/network). _(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:

  ```yaml
  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](/src/plugins/path/README.md) _(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`](https://www.libelektra.org/plugins/line),
  - [`mini`](https://www.libelektra.org/plugins/mini) and
  - [`resolver`](https://www.libelektra.org/plugins/resolver)

  reported on FreeBSD. _(René Schwaiger)_

- The [`resolver` plugin](/src/plugins/resolver) 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](https://www.libelektra.org/libraries/readme) 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](../decisions/6_implemented/global_keyset.md) 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.

  ```c
  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:

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

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

  ```c
  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](/doc/tutorials/command-line-options.md) and the code documentation of `elektraGetOpts`. _(Klemens Böswirth)_

## Tools

- `kdb spec-mount` correctly includes type plugin to validate `type`. _(Markus Raab)_
- `kdb setmeta` reports if it removed a metakey. _(Markus Raab)_
- `system/elektra/version` now has metadata to indicate that it cannot be edited or removed. _(Dominic Jäger)_

## Scripts

- The script `reformat-source` now also handles filenames containing spaces
  correctly. _(René Schwaiger)_
- The script [`reformat-markdown`](https://master.libelektra.org/scripts/dev/reformat-markdown) formats
  [Markdown](https://daringfireball.net/projects/markdown) files in the repository with [`prettier`](https://prettier.io).
  _(René Schwaiger)_
- The scripts `reformat-source`,
  [`reformat-cmake`](https://master.libelektra.org/scripts/dev/reformat-cmake), `reformat-shfmt`
  and [`reformat-markdown`](https://master.libelektra.org/scripts/dev/reformat-markdown) don't format files that are ignored by Git anymore.
  _(Klemens Böswirth)_

## Documentation

- We fixed various spelling mistakes. _(René Schwaiger)_
- The documentation for `elektraMetaArrayToKS` was fixed. It now reflects the fact
  that the parent key is returned as well. _(Klemens Böswirth)_

## Tests

- The tests for the IO bindings and notification plugins now use increased timeout values so that the test suite fails less often on
  machines with high load. _(René Schwaiger)_
- We update most of the [Markdown Shell Recorder][] tests so they use an explicit namespace (like `system` or `user`). This has the
  advantage that the output of these tests [does not change depending on the user that executes them](https://issues.libelektra.org/1773).
  Before the update these tests used [cascading keys](https://www.libelektra.org/tutorials/namespaces). _(René Schwaiger)_
- The [Shell Recorder][] now also works correctly on FreeBSD. _(René Schwaiger)_
- Fix memcheck target to detect memory problems again and enabled parallel testing to speed it up. _(Mihael Pranjić)_
- Fix memleak in pluginprocess tests. _(Mihael Pranjić)_
- The test [`check-env-dep`](https://master.libelektra.org/scripts/check-env-dep) does not require Bash anymore. _(René Schwaiger)_
- We fixed an incorrect directive in the [Markdown Shell Recorder][] test of the
  [Type Checker](https://www.libelektra.org/plugins/typechecker) plugin. _(René Schwaiger)_
- We added a test that invokes the script [`fix-spelling`](http://master.libelektra.org/scripts/dev/fix-spelling) to check the documentation
  for common spelling mistakes. _(René Schwaiger)_
- We added a test that checks the formatting of Markdown files with [`prettier`](https://prettier.io). _(René Schwaiger)_
- The test [`testscr_check_formatting`](https://master.libelektra.org/tests/shell/check_formatting.sh) now prints instructions that show
  you how to fix formatting problems. _(René Schwaiger)_

[shell recorder]: https://master.libelektra.org/tests/shell/shell_recorder
[markdown shell recorder]: https://master.libelektra.org/tests/shell/shell_recorder/tutorial_wrapper

## Build

### CMake

#### Misc

- The plugin name is now provided as compiler definition `ELEKTRA_PLUGIN_NAME` via CMake.
  See [#1042](https://issues.libelektra.org/1042). _(Peter Nirschl)_
- `ELEKTRA_PLUGIN_FUNCTION` does not require the module name as parameter any more, instead the `ELEKTRA_PLUGIN_NAME` compiler definition is being used. See [#1042](https://issues.libelektra.org/1042). _(Peter Nirschl)_
- `ELEKTRA_README`, and `ELEKTRA_PLUGIN_EXPORT` do not require the module name as parameter any more, instead the `ELEKTRA_PLUGIN_NAME` compiler definition is being used. See [#1042](https://issues.libelektra.org/1042). _(Peter Nirschl)_
- We now specify
  - version number,
  - project description, and
  - homepage URL
    in the CMake [`project`](https://cmake.org/cmake/help/latest/command/project.html) command. _(René Schwaiger)_
- We fixed the detection of Python for the [Python 2 binding](https://www.libelektra.org/bindings/swig_python2) on macOS. _(René Schwaiger)_
- You can now use the Ruby binding and plugin without any manual configuration, if you installed Ruby (version `2.5` or later) via [Homebrew](http://brew.sh). _(René Schwaiger)_

#### Find Modules

- The CMake find module [`FindAugeas.cmake`](https://master.libelektra.org/scripts/cmake/Modules/FindAugeas.cmake) does not print an error
  message anymore, if it is unable to locate Augeas in the `pkg-config` search path. _(René Schwaiger)_
- The CMake find module [`FindLua.cmake`](https://master.libelektra.org/scripts/cmake/Modules/FindLua.cmake) does not print an error message
  anymore, if it is unable to locate a Lua executable. _(René Schwaiger)_
- We added code that makes sure you can compile [IO GLIB](https://www.libelektra.org/bindings/io_glib) on macOS, even if `pkg-config`
  erroneously reports that GLIB requires linking to the library `intl` (part of [GNU gettext](https://www.gnu.org/software/gettext)).
  _(René Schwaiger)_
- We added a [CMake find module for GLib](https://master.libelektra.org/scripts/cmake/Modules/FindGLib.cmake). The module makes sure you can
  compile and link [IO GLib](https://www.libelektra.org/bindings/io_glib) on macOS. _(René Schwaiger)_
- The CMake find module [`FindLibOpenSSL.cmake`](https://master.libelektra.org/scripts/cmake/Modules/FindLibOpenSSL.cmake) does not require
  `pkg-config` anymore. The updated code also fixes some linker problems on macOS (and probably other operating systems too), where the
  build system is not able to link to OpenSSL using only the name of the OpenSSL libraries. _(René Schwaiger)_
- We simplified the CMake find module [`FindLibgcrypt.cmake`](https://master.libelektra.org/scripts/cmake/Modules/FindLibgcrypt.cmake).The update
  fixes problems on macOS, where the build system excluded the plugin `crypto_gcrypt`, although
  [Libgcrypt](https://gnupg.org/software/libgcrypt) was installed on the system. _(René Schwaiger)_
- We now use the [official CMake find module for `iconv`](https://github.com/Kitware/CMake/blob/master/Modules/FindIconv.cmake). This
  update fixes linker problems with the [`iconv`](http://libelektra.org/plugins/iconv) and
  [`filecheck`](http://libelektra.org/plugins/filecheck) plugin on FreeBSD 12. _(René Schwaiger)_
- The [CMake find module for Botan](https://master.libelektra.org/scripts/cmake/Modules/FindLibgcrypt.cmake) does not require `pkg-config` anymore.
  _(René Schwaiger)_
- The [CMake find module for libgit2](https://master.libelektra.org/scripts/cmake/Modules/FindLibGit2.cmake) now also exports the version number of
  libgit2. _(René Schwaiger)_
- We added a CMake find module for [libuv](https://libuv.org) and fixed a problem on macOS, where the build system was
  [unable to locate the header file of libuv](https://cirrus-ci.com/task/4852008365326336). _(René Schwaiger)_
- We added a CMake find module for [ZeroMQ](http://zeromq.org) to fix build problems on macOS. _(René Schwaiger)_

### Docker

- We added

  - [ANTLR](https://packages.debian.org/sid/antlr4),
  - [ANTLR’s C++ runtime](https://packages.debian.org/sid/libantlr4-runtime-dev),
  - [Ninja](https://packages.debian.org/sid/ninja-build), and
  - [`shfmt`](https://github.com/mvdan/sh),
    to the [Dockerfile for Debian sid](https://master.libelektra.org/scripts/docker/debian/sid/Dockerfile)

  . _(René Schwaiger)_

### Misc

- We removed the `configure` script from the top-level directory.
  CMake is now popular enough so that this helper-script is not needed. _(René Schwaiger)_

## Infrastructure

### Cirrus

- We now use [Cirrus CI](https://cirrus-ci.com) to [build and test Elektra](http://cirrus-ci.com/github/ElektraInitiative/libelektra) on

  - [FreeBSD 11.2](https://www.freebsd.org/releases/11.2R/announce.html) and
  - [FreeBSD 12.0](https://www.freebsd.org/releases/12.0R/announce.html)

  . Both of these build jobs use `-Werror` to make sure we do not introduce any code that produces compiler warnings. _(René Schwaiger)_

- The new build job `🍎 Clang` tests Elektra on macOS. _(René Schwaiger)_
- We added the build job `🍎 Clang ASAN`, which uses Clang with enabled [AddressSanitizer](https://en.wikipedia.org/wiki/AddressSanitizer)
  to test Elektra on macOS. _(René Schwaiger)_
- The new build job `🍎 FULL` compiles and test Elektra using the CMake options `BUILD_SHARED=OFF` an `BUILD_FULL=ON`. _(René Schwaiger)_
- We added `🍎 MMap`, which tests Elektra using [`mmapstorage`](https://www.libelektra.org/plugins/mmapstorage) as default storage module.
  _(René Schwaiger)_
- We install and uninstall Elektra in all of the macOS build jobs to make sure that
  [`ElektraUninstall.cmake`](https://master.libelektra.org/scripts/cmake/ElektraUninstall.cmake) removes all of the installed files.
  _(René Schwaiger)_

### Jenkins

- We added a badge displaying the current build status to the main [ReadMe](https://master.libelektra.org/README.md). _(René Schwaiger)_
- The build job `formatting-check` now also checks the formatting of Shell scripts. _(René Schwaiger)_

### Travis

- We now test Elektra on [Ubuntu Xenial Xerus](https://docs.travis-ci.com/user/reference/xenial). _(René Schwaiger)_
- We removed the build jobs `🍏 Clang` and `🍏 Check Shell` in favor of the Cirrus build job `🍎 Clang`. _(René Schwaiger)_
- We removed the build jobs `🍏 Clang ASAN` in favor of the Cirrus build job `🍎 Clang ASAN`. _(René Schwaiger)_
- We removed the build jobs `🍏 FULL` in favor of the Cirrus build job `🍎 FULL`. _(René Schwaiger)_
- We removed the build jobs `🍏 MMap` in favor of the Cirrus build job `🍎 MMap`. _(René Schwaiger)_

## Website

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

## Outlook

We are currently working on following topics:

- infallible high-level API: creating an API that guarantees you to return configuration values _(Klemens Böswirth)_
- error handling _(Michael Zronek)_
- elektrify LCDproc _(Klemens Böswirth)_ and _(Michael Zronek)_
- YAML as default storage _(René Schwaiger)_
- misconfiguration tracker _(Vanessa Kos)_
- global mmap cache: This feature will enable Elektra to return configuration without parsing configuration files or executing other plugins as long as the configuration files are not changed. _(Mihael Pranjić)_

and since recently:

- automatic shell completion _(Ulrike Schaefer)_
- plugin framework improvements _(Vid Leskovar)_
- 3-way merge _(Dominic Jäger)_
- reducing entry barriers for newcomers _(Hani Torabi Makhsos)_
- bug fixing _(Usama Morad)_ and _(Kurt Micheli)_

## Statistics

In this release we created 986 commits in which
802 files were changed, with 21687 insertions(+) and 6912 deletions(-).

Following authors made this release possible:

| Commits | Author                                       |
| ------- | -------------------------------------------- |
| 1       | Aybuke Ozdemir <aybuke.147@gmail.com>        |
| 2       | Gabriel Rauter <rauter.gabriel@gmail.com>    |
| 6       | Bernhard Denner <bernhard.denner@gmail.com>  |
| 6       | Dominic Jäger <dominic.jaeger@gmail.com>     |
| 25      | Peter Nirschl <peter.nirschl@gmail.com>      |
| 32      | Mihael Pranjic <mpranj@limun.org>            |
| 66      | Michael Zronek <michael.zronek@gmail.com>    |
| 112     | Markus Raab <elektra@markus-raab.org>        |
| 131     | Klemens Böswirth <k.boeswirth+git@gmail.com> |
| 141     | Dominik Hofer <me@dominikhofer.com>          |
| 464     | René Schwaiger <sanssecours@me.com>          |

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.26.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.26.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.8.26.tar.gz.hashsum?raw=true)

- name: elektra-0.8.26.tar.gz
- size: 6395865
- md5sum: 4ef202b5d421cc497ef05221e5309ebc
- sha1: 94f654764bcf49d0ebc7e636f444e24ca6cfeb19
- sha256: 5806cd0b2b1075fe0d5a303649d0bd9365752053e86c684ab7c06e7f369155d3

The release tarball is also available signed by Markus Raab using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.8.26.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases//elektra-0.8.26.tar.gz.gpg?raw=true)

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.8.26/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.8.26).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.8.26-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 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](https://www.libelektra.org/news/0.9.0-release).

We wrote a new article [describing our vision from
configuration management perspective](https://www.libelektra.org/docgettingstarted/vision).

For more information, visit [https://libelektra.org](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](https://github.com/ElektraInitiative/libelektra/milestone/12),
  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 business@libelektra.org

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 business@libelektra.org

Please note, that Elektra will definitely stay
100% free software ([BSD licensed](../../LICENSE.md)).
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](https://www.libelektra.org/plugins/cache) is a new global caching plugin.
It uses [mmapstorage](https://www.libelektra.org/plugins/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](https://www.libelektra.org/plugins/ini) configuration files mounted with
the [multifile resolver](https://www.libelektra.org/plugins/multifile), 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](https://www.libelektra.org/plugins/gopts) is a new plugin that integrates support for command-line options to applications:

- The [gopts](https://www.libelektra.org/plugins/gopts) plugin retrieves the values of `argc`, `argv` and `envp` needed for
  [`elektraGetOpts`](https://www.libelektra.org/tutorials/command-line-options) 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](https://www.ibm.com/support/knowledgecenter/en/SSGU8G_12.1.0/com.ibm.sqls.doc/ids_sqs_0809.htm)
we changed to structure of our error codes and migrated them. Have a look into
the new [codes](../decisions/6_implemented/error_codes.md). 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](../decisions/6_implemented/error_codes.md)
- [about error message format](../decisions/6_implemented/error_message_format.md)

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

## Plugins

The following section lists news about the [plugins](https://www.libelektra.org/plugins/readme) 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](https://www.libelektra.org/plugins/type)).

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](https://www.libelektra.org/plugins/type).

### Base64

- We fixed some warnings about implicit type conversions reported by [UBSan][] in the [base64](https://www.libelektra.org/plugins/base64) plugin. _(René Schwaiger)_

[ubsan]: https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html

### Crypto and Fcrypt

- Empty GPG key IDs in the plugin configuration are being ignored by the [crypto](https://www.libelektra.org/plugins/crypto) plugin and the [fcrypt](https://www.libelektra.org/plugins/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](https://github.com/ElektraInitiative/libelektra/issues/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](https://www.libelektra.org/plugins/csvstorage) plugin. _(Vlad - Ioan Balan)_

### Filecheck

- We fixed some warnings about implicit type conversions reported by [UBSan][]. _(René Schwaiger)_

### INI

- Fixed [INI](https://www.libelektra.org/plugins/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](../../src/plugins/mini/testmod_mini.c) of the plugin. _(René Schwaiger)_

### Mmapstorage

- [mmapstorage](https://www.libelektra.org/plugins/mmapstorage) is now able to persist the Global KeySet, which is used by the `cache` plugin. _(Mihael Pranjić)_
- Fixed support for `kdb import` and `kdb export`. _(Mihael Pranjić)_

### Multifile

- Fixed segmentation fault in `kdbError()` function. _(Mihael Pranjić)_
- Added Global Keyset handle to storage plugin. _(Mihael Pranjić)_
- Fixed use of wrong resolver handle in the `kdbError()` function. _(Mihael Pranjić)_

### Quickdump

- [quickdump](https://www.libelektra.org/plugins/quickdump) is a new storage plugin. It implements a more concise form of the
  [dump](https://www.libelektra.org/plugins/dump) format, which is also quicker too read. Contrary to dump, quickdump only stores
  keynames relative to the parent key. This allows easy relocation of configurations. _(Klemens Böswirth)_
- quickdump now also uses an variable length integer encoding to further reduce file size. _(Klemens Böswirth)_

### Reference

- Fixed missing Metadata in README and METADATA.ini. _(Michael Zronek)_
- Update README.md web tool to show, how to test REST API on localhost. _(Dmytro Moiseiuk)_

### RGBColor

- [New plugin](https://www.libelektra.org/plugins/rgbcolor) to validate hex formatted colors (e.g. #fff or #abcd) and normalize them to rgba (4294967295 (= 0xffffffff) and 2864434397 (= 0xaabbccdd) respectively). It also has support for named colors according to the [extended color keywords](https://www.w3.org/TR/css-color-3/#svg-color) from CSS3.
  _(Philipp Gackstatter)_

### Semlock

Removed due to:

- constant pain
- never worked properly
- poor design
- no time in future to maintain
  _(Kurt Micheli)_

### Spec

- The spec plugin was partly rewritten to better support specifications for arrays. This includes some breaking changes concerning the less
  used (and also less functional) parts of the plugin. To find out more about these changes take a look at the
  [README](../../src/plugins/spec/README.md). It now better reflects the actually implemented behavior. _(Klemens Böswirth)_

### Specload

- The [specload](https://www.libelektra.org/plugins/specload) plugin is a special storage plugin. Instead of using a storage file
  it calls an external application to request its specification. For the transfer it relies on the
  [quickdump](https://www.libelektra.org/plugins/quickdump) plugin. _(Klemens Böswirth)_
- Currently changing the specification is only allowed in a very limited way. However, in future the plugin should allow overriding a
  specification in all cases where this can be done safely. NOTE: While the plugin technically allows some modifications, because of a
  problem with the resolver this cannot be used right now (see [limitations](https://www.libelektra.org/plugins/specload)).
- We also export `elektraSpecloadSendSpec` to abstract over the `quickdump` dependency. _(Klemens Böswirth)_

### Syslog

- We fixed an incorrect format specifier in a call to the `syslog` function. _(René Schwaiger)_

### Unit

- [New plugin](https://www.libelektra.org/plugins/unit) to validate units of memory and normalize them into bytes. E.g. 20 KB (normalized to 20000 Byte).
  _(Marcel Hauri)_

### YAJL

The [YAJL](https://www.libelektra.org/plugins/yajl) plugin which parses JSON files:

- now allows setting a value to the mountpoint. This is represented as a top level value in JSON if no other key is present. _(Philipp Gackstatter)_
- no longer lists empty parent keys with `kdb ls`. _(Philipp Gackstatter)_
- signifies arrays with the metakey array according to the [array decision](../decisions/5_partially_implemented/array.md). _(Philipp Gackstatter)_
- no longer produces additional `___dirdata` entries for empty array keys. See also issue [#2477](https://github.com/ElektraInitiative/libelektra/issues/2477). _(Philipp Gackstatter)_

### YAMBi

- YAMBi is now able detect multiple syntax errors in a file. _(René Schwaiger)_
- The error message now includes more information about the location of syntax errors. For example, for the incorrect YAML input `config.yaml`:

  ```yaml
  key 1: - element 1
   - element 2
  key 2: scalar
         - element 3
  ```

  , the plugin prints an error message that includes the following text:

  ```
  config.yaml:2:2: syntax error, unexpected start of sequence, expecting end of map or key
                    - element 2
                    ^
  config.yaml:4:8: syntax error, unexpected start of sequence, expecting end of map or key
                          - element 3
                          ^
  ```

  . _(René Schwaiger)_

- YAMBi now supports Elektra’s [boolean data type](../decisions/5_partially_implemented/boolean.md). _(René Schwaiger)_
- The plugin now handles YAML key-value pairs without a value at the end of a file correctly. _(René Schwaiger)_
- The plugin now converts YAML key-value pairs with empty value to null/empty keys. _(René Schwaiger)_
- YAMBi now converts empty files to a key set containing an empty version of the parent key. _(René Schwaiger)_

### YAML CPP

- The plugin now handles keys that are part of a map, but use a basename ending with [array syntax](../tutorials/arrays.md) correctly. For example, in a key set that contains keys with the following names:

  ```
  user/array/#0
  user/array/#1
  user/map/#0
  user/map/key
  user/map/#1
  ```

  , `user/array/#0` and `user/array/#1` represent array elements, while `user/map/#0`, and `user/map/#1` do not, since the key set also contains the key `user/map/key`. The following [Markdown Shell Recorder][] snippet shows the new behavior of the plugin:

  ```sh
  kdb mount config.yaml user yamlcpp
  kdb set user/array/#0 one
  kdb set user/array/#1 two
  kdb set user/map/#0   three
  kdb set user/map/key  four
  kdb set user/map/#1   five
  kdb file user | xargs cat
  #> array:
  #>   - one
  #>   - two
  #> map:
  #>   "#0": three
  #>   "#1": five
  #>   key: four
  ```

  . _(René Schwaiger)_

- [YAML CPP][] now handles the conversion from and to [Elektra’s boolean type](../decisions/5_partially_implemented/boolean.md) properly. _(René Schwaiger)_
- The plugin converts “sparse” key sets properly. For example, for the key set that contains **only** the key:

  - `user/parent/#1/#2/map/#0` with the value `arr`

  and uses `user/parent` as parent key, YAML CPP stores the following YAML data:

  ```yaml
  - ~
  - - ~
    - ~
    - map:
        - arr
  ```

  . _(René Schwaiger)_

- [YAML CPP][] now supports mixed data (nested lists & sequences) better. For example, the plugin now correctly converts the YAML data

  ```yaml
  root:
    - element: one
    - element: two
  ```

  to the key set that contains the following keys:

  ```
  user/tests/yaml/root
  user/tests/yaml/root/#0/element
  user/tests/yaml/root/#1/element
  ```

  .

[markdown shell recorder]: https://master.libelektra.org/tests/shell/shell_recorder/tutorial_wrapper
[yaml cpp]: ../../src/plugins/yamlcpp/README.md

### YAML Smith

<!-- prettier-ignore-start -->

- [YAML Smith](https://www.libelektra.org/plugins/yamlsmith) now converts keys that shares a common prefix correctly. For example, the last command in the script:

  ```sh
  kdb mount config.yaml user/tests/yaml yaml
  kdb set user/tests/yaml/common/one/#0 value
  kdb set user/tests/yaml/common/two/#0 first
  kdb set user/tests/yaml/common/two/#1 second
  kdb export user/tests/yaml yamlsmith
  ```

  now prints the following YAML data:

  ```yaml
  common:
    one:
      - "value"
    two:
      - "first"
      - "second"
  ```

  . _(René Schwaiger)_

<!-- prettier-ignore-end -->

- The plugin now converts Elektra’s boolean values (`0`, `1`) back to YAML’s boolean values (`true`, `false`). _(René Schwaiger)_

### Yan LR

- The build system now disables the plugin, if you installed a version of ANTLR 4 that does not support ANTLR’s C++ runtime (like ANTLR
  `4.5.x` or earlier). _(René Schwaiger)_
- We fixed an ambiguity in the [YAML grammar](https://master.libelektra.org/src/plugins/yanlr/YAML.g4). _(René Schwaiger)_
- The build system now regenerates the modified parsing code, every time we update the grammar file. _(René Schwaiger)_
- The plugin now reports the location of syntax errors correctly. _(René Schwaiger)_
- The lexer for the plugin now emits start tokens for maps at the correct location inside the token stream. This update fixes a problem, where the plugin sometimes reported incorrect error messages for the _first_ syntax error in a YAML file. _(René Schwaiger)_
- The plugin now stores the end position of map start tokens correctly. Before this update the plugin would sometimes not show the markers (`^`) that point to the error positions inside the input. _(René Schwaiger)_
- [Yan LR](https://www.libelektra.org/plugins/yanlr) now supports Elektra’s [boolean data type](../decisions/5_partially_implemented/boolean.md). _(René Schwaiger)_
- The plugin now handles YAML key-value pairs that contain no value at the end of a file correctly. _(René Schwaiger)_
- The plugin now converts YAML key-value pairs with empty value to null/empty keys. _(René Schwaiger)_
- The plugin converts “empty” YAML files to a key set that contains an empty version of the parent key. _(René Schwaiger)_

### YAwn

- YAwn is now able to print error messages for multiple syntax errors. _(René Schwaiger)_
- We also improved the error messages of YAwn, which now also contain the input that caused a syntax error. For example, for the input

  ```yaml
  key: value
    - element
  ```

  the plugin prints an error message that contains the following text:

  ```
  config.yaml:2:3: Syntax error on input “start of sequence”
                     - element
                     ^
  ```

  . _(René Schwaiger)_

- The plugin now supports Elektra’s [boolean data type](../decisions/5_partially_implemented/boolean.md). _(René Schwaiger)_
- YAwn handles YAML key-value pairs that contain no value at the end of a file correctly. _(René Schwaiger)_
- The plugin now converts YAML key-value pairs with empty value to null/empty keys. _(René Schwaiger)_
- YAwn now stores empty files as a key set containing an empty parent key. _(René Schwaiger)_

### YAy PEG

- YAy PEG now also supports PEGTL 2.8. _(René Schwaiger)_
- The plugin now includes the input that could not be parsed in error messages. _(René Schwaiger)_
- We improved the error messages for certain errors slightly. For example, the error message for the input

  ```yaml
  "double quoted
  ```

  now includes the following text

  ```
  1:14: Missing closing double quote or incorrect value inside flow scalar
        "double quoted
                      ^
  ```

  . _(René Schwaiger)_

- YAy PEG now supports compact mappings:

  ```yaml
  - key1: value1
    key2: value2
  ```

  and compact sequences:

  ```yaml
  - - element1
    - element2
  ```

  correctly. _(René Schwaiger)_

- The plugin now supports Elektra’s [boolean data type](../decisions/5_partially_implemented/boolean.md). _(René Schwaiger)_
- YAy PEG now converts YAML key-value pairs with empty value to null/empty keys. _(René Schwaiger)_
- The plugin now translates an empty file to a key set that contains a single empty parent key. _(René Schwaiger)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

### Compatibility

We introduced several incompatible changes:

- different error codes are returned
- INI and YAJL plugins might write different files with the same KeySets

We changed following symbols:

- elektraIsReferenceRedundant
- elektraResolveReference
- elektraPluginFindGlobal
- kdbEnsure

### Core

- `kdbGet` now calls global postgetstorage plugins with the parent key passed to `kdbGet`, instead of a random mountpoint. _(Klemens Böswirth)_
- Fixed a double cleanup error (segmentation fault) when mounting global plugins. _(Mihael Pranjić)_
- Logging in Elektra was changed with this release. If Elektra is compiled with `ENABLE_LOGGER` enabled, we now log warnings and errors to
  stderr and everything except debug messages to syslog. If `ENABLE_DEBUG` is also enabled, debug messages are logged to syslog as well.
  Previously you had to make some manual changes to the code, to see most of the logging messages. _(Klemens Böswirth)_
- The logger does not truncate the file name incorrectly anymore, if `__FILE__` contains a relative (instead of an absolute) filepath. _(René Schwaiger)_
- Disabled any plugin execution when we have a cache hit or no update from backends. The old behavior can be enabled for testing using `ENABLE_DEBUG` and adding the `"debugGlobalPositions"` metakey to the parentKey of the kdbGet invocation. _(Mihael Pranjić)_
- Removed `ingroup` from error messages to reduce verbosity. _(Michael Zronek)_
- Fixed minor problem when `kdb_long_double_t` is not available (e.g. mips32). _(Matthias Schoepfer)_
- Only add benchmarks if `BUILD_TEST` is set in CMake. _(Matthias Schoepfer)_
- We fixed some warnings about implicit conversion to `unsigned int` reported by [UBSan][]. _(René Schwaiger)_

### Ease

- The functions for reference resolving used in the [reference plugin](https://www.libelektra.org/plugins/reference) have been extracted
  into libease. This lets other parts of Elektra easily use references and ensures a consistent syntax for them. _(Klemens Böswirth)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme). This section keeps
you up-to-date with the multi-language support provided by Elektra.

- JNA is now not experimental anymore. _(Markus Raab)_
- gsettings is not default anymore when installed. _(Markus Raab)_
- Add fix for creating the Key and KeySet objects in the HelloElektra.java file. _(Dmytro Moiseiuk)_
- We fixed a [warning about a deprecated default constructor](https://issues.libelektra.org/2670) in the C++ binding reported by GCC 9.0. _(René Schwaiger)_

## Tools

- `kdb get -v` now displays if the resulting value is a default-value defined by the metadata of the key. _(Thomas Bretterbauer)_
- `kdb cp` now succeeds if the target-keys already have the same values as the source-keys. _(Thomas Bretterbauer)_
- `web-ui` does not show empty namespace anymore _(Josef Wechselauer)_
- `kdb import` does not fail anymore if executed more than once with the same target in the spec-namespace. _(Thomas Bretterbauer)_
- `kdb mount` avoid adding sync if sync is already provided. _(Markus Raab)_
- `kdb list-tools` now supports `KDB_EXEC_PATH` environment variables that contain spaces. _(René Schwaiger)_
- `gen-gpg-testkey` is added to the default tools list (see [#2668](https://github.com/ElektraInitiative/libelektra/issues/2668))._(Peter Nirschl)_
- `kdb getenv` now executed correctly from within tests _(Markus Raab)_
- `kdb-bash-completion` now works on Mac (see [#2836](https://github.com/ElektraInitiative/libelektra/pull/2836)). _(Eduardo Santana)_
- `kdb rm` supports `--without-elektra` and returns 11 on key not found. _(Markus Raab)_

### Code generation

`kdb gen` is now no longer an external tool implemented via python, but rather a first class command of the `kdb` tool. For now it only
supports code generation for use with the highlevel API. Try it by running `kdb gen elektra <parentKey> <outputName>`, where `<parentKey>`
is the parent key of the specification to use and `<outputName>` is some prefix for the output files. If you don't have your specification
mounted, use `kdb gen -F <plugin>:<file> elektra <parentKey> <outputName>` to load it from `<file>` using plugin `<plugin>`.

. _(Klemens Böswirth)_

## Scripts

- The `reformat-shfmt` script now also formats `tests/shell/include_common.sh.in`. Additionally it ensures that the file is 1000 lines long,
  so that line numbers of files using it are easier to read. _(Klemens Böswirth)_
- The clang-format wrapper script now also checks the supported maximum version of Clang-Format. _(René Schwaiger)_
- The script `reformat-shfmt` now also reformats shell support files (`*.in`) in the [`scripts`](https://master.libelektra.org/scripts) folder. _(René Schwaiger)_
- The `reformat-*` scripts now allow you to specify a list of files that should be formatted. Only files actual suitable for the reformat script,
  will reformat. So e.g. calling `reformat-cmake src/include/kdbprivate.h` doesn't change any files. _(Klemens Böswirth)_
- The script `scripts/dev/reformat-all` is a new convenience script that calls all other `reformat-*` scripts. _(Klemens Böswirth)_
- The script `scripts/pre-commit-check-formatting` can be used as a pre-commit hook, to ensure files are formatted before committing. _(Klemens Böswirth)_
- The [link checker](../../scripts/link-checker) now prints broken links to the standard error output. _(René Schwaiger)_
- We added a script, called `benchmark-yaml` that compares the run-time of the YAML plugins:

  - [YAML CPP](https://www.libelektra.org/plugins/yamlcpp),
  - [Yan LR](https://www.libelektra.org/plugins/yanlr),
  - YAMBi,
  - YAwn, and
  - YAy PEG

  for a certain input file with [hyperfine](https://github.com/sharkdp/hyperfine). _(René Schwaiger)_

- Added `kdb reset` and `kdb reset-elektra`, fixed `kdb stash`. _(Markus Raab)_

## Benchmarks

- The benchmarking tool [`benchmark_plugingetset`](https://master.libelektra.org/benchmarks/plugingetset.c) now also supports only executing the `get` method for the specified plugin. For example, to convert the data stored in the file `benchmarks/data/yaypeg.test.in` with the YAy PEG plugin to a key set you can now use the following command:

  ```sh
  benchmark_plugingetset benchmarks/data user yaypeg get
  ```

  . _(René Schwaiger)_

## Documentation

### Style

- The documentation now uses [fenced code blocks](https://help.github.com/en/articles/creating-and-highlighting-code-blocks#syntax-highlighting) to improved the syntax highlighting of code snippets. _(René Schwaiger)_
- We added recommendations about the style of Markdown headers to our [coding guidelines](../CODING.md). _(René Schwaiger)_
- We now use [title case](https://en.wiktionary.org/wiki/title_case) for most headings in the documentation. _(René Schwaiger)_
- We added instructions on how to reformat code with

  - [Clang-Format](https://clang.llvm.org/docs/ClangFormat.html),
  - [cmake-format](https://github.com/cheshirekow/cmake_format),
  - [Prettier](https://prettier.io), and
  - [shfmt](https://github.com/mvdan/sh)

  to the [coding guidelines](../CODING.md). _(René Schwaiger)_

### Tutorials

- We added a basic tutorial that tells you [how to write a (well behaved) storage plugin](../tutorials/storage-plugins.md). _(René Schwaiger)_
- Improved the `checkconf` section in the plugin tutorial. _(Peter Nirschl)_
- We added a [tutorial](../tutorials/benchmarking.md) on how to benchmark the execution time of plugins using [`benchmark_plugingetset`](../../benchmarks/README.md) and [hyperfine](https://github.com/sharkdp/hyperfine). _(René Schwaiger)_
- The new [profiling tutorial](../tutorials/profiling.md) describes how to determine the execution time of code using

  - [Callgrind](https://valgrind.org/docs/manual/cl-manual.html), and
  - [XRay](https://llvm.org/docs/XRay.html)

  . _(René Schwaiger)_

- For beginners we added a [tutorial](https://www.libelektra.org/tutorials/contributing-with-clion) that guides them through the process of contributing to libelektra. _(Thomas Bretterbauer)_
- Added a section on `elektraPluginGetGlobalKeySet` in the plugin tutorial. _(Vid Leskovar)_
- Added a step-by-step [tutorial](../tutorials/run_all_tests_with_docker.md) for beginners to run all tests with Docker. _(Oleksandr Shabelnyk)_
- Extend/improve Java bindings related documentation in [tutorial](https://www.libelektra.org/tutorials/java-bindings) and [readme](../../src/bindings/jna/README.md). _(Oleksandr Shabelnyk)_
- Added a step-by-step [tutorial](../tutorials/run_reformatting_script_with_docker.md) for running reformatting scripts with Docker. _(Oleksandr Shabelnyk)_
- Covered Resolving Missing \*.so Library Error in [tutorial](../tutorials/contributing-clion.md). _(Oleksandr Shabelnyk)_
- Added a basic tutorial on [How-To: Write a Java Plugin](../tutorials/java-plugins.md) _(Dmytro Moiseiuk)_ and _(Miruna Orsa)_

### Spelling Fixes

- Write Elektra with capital letter in cascading tutorial. _(Vlad - Ioan Balan)_
- Add typo fix to the hello-elektra tutorial. _(Dmytro Moiseiuk)_
- Add typo fix to the Java kdb tutorial. _(Dominik Hofmann)_
- Fixed capitalization of the initial letter in Readme. _(Miruna Orsa)_
- Improved readability in README. _(Philipp Gackstatter)_
- We fixed some spelling mistakes in the documentation. _(René Schwaiger)_
- Fix typo in root README.md and 'built-in' => 'built-in' in several places _(Raphael Gruber)_
- Fixed typos in `cassandra.ini` _(arampaa)_

### Other

- The [Markdown Link Converter][] now uses the style

  ```
  filename:line:0
  ```

  instead of

  ```
  filename|line col 0|
  ```

  to show the location data for broken links. This is also the same style that Clang and GCC use when they display location information for
  compiler errors. This update has the advantage, that certain tools such as [TextMate](https://macromates.com) are able to convert the
  location data, providing additional features, such as clickable links to the error source. _(René Schwaiger)_

- The [Markdown Link Converter][] uses the index `1` for the first line number instead of `0`. This update fixes an off-by-one-error, when the user tries to use the error location data printed by the tool in a text editor. _(René Schwaiger)_
- We added a badge for [LGTM](https://lgtm.com) to the [main ReadMe file](https://master.libelektra.org/README.md). _(René Schwaiger)_
- Added [LCDproc](../../examples/spec/lcdproc) and [Cassandra](../../examples/spec/cassandra.ini) specification examples. These examples
  provide a good guideline for writing specifications for configurations. _(Michael Zronek)_
- Drastically improved the error message format. For more information look [here](../../doc/decisions/6_implemented/error_message_format.md). _(Michael Zronek)_
- Added a guideline for writing consistent and good error messages. For more information look [here](../../doc/dev/error-message.md). _(Michael Zronek)_
- Every `kdb` command now accepts `v` and `d` as option to show more information in case of warnings or errors. _(Michael Zronek)_
- Improved qt-gui error popup to conform with the new error message format. _(Raffael Pancheri)_
- We fixed the format specifiers in the [“Hello, Elektra” example](https://master.libelektra.org/examples/helloElektra.c). _(René Schwaiger)_
- Expanded the Python Tutorial to cover installation under Alpine Linux. _(Philipp Gackstatter)_
- We wrote a tutorial which is intended to [help newcomers contributing to libelektra](../tutorials/contributing-clion.md). _(Thomas Bretterbauer)_
- We fixed various broken links in the documentation. _(René Schwaiger)_
- Fix finding of jni.h library. _(Dmytro Moiseiuk)_
- Added license for asciinema. _(Anastasia @nastiaulian)_
- We incorporated [`kdb-introduction`](https://github.com/ElektraInitiative/libelektra/blob/5f6e902af5ac8f4c4228fc0859b7ecef7707bbfb/doc/help/kdb-introduction.md) into the [man page for `kdb`](https://www.libelektra.org/man-pages/kdb) _(Markus Raab)_

[markdown link converter]: https://master.libelektra.org/doc/markdownlinkconverter

## Tests

- We now test the [Directory Value Plugin](https://www.libelektra.org/plugins/directoryvalue) with additional test data. _(René Schwaiger)_
- The variables:

  - `SPEC_FOLDER`
  - `SYSTEM_FOLDER`
  - `USER_FOLDER`

  in the [inclusion file for shell test](../../tests/shell/include_common.sh.in) were set incorrectly, if the repository path contained space characters. _(René Schwaiger)_

- The [CFramework](https://master.libelektra.org/tests/cframework) now also compares the names of meta keys. _(René Schwaiger)_
- The [release notes check](../../scripts/build/run_check_release_notes) does not report an illegal number anymore, if the release notes were not updated at all. _(René Schwaiger)_
- We added a test for the keyhelper-class which checks if rebasePath calculates the new path for cascading target-keys correctly. _(Thomas Bretterbauer)_
- Enable MSR for the crypto and fcrypt tutorial ([#1981](https://github.com/ElektraInitiative/libelektra/issues/1981))._(Peter Nirschl)_
- We fixed the [Markdown Shell Recorder][] test for the command [`kdb get`](../help/kdb-get.md). _(René Schwaiger)_
- The tests

  - [`testscr_check_real_world`](../../tests/shell/check_real_world.sh),
  - [`testscr_check_resolver`](../../tests/shell/check_resolver.sh), and
  - [`testscr_check_spec`](../../tests/shell/check_spec.sh)

  now also works correctly, if the `user` and `system` directory file paths contain space characters. _(René Schwaiger)_

### Source Code Checks

- The formatting instructions printed by [`check_formatting`](https://master.libelektra.org/tests/shell/check_formatting.sh) now also work correctly, if

  - the `diff` output does not start with the test number added by CTest, and
  - you use a non-POSIX shell such as [`fish`](https://fishshell.com)

  . _(René Schwaiger)_

- We reformatted the CMake source code with cmake-format `0.5.4` and also [check the style of CMake code](../../tests/shell/check_formatting.sh) with this new version of the tool. _(René Schwaiger)_
- We now check the source code of the repository with [LGTM][]. _(René Schwaiger)_
- We fixed various warnings about

  - missing or duplicated include guards,
  - undefined behavior,
  - incorrect format specifiers,
  - unnecessary statements,
  - short names for global variables, and
  - empty `if`-statements

  reported by [LGTM][]. _(René Schwaiger)_

[lgtm]: https://lgtm.com

## Build

### CMake

- We now disable the option `INSTALL_SYSTEM_FILES` by default. This change makes it possible to install Elektra using [Homebrew](https://brew.sh) on Linux without any changes to [Elektra’s Linuxbrew formula](https://github.com/Homebrew/linuxbrew-core/blob/master/Formula/elektra.rb). _(René Schwaiger)_
  Add `-DINSTALL_SYSTEM_FILES=ON` for previous behavior.
- The build system now rebuilds the [JNA binding](https://www.libelektra.org/bindings/jna) with Maven, if you change any of the Java source files of the binding. _(René Schwaiger)_
- `testshell_markdown_tutorial_crypto` is not compiled and executed if `gen-gpg-testkey` is not part of TOOLS. _(Peter Nirschl)_
- Plugin tests are now only added, if `BUILD_TESTING=ON`. _(Klemens Böswirth)_
- The symbol list for the static version is now exported directly from a CMake function. _(Klemens Böswirth)_
- Building Elektra with enabled [`io_glib`](../../src/bindings/io/glib) binding does not require libuv anymore. _(René Schwaiger)_

### Docker

#### Alpine Linux

- Our [Docker image for Alpine Linux](../../scripts/docker/alpine) now uses the base image for Alpine Linux 3.9. _(René Schwaiger)_
- We added PEGTL to the [Alpine Docker image](../../scripts/docker/alpine). _(René Schwaiger)_

#### Debian

- We now use the default JDK on Debian sid, since the package `openjdk-8-jdk` is not available in the official unstable repositories anymore. _(René Schwaiger)_
- We added

  - [Bison](https://www.gnu.org/software/bison/), and
  - YAEP

  to the [image for Debian sid](../../scripts/docker/debian/sid/Dockerfile). _(René Schwaiger)_

- We now offer images for the latest stable version of Debian codenamed [“buster”](../../scripts/docker/debian/buster). _(René Schwaiger)_

#### Ubuntu

- We added a [Dockerfile for Ubuntu Disco Dingo](../../scripts/docker/ubuntu/disco/Dockerfile). _(René Schwaiger)_

#### Other Updates

- The Docker images for

  - [Debian stretch](https://git.libelektra.org/blob/799fecd94dcb482ea9338facaf63d39f8e5ab5bd/scripts/docker/debian/stretch/Dockerfile), and
  - [Debian sid](../../scripts/docker/debian/sid/Dockerfile),

  now include the Python YAML library recommended by [cmake-format](https://github.com/cheshirekow/cmake_format). _(René Schwaiger)_

### Vagrant

- The [Vagrant file for Ubuntu Artful Aardvark](../../scripts/vagrant/ubuntu/artful32/Vagrantfile) now installs the Python YAML library recommended by [cmake-format](https://github.com/cheshirekow/cmake_format). _(René Schwaiger)_

## Infrastructure

### Cirrus

- We added the build job `🔗 Check`, which checks the documentation for broken links. _(René Schwaiger)_

### Jenkins

- We disabled the tests:

  - `testmod_crypto_botan`,
  - `testmod_crypto_openssl`,
  - `testmod_dbus`,
  - `testmod_dbusrecv`,
  - `testmod_fcrypt`,
  - `testmod_gpgme`, and
  - `testmod_zeromqsend`

  , since they are [known to fail in high load scenarios](https://issues.libelektra.org/2439). _(René Schwaiger)_

- We added deprecated plugins to the tests. _(Markus Raab)_
- We increased the automatic timeout for jobs that show no activity from 5 to 10 minutes. _(René Schwaiger)_
- We improved the exclusion patterns for the [Coveralls coverage analysis](https://coveralls.io/github/ElektraInitiative/libelektra). _(René Schwaiger)_
- We now again build the API documentation of [master](https://doc.libelektra.org/api/master) and we now also build the API documentation of [PRs](https://doc.libelektra.org/api/pr/). _(Markus Raab)_
- We added buster build jobs. _(Markus Raab)_

### Restyled

- We added a [configuration file](../../.restyled.yaml) for [Restyled][]. Currently [Restyled][] monitors changes to Shell code in pull requests and fixes code that does not fit the [coding guideline](../CODING.md), by adding additional formatting commit to PRs. _(René Schwaiger)_

[restyled]: https://restyled.io

### Travis

- We removed the build job for the Haskell binding and Haskell plugin. For more information, please take a look [here](https://issues.libelektra.org/2751). _(Klemens Böswirth)_
- We always use GCC 9 for the build job `🍏 GCC`. This update makes sure that the build job succeeds, even if Homebrew
  adds a new major version of the compiler. _(René Schwaiger)_
- We simplified our Travis configuration file, removing various unnecessary and unused code. In this process we also got rid of the caching directives, we previously used to speed up the Haskell build job `🍏 Haskell`. _(René Schwaiger)_

## Website

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

- Our entry for Elektra has been approved in the Free Software Directory: https://directory.fsf.org/wiki/Elektra
- Added GitHub build status badges to website _(hesirui)_
- We updated part of a test for the [snippet converter](https://www.libelektra.org/conversion). _(René Schwaiger)_
- Fixed anchor links on the website _(hesirui)_
- Added Docsearch in top-bar of website _(hesirui)_

## Outlook

We are currently working on following topics:

- Go bindings and improved Web-UI _(Raphael Gruber)_
- semantic 3-way merging _(Dominic Jaeger)_
- improved error handling _(Michael Zronek)_
- Rust bindings _(Philipp Gackstatter)_
- elektrify LCDproc _(Klemens Böswirth)_ and _(Jakob Fischer)_
- configuration upgrades _(Lukas Kilian)_
- default storage _(René Schwaiger)_ and _(Jakob Fischer)_
- shell completion _(Ulrike Schäfer)_
- improved developer experience _(Hani Torabi)_
- Ansible bindings _(Thomas Waser)_
- misconfiguration tracker _(Vanessa Kos)_
- plugin interface improvements _(Vid Leskovar)_

## Statistics

About 40 authors changed 1278 files with 49409 insertions(+) and 13883 deletions(-) in 2025 commits.

We closed [114 issues](https://github.com/ElektraInitiative/libelektra/milestone/20?closed=1)
for this release.

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.0.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.0.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.0.tar.gz.hashsum?raw=true)

- name: /home/markus/elektra-0.9.0.tar.gz
- size: 7390149
- md5sum: 5cf9935515aba0567d6014a3693e415a
- sha1: 05ebe99c87b89a7cac58bf45cd3aff200cc1fd8d
- sha256: fcdbd1a148af91e2933d9a797def17d386a17006f629d5146020fe3b1b51ddd8

The release tarball is also available signed by Markus Raab using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.0.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.0.tar.gz.gpg?raw=true)

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.0/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.0).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.0-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.1-release)

## Highlights

- We are working on integrating Elektra into [KDE](https://kde.org/). A new Elektra plugin called `kconfig` was added which can read KDE's kconfig ini files. Additionally we are working on a [fork](https://github.com/ElektraInitiative/kconfig) of KDE's `KConfig` configuration system and patching it to use libelektra. _(Dardan Haxhimustafa)_ and _(Felix Resch)_
- The [elektra](https://crates.io/crates/elektra) and [elektra-sys](https://crates.io/crates/elektra-sys) crates have been published to crates.io for easier usage of our Rust binding. _(Philipp Gackstatter)_
- We improved our [Go bindings](https://github.com/ElektraInitiative/go-elektra). _(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)`](https://www.libelektra.org/man-pages/kdb-gen).

If you specifically want to use it with the High-Level API take a look at [this tutorial](https://www.libelektra.org/tutorials/high-level-api).

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](https://build.libelektra.org) and [website](https://www.libelektra.org) to up-to-date hardware. _(Markus Raab and Djordje Bulatovic)_
- Elektra now has a technical preview of a new [merge library](../tutorials/cmerge.md). It is written in C99 and can currently be used with [`kdb cmerge`](../help/kdb-cmerge.md). _(Dominic Jäger)_
- We make it easier for new developers to join Elektra, e.g., see new [get started](../../doc/GETSTARTED.md). _(Hani Torabi)_
- We made many cleanups, to get Elektra ready for 1.0!

## Plugins

The following section lists news about the [plugins](https://www.libelektra.org/plugins/readme) 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](../../src/plugins/yajl) , and
- [YAML CPP](../../src/plugins/yamlcpp)

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)_

[markdown shell recorder]: https://master.libelektra.org/tests/shell/shell_recorder/tutorial_wrapper

### Spec

- There is now the config key `missing/log` that allows logging of all missing `require`d 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](../../src/plugins/type/README.md) 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](https://www.libelektra.org/libraries/readme) 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 functions of `kdbproposal.h`:
  - `elektraKsToMemArray` was moved to `kdbease.h`,
  - `elektraLookupOptions` was moved to `kdbprivate.h`,
  - `keySetStringF` was moved to `kdbinternal.h`,
  - Removed `ksPrev` and `elektraKsPrev`,
  - Removed `elektraRenameKeys` and replaced it with `ksRenameKeys`. _(Philipp Gackstatter)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme). This section keeps
you up-to-date with the multi-language support provided by Elektra.

- We removed the Haskell and GI bindings. _(Markus Raab)_
- Avoid unnecessary copying std::string where possible (setString and setMeta only). _(Manuel Mausz)_
- CPP: add `Key::is{Name,Value,Meta}Locked`. _(Manuel Mausz)_
- GLIB: removed `gelektra_keyset_resize`. _(Manuel Mausz)_
- GLIB: removed `gelektra_keyset_rewind`, `gelektra_keyset_next`, `gelektra_keyset_current`, `gelektra_keyset_getcursor`, `gelektra_keyset_setcursor`. _(Manuel Mausz)_
- GLIB: renamed `gelektra_keyset_atcursor` to `gelektra_keyset_at`. _(Manuel Mausz)_
- gsettings: adapt iterator. _(Manuel Mausz)_
- SWIG: Add `KeyNotFoundException` exception. _(Manuel Mausz)_
- SWIG: Fix KeySet equality operators. _(Manuel Mausz)_
- SWIG/Python: `hash(key)` will throw unless the key name is locked. _(Manuel Mausz)_
- SWIG/Python: Add operator overloadings for `len(Key)`, `repr(Key)`, `str(KeySet)`, `repr(KeySet)`. _(Manuel Mausz)_
- SWIG/Python: Add alternative Key constructor `Key(name, value, [dict])`. _(Manuel Mausz)_
- SWIG/Python: Add `KeySet.extend([key1, key2,...])` and `KeySet.append(key1, key2, ...)`. _(Manuel Mausz)_
- SWIG/Python: Add `KeySet.append(key_name, key_value, key_opts)` which directly creates and appends a key. _(Manuel Mausz)_
- SWIG/Python: Add `KeySet.unpack_names()`, `KeySet.unpack_basenames()`, `KeySet.filter(func)`, `KeySet.filter_below(where)`, `Key.array_elements()`. _(Manuel Mausz)_

### Java

- Completely overhauled the Java binding to be able to use Elektra plugins directly. A new PluginLoader can load Elektra plugins or a native implemented Java plugin.
  All Plugins now implement the new [Plugin](../../src/bindings/jna/libelektra/src/main/java/org/libelektra/Plugin.java) interface.
  For an example see the [test case](../../src/bindings/jna/libelektra/src/test/java/org/libelektra/PluginLoaderIT.java). _(Michael Zronek)_
- Upgraded maven dependencies for Java binding _(Michael Zronek)_
- The Java binding now supports the [error codes](../decisions/6_implemented/error_codes.md) in a native way. All exceptions contain the necessary information. _(Michael Zronek)_
- Further improved the Java binding such as wording and documentation. _(Michael Zronek)_

### Rust

- Add the `elektra-sys` crate which contains raw bindings to libelektra for Rust. _(Philipp Gackstatter)_
- Add the `elektra` crate which contains safe wrapper methods for the raw bindings. The crate contains bindings for the low-level API, which means that the data types `Key` and `KeySet` can now safely be used from Rust. The Rust version of the API has been designed to take advantage of Rust's type system and to be in accordance with the memory safety of Rust. For instance, the Key has been divided into `StringKey` and `BinaryKey`, to prevent type mismatches at compile-time. With the binding for `KDB`, one can take advantage of the elektra ecosystem from Rust. See the [Readme](../../src/bindings/rust/README.md) for more. _(Philipp Gackstatter)_
- Rewrote the `KDBError` to follow the specification fully and in particular allow catching out of memory errors by catching resource errors. _(Philipp Gackstatter)_
- Added a `keyset!` macro to easily create a keyset with many keys in a single invocation. _(Philipp Gackstatter)_

## Tools

- `KDB_EXEC_PATH`, which can be used to add further external tools to `kdb`, now supports `:` to separate paths.
  `kdb list-tools` and `run_env` were improved to take advantage of this. _(Markus Raab)_
- Checks for `kdbCommit` have been added to [kdb plugin-check](../help/kdb-plugin-check.md). _(Vid Leskovar)_
- Added PID file config setting for kdb-run-rest-frontend _(Markus Raab)_
- Added `kdb meta-show` command which prints out all metadata along with its values for a given key. _(Michael Zronek)_
- Removed `kdb vset` as it does not properly put metadata to the spec namespace. _(Michael Zronek)_
- Renamed kdb plugin commands following a hierarchical structure. `kdb info` is now `kdb plugin-info`, `kdb check` is now `kdb plugin-check` and `kdb list` is now `kdb plugin-list`. We also removed the obsolete `kdb fstab`. _(Philipp Gackstatter)_
- Renamed kdb meta commands:
  - `kdb getmeta` is now `kdb meta-get`
  - `kdb lsmeta` is now `kdb meta-ls`
  - `kdb showmeta` is now `kdb meta-show`
  - `kdb rmmeta` is now `kdb meta-rm`
  - `kdb setmeta` is now `kdb meta-set` _(Philipp Gackstatter)_
- Fix test tool `gen-gpg-testkey` by giving a narrower GPG key description. Fixes mismatches with existing GPG keys that contain "elektra.org" as e-mail address. _(Peter Nirschl)_
- `kdb list-commands` and `kdb plugins-list` now sort their output in an alphabetical order _(Anton Hößl)_
- `kdb plugin-list` does now mention in the helptext that with option `-v` the output is sorted by the plugin status _(Anton Hößl)_
- `kdb import`, `kdb export` and `kdb editor` now search the plugin database for suitig plugins so it's now possible to run `kdb export /hello json` instead of having to specify the plugin for the desired format directly. _(Anton Hößl)_
- `get` and `mount`: Remove dependency on `kdbprivate.h` _(Philipp Gackstatter)_

## Scripts

- We structured the [scripts](/scripts). _(Markus Raab)_
- Removed the scripts

  - `scripts/elektra-merge`,
  - `scripts/elektra-mount`,
  - `scripts/elektra-umount`,
  - `convert-fstab`,
  - `convert-hosts`,
  - `convert-inittab`,
  - `convert-users`,
  - `scripts/benchmark_libsplit.sh`,
  - `scripts/zsh` and
  - `example-xorg`. _(Markus Raab)_

- Renamed `scripts/run_dev_env` to `scripts/dev/run_env`. _(Markus Raab)_
- The script [`draw-all-plugins`](../../scripts/dev/draw-all-plugins) now also works properly, if the repository path contains space characters. _(René Schwaiger)_
- The script [`link-checker`](../../scripts/link-checker) now deduplicates the list of links before checking them. The timeout and amount of retries was also reduced.
  Lastly the script now supports a whitelist. Any link stored in [`tests/linkchecker.whitelist`](../../tests/linkchecker.whitelist) will not be checked. _(Klemens Böswirth)_
- We removed a script used to compare the runtime performance of YAML plugins. _(René Schwaiger)_
- Cleanup: separation of dev, admin and completion scripts. _(Markus Raab, Rene Schwaiger)_
- Pre-commit hook `pre-commit-check-formatting` now lives in [`scripts/dev/pre-commit-check-formatting`](../../scripts/dev/pre-commit-check-formatting). _(Klemens Böswirth)_
- The new script `reformat-javascript` formats the JavaScript code of the repository using the tool [`prettier`](https://prettier.io). _(René Schwaiger)_
- We renamed
  - the script `reformat-source` to `reformat-c`, and
  - the script `reformat-shfmt` to `reformat-shell`. _(René Schwaiger)_
- The script [cmake-format](../../scripts/dev/reformat-cmake) now requires `cmake-format` 0.6. _(René Schwaiger)_
- The new script `reformat-java` formats the Java code in the repository using [`clang-format`](https://clang.llvm.org/docs/ClangFormat.html). _(René Schwaiger)_
- The [Markdown Shell Recorder][] now also works correctly on FreeBSD. _(René Schwaiger)_

## Documentation

- Added a tutorial on how to write language bindings. Visit our new [README](../tutorials/language-bindings.md).
  _(Michael Zronek, Raphael Gruber, Philipp Gackstatter)_
- Clarified subtyping in the language bindings tutorial. _(Michael Zronek)_
- A [second tutorial](../tutorials/highlevel-bindings.md) on writing bindings for the high-level API was created as well. _(Klemens Böswirth, Raphael Gruber)_
- Added [info](../../src/plugins/xerces/README.md) on how to include xerces plugin with homebrew installation. _(Anton Hößl)_
- The [compile instructions](../COMPILE.md) do not assume that you use `make` or `gcc` to build Elektra anymore. _(René Schwaiger)_
- Add hints about reformatting with docker. _(Dominic Jäger)_
- Add instructions about sourcing on FreeBSD. _(Dominic Jäger)_
- Add information on debuggers to main testing documentation. _(Dominic Jäger)_
- Added design decision for error code implementations. _(Michael Zronek)_
- Fixed some typos and links in the documentation and add new iterate example. _(Philipp Gackstatter)_
- Clarified warnings metadata in the [error-handling guideline](../dev/error-handling.md). _(Michael Zronek)_
- We fixed minor spelling mistakes in the documentation. _(René Schwaiger)_
- Corrected buildserver documentation. _(Djordje Bulatovic)_
- Add merge library into kdbset example. _(Dominic Jäger)_
- We updated links for the INI parsing library Nickel. _(René Schwaiger)_
- Added some information about [contributing](../../.github/CONTRIBUTING.md) to Elektra. _(Hani Torabi)_

## Tests

- We changed how the `formatting test` detects code differences. This update should get rid of transient errors as [reported here](https://issues.libelektra.org/2927#issuecomment-528058641). _(René Schwaiger)_
- We disabled the test for the conversion engine. For more information, please take a look at [issue #3086](https://issues.libelektra.org/3086). _(René Schwaiger)_
- We disabled the test `testmod_zeromqsend` from the command `kdb run_all`, since it caused timeouts in high load scenarios. _(Mihael Pranjić)_
- The (Markdown) [Shell Recorder](../../tests/shell/shell_recorder/README.md) now prints the protocol for a failed test, even if the test modified the database permanently. _(René Schwaiger)_
- We rerun ctest twice to ignore temporary build failures. _(Markus Raab)_

## Build

### CMake

- `kdbtypes.h` is now generated directly via a CMake `configure_file` call. _(Klemens Böswirth)_
- The variable `ELEKTRA_STAT_ST_SIZE_F` now contains the correct format specifier for the `st_size` member of the `stat` struct on macOS. _(René Schwaiger)_
- We simplified and unified the CMake code for the Shell Tests and the [Shell Recorder](../../tests/shell/shell_recorder). _(René Schwaiger)_
- CMake now prints warnings about missing man pages. _(René Schwaiger)_
- The build system does not update a man page in the folder [doc/man](../man) any more, if ronn only changed the creation date of the man page. _(René Schwaiger)_

### Compilation

- We now have a [setup for proper symbol versioning](../dev/symbol-versioning.md). _(Klemens Böswirth)_
- We do not use implicit typing in the code of the `conditionals` and `yamlcpp` plugin any more. After this update, the code compiles without any warnings, even though we now use the compiler switch `-Wconversion`. _(René Schwaiger)_
- JNA and JNI are not built concurrently anymore to avoid [dependency resolution fails](https://jira.apache.org/jira/browse/MDEP-518). _(Michael Zronek)_

### Docker

- Added [Dockerfile for Ubuntu Bionic](../../scripts/docker/ubuntu/bionic/Dockerfile) _(Djordje Bulatovic)_
- We removed all Haskell packages from the Dockerfiles in the folder [scripts/docker](../../scripts/docker). _(René Schwaiger)_
- We added a basic [Dockerfile for Arch Linux](../../scripts/docker/arch/Dockerfile). _(René Schwaiger)_
- We updated the [Dockerfile for Alpine Linux](../../scripts/docker/alpine). _(René Schwaiger)_

### Vagrant

- We added a [Vagrantfile](../../scripts/vagrant/freebsd/README.md) for a virtual machine based on FreeBSD 12. _(René Schwaiger)_

### Other

- The reformatting script now checks that the correct version of `cmake-format` is used. _(Klemens Böswirth, René Schwaiger)_
- Improved various error messages and synchronized documentations. _(Michael Zronek)_
- Improved `range` plugin error message. _(Michael Zronek)_
- Improved error codes documentation to clarify the hierarchy for developers. _(Michael Zronek)_
- Release notes now use git's union merge driver. _(Dominic Jäger)_
- Updated asciinema recording to correctly use `sudo`. _(Michael Zronek)_
- Add pkg-config file for kdbmerge. _(Raphael Gruber)_

## Infrastructure

### Cirrus

- The `🔗 Check` build job now merges PRs before checking links. _(Klemens Böswirth)_
- We enabled logging in the build job `🍎 Clang`. This update makes sure that Elektra’s logging code compiles without warnings on macOS. _(René Schwaiger)_
- All macOS build jobs now use Xcode `11.1` instead of Xcode `10.1`. _(René Schwaiger)_
- We removed all non-POSIX shell code from the [Cirrus configuration file](../../.cirrus.yml). _(René Schwaiger)_
- The macOS build jobs now use Ruby `2.6`. _(René Schwaiger)_
- We do not call `ninja` directly anymore. Instead we use `cmake --build`. This has the advantage that we do not have to care about the Generator used by CMake. _(René Schwaiger)_
- We added the build job `😈 ASAN`, which builds and executes Elektra on FreeBSD with enabled [AddressSanitizer](https://github.com/google/sanitizers/wiki/AddressSanitizer). _(René Schwaiger)_
- We now store common commands in one place at the top of the configuration file. This makes it easier to selectively disable certain build jobs. _(René Schwaiger)_
- The new job `📚 Check` checks

  - that the [man pages](../man) are up-to-date, and
  - that building the PDF version of the Doxygen documentation works. _(René Schwaiger)_

- The new build job `🐧 Fedora` builds and tests Elektra on Fedora Linux. _(René Schwaiger)_

### Jenkins

- We upgraded all servers to Buster. _(Markus Raab)_
- Jenkins does not auto cancel build jobs of the `master` branch anymore. _(René Schwaiger)_
- Updated xUnit plugin in Jenkinsfile. _(Djordje Bulatovic)_

### Restyled

- [Restyled](https://restyled.io) now also formats Markdown files with [`prettier`](https://prettier.io). _(René Schwaiger)_

### Travis

- The build job `🍏 GCC` now uses the [Travis Homebrew addon](https://docs.travis-ci.com/user/installing-dependencies/#installing-packages-on-macos) to install dependencies. _(René Schwaiger)_
- We now build and test Elektra on Ubuntu `18.04` (Bionic Beaver) instead of Ubuntu `16.04` (Xenial Xerus). _(René Schwaiger)_

## 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 sub menu _Getting Started_ in the menu _Documentation_ to _About Elektra_ and removed the sub-sub-menus _Compiling_, _Installation_ and _Tutorials_. These sub-sub-menus are now sub-menus of _Documentation_. A new sub menu labeled _Get Started_ added to the menu _Documentation_ with some newcomer-friendly information. Renamed the _Getting Started_ sub menu in _Development_ to _Contribute to Elektra_. The green button on the main page is routed to the new _Get Started_ page. _(Hani Torabi)_
- The website now lives in the folder [website](/src/tools/website) to avoid confusion with the REST backend of the Web-UI. _(Markus Raab)_
- Improve main page of website, restructure getting started. _(Markus Raab)_

## Outlook

We are currently working on following topics:

- Elektrify KDE _(Dardan Haxhimustafa)_ and _(Felix Resch)_
- Elektrify LCDproc _(Klemens Böswirth)_ and _(Jakob Fischer)_
- Reduce the number of merge conflicts in 3-way merge. _(Dominic Jäger)_
- Go bindings and improved Web-UI _(Raphael Gruber)_
- Improved Error handling _(Michael Zronek)_
- New default storage _(René Schwaiger)_ and _(Jakob Fischer)_
- Shell completion _(Ulrike Schäfer)_
- Improve Elektra developer experience _(Hani Torabi)_
- Ansible bindings _(Thomas Waser)_
- Plugin interface improvements _(Vid Leskovar)_

## Statistics

We closed [75 issues](https://github.com/ElektraInitiative/libelektra/milestone/21?closed=1) for this release.

About 29 authors changed 1651 files with 82267 insertions(+) and 41690 deletions(-) in 1623 commits.

Thanks to all authors for making this release possible!

## Finished Thesis

- [Klemens Böswirth](https://www.libelektra.org/ftp/elektra/publications/boeswirth2019highlevel.pdf):
  We explore the feasibility of using Elektra in a real-world project. We focused especially on using
  the high-level API with code-generation. In the thesis, we implemented new versions of LCDproc, one
  with the low-level API and one with the high-level API. Then we did some benchmarks to compare them.
  Our results indicate, that Elektra is very much usable in real-world projects. However, we also found
  that there is still potential for further optimizations.
- Mihael Pranjić:
  We design a binary storage format for Elektra's data structures and implement a [cache plugin](https://www.libelektra.org/plugins/cache) based on the format. The cache plugin leverages the `mmap()` system call to read and write data. Our cache implementation for Elektra's data structures makes the access to the KDB more than 80 times faster for larger data sets. The penalty for cache misses is below 20 percent for reasonably sized data sets.

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.1.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.1.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.1.tar.gz.hashsum?raw=true)

- author: mpranj
- file: elektra-0.9.1.tar.gz
- size: 7534156
- md5sum: 42ff587adb7c3f15807ac4dae6722261
- sha1: bf250260a4efa20e5444f0a7f0027430bc7aa8a0
- sha256: df1d2ec1b4db9c89c216772f0998581a1cbb665e295ff9a418549360bb42f758

The release tarball is also available signed by Mihael Pranjic using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.1.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.1.tar.gz.gpg?raw=true)

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.1/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.1).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.1-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.2 Release

- guid: ea79f59e-f471-4658-a11b-1371802814c2
- author: Mihael Pranjić
- 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.2-release)

## Highlights

- KDE integration
- GNOME Integration
- `elektrad` rewritten in Go

### KDE Integration

We created a [fork](https://github.com/ElektraInitiative/kconfig) of [KDE's](https://kde.org/) `KConfig` configuration system and patched it to use libelektra. We have done some initial testing and replaced the `KConfig` library for [Kate](https://kate-editor.org/) and [KDevelop](https://www.kdevelop.org/) 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](https://developer.gnome.org/gio/2.26/GSettingsBackend.html). Our implementation should be able to replace the widely used [dconf](https://wiki.gnome.org/Projects/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](https://www.libelektra.org/tools/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](https://github.com/ElektraInitiative/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](https://doc.libelektra.org/api/latest/html/group__kdb.html) 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](https://hub.docker.com/r/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](https://www.libelektra.org/plugins/readme):

- 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)_

[markdown shell recorder]: https://master.libelektra.org/tests/shell/shell_recorder/tutorial_wrapper

### 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](https://doc.libelektra.org/api/latest/html/group__keyset.html) as [array](../tutorials/arrays.md) if the parent contains the metakey `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](../../src/plugins/xmltool). _(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 metakey `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](https://www.libelektra.org/libraries/readme) 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](https://semver.org/). _(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](../tutorials/command-line-options.md).
  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](https://www.libelektra.org/bindings/readme). 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](../../src/tools/webd/README.md) has updated dependencies. _(Mihael Pranjić)_

## Scripts

- The [fish completion script](../../scripts/completion/kdb.fish) 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](../../scripts/dev/reformat-cmake) now reformats the code with `cmake-format` 0.6.3. _(René Schwaiger)_
- The scripts

  - [reformat-c](../../scripts/dev/reformat-cmake), and
  - [reformat-java](../../scripts/dev/reformat-java)

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

- The script [reformat-shell](../../scripts/dev/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`](../../doc/tutorials/validation.md) _(Anton Hößl)_
- We fixed some minor spelling mistakes. _(René Schwaiger)_
- We updated the man pages of the [`web`](../tutorials/install-webui.md) tool. _(René Schwaiger)_
- Updated documentation for Ubuntu-Bionic Packages. _(Djordje Bulatovic)_
- Fixed an old path of the reformatting script in the [`docker reformatting tutorial`](../tutorials/run_reformatting_script_with_docker.md) _(Jakob Fischer)_

## Tests

- We now use [Google Test](https://github.com/google/googletest) version `1.10` to test Elektra. _(René Schwaiger)_
- The C++ test code does not produce warnings about a missing macro argument for `...` any more. _(René Schwaiger)_
- Whitelisted many broken links. _(Mihael Pranjić)_
- Enabled regex in link checker. _(Mihael Pranjić)_
- The [formatting check](../../tests/shell/check_formatting.sh) now also works correctly, if it is invoked multiple times. _(René Schwaiger)_
- `KDB_EXEC_PATH` is not being set globally to contain the build directory any longer. _(Peter Nirschl)_
- Rewrite gpg-agent shutdown logic to use `fork` and `execv` instead of `system`. _(Peter Nirschl)_
- Removed a broken link from the link checker. _(Djordje Bulatovic)_

## Build

### Compilation

- We do not use implicit typing in the code of the

  - `augeas`,
  - `base64`, and
  - `blockresolver`

  plugin any more. After this update, the code compiles without any warnings, even though we now use the compiler switch `-Wconversion`. _(René Schwaiger)_

### Support

- Debian 9 “stretch” (oldstable) is now the oldest supported platform. _(René Schwaiger)_

### CMake

- Generating the build system now requires CMake `3.4` (released in November 2015). _(René Schwaiger)_
- We fixed warnings about CMake policy [CMP0078](https://cmake.org/cmake/help/latest/policy/CMP0078.html) and [CMP0086](https://cmake.org/cmake/help/latest/policy/CMP0086.html). _(René Schwaiger)_
- The CMake functions `add_msr_test` and `add_msr_test_plugin` do not export the list of required plugins as environment variable any more. _(René Schwaiger)_
- The CMake code of the code generation does not print warnings about unknown regex operators any more. _(René Schwaiger)_

### Docker

- We updated some of the software in the [Dockerfile for Debian sid](../../scripts/docker/debian/sid/Dockerfile). _(René Schwaiger)_
- Building the documentation Dockerfile for Debian Stretch works again. _(René Schwaiger)_
- Use Python 3, SWIG 4.0 and Ruby 2.5 in the [Dockerfile for Debian sid](../../scripts/docker/debian/sid/Dockerfile). _(Mihael Pranjić)_
- Disable python binding on `debian-unstable-full-clang` due to upstream [issue](https://github.com/ElektraInitiative/libelektra/issues/3379). _(Mihael Pranjić)_
- Use current ruby-dev on Debian sid image as Ruby 2.5 has been dropped. _(Mihael Pranjić)_

## Infrastructure

### Cirrus

- We fixed a minor problem with the package install procedure on macOS build jobs. _(René Schwaiger)_
- We updated the startup command for D-Bus on macOS. _(René Schwaiger)_
- We removed python2 (EOL and removed from homebrew). _(Mihael Pranjić)_
- Use latest macOS Catalina Xcode stable. _(Mihael Pranjić)_
- Use newer FreeBSD images and use image family instead of concrete image names. _(Mihael Pranjić)_
- Disable tcl plugin on FreeBSD images because of test failures (see #3353). _(Mihael Pranjić)_
- Disable curlget plugin for macOS jobs (see #3382). _(Mihael Pranjić)_
- Add more dependencies to Fedora image to cover many tests. _(Mihael Pranjić)_
- Installed Ruby 2.6 to test the ruby bindings and plugins. _(Mihael Pranjić)_
- Upgraded Fedora image to current stable (version 32). _(Mihael Pranjić)_

### Jenkins

- Fixed [coveralls](https://coveralls.io/github/ElektraInitiative/libelektra) coverage report. _(Mihael Pranjić)_
- The build jobs `debian-unstable-clang-asan` and `debian-unstable-full-clang` now use Clang 9 to compile Elektra. _(René Schwaiger)_
- Added the `Jenkins.monthly` in the Jenkins' scripts file. _(Djordje Bulatovic)_
- Enabled building packages for Bionic. _(Djordje Bulatovic)_
- Improve gpgme unit test stability. _(Peter Nirschl)_
- Publishing packages for Bionic to community. _(Djordje Bulatovic)_
- Added Fedora 32 image to main build stage, moved Fedora 31 to full build stage. _(Mihael Pranjić)_
- Fixed path for publishing in Jenkinsfile. _(Djordje Bulatovic)_
- Reliably build the rust bindings based on the same version, by adding back the `Cargo.lock` file. _(Philipp Gackstatter)_

### Restyled

- Restyled now also checks the formatting of C, C++ and Java code in the repository. _(René Schwaiger)_

### Travis

- Use newer Xcode 11.4 and ruby 2.6.5 on macOS builds and use macOS 10.15. _(Mihael Pranjić)_
- Disable curlget plugin for macOS jobs (see #3382). _(Mihael Pranjić)_

### Issue Tracker

- We now automatically close issues after one year of inactivity. _(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:

- Fix and re-enable website auto-deployment. _(Mihael Pranjić)_
- Update docker images for website frontend and backend to debian buster. Update dependencies to newer versions. _(Mihael Pranjić)_
- Remove obsolete parts from the website. _(Mihael Pranjić)_

## Outlook

We are currently working on following topics:

- Elektrify KDE _(Dardan Haxhimustafa)_, _(Felix Resch)_ and _(Mihael Pranjić)_
- Elektrify GNOME _(Mihael Pranjić)_
- Elektrify LCDproc _(Klemens Böswirth)_ and _(Jakob Fischer)_
- Packaging for popular Linux distributions _(Djordje Bulatovic)_
- Improve 3-way merge. _(Dominic Jäger)_
- Go bindings and improved Web-UI _(Raphael Gruber)_
- TOML plugin as new default storage _(Jakob Fischer)_
- Shell completion _(Ulrike Schäfer)_
- Improve Elektra developer experience _(Hani Torabi)_
- Ansible bindings _(Thomas Waser)_
- Plugin interface improvements _(Vid Leskovar)_

## Statistics

We closed [40 issues](https://github.com/ElektraInitiative/libelektra/milestone/22?closed=1) for this release.

About 23 authors changed 653 files with 15221 insertions(+) and 18890 deletions(-) in 815 commits.

Thanks to all authors for making this release possible!

## Finished Thesis

[René Schwaiger](https://github.com/sanssecours) finished [his thesis](https://github.com/sanssecours/Configuration-File-Parsing/releases) about parsing techniques and parsing tools for configuration files.

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.2.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.2.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.2.tar.gz.hashsum?raw=true)

- author: mpranj
- file: elektra-0.9.2.tar.gz
- size: 7416188
- md5sum: 6e92ebcbef31cdeab91d228b61456947
- sha1: 8f874de3e7a47baa55d7c5106efbbae635fff499
- sha256: 6f2fcf8aaed8863e1cc323265ca2617751ca50dac974b43a0811bcfd4a511f2e

The release tarball is also available signed by Mihael Pranjic using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.2.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.2.tar.gz.gpg?raw=true).

The following GPG Key was used to sign this release: 9C18145C22F9E746D743DEC59ECC0F4CF0359C7B

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.2/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.2).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.2-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.3 Release

- guid: 9b9e8889-0c77-45ce-8441-8bdf26a110ac
- author: Mihael Pranjić
- 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.3-release)

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/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](https://www.libelektra.org/plugins/toml).
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](https://toml.io).

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](https://www.libelektra.org/plugins/readme) 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](https://www.libelektra.org/plugins/toml), 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](https://www.libelektra.org/bindings/readme). 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](../../scripts/completion/kdb.fish) does not fail any more, if you try to complete a simple
  command that expects a namespace. For example, completing

  ```sh
  kdb ls ‸
  ```

  with the tab key (<kbd>⇥</kbd>) (`‸` represents the current cursor position) should work correctly again. _(René Schwaiger)_

- The formatting scripts using prettier now use [`npx`](https://www.npmjs.com/package/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](http://www.libelektra.org/docgettingstarted/goals). _(Markus Raab)_
- Describe hierarchy and limitations of [hosts plugin](https://www.libelektra.org/plugins/hosts). _(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](https://www.libelektra.org/decisions/readme),
  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](https://hub.docker.com/r/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](/src/tools/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](/doc/decisions), but some of them
are not finalized.

If you are interested in the discussions, please
[subscribe](https://issues.libelektra.org/3520).

## 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](https://github.com/ElektraInitiative/libelektra/milestone/24?closed=1) 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](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.3.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.3.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.3.tar.gz.hashsum?raw=true)

- 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 Pranjic using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.3.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.3.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 9C18145C22F9E746D743DEC59ECC0F4CF0359C7B

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.3/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.3).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.3-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.4 Release

- guid: a3f66c2f-ae6a-412b-bdbd-f8950adb2334
- author: Mihael Pranjić
- 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.4-release)

## Highlights

- Important Breaking Changes to key names et al. _[see below](#hl-1)_
- Debian and Fedora Packaging with CPack _[see below](#hl-2)_

<a id="hl-1"></a>

### Important Breaking Changes

- The structure of key names has been changed. [see below](#br-1) _(Klemens Böswirth)_ <br/>
  **This change breaks mountpoint configurations.**
  Please follow the upgrade procedure [shown below](#mountpoint-upgrade).
- 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](#br-2) _(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)_

<a id="br-1"></a>

#### 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 behavior of Elektra's key names and have already taken the two changes above into account, please refer to the newly created [key name documentation](../KEYNAMES.md) and [Python reference implementation](../../scripts/keynames.py).

- 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/#](/doc/METADATA.ini) 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.

<a id="mountpoint-upgrade"></a>

#### 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](https://issues.libelektra.org/3633).
>
> _You have been warned. Manually backup important data first._

For the migration you can use the following commands:

```sh
#! /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`

<a id="hl-2"></a>

### 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:

```sh
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`.

```sh
apt-get install libelektra5-all
```

##### RPM packages

Download our [.repo configuration file](https://rpms.libelektra.org/fedora-33/libelektra.repo) and add it to yum/dnf.

To get all packaged plugins, bindings and tools install:

```sh
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](../INSTALL.md).

#### 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](../INSTALL.md).

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](https://www.libelektra.org/plugins/readme) 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](https://en.wikipedia.org/wiki/.properties) (`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)_

[section syntax]: https://en.m.wikipedia.org/wiki/INI_file#Sections

### 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](https://en.wikipedia.org/wiki/.properties). 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](https://issues.libelektra.org/3561). _(René Schwaiger)_

### Yan LR

- The plugin now works (with and) requires [ANTLR `4.9`](https://github.com/antlr/antlr4/releases/tag/4.9). _(René Schwaiger)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

### Compatibility

<a id="br-2"></a>

- 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 will be stored as `warnings/#0`, 102nd as `warnings/#1` etc.

### Core

- `kdbSet` now properly handles, if the given `parentKey` is `NULL` or has read-only name, value or metadata. _(Klemens Böswirth)_

### Proposal

- Removed `elektraKeyGetMetaKeySet` and moved `keySetStringF` to the hosts plugin. _(Philipp Gackstatter)_
- Removed `ksPopAtCursor`. _(Philipp Gackstatter)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme). This section keeps
you up-to-date with the multi-language support provided by Elektra.

### Lua

- Remove ipairs support and add our own iterator to add support for Lua 5.4, since `__ipairs` was deprecated. _(Manuel Mausz)_

### JNA

- Fixed allocation not correctly conveyed on key set initialization _(Michael Tucek)_

### C++

- `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++.
  The array `ELEKTRA_NAMESPACES` can be used to iterate over all namespaces. _(Klemens Böswirth)_

### Ruby

- Enable `__declspec` attributes for Ruby 3.0. _(Mihael Pranjić)_

## Tools

- The kdb cmd-line tool outputs better error messages on wrong names like `user` or `user:` as `user:/` is now required. _(Markus Raab)_
- The QtGUI was updated to be compatible with the new key name structure. _(Klemens Böswirth)_

## Scripts

- We fixed the (possibly) infinitely running function `generate-random-string` in [check-env-dep](../../scripts/check-env-dep).
  _(René Schwaiger)_

## Documentation

- Finalize 1.0 [decisions](/doc/decisions). _(Markus Raab)_
- Update [API design document](/doc/DESIGN.md) _(Markus Raab and Stefan Hanreich)_
- Update [release instructions](../todo/RELEASE.md) _(Robert Sowula)_
- Changed API documentation terms [current, latest] to [latest, master].
  The API documentation of the latest release is now available at https://doc.libelektra.org/api/latest/html/ and of the current Git master at https://doc.libelektra.org/api/master/html/. _(Robert Sowula)_

## Tests

- Tests that use additional executables can now be installed and run via `kdb <testname>`.
  Existing tests have been update to support this. _(Klemens Böswirth)_
- Update source formatting check to clang-format 11. _(Mihael Pranjić)_

## Build

### CMake

- Use Lua 5.4 when available. _(Mihael Pranjić)_
- Force `RTLD_NODELETE` on dlopen() when the `ENABLE_ASAN` CMake option is used. This enables ASAN to find symbols which otherwise might be unloaded. _(Mihael Pranjić)_

### Docker

- We added a Docker image for [building the documentation on Debian Sid](https://github.com/ElektraInitiative/libelektra/blob/799fecd94dcb482ea9338facaf63d39f8e5ab5bd/scripts/docker/debian/sid/doc.Dockerfile). _(René Schwaiger)_
- We removed the Docker image for building the documentation on Debian Stretch. _(René Schwaiger)_
- Add Fedora 33 Dockerfile for Cirrus and Jenkins CI. _(Mihael Pranjić)_
- Debian Sid: update to clang 11. _(Mihael Pranjić)_

## Infrastructure

### Cirrus

- Upgrade Cirrus Fedora docker image to Fedora 33. _(Mihael Pranjić)_
- Upgrade to Ruby 3.0 for macOS builds. _(Mihael Pranjić)_

### GitHub Actions

- We added a build job that translates Elektra with GCC on macOS. _(Mihael Pranjić, René Schwaiger)_

### Jenkins

- We refactored shared code between pipelines into a [Jenkins Shared Library](https://github.com/ElektraInitiative/jenkins-library). _(Robert Sowula)_
- We now use Debian Sid to build the documentation instead of Debian Stretch. The Doxygen version in Debian stretch [contains a bug](https://github.com/doxygen/doxygen/issues/6456) that causes the generation of the PDF documentation to fail. _(René Schwaiger)_
- Use Fedora 33 and 32, drop Fedora 31 use in Jenkins. _(Mihael Pranjić)_
- The Main and Release Pipeline now creates packages for Debian Buster, Ubuntu Bionic, Ubuntu Focal and Fedora-33. These packages are also installed and automatically tested before they are published. To install these packages, please refer to our [Install documentation](../INSTALL.md). _(Robert Sowula)_
- We updated our Release Pipeline to push changes directly to our Git repositories. _(Robert Sowula)_

### Travis

- Move macOS GCC 10 build job to GitHub Actions. _(Mihael Pranjić)_

## Website

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

## Outlook

We are currently working on following topics:

- Elektrify KDE _(Dardan Haxhimustafa)_, _(Felix Resch)_ and _(Mihael Pranjić)_
- 1.0 API _(Stefan Hanreich)_ and _(Klemens Böswirth)_
- Improve Java Development Experience _(Michael Tucek)_
- Elektrify GNOME _(Mihael Pranjić)_
- Continious Releases _(Robert Sowula)_
- KDB access using FUSE _(Alexander Firbas)_
- Default TOML plugin _(Jakob Fischer)_
- Improve Plugin Framework _(Vid Leskovar)_
- Improve 3-way merge _(Dominic Jäger)_
- Shell completion _(Ulrike Schäfer)_
- Ansible bindings _(Thomas Waser)_

## Statistics

We closed [21 issues](https://github.com/ElektraInitiative/libelektra/milestone/25?closed=1) for this release.

About 13 authors changed 1280 files with 26471 insertions(+) and 29959 deletions(-) in 428 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.4.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.4.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.4.tar.gz.hashsum?raw=true)

- name: elektra-0.9.4.tar.gz
- size: 7562103
- md5sum: 670a3e9ab225ef53cb2db9058225d7d9
- sha1: 2a5729462fc61694f2b81ca7dbd3620f09cbbf72
- sha256: e1f11f063ab262ce056238ca17aa60442a450a0bb6c5f57a9959df0365576bc6

The release tarball is also available signed using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.4.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.4.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.4/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.4).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.4-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.5 Release

- guid: 8a56a045-3d2e-427d-84bb-8256635159d2
- author: Mihael Pranjić
- 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.5-release)

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/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](#hl-1)_
- Ongoing improvements of Java bindings and publishing of bindings to maven central for easy dependency integrations in Java projects

<a id="hl-1"></a>

### `kdbOpen` Contracts

The signature of `kdbOpen` has been changed from

```c
KDB *  kdbOpen (Key * errorKey);
```

to

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

You can use `kdbOpen (NULL, errorKey)` to get the same behavior 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:

```c
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](../dev/kdb-contracts.md)

## Plugins

The following section lists news about the [plugins](https://www.libelektra.org/plugins/readme) 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](https://github.com/ElektraInitiative/libelektra/issues/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](https://www.libelektra.org/libraries/readme) of Elektra.

### Compatibility

- `keyCopy` and `keyDup` now take an additional flag. See [below](#key-copy).
- `kdbEnsure` was removed and integrated into `kdbOpen`, which now takes an additional `KeySet * contract` parameter. See [above](#hl-1)

### Core

<a id="key-copy"></a>

- 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](#hl-1)_ _(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 key`system:/elektra/io/binding`in 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 are`system:/elektra/notification/callback`and`system:/elektra/notification/context` respectively.
  _(Klemens Böswirth)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme). 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](/doc/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](https://github.com/ElektraInitiative/go-elektra) 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](/doc/tutorials/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](/doc/tutorials/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_BUS_SOCKET` manually (as workaround). _(Mihael Pranjić)_
- Use macOS Big Sur images. _(Mihael Pranjić)_

### GitHub Actions

- Fix issues with `dbus` and java paths, exclude `jni`. _(Mihael Pranjić)_

### Jenkins

- Update daily job to always keep the latest Docker images containing installed Elektra packages that were build on master or during release. _(Robert Sowula)_
- Add a cleanup of the aptly database to the daily job. _(Robert Sowula)_

## Website

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

- It is now possible to have two links on the same line of a Markdown file rendered on the website. _(Klemens Böswirth)_
- The file [doc/KEYNAMES.md](../KEYNAMES.md) is now rendered on the website. _(Klemens Böswirth)_
- Update `ini` dependency. _(Dependa Bot)_
- Update many dependencies (Node 14.x LTS, angular, bootstrap, ..) and fix broken RSS feed permalinks. _(Mihael Pranjić)_

## Outlook

We are currently working on following topics:

- Elektrify KDE _(Dardan Haxhimustafa)_, _(Felix Resch)_ and _(Mihael Pranjić)_
- 1.0 API _(Stefan Hanreich)_ and _(Klemens Böswirth)_
- Improve Java Development Experience _(Michael Tucek)_
- Elektrify GNOME _(Mihael Pranjić)_
- Continious Releases _(Robert Sowula)_
- KDB access using FUSE _(Alexander Firbas)_
- Default TOML plugin _(Jakob Fischer)_
- Improve Plugin Framework _(Vid Leskovar)_
- Improve 3-way merge _(Dominic Jäger)_
- Shell completion _(Ulrike Schäfer)_
- Ansible bindings _(Thomas Waser)_

## Statistics

We closed [20 issues](https://github.com/ElektraInitiative/libelektra/milestone/26?closed=1) for this release.

About 19 authors changed 515 files with 19081 insertions(+) and 10602 deletions(-) in 375 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.5.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.5.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.5.tar.gz.hashsum?raw=true)

- name: elektra-0.9.5.tar.gz
- size: 7636892
- md5sum: 2245727ed0042645d98de34a1872fbb4
- sha1: c0181bbee212a46b5a9eda3180ff7673f657d6ed
- sha256: 0b6ee9d6bf13c3749f4d014df444606f84a2f5a797a541002f8d4e745007c3a5

The release tarball is also available signed using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.5.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.5.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.5/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.5).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.5-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.6 Release

- guid: ad3d9308-4019-46dc-9de0-b3b82de5302a
- author: Mihael Pranjić
- pubDate: Mon, 07 Jun 2021 09:48:41 +0200
- shortDesc: Java Fixes, Documentation Updates, GCC 11 and Clang 12 Compatibility

We are proud to release Elektra 0.9.6, the 7th release in preparation for Elektra 1.0.

## 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.6-release).

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/elektra/elektra).
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run:

```sh
docker pull elektra/elektra
docker run -it elektra/elektra
```

## Highlights

- Java fixes: JNI plugin fixed and JNA bindings improved
- Fedora 34 and Debian Bullseye packages added
- Documentation Improvements & Cleanups
- GCC 11 and Clang 12 compatibility

### JNI plugin fixed

The JNI plugin was encountering a double free on open. This has been fixed in conjunction with an update to JNA binding release mechanism. The previously disabled JNI test have been fixed and enabled.

For how to write plugins, please refer to [java-plugins.md](../tutorials/java-plugins.md) as well as the [JNI plugin](../../src/plugins/jni/README.md) and [JNA binding](../../src/bindings/jna/README.md) documentation.

**Note** that it is currently not possible to mount plugins written in Java (see [#3881](https://github.com/ElektraInitiative/libelektra/issues/3881)).

## Plugins

The following section lists news about the [plugins](https://www.libelektra.org/plugins/readme) we updated in this release.

### JNI

- Fixed double free issues and re-enabled tests
- Updated documentation
- Increased minimum required JDK version to 11

_(Michael Tucek)_

Special thanks to _(Klemens Böswirth)_, _(Mihael Pranjić)_ and _(Robert Sowula)_ for helping with the problem analysis!

### Dbus, Dbusrecv and Zeromqsend

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

### Xerces

- Store length of an array in metakey array according to [array decision](../decisions/5_partially_implemented/array.md). _(Robert Sowula)_

### YAML Smith and Yan LR

- Removed plugins. _(René Schwaiger)_

### ni

- Silence Clang 12 warnings about suspicious string literal concatenation. _(Mihael Pranjić)_

### Lua

- Removed outdated information from docs _(@a-kraschitzer)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

### Core

- Remove keyCompareBy(Name)?Owner _(@a-kraschitzer)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme). This section keeps
you up-to-date with the multi-language support provided by Elektra.

### SWIG

- Remove `-Wno-shift-overflow warnings` option from SWIG bindings compile flags. _(Mihael Pranjić)_
- Suppress SWIG/Ruby bindings warning about `operator != ignored`. _(Mihael Pranjić)_

### JNA

- Increased minimum required JDK version to 11
- Gradle wrapper and docker images upgraded to 7.0.2
- Minumum Gradle version decreased to 6.0
- Upgraded JNA dependency from 4.5.2 to 5.8.0
- Updated Java binding API documentation
- Migrated native resource clean-up from `finalize()` to `Cleaner`
  - Please revisit the documentation for `Key::release` and `KeySet::release` for recommended resource release handling
  - Currently automated native key and key set resource clean-up is deactivated due to some possible race conditions which might result in double free errors. Manual key release is also disabled to not break current API release semantic. This leads to memory leaks, which is a known issue and will be resolved in an upcoming release.
- Introduced multiple exceptions when native API calls fail - see updated Java doc for details
- Introduced early parameter validation for values which would otherwise lead to unspecific errors in native API calls
- Update `Key` API introducing the following changes:
  - Extracted exceptions from `Key` class
  - Fixed `Key::getCurrentMeta`
  - Moved `Elektra.KeyNewArgumentFlags` to `Key.NewArgumentTag`
  - Changed return types from `int` to `boolean` or enabled a fluent interface where appropriate
  - Renamed `Key::*Integer` to `Key::*Int`
  - Renamed `KeyInvalidNameException` to `KeyNameException`
  - Renamed `KeyTypeMismatchException` to `KeyBinaryTypeNotSupportedException`
  - Introduced `Key::get*AndRelease` convenience methods
  - Introduced `Key::createNameless`
  - Introduced `KeyReleasedException` being thrown when a released `Key` is being accessed
  - Introduced `KeyMetaException`
  - Removed unused `KeyTypeConversionException`
  - Removed `Key::needsSync`
  - Removed `Key::isNull`
    - `KeyReleasedException` is now being thrown when a released (= previously `isNull`) `Key` is being accessed
    - `Key`s with no backing native key pointer cannot be created anymore
- Updated `KeySet` API introducing the following changes:
  - Changed return type enabling a fluent interface where appropriate
  - Renamed `KeySet::head` to `KeySet::first`
  - Renamed `KeySet::tail` to `KeySet::last`
  - Introduced `KeySetReleasedException` being thrown when a released `KeySet` is being accessed
  - Introduced `KeySetAppendException`
  - Removed `KeySet::create(int, Object[])`
  - Removed `KeySet::needsSync`
  - Methods which have been returning a nullable `Key`, now return an `Optional<Key>´
    - `KeySet::lookup*` now returns `Optional<Key>`
    - `Key::getMeta` now returns `Optional<Key>`
    - Example:
      ```java
      // checking whether the key has been found BEFORE API change
      Key found = ks.lookup("/some/key");
      if (found != null) {
        // process found key
      }
      ```
      ```java
      // checking whether the key has been found AFTER API change
      ks.lookup("/some/key").ifPresent(k -> // process found key );
      ```
- Updated `KDB` API introducing the following changes:
  - Introduced `KDBClosedException` being thrown when a closed `KDB` session is being accessed
  - Introduced `KDB::get(Key)`
  - Introduced `KDB::open()`
  - Introduced `KDB::open(KeySet)`
  - Introduced `KDB::goptsContract(String[], String[], Key, KeySet)`
  - Changed return type enabling a fluent interface where appropriate
- Updated tests accordingly

_(Michael Tucek)_

## Tools

- Remove `kdb set` functionality that creates a null key. _(Robert Sowula)_
- Rename elektraStrnDup to elektraMemDup _(@a-kraschitzer)_
- Update specmount error message _(@a-kraschitzer)_
- Update `elektraMemDup` to `void *` and update the documentation. _(Mihael Pranjić)_
- There have been a few bugfixes for elektrad. _(Klemens Böswirth)_
- Update `lodash` and `hosted-git-info` dependencies of `webd` due to security update. _(Mihael Pranjić)_

## Scripts

- Require clang-format 12 for reformatting C and Java. _(Mihael Pranjić)_
- Use basename of release file in `generate-hashsums`. _(Mihael Pranjić)_
- Use `shfmt` v3.2.4 to reformat shell scripts. _(Mihael Pranjić)_
- Use `cmake-format` v0.6.13 (`cmakelang`) to reformat CMake. _(Mihael Pranjić)_
- Aptly repositories are now automatically created if they do not exist during a package release. _(Robert Sowula)_

## Documentation

- Added reviews for all functions contained in the Elektra Core API. _(@lawli3t)_
- Added packaging section to news template. _(Mihael Pranjić)_
- Minor readability improvement in [highlevel.md](/doc/tutorials/highlevel.md). _(Tobias Schubert @qwepoizt)_
- Fix examples of spec plugin. _(Robert Sowula)_
- Added reviews for all functions contained in the Elektra Core API. _(@lawli3t)_
- Document package names of plugins, bindings and tools. _(Robert Sowula)_
- Small update in API documentation related to different namespaces in returned keys. _(Markus Raab)_
- Improved documentation of [noresolver](/src/plugins/noresolver). _(Markus Raab)_
- Improved plugin tutorial. _(Markus Raab)_
- Adding info about syncing forks to `doc/Git.md`. _(Klemens Böswirth)_
- Work on [COMPILE.md](/doc/COMPILE.md) and [INSTALL.md](/doc/INSTALL.md). _(@a-kraschitzer)_
- Update and correct licensing information. _(@a-kraschitzer)_
- Rename [RELEASE.md](/doc/todo/RELEASE.md). _(@a-kraschitzer)_
- Improved documentation for module kdb in Elektra Core. _(@lawli3t)_
- Improved documentation for module key in Elektra Core. _(@lawli3t)_
- Improved documentation for module keyname in Elektra Core. _(@lawli3t)_
- Improved documentation for module keyvalue in Elektra Core. _(@lawli3t)_
- Improved documentation for module keymeta in Elektra Core. _(@lawli3t)_
- Improved documentation for module keytest in Elektra Core. _(@lawli3t)_
- Improved documentation for module keyset in Elektra Core. _(@lawli3t)_
- Fixed example in the "mount-configuration-files" tutorial [#3722](https://github.com/ElektraInitiative/libelektra/issues/3722). _(Philipp Oppel)_
- Update and correct third party licensing information. _(@a-kraschitzer)_
- Use Ronn-NG instead of unmaintained ronn to generate man pages. _(Mihael Pranjić)_
- Re-generate man pages to add missing information and remove unnecessary symbols and escaping. _(Mihael Pranjić)_
- Update `doc/Doxyfile` to Doxygen 1.9.1 and fix a syntax error with the `FILTER_PATTERNS` directive. _(Mihael Pranjić)_

## Tests

- Fix failing `testshell_markdown_tutorial_crypto` on Mac OS and other OS with GnuPG version >= 2.3.1. _(Peter Nirschl @petermax2)_
- Use clang-format 12 for Restyled and update Restyled version. _(Mihael Pranjić)_
- Update all Restyled formatters to current versions. _(Mihael Pranjić)_

## Packaging

- We now package the Ruby bindings, ruby plugin and the gitresolver plugin. _(Robert Sowula)_
- We added Fedora 34 packages. _(Mihael Pranjić)_
- We added Debian Bullseye packages. _(Robert Sowula)_

## Build

### CMake

- Disable binding tests when `BUILD_TESTING` is disabled. _(Robert Sowula)_
- Remove unused `FindCppCMS.cmake` CMake module and unused `Boost` variables. _(Mihael Pranjić)_

### Docker

- Add Fedora 34 images. _(Mihael Pranjić)_
- We added release images that come with pre-installed dependencies and sudo permissions for each distribution we build packages for. _(Robert Sowula)_
- Use Clang 12 and Gradle 7.0 in Debian Sid image. _(Mihael Pranjić)_
- Remove Boost and some unused dependencies from all Docker images. _(Mihael Pranjić)_
- Use Gradle 7.0 and Ronn-NG `0.10.1.pre1` in Docker images. _(Mihael Pranjić)_
- Remove unused Debian Buster `doc` image. _(Mihael Pranjić)_

## Infrastructure

### Cirrus

- Use Clang 12 and Python 3.9 for macOS builds. _(Mihael Pranjić)_
- Pin GnuPG version to 2.2.x. _(Mihael Pranjić)_
- Update Fedora image to version 34. _(Mihael Pranjić)_
- Clean up unused dependencies in Arch Linux image and add Ronn-NG to generate man pages. _(Mihael Pranjić)_

### GitHub Actions

- Pin GnuPG version to 2.2.x. _(Mihael Pranjić)_
- Enable `jni` plugin and fix `JAVA_HOME` detection. _(Mihael Pranjić)_

### Jenkins

- We now build and test on Fedora 34 and 33. Fedora 32 was removed from the CI. _(Mihael Pranjić)_
- Build release documentation on Debian Sid, due to newer TeX and Doxygen packages. _(Mihael Pranjić)_

### Travis

- Update Ubuntu to Focal, use GCC 10 and clean up travis scripts. _(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:

- Update `highlight.js` due to a [ReDOS vulnerability](https://github.com/advisories/GHSA-7wwv-vh3v-89cq) and upgrade other dependencies as well. _(Mihael Pranjić)_
- Catch errors when code highlighting fails. _(Mihael Pranjić)_
- Get rid of unused code: authentication, backend, users, snippets and conversion service. _(Mihael Pranjić)_
- Fix docsearch sourcemap error. _(Mihael Pranjić)_
- Update `lodash` dependency due to security update. _(Mihael Pranjić)_

## Outlook

We are currently working on following topics:

- Elektrify KDE _(Dardan Haxhimustafa)_, _(Felix Resch)_ and _(Mihael Pranjić)_
- 1.0 API _(Stefan Hanreich)_ and _(Klemens Böswirth)_
- Improve Java Development Experience _(Michael Tucek)_
- Elektrify GNOME _(Mihael Pranjić)_
- Continious Releases _(Robert Sowula)_
- KDB access using FUSE _(Alexander Firbas)_
- Default TOML plugin _(Jakob Fischer)_
- Improve Plugin Framework _(Klemens Böswirth)_
- Improve 3-way merge _(Dominic Jäger)_
- Shell completion _(Ulrike Schäfer)_
- Ansible module _(Thomas Waser)_

## Statistics

We closed [40 issues](https://github.com/ElektraInitiative/libelektra/milestone/27?closed=1) for this release.

About 17 authors changed 627 files with 15988 insertions(+) and 16768 deletions(-) in 465 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.6.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.6.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.6.tar.gz.hashsum?raw=true)

- name: elektra-0.9.6.tar.gz
- size: 7650067
- md5sum: ed33e7b61f2b1ed3742f3bc6dd046d53
- sha1: fd6082ee38e31e54b66a96a50fc4d20c9c107c89
- sha256: c8e75f4d21bf3bd6b1028e776af9ff644a17a7dfbb1f2052f50392767deea197

The release tarball is also available signed using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.6.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.6.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.6/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.6).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.6-release)

For more information, see [https://libelektra.org](https://libelektra.org)

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.7 Release

- guid: 39F907DA-8B5B-4984-9D19-33BAB7B71B3D
- author: Mihael Pranjić
- pubDate: Fri, 09 Jul 2021 10:19:29 +0200
- shortDesc: FUSE Tool, TOML Improvements, ElektraSettings GSettings Bindings

We are proud to release Elektra 0.9.7.

## 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.7-release).

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/elektra/elektra).
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run:

```sh
docker pull elektra/elektra
docker run -it elektra/elektra
```

## Highlights

### FUSE Tool

We added an **experimental** preview of the Filesystem in User Space [FUSE](../../src/tools/fuse/README.md) tool. This tool enables the inspection and modification of the KDB, in the form of a classical filesystem. _(Alexander Firbas)_

### ElektraSettings GSettings Backend

The **experimental** [ElektraSettings](../../src/bindings/gsettings/README.md) GSettings backend has been updated and is working well with GNOME 40. We do not recommend to use it on production systems yet, but we have been testing ElektraSettings as a replacement for `dconf` successfully and want to share the progess with you. If you want to try ElektraSettings back up all your data first. _(Mihael Pranjić)_

### TOML Improvements

Multiple critical bugs have been fixed in the **experimental** `TOML` plugin _[see below](#hl-1)_. We are currently working towards using the `TOML` plugin as the default [storage plugin](https://github.com/ElektraInitiative/libelektra/blob/master/src/plugins/README.md#storage) for Elektra. _(Klemens Böswirth and Jakob Fischer)_

## Plugins

The following section lists news about the [plugins](https://www.libelektra.org/plugins/readme) we updated in this release.

### [email](/src/plugins/email/README.md)

- Introduce email address validation plugin based on regex. _(a-kraschitzer)_

### Resolver

- Fix invalid cache key name. _(Mihael Pranjić)_

### Length

- Implement a plugin that validates that a string length is less or equal to given number. _(Philipp Oppel)_

### Blacklist

- Implement a blacklist plugin that rejects values specified in a metadata array. _(Robert Sowula)_

<a id="hl-1"></a>

### TOML

- Fixed a bug ([#3896](https://issues.libelektra.org/3896)) that caused the `toml` plugin to swallow the first letter of
  all keys (after the namespace), if the parent key was a root key (e.g. `user:/`). _(Klemens Böswirth)_
- The `type` metakey is now set for numbers on reading. _(Jakob Fischer)_
- Rewrote some error messages, to make them less technical. _(Jakob Fischer)_
- Fixed parsing of floats/empty keynames/multiline strings. _(Jakob Fischer)_

### Python

- Fix format string overflow and add error checking when appending to `sys.path`. _(Mihael Pranjić)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

### Core

- A few rare bugs (mostly related to empty keyname parts `/%/`) in the keyname validation and canonicalization logic
  have been fixed. _(Klemens Böswirth)_
- Fix default backend key name for cache compatibility. _(Mihael Pranjić)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme). This section keeps
you up-to-date with the multi-language support provided by Elektra.

### JNA

- Currently the binding's automated clean-up of native keys and key sets is deactivated until JNI segmentation fault issues are resolved in an upcoming release. After these issues have been resolved, manual clean-up of native resources will be discouraged. Therefore the `Key::get*AndRelease` convenience methods introduced with the last release have been removed. _(Michael Tucek)_
- Upgrade Gradle to 7.1.1. _(Mihael Pranjić)_

### Gsettings

- Fix user and default (system) namespaces and key names. _(Mihael Pranjić)_
- Rewrite `dbus` change notification mechanism. _(Mihael Pranjić)_

## Scripts

- Add a script that automates the process of inserting source archive hashsums and Git statistics into the release notes during a release. _(Robert Sowula)_

## Documentation

- JNI documentation updates and small fixes. _(Markus Raab)_
- Small updates in notification tutorial. _(Markus Raab)_
- Add [tutorial about writing specifications](/doc/tutorials/specification.md). _(Aaron Abebe <aaron.abebe@gmail.com>)_
- Change GPG keyserver for receiving the apt key from keys.gnupg.net to keyserver.ubuntu.com _(Robert Sowula)_
- The man pages now use the date of the last change recorded in git. _(Klemens Böswirth)_

## Tests

- Upgrade GoogleTest frameworks to version 1.11.0. _(Mihael Pranjić)_
- Add additional test cases for module `key`. _(@lawli3t)_
- Add additional test cases for module `keyname`. _(@lawli3t)_
- Add additional test cases for module `keyvalue`. _(@lawli3t)_
- Add tests for module `keyset`. _(@lawli3t)_

## Packaging

- Add packages for following bindings: `glib`, `io_ev`, `io_glib` and `io_uv`. _(Robert Sowula)_

## Build

### Docker

- Upgrade Alpine Linux images to 3.14.0. _(Mihael Pranjić)_

## Infrastructure

### Jenkins

- Add the deployment of the [website](https://www.libelektra.org) to the release pipeline, therefore removing the need to wait until the main pipeline succeeds after a release. _(Robert Sowula)_
- Restructure the release job stages to make it more failsafe and enable a re-run without any version conflict until the last stage. _(Robert Sowula)_
- Fix invalid package artifact path in release pipeline. _(Robert Sowula)_
- Clean Jenkins workspaces after builds. _(Mihael Pranjić)_

## Outlook

We are currently working on following topics:

- Elektrify KDE _(Dardan Haxhimustafa)_, _(Felix Resch)_ and _(Mihael Pranjić)_
- 1.0 API _(Stefan Hanreich)_ and _(Klemens Böswirth)_
- Improve Java Development Experience _(Michael Tucek)_
- Elektrify GNOME _(Mihael Pranjić)_
- Continious Releases _(Robert Sowula)_
- KDB access using FUSE _(Alexander Firbas)_
- Default TOML plugin _(Jakob Fischer)_ and _(Klemens Böswirth)_
- Improve Plugin Framework _(Klemens Böswirth)_
- Improve 3-way merge _(Dominic Jäger)_
- Shell completion _(Ulrike Schäfer)_
- Ansible module _(Thomas Waser)_

## Statistics

We closed [40 issues](https://github.com/ElektraInitiative/libelektra/milestone/28?closed=1) for this release.

About 18 authors changed 307 files with 6547 insertions(+) and 1914 deletions(-) in 304 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.7.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.7.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.7.tar.gz.hashsum?raw=true)

- name: elektra-0.9.7.tar.gz
- size: 7712448
- md5sum: 4355e7df0dcf4178974097604f996747
- sha1: c418d344d72879dd2b3fd6fa8e9831c921cfaba5
- sha256: 12b7b046004db29317b7b937dc794abf719c400ba3115af8d41849127b562681

The release tarball is also available signed using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.7.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.7.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.7/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.7).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.7-release)

For more information, see [https://libelektra.org](https://libelektra.org).

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.8 Release

- guid: 0CB8C139-730C-4CCD-9FB4-0C7C4AA4DBF2
- author: Mihael Pranjić
- pubDate: Mon, 04 Oct 2021 00:02:45 +0200
- shortDesc: Redshift Elektrified, HL API & Java Binding Improvements

We are proud to release Elektra 0.9.8.

## 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.8-release).

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/elektra/elektra).
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run:

```sh
docker pull elektra/elektra
docker run -it elektra/elektra
```

## Highlights

- `kdb` now prohibits write operations on cascading keys that miss a corresponding existing key. See the details in the `Tools` section below and the new subsection on cascading writes in the [tutorial](/doc/tutorials/cascading.md) on cascading keys for further information. _(Alexander Firbas)_
- Redshift is now elektrified. _(Tobias Schubert @qwepoizt)_

### Redshift and Elektra

We have created a version of [Redshift](https://github.com/jonls/redshift/) that uses Elektra for configuration management!

We removed and refactored Redshift's code for loading configuration files, parsing CLI options and validating configuration to use Elektra. Redshift with Elektra has about 700 fewer lines of code (-16%) and is a great example of what Elektra is all about: More applications with less code for configuration management!

To test it, take a look at our PR [Refactor to use Elektra ](https://github.com/jonls/redshift/pull/837) and follow the instructions provided in [CONTRIBUTING.md](https://github.com/qwepoizt/redshift/blob/improve-config/elektrify/CONTRIBUTING.md).

#### Benefits of Redshift using Elektra

Refactoring Redshift to use Elektra brings the following benefits:

- Fewer lines of code: reduction of ~700 LOC or 16%
  (measured across all `*.c` and `*.h` files exclusive of files automatically generated by Elektra).
- Adding new configuration settings is easier and takes less time: Validation and parsing of setting values (from configuration file and CLI options) is handled by Elektra - no custom code required!
- Clean separation of application code and the specification of supported configuration settings (including defaults and validation rules).
- Automatic generation of CLI help text.

### HL API improvements

Redshift with Elektra uses the [high-level API](https://www.libelektra.org/tutorials/high-level-api).

We have made a large number of improvements to the [high-level API](https://www.libelektra.org/tutorials/high-level-api) in the course of refactoring Redshift. The highlights are:

- Improved detection of differences in specification between an application's compilation and runtime.
- Improved validation of CLI options.
- Early detection of errors in specification files.
- Updated and improved documentation and tutorials.
- Various other bugfixes.

More improvements and details are explained in later sections of these release notes.

Thanks to _Klemens Böswirth_, _Markus Raab_ and _Tobias Schubert_!

### Windows releases

We are now shipping experimental releases for Windows 32- and 64-bit! They can be downloaded [here](https://build.libelektra.org/job/libelektra-release/lastSuccessfulBuild/artifact/artifacts/).

A big success is that Redshift already works with Elektra under Windows.

## Plugins

The following section lists news about the [plugins](https://www.libelektra.org/plugins/readme) we updated in this release.

### gopts

- The `gopts` plugin now includes deeply nested options and arguments in the generated help message. _(Tobias Schubert @qwepoizt)_
- Errors from `gopts` are now correctly reported. _(Klemens Böswirth)_
- Fix wrong variable names in `gopts_win32.h`. _(Tobias Schubert @qwepoizt)_

### range

- The `range` plugin now uses metakey `type` as fallback, if `check/type` is not specified. _(Tobias Schubert @qwepoizt)_
- The `range` now treats all validation problems as warnings during kdbGet(). _(Tobias Schubert @qwepoizt)_

### spec

- The `spec` plugin now runs before other `postgetstorage` plugins, so that validation can happen during `kdbGet` as well.
  This is especially relevant in combination with `gopts`. _(Klemens Böswirth)_
- Make spec plugin (with no support for # and \_ in key names) work in mingw-w64 builds. _(Tobias Schubert @qwepoizt)_

### sync

- Add support for mingw-w64 builds using fflush. _(Tobias Schubert @qwepoizt)_

### wresolver

- Add missing `ELEKTRA_PLUGIN_COMMIT` export. _(Tobias Schubert @qwepoizt)_

### TOML

- Improvements to the parser, comment handling and especially quoting of strings. _(Klemens Böswirth)_
- The `toml` plugin now supports all four kinds of strings via the `tomltype` metadata.
  The plugin also remembers which kind was used and handles escape sequences properly, instead of always
  converting to basic strings. For details take a look at the updated [README](../../src/plugins/toml/README.md) _(Klemens Böswirth)_
- The `comment/#/space` metakey is now used correctly to store the actual whitespace characters from the file,
  instead of a number. _(Klemens Böswirth)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

### Compatibility

- Introduced public C API function `ksSearch`
- Previously public function `ksSearchInternal` is now static. Use `ksSearch` instead.

_(Michael Tucek)_

### Core

- Remove obsolete `ksNeedSync` function. _(Mihael Pranjić)_
- Replace various occurences of `sprintf` by `snprintf` and fix out of bounds array access in markdownlinkconverter. _(Mihael Pranjić)_

### High-level API

- Modified High-level API to treat all warnings as errors. _(Tobias Schubert @qwepoizt)_
- Implemented support for warnings in High-level API error handling. _(Tobias Schubert @qwepoizt)_
- Fix a small bug for warnings in High-level API. _(Tobias Schubert @qwepoizt)_
- Fix resource management in High-level API error handling. _(Tobias Schubert @qwepoizt)_
- Implement a check to detect whether an application's specification was properly `mount`ed and `spec-mount`ed. _(Tobias Schubert @qwepoizt)_
- Implement a check to detect whether an application's specification was changed after installation. _(Tobias Schubert @qwepoizt)_
- Add sanity-checks to resource management. _(Tobias Schubert @qwepoizt)_
- Refactor and modularize code. _(Tobias Schubert @qwepoizt)_
- Update and improve inline documentation. _(Tobias Schubert @qwepoizt)_
- Remove "minimal validation" in favor of the new checks (see above). _(Tobias Schubert @qwepoizt)_

### Ease

- Implement calculation of a specification token (=sha-256 hash). _(Tobias Schubert @qwepoizt)_
- Add [asmonier's sha-2](https://github.com/amosnier/sha-2) for sha-256 hash calculation. _(Tobias Schubert @qwepoizt)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme). This section keeps
you up-to-date with the multi-language support provided by Elektra.

### Java binding

- Upgraded Java binding gradle wrapper to 7.2.
- Java source files are formatted using the [Google Java format](https://github.com/google/google-java-format)
- Renamed zero argument static factory method `Key::createNameless` to `Key::create`. To migrate to this change, just update calling code to use the new method name.
- Updated method documentation previously publishing the error key based error handling approach to the Java binding consumer. Such arguments are now explicitly only used for returning warning information in case no error occurred. In case of an exceptional state, appropriate exceptions are thrown. Such exceptions provide access to the underlying key containing warning and error information as metadata. Please review API usage to consider the more elaborated explanation of how Elektra uses this argument's value. Affected signatures:
  - Updated javadoc for `KDB::open(Key)`
  - Updated javadoc for `KDB::open(KeySet, Key)`
  - Updated javadoc for `KDB::close(Key)`
  - Updated javadoc for `KDB::get(Key)`
  - Updated javadoc for `KDB::get(KeySet, Key)`
  - Updated javadoc for `KDB::set(KeySet, Key)`, better explaining the relevance of the second argument `parentKey`
- Introduced `KeySet::remove(Key)` and `KeySet::remove(String)`
- Removed `KeySet::lookup(Key, int)` and `KeySet::lookup(String, int)` as well as accompanying flag definitions `KeySet::KDB_O_NONE`, `KeySet::KDB_O_DEL` and `KeySet::KDB_O_POP`. Please use `KeySet::lookup(Key)` and `KeySet::lookup(String)` instead. Instead of `KeySet::KDB_O_DEL`, please consider using `Key::release`. The proper replacement for `KeySet::KDB_O_POP` is `KeySet::remove(Key)` or `KeySet::remove(String)`.
- Native library proxy interface `Elektra` is now package private (previously was public).
- Added example Java plugin `whitelist` (see [here](../../src/bindings/jna/plugins/whitelist/README.md))
- Changed `Key nextMeta()` to `Optional<Key> nextMeta ()` no longer throwing NoSuchElementException for non-exceptional behavior
- Native library proxy interface `Elektra` is now package private (previously was public)
- Added example Java plugin `whitelist`
- Added support of binary valued keys:
  - Introduced `Key::getBinary()` and `Key::setBinary(byte[])`
  - Renamed `KeyBinaryTypeNotSupportedException` to `KeyStringValueException`
  - Introduced `KeyBinaryValueException`
  - Improved `Key` test coverage
- Fixed example project in `examples/external/java/read-keys-example`
  - now works with a standard installation of Elektra
  - updated code to work with current Java binding
- `KeySetReleasedException` and `KeyReleasedException` have been replaced by the native `IllegalStateException`
- Introduced abstraction `ReadableKey` to better reflect the limitations of metadata keys via a type hierarchy. Metadata keys are now returned as `ReadableKey`s:
  - `Key` extends `ReadableKey`
  - `Key` class is now final
  - Changed `Key Key::nextMeta()` to `Optional<ReadableKey> Key::nextMeta()`, no longer throwing NoSuchElementException for non-exceptional behavior
  - Changed `Key Key::currentMeta()` to `ReadableKey Key::currentMeta()`
  - Changed `Optional<Key> Key::getMeta(String)` to `Optional<ReadableKey> Key::getMeta(String)`
  - Metadata keys can no longer be manually released
  - Removed `Key::incRef`, `Key::decRef` and `Key::getRef`
  - `ReadableKey`/`Key` now implements `Comparable<ReadableKey>`
    - `int Key::cmp(Key)` has been renamed to `int Key::compareTo(Key)`
    - `ReadableKey` now implements `equals` and `hashCode` in line with the contract for `int Key::compareTo(Key)`
  - `ReadableKey`/`Key` no longer implements `Iterable<String>` for iterating over the parts of a key's name - use `Iterator<String> ReadableKey::keyNameIterator ()` instead
  - `Key` now implements `Iterable<Key>` to iterate over a key's metadata `ReadableKey`s
  - Fixed API method typo: Renamed `ReadableKey::isDirectBelow`/`Key::isDirectBelow` to `isDirectlyBelow`
- `KeyNameIterator` and `KeySetIterator` are now package private
- `KeySetAppendException` has been renamed to `KeySetException` and now conveys general `KeySet` related exceptional states
- `KeySet` now implements `SortedSet<Key>` (see [Java API](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/SortedSet.html)). Previously `KeySet` was only implementing `Iterator<Key>`. Now a native key set can be used via its `KeySet` representation wherever one of the following Java Collection Framework interfaces is supported:
  - `Iterable`
  - `Collection`
  - `Set`
  - `SortedSet`

_(Michael Tucek)_

### GLib

- Compile `glib` binding with `-Wno-pedantic` for compatibility. _(Mihael Pranjić)_

## Tools

- Really add all tools when using `-DTOOLS=ALL`. _(Markus Raab)_
- ZeroMQ Hub: fix compilation and man page. _(Markus Raab)_
- Configure packaging for FUSE tool. _(Alexander Firbas)_
- FUSE: fix bug preventing binary writes. _(Alexander Firbas)_
- Ambiguous write operations are now disabled in kdb. _(Alexander Firbas)_
- `webd`: update npm dependencies. _(Mihael Pranjić)_

### KDB

- `kdb set`, `kdb meta-set`: Only allow writes to the cascading namespace if the lookup succeeds. Otherwise, the operation is ambiguous and therefore aborted.
  No more guessing of namespaces in case a cascading key is given (`user:, system`: for `kdb set`, `spec:` for `kdb meta-set`), _(Alexander Firbas)_
- `kdb set`, `kdb meta-set`: Validation of keys can no longer be bypassed by using non-cascading keys (except with the new --force (-f) option). _(Alexander Firbas)_
- Disable `-N/--namespace` option in all kdb subcommands _(Alexander Firbas)_
- Implement new name part getter commands `kdb namespace`, `kdb basename` and `kdb dirname`. _(Alexander Firbas)_
- `kdb file`: Remove namespace guessing (in case a cascading key is given, it needs to resolve to an existing key). _(Alexander Firbas)_
- `kdb editor/import`: Disable the use of cascading names (and the 'validate' strategy operating on cascading keys) entirely. _(Alexander Firbas)_
- Update numerous tests to comply with changes above. _(Alexander Firbas)_
- Add a new subsection on cascading writes to the [tutorial](/doc/tutorials/cascading.md) on cascading keys. _(Alexander Firbas)_
- `kdb gen`: Generate specification token during code-generation and add it to generated contract. _(Tobias Schubert @qwepoizt)_
- `kdb gen`: Improve naming of variables to make code easier to understand. _(Tobias Schubert @qwepoizt)_
- `kdb spec-mount`: Improve usability by failing with helpful error messages, if the specification contains errors. _(Tobias Schubert @qwepoizt)_

## Scripts

- Add script for mingw-w64 i686 build. _(Tobias Schubert @qwepoizt)_

## Documentation

- Add link and small improvements to tutorial about [writing specifications](/doc/tutorials/specification.md) and [logger](/doc/tutorials/logger.md). _(Markus Raab)_
- doc: add pre/postconditions and invariants to module key _(@lawli3t)_
- doc: add pre/postconditions and invariants to module keymeta _(@lawli3t)_
- Fix broken links _(@lawli3t)_
- Remove previous authors. _(Markus Raab)_
- add pre/postconditions and invariants to module keytest _(@lawli3t)_
- Updated the news template. _(Mihael Pranjić)_
- Update and improve tutorial and in-code comments for high-level API _(Tobias Schubert @qwepoizt)_
- Improve documentation of opts library _(Tobias Schubert @qwepoizt)_
- Update tutorial "High-level API (with code-generation)" to reflect change of `loadConfiguration()`'s signature in release 0.9.5 _(Tobias Schubert @qwepoizt)_
- add pre/postconditions and invariants to module keyvalue _(@lawli3t)_
- Update and improve inline documentation of `kdb gen`. _(Tobias Schubert @qwepoizt)_
- Fix broken links. _(Robert Sowula)_

## Tests

- Fix failing `testshell_markdown_tutorial_crypto` on Mac OS and other OS with GnuPG version >= 2.3.1. _(Peter Nirschl @petermax2)_
- Use clang-format 12 for Restyled and update Restyled version. _(Mihael Pranjić)_
- Update all Restyled formatters to current versions. _(Mihael Pranjić)_
- Add additional test cases for module `keytest` _(@lawli3t)_
- Update tests for high-level API to work with new specification token mechanism. _(Tobias Schubert @qwepoizt)_
- Add tests for libease's sha-256. _(Tobias Schubert @qwepoizt)_
- Add tests for sha-256 hash calculation of a KeySet. _(Tobias Schubert @qwepoizt)_
- Add additional test cases for module `keymeta` _(@lawli3t)_

## Packaging

- Add packages for openSuse Leap 15.3. _(Robert Sowula)_

## Build

### CMake

- Add files generated by CMake to .gitignore. _(Tobias Schubert @qwepoizt)_
- Add support for i686 to mingw-w64 toolchains. _(Tobias Schubert @qwepoizt)_
- Add plugins type, cache, spec, gopts, sync to mingw-w64 builds. _(Tobias Schubert @qwepoizt)_

### Docker

- Add docker images for ABI tests. _(Robert Sowula)_
- Enable BuildKit features to leverage tmpfs to speed up `docker build` commands. _(Mihael Pranjić)_
- Bump Gradle to version 7.2. _(Mihael Pranjić)_
- Bump Debian Buster images to Bullseye and Stretch images to Buster. We still leave one Debian Stretch job due to upstream Debian LTS support until June 2022. _(Mihael Pranjić)_
- Add Dockerfiles for openSUSE Leap 15.3 and CentOS Stream 8. _(Robert Sowula)_
- Add docker image for OpenWrt package building. _(Robert Sowula)_
- Add files generated by docker when tutorial [run-all-tests-with-docker](https://www.libelektra.org/tutorials/run-all-tests-with-docker) is followed to .gitignore. _(Tobias Schubert @qwepoizt)_

### Restyled

- Upgrade to latest stable restylers. _(Mihael Pranjić)_
- Added Google Java formatter _(Michael Tucek)_

## Infrastructure

### Jenkins

- Add ABI test stage for release pipeline. _(Robert Sowula)_
- Move check stages that don't build the code to a dedicated stage, to avoid confusion when parallel builds are aborted. _(Robert Sowula)_
- Add test stages for openSUSE and CentOS. _(Robert Sowula)_
- Use `tmpfs` in Docker to speed up the test suite. _(Mihael Pranjić)_
- Add OpenWrt package building stage to release pipeline. _(Robert Sowula)_
- Add debian-bullseye-mingw-w64-i686 build to Jenkinsfile. _(Tobias Schubert @qwepoizt)_

### Cirrus

- Bump FreeBSD images to 12.2 and 13.0 using the LLVM 12 toolchain, drop FreeBSD 11. _(Mihael Pranjić)_
- Fix cirrus-file parsing errors. _(Mihael Pranjić)_
- Redistribute CPU and memory resources and enable greedy instances. _(Mihael Pranjić)_

### GitHub Actions

- Migrate most macOS build jobs to GitHub actions to speed up builds. _(Mihael Pranjić)_
- Upgrade macOS GCC build job to GCC 11. _(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:

- Update npm dependencies. _(Mihael Pranjić)_

## Outlook

We are currently working on following topics:

- 1.0 API _(Stefan Hanreich)_ and _(Klemens Böswirth)_
- KDB access using FUSE _(Alexander Firbas)_
- Improve Java Development Experience _(Michael Tucek)_
- Improve Plugin Framework _(Klemens Böswirth)_
- Default TOML plugin _(Klemens Böswirth)_, _(Markus Raab)_ and _(Jakob Fischer)_
- Elektrify KDE _(Dardan Haxhimustafa)_, _(Felix Resch)_ and _(Mihael Pranjić)_
- Elektrify GNOME _(Mihael Pranjić)_
- Continious Releases _(Robert Sowula)_
- Improve 3-way merge _(Dominic Jäger)_
- Shell completion _(Ulrike Schäfer)_
- Ansible module _(Thomas Waser)_

## Statistics

We closed [59 issues](https://github.com/ElektraInitiative/libelektra/milestone/29?closed=1) for this release.

About 17 authors changed 396 files with 13155 insertions(+) and 8331 deletions(-) in 597 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.8.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.8.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.8.tar.gz.hashsum?raw=true)

- name: elektra-0.9.8.tar.gz
- size: 7753097
- md5sum: d978c17aae94d79f9d1f26b547bc46fe
- sha1: 9725bfd6fca832ed472290e9de3711e01e9bfe54
- sha256: b1e8908c138b84e788fdff25eab1c2b07e0b422a5fd1667814539ea02f151c58

The release tarball is also available signed using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.8.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.8.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.8/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.8).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.8-release)

For more information, see [https://libelektra.org](https://libelektra.org).

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.9 Release

- guid: 3177C958-9473-41BA-9918-A56A18CF20E8
- author: Mihael Pranjić
- pubDate: Thu, 10 Mar 2022 07:40:35 +0100
- shortDesc: Bug Fixes, Java Plugins, Elektra 1.0 Decisions

We are proud to release Elektra 0.9.9.

## 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.9-release).

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/elektra/elektra).
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run:

```sh
docker pull elektra/elektra
docker run -it elektra/elektra
```

## Highlights

- Bug fixing in FLOSS course
- Java plugins
- 1.0 decisions

### Bug Fixing in FLOSS Course

As you will read in this release notes, a massive amount of bugs were fixed within this release.
Many of them were resolved from students participating in a
[university course about FLOSS](https://tiss.tuwien.ac.at/course/courseDetails.xhtml?courseNr=194114&semester=2021W)
This demonstrates that homework of students can be very useful and in public service.

In the upcoming term there will be a course about
[configuration management](https://tiss.tuwien.ac.at/course/courseDetails.xhtml?courseNr=194030&semester=2022S)
in which Elektra will also be used and improved upon.

### Java Plugins

The version of the `process` plugin, makes it much easier to implement plugins in Java.
You can now call an implementation `org.libelektra.Plugin` via `process` and the `org.libelektra.process.PluginProcess` class.
To mount Java plugins the new helper script `kdb mount-java` can be used.

For more information take a look at [the updated tutorial](https://www.libelektra.org/tutorials/java-plugins)
and the new [man page for `kdb mount-java`](../help/kdb-mount-java.md).

### 1.0 Decisions

With this release we greatly updated our [decisions](/doc/decisions/) for the 1.0 release.
This brings us one big step closer to 1.0.

## Plugins

The following section lists news about the [plugins](https://www.libelektra.org/plugins/readme) we updated in this release.

### filecheck

- Removed unused variable that threw an error in filecheck.c. _(Vaibhav Ganesh @flackojr)_

### mmapstorage

- Removed unused variable that threw an error in mmapstorage.c. _(Vaibhav Ganesh @flackojr)_

### csvstorage

- Add `array` metakey to the parentKey of imported Keys _(@muskater)_ _(@4ydan)_ _(@lawli3t)_

### specload

- Change and move `keyCompareMeta (const Key * k1, const Key * k2)` from `src/libs/elektra/keytest.c`
  to `src/plugins/specload/specload.c` and integrate functionality of keyCompare (const Key _ key1, const Key _ key2)
  into `isChangeAllowed (Key * oldKey, Key * newKey)`, because that is the only place where it was used. _(@flo91)_

### uname

- Minor improvement of source code readability in uname.c _(@lawli3t)_

### quickdump

- Fixed an issue with type-limits on ARM32 (see issue #4217). _(Klemens Böswirth @kodebach)_

### dump

- The exported functions `serialize` and `unserialize` have been renamed to `serialize` and `unserialize`. _(Klemens Böswirth @kodebach)_
- New exported functions `int fserialize(KeySet * ks, FILE * file, Key * errorKey)` and `int funserialize(KeySet * ks, FILE * file, Key * errorKey)` have been added.
  These are wrappers around `serialize` and `unserialize` that allow calling from C with a standard `FILE *`. _(Klemens Böswirth @kodebach)_

### process

- The plugin was completely rewritten. The new version is incompatible with the old version.
  The new plugin that uses a simple protocol to allow an external application to act as a plugin.
  This can for example be used to write plugins in Java without going through JNI. _(Klemens Böswirth @kodebach)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

### Compatibility

- Remove the deprecated flags `KEY_NAME` and `KEY_COMMENT` (closes issue #3152) _(Florian Lindner @flo91)_

### Core

- `KeySet` now also has a reference counter like `Key`. The new functions `ksIncRef` and `ksDecRef` behave like their counterparts `keyIncRef` and `keyDecRef`.
  `ksDel` also behaves like `keyDel` in regard to reference counting, i.e. it does nothing unless the reference count is 0.
  The reference counting is very useful for bindings (especially with automatic garbage collection). _(Klemens Böswirth)_
- Clarified that our reference counting mechanism is more related to a shared lock than to the concept of shared ownership. _(Klemens Böswirth)_
- Both the reference count for `Key` and for `KeySet` now use `uint16_t` to reduce memory usage. `Key` previously used `size_t`. _(Klemens Böswirth)_
- Reorder `Key` and `KeySet` struct members to aviod padding and make space for a new `uint16_t` member, reserved for future use. _(Mihael Pranjić @mpranj)_
- Improve `keyReplacePrefix` by using new `keyCopy` function instead of manually copying the name of the `Key` _(@lawli3t)_
- Added else error to core for elektraGetCheckUpdateNeeded _(Aydan Ghazani @4ydan)_
- Include NULL terminators in hashing to avoid collisions _(@lawli3t)_
- Fix check for valid namespace in keyname creation _(@JakobWonisch)_
- Fix `keyCopyMeta` not deleting non existant keys in destination (see #3981) _(@JakobWonisch)_
- The `ELEKTRA_ERROR_*_NAME` and `ELEKTRA_WARNING_*_NAME` constants have been removed from the public API. Use `ELEKTRA_ERROR_*` and `ELEKTRA_WARNING_*` instead. _(Klemens Böswirth @kodebach)_
- Fixed a bug that prevented the creation of cascading keys whose name contains a colon (`:`). _(Klemens Böswirth @kodebach)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme). This section keeps
you up-to-date with the multi-language support provided by Elektra.

### Java binding

- Integrated the `HelloElektra` example as Gradle subproject to allow it to directly depend on the current binding _(Michael Tucek)_
- Extend `HelloElektra` example with cutpoint and value setting example _(@JakobWonisch)_
- Updated Gradle to 7.4. _(Mihael Pranjić @mpranj)_
- Added integration with the new `process` plugin. _(Klemens Böswirth @kodebach)_
- Integrated the `HelloElektra` example as gradle subproject to allow it to directly depend on the current binding _(Michael Tucek)_
- Add `LinkChecker` Java Plugin. _(@aaronabebe)_

### FUSE Binding

- Added check for existence of accessed path before opening new file descriptor _(@lawli3t)_

### Python Binding

- Added examples for append, extend and remove keysets in python. _(@4ydan)_

## Tools

- Implement `kdb validate <key>`, collect warnings and errors while kdb.get() and kdb.set(), see #3674 _(@flo91)_, _(@JakobWonisch)_
- Remove names from kdb mount _(@JakobWonisch)_
- Add `kdb mount-java` helper script for mounting Java plugins _(Klemens Böswirth @kodebach)_

## Scripts

- Updated `reformat-c` script to use clang-format version 13. _(Mihael Pranjić @mpranj)_
- Fix bug where the PATH environment variable would get overwritten in some of the Docker images. Reduce image size _(Ivaylo Ivanov)_
- Allow JSON to be also written as json. _(@muskater)_

## Documentation

- Integrate missing pages to website _(Ivaylo Ivanov)_
- Improved compilation documentation _(Ivaylo Ivanov)_
- Fix Links in [README.md](/README.md) and add small clarifications. _(Markus Raab)_
- Remove previous authors. _(Markus Raab)_
- Add pre/postconditions and invariants to module keytest _(@lawli3t)_
- Updated the news template. _(Mihael Pranjić @mpranj)_
- Update and improve tutorial and in-code comments for high-level API _(Tobias Schubert @qwepoizt)_
- Improve documentation of opts library _(Tobias Schubert @qwepoizt)_
- Update tutorial "High-level API (with code-generation)" to reflect change of `loadConfiguration()`'s signature in release 0.9.5 _(Tobias Schubert @qwepoizt)_
- Add pre/postconditions and invariants to module keyvalue _(@lawli3t)_
- Update and improve inline documentation of `kdb gen`. _(Tobias Schubert @qwepoizt)_
- Fix broken links. _(Robert Sowula)_
- Emphasize that `type` is required when the HL API is used. _(Tobias Schubert @qwepoizt)_
- Add debugging tutorial. _(Tobias Schubert @qwepoizt)_
- Improve wording and formatting of DESIGN.md _(@lawli3t)_
- Correct various typing-, spelling- and grammar-errors in the .md-files in the directory doc and its subdirectories. _(Florian Lindner @flo91)_
- Make version description in key names man page consistent _(@JakobWonisch)_
- Fix typo in elektra-backends man page _(@JakobWonisch)_
- Fix readability in bootstrapping man page _(JakobWonisch)_
- Explained in the docker test tutorial how to run the container with podman instead of docker. _(@muskater)_
- Add a new example on how to use keyCopy. _(@muskater)_
- Fix small error in the "Get Started" guide: the build and test command used a wrong directory and would not work if they were copy and pasted. _(@muskater)_
- Added verification to the "Arrays" tutorial _(Ivaylo Ivanov)_
- Remove deprecated `type=int` from `.ini` files _(Ivaylo Ivanov)_
- Added verification to the "Validation" tutorial _(Ivaylo Ivanov)_
- Fix some typos in the "Getting Started" page _(Ivaylo Ivanov)_
- Added debian buster tutorial to python bindings tutorial _(@4ydan)_
- Made the debian tutorial a bit more precise and removed sudo command _(@4ydan)_
- Fixed some typos in the "namespaces.md" documentation _(@muskater)_
- Fix an error and some overmatching problems in scripts/spelling.sed and fix errors in documentation
  (by running the scripts/dev/fix-spelling script) _(Florian Lindner @flo91)_
- Added some improvements to the core API documentation _(@muskater)_
- Update and improve the CLion tutorial (doc/tutorials/contributing-clion.md), add screenshots _(@flo91)_
- Improve documentation for storage plugins _(@lawli3t)_
- Add list of sources mentioning or linking to Elektra _(@JakobWonisch)_
- Linked to the installation instruction of the webui in its README file and added references to Docker in the get-started-guide. _(@muskater)_ _(@lawli3t)_ _(Aydan Ghazani @4ydan)_
- Added screenshots and a quick walk through in the Qt-GUI README. _(@muskater)_ _(@lawli3t)_ _(Aydan Ghazani @4ydan)_
- Improve example for kdb-restore man page and fix typos _(@JakobWonisch)_
- Fix some typos in the "Getting Started" page _(Ivaylo Ivanov)_
- Add screenshots with hints to CLion PR tutorial _(@JakobWonisch)_
- Fix typo in elektra-backends man page _(@JakobWonisch)_
- Expanded the webside guide for easier understanding and linked to cmake.org. _(Philipp Nirnberger @nirnberger)_
- Fix small error in CLion tutorial: CMake options would create a directory named `~` in home directory _(Maximilian Irlinger @atmaxinger)_

## Tests

- Cleanup tests/linkchecker.whitelist and fix off-by-1 bug of the counter in the scripts/link-checker script (increase counter before printf) _(Florian Lindner @flo91)_
- Add tests for the intercept/env binding _(Ivaylo Ivanov)_
- add and improve checks in scripts/sed _(Florian Lindner @flo91)_
- Change the cpp Key-class (key.hpp) to check the return values of the called c-functions
  and throw exceptions if values that indicate an error are returned + add tests that
  check for this exceptions _(Florian Lindner @flo91)_
- Added more test cases for the keyCopy function _(@muskater)_
- Add exception tests for key C++ bindings _(Ivaylo Ivanov)_
- Added a shell script and a task that checks whether the filenames of newly added files are compliant with the convention. It is executed by the cirrus CI as well as the Jenkins CI _(@muskater)_
- Add a new shellrecoder test to `doc/tutorials/merge.md` _(Florian Lindner @flo91)_
- Added the possibility to enable all the shell recorder test cases for all plugins and fixed some plugin README files in process _(@muskater)_
- Convert example in doc/help/kdb-test.md to shell recorder test _(@JakobWonisch)_

## Packaging

- Add initial flatpak package. See `scripts/flatpak/README.md` and `scripts/flatpak/org.libelektra.kdb.yaml`for more info _(Ivaylo Ivanov)_
- Remove hard coded SWIG 3.0 paths. _(Mihael Pranjić @mpranj)_

## Build

### CMake

- Marked certain variables as advanced and separate user-modifiable and unaccessible variables. _(Vaibhav Ganesh @flackojr)_

### Docker

- Add Fedora 35 images. _(Mihael Pranjić @mpranj)_

## Infrastructure

### Jenkins

- Replace Fedora 33 builds with Fedora 34, and Fedora 34 builds with Fedora 35. _(Mihael Pranjić @mpranj)_

## Website

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

- Update npm dependencies, add forked and update angular-marked module. _(Mihael Pranjić @mpranj)_
- Remove links to Travis CI and replace them with GitHub Actions (with badge). _(Mihael Pranjić @mpranj)_

## Other

- Make Elektra [reuse](https://reuse.software) reuse compliant _(Ivaylo Ivanov)_

## Outlook

We are working on following new topics since the last release:

- Ansible-Elektra _(Lukas Hartl)_
- Recording Configuration _(Maximilian Irlinger)_

Furthermore, we are still working on following topics:

- 1.0 API _(Stefan Hanreich)_ and _(Klemens Böswirth)_
- Improve Java Development Experience _(Michael Tucek)_
- KDB access using FUSE _(Alexander Firbas)_
- Shell completion _(Ulrike Schäfer)_
- Elektrify KDE and GNOME _(Mihael Pranjić)_

## Statistics

We closed [90 issues](https://github.com/ElektraInitiative/libelektra/milestone/30?closed=1) for this release.

About 29 authors changed 491 files with 17997 insertions(+) and 6089 deletions(-) in 648 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.9.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.9.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.9.tar.gz.hashsum?raw=true)

- name: elektra-0.9.9.tar.gz
- size: 8878567
- md5sum: f5109eb0c96fb4164a5437bdebc3bf79
- sha1: a08df79301d56dd8f3711efa1b78b5a4d003d42f
- sha256: 834da360170daa632bbb46dd2e819271327dce1c51be1d7bb2ec22311ded54cb

The release tarball is also available signed using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.9.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.9.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.9/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.9).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.9-release)

For more information, see [https://libelektra.org](https://libelektra.org).

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.10 Release

- guid: CC66FD33-7491-4BFA-975A-36FAB67D45D6
- author: Mihael Pranjić
- pubDate: Sat, 09 Jul 2022 09:40:18 +0200
- shortDesc: Kotlin Binding, Remove Internal Iterators

We are proud to release Elektra 0.9.10.

## 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.10-release).

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/elektra/elektra).
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run:

```sh
docker pull elektra/elektra
docker run -it elektra/elektra
```

## Highlights

- Kotlin Binding
- Remove internal iterators

### Kotline Binding

We created a new Binding for Kotlin with convenience functions and various utilities.
There is also the possibility to convert KeySets to Kotlin data classes or collections and back.
Read the [Kotlin Readme](../../src/bindings/jna/libelektra-kotlin/README.md) for more information.

A big thanks to _(@Gratla and @mandoway)_ for this beautiful work.

### Remove Internal Iterators

In Elektra there are currently two different ways to iterate over KeySets.
The so-called "internal" iterator is, however, inferior and creates several problems, e.g. it was a side effect to be considered for every function call that involved a KeySet.

With this release, we started removing the internal iterators by removing `keyRewindMeta`, `keyCurrentMeta`, `ksHead`, and `ksTail` functions.
The external iterators are now the way to go, see [Iterators](/doc/dev/iterators.md).

A huge thanks to _(Florian Lindner @flo91)_ for doing this thankless cleanup task.

## Plugins

The following section lists news about the [plugins](https://www.libelektra.org/plugins/readme) we updated in this release.
Overall changes:

- We changed all plugins, except `directoryvalue` to use external iteration of `KeySet`s _(Florian Lindner @flo91)_

### Python

- Added `.pop()`, `.cut()`, `.head()` and `.tail()` examples to keySet example _(Lukas Hartl @lukashartl, Leonard Guelmino @leothetryhard)_
- Added a new [DNS plugin](/src/plugins/python/python/dns/README.md) fully written in Python _(Lukas Hartl @lukashartl, Leonard Guelmino @leothetryhard)_

### lineendings - Plugin

- Enable emitting of warnings during kdbGet(), refactor and update methods and return values to match the conventions
  (e.g. #defined constants for return values) _(Michael Langhammer @milangs, Florian Lindner @flo91)_

### date

- Exclude the tests for formats that require GNU extensions of `strptime` on non-GNU systems. _(@kodebach)_

### Length

- Warnings are now added on `kdb get` _(@mandoway)_

### Curlget

- Removed usages (and contents) of VERBOSE macro _(@mandoway)_

### Sorted

- Added new validation plugin: Sorted. It checks whether an Elektra array is sorted by its value or a given key in a configurable direction _(@mandoway @Gratla)_

### mini

- Fix usage of bitwise operator with boolean operands. _(Mihael Pranjić @mpranj)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

### Compatibility

- Remove `keyRewindMeta`, `keyCurrentMeta`, `ksHead`, and `ksTail` functions for internal iteration of `Keyset`s and Metadata of `Key`s _(Florian Lindner @flo91)_

### Core

- Removed mentions of VERBOSE and replaced debug prints with the logger _(@mandoway)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme). This section keeps
you up-to-date with the multi-language support provided by Elektra.

- Remove internal iterators for SWIG (Python, Lua, Ruby) and go-bindings _(Florian Lindner @flo91)_

### Java

- Implement NavigableSet in JNA KeySet _(Burkhard Hampl @bhampl)_
- Added a Java example for meta keys and arrays _(@mandoway)_
- Added examples to HelloElektra.java _(Leonard Guelmino @leothetryhard, Lukas Hartl @lukashartl)_
- Added example which shows how to add a basename for a key. _(Philipp Leeb @Gratla)_
- Introduced Key#setNull, ReadableKey#isNull _(Michael Tucek @tucek)_
- Fixed Key#setBoolean, ReadableKey#isBoolean _(Michael Tucek @tucek)_
- Fixed Java Whitelist plugin tests _(Michael Tucek @tucek)_
- Fixed missing Javadoc in Java Sorted plugin _(Michael Tucek @tucek)_

### Ruby

- Replace `NULL` in `rb_funcall` with `Qnil` to avoid compiler errors/warnings on some systems. _(@kodebach)_

### Kotlin

- Added new JNA subproject which builds an Elektra extension library for Kotlin _(@mandoway & @Gratla)_
- Added get(), getOrNull() extension with type inference for primitive types _(@mandoway)_
- Added set() extension with type inference for primitive types _(@mandoway)_
- Added keySet serialization capabilities (to any format and data classes, with array support) _(@mandoway)_
- Added keyOf() extension and keyOf{} builder for key creation _(@Gratla)_
- Added keySetOf() extension and keySetOf{} builder for keySet creation _(@Gratla)_
- Added withKDB() extension which wraps the try block _(@Gratla)_
- Added nameParts extension value which provides a sequence of key name parts _(@mandoway)_
- Added various utility functions like Key.isEmpty, Key.getMetaOrNull, ... _(@Gratla & @mandoway)_
- Added example project for kotlin binding _(@Gratla & @mandoway)_
- Added lookupOrThrow(), lookupOrNull(), and get operator to search for keys in KeySets without Java Optionals _(@mandoway)_
- Fixed setting null, by using new JNA setNull() function _(@mandoway)_

### Python

- Deleted occurrences of removed property key.fullname _(@mandoway)_

### CPP

- Removed mentions of VERBOSE _(@mandoway)_

### Python

- Deleted occurrences of removed property key.fullname _(@mandoway)_

### CPP

- Removed mentions of VERBOSE _(@mandoway)_

## Tools

### elektrad

- improve logging in `elektrad` _(Lukas Hartl @lukashartl, Leonard Guelmino @leothetryhard)_
- Update `elektrad` to use last version of the `go`-bindings without internal iterators for `Keyset`s and Metadata _(Florian Lindner @flo91)_

### `webui`

- fix issues from namespace-overhaul _(Lukas Hartl @lukashartl, Leonard Guelmino @leothetryhard)_
- apply non-breaking updates to packages _(Leonard Guelmino @leothetryhard, Lukas Hartl @lukashartl)_

### `webd`

- fix path building for requests to `elektrad` _(Lukas Hartl @lukashartl, Leonard Guelmino @leothetryhard)_

### QT GUI

- Removed mentions of VERBOSE _(@mandoway)_
- Fixed dependency for Debian packages _(Markus Raab)_

## Scripts

- Fix `kdb reset`. _(Markus Raab)_

## Documentation

- Small readability improvement _(@Toniboyyy)_
- Python: add guide for Debian 11 (bullseye) _(Lukas Hartl @lukashartl)_
- Fix some errors in the tutorials `Cascading Lookups` and `Command-line Options` _(Florian Lindner @flo91)_
- Extend and update the tutorial for writing specifications,
  add section about using specs in production _(Florian Lindner @flo91)_
- Tutorial: add cleanup section to the specification tutorial _(Lukas Hartl @lukashartl)_ and _(@leothetryhard)_
- Add readme-file [Iterators](/doc/dev/iterators.md) about cm2022s project showcasing usage in various programming languages _(Florian Lindner @flo91 and Michael Langhammer @Milangs)_
- Updated elektra-web installation manual (doc/tutorials/install-webui.md) _(Leonard Guelmino @leothetryhard, Lukas Hartl @lukashartl)_
- Improve jna documentation _(Burkhard Hampl @bhampl)_
- Add Stream API example in Java binding documentation _(Richard Stöckl @Eiskasten)_
- Minor readability improvement in `CODING.md` _(@loessberth)_
- Fix dead link and compile instructions _(Burkhard Hampl @bhampl)_
- Update links from certificate section _(Richard Stöckl @Eiskasten)_
- Fix wrong KDBException reference in java tutorial and improve it _(Burkhard Hampl @bhampl and Richard Stöckl @Eiskasten)_
- Update [FAQ](/doc/help/elektra-faq.md). _(Markus Raab)_

### Tutorials

- The tutorial for [Contributing from Windows](../tutorials/contributing-windows.md) has been updated. _(@kodebach)_
- The tutorial for [CLion](../tutorials/contributing-clion.md) now contains a section for setting up the WSL compiler _(@mandoway)_
- Rephrased sentence in code-generator.md to enhance readability _(@Gratla)_

## Tests

- Add tests for the Error/Warnings-Factory in libtools _(Florian Lindner @flo91)_
- Add tests for keySet in the python binary _(Lukas Hartl @lukashartl, Leonard Guelmino @leothetryhard)_
- Added test for JNA KDB which checks if both get-method implementations return the same result. _(Philipp Leeb @Gratla)_

## Build

### CMake

- CMake now automatically detects all JNA plugins that are added to Gradle. _(@kodebach)_

## Infrastructure

### Jenkins

- make copying of artifacts much faster _(Lukas Hartl)_
- fixed several problems _(Lukas Hartl)_

### Cirrus && GitHub Actions

- Fix wrong path for clang builds on macOS. _(Mihael Pranjić @mpranj)_

### Git

- We added a `.gitattributes` file to make it easier to build Elektra with WSL. _(@kodebach)_

### GitHub

- Added dependabot configuration _(Lukas Hartl @lukashartl)_

## Website

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

- Overhauled the `Get Started` page by adding a brief `kdb` introduction. _(@Milangs)_

## Outlook

We are currently working on following topics:

- 1.0 API _(Stefan Hanreich)_ and _(Klemens Böswirth @kodebach)_
- Elektrify KDE and GNOME _(Mihael Pranjić @mpranj)_
- Elektrify XFCE _(Richard Stöckl @Eiskasten)_
- Mounting SQL databases _(Florian Lindner @flo91)_
- Recording Configuration _(Maximilian Irlinger)_
- Ansible-Elektra _(Lukas Hartl)_
- Improving Build Server Infrastructure _(Lukas Hartl)_ and _(Maximilian Irlinger)_
- Improve Java Development Experience _(Michael Tucek)_
- KDB access using FUSE _(Alexander Firbas)_
- Shell completion _(Ulrike Schäfer)_
- Rewriting tools in C _(Florian Lindner @flo91)_, _(Maximilian Irlinger)_ and _(Richard Stöckl @Eiskasten)_.

## Statistics

We closed [51 issues](https://github.com/ElektraInitiative/libelektra/milestone/31?closed=1) for this release.

About 25 authors changed 376 files with 39350 insertions(+) and 13609 deletions(-) in 393 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.10.tar.gz)
or [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.10.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.10.tar.gz.hashsum?raw=true)

- name: elektra-0.9.10.tar.gz
- size: 9150058
- md5sum: c77f5bcf4e8202fd6d8b6ad6e7c841f4
- sha1: d63c24ea6c666b02d0bd9f059f2d73f96009496d
- sha256: ee50fb5e9814b45a8e99f39435b1461d4b7a7daa27eee240bdbfed98f2c4c0f5

The release tarball is also available signed using GnuPG from
[here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.10.tar.gz.gpg) or on
[GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.10.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.10/html/)
or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.10).

## Stay tuned!

Subscribe to the
[RSS feed](https://www.libelektra.org/news/feed.rss)
to always get the release notifications.

If you also want to participate, or for any questions and comments
please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.10-release)

For more information, see [https://libelektra.org](https://libelektra.org).

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.11 Release

- guid: 1390D163-9CEC-493D-839D-3930B9FFB6C4
- author: Mihael Pranjić
- pubDate: Wed, 05 Oct 2022 08:14:35 +0200
- shortDesc: New Backend System, Opensesame Application, FLOSS Course

We are proud to release Elektra 0.9.11.

## 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.11-release).

You can try out the latest Elektra release using our Docker image [elektra/elektra](https://hub.docker.com/r/elektra/elektra).
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run:

```sh
docker pull elektra/elektra
docker run -it elektra/elektra
```

## Highlights

- Preparing new-backend merge
- Olimex
- Improving Elektra in FLOSS course

### Preparing new-backend merge

In a separated branch we rewrote the whole backend system.
With this new backend system, backends are now also plugins, allowing backends also to be non-file-based, e.g., using databases.
The main purpose of this release is to give a last stable release before master gets disrupted with a huge changeset.
The next release is not to be expected in this year.

A huge thanks to _(Klemens Böswirth @kodebach)_, _(Maximilian Irlinger @atmaxinger)_ for the many changes in the branch.
Thanks to _(Richard Stöckl @Eiskasten)_ for testing.

### Olimex

Elektra is used for [server, desktop and embedded](/doc/WHO.md).
With this release, we strengthen our embedded mainstay, specifically in [open source hardware OSHW](https://freedomdefined.org/OSHW).
We developed a major application running on OSHW [Olimex](https://www.olimex.com/Products/OLinuXino/open-source-hardware) boards.
The application is called [opensesame](https://opensesame.libelektra.org).
It is heavily relying on Elektra and [ansible-libelektra](https://github.com/ElektraInitiative/ansible-libelektra).

In the initial release [opensesame](https://opensesame.libelektra.org) already allows:

- [x] opening (garage) doors via a novel PIN entry method: you can press and release buttons in any sequence
- [x] switching on entry lights
- [x] ringing doorbells
- [x] detection of fire
- [x] report events to Nextcloud chats (English and German)

To give a smoother experience when running such an application we will develop Ansible scripts to customize the Olimex base images.
They will allow changing the language, time zone, static network configuration etc.

Olimex likes this idea and will send us an A20 board.
A big thanks to [Olimex](https://www.olimex.com).

### Improving Elektra in FLOSS course

Also in the [upcoming term](https://tiss.tuwien.ac.at/course/courseDetails.xhtml?courseNr=194114&semester=2022W) Elektra will be object of study how FLOSS initiatives work.
Students will make improvements in Elektra as part of their homework, teamwork and, if chosen, also for their project.
Alternatively, they can also improve other self-chosen FLOSS initiatives.

## Plugins

The following text list news about the [plugins](https://www.libelektra.org/plugins/readme) we updated in this release.

- fix unused-but-set-variable warnings. _(Markus Raab)_

### csvstorage

- Remove superfluous if-conditions that lead to a build error on Debian Unstable _(Maximilian Irlinger @atmaxinger)_

### specload

- fail if either the spec or parentKey parameter of elektraSpecloadSendSpec is NULL _(@hannes99)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

- fix unused-but-set-variable warnings. _(Markus Raab)_

### opts

- opts: fix possible 'free(): invalid pointer' error and add test for it _(@hannes99)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme).
This section keeps you up-to-date with the multi-language support provided by Elektra.

### Python

- add merging based on elektraMerge _(Maximilian Irlinger @atmaxinger)_

### Rust

- start again to publish on crates.io, used by opensesame _(Markus Raab)_

## Documentation

- Added [Documentation Guidelines](https://master.libelektra.org/doc/contrib/documentation.md) _(Markus Raab)_
- Decisions for changes to `keyIsBelow` and new `keyGetNextPart` functions _(@kodebach)_
- Apply fix spelling to more files. _(Markus Raab)_

### Tutorials

- opts: use arg/help instead of arg/name _(@hannes99)_

### Man Pages

- Update [FAQ](/doc/help/elektra-faq.md). _(Markus Raab)_

## Tests

- Use GoogleTest framework v1.12.1. _(Mihael Pranjić @mpranj)_

## Build

### CMake

- Fix build with newer libgit2 versions _(Fabian Vogt)_
- We now require at least CMake `3.12` (released in July 2018). _(Maximilian Irlinger @atmaxinger)_

### Docker

- Bump Alpine Linux to 3.16.0. _(Mihael Pranjić @mpranj)_
- The Docker image for building the documentation is now [based on Debian Bullseye](../../scripts/docker/debian/bullseye/doc.Dockerfile). _(Maximilian Irlinger @atmaxinger)_
- Add Fedora 36 images. _(Mihael Pranjić @mpranj)_

## Infrastructure

### Jenkins

- We no longer build and test on Ubuntu Xenial and Debian Stretch due to outdated CMake versions _(Maximilian Irlinger @atmaxinger)_
- Add Fedora 36 builds, remove Fedora 34 builds. _(Mihael Pranjić @mpranj)_

### Cirrus

- Update FreeBSD images to 13.1 and 12.3 and update packages before builds. _(Mihael Pranjić @mpranj)_
- Bump Fedora builds to Fedora 36. _(Mihael Pranjić @mpranj)_

## Website

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

## Outlook

We are currently working on following topics:

- 1.0 API _(Klemens Böswirth @kodebach)_ and _(Stefan Hanreich)_
- Elektrify KDE and GNOME _(Mihael Pranjić @mpranj)_
- Elektrify XFCE _(Richard Stöckl @Eiskasten)_
- Mounting SQL databases _(Florian Lindner @flo91)_
- Recording Configuration _(Maximilian Irlinger)_
- Ansible-Elektra _(Lukas Hartl)_ and _(Maximilian Irlinger)_
- Configure Olimex Base Images _(Maximilian Irlinger)_
- Improving Build Server Infrastructure _(Lukas Hartl)_ and _(Maximilian Irlinger)_
- Improve Java Development Experience _(Michael Tucek)_
- Rewriting tools in C _(@hannes99)_

## Statistics

We closed [17 issues](https://github.com/ElektraInitiative/libelektra/milestone/32?closed=1) for this release.

About 11 authors changed 156 files with 4020 insertions(+) and 3298 deletions(-) in 134 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.11.tar.gz) or from
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.11.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.11.tar.gz.hashsum?raw=true)

- name: elektra-0.9.11.tar.gz
- size: 9149900
- md5sum: 227094a7760f8faece1a7b8386d01fce
- sha1: a0d2f0d39c8360f67da96585993223b7f9cdebe6
- sha256: 3509adf83efdf08fa0dc5d51396772addff7d8fc82299c18b146fa4406eecff5

The release tarball is also available signed using GnuPG from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.11.tar.gz.gpg) or on
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.11.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found [here](https://doc.libelektra.org/api/0.9.11/html/) or on [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.11).

## Stay tuned!

Subscribe to the [RSS feed](https://www.libelektra.org/news/feed.rss) to always get the release notifications.

If you also want to participate, or for any questions and comments please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.11-release)

For more information, see [https://libelektra.org](https://libelektra.org).

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.12 Release

- guid: F2193578-1773-43A9-85CA-79EA8CE48D7B
- author: Mihael Pranjić
- pubDate: Fri, 03 Mar 2023 08:07:28 +0100
- shortDesc: New Backend Logic, Copy-on-Write, FLOSS Course

We are proud to release Elektra 0.9.12.

## 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.12-release).

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/elektra/elektra).
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run:

```sh
docker pull elektra/elektra
docker run -it elektra/elektra
```

## Highlights

- New Backend
- Copy-on-Write
- FLOSS

### New Backend

The entire logic for backends has been rewritten, to allow for more flexibility und an unlimited number of plugins.
Instead of calling plugins directly, `libelektra-kdb` now only calls so-called backend plugins and special hook plugins.
There is a [contract](../dev/backend-plugins.md) between `libelektra-kdb` and the backend plugins.
All backend plugins must adhere to this contract.
To achieve this goal, most backend plugins will call other plugins (like `libelektra-kdb` did previously).

The logic previously implemented in `libelektra-kdb` was moved to the new default backend plugin `backend`.
It works like the old system, but now also allows an unlimited number of plugins in positions where that makes sense.
For example, you can have unlimited `postgetstorage` plugins, but only a single `getresolver`.

There have also been slight changes to `kdbGet` and `kdbSet`.
Please read their API docs to find out, if you rely on any behavior that has been altered.
You can also read the [new low-level docs](../dev/kdb-operations.md) to find out all the intricate details.

The structure of `system:/elektra/mountpoints` changed as well.
Take a look at the [new docs](../dev/mountpoints.md), if you need to know details.

#### Updating config

The mountpoint configuration format contains **breaking changes** and a manual upgrade process is needed.
Follow these steps to upgrade the old mountpoint configuration to the new format:

> **Warning**: BACK UP YOUR CONFIG FILES BEFORE UPDATING!
> We recommend making a backup of the file printed by `kdb file system:/elektra/mountpoints` before updating your installation.
> In the unlikely case that the migration script fails, you can still use the information from the backup to manually recreate your mountpoints.

To update your existing `system:/elektra/mountpoints` data you can use the [migration script](/scripts/migrate-mountpoints.py).

> **Note**: To run the script you must have Elektra, Python (>= 3.7) and the Python binding installed.
> The script uses the Python binding to manipulate `Key`s and `KeySet`s, but it does not use the `kdb` CLI tool, or the `KDB` API.
> It is safe to run this script before, or after you update your Elektra installation.

By default, the script loads the file `/etc/kdb/elektra.ecf`.
If you changed where `system:/elektra/mountpoints` is stored, you can provide an alternative path:

```
./migrate-mountpoints.py /path/to/your/mountpoints/config.file
```

> **Note**: Because the script does not use the `KDB` API it only works, if the mountpoints config file uses the default `dump` format.
>
> If your mountpoints config file is not using the `dump` format, you may still be able to use the migration script.
> However, in that case, you will have to use the script **before** updating your Elektra installation:
>
> 1. Run `kdb export system:/elektra/mountpoints dump` to get a copy of your mountpoints config in `dump` format
> 2. Write this data to a file and run the migration script on the file.
> 3. To get the data back in your original format you can use
>
> ```sh
> ./migrate-mountpoints.py /path/to/file/from/step2 | kdb convert dump your-format > /path/to/converted/file
> ```
>
> 4. Run `kdb file system:/elektra/mountpoints` to find out where your mountpoint config is stored.
>    Make sure to back up this file, before upgrading your installation.
> 5. Now upgrade your Elektra installation.
> 6. Copy the file `/path/to/converted/file` from step 3 to the location you got in step 4.

The script will read the old mountpoint configuration from the given file.
It will convert the configuration and print the new version to `stdout`.

You can inspect the output to make sure, everything is in order.
When you are ready to commit the changes, you can manually edit the config file, or use:

```
./migrate-mountpoints.py --output=/etc/kdb/elektra.ecf /etc/kdb/elektra.ecf
```

#### Individual changes

- Implement [hooks](https://www.libelektra.org/decisions/hooks-in-kdb). _(Maximilian Irlinger @atmaxinger)_
- Removed old global plugins code. _(Maximilian Irlinger @atmaxinger)_
- New backend logic, based on PR #2969 by @vLesk. _(@kodebach)_
- Add script to migrate `system:/elektra/mountpoints` to new format. _(@kodebach)_

### Copy-on-Write

Thanks to _(Maximilian Irlinger @atmaxinger)_ our `Key` and `KeySet` datastructures are now fully copy-on-write!
This means noticeably reduced memory usage for cases where keys and keysets are copied and/or duplicated!

We ran some very promising benchmarks, each were performed with 400,000 keys.
All benchmarks were executed using `valgrind --tool=massif --time-unit=B --max-snapshots=200 --threshold=0.1`.

| Benchmark      | Old Implementation | Copy-on-Write | Size Reduction | Remarks                    |
| :------------- | -----------------: | ------------: | -------------: | :------------------------- |
| `createkeys.c` |            5.3 MiB |       6.5 MiB |          -22 % |                            |
| `deepdup.c`    |           10.5 MiB |       8.2 MiB |           22 % |                            |
| `large.c`      |           18.9 MiB |      15.3 MiB |           19 % |                            |
| `kdb.c`        |           23.5 MiB |      17.8 MiB |           24 % |                            |
| `kdbget.c`     |           11.0 MiB |       8.8 MiB |           20 % |                            |
| `kdbmodify.c`  |           11.0 MiB |       8.8 MiB |           20 % | Same results as `kdbget.c` |

First, it should be noted that a single key, without counting payload, is about 50% larger with the copy-on-write implementation.
This explains why the `createkeys.c` benchmark yields a negative reduction result.
This benchmark only allocates keys, so not much improvement can be expected there.
Still, as other stuff also uses heap memory, the overall memory consumption only increased by 22%, which is far less than 50%.

All other benchmarks saw meaningful reductions of heap memory used.
One interesting observation is that `kdbget.c` and `kdbmodify.c` used exactly the same memory.
This can most likely be explained by internal caching within the memory allocator of `glibc`.

We also performed runtime tests on the same benchmarks using `perf stat --repeat 13` to ensure no major performance regressions occur.

| Benchmark      | Old Implementation | Deviation | Copy-on-Write | Deviation | Runtime Increase |
| :------------- | -----------------: | --------: | ------------: | --------: | ---------------: |
| `createkeys.c` |         0.209572 s |    0.36 % |     0.21987 s |    0.77 % |            4.9 % |
| `deepdup.c`    |          0.23025 s |    0.47 % |    0.231804 s |    0.32 % |            0.6 % |
| `large.c`      |          1.14038 s |    0.21 % |     1.14837 s |    0.21 % |            0.7 % |
| `kdb.c`        |           1.9270 s |    2.63 % |     1.93354 s |    0.17 % |            0.3 % |
| `kdbget.c`     |         0.145663 s |    0.17 % |     0.15763 s |    0.70 % |            8.2 % |
| `kdbmodify.c`  |         0.146506 s |    0.19 % |    0.156347 s |    0.15 % |            6.7 % |

Overall, the runtime performance hit is less than 10%.
The more a program does, the less the additional overhead of the copy-on-write algorithms matter.
One interesting detail is that `keyCopy` and `keyDup` have become quite a bit faster.
This can be seen by comparing the differences between `createkeys.c` and `deepdup.c`.
The differences are 21 ms for the old implementation and 12 ms for the copy-on-write implementation.

### FLOSS

A Free/Libre and Open Source Software (FLOSS) Initiative couldn't survive with many small contributions fixing annoying problems.
This release also contains all contributions done via one term of the [FLOSS course](https://tiss.tuwien.ac.at/course/courseDetails.xhtml?courseNr=194114&semester=2022W).
The success was tremendous, as shown in the rest of the release notes.

A big thanks to the students for their contributions!

## Plugins

The following text lists news about the [plugins](https://www.libelektra.org/plugins/readme) we updated in this release.

### yajl

- Fix an issue where trying to set invalid meta-keys won't show an error. _(Juri Schreib @Bujuhu)_

### list

- Removed the outdated `list` plugin. _(Maximilian Irlinger @atmaxinger)_
  (Was only needed for global plugins, which are now replaced by [hooks](https://www.libelektra.org/decisions/hooks-in-kdb).)

### logchange

- Made logchange a notification-send hook plugin. _(Maximilian Irlinger @atmaxinger)_

### toml

- Fix bug, where meta-keys that cannot be inserted don't report an error. _(@Bujuhu)_

### uname

- Add error handling if uname call fails. _(Richard Stöckl @Eiskasten)_

### quickdump

- elektraQuickdumpSet: don't fclose if stdout. _(@hannes99)_

### blockresolver

- Add encoding test for blockresolver read. _(@dtdirect)_
- Refactor and restructure blockresolver. _(@dtdirect)_

### desktop

- Add a unit test. _(Richard Stöckl @Eiskasten)_

### mini

- Fix a bug where writing meta-keys will fail silently. _(Juri Schreib @Bujuhu)_

### mmapstorage

- Remove code duplication in the data block calculation. _(Richard Stöckl @Eiskasten)_

### network

- Add a retry mechanism. _(Richard Stöckl @Eiskasten)_

### xfconf

- Add xfconf storage plugin with the ability to read and write to xfconf channels. _(Richard Stöckl @Eiskasten)_
- Make xfconf valgrind suppressions more flexible to lib updates. _(Mihael Pranjić @mpranj)_

### date

- Fix an issue with validationg RFC 822 date-times. _(Juri Schreib @Bujuhu)_ _(Nikola Prvulovic @Dynamichost96)_
- Improve Code Coverage. _(Juri Schreib @Bujuhu)_ _(Nikola Prvulovic @Dynamichost96)_

### csvstorage

- Fix a bug where writing unkown meta-keys will fail silently. _(Juri Schreib @Bujuhu)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

### Compatibility

- Global plugins do not work anymore, use [hooks](https://www.libelektra.org/decisions/hooks-in-kdb) instead.

### Core

- The Key and KeySet datastructures are now fully copy-on-write. _(Maximilian Irlinger @atmaxinger)_
- `keyCopy` now only allocates additional memory if `KEY_CP_META` or `KEY_CP_ALL` is used. _(Maximilian Irlinger @atmaxinger)_
- Check for circular links (overrides). _(@0x6178656c)_

### io

- Check file flags for `elektraIoFdSetFlags`: file flags must be exactly one of: read only, write only or read write. _(Richard Stöckl @Eiskasten)_

### Merge

- Add methods `elektraMergeGetConflictingKeys` and `elektraMergeIsKeyConflicting` to check which keys were causing a merge conflict. _(Maximilian Irlinger @atmaxinger)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme).
This section keeps you up-to-date with the multi-language support provided by Elektra.

### intercept/env

- Remove fallback code. _(Markus Raab)_
- Command-line functionality is broken due to new-backend differences.

### intercept/fs

- Use `KDB_MAX_PATH_LENGTH` for better portability. _(Markus Raab)_

### jna

- Documentation: Improved build instructions. _(@Bujuhu)_
- Add validation on get for whitelist plugin. _(@Bujuhu)_
- Upgrade Gradle to 8.0.1. _(Mihael Pranjić @mpranj)_

### rust

- Fix "feature `resolver` is required" error. _(Markus Raab)_

### elixir

- Initial release of the Elixir binding. _(@0x6178656c)_
- Mark tests as `memleak`. _(@0x6178656c)_

## Tools

### kdb

- Removed `global-mount` and `global-umount` commands. _(Maximilian Irlinger @atmaxinger)_
- Fixed SIGSEGV when using `kdb find` without argument. _(Christian Jonak-Moechel @joni1993)_

### elektrad

- Removed leftover package-lock.json file. _(stefnotch)_

## Scripts

- Added [automatic spelling corrections](https://master.libelektra.org/scripts/spelling.sed) for changeset. _(Maximilian Irlinger @atmaxinger)_
- Introduce shebang-conventions. _(@0x6178656c)_
- Apply auto-fixes from shellcheck. _(@0x6178656c)_
- Use prettier 2.8.4. _(Mihael Pranjić @mpranj)_
- Add scripts to enable and disable pre-commit hooks. _(Juri Schreib @Bujuhu)_ _(Nikola Prvulovic @Dynamichost96)_
- Only let http links pass the check if whitelisted. _(Richard Stöckl @Eiskasten)_
- Link Checker: Add documentation for the usage and how it behaves. _(Richard Stöckl @Eiskasten)_
- Sed: Add spelling correction for "key-value storage". _(@Bujuhu)_
- Fix/extends some shell recorder tests. _(@Joni1993)_
- Use clang-format v15. _(Mihael Pranjić @mpranj)_
- Fix warning parsing in shell recorder. _(@Joni1993)_
- Replaced `egrep` by `grep -E`. _(@0x6178656c and @janldeboer)_
- Add [audit-dependencies](/scripts/dev/audit-dependencies) script to check for vulnerabilities for npm depndencies. _(Juri Schreib @Bujuhu)_ _(Nikola Prvulovic @Dynamichost96)_

## Documentation

- Restructured [contrib/api](/doc/contrib/api). _(Markus Raab)_.
- Improve page on compilation. _(@0x6178656c)_
- Improve page for bindings. _(@0x6178656c)_
- Improve page for getting started. _(@stefnotch)_
- Remove version number from docker README and replace it with latest. _(@Joni1993)_
- Fix grammar for `elektra-granularity.md`. _(@dtdirect)_
- Rephrase sections in `doc/dev/error-\*`. _(@dtdirect)_
- Improve Git.md. _(Juri Schreib @Bujuhu)_ _(Nikola Prvulovic @Dynamichost96)_
- Unify spelling of man pages. _(@stefnotch)_ _(@janldeboer)_
- Extend consistency check `check_doc.sh` to work for [contrib](/doc/contrib), [dev](/doc/dev) and [tutorials](/doc/tutorials). _(@Joni1993)_
- Fix internal links. _(@0x6178656c)_
- Update AUR Link from `elektra` to `libelektra` package. _(@Bujuhu)_
- Update example Ansible playbook in VISION.md. _(@Bujuhu)_
- Harmonize spelling of Git. _(@Joni1993)_
- Update packaging instructions for Fedora. _(@0x6178656c)_
- Improve use of gender. _(@0x6178656c)_
- Fix some minor mistakes in CONTRIBUTING.md. _(@Joni1993)_
- Fix various spelling errors. _(@Joni1993)_
- Denoted package names & global variable names in [INSTALL.md](../INSTALL.md) as `Code`. _(@janldeboer)_
- Improve readability of doc/tutorials/highlevel.md. _(@deoknats861)_
- Improve reference to Podman documentation. _(@0x6178656c)_
- Unify spelling. _(@Joni1993)_
- Fix typo in dev/hooks.md. _(@dtdirect)_
- Remove unused images from doc/images. _(@dtdirect)_
- Fixed Coverage Badge Link. _(@janldeboer)_
- Improve CONTRIBUTING doc. _(Juri Schreib @Bujuhu)_ and _(Nikola Prvulovic @Dynamichost96)_
- Update Doxyfile with Doxygen 1.9.4. _(@0x6178656c)_
- Add project logo to Doxygen in Doxyfile. _(@dtdirect)_
- Add mermaid.js to the project using doxygen-mermaid. _(@dtdirect)_
- Create diagrams in mermaid.js to use in doxygen. _(@dtdirect)_
- Create README for Doxygen and Mermaid JS. _(@dtdirect)_
- Tutorial: Add automatic validation to Docker tutorial _(Schreib @Bujuhu)_ _(Nikola Prvulovic @Dynamichost96)_
- Add mention of audit-dependencies script in doc/todo/RELEASE.md. _(@Bujuhu)_
- Move note in GETSTARTED.md. _(@Joni1993)_
- Use `code` blocks to prevent Markdown from falsy rendering LaTeX. _(@stefnotch)_, _(@janldeboer)_
- Fix broken links in use cases for KDB after files were renamed. _(Florian Lindner @flo91)_
- Replace http links with https. _(Richard Stöckl @Eiskasten)_
- Enhance notifications.md in doc/tutorial. _(@dtdirect)_
- Add tutorial how to suppress memleaks in plugins from dependencies. _(Richard Stöckl @Eiskasten)_
- Write about [history](/doc/dev/history.md) to make plans of Elektra's adoption more clear. _(Markus Raab)_

### Use Cases

- Improve use cases [Template](/doc/usecases/template.md). _(@kodebach and Markus Raab)_
- Use cases for [KDB](/doc/usecases/kdb). _(@kodebach)_
- Use cases for `libelektra-core`. _(@kodebach)_

### Decisions

- Decide and implement [decision process](../decisions/5_partially_implemented/decision_process.md). _(Markus Raab)_
- Decided future [library split](../decisions/4_decided/library_split.md). _(@kodebach)_
- Decided [decision process](https://www.libelektra.org/decisions/decision-process). _(Markus Raab)_
- Draft for [man pages](../decisions/0_drafts/man_pages.md). _(Markus Raab)_
- Add decision for [change tracking](../decisions/3_in_review/change_tracking.md). _(Maximilian Irlinger @atmaxinger)_
- Create [decision](../decisions/0_drafts/operation_sequences.md) for allowed and prohibited operation seqences. _(Maximilian Irlinger @atmaxinger)_
- Add decisions about [location of headers](../decisions/4_decided/header_file_structure.md) and [use of `#include`](../decisions/4_decided/header_include.md) in the repo. _(@kodebach)_
- Add decision about [metadata semantics](../decisions/0_drafts/metakey_semantics.md). _(@kodebach)_
- Many small fixes to adapt to documentation guidelines and new decision process. _(Markus Raab)_
- Add decision for [read-only keynames](../decisions/0_drafts/readonly_keynames.md). _(Maximilian Irlinger @atmaxinger)_
- Revive [keyname decision](../decisions/4_decided/keyname.md). _(@kodebach)_
- Add decisions for [constructor functions](../decisions/0_drafts/constructor_functions.md) and [builder functions](../decisions/0_drafts/builder_functions.md). _(@kodebach)_
- Add decision for [copy-on-write](../decisions/6_implemented/copy_on_write.md) and provide implementation suggestions. _(Maximilian Irlinger @atmaxinger)_
- Update [internal cache](../decisions/4_decided/internal_cache.md). _(Markus Raab)_ _(@kodebach)_
- Create [transformations](../decisions/0_drafts/transformations.md). _(Maximilian Irlinger @atmaxinger)_
- Replace TOC-style [README.md](../decisions/README.md) with folders and generate HTML for website. _(@kodebach)_
- Restructured decisions directories based on new agreed-upon [steps](../decisions/STEPS.md). _(Maximilian Irlinger @atmaxinger)_
- Decision for [types of `KeySet`s](../decisions/2_solutions_clear/keyset_types.md). _(@kodebach)_
- Added [Documentation Guidelines](https://master.libelektra.org/doc/contrib/documentation.md). _(Markus Raab)_
- Add links and formatting to documents affected by PR#4492 (Document Guidelines) and rephrase some parts. _(Florian Lindner @flo91)_
- Decisions for changes to `keyIsBelow` and new `keyGetNextPart` functions. _(@kodebach)_
- Apply fix spelling to more files. _(Markus Raab)_

### Tutorials

- Add tutorial for manual installation from the AUR on Arch Linux. _(@Bujuhu)_
- Add Markdown shell recorder validation to install.webui.md. _(@deoknats861)_
- Fix the outdated array tutorial. _(Juri Schreib @Bujuhu)_ _(Nikola Prvulovic @Dynamichost96)_
- Reinstate mounting tutorial. _(@Bujuhu)_
- Make namespaces tutorial verifiable. _(@0x6178656c)_
- Move Podman-related information to a dedicated page. _(@0x6178656c)_

### Man Pages

- Update man page (patch) as suggested by the CI to fix CI error on master. _(Florian Lindner @flo91)_
- Added links to the website & webui after further reading. _(Philipp Nirnberger @nirnberger)_
- Upgrade `ronn-ng` to 0.10.1.pre3. _(Mihael Pranjić @mpranj)_

## Tests

- Fix an Issue where scripts/dev/fix-spelling does not work, if a resolved path contains whitespaces. _(Juri Schreib @Bujuhu)_ _(Nikola Prvulovic @Dynamichost96)_
- Rename scripts/sed to [scripts/spelling.sed](https://master.libelektra.org/scripts/spelling.sed). _(Juri Schreib @Bujuhu)_ _(Nikola Prvulovic @Dynamichost96)_
- Add `memleak` label to `test_getenv`. _(@0x6178656c)_
- Add test using shellcheck. _(@0x6178656c)_
- Remove `--rerun-failed` from `run_*` scripts. _(@kodebach)_
- Fix paths for icheck test. _(Mihael Pranjić @mpranj)_

### Shell Recorder

- Add check if file exists. _(@0x6178656c)_

## Packaging

- Add missing new `backend` plugin to components of libelektra package. _(Mihael Pranjić @mpranj)_

## Build

### CMake

- Fix warning for CMP0115. _(0x6178656c)_
- Change Doxygen configuration for LaTeX. _(0x6178656c)_
- Fix developer warning for package DISCOUNT. _(Dennis Toth @dtdirect)_
- Pass `--stacktrace` to gradle for the JNA builds. _(Maximilian Irlinger @atmaxinger)_
- Adapt npm build flags to remove reproducability issues. _(Juri Schreib @Bujuhu)_ _(Nikola Prvulovic @Dynamichost96)_
- Fix creation of shell recorder tests. _(@0x6178656c)_

### Docker

- Update packagename `libpcrec++-dev` to `libpcrecpp0v5` in Debian Sid. _(Richard Stöckl @Eiskasten)_
- Add shellcheck to Debian containers. _(@0x6178656c)_
- Use `openjdk-17-jdk` in Debian Sid. _(Maximilian Irlinger @atmaxinger)_
- Add Fedora 37 images. _(Mihael Pranjić @mpranj)_
- Update Debian Sid image to use repository Python modules instead of installing with `pip3` due to upstream debian changes. _(Mihael Pranjić @mpranj)_
- Debian Bullsye: use clang 13. _(Mihael Pranjić @mpranj)_
- Update Alpine Linux to 3.17.2. _(Mihael Pranjić @mpranj)_

## Gradle

- Use Gradle 7.5.1. _(Mihael Pranjić @mpranj)_
- Update `java-library.gradle` to use `archiveClassifier` _(Maximilian Irlinger @atmaxinger)_

## Infrastructure

### Jenkins

- Add Fedora 37 builds, drop Fedora 35 builds. _(Mihael Pranjić @mpranj)_
- Run more tests also on Master. _(Markus Raab)_
- Move doc to main build stage. _(Markus Raab)_
- Disable parallel test runs. _(Maximilian Irlinger @atmaxinger)_
- Upgrade Jenkins node container to Debian bullseye. _(@0x6178656c)_
- Undo previous change that added automatic `ctest --rerun-failed` to Jenkins CI. _(@kodebach)_

### Cirrus

- Use Fedora 37. _(Mihael Pranjić @mpranj)_
- Fix `macos_instance` reference, upgrade to macOS Ventura (by default), use Python 3.11 and Ruby 3.x. _(Mihael Pranjić @mpranj)_
- Automatically rerun `testmod_dbus*` tests on macOS. _(@kodebach)_
- Fix dbus not starting on macOS. _(Maximilian Irlinger @atmaxinger)_

### GitHub Actions

- Add auto-cancellation-running action. _(Tomislav Makar @tmakar)_
- Automatically rerun `testmod_dbus*` tests on macOS. _(@kodebach)_
- Fix dbus not starting on macOS. _(Maximilian Irlinger @atmaxinger)_
- Change stale issue/PR checking to GitHub action. _(@0x6178656c)_
- Update configuration of stale issue/PR action. _(@0x6178656c)_
- Upgrade actions to recent versions and remove deprecated ruby-setup action. _(Mihael Pranjić @mpranj)_

## Website

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

- Fix broken `/pythongen` link on homepage. _(@stefnotch)_
- Fix redirect logic to not cause loops. _(@stefnotch)_
- Remove duplicated link to `TESTING.md` file. _(@stefnotch)_, _(@janldeboer)_
- Restructure parts of the links on the website. _(@stefnotch)_, _(@janldeboer)_
- Removed broken links to packages for Linux distributions. _(@Dynamichost96)_
- Update npm packages. _(Mihael Pranjić @mpranj)_
- Change URLs to say man-page with a dash. _(@stefnotch)_ _(@janldeboer)_

## Outlook

We are currently working on following topics:

- 1.0 API _(Klemens Böswirth @kodebach)_ and _(Stefan Hanreich)_
- Session recording and better Ansible integration _(Maximilian Irlinger @atmaxinger)_
- Change tracking _(Maximilian Irlinger @atmaxinger)_
- Rewriting tools in C _(@hannes99)_
- Elektrify KDE and GNOME _(Mihael Pranjić @mpranj)_
- Elektrify XFCE _(Richard Stöckl @Eiskasten)_
- Mounting SQL databases _(Florian Lindner @flo91)_
- Recording Configuration _(Maximilian Irlinger)_
- Ansible-Elektra _(Lukas Hartl)_ and _(Maximilian Irlinger)_
- Configure Olimex Base Images _(Maximilian Irlinger)_
- Improving Build Server Infrastructure _(Lukas Hartl)_ and _(Maximilian Irlinger)_
- Improve Java Development Experience _(Michael Tucek)_

## Statistics

We closed about [150 issues](https://github.com/ElektraInitiative/libelektra/milestone/33?closed=1) for this release.

About 28 authors changed 960 files with 29400 insertions(+) and 20927 deletions(-) in 1421 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.12.tar.gz) or
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.12.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.12.tar.gz.hashsum?raw=true)

- name: elektra-0.9.12.tar.gz
- size: 9297913
- md5sum: a6de9401709283b69ec211681f2a7757
- sha1: cb4e282d1346fda771de7510663652555f8e6c7d
- sha256: 38238ba4a5318f999dc3045da06467abf529344dc46ad3fdf42bdca0155e149c

The release tarball is also available signed using GnuPG from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.12.tar.gz.gpg) or
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.12.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found

- [here](https://doc.libelektra.org/api/0.9.12/html/) or
- [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.12).

## Stay tuned!

Subscribe to the [RSS feed](https://www.libelektra.org/news/feed.rss) to always get the release notifications.

If you also want to participate, or for any questions and comments, please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.12-release)

For more information, see [https://libelektra.org](https://libelektra.org).

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.13 Release

- guid: e8fd116d-12ab-4281-aaf3-b6441056dd63
- author: Mihael Pranjić
- pubDate: Tue, 14 Mar 2023 10:05:11 +0100
- shortDesc: Bugfix, Ubuntu Packages

We are proud to release Elektra 0.9.13.

## 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.13-release).

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/elektra/elektra).
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run:

```sh
docker pull elektra/elektra
docker run -it elektra/elektra
```

## Highlights

- The main purpose of this bugfix release is to fix a regression ([#4859](https://github.com/ElektraInitiative/libelektra/issues/4859)) introduced in Elektra 0.9.12.
- We added fresh Ubuntu Jammy Jellyfish (22.04 LTS) and Kinetic Kudu (22.10) packages.
- Please refer to the [Elektra 0.9.12](https://www.libelektra.org/news/0.9.12-release) release notes for a complete list of changes. Due to breaking changes since 0.9.11 we highly recommend to read the upgrade instructions.

## Plugins

The following text lists news about the [plugins](https://www.libelektra.org/plugins/readme) we updated in this release.

### spec

- Add hook placement to spec plugin in [README](../../src/plugins/spec/README.md) _(Tomislav Makar @tmakar)_

### gopts

- Add hook placement to gopts plugin in [README](../../src/plugins/gopts/README.md) _(Tomislav Makar @tmakar)_

### internalnotifications

- Add Maximilian Irlinger as maintainer _(Maximilian Irlinger @atmaxinger)_

### logchange

- Add Maximilian Irlinger as maintainer _(Maximilian Irlinger @atmaxinger)_

### dbus

- Add Maximilian Irlinger as maintainer _(Maximilian Irlinger @atmaxinger)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

### tools

- Check for hook placement on `plugin-check` _(Tomislav Makar @tmakar)_

### merge

- Add Maximilian Irlinger as maintainer _(Maximilian Irilnger @atmaxinger)_

## Documentation

- .github rework _(Markus Raab)_
- Added `hook` to `placements` contract in [CONTRACT.ini](../CONTRACT.ini) _(Tomislav Makar @tmakar)_
- Added `hook` information to [hooks.md](../dev/hooks.md)
- Add correct error code in hosts readme _(Tomislav Makar)_

## Build

### CMake

- Add `infos/maintainer` in plugins. _(Maximilian Irlinger @atmaxinger)_

### Docker

- Add Ubuntu Jammy Jellyfish (22.04 LTS) images. _(Mihael Pranjić @mpranj)_
- Add Ubuntu Kinetic Kudu (22.10) images. _(Mihael Pranjić @mpranj)_

## Infrastructure

### Jenkins

- Add Ubuntu Jammy Jellyfish (22.04 LTS) builds and drop Bionic builds. _(Mihael Pranjić @mpranj)_
- Add Ubuntu Kinetic Kudu (22.10) builds. _(Mihael Pranjić @mpranj)_

## Outlook

We are currently working on following topics:

- 1.0 API _(Klemens Böswirth @kodebach)_ and _(Stefan Hanreich)_
- Session recording and better Ansible integration _(Maximilian Irlinger @atmaxinger)_
- Change tracking _(Maximilian Irlinger @atmaxinger)_
- Rewriting tools in C _(@hannes99)_
- Elektrify KDE and GNOME _(Mihael Pranjić @mpranj)_
- Elektrify XFCE _(Richard Stöckl @Eiskasten)_
- Mounting SQL databases _(Florian Lindner @flo91)_
- Recording Configuration _(Maximilian Irlinger)_
- Ansible-Elektra _(Lukas Hartl)_ and _(Maximilian Irlinger)_
- Configure Olimex Base Images _(Maximilian Irlinger)_
- Improving Build Server Infrastructure _(Lukas Hartl)_ and _(Maximilian Irlinger)_
- Improve Java Development Experience _(Michael Tucek)_

## Statistics

We closed [5 issues](https://github.com/ElektraInitiative/libelektra/milestone/34?closed=1) for this release.

About 7 authors changed 35 files with 1186 insertions(+) and 534 deletions(-) in 48 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.13.tar.gz) or
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.13.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.13.tar.gz.hashsum?raw=true)

- name: elektra-0.9.13.tar.gz
- size: 9297899
- md5sum: 871eaaad39bc834ceb7fb42cb8de66f0
- sha1: 68984021d08500693d692c2cb61eb3409fe75226
- sha256: 9b7512d493c284afcca9875d093081c85c4cfe4926dea193202fbdc5fe89b468

The release tarball is also available signed using GnuPG from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.13.tar.gz.gpg) or
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.13.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found

- [here](https://doc.libelektra.org/api/0.9.13/html/) or
- [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.13).

## Stay tuned!

Subscribe to the [RSS feed](https://www.libelektra.org/news/feed.rss) to always get the release notifications.

If you also want to participate, or for any questions and comments, please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.13-release)

For more information, see [https://libelektra.org](https://libelektra.org).

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.9.14 Release

- guid: 9e1e0790-e7ae-4947-9906-2c176a4f8dd2
- author: Mihael Pranjić
- pubDate: Thu, 16 Mar 2023 14:43:04 +0100
- shortDesc: Bugfix Release

We are proud to release Elektra 0.9.14.

## 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.9.14-release).

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/elektra/elektra).
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run:

```sh
docker pull elektra/elektra
docker run -it elektra/elektra
```

## Highlights

- The main purpose of this bugfix release is to fix regressions ([#4859](https://github.com/ElektraInitiative/libelektra/issues/4859)) introduced in Elektra 0.9.12 and 0.9.13.
- Please refer to the [Elektra 0.9.12](https://www.libelektra.org/news/0.9.12-release) release notes for a complete list of changes. Due to breaking changes since 0.9.11 we highly recommend to read the upgrade instructions.

## Plugins

The following text lists news about the [plugins](https://www.libelektra.org/plugins/readme) we updated in this release.

### timeofday

- Use separate symbols for `set` and `commit` functions to satisfy `kdb plugin-check` _(@kodebach)_
- Use new `elektraPluginGetPhase()` instead of counting executions _(@kodebach)_

### tracer

- Use separate symbols for `set` and `commit` functions to satisfy `kdb plugin-check` _(@kodebach)_

## Tests

- Enable more `kdb plugin-check` tests _(@kodebach)_

## Build

### Docker

- Fix conflicting Java versions in CentOS Stream 8 image _(@kodebach)_

## Outlook

We are currently working on following topics:

- 1.0 API _(Klemens Böswirth @kodebach)_ and _(Stefan Hanreich)_
- Session recording and better Ansible integration _(Maximilian Irlinger @atmaxinger)_
- Change tracking _(Maximilian Irlinger @atmaxinger)_
- Rewriting tools in C _(@hannes99)_
- Elektrify KDE and GNOME _(Mihael Pranjić @mpranj)_
- Elektrify XFCE _(Richard Stöckl @Eiskasten)_
- Mounting SQL databases _(Florian Lindner @flo91)_
- Recording Configuration _(Maximilian Irlinger)_
- Ansible-Elektra _(Lukas Hartl)_ and _(Maximilian Irlinger)_
- Configure Olimex Base Images _(Maximilian Irlinger)_
- Improving Build Server Infrastructure _(Lukas Hartl)_ and _(Maximilian Irlinger)_
- Improve Java Development Experience _(Michael Tucek)_

## Statistics

We closed [2 issues](https://github.com/ElektraInitiative/libelektra/milestone/35?closed=1) for this release.

About 4 authors changed 22 files with 299 insertions(+) and 139 deletions(-) in 14 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.14.tar.gz) or
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.14.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.14.tar.gz.hashsum?raw=true)

- name: elektra-0.9.14.tar.gz
- size: 9299478
- md5sum: eb0f1d2e5d93bbae122999b5a27be343
- sha1: 8d7a44ae6b4d53c52ab4219f955d6010f87682c8
- sha256: e4632bb6baa78f6a68c312469e41fd1ef07406571749e32f2645b1858d01a58d

The release tarball is also available signed using GnuPG from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.9.14.tar.gz.gpg) or
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.9.14.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found

- [here](https://doc.libelektra.org/api/0.9.14/html/) or
- [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.9.14).

## Stay tuned!

Subscribe to the [RSS feed](https://www.libelektra.org/news/feed.rss) to always get the release notifications.

If you also want to participate, or for any questions and comments, please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.9.14-release)

For more information, see [https://libelektra.org](https://libelektra.org).

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# 0.10.0 Release

- guid: e0a2b6f4-b18d-47d8-b642-e27907255666
- author: Tomislav Makar
- pubDate: Tue, 23 May 2023 13:33:52 +0200
- shortDesc: New Changetracking API, New spec plugin, Go into repo

We are proud to release Elektra 0.10.0.

## 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/0.10.0-release).

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/elektra/elektra).
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run:

```sh
docker pull elektra/elektra
docker run -it elektra/elektra
```

## Highlights

- New Changetracking API
- New spec plugin
- Go into repo

### New Changetracking API

We've created a new KeySet diffing and changetracking API for both internal and external use.
Several plugins already had their own implementations to detect changes made to the key database.
Every implementation did something different and results varied.
With this new release every plugin now uses the same shared implementation, with identical results!

To try the amazing new API yourself, take a look at [the tutorial](../tutorials/changetracking.md).

Elektra's internal code now also uses this new API to detect which backends to execute.
This can lead to better performance in I/O bound cases, where previously certain keys would have been detected as changed when they weren't.

We ran some memory benchmarks and found a slightly increased memory usage on a stock instance of Elektra.
If you're using many plugins that do changetracking, the overhead will decrease.

| Number of Keys | Old Implementation (bytes) | New Implementation (bytes) | Memory Increase (%) |
| -------------: | -------------------------: | -------------------------: | ------------------: |
|             50 |               225792 bytes |               229580 bytes |              1,68 % |
|            500 |               383180 bytes |               411238 bytes |              7,32 % |
|           5000 |              1992294 bytes |              2306867 bytes |             15,79 % |
|          50000 |             18245222 bytes |             21181235 bytes |             16,09 % |
|         500000 |            178782208 bytes |            207827763 bytes |             16,25 % |

Apart from memory benchmark, we also ran some performance benchmarks.
As the benchmark is heavily I/O bound, the biggest bottleneck is the I/O performance of the system.
We could not reliably detect a real, reliably reproducible performance impact measured in seconds.
Alternatively, we have measured executed instructions.
There seems to be about 10 % overhead, but we don't expect it to be noticeable in real-world workloads.

| Number of Keys | Old Implementation (Instructions) | New Implementation (Instructions) | Performance Overhead (%) |
| -------------: | --------------------------------: | --------------------------------: | -----------------------: |
|             50 |                          18910449 |                          19583227 |                   3,56 % |
|            500 |                          63001911 |                          68948096 |                   9,44 % |
|           5000 |                         526801917 |                         586344210 |                  11,30 % |
|          50000 |                        5730261920 |                        6340292587 |                  10,65 % |
|         500000 |                      104614374974 |                      110702166761 |                   5,82 % |

### New spec plugin

The spec plugin was rewritten to use the standardized error handling in Elektra.
It is now strictly defined that the `spec` plugin throws a warning on `kdbGet` and on any other call an error.

Default values are now created in the `default` namespace.
The instantiated array specifications are now also created in the `default` namespace.

Keys with a require metakey and no default metakey do throw an error now.

Known limitations:

- `#` and `_` keys do not work on MINGW
- No defaults for `_` globbing character

For more information see [Spec Plugin](../../src/plugins/spec/README.md).

### Go into repo

The go binding is now inside of `libelektra` repository.
It is now also included into our build pipeline.
For more information on how to use it see [go readme](../../src/bindings/go-elektra/README.md).

> NOTE: On information how to publish new versions of `go-elektra` to go packages see [go-publishing](https://go.dev/doc/modules/publishing).

## Plugins

The following text lists news about the [plugins](https://www.libelektra.org/plugins/readme) we updated in this release.

### General

- Updated target name of shared object files according to [#3486](https://issues.libelektra.org/3486)

### spec

- Rewrite spec plugin, fix bugs and use correct error handling _(Tomislav Makar @tmakar)_
- Remove info metakey from spec plugin _(Tomislav Makar @tmakar)_

### counter

- Move `static` variables into functions to avoid global variables _(@kodebach)_

### logchange

- Utilize new changetracking API _(Maximilian Irlinger @atmaxinger)_
- Add Maximilian Irlinger as maintainer _(Maximilian Irlinger @atmaxinger)_

### yajl

- The `itKs` global variable workaround, which was used to replace the now removed internal `KeySet` cursor, was replaced with a custom context struct. _(@kodebach)_

### toml

- The `flex` lexer and `bison` parser are now fully reentrant and therefore thread-safe. _(@kodebach)_

### multifile

- Remove multifile plugin as it is unmaintained and conflicts with the new backend architecture _(Maximilian Irlinger @atmaxinger)_

### c

- Add Florian Lindner as maintainer _(Florian Lindner @flo91)_
- Use separate symbols for `set` and `commit` functions to satisfy `kdb plugin-check` _(@kodebach)_
- Use new `elektraPluginGetPhase()` instead of counting executions _(@kodebach)_

### mmapstorage

> **Note**: The plugin is currently disabled, because it is not yet compatible with the COW data structures.

TODO: remove above note, when COW support is added.

- The magic data structures are now fully compile-time constants.
  The magic number to detect endianness is generated in CMake instead of at runtime. _(@kodebach)_

### syslog

- Convert to hook plugin _(Maximilian Irlinger @atmaxinger)_
- Utilize new changetracking API _(Maximilian Irlinger @atmaxinger)_

### lineendings

- Add Florian Lindner as maintainer _(Florian Lindner @flo91)_

### length

- Add Florian Lindner as maintainer _(Florian Lindner @flo91)_

### missing

- Add Florian Lindner as maintainer _(Florian Lindner @flo91)_

### unit

- Add Florian Lindner as maintainer _(Florian Lindner @flo91)_

### dbus

- Utilize new changetracking API _(Maximilian Irlinger @atmaxinger)_
- Add Maximilian Irlinger as maintainer _(Maximilian Irlinger @atmaxinger)_

### internalnotifications

- Utilize new changetracking API _(Maximilian Irlinger @atmaxinger)_
- Add Maximilian Irlinger as maintainer _(Maximilian Irlinger @atmaxinger)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

### Compatibility

### Core

- The `syslog` logging code now calls `openlog` before every `syslog` to avoid the use of a global variable. _(@kodebach)_
- Fix memleak in kdb.c, #4925 _(@hannes99)_

### loader

- Adapt target rename with `-plugin-` in `dl.c` _(Tomislav Makar @tmakar)_

### go

- Golang is now included to build `go binding` _(Tomislav Makar @tmakar)_
- From now on we use tags which are prefixed with `v` so go package versioning works _(Tomislav Makar @tmakar)_

### kdb

- Add new changetracking API _(Maximilian Irlinger @atmaxinger)_
- Fix unwanted removal of subkeys when using mv _(Hannes Laimer @hannes99)_
- Fix inconsistent return values in code, tests and man pages _(Hannes Laimer @hannes99)_
- Remove `smount` alias _(Hannes Laimer @hannes99)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme).
This section keeps you up-to-date with the multi-language support provided by Elektra.

### jna

- Updated Java binding related dependencies. _(Michael Tucek @tucek)_
- Updated `KDBException` to only access error key at construction time. _(Michael Tucek @tucek)_
- Removed public naive resource release API. To migrate just remove calls to the affected methods `Key#release()`, `KeySet#release()` and `KDBException#releaseErrorKey()` _(Michael Tucek @tucek)_
- Enabled strict javadoc checking for Gradle build _(Michael Tucek @tucek)_
- add merging based on elektraMerge _(Maximilian Irlinger @atmaxinger)_
- Added support for `ksIncRef` for `KeySet` _(Michael Tucek @tucek)_
- Enabled `ReferenceCleaner` _(Michael Tucek @tucek)_

### go-elektra

- Move `go-elektra` binding from repository into bindings folder of `libelektra` _(Tomislav Makar @tmakar)_
- Change module for `go-elektra` _(Tomislav Makar @tmakar)_
- Rename `go-elektra` module _(Tomislav Makar @tmakar)_
- Adapt README for `go-elektra` and change module name to match `github.com` _(Tomislav Makar @tmakar)_

## Tools

### elektrad

- Implemented new request to add multiple metakeys for one key _(Tomislav Makar @tmakar)_
- Adding bulk creation request for configuration keys _(Tomislav Makar @tmakar)_

### webd

- Implemented new request to add multiple metakeys for one key _(Tomislav Makar @tmakar)_
- Adding bulk creation request for configuration keys _(Tomislav Makar @tmakar)_

## Scripts

### Jenkins

- Use only v prefix for tags not in real version _(Tomislav Makar @tmakar)_

### Release

- Exclude v prefix from `populate-release-notes.sh` script _(Tomislav Makar @tmakar)_
- Handle tag prefix `v` correctly in `release.sh` _(Tomislav Makar @tmakar)_
- Check for `v` prefix in `make-source-package` script and `Jenkinsfile.release` _(Tomislav Makar @tmakar)_
- Use correct tags for `git-release-stats` script _(Tomislav Makar @tmakar)_

## Documentation

- Adapt and remove outdated docs https://issues.libelektra.org/4882 _(Tomislav Makar @tmakar)_
- Added missing dependencies in COMPILE.md for APT-based systems _(Michael Tucek @tucek)_
- Add `default` namespace to [namespaces documentation](../tutorials/namespaces.md) _(Tomislav Makar @tmakar)_
- Added Tomislav Makar to `AUTHORS.md` _(Tomislav Makar @tmakar)_
- Added Florian Lindner to `AUTHORS.md` _(Florian Lindner @flo91)_
- .github rework _(Markus Raab)_
- Added `hook` to `placements` contract in [CONTRACT.ini](../CONTRACT.ini) _(Tomislav Makar @tmakar)_
- Added `hook` information to [hooks.md](../dev/hooks.md)
- Added Hannes Laimer to `AUTHORS.md` _(Hannes Laimer @hannes99)_
- Add README to tools/kdb _(Hannes Laimer @hannes99)_
- Fixed shell-recorder test in [`install-webui.md`](../tutorials/install-webui.md) _(Tomislav Makar @tmakar)_
- Add new shell-recorder test in [`install-webui.md`](../tutorials/install-webui.md) for newly implemented request for adding multiple metakeys for one key _(Tomislav Makar @tmakar)_
- Small fixes in decisions. _(Markus Raab)_
- Remove wikipedia from release todos in [RELEASE.md](../todo/RELEASE.md) _(Tomislav Makar @tmakar)_
- Update AUTHORS.md info _(@kodebach)_
- Add Stefan Hanreich to AUTHORS.md _(Stefan Hanreich @lawli3t)_

### Use Cases

- Add specification use case for [array-specification](../usecases/specification/array-specification.md) _(Tomislav Makar @tmakar)_
- Add specification use case for [underline-specification](../usecases/specification/underline-specification.md) _(Tomislav Makar @tmakar)_
- Add specification use case for [simple-specification](../usecases/specification/simple-specification.md) _(Tomislav Makar @tmakar)_
- Add specification use case for [enum-specification](../usecases/specification/enum-specification.md) _(Tomislav Makar @tmakar)_
- Add complete specification for `dockerd` configuration file (`daemon.json`) _(Tomislav Makar @tmakar)_

### Decisions

- Decide and implement [decision process](../decisions/5_partially_implemented/decision_process.md) _(Markus Raab)_
- Decided future [library split](../decisions/4_decided/library_split.md) _(@kodebach)_
- Decided [decision process](https://www.libelektra.org/decisions/decision-process) _(Markus Raab)_
- Draft for [man pages](../decisions/0_drafts/man_pages.md) _(Markus Raab)_
- Add decision for [change tracking](../decisions/3_in_review/change_tracking.md) _(Maximilian Irlinger @atmaxinger)_
- Create [decision](../decisions/0_drafts/operation_sequences.md) for allowed and prohibited operation seqences _(Maximilian Irlinger @atmaxinger)_
- Add decisions about [location of headers](../decisions/4_decided/header_file_structure.md) and [use of `#include`](../decisions/4_decided/header_include.md) in the repo _(@kodebach)_
- Add decision about [metadata semantics](../decisions/0_drafts/metakey_semantics.md) _(@kodebach)_
- Many small fixes to adapt to documentation guidelines and new decision process. _(Markus Raab)_
- Add decision for [read-only keynames](../decisions/0_drafts/readonly_keynames.md) _(Maximilian Irlinger @atmaxinger)_
- Revive [keyname decision](../decisions/4_decided/keyname.md) _(@kodebach)_
- Add decision for [copy-on-write](../decisions/6_implemented/copy_on_write.md) and provide implementation suggestions. _(Maximilian Irlinger @atmaxinger)_
- Added explanation on why we wanted to migrate from Maven to [Gradle](../decisions/6_implemented/gradle.md) for Java-related build facilities. _(Michael Tucek @tucek)_

### Tutorials

- Add basic tutorial about changetracking _(Maximilian Irlinger @atmaxinger)_

### Man Pages

## Tests

- Add shell test to verify correct behavior for https://github.com/ElektraInitiative/libelektra/issues/4061 _(Tomislav Makar @tmakar)_
- Add link to `linkchecker.whitelist` _(Tomislav Makar @tmakar)_

## Build

### Docker

- CentOS 8 Stream: manually install `config-manager` DNF plugin. _(Maximilian Irlinger @atmaxinger)_

## Infrastructure

### Cirrus

- Rename deprecated `d-bus` to `dbus` in `macOS.yml` and `.cirrus.yml` [Issue-#4900](https://github.com/ElektraInitiative/libelektra/issues/4900) _(Tomislav Makar @tmakar)_
- Push FreeBSD 12.3 to 12.4 since 12.3 is end of life. _(Richard Stöckl @eiskasten)_

### GitHub Actions

## Website

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

## Miscellaneous

- Many global variables that where used as constants have been made fully `const` _(@kodebach)_

## Outlook

We are currently working on following topics:

- Rewriting tools in C _(@hannes99)_
- Elektrify KDE and GNOME _(Mihael Pranjić @mpranj)_
- Elektrify XFCE _(Richard Stöckl @Eiskasten)_
- Mounting SQL databases _(Florian Lindner @flo91)_
- Recording Configuration _(Maximilian Irlinger)_
- Ansible-Elektra _(Maximilian Irlinger)_
- Configure Olimex Base Images _(Maximilian Irlinger)_
- Improving Build Server Infrastructure _(Lukas Hartl)_
- Improve Java Development Experience _(Michael Tucek)_

## Statistics

About 9 authors changed 309 files with 10024 insertions(+) and 4025 deletions(-) in 402 commits.

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.10.0.tar.gz) or
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.10.0.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.10.0.tar.gz.hashsum?raw=true)

- name: elektra-0.10.0.tar.gz
- size: 9230228
- md5sum: 39ac04c8a0b07061bea781fd73cb13aa
- sha1: 846dcfa22410403b575a4d4d87970aa4841aafdd
- sha256: cb56e40b37c42e1e235cf9e76c9250024f912cbb61cca1a2888f9305f5228dcd

The release tarball is also available signed using GnuPG from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-0.10.0.tar.gz.gpg) or
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-0.10.0.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found

- [here](https://doc.libelektra.org/api/0.10.0/html/) or
- [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/0.10.0).

## Stay tuned!

Subscribe to the [RSS feed](https://www.libelektra.org/news/feed.rss) to always get the release notifications.

If you also want to participate, or for any questions and comments, please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/0.10.0-release)

For more information, see [https://libelektra.org](https://libelektra.org).

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)





# <<VERSION>> Release

This release did not happen yet.

Please always update this file within **every PR**:

1. write what changed
2. use links pointing to your change (See [Documentation Guidelines](/doc/contrib/documentation.md))
3. add your name at the end of the line **Syntax:** _(your name)_

For example, Max would write:

```
- Added a new [doc plugin](https://www.libelektra.org/plugins/doc) _(Max)_
```

Pick a random line to write your changes to minimize the chances of conflicts in this file.

For non-trivial changes, you can choose to be part of the highlighted changes.
Please write a highlight section in this case.

After the horizontal line the release notes for the next version starts.

---

<<`scripts/generate-news-entry`>>

We are proud to release Elektra <<VERSION>>.

## 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](https://libelektra.org).

You can also read the news [on our website](https://www.libelektra.org/news/<<VERSION>>-release).

You can try out the latest Elektra release using our docker image [elektra/elektra](https://hub.docker.com/r/elektra/elektra).
This is the quickest way to get started with Elektra without compiling and other obstacles, simply run:

```sh
docker pull elektra/elektra
docker run -it elektra/elektra
```

## Highlights

- Session Recording
- ODBC Backend

### Session Recording

Elektra now comes with a powerful new feature that allows users to record and export changes made to the KDB: session recording.
This feature enables you to easily track changes made to the configuration database over time, which helps troubleshoot issues, diagnose errors, and improve system performance.
It even lets you undo the changes you've performed!

You can also export the changes as Ansible playbooks using the new Ansible storage plugin!
This makes it easy to automate and reproduce system configurations.
We think that this feature offers significant time savings and improved accuracy when managing complex systems.

Whether you're a system administrator, developer, or DevOps engineer, we believe that the session recording feature in Elektra will become an essential tool for managing and maintaining system configurations.
[Try it today](../tutorials/recording.md) and experience the benefits of streamlined configuration management.

**Note:** when you activate session recording, concurrency of Elektra will be somewhat limited.
As long as it is active, a global lock will be created to ensure no two processes will write data simultaneously.
This behavior is similar as to when multiple processes will write to the same configuration file.
Applications should already handle this case gracefully, and just retry writing their configuration.

### ODBC Backend

Based on the new and more versatile concept for [backends](/doc/dev/backend-plugins.md), where backends are implemented as plugins, a new backend-plugin that uses ODBC data sources for storing keys has been developed.
It was tested on Gentoo Linux with [unixODBC](https://www.unixodbc.org) using [SQLite](https://www.sqlite.org) and [PostgreSQL](https://www.postgresql.org) data sources.
The ODBC backend-plugin can only be built if the ODBC library is available on the build system. This can be accomplished by installing e.g. unixODBC.
Microsoft ODBC (on MS Windows) and [iODBC](https://www.iodbc.org) should also be supported, but were not tested yet.
If you use the plugin with another ODBC implementation as unixODBC, you are very welcome to update the documentation with your experiences!

The [tutorial](../tutorials/odbc-backend.md) is a good place for getting started with the new ODBC backend for Elektra.

## Plugins

The following text lists news about the [plugins](https://www.libelektra.org/plugins/readme) we updated in this release.

### General

- Updated target name of shared object files according to [#3486](https://issues.libelektra.org/3486)

### spec

- Remove metakeys from array elements correctly [#4961](https://issues.libelektra.org/4961) _(Tomislav Makar @tmakar)_

### recorder

- Add recorder plugin. _(Maximilian Irlinger @atmaxinger)_

### jdbc

- Fix formatting/spelling problem in README.md _(Hannes Laimer @hannes99)_

### backend_odbc

- Add ODBC backend _(Florian Lindner @flo91)_

### ansible

- Add `ansible` plugin for exporting keysets as [ansible-libelektra](https://galaxy.ansible.com/elektra_initiative/libelektra) playbooks. _(Maximilian Irlinger @atmaxinger)_

### toml

- Fix error reporting when unsupported metakey has been encountered. _(Maximilian Irlinger @atmaxinger)_

### length

- Remove experimental status. _(Maximilian Irlinger @atmaxinger)_

### Xfconf

- Implemented the first revision of the Xfconf binding. _(Richard Stöckl @Eiskasten)_
- Make Xfconf storage plugin compatible with new backend and noresolver. _(Richard Stöckl @Eiskasten)_
- This allows to use elektra as a drop-in replacement for applications which use Xfconf. _(Richard Stöckl @Eiskasten)_
- Xfconf applications can now read and write configuration settings to elektra. _(Richard Stöckl @Eiskasten)_
- Use cmake variables in the replace and restore scripts. _(Richard Stöckl @Eiskasten)_

### c

- Improve the c plugin: some refactoring, add documentation, extend README.md, add unit tests. _(Florian Lindner @flo91)_

## Libraries

The text below summarizes updates to the [C (and C++)-based libraries](https://www.libelektra.org/libraries/readme) of Elektra.

### kdb

- Add `elektraCopyError` function to copy error from one key to another _(Maximilian Irlinger @atmaxinger)_
- Add `elektraCopyWarnings` function to copy warnings from one key to another _(Maximilian Irlinger @atmaxinger)_
- Add `elektraCopyErrorAndWarnings` function to copy error and warnings from one key to another _(Maximilian Irlinger @atmaxinger)_

### record

- Add record library used for session recording. _(Maximilian Irlinger @atmaxinger)_

### ease

- Add `elektraArrayGetPrefix` function. _(Maximilian Irlinger @atmaxinger)_

## Bindings

Bindings allow you to utilize Elektra using [various programming languages](https://www.libelektra.org/bindings/readme).
This section keeps you up-to-date with the multi-language support provided by Elektra.

### C++

- Provide getter for the underlying C object of KDB _(Maximilian Irlinger @atmaxinger)_
- Add `ElektraDiff` binding for C++ _(Maximilian Irlinger @atmaxinger)_
- The `dup` method of `KeySet` now returns a wrapped object _(Maximilian Irlinger @atmaxinger)_
- Add an overload for `KeySet::cut` that accepts a string for the keyname _(Maximilian Irlinger)_
- The `dup` method of `Key` now returns a wrapped object _(Maximilian Irlinger @atmaxinger)_
- Add overloads for `Key::isBelow`, `Key::isBelowOrSame` and `Key::isDirectBelow` that accept a string as the key name _(Maximilian Irlinger @atmaxinger)_
- Include the header `cstdint` in `key.hpp`. It is needed for an enum of type `std::uint8_t` _(Florian Lindner @flo91)_

### Java

- Added documentation about the design of the binding. _(Michael Tucek @tucek)_

### Python

- Add `ElektraDiff` binding _(Maximilian Irlinger @atmaxinger)_
- The `__meta__` attribute on a key now returns a proper keyset _(Maximilian Irlinger @atmaxinger)_
- Add new module `kdb.errors` to simplify extracting errors and warnings from keys _(Maximilian Irlinger @atmaxinger)_
- Add new module `kdb.record` for interfacing with the session recording capabilities of Elektra _(Maximilian Irlinger @atmaxinger)_
- Add `getConflictingKeys` method to `kdb.merge.MergeResult`. _(Maximilian Irlinger @atmaxinger)_

### Rust

- Upgrade bindgen dependency to version 0.55.1. _(Maximilian Irlinger @atmaxinger)_

### Xfconf

- Implemented the first revision of the Xfconf binding. _(Richard Stöckl @Eiskasten)_
- This allows to use elektra as a drop-in replacement for applications which use Xfconf. _(Richard Stöckl @Eiskasten)_
- Xfconf applications can now read and write configuration settings to elektra. _(Richard Stöckl @Eiskasten)_
- Use cmake variables in the replace and restore scripts. _(Richard Stöckl @Eiskasten)_

## Tools

### kdb

- Add commands for session recording. _(Maximilian Irlinger @atmaxinger)_
- The `kdb mount` command will now automatically detect whether the given path is an absolute path. _(Maximilian Irlinger @atmaxinger)_
- Fix unwanted removal of subkeys when using mv _(Hannes Laimer @hannes99)_
- Fix inconsistent return values in code, tests and man pages _(Hannes Laimer @hannes99)_
- Remove `smount` alias _(Hannes Laimer @hannes99)_

## Documentation

- Fix bug in Doxygen comment for `const char * keyName (const Key * key)` which lead to failed building of the refman.pdf on recent TeX Live releases _(Florian Lindner @flo91)_
- Update release documentation regarding version tags. _(Mihael Pranjić @mpranj)_
- Add glossaries for [developers](/doc/dev/dev-glossary.md) and [contributors](/doc/contrib/contrib-glossary.md) _(Maximilian Irlinger @atmaxinger)_
- Add use cases for using the bindings. _(Richard Stöckl @Eiskasten)_
- Write the Xfconf tutorial. _(Richard Stöckl @Eiskasten)_
- Add use cases for libelektra-core _(@lawli3t)_

### Use Cases

- Add end-user and developer integration use case _(Hannes Laimer @hannes99)_
- Add use cases for using the bindings. _(Richard Stöckl @Eiskasten)_
- Add use cases for libelektra-core _(@lawli3t)_

### Decisions

- Add decision for [Elixir bindings](../decisions/3_decided/elixir_bindings.md). _(@0x6178656c)_

### Tutorials

- Add tutorial for [session recording](../tutorials/recording.md). _(Maximilian Irlinger @atmaxinger)_
- Add tutorial for [ODBC backend](../tutorials/odbc-backend.md). _(Florian Lindner @flo91)_

### Man Pages

- Add man pages for session recording

## Tests

- Add macro `succeed_if_keyset_contains_key_with_string` to assert that a certain key with a certain value must exist. _(Maximilian Irlinger @atmaxinger)_

### Docker

- Use openwrt/sdk instead of openwrtorg/sdk. _(Richard Stöckl @Eiskasten)_
- Reduce fedora docker image size (PR #4637) _(@4ydan)_

## Infrastructure

### Jenkins

- Disable openwrt build until we have found a new maintainer for it. _(Maximilian Irlinger @atmaxinger)_

### Cirrus

- The arch package `texlive-most` is no longer available, replaced it with other texlive packages. See https://archlinux.org/packages/?q=texlive _(Florian Lindner @flo91)_

## Outlook

We are currently working on following topics:

- Fix bugs!
- Improvements for https://opensesame.libelektra.org/

## Statistics

We closed [<<NUMISSUES>> issues](https://github.com/ElektraInitiative/libelektra/milestone/<<MILESTONE>>?closed=1) for this release.

<<`scripts/git-release-stats <<VERSION>>.VER-1 <<VERSION>>`>>

Thanks to all authors for making this release possible!

## Join the Initiative!

We welcome new contributors!
Read [here](https://www.libelektra.org/devgettingstarted/ideas) about how to get started.

As first step, you could give us feedback about these release notes.
Contact us via our [issue tracker](https://issues.libelektra.org).

## Get the Release!

You can download the release from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-<<VERSION>>.tar.gz) or
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-<<VERSION>>.tar.gz?raw=true)

The [hashsums are:](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-<<VERSION>>.tar.gz.hashsum?raw=true)

<<`scripts/generate-hashsums elektra-<<VERSION>>.tar.gz`>>

The release tarball is also available signed using GnuPG from

- [here](https://www.libelektra.org/ftp/elektra/releases/elektra-<<VERSION>>.tar.gz.gpg) or
- [GitHub](https://github.com/ElektraInitiative/ftp/blob/master/releases/elektra-<<VERSION>>.tar.gz.gpg?raw=true)

The following GPG Key was used to sign this release: 12CC44541E1B8AD9B66AFAD55262E7353324914A

Already built API documentation can be found

- [here](https://doc.libelektra.org/api/<<VERSION>>/html/) or
- [GitHub](https://github.com/ElektraInitiative/doc/tree/master/api/<<VERSION>>).

## Stay tuned!

Subscribe to the [RSS feed](https://www.libelektra.org/news/feed.rss) to always get the release notifications.

If you also want to participate, or for any questions and comments, please contact us via our issue tracker [on GitHub](http://issues.libelektra.org).

[Permalink to this NEWS entry](https://www.libelektra.org/news/<<VERSION>>-release)

For more information, see [https://libelektra.org](https://libelektra.org).

Best regards,
[Elektra Initiative](https://www.libelektra.org/developers/authors)
