File Coverage

blib/lib/POE/Component/IRC/Plugin/FTP/EasyUpload.pm

Criterion	Covered	Total	%
statement	18	70	25.7
branch	0	30	0.0
condition			n/a
subroutine	6	15	40.0
pod	1	5	20.0
total	25	120	20.8

package POE::Component::IRC::Plugin::FTP::EasyUpload;

use warnings;
use strict;

our $VERSION = '0.002';

use Carp;
use POE qw(Component::Net::FTP);
use Devel::TakeHashArgs;
use POE::Component::IRC::Plugin qw( :ALL );

sub new {
    my $class = shift;
    get_args_as_hash( \@_, \ my %args, {
            port            => 21,
            timeout         => 30,
            pub_uri         => '',
            retries         => 5,
            verbose_error   => 1,
            tag             => qr//,
        },
        [ qw(host login pass) ],
        [
            qw( host  login  pass  obj_args  timeout  pub_uri  debug
                retries  tag  port  verbose_error unique
            )
        ],
    ) or croak $@;


    $args{pub_uri} = $args{host}
        unless defined $args{pub_uri};

    my $self = bless \%args, $class;

    return $self;
}

sub PCI_register {
    my ($self, $irc) = @_;

    $self->{irc} = $irc;

    $irc->plugin_register( $self, 'USER', qw(privmsg notice) );

    $self->{session_id} = POE::Session->create(
        object_states => [
            $self => [qw(_start  _processed  _shutdown)],
        ],
    )->ID();

    return 1;
}

sub U_privmsg { my $self = shift; $self->_process( @_ ); }
sub U_notice  { my $self = shift; $self->_process( @_ ); }

sub _process {
    my ( $self, $irc, $out_ref ) = @_;
    $self->{debug}
        and carp "OUT: $$out_ref";


    if ( my ( $file, $dir, $prefix ) = $$out_ref =~ /$self->{tag}/ ) {
        $prefix = ''
            unless defined $prefix;

        $self->{debug}
            and carp "[ file => $file, dir => $dir, prefix => $prefix ]";

        $self->{poco}->process( {
                event       => '_processed',
                session     => $self->{session_id},
                _out        => $$out_ref,
                _try        => 0,
                _prefix     => $prefix,
                commands    => [
                   { new => [
                            $self->{host},
                            Timeout => $self->{timeout},
                            Port    => $self->{port},
                            @{ $self->{obj_args} || [] },
                        ],
                   },
                   { login  => [ $self->{login}, $self->{pass} ] },

                   defined $dir ? ( { cwd => [ $dir ] } ) : (),

                   $self->{unique} ? { put_unique => [ $file ] }
                                   : { put => [ $file ] },
                ],
            },
        );

        return PCI_EAT_ALL;
    }
    return PCI_EAT_NONE;
}

sub _processed {
    my ( $kernel, $self, $in_ref ) = @_[ KERNEL, OBJECT, ARG0 ];
    my $out_message;
    if ( $in_ref->{is_error} ) {
        $self->{debug}
            and carp "FTP error on $in_ref->{error} command: "
                        . $in_ref->{last_error};

        if ( $self->{retries} < $in_ref->{_try}++ ) {
            $self->{debug}
                and carp "Retring after error [retry # $in_ref->{_try}]";

            delete @$in_ref{ qw(error responses) };
            $self->{poco}->process( $in_ref );
            return;
        }
        $in_ref->{last_error} =~ s/\n|\r//g;
        $out_message = $self->{verbose_error}
                        ? "[FTP Error: $in_ref->{last_error}]"
                        : '[FTP Error]';
    }
    else {
        $out_message = $self->{pub_uri}
                            . $in_ref->{_prefix}
                            . $in_ref->{responses}[-1][0];
    }
    $in_ref->{_out} =~ s/$self->{tag}/$out_message/g;
    $kernel->post( $self->{irc} => quote => $in_ref->{_out} );
    return;
}

sub PCI_unregister {
    my ($self, $irc) = @_;
    $poe_kernel->call( $self->{session_id} => '_shutdown' );
    delete $self->{irc};

    return 1;
}

sub _start {
    my ( $kernel, $self ) = @_[KERNEL, OBJECT];
    $self->{session_id} = $_[SESSION]->ID();
    $kernel->refcount_increment( $self->{session_id}, __PACKAGE__ );

    $self->{poco} = POE::Component::Net::FTP->spawn(
        $self->{debug} ? ( debug => $self->{debug} ) : ()
    );

    return;
}

sub _shutdown {
    my ( $kernel, $self ) = @_[KERNEL, OBJECT];
    $self->{poco}->shutdown;
    $kernel->alarm_remove_all();
    $kernel->refcount_decrement( $self->{session_id}, __PACKAGE__ );

    return;
}

1;
__END__