Free poe component client ping 1.13 software for linux

POE::Component::Client::SMTP is a Perl module for asynchronous mail sending with POE. Thus your program isnt blocking while busy talking with an (E)SMTP server.

SYNOPSIS

Warning! The following examples are not complete programs, and arent designed to be run as full blown applications. Their purpose is to quickly introduce you to the module.

For complete examples, check the eg directory that can be found in the distributions kit.

A simple example:

# load PoCoClient::SMTP
use POE::Component::Client::SMTP;
# spawn a session
POE::Component::Client::SMTP->send(
From => foo@baz.com,
To => john@doe.net,
Server => relay.mailer.net,
SMTP_Success => callback_event_for_success,
SMTP_Failure => callback_event_for_failure,
);
# and you are all set ;-)
A more complex example:
# load PoCoClient::SMTP
use POE::Component::Client::SMTP;
# spawn a session
POE::Component::Client::SMTP->send(
# Email related parameters
From => foo@baz.com,
To => [
john@doe.net,
andy@zzz.org,
peter@z.net,
george@g.com,
],
Body => $email_body, # heres where your message is stored
Server => relay.mailer.net,
Timeout => 100, # 100 seconds before timeouting
# POE related parameters
Alias => pococlsmtpX,
SMTP_Success => callback_event_for_success,
SMTP_Failure => callback_event_for_failure,
);
# and you are all set

POE::Component::Client::AirTunes is a Perl module with stream music to Airport Express.

SYNOPSIS

use POE qw( Component::Client::AirTunes );

POE::Component::Client::AirTunes->new(
host => $ip,
alias => "airtunes",
events => {
connected => connected,
error => error,
done => done,
},
);

$kernel->post(airtunes => volume => 100);
$kernel->post(airtunes => play => "/path/to/foobar.m4a");
$kernel->post(airtunes => stop);

POE::Component::Client::AirTunes is a POE component to stream music files to your Airport Express. This module is a frontend for a command line Airport Express player raop_play, which is included in Airport Express Client, availabe at http://raop-play.sourceforge.net.

See t/01_airtunes.t for more example. This module is ALPHA software and its API might change in the future.

POE::Component::Client::TCPMulti is a high performance client TCP library.

SYNOPSIS

# Short Usage
POE::Component::Client::TCPMulti->create
( InputEvent => sub {
printf "%s:%d: %s",
$_[CHEAP]->ADDR, $_[CHEAP]->PORT, $_[ARG0];
},
SuccessEvent => sub {
printf "%s:%d: Connection Recieved",
$_[CHEAP]->ADDR, $_[CHEAP]->PORT;
$_[KERNEL]->yield( send => "" );
},
inline_states => {
_start => sub {
$_[KERNEL]->yield( connect => "127.0.0.1", $_ )
for 1..1024;
},
},
InputTimeout => 15,
);

# Longer Usage
POE::Component::Client::TCPMulti->create
( InputEvent => sub {
$_[KERNEL]->yield(send => $_[CHEAP]->ID, "Some Stuff");
},

Initialize => sub {
$_[CHEAP]->input_filter
( "POE::Filter::Block", BlockSize => 4);
},
ErrorEvent => &ErrorHandle,
Disconnected => &ErrorHandle,
TimeoutEvent => &TimeoutHandle,
FailureEvent => &FailureHandle,
SuccessEvent => sub {
$_[CHEAP]->filter("POE::Filter::Line");

# Set timeout for this connection to 350 seconds.
$_[CHEAP]->timeout(350);

# This state is part of the component interface
$_[KERNEL]->yield(send => $_[CHEAP]->ID, "Some Data");
},

Domain => AF_INET, # Optional

Alias => "MySession", # Optional
InputTimeout => 360, # Seconds, Optional
ConnectTimeout => 30, # Seconds, Optional
Timeout => 30, # Seconds, Optional
Filter => "POE::Filter::Something", # Optional

inline_states => {
_start => sub {
$_[KERNEL]->yield(connect => q(127.0.0.1), 25);
# _start isnt needed if you use an alias.
},
},

args => $Session_Args, # Optional
object_states => $Object_States, # Optional
package_states => $Package_States, # Optional
);

# This should be done from within a state in the TCPMulti
# Session. Its purpose is to allow prepropigation of the
# connection heap as well as connection specific timeout
# Settings.
POE::Component::Client::TCPMulti->connect
( RemoteAddress => "127.0.0.1",
RemotePort => 25,
BindAddress => "127.0.0.1", # Optional
BindPort => 0, # Optional
ConnectTimeout => 50, # Connect only.
InputTimeout => 300, # Input only.
Heap => %Propigation );

