px-service-client 1.0.1

data/lib/px/service/client/list_response.rb

@@ -0,0 +1,80 @@
+require 'will_paginate/collection'
+
+module Px::Service::Client
+  ##
+  # This class implements the methods necessary to be compatible with WillPaginate and Enumerable
+  class ListResponse
+    include WillPaginate::CollectionMethods
+    include Enumerable
+
+    attr_reader :response, :per_page
+
+    DEFAULT_PER_PAGE = 20
+
+    def initialize(page_size, response, results_key, options = {})
+      @response = response
+      @results_key = results_key
+      @options = options
+      @per_page = page_size || DEFAULT_PER_PAGE
+    end
+
+    ##
+    # Get the current page
+    def current_page
+      response["current_page"]
+    end
+
+    def offset
+      (current_page - 1) * per_page
+    end
+
+    def total_entries
+      response["total_items"]
+    end
+    alias_method :total, :total_entries
+
+    def total_pages
+      response["total_pages"]
+    end
+
+    def results
+      response[@results_key]
+    end
+
+    def raw_results
+      response[@results_key]
+    end
+
+    ##
+    # Support Enumerable
+    def each(&block)
+      results.each(&block)
+    end
+
+    ##
+    # Allow comparisons with arrays e.g. in Rspec to succeed
+    def ==(other)
+      if other.class == self.class
+        other.results == self.results
+      elsif other.class <= Array
+        other == self.results
+      else
+        false
+      end
+    end
+    alias_method :eql?, :==
+
+    def empty?
+      results.empty?
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      results.send(method_name, *arguments, &block)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      results.respond_to?(method_name, include_private)
+    end
+
+  end
+end

data/lib/px/service/client/multiplexer.rb

@@ -0,0 +1,34 @@
+module Px::Service::Client
+  class Multiplexer
+    attr_accessor :hydra
+    attr_accessor :states
+
+    def initialize(params = {})
+      self.hydra = Typhoeus::Hydra.new(params)
+    end
+
+    def context
+      Fiber.new{ yield }.resume
+      self
+    end
+
+    ##
+    # Queue a request on the multiplexer, with retry
+    def do(request_or_future, retries: RetriableResponseFuture::DEFAULT_RETRIES)
+      response = request_or_future
+      if request_or_future.is_a?(Typhoeus::Request)
+        response = RetriableResponseFuture(request_or_future, retries: retries)
+      end
+
+      # Will automatically queue the request on the hydra
+      response.hydra = hydra
+      response
+    end
+
+    ##
+    # Start the multiplexer.
+    def run
+      hydra.run
+    end
+  end
+end

data/lib/px/service/client/retriable_response_future.rb

@@ -0,0 +1,98 @@
+# This is based on this code: https://github.com/bitherder/stitch
+
+require 'fiber'
+
+module Px::Service::Client
+  class RetriableResponseFuture < Future
+    DEFAULT_RETRIES = 3
+
+    attr_reader :hydra, :request
+
+    def initialize(request = nil, retries: DEFAULT_RETRIES)
+      super()
+
+      @retries = retries
+      self.request = request if request
+    end
+
+    def request=(request)
+      raise ArgumentError.new("A request has already been assigned") if @request
+
+      @request = request
+      self.request.on_complete do |response|
+        result = handle_error_statuses(response)
+        complete(result)
+      end
+
+      configure_auto_retry(request, @retries)
+
+      hydra.queue(request) if hydra
+    end
+
+    def hydra=(hydra)
+      raise ArgumentError.new("A hydra has already been assigned") if @hydra
+
+      @hydra = hydra
+      hydra.queue(request) if request
+    end
+
+    private
+
+    ##
+    # Raise appropriate exception on error statuses
+    def handle_error_statuses(response)
+      return response if response.success?
+
+      begin
+        body = parse_error_body(response)
+
+        if response.response_code >= 400 && response.response_code < 499
+          raise Px::Service::ServiceRequestError.new(body, response.response_code)
+        elsif response.response_code >= 500 || response.response_code == 0
+          raise Px::Service::ServiceError.new(body, response.response_code)
+        end
+      rescue Exception => ex
+        return ex
+      end
+    end
+
+    def parse_error_body(response)
+      if response.headers && response.headers["Content-Type"] =~ %r{application/json}
+        JSON.parse(response.body)["error"] rescue response.body.try(:strip)
+      else
+        response.body.strip
+      end
+    end
+
+
+    ##
+    # Configures auto-retry on the request
+    def configure_auto_retry(request, retries)
+      return if retries.nil? || retries == 0
+      # To do this, we have to hijack the Typhoeus callback list, as there's
+      # no way to prevent later callbacks from being executed from earlier callbacks
+      old_on_complete = request.on_complete.dup
+      request.on_complete.clear
+      retries_left = retries
+
+      request.on_complete do |response|
+        if !self.completed?
+          # Don't retry on success, client error, or after exhausting our retry count
+          if response.success? ||
+              response.response_code >= 400 && response.response_code <= 499 ||
+              retries_left <= 0
+
+            # Call the old callbacks
+            old_on_complete.map do |callback|
+              response.handled_response = callback.call(response)
+            end
+          else
+            # Retry
+            retries_left -= 1
+            hydra.queue(response.request)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/px/service/client/version.rb

