LVS-JSONService 0.0.0 → 0.1.0

data/JSONService.gemspec

@@ -0,0 +1,57 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{JSONService}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["LVS"]
+  s.date = %q{2009-06-18}
+  s.email = %q{info@lvs.co.uk}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    "JSONService.gemspec",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/json_service.rb",
+     "lib/lvs/json_service/base.rb",
+     "lib/lvs/json_service/logger.rb",
+     "lib/lvs/json_service/request.rb",
+     "spec/fixtures/error_response.yml",
+     "spec/fixtures/response.yml",
+     "spec/json_service_spec.rb",
+     "spec/lvs/json_service/base_spec.rb",
+     "spec/lvs/json_service/logger_spec.rb",
+     "spec/lvs/json_service/request_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/lvs/JSONService}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{TODO}
+  s.test_files = [
+    "spec/lvs/json_service/base_spec.rb",
+     "spec/lvs/json_service/logger_spec.rb",
+     "spec/lvs/json_service/request_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/json_service_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.1.0

data/lib/lvs/json_service/base.rb

@@ -0,0 +1,194 @@
+require 'activesupport'
+require 'net/https'
+require 'lvs/json_service/request'
+
+module LVS
+  module JsonService
+    class Base
+      include ::LVS::JsonService::Request
+
+      @@services = []
+      @@cache = CACHE if defined?(CACHE)
+      @@service_prefix = ""
+      attr_accessor :fields
+      cattr_accessor :service_prefix
+      cattr_accessor :field_prefix
+      cattr_accessor :cache
+
+      protected
+
+      def self.site=(value)
+        # value is containing AGP_LOCATION already sometimes:
+        if SSL_DISABLED
+          value.gsub!(/^#{AGP_LOCATION}/, '') if AGP_LOCATION && value.match(/#{AGP_LOCATION}/)
+          agp = AGP_LOCATION.gsub(/\/$/, '')
+        else
+          value.gsub!(/^#{AGP_LOCATION}/, '')
+          value.gsub!(/^#{SSL_AGP_LOCATION}/, '') if SSL_AGP_LOCATION && value.match(/#{SSL_AGP_LOCATION}/)
+          agp = SSL_AGP_LOCATION.gsub(/\/$/, '')
+        end
+        value.gsub!(/^\//, '')
+        @@site = (agp + '/' + value)
+      end
+
+      def self.debug(message)
+        Rails.logger.debug " \033[1;4;32mLVS::JsonService\033[0m #{message}"
+      end
+
+      def self.define_cached_service(name, service, options)
+        (class<<self;self;end).send :define_method, name do |*args|
+          begin
+            args = args.first || {}
+            options[:cache_time] ||= 10
+            service_name = "call_#{name}"
+            mutex ||= Mutex::new
+            tried = false
+            mutex.lock if AppTools.is_memcached_threaded?
+            begin
+              jsn_data = { }
+              if ActionController::Base.perform_caching && @@cache
+                Rails.logger.info("JSON API CACHED CALL: #{service} - #{args.to_yaml}")
+                key = "json:call:" + Digest::MD5.hexdigest("#{service}:#{args.to_s}")
+                cached = @@cache.get(key)
+                if cached.nil?
+                  result = self.send(service_name, args)
+                  @@cache.set(key, result, options[:cache_time])
+                  jsn_data = result
+                else
+                  jsn_data = cached
+                end
+              else
+                Rails.logger.info("JSON API CALL: #{method} - #{args.to_yaml}")
+                jsn_data = self.send(service_name, args)
+              end
+              jsn_data
+            rescue MemCache::MemCacheError => err
+              raise err if tried
+              Rails.logger.info("JSON API CALL RETRY: #{err} - #{method} - #{args.to_yaml}")
+              tried = true
+              retry
+            end
+          ensure
+            mutex.unlock if AppTools.is_memcached_threaded?
+          end
+        end
+      end
+
+      def self.define_service(name, service, options = {})
+        service_name = name
+
+        service_path = service.split('.')
+        if service_path.size <= 2
+          internal_service = service
+          prefix = @@service_prefix
+        else
+          internal_service = service_path[-2..-1].join('.')
+          prefix = service_path[0..-3].join('.') + '.'
+        end
+
+        if options[:cached]
+          service_name = "call_#{name}"
+          self.define_cached_service(name, service, options)
+        end
+
+        (class<<self;self;end).send :define_method, service_name do |args|
+          method_params, flags = args
+
+          method_params ||= {}
+          options[:defaults] ||= {}
+          options[:defaults].each_pair do |key, value|
+            method_params[key] = value if method_params[key].blank?
+          end
+          options[:required] ||= {}
+          options[:required].each do |key|
+            raise LVS::JsonService::Error.new("Required field #{key} wasn't supplied", internal_service, '0', method_params) if method_params[key].blank?
+          end
+          result = self.run_remote_request(@@site + prefix + internal_service, method_params, options)
+          if flags && flags[:raw]
+            result
+          else
+            self.parse_result(result)
+          end
+        end
+
+        @@services << name
+      end
+
+      def self.fake_service(name, json)
+        (class<<self;self;end).send :define_method, name do |*args|
+          self.parse_result(JSON.parse(json))
+        end
+        @@services << name
+      end
+
+      def self.services
+        @@services
+      end
+
+      def self.parse_result(response)
+        if response.is_a?(Array)
+          response.map { |x| self.new(x) }
+        else
+          self.new(response)
+        end
+      end
+
+      def initialize(values = {})
+        values.each_pair do |key, value|
+          key = key.underscore
+          self.class.send(:define_method, key, proc {self.instance_variable_get("@#{key}")})
+          self.class.send(:define_method, "#{key}=", proc {|value| self.instance_variable_set("@#{key}", value)})
+
+          # If the key starts with has_ create alias to has_ method removing has
+          # and putting ? at the end
+          if key =~ /^has_/
+            temp_key = "#{key.gsub(/^has_/, '')}?"
+            self.class.send(:define_method, temp_key, proc {self.instance_variable_get("@#{key}")})
+            self.class.send(:define_method, "#{temp_key}=", proc {|value| self.instance_variable_set("@#{key}", value)})
+          end
+
+          if value.is_a?(Hash)
+            self.instance_variable_set("@#{key}", self.class.new(value))
+          elsif value.is_a?(Array)
+            self.instance_variable_set("@#{key}", value.collect {|v| if v.is_a?(Hash) or v.is_a?(Array) then self.class.new(v) else v end })
+          else
+            if key =~ /date$/
+              value = Time.at(value/1000)
+            elsif key =~ /^has_/
+              self.instance_variable_set("@#{key}", value)
+              !(value == 0 || value.blank?)
+            elsif key =~ /\?$/
+              key = "has_#{key.chop}"
+              !(value == 0 || value.blank?)
+            end
+
+            self.instance_variable_set("@#{key}", value)
+          end
+        end
+      end
+
+      def method_missing(*args)
+        self.class.debug("Method #{args[0]} called on #{self.class} but is non-existant, returned default FALSE")
+        super
+      end
+    end
+
+    class Error < StandardError
+      attr_reader :message, :code, :service, :args, :json_response
+
+      def initialize(message, code, service, args, response=nil)
+        @message = message
+        @code   = code
+        @service = service
+        @args   = args
+        @json_response = response
+
+        super "#{message}\n#{service} (#{args.inspect})"
+      end
+    end
+
+    class NotFoundError < Error; end
+    class TimeoutError < Error; end
+    class BackendUnavailableError < Error; end
+  end
+end

data/lib/lvs/json_service/logger.rb

@@ -0,0 +1,11 @@
+module LVS
+  module JsonService
+    module Logger
+      def self.debug(message)
+        if const_defined?(:RAILS_DEFAULT_LOGGER)
+          RAILS_DEFAULT_LOGGER.debug(message)
+        end
+      end
+    end
+  end
+end

data/lib/lvs/json_service/request.rb

@@ -0,0 +1,76 @@
+require 'json'
+require 'lvs/json_service/logger'
+
+module LVS
+  module JsonService
+    module Request
+      def self.http_request_with_timeout(service, args, options)
+
+        uri = URI.parse(service)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        
+        if options[:encrypted] && !SSL_DISABLED
+          http.use_ssl = true
+          if options[:auth_cert]
+            http.cert = OpenSSL::X509::Certificate.new(File.read(options[:auth_cert]))
+            http.key = OpenSSL::PKey::RSA.new(File.read(options[:auth_key]), options[:auth_key_password])
+          end
+        end
+        
+        http.open_timeout = options[:timeout] || 1
+        http.read_timeout = options[:timeout] || 1
+        
+        req = Net::HTTP::Post.new(uri.path)
+        req.form_data = { "object_request" => args.to_json }
+
+        retries = options[:retries] || 0
+
+        begin
+          retries -= 1          
+          response = http.start { |connection| connection.request(req) }
+          
+        rescue Timeout::Error
+          if retries >= 0
+            LVS::JsonService::Logger.debug(
+              "Retrying #{service} due to TimeoutError"
+            )
+            retry
+          end
+          raise LVS::JsonService::TimeoutError.new("Backend failed to respond in time", 500, service, args)
+                    
+        rescue Errno::ECONNREFUSED
+          if retries >= 0
+            LVS::JsonService::Logger.debug(
+              "Retrying #{service} due to Errno::ECONNREFUSED"
+            )
+            sleep(1)  
+            retry
+          end
+          raise LVS::JsonService::BackendUnavailableError.new("Backend unavailable", 500, service, args)
+        end
+
+        if response.is_a?(Net::HTTPNotFound)
+          raise LVS::JsonService::NotFoundError.new("404 Found for the service", 404, service, args)
+        end
+
+        response
+      end
+
+      def self.run_remote_request(service, args, options = {})
+        LVS::JsonService::Logger.debug "run_remote_request('#{service}', #{args.to_json}"
+        response = http_request_with_timeout(service, args, options)
+        if response.body.size < 1024
+          LVS::JsonService::Logger.debug "Response: #{response.body.gsub(/\n/, '')}"
+        else
+          LVS::JsonService::Logger.debug "Response Snippet: #{response.body.gsub(/\n/, '')[0..1024]}"
+        end
+        result = JSON.parse(response.body)
+        if result.is_a?(Hash) && result.has_key?("PCode")
+          raise LVS::JsonService::Error.new(result["message"], result["PCode"], service, args, result)
+        end
+        result
+      end
+    end
+  end
+end

data/spec/fixtures/error_response.yml

@@ -0,0 +1,21 @@
+--- !ruby/object:Net::HTTPOK 
+body: |
+  {
+    "PCode" : 1,
+    "message": "something bad happened"
+  }
+body_exist: true
+code: "200"
+header: 
+  date: 
+  - Wed, 17 Jun 2009 13:17:54 GMT
+  content-type: 
+  - text/plain;charset=UTF-8
+  server: 
+  - Apache-Coyote/1.1
+  transfer-encoding: 
+  - chunked
+http_version: "1.1"
+message: OK
+read: true
+socket: 

data/spec/fixtures/response.yml

@@ -0,0 +1,27 @@
+--- !ruby/object:Net::HTTPOK 
+body: |-
+  [
+    {
+    "description": "Handball (ABP)",
+    "id": 1100
+   },
+    {
+    "description": "Casino Roulette",
+    "id": 978400
+   }
+  ]
+body_exist: true
+code: "200"
+header: 
+  date: 
+  - Wed, 17 Jun 2009 13:17:54 GMT
+  content-type: 
+  - text/plain;charset=UTF-8
+  server: 
+  - Apache-Coyote/1.1
+  transfer-encoding: 
+  - chunked
+http_version: "1.1"
+message: OK
+read: true
+socket: 

data/spec/lvs/json_service/base_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe LVS::JsonService::Base do
+  it "should include Request" do
+    LVS::JsonService::Base.ancestors.should include(LVS::JsonService::Request)
+  end
+end

data/spec/lvs/json_service/logger_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe LVS::JsonService::Logger do
+  before :each do
+  end
+
+  describe "debug" do
+    describe "with RAILS_DEFAULT_LOGGER set" do
+      before :each do
+        @mock_logger = mock()
+        LVS::JsonService::Logger.const_set(:RAILS_DEFAULT_LOGGER, @mock_logger)
+      end
+
+      it "should pass the message to RAILS_DEFAULT_LOGGER" do
+        message = "Some debug message"
+        @mock_logger.should_receive(:debug).with(message)
+        LVS::JsonService::Logger.debug(message)
+      end
+    end
+
+    describe "without RAILS_ROOT set" do
+      before :each do
+        LVS::JsonService::Logger.module_eval do
+          remove_const(:RAILS_DEFAULT_LOGGER) if const_defined?(:RAILS_DEFAULT_LOGGER)
+        end
+      end
+
+      it "should not raise an exception" do
+        lambda {
+          LVS::JsonService::Logger.debug("something")
+        }.should_not raise_error(Exception)
+      end
+    end
+  end
+end

data/spec/lvs/json_service/request_spec.rb

@@ -0,0 +1,249 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+# Explicitly requiring this now to ensure it is loaded before we try to
+# unmarshall response from the yaml fixture file.
+require 'net/http'
+
+describe LVS::JsonService::Request do
+  before :each do
+    @domain = "example.com"
+    @path   = "/some/path"
+    @port   = 80
+    @url    = "http://#{@domain}#{@path}"
+
+    @args   = {:some => "thing"}
+    @options= {:timeout => 100}
+  end
+  
+  describe ".http_request_with_timeout" do
+    before :each do 
+      @mock_post = mock(:post, :null_object => true)
+      Net::HTTP::Post.stub!(:new).and_return(@mock_post)
+      
+      @mock_http = MockNetHttp.new
+      @connection = @mock_http.connection
+      Net::HTTP.stub!(:new).and_return(@mock_http)      
+    end
+    
+    it "should set Net::HTTP#open_timeout" do
+      @mock_http.should_receive(:open_timeout=).with(@options[:timeout])
+      do_request      
+    end
+    
+    it "should set Net::HTTP#read_timeout" do
+      @mock_http.should_receive(:read_timeout=).with(@options[:timeout])      
+      do_request      
+    end    
+    
+    it "should default to a timeout of 1 if not set" do
+      @options = {:timeout => nil}
+      @mock_http.should_receive(:read_timeout=).with(1)     
+      do_request
+    end
+    
+    it "should pass through the domain and port to Net::HTTP" do
+      Net::HTTP.should_receive(:new).with(@domain, @port).and_return(@mock_http)
+      do_request
+    end
+    
+    it "should create a Net::HTTP::Post object" do
+      Net::HTTP::Post.should_receive(:new).with(@path).and_return(@mock_post)
+      do_request
+    end
+    
+    it "should assign the JSON parameters to a Net::HTTP::Post object" do
+      @mock_post.should_receive(:form_data=).with({ "object_request" => @args.to_json })
+      do_request
+    end
+    
+    it "should send one request to Net::HTTP#start" do
+      @connection.should_receive(:request).once.with(@mock_post)
+      do_request
+    end
+    
+    it "should return the response from the service" do
+      response = "some response"
+      @connection.should_receive(:request).and_return(response)
+      do_request.should == response
+    end
+    
+    describe "with 2 retries of Timeout::Error" do
+      
+      before :each do
+        @options = {:retries => 2}
+      end
+
+      describe "with subsequent success" do
+
+        it "should post the request 2 times" do
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_raise(Timeout::Error.new(nil))                
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered
+          do_request                
+        end   
+        
+        it "should return the response from the service" do
+          response = "some response"
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_raise(Timeout::Error.new(nil))                
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_return(response)
+          do_request.should == response          
+        end
+        
+      end
+            
+      it "should log the retry attempt" do
+        @connection.stub!(:request).and_raise(Timeout::Error.new(nil))
+        LVS::JsonService::Logger.should_receive(:debug).at_least(1).times.
+          with("Retrying #{@url} due to TimeoutError")
+        do_request_catching_errors
+      end
+      
+      describe "with subseqent failure" do
+
+        before :each do
+          @connection.stub!(:request).and_raise(Timeout::Error.new(nil))
+        end
+
+        it "should post the request 3 times (original + 2 retries)" do
+          @connection.should_receive(:request).with(@mock_post).exactly(3).times.and_raise(Timeout::Error.new(nil))        
+          do_request_catching_errors
+        end
+
+        it "should raise an LVS::JsonService::TimeoutError exception" do
+          lambda {
+            do_request
+          }.should raise_error(LVS::JsonService::TimeoutError)
+        end
+      end
+        
+    end
+    
+    describe "with 2 retries of Errno::ECONNREFUSED" do
+      
+      before :each do
+        @options = {:retries => 2}
+        LVS::JsonService::Request.stub!(:sleep)                  
+      end
+      
+      it "should sleep for 1 second before each timeout" do
+        @connection.stub!(:request).and_raise(Errno::ECONNREFUSED)        
+        LVS::JsonService::Request.should_receive(:sleep).with(1)
+        do_request_catching_errors
+      end
+      
+      describe "with subsequent success" do
+
+        it "should post the request 2 times" do
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_raise(Errno::ECONNREFUSED)                
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered
+          do_request                
+        end   
+        
+        it "should return the response from the service" do
+          response = "some response"
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_raise(Errno::ECONNREFUSED)                
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_return(response)
+          do_request.should == response
+        end
+      end
+
+      describe "with subsequent failure" do
+        
+        before :each do
+          @connection.stub!(:request).and_raise(Errno::ECONNREFUSED)      
+        end        
+        
+        it "should post the request 3 times (original + 2 retries)" do
+          @connection.should_receive(:request).with(@mock_post).exactly(3).times.and_raise(Errno::ECONNREFUSED)        
+          do_request_catching_errors
+        end      
+
+        it "should raise an LVS::JsonService::BackendUnavailableError exception" do
+          lambda {
+            do_request
+          }.should raise_error(LVS::JsonService::BackendUnavailableError)
+        end
+
+      end
+
+      it "should log the retry attempt" do
+        @connection.stub!(:request).and_raise(Errno::ECONNREFUSED)
+        LVS::JsonService::Logger.should_receive(:debug).at_least(1).times.
+          with("Retrying #{@url} due to Errno::ECONNREFUSED")
+        do_request_catching_errors
+      end
+    end
+
+    it "should raise LVS::JsonService::NotFoundError if Net::HTTPNotFound is raised" do
+      @connection.stub!(:request).and_return(Net::HTTPNotFound.new(404, 1.1, "Not Found"))
+      lambda {
+        do_request
+      }.should raise_error(LVS::JsonService::NotFoundError)
+    end
+    
+    def do_request
+      LVS::JsonService::Request.http_request_with_timeout(@url, @args, @options)
+    end
+    
+    def do_request_catching_errors
+      do_request
+    rescue LVS::JsonService::Error
+    end
+    
+  end
+
+  describe ".run_remote_request" do
+    before :each do
+      @response = load_fixture('response.yml')
+    end
+
+    it "should call http_request_with_timeout with service, args and options" do
+      LVS::JsonService::Request.should_receive(:http_request_with_timeout).
+        with(@url, @args, @options).
+        and_return(@response)
+      LVS::JsonService::Request.run_remote_request(@url, @args, @options)
+    end
+
+    it "should return the parsed JSON result" do
+      expected_result = [
+        {"id"=>1100, "description"=>"Handball (ABP)"},
+        {"id"=>978400, "description"=>"Casino Roulette"}
+      ]
+      LVS::JsonService::Request.stub!(:http_request_with_timeout).and_return(@response)
+      LVS::JsonService::Request.run_remote_request(@url, @args, @options).should == expected_result
+    end
+
+    it "should raise an error if the response contains PCode" do
+      error_response = load_fixture('error_response.yml')
+      LVS::JsonService::Request.stub!(:http_request_with_timeout).
+        and_return(error_response)
+
+      lambda {
+        LVS::JsonService::Request.run_remote_request(@url, @args, @options)
+      }.should raise_error(LVS::JsonService::Error)
+    end
+  end
+  
+end
+
+def load_fixture (file)
+  response_file = File.join(File.dirname(__FILE__), '..', '..', 'fixtures', file)
+  YAML.load_file(response_file)
+end
+
+class MockNetHttp
+  
+  attr_accessor :connection
+  
+  def initialize(*args)
+    @connection = mock(:connection)    
+  end
+  
+  def start
+    yield @connection
+  end  
+    
+  def method_missing(*args)
+    return self
+  end
+    
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: LVS-JSONService
 version: !ruby/object:Gem::Version 
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors: 
 - LVS
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-12 00:00:00 -07:00
+date: 2009-06-18 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -23,14 +23,24 @@ extra_rdoc_files:
 - LICENSE
 - README.rdoc
 files: 
+- JSONService.gemspec
 - LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
 - lib/json_service.rb
+- lib/lvs/json_service/base.rb
+- lib/lvs/json_service/logger.rb
+- lib/lvs/json_service/request.rb
+- spec/fixtures/error_response.yml
+- spec/fixtures/response.yml
 - spec/json_service_spec.rb
+- spec/lvs/json_service/base_spec.rb
+- spec/lvs/json_service/logger_spec.rb
+- spec/lvs/json_service/request_spec.rb
+- spec/spec.opts
 - spec/spec_helper.rb
-has_rdoc: false
+has_rdoc: true
 homepage: http://github.com/lvs/JSONService
 post_install_message: 
 rdoc_options: 
@@ -54,8 +64,11 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.2.0
 signing_key: 
-specification_version: 3
+specification_version: 2
 summary: TODO
 test_files: 
-- spec/json_service_spec.rb
+- spec/lvs/json_service/base_spec.rb
+- spec/lvs/json_service/logger_spec.rb
+- spec/lvs/json_service/request_spec.rb
 - spec/spec_helper.rb
+- spec/json_service_spec.rb