Orbjson 0.0.1

data/lib/orbjson.rb

@@ -0,0 +1,250 @@
+require 'rubygems' 
+require 'logger'
+require 'json/objects'
+require 'json/lexer'
+require 'yaml'
+require 'needle'
+require 'webrick'
+
+class CGI
+  def raw_post
+    self.params.keys[0]
+  end
+end
+
+include WEBrick
+
+def new_from_name( classname, *args)
+  cname = String.new( classname.untaint )
+  obj = nil
+  begin
+    obj = Object.const_get( cname ).new( *args )
+  rescue Exception
+    begin
+      require cname
+      obj = Object.const_get( cname ).new( *args )
+    rescue Exception
+      raise "Cannot create object #{cname}: #{$!}" unless obj
+    end
+  end
+  obj
+end
+
+
+
+
+module Orbjson
+  
+  $roy_logger = Logger.new( "Orbjson.log" )
+  $roy_logger.level = Logger::DEBUG
+
+  Version = "0.1.1"
+  LibPath = File.dirname(__FILE__)  
+  
+  class System
+    @@registry = Needle::Registry.new() 
+    
+    def self.get_object( klass, *args )
+      return @@registry[ klass.intern ] 
+    end
+    
+    def self.put_object( klass, instance )
+      @@registry.register( klass ) { instance }
+      # @@cache[ klass ] = instance 
+    end
+    
+    def self.registered_classses
+      @@registry.keys.map{ |k| k.to_s.capitalize }
+    end
+    
+    def listMethods
+      System.list_methods
+    end
+    
+    def self.list_methods
+      mlist = []
+      
+      System.registered_classses.each  do |cls|
+        name = cls.to_s.downcase
+        begin 
+          klass = eval(cls )
+          ( klass.public_instance_methods  - 
+            Object.methods ).sort.each { |m| 
+              mlist << "#{name}.#{m}" 
+           }  
+         rescue Exception
+           STDERR.puts( "System#list_methods error #{$!}" )
+           $roy_logger.error( "System#list_methods error #{$!}" )
+         end
+      end
+      mlist 
+    end
+
+
+       # You configure the services list by passing in either a hash of file
+       # paths mapped to class names, or a YMAL string encoding the same, or
+       # the path to YAML file 
+    def self.init( cfg, flush = true )
+      
+      @@registry = Needle::Registry.new() if flush 
+      STDERR.puts( "cfg starts as  #{cfg}") 
+      case  cfg.class.to_s
+        when 'String'
+          if cfg =~ /^file:\/\//
+            cfg.gsub!( /^file:\/\//, '' )
+            STDERR.puts( "cfg is now #{cfg}")
+            config_hash = YAML::load( File.open( cfg  ) )
+          else
+            STDERR.puts( "cfg is  #{cfg}")
+            config_hash = YAML::load( cfg  )            
+          end
+        when 'Hash'
+          config_hash = cfg
+        else
+          raise "init was given unusable configuration data [ #{cfg.class}]: #{$!}"
+      end
+      
+      config_hash.each do |src_file, class_list|
+        require src_file
+        class_list.each do |klass|
+          @@registry.register( klass ) { new_from_name( klass ) }
+        end
+      end  
+
+      @@registry.register( :System ) { System.new }
+      @@registry.register( :system ) { System.new }  
+      $roy_logger.debug(  "Regist now has \n" + @@registry.keys.inspect )
+    end
+  end
+
+  module Common
+    def format_repsonse( result, error, id )
+      id.class == String ? quote = '"' : quote = ''
+      '{ "result" : ' + result.to_json + ', "error":"' + 
+       error.to_s + '", "id": ' +  quote +  id.to_s + 
+       quote + ' }'
+    end
+
+    def process( json )
+      json   = "#{json}"
+      null=nil;  
+      jsonobj = {}.from_json( JSON::Lexer.new(json ) ) 
+      klass, method = jsonobj[ 'method'].split( '.' ) 
+      $roy_logger.debug( "klass, method  = #{klass}, #{method}" )
+      receiver = System.get_object( klass.capitalize )
+      begin
+        if ( jsonobj[ 'params'] && jsonobj[ 'params'] != 'nil' )
+          $roy_logger.debug( __LINE__ )
+          if jsonobj[ 'params'].size < 1
+            $roy_logger.debug( __LINE__ )          
+            result = receiver.send( method  )                  
+          else
+            $roy_logger.debug( __LINE__ )          
+            result = receiver.send( method , *jsonobj[ 'params']   )
+          end
+        else
+          $roy_logger.debug( __LINE__ )
+          result = receiver.send( method  )        
+        end
+        error = null
+      rescue
+        result = null
+        error = $!.to_s
+        $roy_logger.error( "#{_LINE__}: #{$!}"  )      
+      end
+      format_repsonse( result, error, jsonobj['id'] || 'default' )
+    end
+  end
+
+
+    # Manages json-rpc requests sent as a post to a WEBrick servlet.
+    # Mount a path to  WEBrick_JSON_RPC, and you should be set
+  class WEBrick_JSON_RPC < HTTPServlet::AbstractServlet
+    
+    include  Common
+    
+    def process_request( req, res, json )
+      res.body = process( json )
+      res['Content-Type'] = "text/javascript"    
+    end
+   
+      # Delegates the call to process_request
+    def do_GET( request, response )
+      process_request( request, response, request.query_string )
+    end
+    
+      # Delegates the call to process_request
+    def do_POST( request, response )
+      process_request( request, response, request.body )    
+    end  
+     
+  
+  end
+
+
+    # Manages json-rpc requests sent as a raw post to a CGI application.
+  class CGI_JSON_RPC 
+    
+    include  Common
+
+    def initialize(  cfg  )
+       System.init( cfg  )
+    end
+    
+    def process_request( )
+      cgi =  CGI.new
+      json   = cgi.raw_post
+      process( json )
+    end
+  
+  end
+end
+
+#
+#
+#  TODO  See specs at http://www.json-rpc.org/specs.xhtml
+#  1.3 notification
+# A notification is a special request which does not have a response.
+# The notification is a single object serialized using JSON.
+# It has the same properties as the request object with one exception.
+# 
+#     * id
+#       Muste be null.
+#
+# 2.2   JSON-RPC over HTTP
+# With some limitations HTTP can be used for communicating to a service.
+# A client may send one or more requests to a service.
+# The requests must be sent as an HTTP POST containing all serialized request objects.
+# The reply must contain the serialized response objects for all requests.
+# Notifications may be sent by the client or the service.
+# 
+# A non valid request must result in closing the connection.
+# A non valid responses must raise an exception for all unanswered requests on the client.
+# Closing a connection must raise an exception for all unanswered requests on the client.
+#
+# 3. JSON Class hinting?
+# There are only simple data types defined in JSON.
+# To overcome this problem in a JSON compatible way a special property for objects is introduced.
+# {"jsonclass":["constructor", [param1, ], "prop1": ...}
+# The object is then instanciated using the constructor passing the parameters.
+# Once constructed the properties will be applied.
+
+
+# Copyright (C) 2005 James Britt & Neurogami LLC
+# Big thanks to Florian Franks for his ruby-json lib, and Jamis Buck for
+# Needle
+# 
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License,
+# version 2, as published by the Free Software Foundation.
+# 
+# This program is distributed in the hope that it will be
+# useful, but WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+# PURPOSE. See the GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the Free
+# Software Foundation, Inc., 59 Temple Place, Suite 330,
+# Boston, MA 02111-1307 USA.
+

data/lib/skeleton/cgi/json-rpc.rb

@@ -0,0 +1,60 @@
+#!/usr/local/bin/ruby
+
+
+require 'cgi'
+require 'rubygems'
+require "orbjson"
+require 'logger'
+
+include Orbjson
+
+
+$logger = Logger.new( "orbjson_cgi.log" )
+
+# Change this to ERROR or something when your code does 
+# all it should, and does it right:
+$logger.level = Logger::DEBUG 
+
+
+$logger.debug( "Have a request!" )
+
+# You can configure the Orbjsn services list in a few ways.
+# Well, three, really:
+#  1. Pass in a path to a local YAML file; the path must begin with
+#   'file://'
+#     For example: cfg = 'file://config.yaml'
+#     json_rpc = CGI_JSON_RPC.new( cfg )
+#     
+#  2. Pass in some YAML:   
+#    cfg = 'services/sample: 
+#            - Details'
+#    json_rpc = CGI_JSON_RPC.new( cfg )
+#            
+#  3. Pass in some an atual Hash objectL:   
+#    cfg = { 'services/sample' => ['Details'] }
+#    json_rpc = CGI_JSON_RPC.new( cfg )
+#
+#  The hash (however you express it) consists of 'require' paths mapped
+#  to arrays of classes to instantiate.
+
+
+# Change this to suit your actual situation:
+cfg = 'services/sample: 
+   - Details'
+json_rpc = CGI_JSON_RPC.new( cfg )
+
+print "content-type: text/javascript\n\n"
+res =  json_rpc.process_request
+$logger.debug( "Have a response:\n#{res}" ) 
+# Logging may make an already slow CGI app go
+# even slower, so consider dropping this suf when things are good.
+
+print res
+
+
+
+
+
+
+
+

data/lib/skeleton/script/jsonrpc.js

@@ -0,0 +1,187 @@
+/*
+ * JSON-RPC JavaScript client
+ *
+ * $Id: jsonrpc.js,v 1.1.1.1 2005/02/28 03:06:28 jamesgbritt Exp $
+ *
+ * Copyright (c) 2003-2004 Jan-Klaas Kollhof
+ * Copyright (c) 2005 Michael Clark, Metaparadigm Pte Ltd
+ *
+ * This code is based on Jan-Klaas' JavaScript o lait library (jsolait).
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public (LGPL)
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details: http://www.gnu.org/
+ *
+ */
+
+// TODO: Add async
+// TODO: Add HTTP auth (user, password)
+
+Object.prototype.toJSON = function Object_toJSON() {
+    var v = [];
+    for(attr in this) {
+      if(this[attr] == null) v.push("\"" + attr + "\": null");
+      else if(typeof this[attr] == "function"); // skip
+      else v.push("\"" + attr + "\": " + this[attr].toJSON());
+    }
+    return "{" + v.join(", ") + "}";
+}
+
+String.prototype.toJSON = function String_toJSON()  {
+    return "\"" + this.replace(/([\"\\])/g, "\\$1") + "\"";
+}
+
+Number.prototype.toJSON = function Number_toJSON() {
+    return this.toString();
+}
+
+Boolean.prototype.toJSON = function Boolean_toJSON() {
+    return this.toString();
+}
+
+Date.prototype.toJSON = function Date_toJSON() {
+    this.valueOf().toString();
+}
+
+Array.prototype.toJSON = function Array_toJSON() {
+    var v = [];
+    for(var i=0; i<this.length; i++) {
+      if(this[i] == null) v.push("null");
+      else v.push(this[i].toJSON());
+    }
+    return "[" + v.join(", ") + "]";
+}
+
+JSONRpcClient = function JSONRpcClient_ctor(serverURL, objectID) {
+    this.serverURL = serverURL;
+    this.objectID = objectID;
+
+    // Lazy initialization of the XMLHttpRequest singleton
+    if(!JSONRpcClient.http)
+      JSONRpcClient.http = JSONRpcClient.getHTTPRequest();
+
+    // Add standard methods
+    this.addMethods(["system.listMethods"]);
+
+    // Query the methods on the server and add them to this object
+    var m = this.sendRequest("system.listMethods", []);
+    this.addMethods(m);
+}
+
+JSONRpcClient.Exception = function JSONRpcClient_Exception_ctor(code, msg) {
+    this.code = code;
+    this.msg = msg;
+}
+
+JSONRpcClient.Exception.prototype.toString =
+function JSONRpcClient_Exception_toString(code, msg)  {
+    return "JSONRpcClientException: " + this.msg;
+}
+
+JSONRpcClient.Method =
+function JSONRpcClient_Method_ctor(client, methodName) {
+    var fn=function()  {
+      var args = [];
+      for(var i=0;i<arguments.length;i++) {
+          args.push(arguments[i]);
+      }
+      return fn.client.sendRequest.call(fn.client, fn.methodName, args);
+    }
+    fn.client = client;
+    fn.methodName = methodName;
+    return fn;
+}
+
+JSONRpcClient.prototype.addMethods =
+function JSONRpcClient_addMethods(methodNames) {
+    for(var i=0; i<methodNames.length; i++) {
+    var obj = this;
+    var names = methodNames[i].split(".");
+    for(var n=0; n<names.length-1; n++){
+      var name = names[n];
+      if(obj[name]){
+        obj = obj[name];
+      } 
+      else {
+        obj[name]  = new Object();
+        obj = obj[name];
+      }
+  }
+  var name = names[names.length-1];
+  if(!obj[name]){
+      var method = new JSONRpcClient.Method(this, methodNames[i]);
+      obj[name] = method;
+   }
+  }
+}
+
+JSONRpcClient.prototype.sendRequest =
+function JSONRpcClient_sendRequest(methodName, args) {
+    // Make request object
+    var obj = {"method" : methodName, "params" : args};
+    if (this.objectID) obj.objectID = this.objectID;
+
+    // Marshall the request object to a JSON string
+    var req_data = obj.toJSON();
+
+    // Send the request
+    JSONRpcClient.http.open("POST", this.serverURL, false); // no async
+    // setRequestHeader is missing in Opera 8 Beta
+    try {
+      JSONRpcClient.http.setRequestHeader("Content-type", "text/plain");
+    } 
+    catch(e) {}
+    JSONRpcClient.http.send(req_data);
+
+    // Unmarshall the response
+    // DEBUG
+    try {
+      eval("var obj = " + JSONRpcClient.http.responseText);
+    }
+    catch(e) {
+      alert( e )            
+      alert( JSONRpcClient.http.responseText )            
+      obj.err = e.toString()
+      }
+    if( obj.error) {
+      alert( JSONRpcClient.http.responseText )      
+      throw new JSONRpcClient.Exception(obj.error.code, obj.error.msg);
+     }
+      var res = obj.result;
+
+    // Handle CallableProxy
+    if(res && res.objectID && res.JSONRPCType == "CallableReference")
+      return new JSONRpcClient(this.serverURL, res.objectID);
+
+    return res;
+}
+
+JSONRpcClient.getHTTPRequest = function JSONRpcClient_getHTTPRequest() {
+    try { // to get the mozilla httprequest object
+      return new XMLHttpRequest();
+    } 
+    catch(e) {}
+
+    try { // to get MS HTTP request object
+      return new ActiveXObject("Msxml2.XMLHTTP.4.0");
+    } 
+    catch(e) {}
+
+    try { // to get MS HTTP request object
+      return new ActiveXObject("Msxml2.XMLHTTP");
+    } 
+    catch(e) {}
+
+    try {// to get the old MS HTTP request object
+      return new ActiveXObject("microsoft.XMLHTTP"); 
+    } 
+    catch(e) {}
+
+    throw new JSONRpcClient.Exception(0, "Can't create XMLHttpRequest object");
+}

data/lib/skeleton/webrick/config.yml

@@ -0,0 +1,2 @@
+services/sample: 
+   - Details

data/lib/skeleton/webrick/server.rb

@@ -0,0 +1,57 @@
+#!/usr/local/bin/ruby
+require 'webrick'
+
+require "orbjson"
+include WEBrick
+
+
+Socket.do_not_reverse_lookup = true
+
+$logger = Logger.new( "orbjson.log" )
+$logger.level = Logger::DEBUG
+
+s = HTTPServer.new( :Port => 2222,
+                    :DocumentRoot  =>  File.dirname( __FILE__ )  )
+
+s.mount("/json-rpc", Orbjson::WEBrick_JSON_RPC )
+
+
+# These mounts are a ahandy way to to kill a WEBrick instance via  URL,
+# useful mostly during debugging.  Probably less useful when you've deployed
+# the applicaton.  Consider removing these before going live.
+s.mount_proc( "/exit" ){|req, res| s.shutdown;  exit;  } 
+s.mount_proc( "/quit" ){|req, res| s.shutdown;  exit; }   
+
+
+# You can configure the Orbjsn services list in a few ways.
+# Well, three, really:
+#  1. Pass in a path to a local YAML file; the path must begin with
+#   'file://'
+#     For example: cfg = 'file://config.yaml'
+#     Orbjson::System.init( cfg )
+#     
+#  2. Pass in some YAML:   
+#    cfg = 'services/sample: 
+#            - Details'
+#    Orbjson::System.init( cfg )
+#            
+#  3. Pass in some an atual Hash objectL:   
+#    cfg = { 'services/sample' => ['Details'] }
+#    Orbjson::System.init( cfg )
+#
+#  The hash (however you express it) consists of 'require' paths mapped
+#  to arrays of classes to instantiate.
+
+
+# Change this to suit your actual situation: If you use a configuration file,
+# # mkae sure you have the correct name, path, and contents.
+# This example expects to find the file config.yml in the same dir
+# as server.rb 
+cfg = "file://config.yml"
+Orbjson::System.init( cfg )
+
+
+trap( "INT" ){ s.shutdown }
+trap( 1 ){ s.shutdown }
+s.start
+

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.6
+specification_version: 1
+name: Orbjson
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2005-02-27
+summary: Lib for creating JSON-RPC server applications.
+require_paths: 
+  - lib
+email: jamesgb@neurogami.com
+homepage: http://orbjson.rubyforge.org
+rubyforge_project: orbjson
+description: 
+autorequire: orbjson
+default_executable: orbjson
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+  version: 
+platform: ruby
+authors: 
+  - James Britt
+files: 
+  - README
+  - docs/todo.txt
+  - bin/orbjson
+  - lib/orbjson.rb
+  - lib/skeleton
+  - lib/skeleton/cgi
+  - lib/skeleton/script
+  - lib/skeleton/webrick
+  - lib/skeleton/cgi/json-rpc.rb
+  - lib/skeleton/script/jsonrpc.js
+  - lib/skeleton/webrick/config.yml
+  - lib/skeleton/webrick/server.rb
+  - examples/cgi
+  - examples/webrick
+  - examples/cgi/Orbjson.log
+  - examples/cgi/httpd.conf
+  - examples/cgi/index.html
+  - examples/cgi/json-rpc.rb
+  - examples/cgi/orbjson_cgi.log
+  - examples/cgi/yellow_crossfade_01.gif
+  - examples/cgi/script
+  - examples/cgi/services
+  - examples/cgi/script/jsonrpc.js
+  - examples/cgi/services/sample.rb
+  - examples/webrick/config.yml
+  - examples/webrick/index.html
+  - examples/webrick/server.rb
+  - examples/webrick/yellow_crossfade_01.gif
+  - examples/webrick/script
+  - examples/webrick/services
+  - examples/webrick/script/jsonrpc.js
+  - examples/webrick/services/sample.rb
+  - dep/handy
+  - dep/required
+  - dep/handy/script
+  - dep/handy/script/jsonrpc.js
+  - dep/required/ruby-json
+  - dep/required/ruby-json/ruby-json-1.1.1.gem
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: 
+  - orbjson
+extensions: []
+requirements: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: needle
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: 1.2.0
+      version: 
+  - !ruby/object:Gem::Dependency 
+    name: ruby-json
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: "1.1"
+      version: