Skip to content

@mpranj mpranj released this May 26, 2020 · 91 commits to master since this release

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

We are proud to release Elektra 0.9.2.

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

What is Elektra?

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

You can also read the news on our website

Highlights

  • KDE integration
  • GNOME Integration
  • elektrad rewritten in Go

KDE Integration

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

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

GNOME Integration

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

elektrad rewritten in Go

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

Try out Elektra

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

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

Plugins

We removed the maintained status of the following plugins:

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

New maintainers are very much welcomed!

Augeas

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

CCode

Crypto

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

Directory Value

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

Fcrypt

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

KConfig

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

SWIG

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

SWIG/python

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

SWIG/python2

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

Tcl

YAMBi

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

YAML CPP

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

  • The plugin does not interpret a key set such as

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

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

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

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

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

Yan LR

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

GOpts

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

Cache

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

Libraries

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

Compatibility

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

Opts

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

Bindings

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

python2

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

Rust

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

Tools

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

Scripts

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

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

  • The scripts

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

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

Documentation

  • Improved formatting of the validation tutorial (Anton Hößl)
  • We fixed some minor spelling mistakes. (René Schwaiger)
  • We updated the man pages of the web tool. (René Schwaiger)
  • Updated documentation for Ubuntu-Bionic Packages. (Djordje Bulatovic)
  • Fixed an old path of the reformatting script in the docker reformatting tutorial (Jakob Fischer)

