README-Spawn lib/job.rb lib/job_queue.rb lib/job_step.rb lib/json_rpc_utils.rb lib/spawn/patches.rb lib/spawn/spawn.rb spec/enqueue_spec.rb spec/job_queue_spec.rb spec/job_spec.rb spec/job_step_spec.rb @@ -65,6 +65,7 @@ route string must end with '/*method'. In future versions there might be a helpe create JSON-RPC routes, but as yet that piece of syntactic sugar is not available. + == Client Side The client side of things is the module JsonRpcClient. To connect to a service as defined @@ -94,14 +95,119 @@ slower. Also note that your JSON-RPC client class, "Yonder" in this example, never is instantiated. -You can also pass a one-argument block to a remote procedure call: - Yonder.foo(bar, baz) { |x| x.kind_of?(Exception) ? scream(x) : process(x) } +== Client side retries + +When a retriable failure occurs (e.g. the service is down server-side), by default a total of +three tries are attempted. You can modify this by passing a parameter to +json_rpc_service+, ++:retries+. This may be an integer specifying the number of retries to perform after the initial +one (thus this figure is always one less than the total number of tries made.) + +However, +:retries+ may also be a hash with the following possible components: + + :max_retries The total number of retries or nil (= infinite). Default: 2. + :max_time The total number of seconds allowed for retries starting from + the beginning of the whole operation. Default: nil (no limit). + :sleep The number of seconds to wait between retries. + Default: nil (don't wait). + :sleep_factor A factor with which to multiply the sleep time after each + sleep period. Default: 1.5. + :sleep_max Ceiling value for the modified sleep time. + Default: nil (no upper limit). + +Thus, if you specify nil or leave out +:retries+ altogether, the JSON-RPC client will do three tries +without waiting in between, after which the operation will fail with the original exception. + +You can also change the retry parameters locally - per service - by using the class method ++retry_strategy+: + + Yonder.retry_strategy(:sleep => 5.0, :sleep_factor => 2.0, :sleep_max => 5.minutes) do + Yonder.sum 24, 6 + end + + +== Asynchronous queueing of client-side requests + +It is possible to execute code asynchronously in other processes. This is not limited to JSON-RPC +calls. Any code involving ActiveRecord classes and instances can be enqueued for execution using +the simple method +enqueue+. It is possible to specify jobs consisting of any number of discrete +steps. For each job step, it is possible to specify rollback operations to execute in case the +job step fails, with configurable retry counts and much more. It is also possible to specify +failure handlers for jobs which fail entirely. + +The basic syntax is as follows: + + enqueue({job-step-1}, {job-step-2}, ... {job-step-n}, + :job-config-param-1, + :job-config-param-2, + ... + :job-config-param-n) + +The method +enqueue+ always returns true. This means that you cannot retrieve the result of the +job by normal means. If it's needed (which rarely is the case), you must use a job step to do so. + +Here's a simple example of an +enqueue+ call: + + enqueue :target => @user, :do => :do_something, :do_args => [x, [1, 2, 3], User.find(xxx)] -If a block is present, the result of executing +foo+ on +bar+ and +baz+ will be yielded to the -block. However, if for any reason an exception should occur at any point, including HTTP setup, -remote evaluation or decoding of the JSON reply, the block will instead receive the exception. -This allows you to program continuation style, or to implement execution queues for retries, etc. +This will set up a call to +user.do_something(x, [1,2,3], <some_user>)+ in another process. + +Each job step may have a single ActiveRecord object as its target, but it is also possible to +invoke class methods: + + enqueue :target => MyClass, :do => :some_class_method + +And of course, if there is more than one job step: + + enqueue({ :target => myobj, :do => :a_myobj_method, :do_args => ['foo'] }, + { :target => other, :do => :foo }, + { :target => myobj, :do => :something_final }) + +Please note that all args and targets are retrieved fresh from the database for each job step. +Thus the two references to +myobj+ in the above code are not the same object in memory, but +two distinct instances (which of course still may be identical). + +Each job step can take the following key/value pairs: + + :target An ActiveRecord class or instance + :do A symbol naming the method to invoke on the target + :do_args An array of arguments to pass to the invoked method. ActiveRecord instances + and classes may appear in this array, but only on the top level. + :rollback A symbol naming a method to invoke on the target in case the +:do+ operation + fails (i.e. an exception is raised). + :rollback_args An array of arguments to pass to the invoked rollback method. The same + rules as for +:do_args+ apply to +:rollback_args+. + :tries An integer which specifies the total number of tries to be performed for + this job step. Defaults to 3 (but if there is a :tries value defined + for the whole job, then that value is used instead - more on this + further down). + +Job configuration parameters can be specified as the last hash in the +enqueue+ call (which +thus may either be a job step or a hash of job configuration parameters - and remember that +any "loose" symbol/value pairs in any Ruby method call will be grouped together as a hash). + +The job configuration parameters can be any or all of the following: + + :target An ActiveRecord class or instance (only used with :on_failure) + :on_failure A symbol naming the method to invoke on the target if the operation fails. + Any exceptions generated by the :on_failure call are suppressed silently. + :failure_args An array of arguments to pass to the +:on_failure+ handler. The same + restrictions apply to this argument list as to the :do_args and + :rollback_args argument lists. + :tries An integer which specifies the default total number of tries to be performed + for each job step (and which can be overridden individually in each + job step). Defaults to nil. + :unordered If true, the job is permitted to execute in parallel with any other job. + If false (the default), the job is *ordered*, meaning it will execute + in strict order compared to all other ordered jobs. Only one ordered + job will be permitted to execute at one time. This means you can depend + on the results of one ordered job for any following job. + :synchronous Normally false. If true, it overrides the value of :unordered and will + cause all calls to +enqueue+ to be performed synchronously. This is + the default value in the test and build environments. + + + === Service Description README @@ -1,17 +1,16 @@ require 'rake' -require 'rake/testtask' -require 'rake/rdoctask' +require 'spec/rake/spectask' -desc 'Default: run unit tests.' -task :default => :test +desc 'Default: run specs.' +task :default => :spec -desc 'Test the json_rpc plugin.' -Rake::TestTask.new(:test) do |t| - t.libs << 'lib' - t.pattern = 'test/**/*_test.rb' - t.verbose = true +desc 'Run the specs' +Spec::Rake::SpecTask.new(:spec) do |t| + t.spec_opts = ['--colour --format progress --loadby mtime --reverse'] + t.spec_files = FileList['spec/**/*_spec.rb'] end + desc 'Generate documentation for the JSON-RPC plugin.' Rake::RDocTask.new(:rdoc) do |rdoc| rdoc.rdoc_dir = 'rdoc' Rakefile @@ -1,2 +1,41 @@ # Include hook code here + +require 'json/ext' +require 'json/add/rails' +require 'openstruct' + +require 'job' +require 'job_step' +require 'job_queue' +require 'json_rpc_client' +require 'json_rpc_service' +require 'json_rpc_utils' + +require 'spawn/spawn' +require 'spawn/patches' +ActionController::Base.send :include, Spawn +if defined?(ActiveRecord) + ActiveRecord::Base.send :include, Spawn + ActiveRecord::Observer.send :include, Spawn +end + +# +# This might be right or it might not: the default to_json +# method for strings encodes *all* Unicode characters using +# the "\uFFFF" syntax, which is unnecessary since the JSON +# spec explicitly states that Unicode characters are fully +# supported. Rails only uses UTF-8 and never decodes the +# \uFFFF it creates (insert expletive here). Therefore, we +# monkey patch String#to_json to not use the \uFFFF syntax +# at all. This might have unforeseen side effects. We shall +# see. +# +class ::String + def to_json(options = nil) #:nodoc: + '"' + gsub(/[\010\f\n\r\t"\\><&]/) { |s| ActiveSupport::JSON::Encoding::ESCAPED_CHARS[s] } + '"' + end +end + + + ActionController::Base.send(:include, JsonRpcService) init.rb @@ -4,20 +4,24 @@ # class JsonRpcClient - require 'json' require 'net/http' require 'uri' - + require 'timeout' # - # Our runtime error class. + # Our runtime error classes. Indentation reflects inheritance. # class Error < RuntimeError; end - class ServiceError < Error; end - class ServiceDown < Error; end - class NotAService < Error; end - class ServiceReturnsJunk < Error; end + class ServiceError < Error; end + class ServiceReturnsJunk < Error; end + class RetriableError < Error; end + class NotAService < Error; end + class ServiceDown < RetriableError; end + class ServiceUnavailable < RetriableError; end + class Timeout < RetriableError; end + class ServerTimeout < Timeout; end + class GatewayTimeout < Timeout; end # # Execute this "declaration" with a string or URI object describing the base URI @@ -27,7 +31,9 @@ class JsonRpcClient # If you pass :no_auto_config => true, no attempt will be made to contact the service # to obtain a description of its available services, which means POST will be used # for all requests. This is sometimes useful when a server is non-compliant and does not - # provide a system.describe call. + # provide a system.describe call. If you pass :uri_encode_post_bodies => true, all + # bodies used in POSTs will be URI encoded (fixing a tricky case with UTF-8 characters and + # non-compliant JSON-RPC servers written in Perl). # def self.json_rpc_service(base_uri, opts={}) @uri = URI.parse base_uri @@ -40,10 +46,24 @@ class JsonRpcClient @get_procs = [] @post_procs = [] @no_auto_config = opts[:no_auto_config] + @uri_encode_post_bodies = opts[:uri_encode_post_bodies] @logger = opts[:debug] + @retry_strategy = analyze_retry_strategy(opts[:retries]) @uri end + + def self.analyze_retry_strategy(strat) + strat ||= 2 + strat = { :max_retries => strat } if strat.kind_of?(Integer) + { :max_time => nil, + :sleep => nil, + :sleep_factor => 1.5, + :sleep_max => nil + }.merge(strat) + end + + # # Changes the URI for this service. Used in setups where several identical # services can be reached on different hosts. @@ -57,7 +77,20 @@ class JsonRpcClient @proxy_port = @proxy.port end @uri - end + end + + + # + # This block handler establishes a local scope for a service retry strategy + # + def self.retry_strategy(new_strategy) + old_strategy = @retry_strategy + @retry_strategy = analyze_retry_strategy(new_strategy) + yield + ensure + @retry_strategy = old_strategy + end + # # This allows us to call methods remotely with the same syntax as if they were local. @@ -71,27 +104,49 @@ class JsonRpcClient def self.method_missing(name, *args) system_describe unless (@no_auto_config || @service_description) name = name.to_s - @logger.debug "JSON-RPC call: #{self}.#{name}(#{args.join(',')})" if @logger - req_wrapper = @get_procs.include?(name) ? Get.new(self, name, args) : Post.new(self, name, args) + @logger.debug "JSON-RPC call (#{host_and_port}): #{self}.#{name}(#{args.inspect})" if @logger + req_wrapper = @get_procs.include?(name) ? Get.new(self, name, args) : + Post.new(self, name, args, @uri_encode_post_bodies) req = req_wrapper.req + remaining_retries = @retry_strategy[:max_retries] + started_at = Time.now + sleep_time = @retry_strategy[:sleep] begin begin Net::HTTP.start(@host, @port, @proxy_host, @proxy_port) do |http| res = http.request req if res.content_type != 'application/json' - @logger.debug "JSON-RPC server returned non-JSON data: #{res.body}" if @logger - raise NotAService, "Returned #{res.content_type} (status code #{res.code}: #{res.message}) rather than application/json" + @logger.debug "JSON-RPC server (#{host_and_port}) returned non-JSON data: #{res.body}" if @logger + raise GatewayTimeout, "#{res.message} (#{host_and_port})" if res.code == 504 || res.code == "504" + raise ServiceUnavailable, "#{res.message} (#{host_and_port})" if res.code == 503 || res.code == "503" + raise NotAService, "Returned #{res.content_type} (status code #{res.code}: #{res.message}) (#{host_and_port}) rather than application/json" end json = JSON.parse(res.body) rescue raise(ServiceReturnsJunk) - raise ServiceError, "JSON-RPC error #{json['error']['code']}: #{json['error']['message']}" if json['error'] - @logger.debug "JSON-RPC result: #{self.class}.#{name} => #{res.body}" if @logger - return (block_given? ? yield(json['result']) : json['result']) + raise ServiceError, "JSON-RPC error #{json['error']['code']} (#{host_and_port}): #{json['error']['message']}" if json['error'] + @logger.debug "JSON-RPC result (#{host_and_port}): #{self.class}.#{name} => #{res.body}" if @logger + return json['result'] end rescue Errno::ECONNREFUSED - raise ServiceDown, "Connection refused" + raise ServiceDown, "Connection refused (#{host_and_port})" + rescue ::Timeout::Error + raise ServerTimeout, "Server timeout (#{host_and_port})" + end + rescue RetriableError => e + if @retry_strategy[:max_retries] + remaining_retries -= 1 + raise e if remaining_retries < 0 + end + if @retry_strategy[:max_time] && (Time.now >= (started_at + @retry_strategy[:max_time])) + raise e end + if sleep_time + sleep(sleep_time) + sleep_time = sleep_time * @retry_strategy[:sleep_factor] if @retry_strategy[:sleep_factor] + sleep_time = [sleep_time, @retry_strategy[:sleep_max]].min if @retry_strategy[:sleep_max] + end + retry rescue Exception => e - block_given? ? yield(e) : raise(e) + raise(e) end end @@ -135,8 +190,8 @@ class JsonRpcClient def self.system_describe @service_description = :in_progress @service_description = method_missing('system.describe') - raise "JSON-RPC server failed to return a service description" unless @service_description - raise "JSON-RPC server failed to return a standard-compliant service description" unless @service_description['procs'].kind_of?(Array) + raise "JSON-RPC server (#{host_and_port}) failed to return a service description" unless @service_description + raise "JSON-RPC server (#{host_and_port}) failed to return a standard-compliant service description" unless @service_description['procs'].kind_of?(Array) @service_description['procs'].each do |p| @post_procs << p['name'] @get_procs << p['name'] if p['idempotent'] @@ -177,6 +232,7 @@ class JsonRpcClient # in the arglist. # class Get < Request + def initialize(klass, name, args) if args.length == 0 query = '' @@ -201,7 +257,7 @@ class JsonRpcClient @req = Net::HTTP::Get.new(uri) super() end - + end @@ -217,14 +273,21 @@ class JsonRpcClient # class Post < Request - def initialize(klass, name, args) + def initialize(klass, name, args, uri_encode) @req = Net::HTTP::Post.new(klass.service_path) super() @req.add_field 'Content-Type', 'application/json' args = args[0] if args.length == 1 && args[0].is_a?(Hash) body = { :version => '1.1', :method => name, :params => args }.to_json - @req.body = body - klass.logger.debug "JSON-RPC POST request to URI #{klass.host_and_port}#{klass.service_path} with body #{body}" if klass.logger + @req.body = uri_encode ? Post.uri_escape_sanely(body) : body + klass.logger.debug "JSON-RPC POST request #{uri_encode ? '(with URI encoded body) ' : ''}to URI #{klass.host_and_port}#{klass.service_path} with body #{body}" if klass.logger + end + + + OUR_UNSAFE = /[^ _\.!~*'()a-zA-Z\d;\/?:@&=+$,{}\"-]/nm unless defined?(OUR_UNSAFE) + + def self.uri_escape_sanely(str) + URI.escape(str, OUR_UNSAFE).gsub('%5B', '[').gsub('%5D', ']') # Ruby's regexes are BRAIN-DEAD. end end lib/json_rpc_client.rb @@ -2,9 +2,7 @@ # This is the JSON-RPC Service. # module JsonRpcService - - require 'json' - + def self.included(base) base.extend ClassMethods end @@ -66,7 +64,7 @@ module JsonRpcService render :text => req.response, :status => req.status_code end end - + # # This class defines the server side of the JSON-RPC protocol handler. @@ -390,7 +388,7 @@ module JsonRpcService super service, req, par set_error(999, "Content-Type header must be application/json") and return unless req.env['CONTENT_TYPE'] == 'application/json' begin - body = JSON.parse req.raw_post + body = JSON.parse(req.raw_post) rescue JSON.parse(URI.decode(req.raw_post)) rescue Exception => e set_error 999, "JSON did not parse" return lib/json_rpc_service.rb @@ -2,16 +2,19 @@ require File.dirname(__FILE__) + '/spec_helper' describe JsonRpcClient do - before do - class FooController < ApplicationController + before :all do + class FuBarController < ApplicationController json_rpc_service :name => 'TestService', :id => 'skdjfhsdhfkjshdjkhskdhfkjshdf' json_rpc_procedure :name => 'add', :params => [{:name => 'x', :type => 'any'}, {:name => 'y', :type => 'any'}], :proc => :+, :idempotent => true + json_rpc_procedure :name => 'sub', :params => [{:name => 'x', :type => 'any'}, + {:name => 'y', :type => 'any'}], + :proc => :-, :idempotent => true end - class Foo < JsonRpcClient - json_rpc_service 'http://localhost:8888/da_service' + class FuBar < JsonRpcClient + json_rpc_service 'http://localhost:8888/da_service', :no_auto_config => true, :retries => 2 end end @@ -19,13 +22,14 @@ describe JsonRpcClient do it "should request the system description when first called" do Net::HTTP.should_receive(:start).with("localhost", 8888, nil, nil). - and_return(stringify_symbols_in_hash(FooController.service.system_describe)) - Foo.system_describe.should == {"procs"=>[{"name"=>"add", - "idempotent"=>true, - "params"=>[{"name"=>"x", "type"=>"any"}, - {"name"=>"y", "type"=>"any"}], - "return"=>{"type"=>"any"}}], - "name"=>"TestService", "id"=>"skdjfhsdhfkjshdjkhskdhfkjshdf", "sdversion"=>"1.0"} + and_return(stringify_symbols_in_hash(FuBarController.service.system_describe)) + FuBar.system_describe.should == {"procs"=>[{"name"=>"sub", "idempotent"=>true, "params"=>[{"name"=>"x", "type"=>"any"}, {"name"=>"y", "type"=>"any"}], "return"=>{"type"=>"any"}}, + {"name"=>"add", "idempotent"=>true, "params"=>[{"name"=>"x", "type"=>"any"}, {"name"=>"y", "type"=>"any"}], "return"=>{"type"=>"any"}} + ], + "name"=>"TestService", + "id"=>"skdjfhsdhfkjshdjkhskdhfkjshdf", + "sdversion"=>"1.0" + } end @@ -34,40 +38,68 @@ describe JsonRpcClient do and_yield(mock_model(Net::HTTP, :request => mock_model(Net::HTTPRequest, :body => '{"error": {"code": 123, "message": "Disaster!"}}', :content_type => 'application/json'))) - lambda { Foo.add 1, 2 }.should raise_error(JsonRpcClient::ServiceError, 'JSON-RPC error 123: Disaster!') + lambda { FuBar.add 1, 2 }.should raise_error(JsonRpcClient::ServiceError, 'JSON-RPC error 123 (localhost:8888): Disaster!') end + it "should raise a JsonRpcClient::ServiceDown error when the client cannot reach the remote service" do - lambda { Foo.add 1, 2 }.should raise_error(JsonRpcClient::ServiceDown) + lambda { FuBar.add 1, 2 }.should raise_error(JsonRpcClient::ServiceDown) end - it "should raise a JsonRpcClient::NotAService when the service does not return JSON" do + + it "should raise a JsonRpcClient::NotAService when the service returns non-JSON data" do Net::HTTP.should_receive(:start).with("localhost", 8888, nil, nil). - and_yield(mock_model(Net::HTTP, :request => mock_model(Net::HTTPRequest, + and_yield(mock_model(Net::HTTP, :request => mock_model(Net::HTTPRequest, + :code => 12345, :message => 'blablabla', :body => '{"error": {"code": 123, "message": "Disaster!"}}', :content_type => 'text/html'))) - lambda { Foo.add 1, 2 }.should raise_error(JsonRpcClient::NotAService) + lambda { FuBar.add 1, 2 }.should raise_error(JsonRpcClient::NotAService) + end + + + it "should raise a JsonRpcClient::GatewayTimeout when the service returns non-JSON data with a status code of 504" do + Net::HTTP.should_receive(:start).exactly(3).times.with("localhost", 8888, nil, nil). + and_yield(mock_model(Net::HTTP, :request => mock_model(Net::HTTPRequest, + :code => 504, :message => 'blablabla', + :body => '{"error": {"code": 504, "message": "Disaster!"}}', + :content_type => 'text/html'))) + lambda { FuBar.add 1, 2 }.should raise_error(JsonRpcClient::GatewayTimeout) end + + it "should raise a JsonRpcClient::ServiceUnavailable when the service returns non-JSON data with a status code of 503" do + Net::HTTP.should_receive(:start).exactly(3).times.with("localhost", 8888, nil, nil). + and_yield(mock_model(Net::HTTP, :request => mock_model(Net::HTTPRequest, + :code => 503, :message => 'blablabla', + :body => '{"error": {"code": 503, "message": "Disaster!"}}', + :content_type => 'text/html'))) + lambda { FuBar.add 1, 2 }.should raise_error(JsonRpcClient::ServiceUnavailable) + end + + it "should raise a JsonRpcClient::ServiceReturnsJunk when the service returns unparseable JSON" do Net::HTTP.should_receive(:start).with("localhost", 8888, nil, nil). and_yield(mock_model(Net::HTTP, :request => mock_model(Net::HTTPRequest, :body => '<this>is not<json />but some sort of</markup>', :content_type => 'application/json'))) - lambda { Foo.add 1, 2 }.should raise_error(JsonRpcClient::ServiceReturnsJunk) + lambda { FuBar.add 1, 2 }.should raise_error(JsonRpcClient::ServiceReturnsJunk) end - it "should yield the exception to a block, if there is one provided" do - Foo.add(1, 2) { |x| "x is #{x.class}" }.should == "x is JsonRpcClient::ServiceDown" - end - it "should yield the result to a block, if there is one provided" do + # it "should translate ::Timeout::Error exceptions to JsonRpcClient::ServerTimeout exceptions" do + # Net::HTTP.should_receive(:start).with("localhost", 8888, nil, nil).and_raise(::Timeout::Error) + # lambda { FuBar.add 1, 2 }.should raise_error(JsonRpcClient::ServerTimeout) + # end + + + it "should be possible to wrap a call in a retry_strategy block" do Net::HTTP.should_receive(:start).with("localhost", 8888, nil, nil). and_yield(mock_model(Net::HTTP, :request => mock_model(Net::HTTPRequest, - :body => '{"result": 3}', + :body => '{"result": 30}', :content_type => 'application/json'))) - Foo.add(1, 2) { |x| "x is #{x}" }.should == "x is 3" + FuBar.retry_strategy(nil) do + FuBar.add(10, 20) + end end - - + end spec/json_rpc_client_spec.rb @@ -23,34 +23,34 @@ describe JsonRpcService do @request.env['HTTP_USER_AGENT'] = nil req = FooController.service.process @request, {:method => ['add']} req.status_code.should == 500 - req.response.should == "{\"version\": \"1.1\", \"error\": {\"code\":999,\"name\":\"JSONRPCError\",\"message\":\"User-Agent header not specified\"}}\n" + JSON.parse(req.response).should == {"error"=>{"message"=>"User-Agent header not specified", "name"=>"JSONRPCError", "code"=>999}, "version"=>"1.1"} end it "should require a HTTP Accept header specifying JSON" do @request.env['HTTP_ACCEPT'] = 'application/text' req = FooController.service.process @request, {:method => ['add']} req.status_code.should == 500 - req.response.should == "{\"version\": \"1.1\", \"error\": {\"code\":999,\"name\":\"JSONRPCError\",\"message\":\"Accept header must be application\\/json\"}}\n" + JSON.parse(req.response).should == {"error"=>{"message"=>"Accept header must be application/json", "name"=>"JSONRPCError", "code"=>999}, "version"=>"1.1"} end it "should be able to add two strings" do req = FooController.service.process @request, {:method => ['add']} req.status_code.should be_nil - req.response.should == "{\"version\": \"1.1\", \"result\": \"1223\"}\n" + JSON.parse(req.response).should == {"result"=>"1223", "version"=>"1.1"} end it "should aggregate multiple occurrences of the same arg name" do @request.env['QUERY_STRING'] = 'x=AAA&y=BBB&y=CCCCCC&x=DDDDDD' req = FooController.service.process @request, {:method => ['add']} req.status_code.should be_nil - req.response.should == "{\"version\": \"1.1\", \"result\": [\"AAA\",\"DDDDDD\",\"BBB\",\"CCCCCC\"]}\n" + JSON.parse(req.response).should == {"result"=>["AAA", "DDDDDD", "BBB", "CCCCCC"], "version"=>"1.1"} end it "should handle named args" do @request.env['QUERY_STRING'] = 'y=223&x=1' req = FooController.service.process @request, {:method => ['add']} req.status_code.should be_nil - req.response.should == "{\"version\": \"1.1\", \"result\": \"1223\"}\n" + JSON.parse(req.response).should == {"result"=>"1223", "version"=>"1.1"} end it "should also be callable using POST" do @@ -60,7 +60,7 @@ describe JsonRpcService do @request.env['RAW_POST_DATA'] = '{"version": "1.1", "method": "add", "params": ["100", "33"]}' req = FooController.service.process @request, {:method => ['add']} req.status_code.should be_nil - req.response.should == "{\"version\": \"1.1\", \"result\": \"10033\"}\n" + JSON.parse(req.response).should == {"result"=>"10033", "version"=>"1.1"} end end @@ -89,69 +89,69 @@ describe JsonRpcService do @request.env['QUERY_STRING'] = 'x=12&y=23' req = FooController.service.process @request, {:method => ['sub']} req.status_code.should == 500 - req.response.should == "{\"version\": \"1.1\", \"error\": {\"code\":999,\"name\":\"JSONRPCError\",\"message\":\"This method is not idempotent and can only be called using POST.\"}}\n" + JSON.parse(req.response).should == {"error"=>{"message"=>"This method is not idempotent and can only be called using POST.", "name"=>"JSONRPCError", "code"=>999}, "version"=>"1.1"} end it "should require POST data specifying a version" do @request.env['RAW_POST_DATA'] = '{"method": "add", "params": [10, 25]}' req = FooController.service.process @request, {:method => ['sub']} req.status_code.should == 500 - req.response.should == "{\"version\": \"1.1\", \"error\": {\"code\":999,\"name\":\"JSONRPCError\",\"message\":\"JSON-RPC client protocol version must be specified in POSTs\"}}\n" + JSON.parse(req.response).should == {"error"=>{"message"=>"JSON-RPC client protocol version must be specified in POSTs", "name"=>"JSONRPCError", "code"=>999}, "version"=>"1.1"} end it "should handle positional arguments" do req = FooController.service.process @request, {:method => ['sub']} req.status_code.should be_nil - req.response.should == "{\"version\": \"1.1\", \"result\": 67}\n" + JSON.parse(req.response).should == {"result"=>67, "version"=>"1.1"} end it "should handle named arguments" do @request.env['RAW_POST_DATA'] = '{"version": "2.99", "method": "sub", "params": {"y": 33, "x": 100}}' req = FooController.service.process @request, {:method => ['sub']} req.status_code.should be_nil - req.response.should == "{\"version\": \"1.1\", \"result\": 67}\n" + JSON.parse(req.response).should == {"result"=>67, "version"=>"1.1"} end it "should handle arguments with numerical order" do @request.env['RAW_POST_DATA'] = '{"version": "2.99", "method": "sub", "params": {"1": 33, "0": 100}}' req = FooController.service.process @request, {:method => ['sub']} req.status_code.should be_nil - req.response.should == "{\"version\": \"1.1\", \"result\": 67}\n" + JSON.parse(req.response).should == {"result"=>67, "version"=>"1.1"} end it "should handle mixed arguments" do @request.env['RAW_POST_DATA'] = '{"version": "2.99", "method": "sub", "params": {"y": 33, "0": 100}}' req = FooController.service.process @request, {:method => ['sub']} req.status_code.should be_nil - req.response.should == "{\"version\": \"1.1\", \"result\": 67}\n" + JSON.parse(req.response).should == {"result"=>67, "version"=>"1.1"} end it "should require a Content-Type header specifying JSON" do @request.env['CONTENT_TYPE'] = 'application/html' req = FooController.service.process @request, {:method => ['sub']} req.status_code.should == 500 - req.response.should == "{\"version\": \"1.1\", \"error\": {\"code\":999,\"name\":\"JSONRPCError\",\"message\":\"Content-Type header must be application\\/json\"}}\n" + JSON.parse(req.response).should == {"error"=>{"message"=>"Content-Type header must be application/json", "name"=>"JSONRPCError", "code"=>999}, "version"=>"1.1"} end it "should require POST data specifying the method to call" do @request.env['RAW_POST_DATA'] = '{"version": "2.99", "params": [10, 25]}' req = FooController.service.process @request, {:method => ['sub']} req.status_code.should == 500 - req.response.should == "{\"version\": \"1.1\", \"error\": {\"code\":999,\"name\":\"JSONRPCError\",\"message\":\"Method not specified\"}}\n" + JSON.parse(req.response).should == {"error"=>{"message"=>"Method not specified", "name"=>"JSONRPCError", "code"=>999}, "version"=>"1.1"} end it "should require POST data specifying an existing method to call" do @request.env['RAW_POST_DATA'] = '{"version": "2.99", "method": "zzz", "params": [10, 25]}' req = FooController.service.process @request, {:method => ['sub']} req.status_code.should == 500 - req.response.should == "{\"version\": \"1.1\", \"error\": {\"code\":999,\"name\":\"JSONRPCError\",\"message\":\"This JSON-RPC service does not provide a 'zzz' method.\"}}\n" + JSON.parse(req.response).should == {"error"=>{"message"=>"This JSON-RPC service does not provide a 'zzz' method.", "name"=>"JSONRPCError", "code"=>999}, "version"=>"1.1"} end it "should barf on missing numerical arguments" do @request.env['RAW_POST_DATA'] = '{"version": "2.99", "method": "sub", "params": [10]}' req = FooController.service.process @request, {:method => ['sub']} req.status_code.should == 500 - req.response.should == "{\"version\": \"1.1\", \"error\": {\"code\":999,\"name\":\"JSONRPCError\",\"message\":\"The arg y must be numeric (was null)\"}}\n" + JSON.parse(req.response).should == {"error"=>{"message"=>"The arg y must be numeric (was null)", "name"=>"JSONRPCError", "code"=>999}, "version"=>"1.1"} end it "should barf on excess arguments" do @@ -164,7 +164,7 @@ describe JsonRpcService do @request.env['RAW_POST_DATA'] = '{"version": "2.99", "method": "sub", "params": {"y": 10, "x": "blah"}}' req = FooController.service.process @request, {:method => ['sub']} req.status_code.should == 500 - req.response.should == "{\"version\": \"1.1\", \"error\": {\"code\":999,\"name\":\"JSONRPCError\",\"message\":\"The arg x must be numeric (was \\\"blah\\\")\"}}\n" + JSON.parse(req.response).should == {"error"=>{"message"=>"The arg x must be numeric (was \"blah\")", "name"=>"JSONRPCError", "code"=>999}, "version"=>"1.1"} end end @@ -190,7 +190,7 @@ describe JsonRpcService do @request.env['REQUEST_METHOD'] = 'PUT' req = FooController.service.process @request, {:method => ['add']} req.status_code.should == 500 - req.response.should == "{\"version\": \"1.1\", \"error\": {\"code\":999,\"name\":\"JSONRPCError\",\"message\":\"Only POST and GET supported\"}}\n" + JSON.parse(req.response).should == {"error"=>{"message"=>"Only POST and GET supported", "name"=>"JSONRPCError", "code"=>999}, "version"=>"1.1"} end end spec/json_rpc_service_call_spec.rb @@ -1,11 +1,20 @@ -require File.dirname(__FILE__) + '/../../../../spec/spec_helper' +begin + require File.dirname(__FILE__) + '/../../../../spec/spec_helper' +rescue LoadError + puts "You need to install rspec in your base app" + exit +end plugin_spec_dir = File.dirname(__FILE__) ActiveRecord::Base.logger = Logger.new(plugin_spec_dir + "/debug.log") + require 'spec' require 'spec/rails' +load File.expand_path(File.dirname(__FILE__) + '/../lib/json_rpc_client.rb') # To get rid of the redefinition in laplace + + class Hash def except(*keys) @@ -34,6 +43,7 @@ def stringify_symbols_in_hash(h) end res end + def stringify_symbols_in_array(h) res = [] h.each do |v| spec/spec_helper.rb @@ -1,4 +1,7 @@ -# desc "Explaining what the task does" -# task :json_rpc do -# # Task goes here -# end +desc "Copies the local version of the json_rpc to the shared plugin for later submission to git" +task :json_rpc do + from = RAILS_ROOT + '/vendor/plugins/json_rpc/*' + to = File.expand_path RAILS_ROOT + '/../json_rpc/' + `cp -Rf #{from} #{to}` + puts "The json_rpc plugin has been updated. You must now submit the changes to git in the usual manner." +end tasks/json_rpc_tasks.rake 91ebd7a3c7fbad123314615b95ce15c8a85b7300 Peter Bengtson peter@peterbengtson.com http://github.com/PeterBengtson/json-rpc-1-1/commit/1c0b064b67d4f6f32485eb5098d2bb6fe7067f8f 1c0b064b67d4f6f32485eb5098d2bb6fe7067f8f 2009-04-19T01:18:25-07:00 2009-04-19T01:18:25-07:00 Many new features: queues, retries, etc. 12dba5bca3e49c90c12576ebdcfeef52eefd31dd Peter Bengtson peter@peterbengtson.com