use POE;
POE::Session->create(
    inline_states => {
    _start  => \&start,
    hello   => \&hello,
    },
);

print "Uruchamiam jdro\n";
$poe_kernel->run(  );
print "Kocz\n";
exit(0);

sub start {
    my ($kernel) = $_[KERNEL];
    print "Przygotowuj sesj\n";
    $kernel->yield("hello");
}

sub hello { print "Hello, world\n"; }
---------------------------------
use POE; 
print "Uruchamiam jdro\n"; 
$poe_kernel->run(  ); 
print "Kocz\n"; 
exit(0);
---------------------------------
POE::Session->create(
    inline_states => {
    _start  => \&start,
    hello   => \&hello,
    },
);
---------------------------------
sub start {
    my ($kernel) = $_[KERNEL];
    print "Przygotowuj sesj\n";
    $kernel->yield("hello");
}

sub hello { print "Hello, world\n"; }
---------------------------------
my ($kernel, $heap, $session) = @_[KERNEL, HEAP, SESSION];
---------------------------------
$kernel->yield("hello");
---------------------------------
sub hello { 
    my ($kernel) = $_[KERNEL];
    print "Hello, world!\n";
    sleep 5;
    $kernel->yield("hello");
}
---------------------------------
sub hello {
    my ($kernel) = $_[KERNEL];
    print "Hello, world!\n";
    $kernel->delay_set("hello", 5);
}
---------------------------------
use POE;

for my $session_no (1..2) {
  POE::Session->create(
    inline_states => {
      hello => \&hello,
      _start => sub { $_[KERNEL]->alias_set("session_" . $session_no) },
  });
}

$poe_kernel->post("session_1", "hello", "session_2");
$poe_kernel->run(  );
exit(0);

