Free config files software for linux

Config::Fast is an extremely fast configuration file parser.

SYNOPSIS

# default config format is a space-separated file
company "Supercool, Inc."
support nobody@nowhere.com


# and then in Perl
use Config::Fast;

%cf = fastconfig;

print "Thanks for visiting $cf{company}!n";
print "Please contact $cf{support} for support.n";

This module is designed to provide an extremely lightweight way to parse moderately complex configuration files. As such, it exports a single function - fastconfig() - and does not provide any OO access methods. Still, it is fairly full-featured.

Heres how it works:

%cf = fastconfig($file, $delim);

Basically, the fastconfig() function returns a hash of keys and values based on the directives in your configuration file. By default, directives and values are separated by whitespace in the config file, but this can be easily changed with the delimiter argument (see below).

When the configuration file is read, its modification time is first checked and the results cached. On each call to fastconfig(), if the config file has been changed, then the file is reread. Otherwise, the cached results are returned automatically. This makes this module great for mod_perl modules and scripts, one of the primary reasons I wrote it. Simply include this at the top of your script or inside of your constructor function:

my %cf = fastconfig(/path/to/config/file.conf);

If the file argument is omitted, then fastconfig() looks for a file named $0.conf in the ../etc directory relative to the executable. For example, if you ran:

/usr/local/bin/myapp

Then fastconfig() will automatically look for:

/usr/local/etc/myapp.conf

This is great if youre really lazy and always in a hurry, like I am.

If this doesnt work for you, simply supply a filename manually. Note that filename generation does not work in mod_perl, so youll need to supply a filename manually.

Xmms::Config is a Perl Interface to xmms_cfg API.

SYNOPSIS

my $file = Xmms::Config->file; #$ENV{HOME}/.xmms/config
my $cfg = Xmms::Config->new($file);

DNS::Config is a Perl module with DNS Configuration.

SYNOPSIS

use DNS::Config;
my $config = new DNS::Config();
$config->debug();

ABSTRACT

This class represents a configuration for a domain name service daemon (DNS).

A domain name service daemon configuration knows about the zone information actively provided to the service users as well as lots of other configuration data.

This class allows to represent this configuration data in a more or less generic way. Another class, the file adaptor, then knows how to write the information to a file in a daemon specific format.

So far this class is strongly related to the ISCs Bind domain name service daemon but it is inteded to get more generic in upcoming releases. Your help is welcome.

Config::Std is a Perl module load and save configuration files in a standard format.

SYNOPSIS

use Config::Std;

# Load named config file into specified hash...
read_config demo2.cfg => my %config;

# Extract the value of a key/value pair from a specified section...
$config_value = $config{Section_label}{key};

# Change (or create) the value of a key/value pair...
$config{Other_section_label}{other_key} = $new_val;

# Update the config file from which this hash was loaded...
write_config %config;

# Write the config information to another file as well...
write_config %config, $other_file_name;

This module implements yet another damn configuration-file system.

The configuration language is deliberately simple and limited, and the module works hard to preserve as much information (section order, comments, etc.) as possible when a configuration file is updated.

See Chapter 19 of "Perl Best Practices" (OReilly, 2005) for the rationale for this approach.

Config::Framework is a Perl module with handy one-stop shopping for (most) of your configuration file needs.

SYNOPSIS

#create a new object, load two configuration files and decrypt the passwords. my $Object = new Config::Framework( Files => [ApplicationCfg.xml,UserCfg.xml], GetSecure => 1 ) || die $Config::Framework::errstr;

#change some data in one of the loaded configs $Object->{UserCfg}->{backgroundColor} = #00CCFF;

#write that change back to the file you loaded it from $Object->WriteConfig(configNamespace => "UserCfg") || die $Object->{errstr};

#Define a new configuration namespace %{ $Object->{newConfig} } = ( configNamespace => "newConfig", protectNamespace => 1, Version => 1, #arbitrary data keys follow backgroundColor => #006699, getRecords => 10, followLinks => 1, someThing => "in a bag" );

#Write your new configuration data out to an encrypted file #under the applications ApplicationFramework directory $Object->WriteConfig( configNamespace => "newConfig", Encrypt => 1, Crypt => "Rijndael", Key => "l33tp4sw3rd" File => "$Object->{FrameworkDir}/newConfig.xml" ) || die $Object->{errstr};

At long last I have decided to re-write the documentation for Config::Framework, in a manner which should be comprehensible by people other than myself. I would like to offer my sincerest appologies to anyone who tried to comprehend the sprawling stream-of-consiousness rant that was the previous documentation. Im sorry, I wasnt trying to make you insane. Now on with the show.

Ok so what is Config::Framework? Its a handy module for dealing with situations where you need your program to be able to load external data from a file that controls how your program operates. Im talking about configuration files here. So what do you do in a situation like that? Well you figure out a format to store your configuration parameters in, then write routines to read that format and put it some sort of meaningful data structure, and to write data from the data structure back out to the file.

Wouldnt it be nice if someone defined a standard config file format so that you wouldnt need to write your own parser? Well in the end, all a config file really is, is an arbitrary data structure expressed in in ascii. A standard way of serializing data structures in ascii you say? That sounds a bit like XML! Well the Data::DumpXML module will serialize perl data structures into XML and restore them for you, and you could certainly dump that to a file easily enough.
Ok getting to the point. The main thing that Config::Framework does for you is to define a standard data structure (or at least some standard guidelines for your data structure) and then front-ends Data::DumpXML so that you can arbitrarily dump and restore these data structures to files.

While were at it, Config::Framework aspires to be your one-stop-shop for config-type-stuff, by helping you stay organized in the way you handle external configuration data.

PXP::Config is a Perl module for PXP configuration.

SYNOPSIS

# do this only once at server initialization:
PXP::Config::init(file=>$finename);
# then from anywhere:
my $global_configuration_hash = PXP::Config::getGlobal();
# only from a plugin class:
my $plugin_configuration_hash = PXP::Config::get();

PXP::Config is a PXP component which provides a unified and simplified API for the PXP server and PXP plugins to read and store there configuration.

PXP::Config uses the XML::Simple module to access a centralized XML configuration file. This file (/opt/etc/imc.xml by default) contains root element named imc which has a global child for the PXP server configuration and a plugins child which has itself a child per plugin configuration (the child name must be the plugin name for this class to automatically retrieve a plugin configuration.

As plugins configurations are retrived by plugin name in a centralized location, the only thing a plugin has to do in order to get its configuration is to call the PXP::Config::get() method which returns a hash convertion of the plugin XML configuration.

Configuring plugins can be made in two manners:

1) the simple way - use it when you dont need to update the configuration from the application itself and when your plugin configuration has a very simple structure:
simply add a tag with the name of your plugin in the etc/imc.xml file, the plugin configuration can then be accessed as a has by calling the PXP::Config::get() method
2) the sophisticated way - use it in other cases:
create a new package in a file MyConfig/PLUGIN_NAME.pm under your plugin directory
in this file, define a package that inherits from PXP::MyConfig class and which overrode the config, loadFile and synchro methods (see plugins/LogViewer/MyConfig/LogViewer.pm for an example)

edit your plugin.xml and add your new package as an extension to the PXP::MyConfig extension point:

< extension
id="MyConfig::LogViewer"
name="Plugin configuration"
version="0.1"
point="IMC::MyConfig"/ >

< file value=/tmp/imc.xml/ >

< /extension >

You can ommit the file tag, configuration file will then default to the main configuration file (the one passed to the server with the -c switch or etc/imc.xml by default).

See the PXP::Config and PXP::MyConfig APIs for using configuration inside plugins.