view release on metacpan or  search on metacpan

lib/Mojo/Transaction.pm  view on Meta::CPAN

package Mojo::Transaction;
use Mojo::Base 'Mojo::EventEmitter';

use Carp       qw(croak);
use List::Util qw(any);
use Mojo::Message::Request;
use Mojo::Message::Response;
use Mojo::Util qw(network_contains);

has [qw(kept_alive local_address local_port original_remote_address remote_port)];
has req => sub { Mojo::Message::Request->new };
has res => sub { Mojo::Message::Response->new };

sub client_read  { croak 'Method "client_read" not implemented by subclass' }
sub client_write { croak 'Method "client_write" not implemented by subclass' }

sub closed { shift->completed->emit('finish') }

sub completed { ++$_[0]{completed} and return $_[0] }

sub connection {
  my $self = shift;
  return $self->emit(connection => $self->{connection} = shift) if @_;
  return $self->{connection};
}

sub error { $_[0]->req->error || $_[0]->res->error }

sub is_finished { !!shift->{completed} }

sub is_websocket {undef}

sub remote_address {
  my $self = shift;

  return $self->original_remote_address(@_) if @_;
  return $self->original_remote_address unless $self->req->reverse_proxy;

  # Reverse proxy
  my @addrs   = split /\s*,\s*/, ($self->req->headers->header('X-Forwarded-For') // '');
  my $trusted = $self->req->trusted_proxies;
  return @addrs ? $addrs[-1] : $self->original_remote_address unless @$trusted;

  push @addrs, $self->original_remote_address;
  for my $addr (reverse @addrs) {
    return $addr unless any { network_contains($_, $addr) } @$trusted;
  }
  return $addrs[0];
}

sub result {
  my $self = shift;
  my $err  = $self->error;
  return !$err || $err->{code} ? $self->res : croak $err->{message};
}

sub server_read  { croak 'Method "server_read" not implemented by subclass' }
sub server_write { croak 'Method "server_write" not implemented by subclass' }

1;

=encoding utf8

=head1 NAME

Mojo::Transaction - Transaction base class

=head1 SYNOPSIS

  package Mojo::Transaction::MyTransaction;
  use Mojo::Base 'Mojo::Transaction';

  sub client_read  {...}
  sub client_write {...}
  sub server_read  {...}
  sub server_write {...}

=head1 DESCRIPTION

L<Mojo::Transaction> is an abstract base class for transactions, like L<Mojo::Transaction::HTTP> and
L<Mojo::Transaction::WebSocket>.

=head1 EVENTS

L<Mojo::Transaction> inherits all events from L<Mojo::EventEmitter> and can emit the following new ones.

=head2 connection

  $tx->on(connection => sub ($tx, $connection) {...});

Emitted when a connection has been assigned to transaction.

=head2 finish

  $tx->on(finish => sub ($tx) {...});

Emitted when transaction is finished.

=head1 ATTRIBUTES