sub hello {
  my ($kernel, $session, $next) = @_[KERNEL, SESSION, ARG0];
  print "Event in ", $kernel->alias_list($session), "\n";
  $kernel->post($next, "hello", $session->ID);
}
---------------------------------
print "Zdarzenie w sesji ", $kernel->alias_list($session), "\n";
---------------------------------
$poe_kernel->post("session_1", "hello", "session_2");
---------------------------------
my ($kernel, $session, @args) = @_[KERNEL, SESSION, ARG0..$#_];
---------------------------------
$kernel->post($next, "hello", $session->ID);
---------------------------------
Zdarzenie w sesji session_1
Zdarzenie w sesji session_2
Zdarzenie w sesji session_1
Zdarzenie w sesji session_2

...
---------------------------------
use POE qw(Wheel::FollowTail);

POE::Session->create(
  inline_states => {
     _start => sub {
        my ($heap) = $_[HEAP];
        my $log_watcher = POE::Wheel::FollowTail->new(
            Filename => "my_log_file.txt",
            InputEvent => "got_record",
        );

        $heap->{watcher} = $log_watcher;
     },
     got_record => sub { my $record = $_[ARG0]; print $record,"\n"; }
  }
);

$poe_kernel->run(  );
---------------------------------
my $log_watcher = POE::Wheel::FollowTail->new(
            Filename => "my_log_file.txt",
            InputEvent => "got_record",
        );
---------------------------------
        my ($heap) = $_[HEAP];
        . . .
        $heap->{watcher} = $log_watcher;
---------------------------------
use POE qw(Wheel::FollowTail Wheel::Run);

POE::Session->create(
  inline_states => {
     _start => sub {
        my ($heap) = $_[HEAP];
        my $log_watcher  = POE::Wheel::FollowTail->new(
            Filename     => "my_log_file.txt",
            InputEvent   => "redirect",
        );
        my $dumper = POE::Wheel::Run->new(
            Program      => "/usr/bin/hexdump",
            StdoutEvent  => "print"
        );

        $heap->{watcher} = $log_watcher;
        $heap->{dumper}  = $dumper;
     },
     redirect => sub {
        my ($heap, $data) = @_[HEAP, ARG0];
        $heap->{dumper}->put($data);
     },
     print => sub { my $record = $_[ARG0]; print $record, "\n"; }
  }
);
---------------------------------
Przypis:
my $i = -16;
binmode(STDIN);
my $data; $|++;
printf "%07x ". ("%02x%02x "xb)."\n", $i++16, map ord, split//,$data
    while read STDIN, $data, 16;
---------------------------------
        my $dumper = POE::Wheel::Run->new(
            Program      => "/usr/bin/hexdump",
            Conduit      => "pty",
            StdoutEvent  => "print"
        );
---------------------------------
    my $office = shift;

    my ($local_address, $local_port, $remote_address, $remote_port);
    ($office ? $remote_address : $local_address) = "mybox.real-world.int";
    ($office ? $local_port     : $remote_port)   = 6667;
    ($office ? $remote_port    : $local_port)    = 80;

    if ($office) { 
       $local_address = "127.0.0.1";
    } else {
       $remote_address = "irc.perl.org";
    }

    POE::Session->new
      ( _start => \&server_start,
        client_connected => \&client_connected,
        [ $local_address, $local_port, $remote_address, $remote_port ]
      );
   $poe_kernel->run;
---------------------------------
sub server_start {
    my ( $heap, $local_addr, $local_port, $remote_addr, $remote_port )
    = @_[ HEAP, ARG0,        ARG1,        ARG2,         ARG3 ];

    # Zapisujemy nasze parametry
    $heap->{local_addr}  = $local_addr;
    $heap->{local_port}  = $local_port;
    $heap->{remote_addr} = $remote_addr;
    $heap->{remote_port} = $remote_port;

    # Tworzymy i zachowujemy koo
    $heap->{server_wheel} = POE::Wheel::SocketFactory->new
      ( BindAddress  => $local_addr,
        BindPort     => $local_port,
        Reuse        => 'yes',
        SuccessEvent => 'client_connected'
      );
}
---------------------------------
sub client_connected {
    my ( $heap, $socket, $peer_addr, $peer_port ) = 
      @_[ HEAP,  ARG0,    ARG1,       ARG2];
}
---------------------------------
sub accept {
    my ( $heap, $socket, $peer_addr, $peer_port ) = 
      @_[ HEAP,  ARG0,    ARG1,       ARG2];
    
    POE::Session->new
      ( _start => \&forwarder_start,
        server_connect => \&connected_to_other_side,

        client_input   => \&forward_outbound,
        server_input   => \&forward_inbound,

        [ $socket, $peer_addr, $peer_port,
          $heap->{remote_addr}, $heap->{remote_port} ]
      );
}
---------------------------------
sub forwarder_start {
    my ( $heap, $session,
        $socket, $peer_host, $peer_port, $remote_addr, $remote_port
      ) =
      @_[ HEAP, SESSION, ARG0, ARG1, ARG2, ARG3, ARG4 ];

    $heap->{qw(peer_host    peer_port   remote_addr   remote_port)} = 
              ($peer_host, $peer_port, $remote_addr, $remote_port);

    $heap->{wheel_client} = POE::Wheel::ReadWrite->new
      ( Handle => $socket,
        Filter     => POE::Filter::Stream->new,
        InputEvent => 'client_input',
      );

    $heap->{wheel_server} = POE::Wheel::SocketFactory->new
      ( RemoteAddress => $remote_addr,
        RemotePort   => $remote_port,
        SuccessEvent => 'server_connect',
      );
}
---------------------------------
    $heap->{state} = 'connecting';
    $heap->{queue} = [  ];
---------------------------------
sub forward_outbound {
    my ( $heap, $input ) = @_[ HEAP, ARG0 ];

    if ( $heap->{state} eq 'connecting' ) {
        push @{ $heap->{queue} }, $input;
    }
    else {
        $heap->{wheel_server}->put($input);
    }
}
---------------------------------
sub connected_to_other_side {
    my ( $kernel, $session, $heap, $socket ) = @_[ KERNEL, SESSION,
HEAP, ARG0
];

    $heap->{wheel_server} = POE::Wheel::ReadWrite->new
      ( Handle => $socket,
        Driver     => POE::Driver::SysRW->new,
        Filter     => POE::Filter::Stream->new,
        InputEvent => 'server_input',
      );
}
---------------------------------
    $heap->{state} = 'connected';
    foreach my $pending ( @{ $heap->{queue} } ) {
        $kernel->call( $session, 'client_input', $pending );
    }
    $heap->{queue} = [  ];
---------------------------------
my ( $heap, $input ) = @_[ HEAP, ARG0 ];
$heap->{wheel_client}->put($input);
---------------------------------
POE::Component::Server::TCP->new(
    Port => 6667,
    ClientConnected => \&spawn_client_side,
    ClientInput => sub {
        my ( $kernel, $heap, $input ) = @_[ KERNEL, HEAP,  ARG0 ];
        $kernel->post( $heap->{client_id} => send_stuff => $input );
    },
    InlineStates => {
        _child => sub {
            my ( $heap, $child_op, $child ) = @_[ HEAP, ARG0, ARG1 ];
            $heap->{client_id} = $child->ID
             if $child_op eq "create";
        },
        send_stuff => sub {
            my ( $heap, $stuff ) = @_[ HEAP, ARG0 ];
            $heap->{client}->put($stuff);
        }
    },
);
---------------------------------
sub spawn_client_side {
    POE::Component::Client::TCP->new(
        RemoteAddress => 'mybox.real-world.int',
        RemotePort    => 80,

        Started => sub { $_[HEAP]->{server_id} = $_[SENDER]->ID; },
        ServerInput => sub {
            my ( $kernel, $heap, $input ) = @_[ KERNEL, HEAP, SESSION, ARG0 ];
            $kernel->post( $heap->{server_id} => send_stuff => $input );
        },

        InlineStates => {
            send_stuff => sub {
                my ( $heap, $stuff ) = @_[ HEAP, ARG0 ];
                $heap->{server}->put($stuff);
            },
        },
    );
}
---------------------------------
use strict;
use POE::Component::Server::HTTP;
use POE;

my $datadir = "/Users/simon/";
POE::Component::Server::HTTP->new(
    ContentHandler => { '/' => \&callback }, 
    Port => 8000
);  
$poe_kernel->run;
---------------------------------
use URI::Escape;
use HTTP::Headers;
use File::Spec::Functions;
use File::MMagic;

sub callback {
    my ($request, $response) = @_;
    my $path = catfile($datadir,canonpath(uri_unescape($request->uri->path)));

    return error($response, $request, RC_NOT_FOUND) unless -e $path;
    return error($response, $request, RC_FORBIDDEN) unless open OUT, $path;

    $response->code(RC_OK);
    my $magic = File::MMagic->new(  );
    $response->push_header("Content-type", $magic->checktype_filename($path));
    local $/; $response->content(scalar <OUT>);
    close OUT;
    return $response;
}
---------------------------------
my $path = catfile($datadir,canonpath(uri_unescape($request->uri->path)));
---------------------------------
return error($response, $request, RC_NOT_FOUND) unless -e $path;
return error($response, $request, RC_FORBIDDEN) unless open OUT, $path;
---------------------------------
$response->push_header("Content-type", $magic->checktype_filename($path));
---------------------------------
local $/; $response->content(scalar <OUT>);
close OUT;
return $response;
---------------------------------
sub not_found {
    my ($response, $request, $code) = @_;
    my $uri = $request->uri;
    my $message = status_message($code);
    my $explanation = $code =  = RC_FORBIDDEN ? "accessible" : "found";
    $response->code($code);
    $response->push_header("Content-type", "text/html");
    $response->content(<<EOF);
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<HTML><HEAD>
<TITLE>$code $message</TITLE>
</HEAD><BODY>
<H1>$message</H1>
The requested URL $uri was not $explanation on this server.<P>
</BODY></HTML>
EOF
    return $response;
}
---------------------------------
use XML::RSS::Feed::Factory;

my @feeds = feed_factory(
    {   url => "http://slashdot.org/slashdot.rss",
       name => "Slashdot",
      delay => 60 },
    {   url => "http://blog.simon-cozens.org/blosxom.cgi/xml",
       name => "Simon Cozens",
      delay => 60 },
    {   url => "http://use.perl.org/perl-news-short.rdf",
       name => "Perl news",
      delay => 60 }
);
---------------------------------
my $aggie = POE::Component::RSSAggregator->new(
               feeds    => \@feeds,
               callback => \&new_headlines
);
POE::Kernel->run;
---------------------------------
sub new_headlines {
    my ($feed) = shift;
    return unless my @newnews = $feed->late_breaking_news;
    for my $headline (@newnews) {
         print $headline->headline . ": " . $headline->url . "\n";
    }
}
---------------------------------
