File Coverage

blib/lib/POE/Component/SmokeBox/Recent/HTTP.pm

Criterion	Covered	Total	%
statement	99	111	89.1
branch	14	28	50.0
condition	10	24	41.6
subroutine	19	20	95.0
pod	1	1	100.0
total	143	184	77.7

package POE::Component::SmokeBox::Recent::HTTP;
$POE::Component::SmokeBox::Recent::HTTP::VERSION = '1.50';
#ABSTRACT: an extremely minimal HTTP client

use strict;
use warnings;
use POE qw(Filter::HTTP::Parser Component::Client::DNS);
use Net::IP::Minimal qw(ip_get_version);
use Test::POE::Client::TCP;
use Carp qw(carp croak);
use HTTP::Request;
use URI;

sub spawn {
  my $package = shift;
  my %opts = @_;
  $opts{lc $_} = delete $opts{$_} for keys %opts;
  croak( "You must provide the 'uri' parameter and it must a URI object and a supported scheme\n" )
	unless $opts{uri} and $opts{uri}->isa('URI')
	and $opts{uri}->scheme and $opts{uri}->scheme =~ /^http$/
	and $opts{uri}->host;
  my $options = delete $opts{options};
  $opts{prefix} = 'http_' unless $opts{prefix};
  $opts{prefix} .= '_' unless $opts{prefix} =~ /\_$/;
  my $self = bless \%opts, $package;
  $self->{session_id} = POE::Session->create(
    object_states => [
	$self => { map { ($_,"_$_" ) } qw(web_socket_failed web_connected web_input web_disconnected) },
	$self => [qw(
		_start
		_resolve
		_response
		_connect
		_shutdown
		_timeout
	)],
     ],
     heap => $self,
     ( ref($options) eq 'HASH' ? ( options => $options ) : () ),
  )->ID();
  return $self;
}

sub _start {
  my ($kernel,$sender,$self) = @_[KERNEL,SENDER,OBJECT];
  $self->{session_id} = $_[SESSION]->ID();
  if ( $kernel == $sender and !$self->{session} ) {
	croak "Not called from another POE session and 'session' wasn't set\n";
  }
  my $sender_id;
  if ( $self->{session} ) {
    if ( my $ref = $kernel->alias_resolve( $self->{session} ) ) {
	$sender_id = $ref->ID();
    }
    else {
	croak "Could not resolve 'session' to a valid POE session\n";
    }
  }
  else {
    $sender_id = $sender->ID();
  }
  $kernel->refcount_increment( $sender_id, __PACKAGE__ );
  $self->{sender_id} = $sender_id;

  $self->{_resolver} = POE::Component::Client::DNS->spawn(
	Alias => 'Resolver-' . $self->{session_id},
  );

  $self->{address} = $self->{uri}->host;
  $self->{port}    = $self->{uri}->port;

  $kernel->yield( '_resolve' );
  return;
}

sub _resolve {
  my ($kernel,$self) = @_[KERNEL,OBJECT];
  if ( ip_get_version( $self->{address} ) ) {
     # It is an address already
     $kernel->yield( '_connect', $self->{address} );
     return;
  }
  my $resp = $self->{_resolver}->resolve(
     host 	=> $self->{address},
     context 	=> { },
     event	=> '_response',
  );
  $kernel->yield( '_response', $resp ) if $resp;
  return;
}

sub _response {
  my ($kernel,$self,$resp) = @_[KERNEL,OBJECT,ARG0];
  if ( $resp->{error} and $resp->{error} ne 'NOERROR' ) {
     $kernel->yield( 'web_socket_failed', $resp->{error} );
     return;
  }
  my @answers = $resp->{response}->answer;
  foreach my $answer ( $resp->{response}->answer() ) {
     next if $answer->type !~ /^A/;
     $kernel->yield( '_connect', $answer->rdatastr );
     return;
  }
  $kernel->yield( 'web_socket_failed', 'Could not resolve address' );
  return;
}

sub _connect {
  my ($self,$address) = @_[OBJECT,ARG0];
  $self->{web} = Test::POE::Client::TCP->spawn(
	address     => $address,
	port        => $self->{port} || 80,
	prefix      => 'web',
	autoconnect => 1,
	filter	    => POE::Filter::HTTP::Parser->new( type => 'client' ),
  );
  return;
}

sub _web_connected {
  my $self = $_[OBJECT];
  my $req = HTTP::Request->new( GET => $self->{uri}->path );
  $req->protocol( 'HTTP/1.1' );
  $req->header( 'Host', $self->{address} . ( $self->{port} ne '80' ? ":$self->{port}" : '' ) );
  $req->user_agent( sprintf( 'POE-Component-SmokeBox-Recent-HTTP/%s (perl; N; POE; en; rv:%f)', $POE::Component::SmokeBox::Recent::HTTP::VERSION, $POE::Component::SmokeBox::Recent::HTTP::VERSION ) );
  $self->{web}->send_to_server( $req );
  $poe_kernel->delay( '_timeout', $self->{timeout} || 60 );
  return;
}

sub _timeout {
  my ($kernel,$self) = @_[KERNEL,OBJECT];
  $self->_send_event( $self->{prefix} . 'timeout', "Timed out connection after " . ( $self->{timeout} || 60 ) . " seconds." );
  $kernel->refcount_decrement( $self->{sender_id}, __PACKAGE__ );
  $kernel->yield( '_shutdown' );
  return;
}

sub _web_socket_failed {
  my ($kernel,$self,@errors) = @_[KERNEL,OBJECT,ARG0..$#_];
  $self->_send_event( $self->{prefix} . 'sockerr', @errors );
  $kernel->refcount_decrement( $self->{sender_id}, __PACKAGE__ );
  $kernel->yield( '_shutdown' );
  return;
}

sub _web_input {
  my ($kernel,$self,$resp) = @_[KERNEL,OBJECT,ARG0];
  $kernel->delay( '_timeout' );
  $self->_send_event( $self->{prefix} . 'response', $resp );
  $kernel->refcount_decrement( $self->{sender_id}, __PACKAGE__ );
  $self->{web}->shutdown();
  delete $self->{web};
  return;
}

sub _web_disconnected {
  my ($kernel,$self) = @_[KERNEL,OBJECT];
  $kernel->yield( '_shutdown' );
  return;
}

sub _send_event {
  my $self = shift;
  $poe_kernel->post( $self->{sender_id}, @_ );
  return;
}

sub _shutdown {
  my $self = $_[OBJECT];
  $poe_kernel->delay( '_timeout' );
  $self->{web}->shutdown() if $self->{web};
  $self->{_resolver}->shutdown() if $self->{_resolver};
  delete $self->{web};
  delete $self->{_resolver};
  return;
}

'Get me that file, sucker'

__END__