NAME¶
UR::Service::JsonRpcServer - A self-contained JSON-RPC server for UR namespaces
SYNOPSIS¶
use lib '/path/to/your/moduletree';
use YourNamespace;
my $rpc = UR::Service::JsonRpcServer->create(host => 'localhost',
port => '8080',
api_root => 'URapi',
docroot => '/html/pages/path',
);
$rpc->process();
Description¶
This is a class containing an implementation of a JSON-RPC server to respond to
requests involving UR-based namespaces and their objects. It uses
Net::HTTPServer as the web server back-end library.
Incoming requests are divided into two major categories:
- http://server:port/"api-root"/class/Namespace/Class
- This is the URL for a call to a class metnod on
"Namespace::Class"
- http://server:port/"api-root"/obj/Namespace/Class/id
- This is the URL for a method call on an object of class Namespace::Class
with the given id
Constructor¶
The constructor takes the following named parameters:
- host
- The hostname to listen on. This can be an ip address, host name, or undef.
The default value is '0.0.0.0'. This argument is passed along verbatim to
the Net::HTTPServer constructor.
- port
- The TCP port to listen on. The default value is 8080. This argument is
passed along verbatim to the Net::HTTPServer constructor.
- api_root
- The root path that the http server will listen for requests on. The
constructor registers two paths with the Net::HTTPServer with
RegisterRegex() for /"api_root"/class/* and
/"api_root"/obj/* to respond to class and instance metod
calls.
All other arguments are passed along to the Net::HTTPServer constructor.
Methods¶
- $rpc->process()
- A wrapper to the Net::HTTPServer Process() method. With no
arguments, this call will block forever from the perspective of the
caller, and process all http requests coming in. You can optionally pass
in a timeout value in seconds, and it will respond to requests for the
given number of seconds before returning.
Client Side¶
There are (or will be) client-side code in both Perl and Javascript. The Perl
code is (will be) implemented as a UR::Context layer that will return
light-weight object instances containing only class info and IDs. All method
calls will be serialized and sent over the wire for the server process to
execute them.
The Javascript interface is defined in the file urinterface.js. An example:
var UR = new URInterface('http://localhost:8080/URApi/'); // Connect to the server
var FooThingy = UR.get_class('Foo::Thingy'); // Get the class object for Foo::Thingy
var thingy = FooThingy.get(1234); // Retrieve an instance with ID 1234
var result = thingy.call('method_name', 1, 2, 3); // Call $thingy->method_name(1,2,3) on the server
SEE ALSO¶
Ney::HTTPServer, urinterface.js