Free joedog config 2.01 software for linux

JoeDog::Config provides a perl extension for parsing data/configuration file.

It reads columns, key-value pairs, and INI style config files into arrays, hashes and hashes of hashes. It can take characters or regexes for separators.

ABSTRACT:
This is a autoloadable module which allows the programmer
to read data from an configuration file into various perl
data types, arrays, multi-dimentional arrays and hashes.

INSTALLATION
JoeDog::Config.pm was built using perl Make::Maker utility
If you are familiar with that utility you should have no
problem with this installation as it will be familiar:

$ perl Makefile.PL
$ make
$ make test
$ su
$ make install

USAGE
use JoeDog::Config;
my $cnf = new JoeDog::Config(filename);
my @array = $cnf->get_column();
my @arrays = $cnf->get_columns(sep);
my @aoa = $cnf->get_table(sep,num);
my @aoa = $cnf->get_table(sep,[num1, num2, etc...]);
my %hash = $cnf->get_hash(sep);
my %hashes = $cnf->get_hashes(sep);

network-config is a simple network configuration tool.

Network-config is a simple and easy to use program that helps configuring the network interfaces for linux-based operating systems. It allows to have multiple configurations for the same computer and to easy configure NAT for internet sharing.

It can also be used to scan for wireless networks. It is written in perl and uses gtk2+, but also works as a command line program.

dtRdr::Config is a Perl module with Factory class for configuration system.

Factory Methods

factory_read_config

Constructor function (see new)

my $obj = factory_read_config($file);

new

$conf = dtRdr::Config->new($file);

get_library_info

my @libraries = $conf->get_library_info;

XAO::DO::FS::Config is an embeddable configuration object for XAO::FS.

SYNOPSIS

use XAO::Projects;
use XAO::Objects;

my $config=XAO::Objects->new(objname => Config,
sitename => test);

XAO::Projects::create_project(name => test,
object => $config,
set_current => 1);

my $fsconfig=XAO::Objects->new(objname => FS::Config,
odb_args => {
dsn => OS:MySQL_DBI:test_os
user => test,
password => TeSt,
});

$config->embed(fs => $fsconfig);

my $odb=$config->odb();

The XAO::DO::FS::Config is normally used in larger projects configurations that are persistent in memory. See XAO::DO::Config for more information on how embeddable configuration objects work.

METHODS

cleanup ()

Calls reset() method on the odb to clean up the handler and prepare it for the next session.

disable_special_access ()

Disables use of odb() method to set a new value (this is the default state).

embeddable_methods ()

Used internally by global Config object, returns an array with embeddable method names. Currently there is only one embeddable method -- odb().

enable_special_access ()

Enables use of odb() method to set a new value. Normally you do not need this method.

Example:

$config->enable_special_access();
$config->odb($odb);
$config->disable_special_access();
new ($$)

Creates a new empty configuration object. If odb_args is given then it will connect to a database using these arguments.

Example:

my $fsconfig=XAO::Objects->new(objname => FS::Config,
odb_args => {
dsn => OS:MySQL_DBI:test_os
user => test,
password => TeSt,
});
odb (;$)

Returns current database handler. If called with an argument and speciall access is enabled then replaces database handler.

MRTG::Config is a Perl module for parsing MRTG configuration files.

WARNING

This module, while reliable right now, is still in ALPHA stages of development... The API/methods may change. Behaviors of methods will almost certainly change. The internal structure of data will change, as will many other things.

I will try to always release working versions, but anyone who expects their code that uses this module to continue working shouldnt... until I remove this warning.

SYNOPSIS

Ever have the need to parse an MRTG config file? I have. I needed to parse lots and lots of them. Using the functions built-in to MRTG_lib was too slow, too complex, and used too much RAM and CPU time for my poor web server to handle - and the data structures MRTG_lib built were way more complex than I needed.

MRTG::Config can load and parse MRTG and MRTG-style confiuguration files very quickly, and the parsed directives, targets and values can be located, extracted, and manipulated through an OO interface.

This module is intended to focus on correctly parsing the format of an MRTG configuration, regardless of whether or not the directives and values, etc. are valid for MRTG. I am using both the parsing behavior of MRTG_libs readcfg() function and the description of the format on the MRTG website as my guidelines on how to correctly parse these configuration files. I am still a short way off that goal, but this module is currently being used in a production environment with great success!

PLEA FOR MERCY

I plan on adding to this documentation and making it better organized soon, but Im willing to answer questions directly in the mean time. Also, this is my first module, written in a hurry to appease some disgruntled engineers. I do plan on continuing to improve it, so any input, positive or negative is certainly welcome!