POE::Component::Client::TCPMulti is a very lightweight, highly optimized component designed for large numbers of simultanious outgoing connections. The major advantage to this module over POE::Component::Client::TCP is that it runs in a single session, reguardless of the number of outgoing simultanious connections. I have found this in fact to use considerable less overhead than POE::Component::Client::TCP in high traffic. The disadvantage lies mearly in the API complexity over POE::Component::Client::TCP.

It is in fact due to this added API complexity that I decided to create a seperate module, rather than altering POE::Component::Client::TCP [ or coaxing Rocco to let me ]. POE::Component::Client::TCP is a great module and this is not designed to completely replace it. It is however designed as a solution for extremely high traffic situations when the overhead of an individual session for each outgoing connection is not appropriate for the added simplicity in the API. Especially considering that this API is not really *that* much more complex.

POE::Component::Client::Halo is an implementation of the Halo query protocol.

SYNOPSIS

use Data::Dumper; # for the sample below
use POE qw(Component::Client::Halo);

my $halo = new POE::Component::Client::Halo(
Alias => halo,
Timeout => 15,
Retry => 2,
);

$kernel->post(halo, info, 127.0.0.1, 2302, pbhandler, ident);

$kernel->post(halo, detail, 127.0.0.1, 2302, pbhandler, ident);

sub postback_handler {
my ($ip, $port, $command, $identifier, $response) = @_;
print "Halo query $command_executed on ";
print " at $ip:$port";
print " had a identifier of $identifier" if defined $identifier;
print " returned from the server with:";
print Dumper($response), "nn";
}

POE::Component::Client::Halo is an implementation of the Halo query protocol. It was reverse engineered with a sniffer and two cups of coffee. This is a preliminary release, based version 1.00.01.0580 of the dedicated server (the first public release). It is capable of handling multiple requests of different types in parallel.

POE::Component::ControlPort is a Perl module with network control port for POE applications.

SYNOPSIS

use POE;
use Getopt::Long;

use POE::Component::ControlPort;
use POE::Component::ControlPort::Command;

my @commands = (
{
help_text => My command,
usage => my_command [ arg1, arg2 ],
topic => custom,
name => my_command,
command => sub {
my %input = @_;

local @ARGV = @{ $input{args} };
GetOptions( ... );
},
}
);


POE::Component::ControlPort->create(
local_address => 127.0.0.1,
local_port => 31337,

# optional...
hostname => pie.pants.org,
appname => my perl app,

commands => @commands,

poe_debug => 1,
);

# other poe sessions or whatever ...

POE::Kernel->run();

When building network applications, it is often helpful to have a network accessible control and diagnostic interface. This module provides such an interface for POE applications. By default, it provides a fairly limited set of commands but is easily extended to provide whatever command set you require. In addition, if POE::Component::DebugShell version 1.018 or above is installed, a set of POE debug commands will be loaded.

POE::Component::Client::Traceroute is a non-blocking traceroute client.

SYNOPSIS

use POE qw(Component::Client::Traceroute);

POE::Component::Client::Traceroute->spawn(
Alias => tracer, # Defaults to tracer
FirstHop => 1, # Defaults to 1
MaxTTL => 16, # Defaults to 32 hops
Timeout => 0, # Defaults to never
QueryTimeout => 3, # Defaults to 3 seconds
Queries => 3, # Defaults to 3 queries per hop
BasePort => 33434, # Defaults to 33434
PacketLen => 128, # Defaults to 68
SourceAddress => 0.0.0.0, # Defaults to 0.0.0.0
PerHopPostback => 0, # Defaults to no PerHopPostback
Device => eth0, # Defaults to undef
UseICMP => 0, # Defaults to 0
Debug => 0, # Defaults to 0
DebugSocket => 0, # Defaults to 0
);

sub some_event_handler
{
$kernel->post(
"tracer", # Post request to tracer component
"traceroute", # Ask it to traceroute to an address
"trace_response", # Post answers to trace_response
$destination, # This is the host to traceroute to
[
Queries => 5, # Override the global queries parameter
MaxTTL => 30, # Override the global MaxTTL parameter
Callback => [ $args ], # Data to send back with postback event
]
);
}

# This is the sub which is called with the responses from the
# Traceroute component.
sub trace_response
{
my ($request,$response) = @_[ARG0, ARG1];

my ($destination, $options, $callback) = @$request;
my ($hops, $data, $error) = @$response;

if ($hops)
{
print "Traceroute results for $destinationn";

foreach my $hop (@$data)
{
my $hopnumber = $hop->{hop};
my $routerip = $hop->{routerip};
my @rtts = @{$hop->{results}};

print "$hopnumbert$routeript";
foreach (@rtts)
{
if ($_ eq "*") { print "* "; }
else { printf "%0.3fms ", $_*1000; }
}
print "n";
}
}

warn "Error occurred tracing to $destination: $errorn" if ($error);
}

