Free async 0.05 software for linux

HTTP::Async is a Perl module that can process multiple HTTP requests in parallel without blocking.

SYNOPSIS

Create an object and add some requests to it:
use HTTP::Async;
my $async = HTTP::Async->new;

# create some requests and add them to the queue.
$async->add( HTTP::Request->new( GET => http://www.perl.org/ ) );
$async->add( HTTP::Request->new( GET => http://www.ecclestoad.co.uk/ ) );
and then EITHER process the responses as they come back:
while ( my $response = $async->wait_for_next_response ) {
# Do some processing with $response
}
OR do something else if there is no response ready:
while ( $async->not_empty ) {
if ( my $response = $async->next_response ) {
# deal with $response
} else {
# do something else
{
}
OR just use the async object to fetch stuff in the background and deal with the responses at the end.
# Do some long code...
for ( 1 .. 100 ) {
some_function();
$async->poke; # lets it check for incoming data.
}

while ( my $response = $async->wait_for_next_response ) {
# Do some processing with $response
}

Although using the conventional LWP::UserAgent is fast and easy it does have some drawbacks - the code execution blocks until the request has been completed and it is only possible to process one request at a time. HTTP::Async attempts to address these limitations.

It gives you a Async object that you can add requests to, and then get the requests off as they finish. The actual sending and receiving of the requests is abstracted. As soon as you add a request it is transmitted, if there are too many requests in progress at the moment they are queued. There is no concept of starting or stopping - it runs continuously.

Whilst it is waiting to receive data it returns control to the code that called it meaning that you can carry out processing whilst fetching data from the network. All without forking or threading - it is actually done using select lists.

Prelaunch is a utility for the Linux desktop which significantly decrease the time to launch programs.

Pre- launch start the respective program during login not visible to the user. With this trick the real launch needs no time. It is written in C and GTK.

*Prelaunch will work with every desktop environment but only Gnome is supported at the moment (Adding new apps...).

wlan-ui is a very small Linux GUI tool for connecting to wireless networks. It is written in perl, and is a basic example of using perl with Gtk and Glade.

There is also some simple process handling (forking off a process, collecting output, killing the process if cancelled).

syslog-async project is a non-blocking syslog() replacement.

It is not widely known that the standard Unix syslog() library routine can block waiting for the syslog daemon, but it is generally true. On some systems, using a datagram socket for /dev/log avoids endless waits, but on Linux, even this does not work. Try typing

killall -STOP syslogd

into a root terminal on a non-critical box: Eventually, everything will stop.

This library provides a version of syslog() which never blocks: the code was originally written for dnsmasq, to fix a deadlock between syslod and dnsmasq where syslogd uses dnsmasq for DNS, and dnsmasq uses syslogd for logging. It should be generally useful for any daemon where its more important that the daemon continue to function than that it continue to log.

The code has been tested on Linux 2.6, OpenBSD 4.0 and FreeBSD 6.0. It has been run with syslogd and syslog-ng. Note that it is not, currently, threadsafe.

The header file, syslog_async.h is extensively commented, and details how to use the library. It is, as far as possible, API compatible with the POSIX-standard syslog.

GPS::PRN is a package for PRN - Object ID conversions.

SYNOPSIS

use GPS::PRN;
my $obj = GPS::PRN->new();
print "PRN: ", $obj->prn_oid(22231), "n";
print "OID: ", $obj->oid_prn(1), "n";

This module maps GPS PRN number to Satellite OID and vice versa.

Object Identification Number (OID)

The catalog number assigned to the object by the US Air Force. The numbers are assigned sequentially as objects are cataloged. This is the most common way to search for TLE data on this site.

Object numbers less then 10000 are always aligned to the right, and padded with zeros or spaces to the left.

Pseudo Random Numbers (PRNs)

GPS satellites are identified by the receiver by means of PRN-numbers. Real GPS satellites are numbered from 1 - 32. WAAS/EGNOS satellites and other pseudolites are assigned higher numbers. The PRN-numbers of the satellites appear on the satellite view screens of many GPS receivers.

METHODS

prn_oid

PRN given Object ID.

my $prn=prn_oid(22231);

oid_prn

Object ID given PRN.

my $oid=oid_prn(1);

listprn

List all known PRNs.

my @prn=$obj->listprn;
my $prn=$obj->listprn;

listoid

List all known OIDs.

my @oid=$obj->listoid;
my $oid=$obj->listoid;

data

OID to PRN hash reference

my $data=$self->data;

overload

Adds or overloads new OID/PRN pairs.

$obj->overload($oid=>$prn);

reset

Resets overloaded OID/PRN pairs to package defaults.

$obj->reset;

Tie::Trace can easy print debugging with tie.

SYNOPSIS

use Tie::Trace;

my %hash;
tie %hash, "Tie::Trace";

$hash{hoge} = hogehoge; # warn Hash => Key: hoge, Value: hogehgoe at ...

my @array;
tie @aray, "Tie::Trace";
push @array, "array"; # warn Array => Point: 0, Value: array at ...

my $scalar;
tie $scalar, "Tie::Trace";
$scalar = "scalar"; # warn Scalar => Value: scalar at ...

This is usefull for print debugging. Using tie mechanism, you can see sotred value for the specified variable.

If the stored value is scalar/array/hash ref, this can check recursively.

for example;
tie %hash, "Tie::Trace";

$hash{foo} = {a => 1, b => 2}; # warn ...
$hash{foo}->{a} = 2 # warn ...

But This ignores blessed reference and tied value.

AI::FuzzyInference is a Perl module to implement a Fuzzy Inference System.

SYNOPSYS

use AI::FuzzyInference;

my $s = new AI::FuzzyInference;

$s->inVar(service, 0, 10,
poor => [0, 0,
2, 1,
4, 0],
good => [2, 0,
4, 1,
6, 0],
excellent => [4, 0,
6, 1,
8, 0],
amazing => [6, 0,
8, 1,
10, 0],
);

$s->inVar(food, 0, 10,
poor => [0, 0,
2, 1,
4, 0],
good => [2, 0,
4, 1,
6, 0],
excellent => [4, 0,
6, 1,
8, 0],
amazing => [6, 0,
8, 1,
10, 0],
);

$s->outVar(tip, 5, 30,
poor => [5, 0,
10, 1,
15, 0],
good => [10, 0,
15, 1,
20, 0],
excellent => [15, 0,
20, 1,
25, 0],
amazing => [20, 0,
25, 1,
30, 0],
);

$s->addRule(
service=poor & food=poor => tip=poor,
service=good & food=poor => tip=poor,
service=excellent & food=poor => tip=good,
service=amazing & food=poor => tip=good,

service=poor & food=good => tip=poor,
service=good & food=good => tip=good,
service=excellent & food=good => tip=good,
service=amazing & food=good => tip=excellent,

service=poor & food=excellent => tip=good,
service=good & food=excellent => tip=excellent,
service=excellent & food=excellent => tip=excellent,
service=amazing & food=excellent => tip=amazing,

service=poor & food=amazing => tip=good,
service=good & food=amazing => tip=excellent,
service=excellent & food=amazing => tip=amazing,
service=amazing & food=amazing => tip=amazing,

);

$s->compute(service => 2,
food => 7);

HTML::Myasp can generate HTML pages based on Templates. JATP (Just Another Template Parser).

This library is another template module for the generation of HTML pages. Why ?. Well primarily i wanted a module: light, that keeps mod_perl power and flow control like HTML::Template, good interaction with external contents administrators, have the chance of using naturally the print statement for generating web content, but, for some situations have the chance of directly replace keywords in the template with values. In some way this module centralizes the feature of a hash with values for replacing that you find in HTML::Template and the XMLSubsMatch feature of Apache::ASP.

This module keeps the basic mod_perl flow, and permits the replacing with dynamic content using two forms of marking. Is very well suited for working in parallel with the designers team, living each group advance on its own.

HTML::Myasp export the send_page function by default, you can attach the dynamic content using:

A callback style for special tags delimiting zones.
Direct replacing of keywords by values.
In order to improve performance it uses a global pages CACHE hash, avoiding parsing files unless modified.