LVS-JSONService 0.4.2 → 0.4.3

data/.specification

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: LVS-JSONService 
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
+  version: 0.4.3
 require_paths:
 - lib
 platform: ruby

data/LVS-JSONService.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{LVS-JSONService}
-  s.version = "0.4.2"
+  s.version = "0.4.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["LVS", "andyjeffries"]
-  s.date = %q{2009-08-06}
+  s.date = %q{2010-01-19}
   s.email = %q{info@lvs.co.uk}
   s.extra_rdoc_files = [
     "LICENSE",

data/VERSION

@@ -1 +1 @@
-0.4.2
+0.4.3

data/lib/json_service.rb

@@ -1,2 +1,6 @@
+require 'rubygems'
+require 'activesupport'
+require 'eventmachine'
+require 'em-http'
 require 'lvs/json_service/base'
 require 'lvs/json_service/logger'

data/lib/lvs/json_service/base.rb

@@ -12,15 +12,16 @@ module LVS
       protected
 
       class << self
-        @site = ""
-        @services = []
-        @service_prefix = ""
-        @field_prefix = ""
-        @encrypted = false
-        @ignore_missing = false
-        @auth_cert = ""
-        @auth_key = ""
-        @auth_key_pass = ""
+        @site               = ""
+        @services           = []
+        @service_prefix     = ""
+        @field_prefix       = ""
+        @encrypted          = false
+        @ignore_missing     = false
+        @auth_cert          = ""
+        @auth_key           = ""
+        @auth_key_pass      = ""
+        @eventmachine_async = false
 
         def encrypted=(value)
           @encrypted = value
@@ -55,6 +56,10 @@ module LVS
           @field_prefix = value
         end
         
+        def is_eventmachine_async!
+          @eventmachine_async = true
+        end
+        
         def site=(value)
           # value is containing AGP_LOCATION already sometimes:
           value.gsub!(/^#{AGP_LOCATION}/, '') if defined?(AGP_LOCATION) && value.match(/#{AGP_LOCATION}/)
@@ -80,7 +85,7 @@ module LVS
           (Module.const_defined?(:SSL_ENABLED) && SSL_ENABLED) || (Module.const_defined?(:SSL_DISABLED) && !SSL_DISABLED)
         end
 
-        def define_service(name, service, options = {})
+        def define_service(name, service, options = {}, &block)
           service_name = name
 
           service_path = service.split('.')
@@ -92,12 +97,13 @@ module LVS
             prefix = service_path[0..-3].join('.') + '.'
           end
 
-          options[:encrypted]     = @encrypted if @encrypted
-          options[:auth_cert]     = @auth_cert if @auth_cert
-          options[:auth_key]      = @auth_key if @auth_key
-          options[:auth_key_pass] = @auth_key_pass if @auth_key_pass
+          options[:encrypted]          = @encrypted if @encrypted
+          options[:eventmachine_async] = @eventmachine_async if @eventmachine_async
+          options[:auth_cert]          = @auth_cert if @auth_cert
+          options[:auth_key]           = @auth_key if @auth_key
+          options[:auth_key_pass]      = @auth_key_pass if @auth_key_pass
           
-          (class<<self;self;end).send :define_method, service_name do |*args|
+          (class<<self;self;end).send :define_method, service_name do |*args, &block|
             method_params, flags = args
 
             method_params ||= {}
@@ -109,11 +115,22 @@ module LVS
             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
+            if block
+              self.run_remote_request(@site + prefix + internal_service, method_params, options) do |result|
+                if flags && flags[:raw]
+                  yield(result)
+                else
+                  block.call(self.parse_result(result))
+                end
+              end
             else
-              self.parse_result(result)
+              result = self.run_remote_request(@site + prefix + internal_service, method_params, options)
+              puts "In service call non-block"
+              if flags && flags[:raw]
+                result
+              else
+                self.parse_result(result)
+              end
             end
           end
 
@@ -132,7 +149,9 @@ module LVS
         end
 
         def parse_result(response)
-          if response.is_a?(Array)
+          if response.is_a?(LVS::JsonService::Error)
+            response
+          elsif response.is_a?(Array)
             array = response.map { |x| self.new(x) }
           else
             self.new(response)
@@ -267,7 +286,7 @@ module LVS
     end
 
     class Error < StandardError
-      attr_reader :message, :code, :service, :args, :json_response
+      attr_reader :message, :code, :service, :args, :json_response, :backtrace
 
       def initialize(message, code=nil, service=nil, args=nil, response=nil)
         @message = message
@@ -275,6 +294,7 @@ module LVS
         @service = service
         @args   = args
         @json_response = response
+        @backtrace = caller
 
         super "#{message}\n#{service} (#{args.inspect})"
       end

data/lib/lvs/json_service/request.rb

@@ -1,4 +1,5 @@
 require 'json'
+require 'ostruct'
 require 'lvs/json_service/logger'
 require 'lvs/json_service/connection_manager'
 
@@ -15,7 +16,7 @@ module LVS
           Digest::SHA1.hexdigest((rand(4294967295)+Time.now.usec).to_s)
         end
         
-        def http_request_with_timeout(service, args, options)
+        def http_standard_request_with_timeout(service, args, options)
           uri = URI.parse(service)
         
           req = Net::HTTP::Post.new(uri.path)
@@ -65,7 +66,6 @@ module LVS
             
           rescue OpenSSL::SSL::SSLError => e
             raise LVS::JsonService::BackendUnavailableError.new("Backend unavailable #{e}", 500, service, args)
-            
           end
 
           if response.is_a?(Net::HTTPNotFound)
@@ -76,55 +76,110 @@ module LVS
             raise LVS::JsonService::NotModified.new("304 Data hasn't changed", 304, service, args)
           end
 
-          response
+          yield(response)
+        end
+
+        def http_eventmachine_request_with_timeout(service, args, options)
+          http_options = {}
+          http_options[:timeout] = options[:timeout] || 1
+          http_options[:head] = {"X-LVS-Request-ID" => options[:request_id]}
+          http_options[:body] = {"object_request" => args.to_json}
+          
+          http = EventMachine::HttpRequest.new(service).post(http_options)
+          http.callback {
+            response = OpenStruct.new(:request_id => http.response_header["X-LVS-Request-ID"], :body => http.response)
+            yield(response)
+          }
+          http.errback {
+            if (http.response_header.status == 404)
+              yield(LVS::JsonService::NotFoundError.new("404 Found for the service #{service}", 404, service, args))
+            elsif (http.response_header.status == 304)
+              yield(LVS::JsonService::NotModified.new("304 Data hasn't changed", 304, service, args))
+            elsif (http.response_header.status == 0)
+              yield(LVS::JsonService::BackendUnavailableError.new("Backend unavailable (in time)", 500, service, args))
+            else
+              yield(LVS::JsonService::Error.new("Unknown error (#{http.response_header.inspect})", 500, service, args))
+            end
+          }
         end
 
         def run_remote_request(service, args, options = {})
           LVS::JsonService::Logger.debug "Requesting '#{service}' with #{args.to_json}"
           
+          response             = nil
+          result               = nil
           options[:request_id] = unique_request_id
+          
           if options[:cached_for]
             timing = "CACHED"
-            response, result = Rails.cache.fetch([service, args].cache_key, :expires_in => options[:cached_for]) do
-              start = Time.now
-              response = http_request_with_timeout(service, args, options)
-              verify_request_id(response, options[:request_id])
-              net_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
-              start = Time.now
-              result = JSON.parse(response.body)
-              parse_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
-              timing = "Net: #{net_timing}, Parse: #{parse_timing}"
-              [response, result]
+            response, result = Rails.cache.read([service, args].cache_key, :expires_in => options[:cached_for])
+          end
+          if response.nil?
+            start = Time.now
+            if options[:eventmachine_async]
+              http_eventmachine_request_with_timeout(service, args, options) do |response|
+                if response.is_a?(LVS::JsonService::Error)
+                  result = response
+                else
+                  verify_request_id(response.request_id, options[:request_id])
+                  net_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+                  start = Time.now
+                  result = JSON.parse(response.body)
+                  parse_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+                  timing = "Net: #{net_timing}, Parse: #{parse_timing}"
+                  if options[:cached_for]
+                    Rails.cache.write([service, args].cache_key, [response, result], :expires_in => options[:cached_for])
+                  end
+                  log_response(timing, response.body, options)
+                  if result.is_a?(Hash) && result.has_key?("PCode")
+                    result = LVS::JsonService::Error.new(result["message"], result["PCode"], service, args, result)
+                  end
+                end
+                yield(result) if block_given?
+                return result
+              end
+            else
+              http_standard_request_with_timeout(service, args, options) do |response|
+                verify_request_id(response["X-LVS-Request-ID"], options[:request_id])
+                net_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+                start = Time.now
+                result = JSON.parse(response.body)
+                parse_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+                timing = "Net: #{net_timing}, Parse: #{parse_timing}"
+                if options[:cached_for]
+                  Rails.cache.write([service, args].cache_key, [response, result], :expires_in => options[:cached_for])
+                end
+                log_response(timing, response.body, options)
+                if result.is_a?(Hash) && result.has_key?("PCode")
+                  raise LVS::JsonService::Error.new(result["message"], result["PCode"], service, args, result)
+                end
+                yield(result) if block_given?
+                return result
+              end
             end
           else
-            start = Time.now
-            response = http_request_with_timeout(service, args, options)
-            verify_request_id(response, options[:request_id])
-            net_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
-            start = Time.now
-            result = JSON.parse(response.body)
-            parse_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
-            timing = "Net: #{net_timing}, Parse: #{parse_timing}"
+            log_response(timing, response.body, options)
+            if result.is_a?(Hash) && result.has_key?("PCode")
+              raise LVS::JsonService::Error.new(result["message"], result["PCode"], service, args, result)
+            end
           end
+          result
+        end
 
-          if response.body.size < 1024 || options[:debug]
-            LVS::JsonService::Logger.debug "Response (#{timing}): #{response.body.gsub(/\n/, '')}"
+        def log_response(timing, body, options)
+          if body.size < 1024 || options[:debug]
+            LVS::JsonService::Logger.debug "Response (#{timing}): #{body.gsub(/\n/, '')}"
           else
-            LVS::JsonService::Logger.debug "Response Snippet (#{timing} / #{"%.1f" % (response.body.size/1024)}kB): #{response.body.gsub(/\n/, '')[0..1024]}"
-          end
-          if result.is_a?(Hash) && result.has_key?("PCode")
-            raise LVS::JsonService::Error.new(result["message"], result["PCode"], service, args, result)
+            LVS::JsonService::Logger.debug "Response Snippet (#{timing} / #{"%.1f" % (body.size/1024)}kB): #{body.gsub(/\n/, '')[0..1024]}"
           end
-          result
         end
         
-        def verify_request_id(response, request_id)
-          returned_request_id = response["X-LVS-Request-ID"]
-          if returned_request_id != request_id && !returned_request_id.blank?
-            raise LVS::JsonService::RequestMismatchError.new("The sent Request ID (#{request_id}) didn't " + 
+        def verify_request_id(returned_request_id, sent_request_id)
+          if returned_request_id != sent_request_id && !returned_request_id.blank?
+            raise LVS::JsonService::RequestMismatchError.new("The sent Request ID (#{sent_request_id}) didn't " + 
               "match the returned Request ID (#{returned_request_id}) ")
           else
-            LVS::JsonService::Logger.debug "Sent and received Request ID - #{request_id}"
+            LVS::JsonService::Logger.debug "Sent and received Request ID - #{sent_request_id}"
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: LVS-JSONService
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors: 
 - LVS
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-06 00:00:00 +01:00
+date: 2010-01-19 00:00:00 +00:00
 default_executable: 
 dependencies: []