@@ -0,0 +1,7 @@
+module Px
+  module Service
+    module Client
+      VERSION = "1.0.1"
+    end
+  end
+end

data/lib/px/service/client.rb

@@ -0,0 +1,19 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'px/service/errors'
+
+module Px
+  module Service
+    module Client
+    end
+  end
+end
+
+require "px/service/client/version"
+require "px/service/client/future"
+require "px/service/client/caching"
+require "px/service/client/circuit_breaker"
+require "px/service/client/list_response"
+require "px/service/client/base"
+require "px/service/client/multiplexer"
+require "px/service/client/retriable_response_future"

data/lib/px/service/errors.rb

@@ -0,0 +1,28 @@
+module Px
+  module Service
+    ##
+    # Any external service should have its exceptions inherit from this class
+    # so that controllers can handle them all nicely with "service is down" pages or whatnot
+    class ServiceBaseError < StandardError
+      attr_accessor :status
+
+      def initialize(message, status)
+        self.status = status
+        super(message)
+      end
+    end
+
+    ##
+    # Indicates something was wrong with the request (ie, not a service failure, but an error on the caller's
+    # part).  Corresponds to HTTP status 4xx responses
+    class ServiceRequestError < ServiceBaseError
+    end
+
+    ##
+    # Indicates something went wrong during request processing (a service or network error occurred)
+    # Corresponds to HTTP status 5xx responses.
+    # Services should catch other network/transport errors and raise this exception instead.
+    class ServiceError < ServiceBaseError
+    end
+  end
+end

data/lib/px-service-client.rb

@@ -0,0 +1 @@
+require 'px/service/client'

data/px-service-client.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'px/service/client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "px-service-client"
+  spec.version       = Px::Service::Client::VERSION
+  spec.summary       = %q{Common service client behaviours for Ruby applications}
+  spec.authors       = ["Chris Micacchi"]
+  spec.email         = ["chris@500px.com"]
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "will_paginate", "~> 3.0"
+  spec.add_dependency "dalli"
+  spec.add_dependency "typhoeus"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "circuit_breaker", "~> 1.1"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "vcr"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "timecop", "~> 0.5"
+end

data/spec/px/service/client/base_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Px::Service::Client::Base do
+  subject { Px::Service::Client::Base.send(:new) }
+  let(:response) do
+    Typhoeus::Response.new(
+      code: 200,
+      body: { status: 200, message: "Success"}.to_json,
+      headers: { "Content-Type" => "application/json"} )
+  end
+
+  describe '#make_request' do
+    let(:url) { 'http://localhost:3000/path' }
+
+    it "returns a future response" do
+      expect(subject.send(:make_request, 'get', url)).to be_a(Px::Service::Client::Future)
+    end
+
+    context "with a header" do
+      let(:expected_headers) {
+        {
+          "Cookie" => "_hpx1=cookie",
+        }
+      }
+
+      let(:resp) { subject.send(:make_request, 'get', url, headers: expected_headers) }
+      let(:headers) { resp.request.options[:headers] }
+
+      it "sets the expected header" do
+        expect(headers).to include(expected_headers)
+      end
+    end
+
+    context "with a query" do
+      let(:expected_query) {
+        {
+          "one" => "a",
+          "two" => "b",
+        }
+      }
+
+      let(:resp) { subject.send(:make_request, 'get', url, query: expected_query) }
+
+      it "sets the query" do
+        expect(resp.request.url).to include("one=a&two=b")
+      end
+    end
+  end
+end

data/spec/px/service/client/caching/caching_spec.rb

