Free component to software for linux

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.

Simple components for Ada library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
As a special exception, if other files instantiate generics from this unit, or you link this unit with other files to produce an executable, this unit does not by itself cause the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the executable file might be covered by the GNU Public License.
Enhancements:
- Functions Is_In were added for doubly-linked webs and lists. GPS project files were added for GNAT users.

POE::Component::Enc::Mp3 is a mp3 encoder wrapper.

SYNOPSIS

use POE qw(Component::Enc::Mp3);

$mp3 = POE::Component::Enc::Mp3->new($bitrate => 160);

$mp3->enc("/tmp/tst.wav");

POE::Kernel->run();

This POE component encodes raw audio files into mp3 format. It is merely a wrapper for the notlame program.

METHODS

The module provides an object oriented interface as follows:

new

Used to initialise the system and create a module instance. The following parameters are available:

alias

Indicates the name of a session to which module callbacks are posted. Default: main.

bitrate

Should be self-evident. If left unspecified, defaults to 160.

enc < file-name > [del-orig]

Encodes the given file, naming it with a .mp3 extension. An optional true value for the second parameter indicates that the original file should be deleted.

e.g. $mp3->enc("/tmp/tst.wav");

POE::Component::Enc::Flac is a POE component to wrap FLAC encoder flac.

SYNOPSIS

use POE qw(Component::Enc::Flac);

$encoder1 = POE::Component::Enc::Flac->new();
$encoder1->enc(input => "/tmp/track03.wav");

$encoder2 = POE::Component::Enc::Flac->new(
parent => mainSession,
priority => 10,
compression => best,
status => flacStatus,
error => flacEerror,
warning => flacWarning,
done => flacDone,
);
$encoder2->enc(
input => "/tmp/track02.wav",
output => "/tmp/02.flac",
tracknumber => Track 2,
comment => [
title=Birdhouse in your Soul,
artist=They Might be Giants,
date=1990,
origin=CD,
]
);

POE::Kernel->run();

ABSTRACT

POE is a multitasking framework for Perl. FLAC stands for Free Lossless Audio Codec and flac is an encoder for this standard. This module wraps flac into the POE framework, simplifying its use in, for example, a CD music ripper and encoder application. It provides an object oriented interface.

POE::Component::Basement provides Class::Std and base POE component functionality.

SYNOPSIS

package POE::MyComponent;

# use as base
use base qw/ POE::Component::Basement /;

# where the initializations happen (see Class::Std)
sub BUILD { ... }

# see also Class::Std and Class::Data::Inheritable also
# for accessor creation etc.

# define states
sub state_one : State( :inline< _start > ) { ... }
sub state_two : State( :object< foo > ) { ... }
sub state_three : State( :package< bar > ) { ... }

# combined
sub state_multi : State( :inline< foobar > :package< snafoo > ) { ... }
...

# chained events
sub first : State( :object< foo > :chained< bar > ) { ... }
sub second : State( :object< bar > ) { ... }
...

# calling in a row
sub first : State( :object< foo > :next< bar > ) { ... }
sub second : State( :object< bar > ) { ... }
...

# usage
my $comp = POE::MyComponent->new ({

# single alias or array reference for multiple
aliases => [qw/ mycomp shub_niggurath /],

... # your specific init_args.
});

Provides Class::Std and base POE component functionality. This module is still kinda experimental.

POE::Component::Proxy::TCP is a simplified TCP proxy.

SYNOPSIS

use POE qw(Component::Proxy::TCP);
POE::Component::Proxy::TCP->new
(Alias => "ProxyServerSessionAlias",
Port => $local_server_port,
OrigPort => $remote_server_port,
OrigAddress => $remote_server_host,
DataFromClient => &data_from_client_handler,
DataFromServer => &data_from_server_handler,
);


# gets called with data passed from server.
# called inside the per client connected session created by PoCo::Server::TCP
sub data_from_server_handler {
my $server_data = shift;
# show obtaining other session info esp per proxy session info
};

# gets called with data passed from remote client
#
sub data_from_client_handler {
my $server_data = shift;
};

# show obtaining other session info esp per proxy session info
# Reserved HEAP variables:

$heap->{self} = Proxy object / instance var hash
$heap->{self}->losta stuff add documentation
[do the per connection ones]
EXAMPLE ^
use warnings;
use strict;
use diagnostics;
use POE;
use POE::Filter::Stream;
use POE::Filter::Line;
use POE::Component::Proxy::TCP;
$|++;

POE::Component::Proxy::TCP->new
(Alias => "ProxyServerSessionAlias",
Port => 4000,
OrigPort => 5000,
OrigAddress => "localhost",
DataFromClient => sub {print "From client:", shift(), "n";},
DataFromServer => sub {print "From server:", shift(), "n";},
RemoteClientFilter => "POE::Filter::Stream",
RemoteServerOutputFilter => "POE::Filter::Stream",
RemoteServerInputFilter => "POE::Filter::Stream"
);

$poe_kernel->run();
exit 0;

POE::Component::Proxy::MSN is a POE Component that is an MSN Messenger proxy.

SYNOPSIS

use POE qw(Component::Proxy::MSN);

# spawn MSN session
POE::Component::Proxy::MSN->spawn(
alias => msnproxy, # Optional, default
ip => any, # Optional, ip to bind to or any (default)
port => 1863, # Optional, default
msn_server => 207.46.106.79, # Server to connect to, not optional
msn_port => 1863, # Just leave this at 1863, not optional
);

# register your session as MSN proxy observer in _start of a new session
POE::Session->create(
inline_states => {
_start => sub {
$_[KERNEL]->post(msnproxy => register);
}
msn_logged_in => sub {
my ($kernel, $cmd) = @_[KERNEL, ARG0];
# tell them they are on the proxy, this is called when they log in
if ($cmd->{data} =~ m/(S+@S+)/) {
$kernel->post(msnproxy => toast => {
text => "MSN Proxy Active",
site_url => http://teknikill.net/?MSNProxy,
action_url => /,
options_url => /,
# not speciying email will toast all users
email => $1, # email targets a specific user that is logged in
});
}
},
}
);

$poe_kernel->run;

POE::Component::Proxy::MSN is a POE component that proxys the MSN Messenger service and allows you to send your own notifications (toasts).

POE::Component::SubWrapper is an event based wrapper for subs.
SYNOPSIS
use POE::Component::SubWrapper;
POE::Component::SubWrapper->spawn(main);
$kernel->post(main, my_sub, [ $arg1, $arg2, $arg3 ], callback_state);
This is a module which provides an event based wrapper for subroutines.
SubWrapper components are not normal objects, but are instead spawned as separate sessions. This is done with with PoCo::SubWrappers spawn method, which takes one required and one optional argument. The first argument is the package name to wrap. This is required. The second argument is optional and contains an alias to give to the session created. If no alias is supplied, the package name is used as an alias.
Another way to create SubWrapper components is to use the poeize method, which is included in the default export list of the package. You can simply do:
poeize Data::Dumper;
and Data::Dumper will be wrapped into a session with the alias Data::Dumper.
When a SubWrapper component is created, it scans the package named for subroutines, and creates one state in the session created with the same name of the subroutine.
The states each accept 3 arguments:
- An arrayref to a list of arguments to give the subroutine.
- A state to callback with the results.
- A string, either SCALAR, or ARRAY, allowing you to decide which context the function handled by this state will be called in.
The states all call the function with the name matching the state, and give it the supplied arguments. They then postback the results to the named callback state. The results are contained in ARG0 and are either a scalar if the function was called in scalar context, or an arrayref of results if the function was called in list context.