Free args software for linux

GetArgs is a Perl module to allow enhanced argument passing, including passing of case-insensitive named arguments as well as positioned arguments.

SYNOPSIS

sub WHATEVER {
my @DEFAULT_ARGS =
( Content => "Default content",
Verbose => 0
);
my %ARGS=GetArgs(@_,@DEFAULT_ARGS);
# do some stuff with $ARGS{Content}
# show all kinds of detail if $ARGS{Verbose}
}

# a simple call to WHATEVER
WHATEVER( "Just deal with my content" );

# a flexible call to WHATEVER
WHATEVER({ verbose => 1,
content => "This is my content",
});

GetArgs needs to know * what your subroutine was passed, * and what it expected to be passed. * If you like, you can also supply default values to use when an argument is not passed.

Using this information, GetArgs will create a hash of arguments for you to use throughout your subroutine. Using GetArgs has several advantages:

1) Calls to your subroutine can pass named arguments, making the code more readable.
2) If its easier to pass a list of arguments as you normally would, thats fine.
3) With GetArgs your use of arguments in your subroutine code is more readable.
4) Your subroutines are no longer limited in the number of arguments they expect.
5) Arguments can be passed in any order (if passed inside the hash ref), thus only the arguments relevant to that call need to be passed--unnecessary arguments can be ignored.
6) Case is not important, as GetArgs matches argument names case insensitively.

Bio::AlignIO::msf is a Perl module with msf sequence input/output stream.

SYNOPSIS

Do not use this module directly. Use it via the Bio::AlignIO class.

This object can transform Bio::Align::AlignI objects to and from msf flat file databases.

The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _

next_aln

Title : next_aln
Usage : $aln = $stream->next_aln()
Function: returns the next alignment in the stream. Tries to read *all* MSF
It reads all non whitespace characters in the alignment
area. For MSFs with weird gaps (eg ~~~) map them by using
$al->map_chars(~,-)
Returns : L< Bio::Align::AlignI > object
Args : NONE

write_aln

Title : write_aln
Usage : $stream->write_aln(@aln)
Function: writes the $aln object into the stream in MSF format
Sequence type of the alignment is determined by the first sequence.
Returns : 1 for success and 0 for error
Args : L< Bio::Align::AlignI > object

Catalyst is a Perl module that contains the elegant MVC web application framework.

SYNOPSIS

See the Catalyst::Manual distribution for comprehensive documentation and tutorials.

# Install Catalyst::Devel for helpers and other development tools
# use the helper to create a new application
catalyst.pl MyApp

# add models, views, controllers
script/myapp_create.pl model MyDatabase DBIC::Schema create=dynamic dbi:SQLite:/path/to/db
script/myapp_create.pl view MyTemplate TT
script/myapp_create.pl controller Search

# built in testserver -- use -r to restart automatically on changes
# --help to see all available options
script/myapp_server.pl

# command line testing interface
script/myapp_test.pl /yada

### in lib/MyApp.pm
use Catalyst qw/-Debug/; # include plugins here as well

### In lib/MyApp/Controller/Root.pm (autocreated)
sub foo : Global { # called for /foo, /foo/1, /foo/1/2, etc.
my ( $self, $c, @args ) = @_; # args are qw/1 2/ for /foo/1/2
$c->stash->{template} = foo.tt; # set the template
# lookup something from db -- stash vars are passed to TT
$c->stash->{data} =
$c->model(Database::Foo)->search( { country => $args[0] } );
if ( $c->req->params->{bar} ) { # access GET or POST parameters
$c->forward( bar ); # process another action
# do something else after forward returns
}
}

# The foo.tt TT template can use the stash data from the database
[% WHILE (item = data.next) %]
[% item.foo %]
[% END %]

# called for /bar/of/soap, /bar/of/soap/10, etc.
sub bar : Path(/bar/of/soap) { ... }

# called for all actions, from the top-most controller downwards
sub auto : Private {
my ( $self, $c ) = @_;
if ( !$c->user_exists ) { # Catalyst::Plugin::Authentication
$c->res->redirect( /login ); # require login
return 0; # abort request and go immediately to end()
}
return 1; # success; carry on to next action
}

# called after all actions are finished
sub end : Private {
my ( $self, $c ) = @_;
if ( scalar @{ $c->error } ) { ... } # handle errors
return if $c->res->body; # already have a response
$c->forward( MyApp::View::TT ); # render template
}

### in MyApp/Controller/Foo.pm
# called for /foo/bar
sub bar : Local { ... }

# called for /blargle
sub blargle : Global { ... }

# an index action matches /foo, but not /foo/1, etc.
sub index : Private { ... }

### in MyApp/Controller/Foo/Bar.pm
# called for /foo/bar/baz
sub baz : Local { ... }

# first Root auto is called, then Foo auto, then this
sub auto : Private { ... }

# powerful regular expression paths are also possible
sub details : Regex(^product/(w+)/details$) {
my ( $self, $c ) = @_;
# extract the (w+) from the URI
my $product = $c->req->captures->[0];
}

Term::Shell is a simple command-line shell framework.

SYNOPSIS

package MyShell;
use base qw(Term::Shell);

