CPAN::Groonga

yEvent::JSONRPC;
use strict;
use warnings;
use base 'Exporter';

our $VERSION = '0.15';

our @EXPORT = qw/jsonrpc_client jsonrpc_server/;

use AnyEvent::JSONRPC::TCP::Client;
use AnyEvent::JSONRPC::TC

P::Server;

sub jsonrpc_client($$) {
    my ($host, $port) = @_;

    AnyEvent::JSONRPC::TCP::Client->new(
        host => $host,
        port => $port,
    );
}

sub jsonrpc_server($$) {
    my ($add

ent::JSONRPC::TCP::Server->new(
        address => $address,
        port    => $port,
    );
}

1;

__END__

=encoding utf-8

=for stopwords TCP TCP-based JSONRPC RPC

=head1 NAME

AnyEvent::JSONRPC 

vent::JSONRPC::HTTP::Server;
use Moose;

extends 'AnyEvent::JSONRPC::Server';

use Carp;
use Scalar::Util 'weaken';

use AnyEvent::JSONRPC::CondVar;

use AnyEvent::HTTPD;

use JSON::XS;
use JSON::RPC:

    request => sub {
            my ($httpd, $req) = @_;

            my $request = eval { $self->json->decode( $req->content ) };

            unless (defined $request ) {
                $req->respo

$response) {
                $req->respond( [ 200, 'Ok', { "Content-Type" => "application/json" }, $self->json->encode( $response ) ] ); 
            } else {
                $req->respond( [ 204, 'No

e AnyEvent::JSONRPC::Client;

use Any::Moose;

no Any::Moose;

__PACKAGE__->meta->make_immutable;

1;
__END__

=encoding utf-8

=head1 NAME

AnyEvent::JSONRPC::Client - Base class for JSON-RPC clients

=head1 SYNOPSIS

    use AnyEvent::JSONRPC::XXX::Client;
    
    my $client = AnyEvent::JSONRPC::XXX::Client->new(
        ...
    );
    
    # blocking interface
    my $res = $client->call( echo

s for clients in the L<AnyEvent::JSONRPC> suite of
modules. Current implementations includes a
L<TCP|AnyEvent::JSONRPC::TCP::Client> client and a
L<HTTP|AnyEvent::JSONRPC::HTTP::Client> client. See th

package Anyevent::JSONRPC::Utils;

use base qw(Exporter);
our @EXPORT_OK = qw(
    delegate
    do_moose
    do_exporter
);

sub delegate {
    my $object = shift;
    
    croak("delegate needs a ble

ssed object as parameter") unless blessed $object;

    if ( $object->isa("AnyEvent::JSONRPC::Client") ) {
        # Any call is proxied to the client

        return sub {
            my $cv   = shif

_

=head1 NAME

AnyEvent::JSONRPC::Utils - Helper functions for use with AnyEvent::JSONRPC

=head1 SYNOPSIS

    # XXX being either TCP or HTTP
    my $server = AnyEvent::JSONRPC::XXX::Server->new();

package AnyEvent::JSONRPC::Server;

use Moose;
use JSON::XS;

has json => (
    is      => "ro",
    default => sub {
        JSON::XS->new->allow_blessed(1)->convert_blessed(1);
    },
);

no Moose;

D__

=head1 NAME

AnyEvent::JSONRPC::Server - Base class for JSON-RPC Servers

=head1 SYNOPSIS

    use AnyEvent::JSONRPC::XXX::Server;
    
    my $server = AnyEvent::JSONRPC::TCP::Server->new( ... )

s for servers in the L<AnyEvent::JSONRPC> suite of
modules. Current implementations includes a
L<TCP|AnyEvent::JSONRPC::TCP::Server> client and a
L<HTTP|AnyEvent::JSONRPC::HTTP::Server> client. See th

package AnyEvent::JSONRPC::CondVar;
use Any::Moose;

use AnyEvent;

has cv => (
    is      => 'ro',
    isa     => 'AnyEvent::CondVar',
    default => sub {
        AnyEvent->condvar;
    },
    hand

les => [qw( send recv cb )],
);

has call => (
    is       => 'ro',
    isa      => 'JSON::RPC::Common::Procedure::Call',
    required => 1,
    handles  => [qw( is_notification )], 
);

no Any::Moos

AnyEvent::JSONRPC::CondVar - Condvar object used in
AnyEvent::JSONRPC::TCP::Server and AnyEvent::JSONRPC::HTTP::Server

=head1 SEE ALSO

L<AnyEvent::JSONRPC::TCP::Server> and L<AnyEvent::JSONRPC::HTTP

package AnyEvent::JSONRPC::HTTP::Client;
use Any::Moose;
use Any::Moose '::Util::TypeConstraints';

extends 'AnyEvent::JSONRPC::Client';

use Carp;
use Scalar::Util 'weaken';

use AnyEvent;
use AnyEve

nt::HTTP;

use JSON::RPC::Common::Procedure::Call;
use JSON::RPC::Common::Procedure::Return;

use MIME::Base64;
use JSON::XS;

has url => (
    is       => 'ro',
    isa      => 'Str',
    required =>

;
    },
);

no Any::Moose;

sub call {
    my ($self, $method, @params) = @_;

    my $request = JSON::RPC::Common::Procedure::Call->inflate ( 
        version => $self->version,
        id      => $

age AnyEvent::JSONRPC::TCP::Server;
use Moose;

extends 'AnyEvent::JSONRPC::Server';

use Carp;
use Scalar::Util 'weaken';

use AnyEvent::Handle;
use AnyEvent::Socket;

use AnyEvent::JSONRPC::Internal

Handle;
use AnyEvent::JSONRPC::CondVar;
use JSON::RPC::Common::Procedure::Call;

has address => (
    is      => 'ro',
    isa     => 'Maybe[Str]',
    default => undef,
);

has port => (
    is      

   },
            json => $self->json,
            %{ $self->handler_options },
            fh => $fh,
        );
        $handle->on_read(sub {
            shift->unshift_read( json => sub {
        

package AnyEvent::JSONRPC::TCP::Client;
use Any::Moose;
use Any::Moose '::Util::TypeConstraints';

extends 'AnyEvent::JSONRPC::Client';

use Carp;
use Scalar::Util 'weaken';

use AnyEvent;
use AnyEven

t::Socket;
use AnyEvent::Handle;

use JSON::RPC::Common::Procedure::Call;
use JSON::RPC::Common::Procedure::Return;

has host => (
    is       => 'ro',
    isa      => 'Str',
    required => 1,
);

h

ead(json => sub {
                $self->_handle_response( $_[1] );
            });
        });

        while (my $pooled = shift @{ $self->_request_pool }) {
            $handle->push_write( json =>

package AnyEvent::JSONRPC::InternalHandle;
use Any::Moose;

use AnyEvent;

has cv => (
    is      => 'ro',
    isa     => 'AnyEvent::CondVar',
    default => sub {
        AnyEvent->condvar;
    },
 

ite {
    my ($self, $type, $json) = @_;

    $self->cv->send( $json );
}

__PACKAGE__->meta->make_immutable;

__END__

=for stopwords condvar

=head1 NAME

AnyEvent::JSONRPC::InternalHandle - Handle 

object used internally in
AnyEvent::JSONRPC::TCP::Server

=head1 SEE ALSO

L<AnyEvent::JSONRPC>.

=head1 AUTHOR

Peter Makholm <peter@makholm.net>

=head1 COPYRIGHT AND LICENSE

Copyright (c) 2010 by