@@ -0,0 +1,209 @@
+require 'spec_helper'
+require 'dalli'
+
+describe Px::Service::Client::Caching do
+  subject {
+    Class.new.include(Px::Service::Client::Caching).tap do |c|
+      # Anonymous classes don't have a name.  Stub out :name so that things work
+      allow(c).to receive(:name).and_return("Caching")
+    end.new
+  }
+
+  let(:dalli_host) { "localhost:11211" }
+  let(:dalli_options) { { :namespace => "service-client-test", expires_in: 3600, compress: false, failover: false } }
+  let(:dalli) { Dalli::Client.new(dalli_host, dalli_options) }
+
+  before :each do
+    dalli.flush_all
+    subject.cache_client = dalli
+  end
+
+  let (:url) { "http://search/foo?bar=baz"}
+  let (:response) {
+    { "response" => ["foo", "bar"], "status" => 200 }
+  }
+
+  shared_examples_for "a successful request" do
+    it "should call the block" do
+      called = false
+      subject.cache_request(url, strategy: strategy) do |u|
+        expect(u).to eq(url)
+        called = true
+      end
+
+      expect(called).to be_truthy
+    end
+
+    it "should return the block's return value" do
+      expect(subject.cache_request(url, strategy: strategy) { response }).to eq(response)
+    end
+  end
+
+  shared_examples_for "a failed uncacheable request" do
+    it "should raise the exception raised by the block" do
+      expect{
+        subject.cache_request(url, strategy: strategy) do
+          # Px::Service::ServiceRequestError is not cachable
+          # and does not trigger a fallback to a cached response
+          raise Px::Service::ServiceRequestError.new("Error", 404)
+        end
+      }.to raise_error(Px::Service::ServiceRequestError)
+    end
+  end
+
+  shared_examples_for "a request with no cached response" do
+    it "raises the exception" do
+      expect {
+        subject.cache_request(url, strategy: strategy) do
+          raise Px::Service::ServiceError.new("Error", 500)
+        end
+      }.to raise_error(Px::Service::ServiceError)
+    end
+  end
+
+  context "when not caching" do
+    let(:strategy) { :none }
+
+    it_behaves_like "a successful request"
+    it_behaves_like "a failed uncacheable request"
+  end
+
+  context "when caching as a last resort" do
+    let(:strategy) { :last_resort }
+
+    it_behaves_like "a successful request"
+    it_behaves_like "a failed uncacheable request"
+
+    context "when there is a cached response" do
+      before :each do
+        subject.cache_request(url, strategy: strategy) do
+          response
+        end
+      end
+
+      it "returns the cached response on failure" do
+        expect(subject.cache_request(url, strategy: strategy) do
+          raise Px::Service::ServiceError.new("Error", 500)
+        end).to eq(response)
+      end
+
+      it "does not returns the cached response on request error" do
+        expect {
+          subject.cache_request(url, strategy: strategy) do
+            raise Px::Service::ServiceRequestError.new("Error", 404)
+          end
+        }.to raise_error(Px::Service::ServiceRequestError)
+      end
+
+      it "touches the cache entry on failure" do
+        expect(dalli).to receive(:touch).with(a_kind_of(String), a_kind_of(Fixnum))
+
+        subject.cache_request(url, strategy: strategy) do
+          raise Px::Service::ServiceError.new("Error", 500)
+        end
+      end
+    end
+
+    it_behaves_like "a request with no cached response"
+  end
+
+  context "when caching as a first resort" do
+    let(:strategy) { :first_resort }
+
+    it_behaves_like "a successful request"
+    it_behaves_like "a failed uncacheable request"
+
+    context "when there is a cached response" do
+      before :each do
+        subject.cache_request(url, strategy: strategy) do
+          response
+        end
+      end
+
+      it "does not invoke the block" do
+        called = false
+        subject.cache_request(url, strategy: strategy) do |u|
+          called = true
+        end
+
+        expect(called).to be_falsey
+      end
+
+      it "returns the response" do
+        expect(subject.cache_request(url, strategy: strategy) { nil }).to eq(response)
+      end
+    end
+
+    context "when there is an expired cached response" do
+      before :each do
+        Timecop.freeze(10.minutes.ago) do
+          subject.cache_request(url, strategy: strategy) do
+            response
+          end
+        end
+      end
+
+      let (:response) { { "value" => "response" } }
+
+      it "invokes the block" do
+        called = false
+        subject.cache_request(url, strategy: strategy) do |u|
+          called = true
+        end
+
+        expect(called).to be_truthy
+      end
+
+      it "returns the new response" do
+        expect(subject.cache_request(url, strategy: strategy) { response }).to eq(response)
+      end
+
+      it "updates the cache entry before making the request" do
+        subject.cache_request(url, strategy: strategy) do
+          # A bit goofy, but basically, make a request, but in the block
+          # check that another request that happens while we're in the block
+          # gets the cached result and doesn't invoke its own block
+          called = false
+          expect(subject.cache_request(url, strategy: strategy) do
+            called = true
+          end).to eq(response)
+          expect(called).to be_falsey
+
+          response
+        end
+      end
+
+      it "caches the new response" do
+        subject.cache_request(url, strategy: strategy) do
+          response
+        end
+
+        expect(subject.cache_request(url, strategy: strategy) { nil }).to eq(response)
+      end
+
+      it "returns the cached response on failure" do
+        expect(subject.cache_request(url, strategy: strategy) do
+          raise Px::Service::ServiceError.new("Error", 500)
+        end).to eq(response)
+      end
+
+      it "does not returns the cached response on request error" do
+        expect {
+          subject.cache_request(url, strategy: strategy) do
+            raise Px::Service::ServiceRequestError.new("Error", 404)
+          end
+        }.to raise_error(Px::Service::ServiceRequestError)
+      end
+
+      it "touches the cache entry on failure" do
+        expect(dalli).to receive(:touch).with(a_kind_of(String), a_kind_of(Fixnum)).twice
+
+        subject.cache_request(url, strategy: strategy) do
+          raise Px::Service::ServiceError.new("Error", 500)
+        end
+      end
+    end
+
+    it_behaves_like "a request with no cached response"
+  end
+end

