json_api_resource_connecitons 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3f3f54916a89e9f3f079b32b656bd8a72a9de26
+  data.tar.gz: edc2bf3aa050e7a3324b81ba5e6697d6e16e68f1
+SHA512:
+  metadata.gz: 87bdc3c17a3811926b17c5a427b6b3096aa163622e6335d18144009cf0bbb6ba070533c1b08357f036afa4acd7420344448aec8cc11b2275e1a55357f3bb6afc
+  data.tar.gz: f4ab1b7b605044ba6bca452e4beb9bf0b9a3a3b4e60db36446f2c1658bfd9820b4abfbd47b2cf6f24d8d7ac9fca3293a594b70e4679b24b32a0a3773d5e1dfcb

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.1
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in json_api_resource_connecitons.gemspec
+gemspec
+
+gem 'rake'
+
+gem 'json_api_resource', path: "../json_api_resource"
+
+group :test do
+  gem 'simplecov'
+  gem 'minitest-stub_any_instance'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Greg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,80 @@
+# JsonApiResourceConnecitons
+
+Complex connection behaviour to sit on top of [JsonApiResource](http://github.com/avvo/json_api_resource) v2.0. This makes circuitbreaker connections default and enables cache flallbacks to when the server replies with anything other than a 404
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'json_api_resource_connecitons'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install json_api_resource_connecitons
+
+And it should auto magically inject itself into `JsonApiResource::Resource`
+
+## Usage
+
+### CacheProcessor
+
+Cache Processor is the component that handles caching. `CompressedCacheProcessor` caches results in two pieces: the actual object and the ids for the action. So your `Snack.search(q: "cheezbergher")` call will cache as 
+``` ruby
+'snack/search/q=>"cheezbergher"' => `[1, 2, 3, 4]`
+
+# and
+
+"snack/search/1" => {id: 1, ... }
+"snack/search/2" => {id: 2, ... }
+...
+```
+
+When no id is present in the response, the full response will be cached.
+
+#### Setup
+
+In your `config/json_api_resource.rb` you will need to set up the cache layer for the `CacheProcessor`
+
+```ruby
+module JsonApiResource
+
+  # set up the cache lawyer for the cache processor
+  module CacheProcessor
+    CompressedCacheProcessor.cache = Rails.cache # or whatever
+  end
+
+  # set up the processor for the connections
+  module Connections
+    CachedCircuitbreakerServerConnection.cache_processor = JsonApiResource::CacheProcessor::CompressedCacheProcessor
+    CacheConnection.cache_processor = JsonApiResource::CacheConnection::CompressedCacheProcessor
+  end
+end
+```
+
+### Connections
+
+The default connection is the `CachedCircuitbreakerServerConnection`. It will prevent any more calls to the server if any non-404 error is returned for 30 seconds. If you assign cache_processor, the cache part will kick in and cache the results returnrd from the server. 
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/json_api_resource_connecitons.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,12 @@
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "json_api_resource_connecitons"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/json_api_resource_connecitons.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'json_api_resource_connecitons/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "json_api_resource_connecitons"
+  spec.version       = JsonApiResourceConnecitons::VERSION
+  spec.authors       = ["Greg"]
+  spec.email         = ["greg@avvo.com"]
+
+  spec.summary       = "circuit breaker and cache fallback connections for json api resource v2"
+  spec.description   = "circuit breaker and cache fallback connections for json api resource v2"
+  spec.homepage      = "https://github.com/avvo/json_api_resource_connections"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+  spec.add_dependency "json_api_resource"
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/lib/json_api_resource/cache_processor.rb

@@ -0,0 +1,6 @@
+module JsonApiResource
+  module CacheProcessor
+    autoload :Base,                     'json_api_resource/cache_processor/base'
+    autoload :CompressedCacheProcessor, 'json_api_resource/cache_processor/compressed_cache_processor'
+  end
+end

data/lib/json_api_resource/cache_processor/base.rb

@@ -0,0 +1,16 @@
+module JsonApiResource
+  module CacheProcessor
+    class Base
+
+      class << self 
+        def write( result, client, action, *args )
+          result
+        end
+
+        def read( client, action, *args )
+          []
+        end
+      end
+    end
+  end
+end

data/lib/json_api_resource/cache_processor/compressed_cache_processor.rb

@@ -0,0 +1,85 @@
+module JsonApiResource
+  module CacheProcessor
+    class CompressedCacheProcessor < Base
+      
+      class_attribute :cache
+
+      class << self
+
+        def write(result, client, action, *args)
+          result_set = Array(result)
+
+          key = cache_key(client, action, *args)
+          
+          # result set has ids and we can break the set down into an array of ids and the objects
+          if splitable?(result_set)
+            
+            write_ids(key, result_set)
+            
+            write_objects(client, action, result_set)
+
+          else
+            cache.write key, result_set
+          end
+
+          result
+        end
+
+        def read(client, action, *args)
+          key = cache_key(client, action, *args)
+          set = cache.read key
+
+          # set can be an array of blobs or an array of ids
+          set.map do |item|
+            # if the results are ids
+            if item.is_a? Integer
+              # grab the actual object from cache
+              key = item_cache_key(client, action, item)
+              cache.read key
+            # if they are not ids
+            else
+              # they have to be the full objects. return them
+              item
+            end
+          end
+        end
+
+        private 
+
+        def cache_key(client, action, *args)
+          # this can come in as a class or as an instance
+          #                                       class    |     instance
+          class_string = client.is_a?(Class) ? client.to_s : client.class.to_s
+          class_string = class_string.underscore
+          args = args.present? ? ordered_args(*args) : nil
+          "#{class_string}/#{action}/#{args}"
+        end
+
+        def item_cache_key(client, action, id)
+          "#{cache_key(client, action)}id:#{id}"
+        end
+
+        def ordered_args(*args)
+          args.map do |arg|
+            arg.is_a?(Hash) ? arg.sort.to_h : arg
+          end.sort
+        end
+
+        def splitable?(result_set)
+          result_set.select{|_| _["id"]}.present?
+        end
+
+        def write_ids(key, result_set)
+          cache.write key, result_set.map{|_| _["id"]}
+        end
+
+        def write_objects(client, action, result_set)
+          result_set.each do |item|
+            key = item_cache_key client, action, item["id"]
+            cache.write key, item
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_api_resource/connections.rb

@@ -0,0 +1,7 @@
+module JsonApiResource
+  module Connections
+    autoload :CacheConnection,                        'json_api_resource/connections/cache_connection'
+    autoload :CachedCircuitbreakerServerConnection,   'json_api_resource/connections/cached_circuitbreaker_server_connection'
+    autoload :ServerNotReadyError,                    'json_api_resource/connections/server_not_ready_error'
+  end
+end

data/lib/json_api_resource/connections/cache_connection.rb

@@ -0,0 +1,23 @@
+module JsonApiResource
+  module Connections
+    class CacheConnection < Multiconnect::Connection::Base
+
+      class_attribute :cache_processor
+      class_attribute :error_notifier
+            
+      self.cache_processor = ::JsonApiResource::CacheProcessor::Base
+      
+      class << self
+        attr_accessor :cache
+      end
+
+      def report_error( e )
+        error_notifier.notify( self, e ) if error_notifier.present?
+      end
+
+      def request( action, *args )
+        cache_processor.read client, action, *args
+      end
+    end
+  end
+end

data/lib/json_api_resource/connections/cached_circuitbreaker_server_connection.rb

@@ -0,0 +1,82 @@
+module JsonApiResource
+  module Connections
+    class CachedCircuitbreakerServerConnection < Multiconnect::Connection::Base
+
+      class_attribute :cache_processor
+      class_attribute :error_notifier
+
+      self.cache_processor = ::JsonApiResource::CacheProcessor::Base
+
+      def initialize(options)
+        super options
+        @caching            = options.fetch :caching, true
+        @timeout            = Time.now
+      end
+
+      def report_error( e )
+        unless e.is_a? ServerNotReadyError
+          error_notifier.notify( self, e ) if error_notifier.present?
+        end
+      end
+
+      def request( action, *args )
+        if ready_for_request?
+          
+          result = client_request(action, *args)
+
+          cache_processor.write(result, client, action, *args) if cache?
+
+          result
+
+        else
+          raise ServerNotReadyError
+        end
+
+      rescue JsonApiClient::Errors::NotFound => e
+        empty_set_with_errors e
+      rescue => e
+        @timeout = timeout
+
+        # propagate the error up to be handled by Connection::Base
+        raise e
+      end
+
+      def empty_set_with_errors( e )
+        result = JsonApiClient::ResultSet.new
+
+        result.meta = {status: 404}
+
+        result.errors = ActiveModel::Errors.new(result)
+        result.errors.add("RecordNotFound", e.message)
+
+        result
+      end
+
+      private
+
+      def timeout
+        # default circuit broken for 30 seconds. 
+        # This should probably be 1 - 2 - 5 - 15 - 30 - 1 min *
+        Time.now + 30.seconds
+      end
+
+      def ready_for_request?
+        Time.now > @timeout
+      end
+
+      def cache?
+        @caching
+      end
+
+      def client_request(action, *args)
+        result = self.client.send action, *args
+
+        if result.is_a? JsonApiClient::Scope
+          result = result.all
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/json_api_resource/connections/server_not_ready_error.rb

@@ -0,0 +1,7 @@
+module JsonApiResource
+  module Connections
+    class ServerNotReadyError < StandardError
+
+    end
+  end
+end

data/lib/json_api_resource_connecitons.rb

@@ -0,0 +1,42 @@
+require 'active_support'
+require 'active_support/callbacks'
+require 'active_support/concern'
+require 'active_support/core_ext/module'
+require 'active_support/core_ext/class/attribute'
+require 'json_api_resource'
+require "json_api_resource_connecitons/version"
+
+module JsonApiResourceConnections
+  require 'json_api_resource/connections'
+  require 'json_api_resource/cache_processor'
+
+  extend ActiveSupport::Concern
+
+  included do
+
+    include Multiconnect::Connectable
+
+    class << self
+      class_attribute :_fallbacks
+      self._fallbacks = []
+
+      def cache_fallback(*actions)
+        self._fallbacks = _fallbacks + Array(actions)
+        add_connection JsonApiResource::Connections::CacheConnection, client: self.client_class, only: self._fallbacks
+      end
+
+      def wraps(client)
+        self.client_class = client
+
+        # now that we know where to connect to, let's do it
+        add_connection JsonApiResource::Connections::CachedCircuitbreakerServerConnection, client: self.client_class
+      end
+    end
+
+    def connection
+      @connection ||= JsonApiResource::Connections::CachedCircuitbreakerServerConnection.new( client: self.client, caching: false )
+    end
+  end
+end
+
+JsonApiResource::Resource.send :include, JsonApiResourceConnections

data/lib/json_api_resource_connecitons/version.rb

@@ -0,0 +1,3 @@
+module JsonApiResourceConnecitons
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: json_api_resource_connecitons
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Greg
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json_api_resource
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: circuit breaker and cache fallback connections for json api resource
+  v2
+email:
+- greg@avvo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- json_api_resource_connecitons.gemspec
+- lib/json_api_resource/cache_processor.rb
+- lib/json_api_resource/cache_processor/base.rb
+- lib/json_api_resource/cache_processor/compressed_cache_processor.rb
+- lib/json_api_resource/connections.rb
+- lib/json_api_resource/connections/cache_connection.rb
+- lib/json_api_resource/connections/cached_circuitbreaker_server_connection.rb
+- lib/json_api_resource/connections/server_not_ready_error.rb
+- lib/json_api_resource_connecitons.rb
+- lib/json_api_resource_connecitons/version.rb
+homepage: https://github.com/avvo/json_api_resource_connections
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: circuit breaker and cache fallback connections for json api resource v2
+test_files: []