USAGE EXAMPLE

use MRTG::Config;

my $cfgFile = mrtg.cfg;
my $persist_file = mrtg.cfg.db;

my $mrtgCfg = new MRTG::Config;

$mrtgCfg->loadparse($cfgFile);

# Want to store the parsed data for use later or by
# another program?
$mrtgCfg->persist_file($persist_file);
$mrtgCfg->persist(1);

foreach my $tgtName (@{$mrtgCfg->targets()}) {
my $tgtCfg = $mrtgCfg->target($tgtName);
# Lets assume every target has a Title.
print $tgtCfg->{title} . "n";
}

# globals() has some, um, interesting things you
# should know. Please read about it below...
my $globalCfg = $mrtgCfg->globals();

# Lets assume WorkDir is set.
print $globalCfg->{workdir} . "n";

Java::SJ::Config is a Perl module that represents SJ Configuration File.

It uses XML::XPath to parse configuration files and generates objects to represent the directives.

Unless youre working on the module what you really want to know is what directives are allowed and their meaning. Youre in luck, its below.

VARIABLES

The following variables and their relevant defaults are used by the system. These defaults have been chosen to make it as easy as possible to install SJ on a fairly standard UNIX system and have logs, and directories in places that you would expect to find them.

The full paths that will be used if every default is in effect is also shown below.
dir.base - default /usr/local - full /usr/local

The base directory for the system. This directory is used in conjunction with defaults to find directories if they have not been defined elsewhere.
dir.lib - default ${dir.base}/lib/sj - full /usr/local/lib/sj

The directory to find jar files in.
dir.pid - default ${dir.base}/var/run - full /usr/local/var/run

The directory to store PID files in.
dir.log - default ${dir.base}/var/log/sj - full /usr/local/var/log/sj

The directory to store log files in
dir.script - default ${dir.base}/var/sj/script - full /usr/local/var/sj/script

The directory to store generated script files in.
dir.tmp - default &File::Spec::Functions::tmpdir - full N/A (depends on system)

The directory to store temporary files in.
app.name - no default

The name of the application
app.class - no default

The class file for the application
vm.default - Defined by whichever VM has default=true attribute

The default VM tag to use if none supplied by the application

Log::Dispatch::Config is a Log4j for Perl.

SYNOPSIS

use Log::Dispatch::Config;
Log::Dispatch::Config->configure(/path/to/log.conf);

my $dispatcher = Log::Dispatch::Config->instance;
$dispatcher->debug(this is debug message);
$dispatcher->emergency(something *bad* happened!);

# automatic reloading conf file, when modified
Log::Dispatch::Config->configure_and_watch(/path/to/log.conf);

# or if you write your own config parser:
use Log::Dispatch::Configurator::XMLSimple;

my $config = Log::Dispatch::Configurator::XMLSimple->new(log.xml);
Log::Dispatch::Config->configure($config);

Log::Dispatch::Config is a subclass of Log::Dispatch and provides a way to configure Log::Dispatch object with configulation file (default, in AppConfig format). I mean, this is log4j for Perl, not with all API compatibility though.

METHOD

This module has a class method configure which parses config file for later creation of the Log::Dispatch::Config singleton instance. (Actual construction of the object is done in the first instance call).

So, what you should do is call configure method once in somewhere (like startup.pl in mod_perl), then you can get configured dispatcher instance via Log::Dispatch::Config->instance.

Simple Config library supports configuration files consisting of simple name-value pairs, similar to the old Windows INI files. A config file can be loaded into memory, queried by item name, modified, and written back out to a file. Configuration items may also be "watched", which causes a user-supplied callback function to be called with the named item is modified
Client code can query the configuration system for named values, set named values, test the type of values (STR, INT, FIX, BOOL, DATE or TIME) and watch values for changes. The system can update the configuration file when the application has changed or added values, even preserving the original format and commens from the input configuration file.
Theres not much to it, at the moment, not even a manpage, so youre on your own as far as using the library. There is a ReadMe file and a makefile, so you can easily build and install the library.
The whole thing took about a week to design, code and test, so its no heroic effort or anything. With a bit more time and energy it could probably be something really spectacular. My main point was that, given the simple problem statement, it was (relatively) trivial to code up a conforming solution.
Enhancements:
- The hashtable code was updated.
- No changes were made to functionality, but it is now more heap-friendly with less heap fragmentation and faster bucket allocation.
- The ground work for automatic table resizing has been laid.