data/spec/px/service/client/circuit_breaker_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Px::Service::Client::CircuitBreaker do
+
+  let(:subject_class) {
+    Class.new.include(Px::Service::Client::CircuitBreaker).tap do |c|
+      # Anonymous classes don't have a name.  Stub out :name so that things work
+      allow(c).to receive(:name).and_return("CircuitBreaker")
+    end
+  }
+
+  subject { subject_class.new }
+
+  describe '#included' do
+    it "excludes Px::Service::ServiceRequestError by default" do
+      expect(subject_class.circuit_handler.excluded_exceptions).to include(Px::Service::ServiceRequestError)
+    end
+
+    it "sets the failure threshold" do
+      expect(subject_class.circuit_handler.failure_threshold).to eq(5)
+    end
+
+    it "sets the failure timeout" do
+      expect(subject_class.circuit_handler.failure_timeout).to eq(7)
+    end
+
+    it "sets the invocation timeout" do
+      expect(subject_class.circuit_handler.invocation_timeout).to eq(5)
+    end
+  end
+
+  describe '#circuit_method' do
+    context "when the wrapped method succeeds" do
+      before :each do
+        subject_class.send(:define_method, :test_method) do |arg|
+          "returned #{arg}"
+        end
+
+        subject_class.circuit_method(:test_method)
+      end
+
+      it "returns the return value" do
+        expect(subject.test_method("test")).to eq("returned test")
+      end
+    end
+
+    context "when the wrapped method fails with a ServiceRequestError" do
+      before :each do
+        subject_class.send(:define_method, :test_method) do |arg|
+          raise Px::Service::ServiceRequestError.new("Error", 404)
+        end
+
+        subject_class.circuit_method(:test_method)
+      end
+
+      it "raises a ServiceRequestError" do
+        expect{
+          subject.test_method("test")
+        }.to raise_error(Px::Service::ServiceRequestError, "Error")
+      end
+    end
+
+    context "when the wrapped method fails with a ServiceError" do
+      before :each do
+        subject_class.send(:define_method, :test_method) do |arg|
+          raise Px::Service::ServiceError.new("Error", 500)
+        end
+
+        subject_class.circuit_method(:test_method)
+      end
+
+      it "raises a ServiceError" do
+        expect{
+          subject.test_method("test")
+        }.to raise_error(Px::Service::ServiceError, "Error")
+      end
+    end
+
+    context "when the wrapped method fails with another exception" do
+      before :each do
+        subject_class.send(:define_method, :test_method) do |arg|
+          this_is_not_a_method # Raises NoMethodError
+        end
+
+        subject_class.circuit_method(:test_method)
+      end
+
+      it "raises a ServiceError" do
+        expect{
+          subject.test_method("test")
+        }.to raise_error(Px::Service::ServiceError)
+      end
+    end
+
+    context "when the circuit is open" do
+      before :each do
+        subject_class.send(:define_method, :test_method) do |arg|
+          "should not be called"
+        end
+
+        subject_class.circuit_method(:test_method)
+
+        subject.circuit_state.trip
+      end
+
+      it "raises a ServiceError" do
+        expect{
+          subject.test_method("test")
+        }.to raise_error(Px::Service::ServiceError)
+      end
+    end
+  end
+end