Free some simple software for linux

JOpt Simple is a simple, test-driven command line parser for Java programs. JOpt Simple supports POSIX getopt() and GNU getopt_long().
What command line switch syntax does JOpt Simple support?
As closely as possible, JOpt Simple attempts to adhere to the rules of POSIX getopt() and GNU getopt_long(). You can find a brief summary of these rules in the javadoc for class OptionParser.
Enhancements:
- Minor internal changes.

XML::Simple is a easy API to maintain XML (esp config files).

SYNOPSIS

use XML::Simple;

my $ref = XMLin([< xml file or string >] [, < options >]);

my $xml = XMLout($hashref [, < options >]);

Or the object oriented way:

require XML::Simple;

my $xs = new XML::Simple(options);

my $ref = $xs->XMLin([< xml file or string >] [, < options >]);

my $xml = $xs->XMLout($hashref [, < options >]);

(or see "SAX SUPPORT" for the SAX way).

To catch common errors:

use XML::Simple qw(:strict);

ICS::Simple is a simple interface to CyberSource ICS2.

SYNOPSIS

Here is some basic code. Hopefully Ill come back through soon to document it properly.

use ICS::Simple;

my $ics = ICS::Simple->new(
ICSPath => /opt/ics,
MerchantId => v0123456789, # CyberSource supplies this number to you
Mode => test,
Currency => USD,
Grammar => UpperCamel, # defaults to raw ICS responses, so you might want to set this
#ErrorsTo => all-errors@some.fun.place.com,
CriticalErrorsTo => only-critical-errors@some.fun.place.com,
);

my $request = {
OrderId => order19857219,
FirstName => Fred,
LastName => Smith,
Email => fred.smith@buyer-of-stuff.com,
CardNumber => 4111111111111111,
CardCVV => 123,
CardExpYear => 2008,
CardExpMonth => 12,
BillingAddress => 123 Main St,
BillingCity => Olympia,
BillingRegion => WA,
BillingPostalCode => 98501,
BillingCountryCode => US,
ShippingAddress1 => 6789 Industrial Pl,
ShippingAddress2 => Floor 83, Room 11415,
ShippingCity => Olympia,
ShippingRegion => WA,
ShippingPostalCode => 98506,
ShippingCountryCode => US,
ShippingFee => 25.05,
HandlingFee => 5.00,
Items => [
{ Description => Mega Lizard Monster RC,
Price => 25.00,
SKU => prod15185 },
{ Description => Super Racer Parts Kit,
Price => 15.30,
SKU => prod23523 },
{ Description => Uber Space Jacket,
Price => 72.24,
SKU => prod18718 },
],
};

my $response = $ics->requestBill($request);

if ($response->{success}) {
print "Woo! Success!n";
$response = $response->{response};
print "Thanks for your payment of $$response->{BillAmount}.n";
}
else {
print "Boo! Failure!n";
print "Error: $response->{error}->{description}n";
}

Timestamp::Simple is a Perl module with simple methods for timestamping.

SYNOPSIS

use Timestamp::Simple qw(stamp);
print stamp, "n";

This module provides a simple method for returning a stamp to mark when an event occurs.

METHODS

stamp()

This method returns a timestamp in the form yyyymmddHHMMSS.

LockFile::Simple is a simple file locking scheme.

SYNOPSIS

use LockFile::Simple qw(lock trylock unlock);

# Simple locking using default settings
lock("/some/file") || die "cant lock /some/filen";
warn "already lockedn" unless trylock("/some/file");
unlock("/some/file");

# Build customized locking manager object
$lockmgr = LockFile::Simple->make(-format => %f.lck,
-max => 20, -delay => 1, -nfs => 1);

$lockmgr->lock("/some/file") || die "cant lock /some/filen";
$lockmgr->trylock("/some/file");
$lockmgr->unlock("/some/file");

$lockmgr->configure(-nfs => 0);

# Using lock handles
my $lock = $lockmgr->lock("/some/file");
$lock->release;

This simple locking scheme is not based on any file locking system calls such as flock() or lockf() but rather relies on basic file system primitives and properties, such as the atomicity of the write() system call. It is not meant to be exempt from all race conditions, especially over NFS. The algorithm used is described below in the ALGORITHM section.

It is possible to customize the locking operations to attempt locking once every 5 seconds for 30 times, or delete stale locks (files that are deemed too ancient) before attempting the locking.

Getopt::Simple is a Perl module that provides a simple wrapper around Getopt::Long.

SYNOPSIS

use Getopt::Simple;

# Or ...
# use Getopt::Simple qw($switch);

my($options) =
{
help =>
{
type => ,
env => -,
default => ,
# verbose => , # Not needed on every key.
order => 1,
},
username =>
{
type => =s, # As per Getopt::Long.
env => $USER, # Help text.
default => $ENV{USER} || RonSavage, # In case $USER is undef.
verbose => Specify the username on the remote machine,
order => 3, # Help text sort order.
},
password =>
{
type => =s,
env => -,
default => password,
verbose => Specify the password on the remote machine,
order => 4,
},
};

my($option) = Getopt::Simple -> new();

if (! $option -> getOptions($options, "Usage: testSimple.pl [options]") )
{
exit(-1); # Failure.
}

print "username: $$option{switch}{username}. n";
print "password: $$option{switch}{password}. n";

# Or, after use Getopt::Simple qw($switch); ...
# print "username: $$switch{username}. n";
# print "password: $$switch{password}. n";

Getopt::Simple is a pure Perl module.

The Getopt::Simple module provides a simple way of specifying:

Command line switches

Type information for switch values

Default values for the switches

Help text per switch

MP3::Icecast::Simple is a simple MP3::Icecast wrapper.

SYNOPSIS

use MP3::Icecast::Simple;

$icy = MP3::Icecast::Simple->new(
description => "Station",
server => 127.0.0.1:8000,
password => password,
local_port => 1234,
bitrate => 96
);
$icy->play("/path/to/files");

ABSTRACT

MP3::Icecast::Simple is a simple MP3::Icecast wrapper, that can be used to create a SHOUTcast/Icecast broadcast source easy.