Perl module to create configuration editor wtih semantic validation
Perl Perl6
Latest commit b5e9c03 Dec 27, 2016 @dod38fr fix error forwarding in BackendMgr
Only Config::Model::Exception is able to rethrow. Other error object
must be handled like strings, i.e. with die.
Permalink
Failed to load latest commit information.
contrib
lib/Config fix error forwarding in BackendMgr Dec 27, 2016
t test instance retrieval by name Dec 22, 2016
.gitignore gitignore: added *~ Jul 18, 2013
.travis.yml
Build.PL Build.PL: removed needless cleanup dir May 23, 2016
CONTRIBUTING.md
Changes
MANIFEST.SKIP Move all files one directory up Jun 29, 2012
MODELS
README.install.pod updated installation instructions in README.install May 16, 2016
README.md updated build-from0git documentation Dec 14, 2016
TODO added todo: remove Exception::Class Jan 20, 2016
build-from-git.md added link to debian pts for authordebs pkg Dec 14, 2016
dist.ini dist.ini: added missing authordep modules Dec 18, 2016
weaver.ini

README.md

Config-Model

Configuration schema on steroids.

What is Config-Model project

Config::Model is:

To generate a configuration editor and validator for a project, Config::Model needs:

  • a description of the structure and constraints of a project configuration. (this is called a model, but could also be called a schema)
  • a way to read and write configuration data. This can be provided by built-in read/write backends or by a new read/write backend.

With the elements above, Config::Model generates interactive configuration editors (with integrated help and data validation) and support several kinds of user interface, e.g. graphical, interactive command line. See the list of available user interfaces

Installation

See installation instructions. Perl developers can also build Config::Model from git

Getting started

How does this work ?

Using this project, a typical configuration editor will be made of 3 parts :

  1. The user interface ( cme program and some other optional modules)
  2. The validation engine which is in charge of validating all the configuration information provided by the user. This engine is made of the framework provided by this module and the configuration description (often referred as "configuration model", this could also be known as a schema).
  3. The storage facility that store the configuration information (currently several backends are provided: ini files, perl files)

The important part is the configuration model used by the validation engine. This model can be created or modified with a graphical editor (cme meta edit provided by Config::Model::Itself).

Don't we already have some configuration validation tools ?

You're probably thinking of tools like webmin. Yes, these tools exist and work fine, but they have their set of drawbacks.

Usually, the validation of configuration data is done with a script which performs semantic validation and often ends up being quite complex (e.g. 2500 lines for Debian's xserver-xorg.config script which handles xorg.conf file).

In most cases, the configuration model is expressed in instructions (whatever programming language is used) and interspersed with a lot of processing to handle the actual configuration data.

What's the advantage of this project ?

Config::Model projects provide a way to get a validation engine where the configuration model is completely separated from the actual processing instructions.

A configuration model can be created and modified with the graphical interface provided by "cme meta edit" distributed with Config::Model::Itself. The model is saved in a declarative form (currently, a Perl data structure). Such a model is easier to maintain than a lot of code.

The model specifies:

  • the structure of the configuration data (which can be queried by generic user interfaces)
  • the properties of each element (boundaries check, integer or string, enum like type ...)
  • the default values of parameters (if any)
  • mandatory parameters
  • Warning conditions (and optionally, instructions to fix warnings)
  • on-line help (for each parameter or value of parameter)

So, in the end:

  • maintenance and evolution of the configuration content is easier
  • user will see a common interface for all programs using this project.
  • upgrade of configuration data is easier and sanity check is performed
  • audit of configuration is possible to check what was modified by the user compared to default values

What about the user interface ?

Config::Model interface can be:

All these interfaces are generated from the configuration model.

And configuration model can be created or modified with a graphical user interface ("cme meta edit")

What about configuration data storage ?

Since the syntax of configuration files vary wildly form one program to another, most people who want to use this framework will have to provide a dedicated parser/writer.

Nevertheless, this project provides a writer/parser for some common format: ini style file and perl file.

If you want to discuss Config::Model ?

More information

See