File Coverage

blib/lib/RPC/Serialized.pm

Criterion	Covered	Total	%
statement	67	70	95.7
branch	35	48	72.9
condition	17	42	40.4
subroutine	14	14	100.0
pod	2	3	66.6
total	135	177	76.2

package RPC::Serialized;
{
  $RPC::Serialized::VERSION = '1.123630';
}

use strict;
use warnings FATAL => 'all';

use base 'Class::Accessor::Fast::Contained';

use Readonly;
use Data::Serializer;
use RPC::Serialized::Config;
use RPC::Serialized::Exceptions;

__PACKAGE__->mk_ro_accessors(qw/
    debug
/);
__PACKAGE__->mk_accessors(qw/
    ds
    ifh ofh
/);

# this is the record separator in our data stream,
# used if debug is enabled
Readonly my $TERMINATOR => '...';

sub new {
    my $class  = shift;
    my $params = RPC::Serialized::Config->parse(@_);

    throw_app 'Missing or invalid input handle'
        if exists $params->me->{ifh}
        and ! _is_valid_input_handle( $params->me->{ifh} );

    throw_app 'Missing or invalid output handle'
        if exists $params->me->{ofh}
        and ! _is_valid_output_handle( $params->me->{ofh} );

    $params->me->{ofh}->autoflush(1) if exists $params->me->{ofh};
    $params->me->{ds} = Data::Serializer->new($params->data_serializer);

    return $class->SUPER::new({ $params->me });
}

sub _is_valid_handle {
    my $h = shift;
    return 1
        if defined $h
        and ref $h
        and $h->can('error');
    return 0;
}

sub _is_valid_input_handle {
    my $h = shift;
    return 1
        if _is_valid_handle($h)
        and $h->can('getline')
        and $h->can('eof');
    return 0;
}

sub _is_valid_output_handle {
    my $h = shift;
    return 1
        if _is_valid_handle($h)
        and $h->can('print')
        and $h->can('autoflush')
        and $h->can('error');
    return 0;
}

sub send {
    my $self = shift;
    my $data = shift;

    throw_proto 'Data not a hash reference'
        unless ref($data) eq 'HASH';

    my $io = $self->ofh;

    if ($self->debug) {
        my $send_data = $self->ds->raw_serialize($data);
        $io->print( $send_data .
                ($send_data =~ m/\n$/ ? '' : "\n") . "$TERMINATOR\n" )
            and not $io->error
            or throw_system "Failed to send data: $!";
    }
    else {
        $io->print( $self->ds->serialize($data) . "\n" )
            and not $io->error
            or throw_system "Failed to send data: $!";
    }
}

sub recv {
    my $self = shift;
    my $data = '';
    my $io   = $self->ifh;

    if ($self->debug) {
        while ( $_ = $io->getline and not $io->error ) {
            last if /^\Q$TERMINATOR\E$/o;
            $data .= $_;
        }
    }
    else {
        $data = $io->getline;
    }

    throw_system "Failed to read data: $!"
        if $io->error;

    chomp $data if defined $data;
    return unless defined($data) && length($data);

    my @token = ();
    eval {
        if ($self->debug) {
            $data = $self->ds->raw_deserialize($data);
        }
        else {
            my $token = $self->ds->_get_token($data);
            @token = $self->ds->_extract_token($token) if defined $token;

            $data = $self->ds->deserialize($data);
        }
    };
    throw_proto "Data::Serializer error: $@"
        if $@;

    throw_proto 'Serializer parse error'
        if !defined $data or $data == 1;

    throw_proto 'Data not a hash reference'
        if ref($data) ne 'HASH';

    return (wantarray
        ? ($data, @token)
        : $data);
}

sub DESTROY {
    my $self = shift;
    $self->ifh->close if $self->ifh;
    $self->ofh->close if $self->ofh;
}

1;

# ABSTRACT: Subroutine calls over the network using common serialization


# Here are some of the less common error messages. When more time is available
# these will be futher documented:
#
# =over 4
#
# =item C in an C
#
# The authorization scheme loaded has refused to permit the current subject to
# make the current call.
#
# =item C in an C
#
# The C server will look for the C environment
# variable, if authorization is enabled. See the C documentation for
# details if you don't know how to enable this.
#
# =item C in an C
#
# The C server will look for the C environment
# variable, if authorization is enabled. See the  documentation for
# details if you don't know how to enable this.
#
# =item C in an C
#
# The C server failed to get the username for the calling user. Only
# happens if authorization has been enabled.
#
# =item C in an C
#
# Server authorization is enabled but the specified handler does not inherit
# from L.
#
# =item C in an C
#
# =item C in an C
#
# =item C in an C
#
# =item C in an C
#
# =item C in an C
#
# =item C in an C
#
# =item C in an C
#
# =item C in an C
#
# =item C in an C
#
# =item C in an C
#
# =item C in an C
#
# =item C in an C
#
# =item C in an C
#
# =back


__END__