or

sub another_event_handler
{
$kernel->post(
"tracer", # Post request to tracer component
"traceroute", # Ask it to traceroute to an address
"trace_response", # Post answers to trace_response
$destination, # This is the host to traceroute to
[
# The trace_row event will get called after each hop
PerHopPostback => trace_row,
]
);
}

sub trace_row
{
my ($request,$response) = @_[ARG0, ARG1];

my ($destination, $options, $callback) = @$request;
my ($currenthop, $data, $error) = @$response;

# $data only contains responses for the current TTL
# The structure is the same as for trace_response above
}

POE::Component::Client::Traceroute is a non-blocking Traceroute client. It lets several other sessions traceroute through it in parallel, and it lets them continue doing other things while they wait for responses.

POE::Component::IRC is a fully event-driven IRC client module.

SYNOPSIS

# A simple Rot13 encryption bot

use strict;
use warnings;
use POE qw(Component::IRC);

my $nickname = Flibble . $$;
my $ircname = Flibble the Sailor Bot;
my $ircserver = irc.blahblahblah.irc;
my $port = 6667;

my @channels = ( #Blah, #Foo, #Bar );

# We create a new PoCo-IRC object and component.
my $irc = POE::Component::IRC->spawn(
nick => $nickname,
server => $ircserver,
port => $port,
ircname => $ircname,
) or die "Oh noooo! $!";

POE::Session->create(
package_states => [
main => [ qw(_default _start irc_001 irc_public) ],
],
heap => { irc => $irc },
);

$poe_kernel->run();
exit 0;

sub _start {
my ($kernel,$heap) = @_[KERNEL,HEAP];

# We get the session ID of the component from the object
# and register and connect to the specified server.
my $irc_session = $heap->{irc}->session_id();
$kernel->post( $irc_session => register => all );
$kernel->post( $irc_session => connect => { } );
undef;
}

sub irc_001 {
my ($kernel,$sender) = @_[KERNEL,SENDER];

# Get the components object at any time by accessing the heap of
# the SENDER
my $poco_object = $sender->get_heap();
print "Connected to ", $poco_object->server_name(), "n";

# In any irc_* events SENDER will be the PoCo-IRC session
$kernel->post( $sender => join => $_ ) for @channels;
undef;
}

sub irc_public {
my ($kernel,$sender,$who,$where,$what) = @_[KERNEL,SENDER,ARG0,ARG1,ARG2];
my $nick = ( split /!/, $who )[0];
my $channel = $where->[0];

if ( my ($rot13) = $what =~ /^rot13 (.+)/ ) {
$rot13 =~ tr[a-zA-Z][n-za-mN-ZA-M];
$kernel->post( $sender => privmsg => $channel => "$nick: $rot13" );
}
undef;
}

# We registered for all events, this will produce some debug info.
sub _default {
my ($event, $args) = @_[ARG0 .. $#_];
my @output = ( "$event: " );

foreach my $arg ( @$args ) {
if ( ref($arg) eq ARRAY ) {
push( @output, "[" . join(" ,", @$arg ) . "]" );
} else {
push ( @output, "$arg" );
}
}
print STDOUT join , @output, "n";
return 0;
}

POE::Component::IRC is a POE component (whod have guessed?) which acts as an easily controllable IRC client for your other POE components and sessions. You create an IRC component and tell it what events your session cares about and where to connect to, and it sends back interesting IRC events when they happen. You make the client do things by sending it events. Thats all there is to it. Cool, no?

[Note that using this module requires some familiarity with the details of the IRC protocol. Id advise you to read up on the gory details of RFC 1459 before you get started. Keep the list of server numeric codes handy while you program. Needless to say, youll also need a good working knowledge of POE, or this document will be of very little use to you.]
The POE::Component::IRC distribution has a docs/ folder with a collection of salient documentation including the pertinent RFCs.

POE::Component::IRC consists of a POE::Session that manages the IRC connection and dispatches irc_ prefixed events to interested sessions and an object that can be used to access additional information using methods.

Sessions register their interest in receiving irc_ events by sending register to the component. One would usually do this in your _start handler. Your session will continue to receive events until you unregister. The component will continue to stay around until you tell it not to with shutdown.

The SYNOPSIS demonstrates a fairly basic bot.