RPC::Object - A lightweight implementation for remote procedure calls

  use RPC::Object::Broker;
  $b = $RPC::Object::Broker->new(preload => \@preload_modules);
  $b->start();

  use RPC::Object;
  $o = RPC::Object->new("$host:$port", 'method_a', 'TestModule');
  my $ans1 = $o->method_b($arg1, $arg2);
  my @ans2 = $o->method_c($arg3, $arg4);

  # To access the global instance
  # allocate and initialize first,
  RPC::Object->new("$host:$port", 'method_a', 'TestModule');
  ...
  $global = RPC::Object->get_instance("$host:$port", 'TestModule');

  package TestModule;
  use threads;
  ...
  sub method_a {
      my $class = shift;
      my $self : shared;
      ...
      return bless $self, $class;
  }  }

package RPC::Object;
use constant DEFAULT_PORT => 8049;
use constant RETRY_MAX => 10;
use constant RETRY_WAIT => 2;
use strict;
use warnings;
use Carp;
use Storable qw(nfreeze thaw);
use RPC::Object::Transport;

our $VERSION = '0.31';

sub new {
    my ($class, $url) = splice @_, 0, 2;
    my ($host, $port) = $url =~ /([^:]+)(?::(\d+))?/;
    croak 'usage: ' . __PACKAGE__ . qq(->new("host:port", ...)) unless defined $host;
    $port = DEFAULT_PORT unless defined $port;
    my $obj = _invoke($host, $port, @_);
    my $self = \"$host:$port:$obj";
    return bless $self, $class;
}

sub get_instance {
    my ($class, $url) = splice @_, 0, 2;
    return $class->new($url, '_rpc_object_find_instance', 'RPC::Object::Broker', @_);
}

sub AUTOLOAD {
    my $self = shift;
    our $AUTOLOAD;
    my $name = [split '::', $AUTOLOAD]->[-1];
    return unless __PACKAGE__ eq substr($AUTOLOAD, 0, -(length "::$name"));
    my ($host, $port, $obj) = split ':', $$self;
    if ($name eq 'DESTROY') {
        return;
    }
    elsif (defined $obj) {
        return _invoke($host, $port, $name, $obj, @_);
    }
    return;
}

sub _invoke {
    my ($host, $port) = splice @_, 0, 2;
    my $context = wantarray;
    my $res = _request($host, $port, 'a' . nfreeze([$context, @_]));
    my $id = $res;
    my @ret;
    while (1) {
        $res = _request($host, $port, 'r' . $id);
        next if $res eq '';
        @ret = @{thaw($res)};
        last if @ret;
    }
    continue {
        sleep 1;
    }
    my $state = shift @ret;
    croak @ret if $state eq 'e';
    return unless defined $context;
    return $context ? @ret : $ret[0];
}

sub _request {
    my ($host, $port, $cmd) = @_;
    return RPC::Object::Transport->new({PeerAddr => $host,
                                        PeerPort => $port,
                                        Proto => 'tcp',
                                       })->request($cmd);
}

1;
__END__