Tests

  • We now use Google Test 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 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 and CMP0086. (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

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 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 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 finished his thesis about parsing techniques and parsing tools for configuration files.

Join the Initiative!

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

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

Get the Release!

You can download the release from here
or GitHub

The hashsums are:

  • author: mpranj
  • 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 or on
GitHub.

The following GPG Key was used to sign this release: 9C18145C22F9E746D743DEC59ECC0F4CF0359C7B

Already built API-Docu can be found here
or on GitHub.

Stay tuned!

Subscribe to the
RSS feed
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.

Permalink to this NEWS entry

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

Best regards,
Elektra Initiative

Assets 4

@mpranj mpranj released this Nov 27, 2019 · 906 commits to master since this release

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

We are proud to release Elektra 0.9.1.

What is Elektra?

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

You can also read the news on our website

Highlights

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

Code Generation

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

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

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

Further Highlights

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

Plugins

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

General

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

Camel

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

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

Spec

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

Specload

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

Tcl

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

Type

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

Yajl

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

YAwn

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

YAy PEG

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

Libraries

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

Compatibility

We introduced several incompatible changes:

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

We changed the following symbols:

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

Core

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

Opts

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

Proposal

  • Removed or moved several 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. 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 interface.
    For an example see the test case. (Michael Zronek)
  • Upgraded maven dependencies for Java binding (Michael Zronek)
  • The Java binding now supports the error codes 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 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. (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 meta-data 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. (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 now also works properly, if the repository path contains space characters. (René Schwaiger)

  • The script 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 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. (Klemens Böswirth)

  • The new script reformat-javascript formats the JavaScript code of the repository using the tool prettier. (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 now requires cmake-format 0.6. (René Schwaiger)

  • The new script reformat-java formats the Java code in the repository using clang-format. (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.
    (Michael Zronek, Raphael Gruber, Philipp Gackstatter)
  • Clarified subtyping in the language bindings tutorial. (Michael Zronek)
  • A second tutorial on writing bindings for the high-level API was created as well. (Klemens Böswirth, Raphael Gruber)
  • Added info on how to include xerces plugin with homebrew installation. (Anton Hößl)
  • The compile instructions 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. (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 informations about contributing 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. (René Schwaiger)
  • We disabled the test for the conversion engine. For more information, please take a look at issue #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 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. (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 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. (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. (Michael Zronek)

Docker

Vagrant

  • We added a Vagrantfile 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. (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. (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 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

Travis

  • The build job 🍏 GCC now uses the Travis Homebrew addon 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 informations. 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 folders website-frontend and website-backend 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 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:
    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 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 about how to get started.

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

Get the Release!

You can download the release from here
or GitHub

The hashsums are:

  • author: mpranj
  • 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 or on
GitHub

Already built API-Docu can be found here
or on GitHub.

Stay tuned!

Subscribe to the
RSS feed
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.

Permalink to this NEWS entry

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

Best regards,
Elektra Initiative

Assets 4

@markus2330 markus2330 released this Aug 6, 2019 · 2529 commits to master since this release

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

What is Elektra?

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

You can also read this document on our website.

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

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

0.9.*

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

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

Business Plans

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

We plan to introduce following ways of income:

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

If you are interested in any of these, please
contact us via 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).
We do not plan to make any part proprietary. We only introduce a way
for paid customers to get desired features or help more quickly.

Highlights

  • Cache
  • Command-line Options
  • Error Codes

Cache

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

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

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

Limitations:

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

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

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

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

Command-line Options

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

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

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

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

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

Limitations:

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

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

Error Codes

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

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

For background information read:

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

Plugins

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

Type (New Version)

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

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

A few notes on compatibility:

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

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

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

Base64

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

Crypto and Fcrypt

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

CSVStorage

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

Filecheck

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

INI

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

Macaddr

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

mINI

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

Mmapstorage

  • mmapstorage is now able to persist the Global KeySet, which is used by the cache plugin. (Mihael Pranjić)
  • Fixed support for 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 is a new storage plugin. It implements a more concise form of the
    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 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 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. It now better reflects the actually implemented behaviour. (Klemens Böswirth)

Specload

  • The 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 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).
  • 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 to validate units of memory and normalize them into bytes. E.g. 20 KB (normalized to 20000 Byte).
    (Marcel Hauri)

YAJL

The 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. (Philipp Gackstatter)
  • no longer produces additional ___dirdata entries for empty array keys. See also issue #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:

    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. (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 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:

    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 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:

    - ~
    - - ~
      - ~
      - map:
          - arr

    . (René Schwaiger)

  • YAML CPP now supports mixed data (nested lists & sequences) better. For example, the plugin now correctly converts the YAML data

    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
    

    .

YAML Smith

  • YAML Smith now converts keys that shares a common prefix correctly. For example, the last command in the script:

    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:

    common:
      one:
        - "value"
      two:
        - "first"
        - "second"

    . (René Schwaiger)

  • 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. (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 now supports Elektra’s boolean data type. (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

    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. (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

    "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:

    - key1: value1
      key2: value2

    and compact sequences:

    - - element1
      - element2

    correctly. (René Schwaiger)

  • The plugin now supports Elektra’s boolean data type. (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 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 behaviour can be enabled for testing using ENABLE_DEBUG and adding the "debugGlobalPositions" meta key 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 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. 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 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).(Peter Nirschl)
  • kdb getenv now executed correctly from within tests (Markus Raab)
  • kdb-bash-completion now works on Mac (see #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-source 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 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/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 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:

    for a certain input file with hyperfine. (René Schwaiger)

  • Added kdb reset and kdb reset-elektra, fixed kdb stash. (Markus Raab)

Benchmarks

  • The benchmarking tool benchmark_plugingetset 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:

    benchmark_plugingetset benchmarks/data user yaypeg get

    . (René Schwaiger)

Documentation

Style

Tutorials

  • We added a basic tutorial that tells you how to write a (well behaved) storage plugin. (René Schwaiger)

  • Improved the checkconf section in the plugin tutorial. (Peter Nirschl)

  • We added a tutorial on how to benchmark the execution time of plugins using benchmark_plugingetset and hyperfine. (René Schwaiger)

  • The new profiling tutorial describes how to determine the execution time of code using

    . (René Schwaiger)

  • For beginners we added a tutorial 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 for beginners to run all tests with Docker. (Oleksandr Shabelnyk)

  • Extend/improve Java bindings related documentation in tutorial and readme. (Oleksandr Shabelnyk)

  • Added a step-by-step tutorial for running reformatting scripts with Docker. (Oleksandr Shabelnyk)

  • Covered Resolving Missing *.so Library Error in tutorial. (Oleksandr Shabelnyk)

  • Added a basic tutorial on How-To: Write a Java Plugin (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 'build-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 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 to the main ReadMe file. (René Schwaiger)

  • Added LCDproc and Cassandra 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. (Michael Zronek)

  • Added a guideline for writing consistent and good error messages. For more information look here. (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. (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. (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 into the man page for kdb (Markus Raab)

Tests

  • We now test the Directory Value Plugin with additional test data. (René Schwaiger)

  • The variables:

    • SPEC_FOLDER
    • SYSTEM_FOLDER
    • USER_FOLDER

    in the inclusion file for shell test were set incorrectly, if the repository path contained space characters. (René Schwaiger)

  • The CFramework now also compares the names of meta keys. (René Schwaiger)

  • The release notes check 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).(Peter Nirschl)

  • We fixed the Markdown Shell Recorder test for the command kdb get. (René Schwaiger)

  • The tests

    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 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

    . (René Schwaiger)

  • We reformatted the CMake source code with cmake format 0.5.4 and also check the style of CMake code 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)

Build

CMake

  • We now disable the option INSTALL_SYSTEM_FILES by default. This change makes it possible to install Elektra using Homebrew on Linux without any changes to Elektra’s Linuxbrew formula. (René Schwaiger)
    Add -DINSTALL_SYSTEM_FILES=ON for previous behavior.
  • The build system now rebuilds the JNA binding 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 binding does not require libuv anymore. (René Schwaiger)

Docker

Alpine Linux

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

    to the image for Debian sid. (René Schwaiger)

  • We now offer images for the latest stable version of Debian codenamed “buster”. (René Schwaiger)

Ubuntu

Other Updates

Vagrant

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. (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. (René Schwaiger)

  • We now again build the API docu of master and we now also build the API docu of PRs. (Markus Raab)

  • We added buster build jobs. (Markus Raab)

Restyled

Travis

  • We removed the build job for the Haskell binding and Haskell plugin. For more information, please take a look here. (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. (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
for this release.

Join the Initiative!

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

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

Get the Release!

You can download the release from here
or GitHub

The hashsums are:

  • 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 or on
GitHub

Already built API-Docu can be found here
or on GitHub.

Stay tuned!

Subscribe to the
RSS feed
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.

Permalink to this NEWS entry

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

Best regards,
Elektra Initiative

Assets 5

@markus2330 markus2330 released this Feb 26, 2019 · 4554 commits to master since this release

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

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

What is Elektra?

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

You can also read the news on our website

High-Level API

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

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

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

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

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

elektraClose (elektra);

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

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

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

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

Take a look at the README for more information.

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

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

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

Plugins

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

Augeas

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

Network

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

YAMBi

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

YanLR

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

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

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

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

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

  • Yan LR’s lexer now

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

    . (René Schwaiger)

Path

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

YAwn

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

YAy PEG

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

Ruby

  • Added some basic unit tests (Bernhard Denner)

Misc

  • We fixed some compiler warnings for the plugins

    reported on FreeBSD. (René Schwaiger)

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

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

Libraries

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

Compatibility

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

We have two minor incompatible changes:

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

For details of the changes see below Core and Libease.

Core

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

Libease

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

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

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

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

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

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

    . (René Schwaiger)

Libopts

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

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

Tools

  • kdb spec-mount correctly includes type plugin to validate type. (Markus Raab)
  • kdb setmeta 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

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.
    Before the update these tests used cascading keys. (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 does not require Bash anymore. (René Schwaiger)
  • We fixed an incorrect directive in the Markdown Shell Recorder test of the
    Type Checker plugin. (René Schwaiger)
  • We added a test that invokes the script 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. (René Schwaiger)
  • The test testscr_check_formatting now prints instructions that show
    you how to fix formatting problems. (René Schwaiger)

Build

CMake

Misc

  • The plugin name is now provided as compiler definition ELEKTRA_PLUGIN_NAME via CMake.
    See #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. (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. (Peter Nirschl)
  • We now specify
    • version number,
    • project description, and
    • homepage URL
      in the CMake project command. (René Schwaiger)
  • We fixed the detection of Python for the Python 2 binding 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. (René Schwaiger)

Find Modules

  • The CMake find module 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 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 on macOS, even if pkg-config
    erroneously reports that GLIB requires linking to the library intl (part of GNU gettext).
    (René Schwaiger)
  • We added a CMake find module for GLib. The module makes sure you can
    compile and link IO GLib on macOS. (René Schwaiger)
  • The CMake find module 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.The update
    fixes problems on macOS, where the build system excluded the plugin crypto_gcrypt, although
    Libgcrypt was installed on the system. (René Schwaiger)
  • We now use the official CMake find module for iconv. This
    update fixes linker problems with the iconv and
    filecheck plugin on FreeBSD 12. (René Schwaiger)
  • The CMake find module for Botan does not require pkg-config anymore.
    (René Schwaiger)
  • The CMake find module for libgit2 now also exports the version number of
    libgit2. (René Schwaiger)
  • We added a CMake find module for libuv and fixed a problem on macOS, where the build system was
    unable to locate the header file of libuv. (René Schwaiger)
  • We added a CMake find module for ZeroMQ to fix build problems on macOS. (René Schwaiger)

Docker

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 to build and test Elektra on

    . 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
    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 as default storage module.
    (René Schwaiger)

  • We install and uninstall Elektra in all of the macOS build jobs to make sure that
    ElektraUninstall.cmake removes all of the installed files.
    (René Schwaiger)

Jenkins

  • We added a badge displaying the current build status to the main ReadMe. (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. (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:

  1 commit by Aybuke Ozdemir <aybuke.147@gmail.com>
  2 commits by Gabriel Rauter <rauter.gabriel@gmail.com>
  6 commits by Bernhard Denner <bernhard.denner@gmail.com>
  6 commits by Dominic Jäger <dominic.jaeger@gmail.com>
 25 commits by Peter Nirschl <peter.nirschl@gmail.com>
 32 commits by Mihael Pranjic <mpranj@limun.org>
 66 commits by Michael Zronek <michael.zronek@gmail.com>
112 commits by Markus Raab <elektra@markus-raab.org>
131 commits by Klemens Böswirth <k.boeswirth+git@gmail.com>
141 commits by Dominik Hofer <me@dominikhofer.com>
464 commits by René Schwaiger <sanssecours@me.com>

Join the Initiative!

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

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

Get the Release!

You can download the release from here
or GitHub

The hashsums are:

  • 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 or on
GitHub

Already built API-Docu can be found here
or on GitHub.

Stay tuned!

Subscribe to the
RSS feed
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.

Permalink to this NEWS entry

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

Best regards,
Elektra Initiative

Assets 4

@markus2330 markus2330 released this Nov 18, 2018 · 5540 commits to master since this release

We are proud to present Elektra 0.8.25.

What is Elektra?

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

For a small demo see here:

asciicast

You can also read the news on our website

Metadata

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

Highlight

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

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

mmap storage

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

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

Median write time in microseconds:

Plugin Time
dump 71079
mmapstorage 2964
mmapstorage_crc 7644

Median read time in microseconds:

Plugin Time
dump 82737
mmapstorage 1145
mmapstorage_crc 5744

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

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

Thanks to Mihael Pranjić for this improvement.

Hybrid Search Algorithm for ksLookup (...)

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

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

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

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

Thanks to Kurt Micheli for this improvement.

Plugins

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

Directory Value

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

Process

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

FSTab

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

passwd

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

gpgme

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

network

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

YAMBi

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

YAML CPP

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

Yan LR

A new plugin parsing YAML files using Yan LR.

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

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

    now works correctly. (René Schwaiger)

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

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

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

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

YAwn

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

Reference

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

Libraries

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

Compatibility

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

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

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

Obviously, we will continue to update the stretch package:

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

Infos for Package Maintainers

Following plugins got added:

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

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

  • libelektra-globbing.so

Core

Optimize elektraKsFilter to not duplicate keys (Markus Raab)

Globbing

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

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

Ease

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

Bindings

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

Ruby

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

Tools

  • Added benchmarks for storage plugins. The currently benchmarked plugins are dump and mmapstorage. (Mihael Pranjić)
  • 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 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][https://master.libelektra.org/scripts/reformat-shfmt] reformats Shell scripts using the tool shfmt. (René Schwaiger)

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.
    (Lukas Winkler)

Tests

  • Fix potential parallel execution of maven tests, which write to KDB. (Markus Raab)
  • The unit test for the dbus plugin 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 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 . (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 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 binding. (René Schwaiger)
  • The command kdb run_all 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 1.8.1. (René Schwaiger)

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. (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 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:

849 commits, 581 files changed, 18503 insertions(+), 3192 deletions(-)

We welcome new contributors!

Finished Thesis

Get It!

You can download the release from here
or GitHub

The hashsums are:

  • 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 or
GitHub

Already built API-Docu can be found here
or GitHub.

Stay tuned!

Subscribe to the
RSS feed
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.

Permalink to this NEWS entry

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

Best regards,
Elektra Initiative

Assets 3

@markus2330 markus2330 released this Aug 18, 2018 · 6397 commits to master since this release

0.8.24 Release

We are proud to release Elektra 0.8.24.

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

What is Elektra?

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

For a small demo see here:

asciicast

You can also read the news on our website

Highlights

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

Elektra Web 1.6

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

Elektra Web 1.6 video

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

1.5 changelog:

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

1.6 changelog:

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

Thanks to Daniel Bugl.

Notifications

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

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

KDE Workshop

At Akademy 2018 we had a successful
Config Workshop.

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

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

For more information see the Slides

Type System Prototype

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

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

For more details see the
typechecker readme

Thanks to Armin Wurzinger.

Chef Cookbook

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

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

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

And to add an hosts entry, you can use:

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

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

Thanks to Michael Zronek and Vanessa Kos.

Plugins

CCode

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

CPP Template

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

    scripts/copy-template -p pluginname

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

Crypto

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

CSVStorage

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

Directory Value

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

fcrypt

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

fstab

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

Haskell

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

Interpreter Plugins

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

JNI

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

HexNumber

  • The plugin hexnumber has 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 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 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 by requiring the plugin
    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

Regex Dispatcher

  • The plugin regexdispatcher has been added.
    It calculates regex representations for commonly used specification keywords to be used with the
    typechecker. Currently the keywords check/range,
    check/enum and default are supported. (Armin Wurzinger)

Typechecker

  • The plugin typechecker, used to validate
    configuration specifications for Elektra statically, has been improved under the hood. It now
    supports a more concise and efficient typechecking 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. (Armin Wurzinger)

Tcl

  • The 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. (René Schwaiger)

YAJL

  • The YAJL Plugin now uses the internal logger functionality instead of printf statements.
    (René Schwaiger)
  • We fixed a problem with negative values reported by the
    UndefinedBehaviorSanitizer. (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:

    # 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 now requires at least yaml-cpp 0.6, since the current
    MSR test for the plugin triggers two bugs:

    in earlier versions of the yaml-cpp library. (René Schwaiger)

  • The plugin does now support arrays containing empty fields. (René Schwaiger)

  • YAML CPP now also adds array meta data for arrays containing arrays. (René Schwaiger)

  • The plugin now also supports empty arrays:

    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 meta data properly:

    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 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 uses a parser, generated by ANTLR 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. (René Schwaiger)

ZeroMQ transport plugins

  • New notification transport plugins for ZeroMQ were added.
    The new "zeromqsend" and "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" and
    "dbusrecv" transport plugins.
    Check out the
    plugin documentation for more
    information. (Thomas Wahringer)

Misc

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 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 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 has been
    added.
    It can be used to integrate the notification feature with applications based
    on ev main loops. (Thomas Wahringer)

Notifications

  • The
    notification API
    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 using Qt 5.11. (René Schwaiger)

Scripts

  • The script check_formatting.sh now also checks the formatting of CMake
    code if you installed sponge and cmake-format. (René Schwaiger)
  • The script check_formatting.sh now no longer writes to stdout if clang-format5.0
    can not be found. (Lukas Winkler)
  • The script check_bashisms.sh should now work correctly again, if the
    system uses the GNU version find. (René Schwaiger)
  • The script 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. (René Schwaiger)
  • scripts/run_icheck now no longer leaves the base directory of the project
    when checking if the ABI changed. (Lukas Winkler)
  • The completion for fish now also suggest the info/ meta attributes of the
    file plugin. (René Schwaiger)

Copy Template

  • The script 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. Please use the
    command line switch -p to create a new plugin based on cpptemplate.

Documentation

  • We improved the formatting of our compilation guide. (René Schwaiger)
  • We fixed various minor spelling mistakes in the documentation. (René Schwaiger)
  • The man pages for kdb change-resolver-symlink and
    kdb change-storage-symlink referenced the wrong command.
    (Lukas Winkler, René Schwaiger)
  • We added documentation for our build system in
    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. (René Schwaiger)

Tests

(Markdown) Shell Recorder

  • We added new Markdown Shell Recorder tests for the
  • (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 test
    of kdb ls. (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 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)

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, since the
    test reported memory leaks on the latest version of Debian Unstable. (René Schwaiger)
  • The 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. 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. See the README. (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 in the Ruby binding and plugin. (René Schwaiger)

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-xdgto 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 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.
    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:

  1 commit  by Mihael Pranjic <mpranj@limun.org>
  2 commits by Thomas Waser <thomas.waser@libelektra.org>
  7 commits by Michael Zronek <michael.zronek@gmail.com>
 12 commits by Kurt Micheli <e1026558@student.tuwien.ac.at>
 17 commits by Peter Nirschl <peter.nirschl@gmail.com>
 21 commits by Klemens Böswirth <k.boeswirth+git@gmail.com>
197 commits by Markus Raab <elektra@markus-raab.org>
102 commits by Thomas Wahringer <thomas.wahringer@libelektra.org>
117 commits by Daniel Bugl <me@omnidan.net>
265 commits by Lukas Winkler <derwinlu+git@gmail.com>
249 commits by Armin Wurzinger <e1528532@student.tuwien.ac.at>
744 commits by 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
or GitHub

The hashsums are:

  • 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 or on
GitHub

Already built API-Docu can be found online
or GitHub.

Stay tuned!

Subscribe to the
RSS feed
to always get the release notifications.

For any questions and comments, please contact the
issue tracker on GitHub
or Markus Raab by email using elektra@markus-raab.org.

Permalink to this NEWS entry

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

Best regards,
Elektra Initiative

Assets 3

@markus2330 markus2330 released this May 13, 2018 · 8133 commits to master since this release

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

We are proud to release Elektra 0.8.23.

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

What is Elektra?

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

For a small demo see here:

asciicast

You can also read the news on our website

Highlights

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

Notification: New transport plugin

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

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

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

Thanks to Thomas Wahringer.

Web UI greatly improved

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

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

To get outstanding usability, Web UI now provides:

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

Furthermore:

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

Read here to get started.

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

Thanks to Daniel Bugl.

Overhaul of Build System and Daily Stretch Repository

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

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

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

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

Thanks to Lukas Winkler.

Other New Features

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

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

Other News

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

Documentation

We improved the documentation in the following ways:

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

Compatibility

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

We removed:

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

We changed:

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

Shell scripts:

  • cp and mv no longer accept cascading keys.

Notes for Maintainer

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

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

We added:

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

We removed:

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

Website

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

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

Notes for Elektra's Developers

These notes are of interest for people developing Elektra:

  • . run_dev_env is a script to be sourced from the build directory.
    It sets environment variables, so that Elektra from the build
    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
    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:

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

  • Documentation and debugging capabilities of Markdown Shell Recorder were improved.

  • We added style guidelines for CMake code to
    doc/CODING.md.

Fixes

Many problems were resolved with the following fixes:

  • YAML CPP now also saves key values directly below a mountpoint correctly,
    thanks to René Schwaiger
  • If you use a minimal configuration (dump, 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 plugin.
  • The Shell Recorder counts the number of executed tests properly again.
  • CMake now fails if the required plugins list or spec (on
    non-MinGW platforms) are missing from the current build configuration.
  • The Lua, Python 2,
    Python, and Ruby plugins now require SWIG bindings for
    the corresponding programming language,
    thanks to René Schwaiger
  • The type checker 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 now passes the child config
    to the storage plugins too and also handles symlinks correctly,
    thanks to Thomas Waser

Workshop

Elektra Initiative 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 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
    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
or GitHub

The hashsums are:

  • 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 or
GitHub

Already built API-Docu can be found online
or GitHub.

Stay tuned!

Subscribe to the
RSS feed
to always get the release notifications.

For any questions and comments, please contact the
issue tracker on GitHub
or Markus Raab by email using elektra@markus-raab.org.

Permalink to this NEWS entry

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

Best regards,
Elektra Initiative

Assets 2

@markus2330 markus2330 released this Feb 27, 2018 · 8853 commits to master since this release

You can also read the news on our website

  • 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.

For a small demo see here:

asciicast

You can also read the FOSDEM interview and watch the FOSDEM main talk given recently.

Elektra is now an official part of Homebrew and
Alpine Linux.

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.

Elektra

Thanks to Philipp Frei!

We also gave the website a new look. It has the colors from the logo and new
fonts (Lato and
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
  • 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 if you store a value inside it. This has the advantage that you will not lose data unexpectedly anymore.
  • The INI plugin 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 meta data 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:

sudo kdb change-default-storage dini

You can also mount INI (or dini) as root:

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

The
Notification API
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.
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
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
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.

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. We still provide a
    tap, 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.
  • The invoke library can now report errors upon opening/closing a plugin,
    thanks to Armin Wurzinger.
  • The YAML CPP plugin does not require Boost anymore, if you
    installed yaml-cpp 0.6.
  • Improved colored output in kdb tool.
  • We added two build jobs: docker and haskell.
    Thanks to Bernhard Denner and Armin Wurzinger.
  • YAML CPP does not write binary data to a config file, if you forget to load the Base64 plugin.
  • YAML CPP now encodes empty binary keys as NULL values (~), and also adds the meta key binary for such values automatically.

Documentation

We improved the documentation in the following ways:

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.
    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 meta data.
    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

    using namespace ckdb;

    before you import kdberrors.h.

  • The CMake code for Elektra’s 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 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 in the CMake code of the Augeas plugin
  • We fixed the haskell bindings and plugins on Debian Stretch
    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
or GitHub

The hashsums are:

  • 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 or
GitHub

Already built API-Docu can be found online
or GitHub.

Stay tuned!

Subscribe to the
RSS feed
to always get the release notifications.

For any questions and comments, please contact the
issue tracker on GitHub
or me by email using elektra@markus-raab.org.

Permalink to this NEWS entry

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

Best regards,
Elektra Initiative

Assets 2

@markus2330 markus2330 released this Dec 22, 2017 · 9283 commits to master since this release

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:

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.

The news can be read rendered at our web server.

Highlights

In this release 8 authors created 307 commits and we changed 217 files (5227 insertions, 1914 deletions).
The highlights of the 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:

  • Title: Configuration Revolution
  • Subtitle: Why it Needed 13 Years and How it Will be Done
  • Day: Saturday 2018-02-03
  • Start time: 15:00:00
  • Duration: 50 min
  • Room: K.1.105 (La Fontaine)

And a second talk in the Config Management DevRoom:

  • 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: 30:00
  • Duration: 25min
  • Room: UA2.114 (Baudoux)

See you in Brussels at 3 and 4 February 2018!

I will also be present in the Config Management Camp 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
and the compiled book can be downloaded from here.

Maturing of Plugins

  • The new Directory Value plugin supports storage plugins such as YAJL and YAML CPP . 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 reads and writes YAML data using 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 instead.
  • The mINI plugin reads and writes simple property list, separated by equal (=) signs.
  • The xerces plugin allows Elektra to read and write XML data. The plugin uses Xerces-C++ for this task. It supports both arrays and metadata.
  • The boolean plugin normalizes boolean values such as 0, 1, true and false.
  • The crypto plugin and fcrypt plugin 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

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:

-DKDB_DEFAULT_STORAGE=dini

Or simply switch for your installation with:

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:

    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
    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
    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 lua and jni plugins are again experimental because they do not work with some Lua/Java interpreters.

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 under heavy load.
  • Markdown Shell Recorder Syntax recommended when reporting bugs.
  • Elektra's 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
  • 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
or GitHub

The hashsums are:

  • 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 or
GitHub

Already built API-Docu can be found online
or GitHub.

Stay tuned!

Subscribe to the
RSS feed
to always get the release notifications.

For any questions and comments, please contact the
issue tracker on GitHub
or me by email using elektra@markus-raab.org.

Permalink to this NEWS entry

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

Best regards,
Markus Raab for the Elektra Initiative

Assets 2

@markus2330 markus2330 released this Oct 31, 2017 · 9590 commits to master since this release

0.8.20 Release

  • guid: 547d48e2-c044-4a8e-9d32-ca6b6fb914d9
  • author: Markus Raab
  • pubDate: Thu, 31 Oct 2017 23:08:07 +0200

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.

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, 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.
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
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 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
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
to get an overview of the ever-growing number of plugins.

The yamlcpp plugin
and camel plugin
add first support for YAML.

The mini plugin
is yet another minimal INI plugin.

Thanks to René Schwaiger.

The date plugin
supports validation of dates according to three standards:

  • RFC2822
  • ISO8601
  • POSIX

The multifile plugin
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
interprets the content of a file as configuration value.

The ipaddr plugin
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
supplants the xmltool plugin
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
  • 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.
    The build system now uses Maven to build them. Armin also added Doxygen documentation
    and a script
    to test the JNA binding using Randoop.
  • The improved curlget plugin,
    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 and fcrypt plugin
    • 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:
    • 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
    • thanks to Peter Nirschl
  • Thomas Waser added useful scripts:
  • 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:
    compatibility with RFC 4180, thanks to Thomas Waser
  • gitresolver plugin:
    improvements and update of libgit version, thanks to Thomas Waser
  • curlget plugin:
    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 Maintainer

  • 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
    (for rest-backend and rest-frontend)

The following files are new:

  • Libs: libelektra-utility.so ,libelektra4j-0.8.20.pom.xml
  • 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.jarlibelektra4j-0.8.19.jar

In the Debian branch of the git repo,
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.

Development

  • 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

  • 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 meta data for Elektra's journal entry

Quality

  • 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

  • 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
or GitHub

The hashsums are:
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 or
GitHub

Already built API-Docu can be found online
or GitHub.

Stay tuned!

Subscribe to the
RSS feed
to always get the release notifications.

For any questions and comments, please contact the
issue tracker on GitHub
or me by email using elektra@markus-raab.org.

Permalink to this NEWS entry

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

Best regards,
Markus

Assets 2
You can’t perform that action at this time.