Free failed software for linux

File::PathList is a Perl module that can find a file within a set of paths (like @INC or Java classpaths).

SYNOPSIS

# Create a basic pathset
my $inc = File::PathList->new( @INC );

# Again, but with more explicit params
my $inc2 = File::PathList->new(
paths => @INC,
cache => 1,
);

# Get the full (localised) path for a unix-style relative path
my $file = "foo/bar/baz.txt";
my $path = $inc->find_file( $file );

if ( $path ) {
print "Found $file at $pathn";
} else {
print "Failed to find $filen";
}

Many systems that map generic relative paths to absolute paths do so with a set of base paths.

For example, perl itself when loading classes first turn a Class::Name into a path like Class/Name.pm, and thens looks through each element of @INC to find the actual file.

To aid in portability, all relative paths are provided as unix-style relative paths, and converted to the localised version in the process of looking up the path.

APLoader stands for Another Postgres Loader, is a front-end to the Postgresql COPY command written in Ruby.

Features include:

fault tolerance
a progress meter
failed batch logs
minimal requirements
a programmable API
excellent performance.

The APLoaderproject is a PostgreSQL Community project that is a part of the pgFoundry.

Fatal::Exception - succeed or throw exception.

SYNOPSIS

use Fatal::Exception Exception::System => qw ;
open FILE, "/nonexistent"; # throw Exception::System

use Exception::Base Exception::My;
sub juggle { ... }
import Fatal::Exception Exception::My => juggle;
juggle; # succeed or throw exception
unimport Fatal::Exception juggle;
juggle or die; # restore original behavior

Fatal::Exception provides a way to conveniently replace functions which normally return a false value when they fail with equivalents which raise exceptions if they are not successful. This is the same as Fatal module but it throws Exception::Base object on error.

IMPORTS

use Fatal::Exception Exception => function, function, ...

Replaces the original functions with wrappers which provide do-or-throw equivalents. You may wrap both user-defined functions and overridable CORE operators (except exec, system which cannot be expressed via prototypes) in this way.

If the symbol :void appears in the import list, then functions named later in that import list raise an exception only when these are called in void context.
You should not fatalize functions that are called in list context, because this module tests whether a function has failed by testing the boolean truth of its return value in scalar context.

If the exception class is not exist, its module is loaded with "use Exception" automatically.

unimport Fatal::Exception function, function, ...

Restores original functions for user-defined functions or replaces the functions with do-without-die wrappers for CORE operators.

In fact, the CORE operators cannot be restored, so the non-fatalized alternative is provided instead.

The functions can be wrapped and un-wrapped all the time.

fl0p provides a passive OS fingerprinting tool.
fl0p is a passive L7 flow fingerprinter that examines TCP/UDP/ICMP packet sequences, can peek into cryptographic tunnels, can tell human beings and robots apart, and performs a couple of other infosec-related tricks.
This approach differs from the techniques used by most other passive
sniffers and mappers, and is advantageous in several interesting ways:
- General flow behavior remains largely unchanged regardless of whether
cryptographic tunnels or other obfuscation techniques are used. As
such, backdoors or firewall evasion techniques that for example
use SSL on port 443, can be told apart from browser traffic, and
further investigated.
- General insight into legitimate encrypted sessions can be gained; for
example, it is possible to remotely tell successful and failed SSH
authentication attempts apart, and react accordingly.
- Human actions can be told apart from automated efforts: it is possible
to ignore SMTP client programs, but single out humans manually
interacting with the server on port 25; similarly, automated SSH
login attempts can be told apart from human actions.
Enhancements:
- Chained signature support added.
- SMTP signatures

Test::Simple is a Perl module with basic utilities for writing tests.

SYNOPSIS

use Test::Simple tests => 1;

ok( $foo eq $bar, foo is bar );

** If you are unfamiliar with testing read Test::Tutorial first! **

This is an extremely simple, extremely basic module for writing tests suitable for CPAN modules and other pursuits. If you wish to do more complicated testing, use the Test::More module (a drop-in replacement for this one).
The basic unit of Perl testing is the ok. For each thing you want to test your program will print out an "ok" or "not ok" to indicate pass or fail. You do this with the ok() function (see below).

The only other constraint is you must pre-declare how many tests you plan to run. This is in case something goes horribly wrong during the test and your test program aborts, or skips a test or whatever. You do this like so:

use Test::Simple tests => 23;

You must have a plan.

ok
ok( $foo eq $bar, $name );
ok( $foo eq $bar );

ok() is given an expression (in this case $foo eq $bar). If its true, the test passed. If its false, it didnt. Thats about it.

ok() prints out either "ok" or "not ok" along with a test number (it keeps track of that for you).

# This produces "ok 1 - Hell not yet frozen over" (or not ok)
ok( get_temperature($hell) > 0, Hell not yet frozen over );

If you provide a $name, that will be printed along with the "ok/not ok" to make it easier to find your test when if fails (just search for the name). It also makes it easier for the next guy to understand what your test is for. Its highly recommended you use test names.

All tests are run in scalar context. So this:

ok( @stuff, I have some stuff );
will do what you mean (fail if stuff is empty)

Test::Simple will start by printing number of tests run in the form "1..M" (so "1..5" means youre going to run 5 tests). This strange format lets Test::Harness know how many tests you plan on running in case something goes horribly wrong.
If all your tests passed, Test::Simple will exit with zero (which is normal). If anything failed it will exit with how many failed. If you run less (or more) tests than you planned, the missing (or extras) will be considered failures. If no tests were ever run Test::Simple will throw a warning and exit with 255. If the test died, even after having successfully completed all its tests, it will still be considered a failure and will exit with 255.

So the exit codes are...
0 all tests successful
255 test died or all passed but wrong # of tests run
any other number how many failed (including missing or extras)

If you fail more than 254 tests, it will be reported as 254.

This module is by no means trying to be a complete testing system. Its just to get you started. Once youre off the ground its recommended you look at Test::More.

Flickr::Upload is a Perl module to upload images to flickr.com

SYNOPSIS

use Flickr::Upload;

my $ua = Flickr::Upload->new( key => 90909354, secret => 37465825 );
$ua->upload(
photo => /tmp/image.jpg,
auth_token => $auth_token,
tags => me myself eye,
is_public => 1,
is_friend => 1,
is_family => 1
) or die "Failed to upload /tmp/image.jpg";

HA-JDBC project is a JDBC driver implementation that provides light-weight, transparent clustering capabilities to groups of homogeneous JDBC- accessed databases.
Main features:
- Supports any database accessible via JDBC.
- High-availability - Database cluster can lose a node without failing the current transaction.
- Improves performance of concurrent read-access by distributing load across individual nodes.
- Support for full JDBC 3.0 (Java 1.4) feature set.
- Compatible with JDBC RowSet implementations found in Java 1.5.
- Out-of-the-box database-independent strategies for synchronizing a failed cluster node.
- Exposes JMX management interface to allow administration of database clusters.
- Open source (LGPL).