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