File Coverage

blib/lib/JSON/RPC2/Server.pm

Criterion	Covered	Total	%
statement	125	126	99.2
branch	51	52	98.0
condition	12	12	100.0
subroutine	23	23	100.0
pod	6	6	100.0
total	217	219	99.0

package JSON::RPC2::Server;
use 5.010001;
use warnings;
use strict;
use utf8;
use Carp;

our $VERSION = 'v2.1.2';

use JSON::MaybeXS;

use constant ERR_PARSE  => -32700;
use constant ERR_REQ    => -32600;
use constant ERR_METHOD => -32601;
use constant ERR_PARAMS => -32602;


sub new {
    my ($class) = @_;
    my $self = {
        method  => {},
    };
    return bless $self, $class;
}

sub register {
    my ($self, $name, $cb) = @_;
    $self->{method}{ $name } = [ $cb, 1, 0 ];
    return;
}

sub register_named {
    my ($self, $name, $cb) = @_;
    $self->{method}{ $name } = [ $cb, 1, 1 ];
    return;
}

sub register_nb {
    my ($self, $name, $cb) = @_;
    $self->{method}{ $name } = [ $cb, 0, 0 ];
    return;
}

sub register_named_nb {
    my ($self, $name, $cb) = @_;
    $self->{method}{ $name } = [ $cb, 0, 1 ];
    return;
}

sub execute {
    my ($self, $json, $cb) = @_;
    croak 'require 2 params' if 1+2 != @_;
    croak 'second param must be callback' if ref $cb ne 'CODE';

    undef $@;
    my $request = ref $json ? $json : eval { decode_json($json) };
    if ($@) {
        return _error($cb, undef, ERR_PARSE, 'Parse error.');
    }
    if (ref $request eq 'HASH') {
        return $self->_execute($request, $cb);
    }
    if (ref $request ne 'ARRAY') {
        return _error($cb, undef, ERR_REQ, 'Invalid Request: expect Array or Object.');
    }
    if (!@{$request}) {
        return _error($cb, undef, ERR_REQ, 'Invalid Request: empty Array.');
    }

    my $pending = @{$request};
    my @responses;
    my $cb_acc = sub {
        my ($json_response) = @_;
        if ($json_response) {
            push @responses, $json_response;
        }
        if (!--$pending) {
            if (@responses) {
                $cb->( '[' . join(q{,}, @responses) . ']' );
            } else {
                $cb->( q{} );
            }
        }
        return;
    };
    for (@{$request}) {
        $self->_execute($_, $cb_acc);
    }

    return;
}

sub _execute {
    my ($self, $request, $cb) = @_;

    my $error = \&_error;
    my $done  = \&_done;

    # jsonrpc =>
    if (!defined $request->{jsonrpc} || ref $request->{jsonrpc} || $request->{jsonrpc} ne '2.0') {
        return $error->($cb, undef, ERR_REQ, 'Invalid Request: expect {jsonrpc}="2.0".');
    }

    # id =>
    my $id;
    if (exists $request->{id}) {
        # Request
        if (ref $request->{id}) {
            return $error->($cb, undef, ERR_REQ, 'Invalid Request: expect {id} is scalar.');
        }
        $id = $request->{id};
    }

    # method =>
    if (!defined $request->{method} || ref $request->{method}) {
        return $error->($cb, $id, ERR_REQ, 'Invalid Request: expect {method} is String.');
    }
    my $handler = $self->{method}{ $request->{method} };
    if (!$handler) {
        return $error->($cb, $id, ERR_METHOD, 'Method not found.');
    }
    my ($method, $is_blocking, $is_named) = @{$handler};

    # params =>
    if (!exists $request->{params}) {
        $request->{params} = $is_named ? {} : [];
    }
    if (ref $request->{params} ne 'ARRAY' && ref $request->{params} ne 'HASH') {
        return $error->($cb, $id, ERR_REQ, 'Invalid Request: expect {params} is Array or Object.');
    }
    if (ref $request->{params} ne ($is_named ? 'HASH' : 'ARRAY')) {
        return $error->($cb, $id, ERR_PARAMS, 'This method expect '.($is_named ? 'named' : 'positional').' params.');
    }
    my @params = $is_named ? %{ $request->{params} } : @{ $request->{params} };

    # id => (continue)
    if (!exists $request->{id}) {
        # Notification
        $error = \&_nothing;
        $done  = \&_nothing;
    }

    # execute
    if ($is_blocking) {
        my @returns = $method->( @params );
        $done->($cb, $id, \@returns);
    }
    else {
        my $cb_done = sub { $done->($cb, $id, \@_) };
        $method->( $cb_done, @params );
    }
    return;
}

sub _done {
    my ($cb, $id, $returns) = @_;
    my ($result, $code, $msg, $data) = @{$returns};
    if (defined $code) {
        return _error($cb, $id, $code, $msg, $data);
    }
    return _result($cb, $id, $result);
}

sub _error {
    my ($cb, $id, $code, $message, $data) = @_;
    $cb->( encode_json({
        jsonrpc     => '2.0',
        id          => $id,
        error       => {
            code        => $code,
            message     => $message,
            (defined $data ? ( data => $data ) : ()),
        },
    }) );
    return;
}

sub _result {
    my ($cb, $id, $result) = @_;
    $cb->( encode_json({
        jsonrpc     => '2.0',
        id          => $id,
        result      => $result,
    }) );
    return;
}

sub _nothing {
    my ($cb) = @_;
    $cb->( q{} );
    return;
}


1; # Magic true value required at end of module
__END__