LVS-JSONService 0.2.0 → 0.2.1

data/.gitignore

@@ -1,4 +1,5 @@
 .DS_Store
 coverage/
 spec/reports
-pkg/
+pkg/
+JSONService-*.gem

data/.specification

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

data/JSONService.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{JSONService}
-  s.version = "0.2.0"
+  s.version = "0.2.1"
 
   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.date = %q{2009-06-19}
   s.email = %q{info@lvs.co.uk}
   s.extra_rdoc_files = [
     "LICENSE",

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/lib/lvs/json_service/base.rb

@@ -7,130 +7,129 @@ module LVS
     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
+      class << self
+        @site = ""
+        @services = []
+        @service_prefix = ""
+        @field_prefix = ""
+        @encrypted = false
+        @auth_cert = ""
+        @auth_key = ""
+        @auth_key_pass = ""
+
+        def encrypted=(value)
+          @encrypted = value
+        end
+        
+        def auth_cert=(value)
+          @auth_cert = value
+        end
+        
+        def auth_key=(value)
+          @auth_key = value
+        end
+        
+        def auth_key_pass=(value)
+          @auth_key_pass = value
         end
-      end
 
-      def self.define_service(name, service, options = {})
-        service_name = name
+        def agp_location=(value)
+          @agp_location = value
+        end
+            
+        def add_service(service)
+          @services ||= []
+          @services = @services << service
+        end
+        
+        def service_prefix=(value)
+          @service_prefix = value
+        end
+        
+        def field_prefix=(value)
+          @field_prefix = value
+        end
+        
+        def site=(value)
+          # value is containing AGP_LOCATION already sometimes:
+          value.gsub!(/^#{AGP_LOCATION}/, '') if AGP_LOCATION && value.match(/#{AGP_LOCATION}/)
+          agp = @agp_location ? @agp_location : AGP_LOCATION
+          agp.gsub!(/\/$/, '')
+          value.gsub!(/^\//, '')
+          @site = (agp + '/' + value)
+        end
 
-        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('.') + '.'
+        def debug(message)
+          LVS::JsonService::Logger.debug " \033[1;4;32mLVS::JsonService\033[0m #{message}"
         end
 
-        if options[:cached]
-          service_name = "call_#{name}"
-          self.define_cached_service(name, service, options)
+        def require_ssl?
+          (Module.const_defined?(:SSL_ENABLED) && SSL_ENABLED) || (Module.const_defined?(:SSL_DISABLED) && !SSL_DISABLED)
         end
 
-        (class<<self;self;end).send :define_method, service_name do |args|
-          method_params, flags = args
+        def define_service(name, service, options = {})
+          service_name = name
 
-          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
+          service_path = service.split('.')
+          if service_path.size <= 2
+            internal_service = service
+            prefix = @service_prefix
           else
-            self.parse_result(result)
+            internal_service = service_path[-2..-1].join('.')
+            prefix = service_path[0..-3].join('.') + '.'
           end
-        end
 
-        @@services << name
-      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
+          
+          (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
 
-      def self.fake_service(name, json)
-        (class<<self;self;end).send :define_method, name do |*args|
-          self.parse_result(JSON.parse(json))
+          add_service(name)
         end
-        @@services << name
-      end
 
-      def self.services
-        @@services
-      end
+        def fake_service(name, json)
+          (class<<self;self;end).send :define_method, name do |*args|
+            self.parse_result(JSON.parse(json))
+          end
+          add_service(name)
+        end
 
-      def self.parse_result(response)
-        if response.is_a?(Array)
-          response.map { |x| self.new(x) }
-        else
-          self.new(response)
+        def services
+          @services
+        end
+
+        def parse_result(response)
+          if response.is_a?(Array)
+            response.map { |x| self.new(x) }
+          else
+            self.new(response)
+          end
         end
+        
       end
 
       def initialize(values = {})

data/lib/lvs/json_service/logger.rb

@@ -2,9 +2,8 @@ module LVS
   module JsonService
     module Logger
       def self.debug(message)
-        if const_defined?(:RAILS_DEFAULT_LOGGER)
-          RAILS_DEFAULT_LOGGER.debug(message)
-        end
+        message = "  \033[1;4;32mLVS::JsonService\033[0m #{message}"
+        Rails.logger.debug(message)
       end
     end
   end

data/lib/lvs/json_service/request.rb

@@ -17,9 +17,14 @@ module LVS
 
           http = Net::HTTP.new(uri.host, uri.port)
         
-          if options[:encrypted] && !SSL_DISABLED
+          http = Net::HTTP.new(uri.host, uri.port)
+          if options[:encrypted] || require_ssl?
             http.use_ssl = true
+            # Self-signed certs give streams of "warning: peer certificate won't be verified in this SSL session"
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE 
+            LVS::JsonService::Logger.debug "Using SSL"
             if options[:auth_cert]
+              LVS::JsonService::Logger.debug "Using Auth"
               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
@@ -37,7 +42,7 @@ module LVS
             retries -= 1          
             response = http.start { |connection| connection.request(req) }
           
-          rescue Timeout::Error
+          rescue Timeout::Error => e
             if retries >= 0
               LVS::JsonService::Logger.debug(
                 "Retrying #{service} due to TimeoutError"
@@ -46,7 +51,7 @@ module LVS
             end
             raise LVS::JsonService::TimeoutError.new("Backend failed to respond in time", 500, service, args)
                     
-          rescue Errno::ECONNREFUSED
+          rescue Errno::ECONNREFUSED => e
             if retries >= 0
               LVS::JsonService::Logger.debug(
                 "Retrying #{service} due to Errno::ECONNREFUSED"
@@ -55,6 +60,10 @@ module LVS
               retry
             end
             raise LVS::JsonService::BackendUnavailableError.new("Backend unavailable", 500, service, args)
+            
+          rescue OpenSSL::SSL::SSLError => e
+            raise LVS::JsonService::BackendUnavailableError.new("Backend unavailable #{e}", 500, service, args)
+            
           end
 
           if response.is_a?(Net::HTTPNotFound)
@@ -65,12 +74,26 @@ module LVS
         end
 
         def 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)
+          LVS::JsonService::Logger.debug "Requesting '#{service}' with #{args.to_json}"
+          
+          if options[:cached_for]
+            timing = "CACHED"
+            response = Rails.cache.fetch([service, args].cache_key, :expires_in => options[:cached_for]) do
+              start = Time.now
+              response = http_request_with_timeout(service, args, options)
+              timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+              response
+            end
+          else
+            start = Time.now
+            response = http_request_with_timeout(service, args, options)
+            timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+          end
+          
           if response.body.size < 1024
-            LVS::JsonService::Logger.debug "Response: #{response.body.gsub(/\n/, '')}"
+            LVS::JsonService::Logger.debug "Response (#{timing}): #{response.body.gsub(/\n/, '')}"
           else
-            LVS::JsonService::Logger.debug "Response Snippet: #{response.body.gsub(/\n/, '')[0..1024]}"
+            LVS::JsonService::Logger.debug "Response Snippet (#{timing}): #{response.body.gsub(/\n/, '')[0..1024]}"
           end
           result = JSON.parse(response.body)
           if result.is_a?(Hash) && result.has_key?("PCode")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: LVS-JSONService
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - LVS
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-18 00:00:00 -07:00
+date: 2009-06-19 00:00:00 -07:00
 default_executable: 
 dependencies: []