sub run_command1 { print "command 1!n"; }
sub smry_command1 { "what does command1 do?" }
sub help_command1 {
cmdloop;

Term::Shell lets you write simple command-line shells. All the boring details like command-line parsing, terminal handling, and tab completion are handled for you.
The base class comes with two commands pre-defined: exit and help.

To write a shell with an exec command, do something like this:

package MyShell;
use base qw(Term::Shell); # or manually edit @MyShell::ISA.

sub run_exec {
my ($o, $cmd, @args) = @_;
if ($cmd ne $0) {
print "Im sorry youre leaving us...n";
}
exec $cmd, @args;
exit 1;
}

When Term::Shell needs to handle the exec command, it will invoke this method. Thats all there is to it! You write handlers, and Term::Shell handles the gory details.

Language::Zcode::Parser is a Perl module that reads and parses a Z-code file into a big Perl hash.

SYNOPSIS

# Create a Pure Perl Parser
my $pParser = new Language::Zcode::Parser "Perl";

# If they didnt put ".z5" at the end, find it anyway
$infile = $pParser->find_zfile($infile) || exit;

# Read in the file, store it in memory
$pParser->read_memory($infile);

# Parse header of the Z-file
$pParser->parse_header();

# Get the subroutines in the file (LZ::Parser::Routine objects)
my @subs = $pParser->find_subs($infile);

For finding where the subroutines start and end, you can either depend on an external call to txd, a 1992 C program available at ifarchive.org, or a pure Perl version.

Everything else is done in pure Perl.

new (class, how to find subs, args...)

This is a factory method. Called with Perl or TXD (or txd) as arguments, it will create Parsers of LZ::Parser::Perl or LZ::Parser::TXD, which are subclasses of LZ::Parser::Generic.

That class new method will be called with any other passed-in args.

Net::Analysis are modules for analysing network traffic.

SYNOPSIS

Using an existing analyser:

$ perl -MNet::Analysis -e main help
$ perl -MNet::Analysis -e main TCP,v=1 dump.tcp - basic TCP info
$ perl -MNet::Analysis -e main HTTP,v=1 dump.tcp - HTTP stuff
$ perl -MNet::Analysis -e main Example2,regex=img dump.tcp - run an example

Writing your own analyser:

package MyExample;
use base qw(Net::Analysis::Listener::Base);
# Listen to events from other modules
sub tcp_monologue {
my ($self, $args) = @_;
my ($mono) = $args->{monologue};
my $t = $mono->t_elapsed()->as_number();
my $l = $mono->length();
# Emit your own event
$self->emit(name => example_event,
args => { kb_sec => ($t) ? $l/($t*1024) : N/A }
);
}
# Process your own event
sub example_event {
my ($self, $args) = @_;
printf "Bandwidth: %10.2f KB/secn", $args->{kb_sec};
}
1;
__top

ABSTRACT

Net::Analysis is a suite of modules that parse tcpdump files, reconstruct TCP sessions from the packets, and provide a very lightweight framework for writing protocol anaylsers.
__top

I wanted a batch version of Ethereal in Perl, so I could:

- sift through parsed protocols with structured filters
- write custom reports that mixed events from multiple protocols

So here it is. Net::Analysis is a stack of protocol handlers that emit, and listen for, events.

Proc::Forking is a Perl module that provides a set of tool to fork and daemonize.

SYNOPSIS

#!/usr/bin/perl

use strict;
use Proc::Forking;
use Data::Dumper;
use Time::HiRes qw(usleep); # to allow micro sleep

my $f = Proc::Forking->new();
$SIG{ KILL } = $SIG{ TERM } = $SIG{ INT } = sub { $f->killall_childs;sleep 1; exit },
$f->daemonize(
## uid => 1000,
## gid => 1000,
## home => "/tmp",
pid_file => "/tmp/master.pid"
);

open( STDOUT, ">>/tmp/master.log" );
my $nbr = 0;
my $timemout;

while ( 1 )
{
if ( $nbr < 20 )
{
my $extra = "other parameter";
my ( $status, $pid, $error ) = $f->fork_child(
function => &func,
name => "new_name.##",
args => [ "hello SOMEONE", 3, $extra ],
pid_file => "/tmp/fork.##.pid",
uid => 1000,
gid => 1000,
home => "/tmp",
max_load => 5,
max_mem => 185000000,
expiration => 10,
# expiration_auto => 1,
);
if ( $status == 4 ) # if the load become to high
{
print "Max load reached, do a little napn";
usleep( 100000 );
next;
}
elsif ( $status ) # if another kind of error

{
print "PID=$pidt error=$errorn";
print Dumper( $f->list_names() );
print Dumper( $f->list_pids() );
}
}
$nbr = $f->pid_nbr;
my ( $n, @dp, @dn ) = $f->expirate;
if ( $n )
{
print Dumper( @dp );
}
print "free=n";
usleep( 100000 ); # always a good idea to put a small sleep to allow task swapper to gain some free resources
}

sub func
{
my $ref = shift;
my @args = @$ref;
my ( $data, $time_out, $sockC ) = @args;
$SIG{ USR1 } = sub { open my $log, ">>/tmp/log.s"; print $log "signal USR1 receivedn"; close $log; };
if ( !$time_out )
{
$time_out = 3;
}
open my $FF, ">>/tmp/loglist";
print $FF $$, " start time =", $^T;
close $FF;

for ( 1 .. 4 )
{
open my $fh, ">>/tmp/log";
if ( defined $fh )
{
print $fh "TMOUT = $time_out " . time . " PID=$$ cwd=" . Cwd::cwd() . " name =$0n";
$fh->close;
}
sleep $time_out + rand( 5 );
}
}